Files
Aislo/A00_Common/line_stack_machine_ctl.ts
T
eomsangdonandClaude Opus 5.5 d9e96743e6 feat(848-8): 848-4 부착 줄 화면 — 수량 읽기 「주 기계 줄 따름」 · 제어 구역 값 칸만 · 펼친 풀이 0 비목 줄 안 그림
- 부착 줄(금액 줄 `부착: true`) = 계산기 `hostOf` 로 따르는 주 기계 줄을 찾아(`attachHost`) 수량 칸을 잠근 글로
- 기계 제어 구역 = 값 칸 + 작업량 자리에 따름 글(방식 고르기 · 조종원 · 잡품 없음)
- 산출근거 펼친 풀이(깊이 1 이상) 합계 = 0 인 비목 줄 뺌(부착 손료만 문서의 빈 노무비 · 재료비 줄)
- 시험 test_848_8_diff ⑤ 부착 줄 주 기계 줄(GC001070) · test_839_1 낡은 수 고침 — 848-4 가 조합 주 기계 식 GC001202 를 더해 기계경비식 16 → 17 문서(기호 이름 · 겹침 검사는 그대로 통과)

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-16 23:57:03 +09:00

410 lines
18 KiB
TypeScript

/* =============================================================================
* line_stack_machine_ctl.ts
* 줄 쌓기 기계 제어 구역(PLAN 836-1 · 요구 846 · 849 · 850 · 853) — 왼쪽 기계 줄 아래 접는 구역
* ㉠ 값 칸 = 그 기계 식이 읽는 기계 칸(단위 · 기본 = 사본 값 · 고친 칸 = 「고침」 + [원래 값])
* ㉡ 조종원 = 인력 줄(노임 고르기 · 인/일 · 더하기 · 빼기 · 기본 = 기계 값 조종원 · 직종)
* ㉢ 잡품 = 재료 줄(재료 · 유가 고르기 · 수량 · 율 % · 기본 = 밑 재료 줄 · 품셈 잡재료율)
* ㉣ 시간당 작업량(846-2 · 맨 위) = 일당 / 시간당 식 고르기 · 시간당 변수 칸(`line_stack_machine_work`)
* 굳은 기계(847-1) = 값 · 조종원 · 잡품은 그 기계 것(덮음 열쇠 = 그 기계) · 작업량 덮음은 줄 기계 열쇠(`lineCall`)
* 고침 = 문서 칸 `기계덮음`(캐시 · [저장] 때 서버가 정본으로 다시 셈) · 원본과 같으면 지움(`putCover`)
* 기본값 = 덮음 없이 셈한 그 기계 식 답 + 기계 줄 인력 · 잡품 목록(`defaultsOf` · `rowEntry` · 842-3) ·
* 읽기(M01 기초) = 칸 잠김 · 단추 없음
* 기계 보기(840-2 `line_stack_machine_sheet` · M01 기계 상세 · 내 기계) = 같은 구역(인력 · 잡품 여러 줄 · 842-3) ·
* `lock` = 잠긴 값 칸(품셈 방식 계수 등)
* 층(848-3 · 요구 889) — SK = ① 위 층 고침(`upper` = 읽기 답 `위덮음`) 위에 ② 내 고침 · 기본(원래 값) = `upperOf(정본 기본, ①)` ·
* 고침 = `putCover(…, ①)`(위 층과 같은 칸 지움) · 칸 테두리 = 출처(`sourcesOf` — 나 = 파랑 · 위 = 주황 · 부품 `setUiDiff`) ·
* 「고침」 글 배지 없음(테두리로) · 칸 풍선 = 원래 값 · M01 기초(시스템 관리자) = ① 없음 → 기초 고침 = 「나」
* ========================================================================== */
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";
import { varId, type FormulaDoc, type Link } from "../common_util/common_util_formula_doc";
import { WORK, workKey, type WorkCover } from "../common_util/common_util_formula_doc_work";
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";
import { machineUnit } from "../common_util/common_util_line_stack_unit";
import { attachHost, workAt, workOfMachine } from "../common_util/common_util_line_stack_work";
import { sites, type WorkSpec } from "../common_util/common_util_formula_doc_work";
import { machineCellName } from "../common_util/common_util_machine_symbol_name";
import { openFindPicker } from "../M02_MasterTemplete/M02_MasterTemplete_Find_Pick";
import { buildWorkGroup, putWork } from "./line_stack_machine_work";
import { openStackPick } from "./line_stack_pick";
import { lt } from "./line_stack_text";
export interface CtlHooks {
doc: StackDoc;
answer: DocAnswer;
subDoc: (key: string) => FormulaDoc | null;
/** 덮음 없이 그 기계 식 셈(원본 = 기본값) */
calc: (doc: FormulaDoc, given: Record<string, unknown>) => DocAnswer;
change: (fn: (d: StackDoc) => void) => void;
name: (key: string) => string;
/** 읽기(M01 기초 · 칸 잠김) */
readOnly: boolean;
/** 그 기계 줄 값(인력 · 잡품 목록 — 기본값 바탕 · 842-3) */
lists?: (given: Record<string, unknown>) => Record<string, unknown> | null;
/** 잠긴 값 칸 */
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 own = ["ui-input", "ui-select", "ui-btn"].some((c) => box.classList.contains(c));
const nodes = own ? [box] : ["ui-input", "ui-select", "lstk-res"].flatMap((c) => [...box.querySelectorAll<HTMLElement>(`.${c}`)]); // 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 = ["경유", "휘발유", "실내등유"];
/** 그 기계 줄 부름 — 입력 · 기계 식 문서 · 작업량 덮음 열쇠(줄 기계) · 굳은 기계(847-1)면 입력 기계 = 그 기계 */
export function lineCall(
doc: FormulaDoc,
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 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 };
}
/** 그 기계 줄의 기계 열쇠 · 식 · 원본 기본값 — 기계 식이 아니면 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, 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));
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 => {
const n = Number(t.trim().replace(/,/g, ""));
return t.trim() !== "" && Number.isFinite(n) ? n : null;
};
/** 수 칸 — 빈 글 = 원래대로(null) · 음수 · 글 = 알림 · 단위 = 칸 바로 뒤(공식 묶음 값 칸과 같은 자리 · 845-2 ㉥) */
export function numBox(
label: string,
value: unknown,
unit: string,
ro: boolean,
set: (n: number | null) => void,
hint = "",
): HTMLElement {
const f = createInputField({
value: value === undefined || value === null ? "" : String(value),
placeholder: hint,
compact: true,
size: 24,
});
f.root.classList.add("lstk-f-s");
f.input.setAttribute("aria-label", label);
f.input.title = label;
f.input.disabled = ro;
f.input.addEventListener("change", () => {
const t = f.input.value;
const n = num(t);
if (t.trim() === "") return set(null);
if (n === null || n < 0) {
f.input.value = value === undefined || value === null ? "" : String(value);
return void showToast(lt("Ctl_Bad"), "warning");
}
set(n);
});
return unit
? el("span", { className: "lstk-qty", children: [f.root, el("span", { className: "lstk-unit", text: unit })] }) // prettier-ignore
: f.root;
}
const kind = (text: string): HTMLElement => el("span", { className: "lstk-kind", text });
/** 기계 제어 구역 — `link` = 그 기계 줄 단가 기호 연결 · `at` = 그 금액 줄 차례(작업량) */
export function buildMachineCtl(
h: CtlHooks,
link: Link | undefined,
at?: number,
): HTMLElement | null {
const got = ctlOf(h, link, at);
if (!got) return null;
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, up));
const parts = partsOf(sub);
const lines = sub.금액 ?? [];
// ㉠ 값 칸
const values = parts.fields.map(({ 칸: col }) => {
const was = top.값[col];
const mine = entry.값?.[col];
const now = mine ?? was;
const shut = ro || !!h.lock?.includes(col);
const setVal = (v: number | string | null): void => {
const 값 = { ...(entry.값 ?? {}) };
if (v === null || v === "") delete 값[col];
else 값[col] = v;
put({ ...entry, 값 });
};
const box =
col === "주연료종류"
? createSelectField({
options: [...new Set([...FUELS, String(now ?? "")])]
.filter(Boolean)
.map((x) => ({ value: x, text: x })),
value: String(now ?? ""),
compact: true,
size: 24,
disabled: shut,
ariaLabel: col,
onChange: (x) => setVal(x),
}).root
: numBox(col, now, machineUnit(col), shut, setVal); // 845-2 기계 표 칸 단위 한 벌
const row = el("div", {
className: "lstk-frow",
children: [
el("b", { className: "lstk-sym", text: machineCellName(col), attrs: { title: col } }),
"=",
box,
],
});
if (mine !== undefined) {
if (!shut)
row.append(
createButton({
label: lt("Ctl_Back"),
variant: "ghost",
size: 24,
iconStart: "undo",
onClick: () => setVal(null),
}),
);
}
markDiff(box, diffOf(src[`값.${col}`]), was === undefined ? "—" : eqText(was));
row.dataset.mctlField = col;
return row;
});
// ㉡ 조종원 — 인력 줄
const crew: CrewRow[] = entry.조종원 ?? top.조종원;
const setCrew = (rows: CrewRow[]): void => put({ ...entry, 조종원: rows });
const crewName = (r: CrewRow, i: number): string => {
if (r.이름) return r.이름;
const at = parts.crew[i] ?? parts.crew[0];
const sym = at === undefined ? "" : String(lines[at]?.단가 ?? "");
const v = (sub.변수 ?? []).find((x) => varId(x) === sym);
return (v?.이름 ?? "").replace(/노임$/, "") || h.name(r.키) || r.키;
};
const crewRows = crew.map((r, i) =>
lineRow(
lt("K_인력"),
crewName(r, i),
ro,
() => openStackPick("인력", (p) => setCrew(swapAt(crew, i, { ...r, 키: p.키, 이름: p.이름 })), undefined, crewName(r, i)), // prettier-ignore
[numBox(lt("Ctl_Crew_Qty"), r.인, lt("Ctl_Per_Day"), ro, (n) => setCrew(swapAt(crew, i, { ...r, 인: n ?? 0 })))], // prettier-ignore
"노무비",
() => setCrew(crew.filter((_, k) => k !== i)),
),
);
// ㉢ 잡품 — 재료 줄
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.줄);
const q = b?.수량 ? (vals[String(b.수량)] ?? Number(b.수량)) : null;
return typeof q === "number" && Number.isFinite(q) ? q : null;
};
const miscName = (r: MiscRow): string => {
if (r.이름) return r.이름;
if (r.키) return h.name(r.키) || r.키;
const fuel = r.줄 === "주연료" ? vals.S_연료 : undefined;
return [r.줄, fuel].filter(Boolean).join(" · ");
};
const pickMat = (done: (p: Picked) => void, query: string): void =>
openFindPicker({
layer: "system",
owner: null,
title: `${lt("Find_Title")} — ${lt("Ctl_Misc")}`,
kinds: ["material", "oil"],
query: query || undefined,
element: (e) => done({ 키: e.코드, 이름: e.이름, 단위: e.단위, ...(e.규격 ? { 규격: e.규격 } : {}) }), // prettier-ignore
oil: (e) => done({ 키: e.코드, 이름: e.이름, 단위: e.단위 }),
logic: () => undefined,
});
const asMat = (r: MiscRow, p: Picked): MiscRow => ({
키: p.키,
이름: [p.이름, p.규격].filter(Boolean).join(" "),
...(p.단위 ? { 단위: p.단위 } : {}),
수량: r.수량 ?? baseQty(r) ?? 1,
율: r.율,
});
const miscRows = misc.map((r, i) =>
lineRow(
lt("K_재료"),
miscName(r),
ro,
() => pickMat((p) => setMisc(swapAt(misc, i, asMat(r, p))), r.키 ? miscName(r) : ""),
[
numBox(lt("Qty"), r.수량, r.단위 ?? "", ro, (n) => {
const { 수량: _, ...rest } = r;
setMisc(swapAt(misc, i, n === null ? rest : { ...r, 수량: n }));
}, r.줄 && r.수량 === undefined ? `${baseQty(r) ?? ""} ${lt("Ctl_Follow")}` : ""), // prettier-ignore
numBox(lt("Ctl_Rate"), r.율, "%", ro, (n) =>
setMisc(swapAt(misc, i, { ...r, 율: n ?? 0 })),
),
],
"재료비",
() => setMisc(misc.filter((_, k) => k !== i)),
),
);
// 인력 · 잡품 = 목록 통째 한 칸(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 }),
...(ro
? []
: [
...(add ? [createIconButton({ icon: "plus", title: `${label} ${lt("Ctl_Add")}`, size: 24, onClick: add })] : []), // prettier-ignore
...(covered
? [createButton({ label: lt("Ctl_Back"), variant: "ghost", size: 24, iconStart: "undo", onClick: reset })] // prettier-ignore
: []),
]),
],
});
// ㉣ 시간당 작업량(846-2) — 덮음 열쇠 = 줄 기계(굳은 기계면 값 칸 열쇠와 다름 · 847-1)
const info = (at === undefined ? null : workAt(h.answer, at)) ?? workOfMachine(h.answer, machine);
const wkey = info ? workKey(layeredCover(h.doc, h.upper), info) : machine;
const upWork = (h.upper?.[wkey] as CoverEntry | undefined)?.작업량 ?? null;
const host = at === undefined ? null : attachHost(h.doc, at); // 848-4 부착 줄 = 값 칸만 + 따름 글
const work =
host !== null
? [el("div", { className: "lstk-fhead", children: [kind(lt("Work_Head"))] }), el("div", { className: "lstk-hint", text: `${lt("Follow_Host")} — ${host}`, attrs: { "data-mctl-follow": "", title: lt("Follow_Note") } })] // prettier-ignore
: 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, wb) => h.change((d) => putWork(d, wkey, w, upWork, wb)),
})
: [];
const box = el("div", {
className: "lstk-mctl lstk-wide",
attrs: { "data-mctl": machine },
children: [
...work,
...(values.length
? [el("div", { className: "lstk-fhead", children: [kind(lt("Ctl_Values"))] }), ...values]
: []),
...(host !== null
? []
: [
head(
lt("Ctl_Crew"),
entry.조종원 !== undefined,
() =>
openStackPick("인력", (p) => setCrew([...crew, { 키: p.키, 이름: p.이름, 인: 1 }])),
() => put({ ...entry, 조종원: undefined }),
),
...(crewRows.length ? crewRows : [el("div", { className: "lstk-empty", text: lt("Ctl_None") })]), // prettier-ignore
head(
lt("Ctl_Misc"),
entry.잡품 !== undefined,
() => pickMat((p) => setMisc([...misc, asMat({ 율: 100 }, p)]), ""),
() => put({ ...entry, 잡품: undefined }),
),
...(miscRows.length ? miscRows : [el("div", { className: "lstk-empty", text: lt("Ctl_None") })]), // prettier-ignore
]),
],
});
return box;
}
const swapAt = <T>(rows: T[], i: number, one: T): T[] => rows.map((r, k) => (k === i ? one : r));
/** 줄 꼴(단가산출 줄과 닮음) — [종류][이름 단추][칸들][비목][X] */
function lineRow(
label: string,
name: string,
ro: boolean,
pick: () => void,
boxes: HTMLElement[],
cost: string,
drop: () => void,
): HTMLElement {
const b = createButton({
label: name || "—",
variant: "ghost",
tone: "link",
size: 24,
iconStart: "search",
disabled: ro,
onClick: pick,
});
b.classList.add("lstk-res");
b.title = `${lt("Repick")} — ${name}`;
return el("div", {
className: "lstk-line k-ctl",
children: [
kind(label),
b,
...boxes,
el("span", { className: "lstk-hint", text: cost }),
...(ro ? [] : [createIconButton({ icon: "x", title: lt("Del"), size: 24, onClick: drop })]),
],
});
}