feat(m01-sl): 시트 로직 Model · Eval 속 채움 · 시험

- 상자 더하기(종류별 틀 시트 · 칸 A 이름 · B 값 · C 설명) · 지우기 · 같은 이름은 「 (2)」 - 선 잇기 = 받는 입력 알약 칸에 「'시트'!칸」 참조 수식(여러 선은 +) · 끊기 = 그 참조 뺌 · 순환 · 같은 상자 · 두 번 · 없는 알약은 막고 까닭 - 알약 정하기 · 빼기(이름 · 칸이 바뀌면 선이 따라감) - 바깥 값 칸 목록 · 넣기(표는 칸 덩어리) · 화면 계산 = 우리 스프레드시트 엔진 recalcWorkbook · 결과 노무비 · 재료비 · 경비 · 계 - 검사: 빈 입력 알약 · 안 받은 바깥 값 · 결과 상자 없음 / 선 없음 · 오류 칸 · 순환(#CYCLE!) - 시험 resources/tester/test_m01_sl_model.py 10개(엔진 그대로 Node) Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01VBToTCGk5dqDKeXCEP3vhk
2026-10-01 13:04:15 +09:00
parent ddaff8a6b8
commit 67e4c27658
3 changed files with 728 additions and 44 deletions
@@ -1,11 +1,15 @@
 /* =============================================================================
 * M01_SL_Model.ts
 * 시트 로직 Model — 로직 한 벌 = 통합문서 하나 · 상자 하나 = 시트 하나 · 알약 = 이름 붙은 칸
- * 선 = 받는 입력 알약 칸에 「'시트 이름'!칸」 참조 수식 · DOM 없음
+ * 선 = 받는 입력 알약 칸에 「'시트 이름'!칸」 참조 수식(여러 선이면 「+」 로 이음) · DOM 없음
 * 모양은 `docs/raw/M01_쉬운단가/시트로직_정함.md` 정함 1~5 그대로
+ *
+ * 모든 함수는 새 시트 로직을 돌려줌(받은 것은 안 바꿈) · 엔진(A00_Common/spreadsheet)은 가져다 쓰기만
 * ========================================================================== */

-import type { Workbook } from "../../A00_Common/spreadsheet/spreadsheet_types";
+import { currentLanguageIndex } from "@ui/ui_template_locale";
+import { quoteSheet } from "../../A00_Common/spreadsheet/spreadsheet_address";
+import type { Cell, Sheet, Workbook } from "../../A00_Common/spreadsheet/spreadsheet_types";

 /** 상자 종류 — 입력값 · 고정값 · 표 · 계산 · 항목 · 다른 로직 · 결과 */
 export type SlKind = "input" | "const" | "table" | "calc" | "item" | "logic" | "result";
@@ -73,61 +77,361 @@ export interface SlEnd {
  pill: string;
 }

-const notReady = (): never => {
-  throw new Error("준비 중");
+const TEXT = {
+  Name: ["이름", "Name"],
+  Value: ["값", "Value"],
+  Note: ["설명", "Note"],
+  Sample: ["예시값", "Sample value"],
+  Fixed: ["늘 이 값", "Always this value"],
+  Cond: ["조건", "Condition"],
+  Found: ["결과", "Result"],
+  FromTable: ["표에서 찾은 값", "Value found in the table"],
+  ValueA: ["값1", "Value 1"],
+  ValueB: ["값2", "Value 2"],
+  Times: ["값1 × 값2", "Value 1 × Value 2"],
+  Qty: ["수량", "Quantity"],
+  Price: ["단가", "Unit price"],
+  Amount: ["금액", "Amount"],
+  QtyNote: ["선으로 받음", "Comes in by a line"],
+  PriceNote: ["바깥 값 — 열 때 넣음", "Outside value — filled on open"],
+  LogicNote: ["다른 로직 결과 — 열 때 넣음", "Other logic's result — filled on open"],
+  Sum: ["계", "Total"],
+  NoPill: ["알약이 없음", "No such pill"],
+  Self: ["같은 상자끼리는 못 이음", "A box can't link to itself"],
+  Loop: ["이으면 돌고 도는 선이 됨", "This line would make a loop"],
+  Twice: ["이미 이어져 있음", "Already linked"],
+} as const;
+
+const tl = (key: keyof typeof TEXT): string => TEXT[key][currentLanguageIndex === 1 ? 1 : 0];
+
+/** 비목 이름(결과 · 항목 칸) — 화면 글 아님 · 알약 이름 열쇠 */
+const COSTS = ["노무비", "재료비", "경비"] as const;
+
+/* ── 작은 도움 ──────────────────────────────────────────────────────────── */
+
+const STAGE: Record<SlKind, number> = {
+  input: 0,
+  const: 0,
+  table: 1,
+  logic: 1,
+  calc: 2,
+  item: 3,
+  result: 4,
 };

+const clone = <T>(v: T): T => structuredClone(v);
+
+/** 다음 번호 — 있는 id 들(「n3」)보다 하나 큰 것 */
+function nextId(prefix: string, ids: string[]): string {
+  const nums = ids
+    .filter((x) => x.startsWith(prefix))
+    .map((x) => Number(x.slice(prefix.length)))
+    .filter((n) => Number.isInteger(n));
+  return `${prefix}${Math.max(0, ...nums) + 1}`;
+}
+
+/** 시트 이름 — 통합문서 안에서 하나(같으면 「 (2)」) */
+function uniqueName(book: Workbook, name: string): string {
+  const base = name.trim() || "상자";
+  const used = new Set(book.시트.map((s) => s.이름));
+  if (!used.has(base)) return base;
+  for (let n = 2; ; n++) if (!used.has(`${base} (${n})`)) return `${base} (${n})`;
+}
+
+const sheetOf = (sl: SheetLogic, node: SlNode): Sheet => {
+  const sheet = sl.workbook.시트.find((s) => s.id === node.sheetId);
+  if (!sheet) throw new Error(`없는 시트 ${node.sheetId}`);
+  return sheet;
+};
+
+const nodeOf = (sl: SheetLogic, id: string): SlNode | undefined =>
+  sl.nodes.find((n) => n.id === id);
+
+const pillOf = (node: SlNode, dir: "in" | "out", name: string): SlPill | undefined =>
+  (dir === "in" ? node.pillsIn : node.pillsOut).find((p) => p.name === name);
+
+/* ── 상자 틀 ─────────────────────────────────────────────────────────────── */
+
+type Row = [string, Cell | null, string];
+
+/** 종류별 틀 — 1행 머리(이름 · 값 · 설명) · 2행부터 알약 줄 */
+function template(kind: SlKind, name: string): { rows: Row[]; ins: SlPill[]; outs: SlPill[] } {
+  const v = (값: number | string): Cell => ({ 값 });
+  const f = (식: string): Cell => ({ 식 });
+  switch (kind) {
+    case "input":
+      return { rows: [[name, v(0), tl("Sample")]], ins: [], outs: [{ name, cell: "B2" }] };
+    case "const":
+      return { rows: [[name, v(0), tl("Fixed")]], ins: [], outs: [{ name, cell: "B2" }] };
+    case "table":
+      return {
+        rows: [
+          [tl("Cond"), null, tl("QtyNote")],
+          [tl("Found"), null, tl("FromTable")],
+        ],
+        ins: [{ name: tl("Cond"), cell: "B2" }],
+        outs: [{ name: tl("Found"), cell: "B3" }],
+      };
+    case "calc":
+      return {
+        rows: [
+          [tl("ValueA"), null, tl("QtyNote")],
+          [tl("ValueB"), null, tl("QtyNote")],
+          [tl("Found"), f("B2*B3"), tl("Times")],
+        ],
+        ins: [
+          { name: tl("ValueA"), cell: "B2" },
+          { name: tl("ValueB"), cell: "B3" },
+        ],
+        outs: [{ name: tl("Found"), cell: "B4" }],
+      };
+    case "item":
+      return {
+        rows: [
+          [tl("Qty"), null, tl("QtyNote")],
+          [tl("Price"), null, tl("PriceNote")],
+          [tl("Amount"), f("B2*B3"), ""],
+          ["노무비", f("B4"), ""],
+          ["재료비", v(0), ""],
+          ["경비", v(0), ""],
+        ],
+        ins: [
+          { name: tl("Qty"), cell: "B2" },
+          { name: tl("Price"), cell: "B3", outside: true },
+        ],
+        outs: [
+          { name: tl("Amount"), cell: "B4" },
+          ...COSTS.map((c, i) => ({ name: c, cell: `B${5 + i}` })),
+        ],
+      };
+    case "logic":
+      return {
+        rows: [[tl("Found"), null, tl("LogicNote")]],
+        ins: [],
+        outs: [{ name: tl("Found"), cell: "B2", outside: true }],
+      };
+    case "result":
+      return {
+        rows: [
+          ["노무비", null, tl("QtyNote")],
+          ["재료비", null, tl("QtyNote")],
+          ["경비", null, tl("QtyNote")],
+          [tl("Sum"), f("SUM(B2:B4)"), ""],
+        ],
+        ins: COSTS.map((c, i) => ({ name: c, cell: `B${2 + i}` })),
+        outs: [{ name: "계", cell: "B5" }],
+      };
+  }
+}
+
+/* ── 만들기 · 상자 ───────────────────────────────────────────────────────── */
+
 /** 빈 시트 로직 */
-export function newLogic(_name?: string, _resultUnit?: string): SheetLogic {
-  return notReady();
+export function newLogic(name = "", resultUnit = "원/㎡"): SheetLogic {
+  return {
+    key: null,
+    name,
+    resultUnit,
+    workbook: { 종류: "통합문서", 판: 1, 열: "SL", 서식: [{}], 시트: [] },
+    nodes: [],
+    edges: [],
+  };
 }

 /** 상자 더하기 — 그 종류 틀(칸 A 이름 · B 값 · C 설명)로 시트를 만듦 */
 export function addNode(
-  _sl: SheetLogic,
-  _kind: SlKind,
-  _name: string,
+  sl: SheetLogic,
+  kind: SlKind,
+  name: string,
 ): { sl: SheetLogic; node: SlNode } {
-  return notReady();
+  const out = clone(sl);
+  const book = out.workbook;
+  const sheetId = nextId(
+    "s",
+    book.시트.map((s) => s.id),
+  );
+  const title = uniqueName(book, name);
+  const t = template(kind, title);
+  const 칸: Record<string, Cell> = {
+    A1: { 값: tl("Name") },
+    B1: { 값: tl("Value") },
+    C1: { 값: tl("Note") },
+  };
+  t.rows.forEach(([label, cell, note], i) => {
+    칸[`A${i + 2}`] = { 값: label };
+    if (cell) 칸[`B${i + 2}`] = cell;
+    if (note) 칸[`C${i + 2}`] = { 값: note };
+  });
+  book.시트.push({ id: sheetId, 이름: title, 칸 });
+  book.활성 ??= sheetId;
+  const node: SlNode = {
+    id: nextId(
+      "n",
+      out.nodes.map((n) => n.id),
+    ),
+    kind,
+    name: title,
+    sheetId,
+    pillsIn: t.ins,
+    pillsOut: t.outs,
+    stage: STAGE[kind],
+  };
+  out.nodes.push(node);
+  return { sl: out, node };
 }

 /** 상자 지우기 — 시트 · 이어진 선 · 받던 참조 수식을 함께 지움 */
-export function removeNode(_sl: SheetLogic, _node: string): SheetLogic {
-  return notReady();
+export function removeNode(sl: SheetLogic, id: string): SheetLogic {
+  const node = nodeOf(sl, id);
+  if (!node) return sl;
+  let out = sl;
+  for (const e of sl.edges.filter((x) => x.from.node === id || x.to.node === id))
+    out = disconnect(out, e.id);
+  out = clone(out);
+  out.nodes = out.nodes.filter((n) => n.id !== id);
+  out.workbook.시트 = out.workbook.시트.filter((s) => s.id !== node.sheetId);
+  if (out.workbook.활성 === node.sheetId) out.workbook.활성 = out.workbook.시트[0]?.id;
+  return out;
+}
+
+/* ── 선 ─────────────────────────────────────────────────────────────────── */
+
+/** 받는 알약 칸 수식 = 그 알약으로 오는 선들의 참조를 「+」 로 · 선이 없으면 칸을 비움 */
+function rewriteTarget(sl: SheetLogic, to: SlEnd): void {
+  const node = nodeOf(sl, to.node);
+  const pill = node && pillOf(node, "in", to.pill);
+  if (!node || !pill) return;
+  const refs = sl.edges
+    .filter((e) => e.to.node === to.node && e.to.pill === to.pill)
+    .map((e) => {
+      const src = nodeOf(sl, e.from.node);
+      const out = src && pillOf(src, "out", e.from.pill);
+      return src && out ? `${quoteSheet(sheetOf(sl, src).이름)}!${out.cell}` : null;
+    })
+    .filter((x): x is string => x !== null);
+  const sheet = sheetOf(sl, node);
+  const keepStyle = sheet.칸[pill.cell]?.서식;
+  if (refs.length)
+    sheet.칸[pill.cell] = { 식: refs.join("+"), ...(keepStyle ? { 서식: keepStyle } : {}) };
+  else if (keepStyle) sheet.칸[pill.cell] = { 서식: keepStyle };
+  else delete sheet.칸[pill.cell];
+}
+
+/** from 상자에서 선을 따라 to 상자에 닿나 */
+function reaches(sl: SheetLogic, from: string, to: string): boolean {
+  const seen = new Set<string>();
+  const walk = (id: string): boolean => {
+    if (id === to) return true;
+    if (seen.has(id)) return false;
+    seen.add(id);
+    return sl.edges.filter((e) => e.from.node === id).some((e) => walk(e.to.node));
+  };
+  return walk(from);
 }

 /** 선 잇기 — 받는 알약 칸에 참조 수식 · 순환 · 없는 알약이면 막고 까닭(쉬운 말) */
 export function connect(
-  _sl: SheetLogic,
-  _from: SlEnd,
-  _to: SlEnd,
+  sl: SheetLogic,
+  from: SlEnd,
+  to: SlEnd,
 ): { sl: SheetLogic; why: string | null } {
-  return notReady();
+  const a = nodeOf(sl, from.node);
+  const b = nodeOf(sl, to.node);
+  if (!a || !b || !pillOf(a, "out", from.pill) || !pillOf(b, "in", to.pill))
+    return { sl, why: tl("NoPill") };
+  if (a.id === b.id) return { sl, why: tl("Self") };
+  const same = (e: SlEdge): boolean =>
+    e.from.node === from.node &&
+    e.from.pill === from.pill &&
+    e.to.node === to.node &&
+    e.to.pill === to.pill;
+  if (sl.edges.some(same)) return { sl, why: tl("Twice") };
+  if (reaches(sl, b.id, a.id)) return { sl, why: tl("Loop") };
+  const out = clone(sl);
+  out.edges.push({
+    id: nextId(
+      "e",
+      out.edges.map((e) => e.id),
+    ),
+    from: { ...from },
+    to: { ...to },
+  });
+  rewriteTarget(out, to);
+  return { sl: out, why: null };
 }

 /** 선 끊기 — 그 참조를 받는 칸 수식에서 뺌 */
-export function disconnect(_sl: SheetLogic, _edge: string): SheetLogic {
-  return notReady();
+export function disconnect(sl: SheetLogic, edgeId: string): SheetLogic {
+  const edge = sl.edges.find((e) => e.id === edgeId);
+  if (!edge) return sl;
+  const out = clone(sl);
+  out.edges = out.edges.filter((e) => e.id !== edgeId);
+  rewriteTarget(out, edge.to);
+  return out;
 }

-/** 알약 정하기 — 같은 칸이나 같은 이름이 있으면 바꿈 */
+/* ── 알약 ───────────────────────────────────────────────────────────────── */
+
+/** 알약 정하기 — 같은 칸이나 같은 이름이 있으면 바꿈(이름이 바뀌면 이어진 선도 따라감) */
 export function setPill(
-  _sl: SheetLogic,
-  _node: string,
-  _cell: string,
-  _dir: "in" | "out",
-  _name: string,
-  _extra?: Pick<SlPill, "unit" | "outside">,
+  sl: SheetLogic,
+  nodeId: string,
+  cell: string,
+  dir: "in" | "out",
+  name: string,
+  extra: Pick<SlPill, "unit" | "outside"> = {},
 ): SheetLogic {
-  return notReady();
+  const out = clone(sl);
+  const node = nodeOf(out, nodeId);
+  if (!node) return sl;
+  const list = dir === "in" ? node.pillsIn : node.pillsOut;
+  const at = list.findIndex((p) => p.cell === cell || p.name === name);
+  const pill: SlPill = { name, cell: cell.toUpperCase(), ...extra };
+  if (at < 0) {
+    list.push(pill);
+    return out;
+  }
+  const old = list[at];
+  list[at] = pill;
+  for (const e of out.edges) {
+    const end = dir === "in" ? e.to : e.from;
+    if (end.node === nodeId && end.pill === old.name) end.pill = name;
+  }
+  // 칸이 바뀌면 선이 가리키던 칸도 새로 씀
+  if (old.cell !== pill.cell) {
+    const linked = out.edges.some((e) => e.to.node === nodeId && e.to.pill === name);
+    if (dir === "in" && linked) {
+      delete sheetOf(out, node).칸[old.cell];
+      rewriteTarget(out, { node: nodeId, pill: name });
+    } else if (dir === "out")
+      for (const e of out.edges.filter((x) => x.from.node === nodeId && x.from.pill === name))
+        rewriteTarget(out, e.to);
+  }
+  return out;
 }

 /** 알약 빼기 — 이어진 선도 끊음 */
 export function removePill(
-  _sl: SheetLogic,
-  _node: string,
-  _dir: "in" | "out",
-  _name: string,
+  sl: SheetLogic,
+  nodeId: string,
+  dir: "in" | "out",
+  name: string,
 ): SheetLogic {
-  return notReady();
+  let out = sl;
+  for (const e of sl.edges) {
+    const end = dir === "in" ? e.to : e.from;
+    if (end.node === nodeId && end.pill === name) out = disconnect(out, e.id);
+  }
+  out = clone(out);
+  const node = nodeOf(out, nodeId);
+  if (!node) return out;
+  if (dir === "in") node.pillsIn = node.pillsIn.filter((p) => p.name !== name);
+  else node.pillsOut = node.pillsOut.filter((p) => p.name !== name);
+  return out;
+}
+
+/** 상자 · 시트 찾기(Eval · 화면이 씀) */
+export function nodeSheet(sl: SheetLogic, nodeId: string): Sheet | null {
+  const node = nodeOf(sl, nodeId);
+  return node ? sheetOf(sl, node) : null;
 }