feat(848-3): 제어 구역 층 색 · 「고침」 글 걷음 · 기계 한 줄 되돌림 · M01 기초 제어 구역 엶 · 기초 [초기화] · 알림 지킴 줄 [위 값으로]

- 셈 · 산출근거 · 제어 구역 = layeredCover(문서, 위덮음) · 기본 = upperOf · putCover(…, ①) · 칸 테두리 = sourcesOf(나 파랑 · 위 주황)
- 작업량 묶음 = mergeWork(①, ②) · ① 과 다른 칸만(pruneWorkLayer) · 위 층 시간당이면 일당 = 내 고침
- 기계 줄 머리 = 이름 단추 테두리 + [원래 값](그 기계 고침 통째) · 기계 보기 저장 안 한 바뀜 = 파랑
- M01 단가산출 기초 = 시스템 관리자에게 제어 구역 엶 · 머리 [초기화] = 기계 고침 목록 확인 → 걷고 저장
- 갱신 알림 = 지킴 줄 따로 표(위 값 전 → 후 · 내 값 · [위 값으로] = 그 칸 고침 지움 → [저장]) · 다시복사 · 지워짐 = 지금 꼴
- 걷기 셈 = common_util_formula_doc_cover_drop.ts(dropCover · dropPath) · 시험 test_848_3_cover_drop

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
2026-11-16 20:29:20 +09:00
co-authored by Claude Opus 5.5
parent bfe27d0ad7
commit 64972fcaec
12 changed files with 463 additions and 86 deletions
+100 -16
View File
@@ -4,9 +4,12 @@
* M01 에서 바뀐 항목에 얹힌 내 고침을 지우고 다시 복사한 것을 한 번 보임(서버 `M02_Sk_AutoRenew.notes`)
* 표 = 항목 · M01 전 → 후 · 지워진 내 고침 · [확인] = 저장(다시 안 뜸) · [나중에] = 다음에 열면 또 뜸
* 고침 없는 항목은 조용히 따라옴(알림 없음)
* 848-3(요구 889 · 이음 848-2) — 처리 「지킴」 줄 = 따로 표: 항목 · 위 값 전 → 후 · 내 값(지킴) · [위 값으로]
* [위 값으로] = 그 칸의 내 고침을 지움(부르는 쪽 `back` · 캐시 → [저장]) · 「다시복사」 · 「지워짐」 · 옛 꼴 = 위 표 그대로
* ========================================================================== */
import { askConfirm, el } from "@ui/ui_template_elements";
import { askConfirm, createButton, el } from "@ui/ui_template_elements";
import { eqText } from "@ui/ui_template_equation";
import { createTable } from "@ui/ui_template_table";
import { ft } from "./formula_doc_text";
@@ -17,29 +20,110 @@ export interface RenewNote {
갈래?: string;
M01?: string[];
내고침?: string[];
/** 848-2 — 지킴 · 다시복사 · 지워짐(없음 = 옛 꼴) */
처리?: string;
/** 지킴 — 기계덮음 열쇠 · 칸 경로(`값.<칸>` · 조종원 · 잡품 · `작업량.*`) · 보일 이름 · 위 층 전 · 후 · 내 값 */
열쇠?: string;
경로?: string;
칸?: string;
층?: string;
전?: unknown;
후?: unknown;
내값?: unknown;
/** 다시복사 · 지워짐 — 다시 얹은 고침 */
다시얹음?: string[];
}
export const KEPT = "지킴";
/** 칸 안 여러 줄 — 줄마다 한 덩이 */
const lines = (xs: string[] | undefined): HTMLElement =>
el("div", { children: (xs ?? []).map((t) => el("div", { text: t })) });
/** 알림 창 — 확인이면 true(부르는 쪽이 저장) */
export function askRenew(notes: RenewNote[]): Promise<boolean> {
const table = createTable(
[
{ label: ft("Renew_Item"), width: "28%" },
{ label: ft("Renew_M01") },
{ label: ft("Renew_Mine") },
],
notes.map((n) => [lines([n.이름 || n.키, n.키]), lines(n.M01), lines(n.내고침)]),
{ density: "data" },
);
table.dataset.renewNotes = String(notes.length);
return askConfirm({
/** 값 글 — 수 · 글 · 줄 목록(인력 · 잡품 = 이름 수량) */
export function noteValue(v: unknown): string {
if (v === undefined || v === null || v === "") return "—";
if (typeof v === "number") return eqText(v);
if (Array.isArray(v))
return v
.map((r) => {
if (!r || typeof r !== "object") return String(r);
const x = r as Record<string, unknown>;
const qty = x.인 ?? x.수량;
return [x.이름 ?? x.키 ?? x.줄, qty === undefined ? "" : noteValue(qty), x.율 === undefined ? "" : `${noteValue(x.율)}%`] // prettier-ignore
.filter((t) => t !== "" && t !== undefined)
.join(" ");
})
.join(", ");
return typeof v === "object" ? JSON.stringify(v) : String(v);
}
/** 알림 창 — 확인이면 true(부르는 쪽이 저장) · `back` = 지킴 줄 [위 값으로](누른 줄을 닫을 때 한 번에) */
export async function askRenew(
notes: RenewNote[],
back?: (picked: RenewNote[]) => void,
): Promise<boolean> {
const kept = notes.filter((n) => n.처리 === KEPT && n.열쇠 && n.경로);
const rest = notes.filter((n) => !kept.includes(n));
const picked: RenewNote[] = [];
const parts: HTMLElement[] = [];
if (kept.length) {
const table = createTable(
[
{ label: ft("Renew_Item"), width: "28%" },
{ label: ft("Renew_Upper") },
{ label: ft("Renew_Kept") },
{ label: "", width: "96px" },
],
kept.map((n) => {
const b = createButton({
label: ft("Renew_Back"),
variant: "ghost",
size: 24,
iconStart: "undo",
onClick: () => {
picked.push(n);
b.disabled = true;
b.setAttribute("aria-pressed", "true");
},
});
b.dataset.renewBack = `${n.열쇠}|${n.경로}`;
return [
lines([n.이름 || n.키, n.칸 || n.경로 || ""]),
`${noteValue(n.전)} → ${noteValue(n.후)}`,
noteValue(n.내값),
...(back ? [b] : [""]),
];
}),
{ density: "data" },
);
table.dataset.renewKept = String(kept.length);
parts.push(table);
}
if (rest.length) {
const table = createTable(
[
{ label: ft("Renew_Item"), width: "28%" },
{ label: ft("Renew_M01") },
{ label: ft("Renew_Mine") },
],
rest.map((n) => [
lines([n.이름 || n.키, n.키]),
lines(n.M01),
lines([...(n.내고침 ?? []), ...(n.다시얹음 ?? []).map((t) => `↻ ${t}`)]),
]),
{ density: "data" },
);
table.dataset.renewNotes = String(rest.length);
parts.push(table);
}
const ok = await askConfirm({
title: ft("Renew_Title"),
message: ft("Renew_Ask"),
message: ft(kept.length ? "Renew_Ask_Kept" : "Renew_Ask"),
okLabel: ft("Renew_Ok"),
cancelLabel: ft("Renew_Later"),
detail: table,
detail: parts.length === 1 ? parts[0] : el("div", { children: parts }),
});
if (picked.length) back?.(picked);
return ok;
}
+17
View File
@@ -84,6 +84,13 @@ const TEXT = {
"M01 에서 바뀐 항목에 있던 내 고침을 지우고 M01 에서 다시 복사함 — [확인] 하면 저장(다시 안 뜸)",
"Your edits on items changed in M01 were removed and re-copied — OK saves (no repeat)",
],
Renew_Ask_Kept: [
"위 층(M01 · 기초)에서 값이 바뀜 — 내가 고친 칸은 내 값을 지킴 · [위 값으로] = 그 칸이 위 값을 따름([저장] 해야 반영) · [확인] 하면 다시 안 뜸",
"Upper values changed — your edited cells keep your values · [Use upper] follows the upper value (on [Save]) · OK hides this",
],
Renew_Upper: ["위 값 전 → 후", "Upper before → after"],
Renew_Kept: ["내 값(지킴)", "My value (kept)"],
Renew_Back: ["위 값으로", "Use upper"],
Renew_Item: ["항목", "Item"],
Renew_M01: ["M01 전 → 후", "M01 before → after"],
Renew_Mine: ["지워진 내 고침", "Removed edits"],
@@ -96,6 +103,16 @@ const TEXT = {
"Save or discard edits first",
],
Read_Only: ["읽기만", "Read only"],
Reset_Base: ["초기화", "Reset"],
Reset_Base_Tip: [
"이 기초의 기계 고침을 모두 걷어 기계 정본 · 품셈 기본과 같게",
"Clear all machine edits of this base to match the machine master",
],
Reset_Base_Ask: [
"기계 고침 {n} 개를 걷어 기계 정본 · 품셈 기본과 같게 하고 저장",
"Clear {n} machine edit(s) to match the machine master and save",
],
Reset_Base_Done: ["초기화했음", "Reset done"],
Tools: ["수식 도구", "Equation tools"],
Tool_Frac: ["분수", "Fraction"],
Tool_Sub: ["아래첨자", "Subscript"],
+29 -9
View File
@@ -11,7 +11,7 @@
* ========================================================================== */
import { createBadge } from "@ui/ui_template_badge";
import { createButton, createIconButton } from "@ui/ui_template_button";
import { createButton, createIconButton, setUiDiff } from "@ui/ui_template_button";
import { createRowMenu } from "@ui/ui_template_context_menu";
import { eqText } from "@ui/ui_template_equation";
import { el, showToast } from "@ui/ui_template_elements";
@@ -20,7 +20,12 @@ import { varId, type FormulaDoc, type MoneyLine } from "../common_util/common_ut
import { isNum, type DocAnswer } from "../common_util/common_util_formula_doc_calc";
import { lineMap, offLine, type Values } from "../common_util/common_util_formula_doc_view";
import type { DocTable } from "../common_util/common_util_formula_doc_table";
import { coverOf, type CoverEntry } from "../common_util/common_util_formula_doc_cover";
import {
coverOf,
layeredCover,
type Cover,
type CoverEntry,
} from "../common_util/common_util_formula_doc_cover";
import { HOURLY, Q_NEW, swap, workKey } from "../common_util/common_util_formula_doc_work";
import { workAt } from "../common_util/common_util_line_stack_work";
import { machineText } from "./formula_doc_options";
@@ -56,6 +61,7 @@ import { hiddenByWork, reach } from "./formula_doc_render";
import { attachDrag } from "./line_stack_drag";
import type { WorkSpec } from "../common_util/common_util_formula_doc_work";
import { openMachineWindow, type MachineCtx } from "./line_stack_machine";
import { dropCover } from "../common_util/common_util_formula_doc_cover_drop";
import { buildMachineCtl, lineCall } from "./line_stack_machine_ctl";
import { putWork, swapMachine } from "./line_stack_machine_work";
import { openStackPick, type StackTake } from "./line_stack_pick";
@@ -89,6 +95,10 @@ export interface EditHooks {
look?: TableLook;
/** 846-2 그 기계 작업량 줄 */
work?: (machine: string) => WorkSpec[];
/** 848-3 ① 위 층 고침(SK 읽기 답 `위덮음` · M01 = 없음) */
upper?: Cover | null;
/** 848-3 M01 기초 제어 구역 엶(시스템 관리자) — M02 = 층(`machine.scope`)이 엶 */
ctlEdit?: boolean;
}
const field = (
@@ -188,12 +198,14 @@ function moneyBody(h: EditHooks, i: number): HTMLElement[] {
if (kind === "재료") void askFileWide(h.machine, d, own, p); // 827-3 같은 파일 같은 재료
};
// 847-1 시간당 식 줄 = 굳은 기계를 덮음으로 바꿈(문서 줄 연결은 그대로 — 일당으로 되돌리면 옵션 기계)
const wkey = w ? workKey(coverOf(d), w) : "";
const want = hourly ? (coverOf(d)[wkey] as CoverEntry | undefined)?.작업량 : undefined;
const lay = layeredCover(d, h.upper); // 848-3 ① 위에 ②
const wkey = w ? workKey(lay, w) : "";
const want = hourly ? (lay[wkey] as CoverEntry | undefined)?.작업량 : undefined;
const upWork = (h.upper?.[wkey] as CoverEntry | undefined)?.작업량 ?? null;
const fixed = hourly && w?.고정 ? w.고정 : "";
const swapFixed = (p: Picked): void => {
const got = swapMachine(want ?? { 방식: HOURLY }, w!, p, p.키 === link.키, h.work?.(fixed) ?? []); // prettier-ignore
h.change((doc) => putWork(doc, wkey, got.next));
h.change((doc) => putWork(doc, wkey, got.next, upWork));
if (got.note) showToast(got.note, "info");
};
const label = fixed
@@ -237,9 +249,17 @@ function moneyBody(h: EditHooks, i: number): HTMLElement[] {
});
t.dataset.mctlToggle = String(i);
head.push(t);
const m = lineCall(d, h.answer, link, i);
if (coverOf(d)[m.work] || coverOf(d)[String(m.given.기계 ?? "")])
head.push(createBadge(lt("Ctl_Changed"), "info", { size: 18 }));
// 848-3 고친 기계 = 이름 단추 테두리(나 = 파랑 · 위 층 = 주황) · ㉢ 기계 한 줄 통째 [원래 값]
const m = lineCall(d, h.answer, link, i, h.upper);
const keys = [...new Set([m.work, String(m.given.기계 ?? "")])].filter(Boolean);
const mine = keys.some((k) => coverOf(d)[k]);
setUiDiff(pick, mine ? "mine" : keys.some((k) => h.upper?.[k]) ? "upper" : null);
if (mine && (h.machine?.scope || h.ctlEdit)) {
const back = createButton({ label: lt("Ctl_Back"), variant: "ghost", size: 24, iconStart: "undo", onClick: () => h.change((doc) => dropCover(doc, keys)) }); // prettier-ignore
back.title = lt("Ctl_Line_Back");
back.dataset.mctlLineBack = String(i);
head.push(back);
}
}
const mark = machineMark(found, link);
if (mark) head.push(mark);
@@ -551,7 +571,7 @@ export function buildEdit(h: EditHooks): HTMLElement {
if (line.꼴 === "금액" && h.calc && h.open.has(`mctl:${line.i}`)) {
const own = ownedOf(h.doc).get(line.i);
const zone = buildMachineCtl(
{ ...h, calc: h.calc, change: (fn) => h.change((d) => fn(d)), readOnly: !h.machine?.scope }, // prettier-ignore
{ ...h, calc: h.calc, change: (fn) => h.change((d) => fn(d)), readOnly: !(h.machine?.scope || h.ctlEdit) }, // prettier-ignore
h.doc.변수?.find((x) => varId(x) === own)?.연결,
line.i,
);
+47 -17
View File
@@ -11,10 +11,12 @@
* 읽기(M01 기초) = 칸 잠김 · 단추 없음
* 기계 보기(840-2 `line_stack_machine_sheet` · M01 기계 상세 · 내 기계) = 같은 구역(인력 · 잡품 여러 줄 · 842-3) ·
* `lock` = 잠긴 값 칸(품셈 방식 계수 등)
* 층(848-3 · 요구 889) — SK = ① 위 층 고침(`upper` = 읽기 답 `위덮음`) 위에 ② 내 고침 · 기본(원래 값) = `upperOf(정본 기본, ①)` ·
* 고침 = `putCover(…, ①)`(위 층과 같은 칸 지움) · 칸 테두리 = 출처(`sourcesOf` — 나 = 파랑 · 위 = 주황 · 부품 `setUiDiff`) ·
* 「고침」 글 배지 없음(테두리로) · 칸 풍선 = 원래 값 · M01 기초(시스템 관리자) = ① 없음 → 기초 고침 = 「나」
* ========================================================================== */
import { createBadge } from "@ui/ui_template_badge";
import { createButton, createIconButton } from "@ui/ui_template_button";
import { createButton, createIconButton, setUiDiff, type UiDiff } from "@ui/ui_template_button";
import { eqText } from "@ui/ui_template_equation";
import { el, showToast } from "@ui/ui_template_elements";
import { createInputField, createSelectField } from "@ui/ui_template_input";
@@ -24,13 +26,19 @@ import type { DocAnswer } from "../common_util/common_util_formula_doc_calc";
import {
coverOf,
defaultsOf,
layeredCover,
machineKey,
MINE,
partsOf,
putCover,
rowEntry,
sourcesOf,
upperOf,
type Cover,
type CrewRow,
type CoverEntry,
type MiscRow,
type Source,
} from "../common_util/common_util_formula_doc_cover";
import { subInputs, type StackDoc } from "../common_util/common_util_line_stack";
import type { Picked } from "../common_util/common_util_line_stack_pick";
@@ -59,6 +67,22 @@ export interface CtlHooks {
lock?: string[];
/** 846-2 그 기계 작업량 줄(기계 값 칸 `작업량`) */
work?: (machine: string) => WorkSpec[];
/** 848-3 ① 위 층 고침(SK 읽기 답 `위덮음` · M01 = 없음) */
upper?: Cover | null;
}
/** 출처 → 부품 「바뀜」 상태(848-3) */
export const diffOf = (src: Source | undefined): UiDiff | null =>
src === undefined ? null : src === MINE ? "mine" : "upper";
/** 칸 묶음 안 입력 · 고르기 · 이름 단추에 「바뀜」 상태 · 풍선(원래 값) */
export function markDiff(box: HTMLElement, diff: UiDiff | null, was?: string): void {
const nodes = box.matches(".ui-input, .ui-select, .ui-btn") ? [box] : [...box.querySelectorAll<HTMLElement>(".ui-input, .ui-select, .ui-btn.lstk-res")]; // prettier-ignore
for (const n of nodes) {
setUiDiff(n, diff);
if (diff && was !== undefined)
n.title = `${n.title ? `${n.title} — ` : ""}${lt("Ctl_Was")} ${was}`;
}
}
const FUELS = ["경유", "휘발유", "실내등유"];
@@ -69,11 +93,13 @@ export function lineCall(
answer: DocAnswer,
link: Link | undefined,
at?: number,
upper?: Cover | null,
): { given: Record<string, unknown>; key: string; work: string; want?: WorkCover } {
const given = subInputs(link, (answer.값 ?? {}) as Record<string, unknown>);
const w = at === undefined ? null : workAt(answer, at);
const work = w ? workKey(coverOf(doc), w) : machineKey(given);
const want = w ? (coverOf(doc)[work] as CoverEntry | undefined)?.[WORK] : undefined;
const cover = layeredCover(doc, upper); // 848-3 ① 위에 ②(셈과 같은 덮음)
const work = w ? workKey(cover, w) : machineKey(given);
const want = w ? (cover[work] as CoverEntry | undefined)?.[WORK] : undefined;
if (w?.고정) given.기계 = w.고정;
return { given, key: (w?.고정 && want?.키) || String(link?.키 ?? ""), work, want };
}
@@ -81,14 +107,15 @@ export function lineCall(
/** 그 기계 줄의 기계 열쇠 · 식 · 원본 기본값 — 기계 식이 아니면 null */
export function ctlOf(h: CtlHooks, link: Link | undefined, at?: number) {
if (link?.갈래 !== "단가산출" || !link.키) return null;
const { given, key } = lineCall(h.doc, h.answer, link, at);
const { given, key } = lineCall(h.doc, h.answer, link, at, h.upper);
const machine = machineKey(given);
const sub = h.subDoc(key);
if (!machine || !sub) return null;
const orig = h.calc(sub, given);
const vals = (orig.값 ?? {}) as Record<string, unknown>;
const base = defaultsOf(sub, vals, rowEntry(sub, h.lists?.(given) ?? null));
return { machine, sub, vals, base, entry: coverOf(h.doc)[machine] };
const up = (h.upper?.[machine] as CoverEntry | undefined) ?? null;
return { machine, sub, vals, base, up, top: upperOf(base, up), entry: coverOf(h.doc)[machine] };
}
const num = (t: string): number | null => {
@@ -140,16 +167,17 @@ export function buildMachineCtl(
): HTMLElement | null {
const got = ctlOf(h, link, at);
if (!got) return null;
const { machine, sub, vals, base } = got;
const { machine, sub, vals, base, up, top } = got;
const entry: CoverEntry = got.entry ?? {};
const src = sourcesOf(up, entry);
const ro = h.readOnly;
const put = (next: CoverEntry): void => h.change((d) => putCover(d, machine, next, base));
const put = (next: CoverEntry): void => h.change((d) => putCover(d, machine, next, base, up));
const parts = partsOf(sub);
const lines = sub.금액 ?? [];
// ㉠ 값 칸
const values = parts.fields.map(({ 칸: col }) => {
const was = base.값[col];
const was = top.값[col];
const mine = entry.값?.[col];
const now = mine ?? was;
const shut = ro || !!h.lock?.includes(col);
@@ -182,9 +210,6 @@ export function buildMachineCtl(
],
});
if (mine !== undefined) {
const tag = createBadge(lt("Ctl_Changed"), "info", { size: 18 });
tag.title = `${lt("Ctl_Was")} ${was === undefined ? "—" : eqText(was)}`;
row.append(tag);
if (!shut)
row.append(
createButton({
@@ -196,12 +221,13 @@ export function buildMachineCtl(
}),
);
}
markDiff(box, diffOf(src[`값.${col}`]), was === undefined ? "—" : eqText(was));
row.dataset.mctlField = col;
return row;
});
// ㉡ 조종원 — 인력 줄
const crew: CrewRow[] = entry.조종원 ?? base.조종원;
const crew: CrewRow[] = entry.조종원 ?? top.조종원;
const setCrew = (rows: CrewRow[]): void => put({ ...entry, 조종원: rows });
const crewName = (r: CrewRow, i: number): string => {
if (r.이름) return r.이름;
@@ -223,7 +249,7 @@ export function buildMachineCtl(
);
// ㉢ 잡품 — 재료 줄
const misc: MiscRow[] = entry.잡품 ?? base.잡품;
const misc: MiscRow[] = entry.잡품 ?? top.잡품;
const setMisc = (rows: MiscRow[]): void => put({ ...entry, 잡품: rows });
const baseQty = (r: MiscRow): number | null => {
const b = lines.find((l) => String(l.이름 ?? "") === r.줄);
@@ -274,12 +300,14 @@ export function buildMachineCtl(
),
);
// 인력 · 잡품 = 목록 통째 한 칸(848-1) — 묶음 안 칸 · 이름 단추 모두 그 출처
for (const r of crewRows) markDiff(r, diffOf(src.조종원));
for (const r of miscRows) markDiff(r, diffOf(src.잡품));
const head = (label: string, covered: boolean, add: (() => void) | null, reset: () => void) =>
el("div", {
className: "lstk-fhead",
children: [
el("span", { className: "lstk-kind", text: label }),
...(covered ? [createBadge(lt("Ctl_Changed"), "info", { size: 18 })] : []),
...(ro
? []
: [
@@ -292,18 +320,20 @@ export function buildMachineCtl(
});
// ㉣ 시간당 작업량(846-2) — 덮음 열쇠 = 줄 기계(굳은 기계면 값 칸 열쇠와 다름 · 847-1)
const info = (at === undefined ? null : workAt(h.answer, at)) ?? workOfMachine(h.answer, machine);
const wkey = info ? workKey(coverOf(h.doc), info) : machine;
const wkey = info ? workKey(layeredCover(h.doc, h.upper), info) : machine;
const upWork = (h.upper?.[wkey] as CoverEntry | undefined)?.작업량 ?? null;
const work = info
? buildWorkGroup({
doc: h.doc,
info,
kind: info.꼴 === "시간당" ? (sites(h.doc, h.doc.금액?.[at ?? -1]?.수량)[0]?.꼴 ?? "일당") : info.꼴, // prettier-ignore
entry: (coverOf(h.doc)[wkey] as CoverEntry | undefined)?.작업량,
upper: upWork,
specs: h.work?.(info.고정 ?? wkey) ?? [],
subDoc: h.subDoc,
vals: (h.answer.값 ?? {}) as Record<string, unknown>,
ro,
put: (w) => h.change((d) => putWork(d, wkey, w)),
put: (w, wb) => h.change((d) => putWork(d, wkey, w, upWork, wb)),
})
: [];
const box = el("div", {
+7 -6
View File
@@ -11,6 +11,7 @@
* ========================================================================== */
import { API_BASE_URL } from "@config/config_frontend";
import { setUiDiff } from "@ui/ui_template_button";
import { attachCollapsible, createPanelCard } from "@ui/ui_template_collapsible";
import { createInputField, createSelectField, el } from "@ui/ui_template_elements";
import { createFindList } from "@ui/ui_template_find_list";
@@ -305,7 +306,7 @@ export function createMachineSheet(o: MachineSheetOptions) {
f.input.inputMode = "decimal";
f.input.dataset.key = k;
f.input.readOnly = ro || read;
f.root.classList.toggle("is-changed", !sameVal(v, orig.값?.[k]));
setUiDiff(f.input, !sameVal(v, orig.값?.[k]) ? "mine" : null); // 848-3 저장 안 한 바뀜 = 파랑
f.input.addEventListener("change", () => {
const t = f.input.value.replace(/,/g, "").trim();
const box = (cur.값 ??= {});
@@ -322,7 +323,7 @@ export function createMachineSheet(o: MachineSheetOptions) {
else delete box[k];
} else box[k] = n;
if ((MACHINE_INPUTS as readonly string[]).includes(k)) recoef();
f.root.classList.toggle("is-changed", !sameVal(box[k], orig.값?.[k]));
setUiDiff(f.input, !sameVal(box[k], orig.값?.[k]) ? "mine" : null); // 848-3 저장 안 한 바뀜 = 파랑
changed(PICKY.includes(k));
if ((MACHINE_INPUTS as readonly string[]).includes(k)) drawBase();
});
@@ -341,13 +342,13 @@ export function createMachineSheet(o: MachineSheetOptions) {
f.select.dataset.key = k;
f.select.disabled = ro;
attachPickSearch(f.select, { placeholder: L("MF_PickFind") });
f.root.classList.toggle("is-changed", !sameVal(now, orig.값?.[k]));
setUiDiff(f.select, !sameVal(now, orig.값?.[k]) ? "mine" : null); // 848-3 저장 안 한 바뀜 = 파랑
f.select.addEventListener("change", () => {
const box = (cur.값 ??= {});
if (f.select.value) box[k] = f.select.value;
else if (k in (orig.값 ?? {})) box[k] = orig.값![k] === "" ? "" : null;
else delete box[k];
f.root.classList.toggle("is-changed", !sameVal(box[k], orig.값?.[k]));
setUiDiff(f.select, !sameVal(box[k], orig.값?.[k]) ? "mine" : null); // 848-3 저장 안 한 바뀜 = 파랑
changed(true);
});
return f.root;
@@ -400,10 +401,10 @@ export function createMachineSheet(o: MachineSheetOptions) {
): HTMLElement => {
const f = createInputField({ label: lab, value: get, size: 28 });
f.input.readOnly = ro;
f.root.classList.toggle("is-changed", get !== was);
setUiDiff(f.input, get !== was ? "mine" : null); // 848-3 저장 안 한 바뀜 = 파랑
f.input.addEventListener("input", () => {
set(f.input.value);
f.root.classList.toggle("is-changed", f.input.value !== was);
setUiDiff(f.input, f.input.value !== was ? "mine" : null); // 848-3 저장 안 한 바뀜 = 파랑
o.onChange?.();
});
return f.root;
+59 -28
View File
@@ -9,10 +9,11 @@
* 847-1(요구 884 · 885) — 방식이 하나뿐인 줄(기계에 맞는 식 없음) = 고르기 없이 그 풀이만 ·
* 시간당으로 바꿈 = 그 줄 기계를 굳힘(덮음 `기계`) · 기계 창으로 바꿈(`swapMachine`) = 새 기계 작업량 식 · 규격 변수로
* 다시 차림(같은 식 = 고친 현장 변수 남김 · 다른 식 = 버림 + 알림 · 맞는 식 없음 = 품셈 일당으로 + 알림)
* 층(848-3) — 보이는 값 = `mergeWork(①, ②)` · 원래 값 = 식 기본 위에 ① 변수(같은 식일 때) · 고침 = ① 과 다른 칸만
* (`pruneWorkLayer`) · 테두리 = 방식 · 식 · 변수마다 출처(나 = 파랑 · 위 = 주황) · 「고침」 글 배지 없음
* ========================================================================== */
import { createBadge } from "@ui/ui_template_badge";
import { createButton } from "@ui/ui_template_button";
import { createButton, setUiDiff, type UiDiff } from "@ui/ui_template_button";
import { eqText } from "@ui/ui_template_equation";
import { el } from "@ui/ui_template_elements";
import { createSelectField } from "@ui/ui_template_input";
@@ -23,9 +24,14 @@ import {
COVER,
coverOf,
machineKey,
mergeWork,
pruneWorkLayer,
sourcesOf,
type CoverEntry,
type WorkLayer,
} from "../common_util/common_util_formula_doc_cover";
import {
DAILY,
fits,
HOURLY,
normUnit,
@@ -41,7 +47,7 @@ import type { Picked } from "../common_util/common_util_line_stack_pick";
import type { Values } from "../common_util/common_util_formula_doc_view";
import { varUnit } from "../common_util/common_util_line_stack_unit";
import { workUnit } from "../common_util/common_util_line_stack_work";
import { numBox } from "./line_stack_machine_ctl";
import { diffOf, markDiff, numBox } from "./line_stack_machine_ctl";
import { lt } from "./line_stack_text";
import { workRows } from "./line_stack_work";
@@ -67,6 +73,8 @@ export interface VarRowsOpts {
ro: boolean;
/** null = 원래대로 */
set: (key: string, v: number | string | null) => void;
/** 848-3 칸 「바뀜」 상태 — 없으면 원래 값과 다르면 「나」 */
diff?: (key: string) => UiDiff | null;
}
/** 작업량 틀 변수 칸(입력 · 선택) — 이름(품셈 기호는 칸 풍선) = 칸 단위 */
@@ -91,6 +99,8 @@ export function workVarRows(o: VarRowsOpts): HTMLElement[] {
}).root
: numBox(name, now, varUnit(v), o.ro, (n) => o.set(k, n));
const changed = !same(now, o.base[k]);
const was = o.base[k] === undefined ? "—" : eqText(o.base[k]);
markDiff(box, o.diff ? o.diff(k) : changed ? "mine" : null, was);
const sym = [v.기호, v.아래].filter(Boolean).join(" ");
const row = el("div", {
className: "lstk-frow",
@@ -108,15 +118,10 @@ export function workVarRows(o: VarRowsOpts): HTMLElement[] {
box,
],
});
if (changed) {
const tag = createBadge(lt("Ctl_Changed"), "info", { size: 18 });
tag.title = `${lt("Ctl_Was")} ${o.base[k] === undefined ? "—" : eqText(o.base[k])}`;
row.append(tag);
if (!o.ro)
row.append(
createButton({ label: lt("Ctl_Back"), variant: "ghost", size: 24, iconStart: "undo", onClick: () => o.set(k, null) }), // prettier-ignore
);
}
if (changed && !o.ro && (!o.diff || o.diff(k) === "mine"))
row.append(
createButton({ label: lt("Ctl_Back"), variant: "ghost", size: 24, iconStart: "undo", onClick: () => o.set(k, null) }), // prettier-ignore
);
return row;
});
}
@@ -128,20 +133,30 @@ export interface WorkGroupOpts {
/** 덮음 없을 때 꼴(일당 · 식) — 고르기 첫 칸 이름 */
kind: string;
entry: WorkCover | undefined;
/** 848-3 ① 위 층 작업량(SK · 없음 = 정본) */
upper?: WorkLayer | null;
/** 그 기계 작업량 줄(기계 값 칸) */
specs: WorkSpec[];
subDoc: (key: string) => FormulaDoc | null;
/** 문서 값(일당 풀이 글) */
vals: Values;
ro: boolean;
put: (w: WorkCover | undefined) => void;
/** `base` = 그 식 기본 변수(① 대조 정리용) */
put: (w: WorkCover | undefined, base?: Record<string, unknown>) => void;
}
/** 작업량 덮음 한 줄 고침(줄 기계 열쇠 · 값 칸 덮음은 그대로) — 없음 = 지움 · 비면 칸 지움 */
export function putWork(doc: FormulaDoc, key: string, w: WorkCover | undefined): void {
/** 작업량 덮음 한 줄 고침(줄 기계 열쇠 · 값 칸 덮음은 그대로) — 없음 = 지움 · 비면 칸 지움 ·
* `upper` = ① 그 열쇠 작업량(848-3 · 있으면 ① 과 같은 칸 뺌 · `base` = 식 기본 변수) */
export function putWork(
doc: FormulaDoc,
key: string,
w: WorkCover | undefined,
upper: WorkLayer | null = null,
base?: Record<string, unknown>,
): void {
const all: Record<string, CoverEntry> = { ...coverOf(doc) };
const one: CoverEntry = { ...(all[key] ?? {}) };
const kept = pruneWork(w);
const kept = upper ? (pruneWorkLayer(w, base ?? null, upper) as WorkCover | null) : pruneWork(w);
if (kept) one[WORK] = kept;
else delete one[WORK];
if (Object.keys(one).length) all[key] = one;
@@ -181,7 +196,13 @@ export function swapMachine(
/** 제어 구역 「시간당 작업량」 묶음 */
export function buildWorkGroup(o: WorkGroupOpts): HTMLElement[] {
const hourly = o.entry?.방식 === HOURLY;
const up = o.upper ?? null;
const eff = mergeWork(up, o.entry) as WorkCover | null; // 보이는 값 = ① 위에 ②
const src = sourcesOf(
up ? { 작업량: up as WorkCover } : null,
o.entry ? { 작업량: o.entry } : null,
);
const hourly = eff?.방식 === HOURLY;
const formulas = o.info.식들 ?? [];
const first = o.kind === "식" ? "식" : "일당";
const single = !formulas.length && !hourly; // 847-1 방식 하나뿐 = 고르기 없음
@@ -198,16 +219,16 @@ export function buildWorkGroup(o: WorkGroupOpts): HTMLElement[] {
value: hourly ? HOURLY : "일당",
size: 24,
ariaLabel: lt("Work_Way"),
// 847-1 시간당 = 그 줄 기계를 굳힘(옵션이 정하던 기계를 더 안 읽음)
onChange: (v) => o.put(v === HOURLY ? { 방식: HOURLY, 식: formulas[0], 기계: o.info.기계 } : undefined), // prettier-ignore
// 847-1 시간당 = 그 줄 기계를 굳힘(옵션이 정하던 기계를 더 안 읽음) · 848-3 위 층이 시간당 = 일당을 내 고침으로
onChange: (v) => o.put(v === HOURLY ? { 방식: HOURLY, 식: formulas[0], 기계: o.info.기계 } : up?.방식 === HOURLY ? { 방식: DAILY } : undefined), // prettier-ignore
});
setUiDiff(seg.root, diffOf(src["작업량.방식"]));
if (o.ro) seg.root.querySelectorAll("button").forEach((b) => (b.disabled = true));
seg.root.dataset.workWay = hourly ? HOURLY : first;
const head = el("div", {
className: "lstk-fhead",
children: [
el("span", { className: "lstk-kind", text: lt("Work_Head") }),
...(o.entry ? [createBadge(lt("Ctl_Changed"), "info", { size: 18 })] : []),
...(o.entry && !o.ro
? [createButton({ label: lt("Ctl_Back"), variant: "ghost", size: 24, iconStart: "undo", onClick: () => o.put(undefined) })] // prettier-ignore
: []),
@@ -222,7 +243,7 @@ export function buildWorkGroup(o: WorkGroupOpts): HTMLElement[] {
out.push(...rows.map((r) => el("div", { className: "lstk-work", children: bare(r) })));
return out;
}
const pick = o.entry?.식 || o.info.율 || formulas[0] || "";
const pick = eff?.식 || o.info.율 || formulas[0] || "";
if (formulas.length > 1)
out.push(
el("div", {
@@ -230,7 +251,7 @@ export function buildWorkGroup(o: WorkGroupOpts): HTMLElement[] {
children: [
el("b", { className: "lstk-sym", text: lt("Work_Pick") }),
"=",
createSelectField({
markPick(createSelectField({
options: formulas.map((k) => ({ value: k, text: o.subDoc(k)?.이름 ?? k })),
value: pick,
compact: true,
@@ -238,7 +259,7 @@ export function buildWorkGroup(o: WorkGroupOpts): HTMLElement[] {
disabled: o.ro,
ariaLabel: lt("Work_Pick"),
onChange: (k) => o.put({ 방식: HOURLY, 식: k }),
}).root,
}).root, diffOf(src["작업량.식"])), // prettier-ignore
],
}),
);
@@ -246,20 +267,25 @@ export function buildWorkGroup(o: WorkGroupOpts): HTMLElement[] {
const tpl = pick ? o.subDoc(pick) : null;
if (!tpl) return [...out, note(lt("Work_Wait"))];
const base = workDefaults(tpl, o.specs.find((s) => s.식 === pick) ?? null);
const mine = o.entry?.변수 ?? {};
const top = {
...base,
...(up?.방식 === HOURLY && String(up.식 ?? "") === pick ? (up.변수 ?? {}) : {}),
}; // 원래 값 = 위 층 값
const mine = eff?.변수 ?? {};
out.push(
el("div", { className: "lstk-work", children: [el("span", { className: "lstk-hint", text: tpl.이름 ?? pick })] }), // prettier-ignore
...workVarRows({
tpl,
now: { ...base, ...mine },
base,
now: { ...top, ...mine },
base: top,
ro: o.ro,
diff: (k) => diffOf(src[`작업량.변수.${k}`]),
set: (k, v) => {
const next = { ...mine };
if (v === null) delete next[k];
else next[k] = v;
const kept = pruneVars(next, base);
o.put({ 방식: HOURLY, 식: pick, ...(Object.keys(kept).length ? { 변수: kept } : {}) });
const kept = pruneVars(next, top);
o.put({ 방식: HOURLY, 식: pick, ...(Object.keys(kept).length ? { 변수: kept } : {}) }, base); // prettier-ignore
},
}),
el("div", {
@@ -272,3 +298,8 @@ export function buildWorkGroup(o: WorkGroupOpts): HTMLElement[] {
);
return out;
}
const markPick = (root: HTMLElement, diff: UiDiff | null): HTMLElement => (
markDiff(root, diff),
root
);
+2 -2
View File
@@ -85,7 +85,7 @@ export interface OutHooks {
toggle: (at: string) => void;
/** 캐시에 없는 연결 — 뒤에서 서버에 물음 */
miss: () => void;
/** 836-1 기계 덮음(맨 위 문서 칸) — 펼친 기계 식에 얹음(계산기와 같음) */
/** 836-1 기계 덮음(맨 위 문서 칸) — 펼친 기계 식에 얹음(계산기와 같음) · 848-3 SK = ① 위에 ②(`layeredCover`) */
cover?: Cover;
/** 838-3 기계 이름을 받은 뒤 다시 그림 */
redraw?: () => void;
@@ -510,7 +510,7 @@ export function buildOut(doc: StackDoc, a: DocAnswer, h: OutHooks): HTMLElement
depth: 0,
lv: 0,
};
for (const r of [head, ...rows(doc, a, { ...h, cover: coverOf(doc) }, 0, "")]) {
for (const r of [head, ...rows(doc, a, { ...h, cover: h.cover ?? coverOf(doc) }, 0, "")]) {
const cell = (k: "sum" | (typeof COSTS)[number]): string => {
const v = r.cols?.[k];
if (v === undefined || (r.won && !v && k !== "sum")) return "";
+53 -7
View File
@@ -15,11 +15,15 @@
* `line_stack_machine_ctl` — 문서 칸 `기계덮음` · 캐시 · [저장] 때 서버가 다시 셈)
* [단가 갱신] · [재생성] = 미리 셈 → 알림 → 저장(`formula_doc_copy.ts` · 고친 것 먼저 저장)
* 저장 전 문서(`memory` · 836-5 · 불러오기 미리 보기) = 빈 키 + 서버에 문서째(`본`) 읽음 · 왼쪽 줄 쌓기는 보기만(inert) · 디스크 쓰기 0
* 층(848-3) — SK 읽기 · 미리 셈 답 `위덮음`(① 기초 고침) 을 셈 · 산출근거 · 제어 구역에 얹음(`layeredCover` · 화면 셈 = 서버 셈) ·
* M01 기초 = 시스템 관리자에게 제어 구역 엶 · 머리 [초기화] = 그 기초 기계 고침 전부 걷고 저장(확인창 목록)
* ========================================================================== */
import { API_BASE_URL } from "@config/config_frontend";
import { createBadge } from "@ui/ui_template_badge";
import { createButton } from "@ui/ui_template_button";
import { askConfirm } from "@ui/ui_template_modal";
import { createText } from "@ui/ui_template_text";
import {
el,
hideLoadingOverlay,
@@ -29,7 +33,13 @@ import {
} from "@ui/ui_template_elements";
import { blankDoc, type DocVar, type FormulaDoc } from "../common_util/common_util_formula_doc";
import { calcDoc, type DocAnswer } from "../common_util/common_util_formula_doc_calc";
import { listsOf } from "../common_util/common_util_formula_doc_cover";
import {
COVER,
coverOf,
layeredCover,
listsOf,
type Cover,
} from "../common_util/common_util_formula_doc_cover";
import { importView, type Basis } from "../common_util/common_util_formula_doc_import";
import { createSegment } from "@ui/ui_template_segment";
import type { DocTable } from "../common_util/common_util_formula_doc_table";
@@ -52,8 +62,8 @@ import {
swapBadge,
} from "./formula_doc_copy";
import { docFoot } from "./formula_doc_foot";
import { askRenew } from "./formula_doc_renew";
import { buildOptions } from "./formula_doc_options";
import { askRenew, type RenewNote } from "./formula_doc_renew";
import { buildOptions, machineText } from "./formula_doc_options";
import { hiddenByWork } from "./formula_doc_render";
import { ft } from "./formula_doc_text";
import { addTaken, type Taken } from "../common_util/common_util_line_stack_copy";
@@ -61,6 +71,7 @@ import { machineWork } from "../common_util/common_util_line_stack_work";
import type { Layer } from "../M02_MasterTemplete/M02_MasterTemplete_Api_Fetch";
import { buildEdit } from "./line_stack_edit";
import { openMachineWindow, type CopyAnswer, type MachineCtx } from "./line_stack_machine";
import { dropPath } from "../common_util/common_util_formula_doc_cover_drop";
import { buildOut } from "./line_stack_out";
import { lt } from "./line_stack_text";
import "./line_stack.css";
@@ -91,6 +102,8 @@ interface Loaded {
끊음?: Docs;
사본?: CopyMark;
판?: string;
/** 848-1 ① 위 층 고침(SK · 프로젝트 밖 = 지금 기초 것) */
위덮음?: Cover;
}
const clone = <T>(v: T): T => JSON.parse(JSON.stringify(v)) as T;
@@ -124,6 +137,7 @@ export function createStackScreen(opt: StackScreenOptions) {
let cut: Docs = {};
let mark: CopyMark | undefined;
let version = "";
let upper: Cover | null = null; // 848-3 ① 위 층 고침
let seq = 0;
let asked = "";
let ctl: AbortController | null = null;
@@ -194,7 +208,8 @@ export function createStackScreen(opt: StackScreenOptions) {
const recalc = (): void => {
if (!doc) return;
const basis = mark?.단가기준; // 가져온 식(807-1) — 서버 셈과 같은 보기
answer = calcDoc(basis ? importView(doc, basis) : doc, cache.links, usable());
const d = basis ? importView(doc, basis) : doc;
answer = calcDoc(d, cache.links, usable(), [], new Map(), upper ? layeredCover(d, upper) : undefined); // prettier-ignore
if (cache.takeMissing()) ask();
};
/** 캐시에 없는 연결 — 뒤에서 서버 기록을 받아 더함 */
@@ -205,7 +220,7 @@ export function createStackScreen(opt: StackScreenOptions) {
ctl?.abort();
ctl = new AbortController();
const mine = ++seq;
void call<{ 연결: DocRecord; 사본?: CopyMark }>(
void call<{ 연결: DocRecord; 사본?: CopyMark; 위덮음?: Cover }>(
"/preview",
cp ? { 문서: doc, 끊음: cut } : { 문서: key ? doc : { ...doc, 키: "_새" }, 입력: usable() },
ctl.signal,
@@ -215,6 +230,7 @@ export function createStackScreen(opt: StackScreenOptions) {
cache.merge(got.연결);
cache.merge({ 문서: cut });
if (got.사본) mark = got.사본; // 새로 읽은 줄 「사본 없는 줄 n」(826-3)
if (got.위덮음) upper = got.위덮음;
recalc();
draw();
})
@@ -328,6 +344,7 @@ export function createStackScreen(opt: StackScreenOptions) {
const tools = [
...(mark?.단가기준 && opt.page ? [basisPick(mark.단가기준)] : []), // 모달 = 머리 판 단추(793-3b)
...(cp && edit() && key && !mark?.자동 ? copyTools(true, (job) => void runJob(job)) : []), // 836-2 자동 = 없음
...(!cp && edit() && key && Object.keys(coverOf(doc)).length ? [resetBase()] : []), // 848-3 M01 기초 [초기화]
...(edit() && key && !opt.page
? [
createButton({
@@ -386,6 +403,8 @@ export function createStackScreen(opt: StackScreenOptions) {
lists: (g) => listsOf((q) => cache.links.element(q), g),
look: (p) => cache.links.table(p),
work: (m) => machineWork((q) => cache.links.element(q), m),
upper,
ctlEdit: !cp && edit(), // 848-3 M01 기초 = 시스템 관리자
before: saved ? lineMap(JSON.parse(saved) as StackDoc) : undefined,
}),
]
@@ -405,6 +424,7 @@ export function createStackScreen(opt: StackScreenOptions) {
miss: ask,
pair: (loc) => pair(loc, "right"),
redraw: () => draw(),
cover: layeredCover(doc, upper),
})
: el("p", { className: "ui-text ui-text--muted", text: lt("Empty") }),
);
@@ -420,8 +440,29 @@ export function createStackScreen(opt: StackScreenOptions) {
cut = clone(got.끊음 ?? {});
mark = got.사본;
version = got.판 ?? "";
upper = got.위덮음 ?? null;
};
/** 848-3 M01 기초 [초기화] — 기계 고침 목록 확인 → 걷고 저장(서버 정본 · 저장 안 한 고침이 있으면 먼저) */
const resetBase = (): HTMLElement =>
createButton({
label: ft("Reset_Base"),
variant: "ghost",
size: 28,
iconStart: "rotateCcw",
onClick: async () => {
if (!doc) return;
if (dirty()) return void showToast(ft("Dirty_First"), "warning");
const keys = Object.keys(coverOf(doc));
const detail = el("div", { children: keys.map((k) => createText(`· ${machineText(k, () => undefined) ?? k}`, "muted", 12)) }); // prettier-ignore
const message = ft("Reset_Base_Ask").replace("{n}", String(keys.length));
if (!(await askConfirm({ message, okLabel: ft("Reset_Base"), danger: true, detail }))) return; // prettier-ignore
delete (doc as StackDoc & { [COVER]?: unknown })[COVER];
keep();
await save(undefined, ft("Reset_Base_Done"));
},
});
/** 사본 [단가 갱신] · [재생성] — 미리 셈 → 알림 → 저장(고친 것 먼저 저장 · 버림) */
const runJob = async (job: CopyJob): Promise<void> => {
if (!doc || !cp) return;
@@ -564,8 +605,13 @@ export function createStackScreen(opt: StackScreenOptions) {
draw();
opt.page?.(); // 캐시에서 이어 받은 고침 — 페이지 [저장] · [되돌림] 켬
const notes = (mark as CopyMark | undefined)?.갱신; // 836-2 M01 자동 따라옴 알림(take 가 채움)
if (cp && edit() && !dirty() && notes?.length)
void askRenew(notes).then((ok) => ok && save({ 할일: "갱신확인", 판: version }, ""));
if (cp && edit() && !dirty() && notes?.length) {
let picked: RenewNote[] = []; // 848-3 [위 값으로] = 확인 저장 뒤 캐시에서 그 칸 고침 지움 → [저장]
void askRenew(notes, (p) => (picked = p)).then(async (ok) => {
if (ok) await save({ 할일: "갱신확인", 판: version }, "");
if (picked.length) change((d) => picked.forEach((n) => dropPath(d, n.열쇠!, n.경로!)));
});
}
} catch (e) {
if (mine === seq)
head.replaceChildren(
+4 -1
View File
@@ -98,7 +98,10 @@ const TEXT = {
Ctl_Crew: ["조종원", "Operator"],
Ctl_Misc: ["잡품", "Sundries"],
Ctl_Add: ["더함", "add"],
Ctl_Changed: ["고침", "Edited"],
Ctl_Line_Back: [
"이 기계의 고침 전부를 위 층 값으로(캐시 · [저장] 때 반영)",
"Revert all edits of this machine to the upper layer (saved on [Save])",
],
Ctl_Was: ["원래 값", "Original"],
Ctl_Back: ["원래 값", "Original"],
Ctl_Bad: ["0 이상 수만 넣을 수 있음", "Enter a number 0 or more"],
@@ -0,0 +1,47 @@
/* =============================================================================
* common_util_formula_doc_cover_drop.ts
* 기계 고침 걷기(PLAN 848-3 · 요구 889) — 화면 초기화 단추 · 알림 [위 값으로] 가 부르는 순수 셈(화면 · fetch 없음)
* `dropCover` = 그 기계 줄 고침 통째(값 칸 열쇠 · 작업량 열쇠) — 걷으면 그 칸은 위 층 값(① · 없으면 정본)
* `dropPath` = 한 칸 고침 — 경로 = `값.<칸>` · 조종원 · 잡품 · `작업량.방식|식|기계` · `작업량.변수.<열쇠>`(848-1 출처 경로와 같음)
* 자리 = 문서 칸 `기계덮음`(② 내 고침 · 캐시 → [저장] 때 서버가 정본으로 다시 셈 · 비면 칸 지움)
* ========================================================================== */
import type { FormulaDoc } from "./common_util_formula_doc";
import { COVER, coverOf, type Cover, type CoverEntry } from "./common_util_formula_doc_cover";
import { WORK } from "./common_util_formula_doc_work";
const write = (doc: FormulaDoc, all: Cover): void => {
const box = doc as FormulaDoc & { [COVER]?: unknown };
if (Object.keys(all).length) box[COVER] = all;
else delete box[COVER];
};
/** 그 기계 줄 고침 통째 걷음 */
export function dropCover(doc: FormulaDoc, keys: string[]): void {
const all = { ...coverOf(doc) };
for (const k of keys) delete all[k];
write(doc, all);
}
/** 한 칸 고침 걷음 */
export function dropPath(doc: FormulaDoc, key: string, path: string): void {
const one = coverOf(doc)[key] as CoverEntry | undefined;
if (!one) return;
const e = JSON.parse(JSON.stringify(one)) as CoverEntry;
const [head, sub, leaf] = path.split(".");
if (head === "값" && e.값) delete e.값[sub];
if (head === "조종원" || head === "잡품") delete e[head];
const w = e[WORK] as Record<string, unknown> | undefined;
if (head === WORK && w) {
const vars = w.변수 as Record<string, unknown> | undefined;
if (sub === "변수" && vars) delete vars[leaf];
else if (sub === "기계") for (const k of ["기계", "키", "이름"]) delete w[k];
else delete w[sub];
if (vars && !Object.keys(vars).length) delete w.변수;
if (!Object.keys(w).length) delete e[WORK];
}
if (e.값 && !Object.keys(e.값).length) delete e.값;
const all = { ...coverOf(doc), [key]: e };
if (!Object.keys(e).length) delete all[key];
write(doc, all);
}
@@ -0,0 +1,37 @@
/* 848-3 기계 고침 걷기 헬퍼 — common_util_formula_doc_cover_drop.ts · common_util_formula_doc_cover.ts 를 트랜스파일해 Node 로 돌림.
* stdin = {문서, 위, 걷기: [{열쇠, 경로?}](경로 없음 = 그 열쇠 통째)} — 걷기를 차례로 하며 걸음마다 덮음 · 출처를 냄
* stdout = [{덮음, 출처: {열쇠: sourcesOf(위[열쇠], 덮음[열쇠])}}] */
const fs = require("fs");
const path = require("path");
const ts = require(path.join(__dirname, "..", "..", "config", "node_modules", "typescript"));
const cache = new Map();
function load(at) {
if (cache.has(at)) return cache.get(at);
const js = ts.transpileModule(fs.readFileSync(at, "utf8"), {
compilerOptions: { module: ts.ModuleKind.CommonJS, target: ts.ScriptTarget.ES2020 },
}).outputText;
const box = { exports: {} };
cache.set(at, box.exports);
const need = (p) =>
p.startsWith(".") ? load(path.resolve(path.dirname(at), `${p}.ts`)) : require(p);
new Function("exports", "module", "require", js)(box.exports, box, need);
return box.exports;
}
const root = path.join(__dirname, "..", "..", "common_util");
const drop = load(path.join(root, "common_util_formula_doc_cover_drop.ts"));
const cover = load(path.join(root, "common_util_formula_doc_cover.ts"));
const ask = JSON.parse(fs.readFileSync(0, "utf8"));
const doc = ask.문서;
const out = ask.걷기.map((s) => {
if (s.경로) drop.dropPath(doc, s.열쇠, s.경로);
else drop.dropCover(doc, [s.열쇠]);
const now = cover.coverOf(doc);
const keys = [...new Set([...Object.keys(ask.위), ...Object.keys(now)])];
return {
덮음: doc[cover.COVER] ?? null,
출처: Object.fromEntries(keys.map((k) => [k, cover.sourcesOf(ask.위[k], now[k])])),
};
});
process.stdout.write(JSON.stringify(out));
+61
View File
@@ -0,0 +1,61 @@
"""848-3 칸 · 기계 한 줄 초기화(요구서_889 4 장) — 내 고침을 걷으면 그 칸 출처가 위 층(①)으로 돌아감.
짝 = `common_util/common_util_formula_doc_cover_drop.ts`(화면 [원래 값] · 알림 [위 값으로] · 줄 머리 되돌림) ·
출처 = 848-1 `sourcesOf`(나 = 파랑 · 위 = 주황 테두리).
① 값 칸 하나 걷음 = 그 칸만 「위」(① 이 고친 칸) 또는 정본(없음) · 다른 칸 「나」 그대로.
② 작업량 변수 하나 · 방식 걷음 = 그 경로만 · 비면 작업량 칸 지움.
③ 마지막 칸 걷음 = 그 열쇠 지움 · 모두 비면 문서 칸 `기계덮음` 없음 · 줄 통째 = 그 열쇠만.
"""
import json
import os
import subprocess
HERE = os.path.dirname(os.path.abspath(__file__))
A, B = "0201-0070", "0201-0100"
def _run(doc, upper, steps):
proc = subprocess.run(
["node", os.path.join(HERE, "helper_848_3_cover_drop.cjs")],
input=json.dumps({"문서": doc, "위": upper, "걷기": steps}, ensure_ascii=False),
capture_output=True,
text=True,
encoding="utf-8",
)
assert proc.returncode == 0, proc.stderr[-2000:]
return json.loads(proc.stdout)
def test_칸_걷으면_위_층으로():
work = {"방식": "시간당", "식": "GC001147", "변수": {"E": 0.8, "f": 1.1}}
mine = {
A: {"값": {"가격": 2, "연료": 3}, "조종원": [{"키": "LB:1048", "인": 2}], "작업량": work},
B: {"값": {"가격": 5}},
}
upper = {A: {"값": {"가격": 9}}}
got = _run(
{"이름": "x", "기계덮음": mine},
upper,
[
{"열쇠": A, "경로": "값.가격"},
{"열쇠": A, "경로": "작업량.변수.E"},
{"열쇠": A, "경로": "작업량.방식"},
{"열쇠": A, "경로": "조종원"},
{"열쇠": B},
{"열쇠": A, "경로": "작업량.식"},
{"열쇠": A, "경로": "작업량.변수.f"},
{"열쇠": A, "경로": "값.연료"},
],
)
first = got[0]
assert first["출처"][A]["값.가격"] == "위" and first["출처"][A]["값.연료"] == "나"
assert first["덮음"][A]["값"] == {"연료": 3} and first["덮음"][B] == {"값": {"가격": 5}}
assert got[1]["덮음"][A]["작업량"]["변수"] == {"f": 1.1}
assert "작업량.변수.E" not in got[1]["출처"][A] and got[1]["출처"][A]["작업량.변수.f"] == "나"
assert "방식" not in got[2]["덮음"][A]["작업량"]
assert "조종원" not in got[3]["덮음"][A] and "조종원" not in got[3]["출처"][A]
assert B not in got[4]["덮음"] and B not in got[4]["출처"]
assert "작업량" not in got[6]["덮음"][A] # 비면 작업량 칸 지움
assert got[7]["덮음"] is None # 모두 걷음 = 문서 칸 없음
assert got[7]["출처"][A] == {"값.가격": "위"} # ① 고친 칸만 주황