/* ============================================================================= * common_util_formula_doc_work.ts * 기계 줄 시간당 작업량(PLAN 846-1 · 요구 881 · 882 · 883) — 기계 줄 수량을 「1 ÷ 시간당 작업량」 으로 읽고 * 단가산출 덮음으로 그 기계의 작업량 식(시간당 방식)으로 바꿔 셈. * 읽기(`sites`) — 기계 줄 수량 식의 시간당 작업량 자리(저장 식 글은 안 바꿈 · 만약 갈래 안도 찾음): * 일당 = 곱 · 나눔 줄에 8 과 나눔 하나(시공량 D) → 시간당 작업량 = D ÷ (8 × 대수) * (대수 = 곱의 다른 변수 — 단위 % · `r_` 율은 곱에 남김) * 식 = 나눔으로만 쓰는 변수 · 단위 「…/hr」(작업량 식 부품 · 표 값 · 빈 단위 = 정의 식에서 짐작) * 기계 값 칸 `작업량` = [{식: 작업량 틀 키, 단위, 변수: {기계 규격에서 정해지는 칸}}](빌더 build_기계_작업량_846_1.py) * 덮음 = `기계덮음` 기계 칸 `작업량: {방식: '시간당', 식, 변수?}` — 그 기계 줄의 작업량 자리를 `1 ÷ Q` 로 바꿈 * (Q = 그 식을 식 문서 기본 › 기계 변수 › 덮음 변수로 셈) · 다른 곱(율 등) 그대로 · 못 함 = 그 줄 멈춤(까닭) * 부착 기계(브레이커 · 집게 입력) 줄 = 그 부착 기계 열쇠(굴착기 줄과 따로) * 덮음 열쇠(847-1) = 그 줄 단가 기호(옵션이 기계를 바꿔도 같은 줄) › 기계 열쇠(846-1 옛 꼴) * 굳은 기계(847-1 · 요구 885) = 덮음 `기계`(시간당으로 바꿀 때 그 줄 기계 · 기계 창으로 바꾼 기계) — 그 줄 단가를 * 그 기계(`키` = 기계 식 문서가 다를 때)로 다시 부르고 작업량 식 · 변수도 그 기계 것(옵션이 정하던 기계를 안 읽음) · * `이름` = 화면 이름만 · 부착 기계 줄 = 굳힘 없음 * 부착 줄(848-4 · 금액 줄 칸 `부착: true`) = 같은 묶음 앞쪽 주 기계 줄의 수량을 그대로 씀(품셈 일당 · 시간당 식 * 모두 · 그 줄 작업량 덮음은 안 읽음) · 답 칸 꼴 = 주 줄 꼴 + `따름` {기호, 이름, 꼴} · 끝수 = 묶음 한 덩이(계산기) * 셈 답 기계 줄 칸 `작업량` = {기계, 꼴(일당 · 식 · 시간당), 율, 값, 단위, 식들, 변수?, 까닭?}(산출근거 자료) * 파이썬 · TS 짝 — 짝 = resources/master_data/scripts/master_doc_work.py · 거울 시험 test_846_1_machine_work.py * · 계산기(`common_util_formula_doc_calc.ts` money)가 줄마다 `lineWork` 를 부름 · 화면 · DOM · fetch 없음 * ========================================================================== */ import { names, parse, textOf, varId, walk, type DocVar, type FormulaDoc, type Mark, type Node, } from "./common_util_formula_doc"; import type { Cover } from "./common_util_formula_doc_cover"; export const WORK = "작업량"; export const HOURLY = "시간당"; export const DAILY = "일당"; export const Q_NEW = "Q_시간당작업량"; // 셈 범위 이름(문서 기호 아님) export const NOT_MACHINE = ["지역", "보정작업", "조종원직종", "계약종별"]; // 기계 식 입력 가운데 기계 아닌 것 /** 기계 값 칸 `작업량` 한 줄 */ export interface WorkSpec { 식: string; 단위?: string; 변수?: Record; } /** 덮음 `작업량` */ export interface WorkCover { 방식: string; 식?: string; 변수?: Record; /** 굳은 기계 입력 글(따옴표 뗌) */ 기계?: string; /** 굳은 기계의 기계 식 문서(줄 연결과 다를 때만) */ 키?: string; /** 화면 이름(셈 안 봄) */ 이름?: string; } const FIXED = ["기계", "키", "이름"] as const; export const ATTACH = "부착"; // 848-4 금액 줄 칸 export const FOLLOW = "따름"; // 848-4 부착 줄 답 칸(꼴 = 주 줄 꼴) /** 셈 답 기계 줄 `작업량` */ export interface WorkInfo { 기계: string; /** 그 줄 단가 기호(847-1 덮음 열쇠) */ 기호?: string; 꼴: string; 율: string; 값: number | null; 단위: string; 식들: string[]; 변수?: Record; 까닭?: string; /** 굳은 기계(덮음 `기계`) */ 고정?: string; /** 848-4 부착 줄 — 따르는 주 기계 줄 */ 따름?: { 기호: string; 이름: string; 꼴: string }; } interface Site { 꼴: string; 노드: Node; 단위: string; 율: string; 뺌?: Set; } type Fac = [number, Node]; export const normUnit = (u: unknown): string => String(u ?? "") .trim() .replace(/[mM]3/g, "㎥") // 848-6 대문자 꼴 .replace(/[mM]2/g, "㎡") .replace(/(? s.toLowerCase()) .replace(/톤(?=\/)/g, "ton") // 848-7 「톤/hr」 = 우리 식 「ton/hr」 .replace(/\/(시간|h|Hr|HR)$/, "/hr"); const varOf = (doc: FormulaDoc, name: string): DocVar | undefined => (doc.변수 ?? []).find((v) => varId(v) === name); function parseOr(text: unknown): Node | null { try { return parse(text === null || text === undefined || text === "" ? "1" : text); } catch { return null; } } /** 문서 결과 단위(원/X · 원/100㎡) → X/hr · 모름 = "" */ function perHour(doc: FormulaDoc): string { const t = String(doc.결과단위 ?? ""); const low = t.includes("/") ? t .split("/") .slice(1) .join("/") .replace(/^[\d.,]+/, "") .trim() : ""; return low ? `${normUnit(low)}/hr` : ""; } /** 변수 단위 — 빈 칸이면 정의 식에서 짐작(…/hr 변수를 씀 · 3600 이 든 식 = 문서 결과 단위/hr) */ export function unitOf(doc: FormulaDoc, name: string, depth = 0): string { const u = normUnit(varOf(doc, name)?.단위); const line = (doc.식 ?? []).find((x) => x.기호 === name); if (u || depth > 3 || !line) return u; const node = parseOr(line.식); if (!node) return ""; for (const n of names(node)) { const got = unitOf(doc, n, depth + 1); if (got.endsWith("/hr")) return got; } return [...walk(node)].some((x) => x[0] === "num" && x[1] === 3600) ? perHour(doc) : ""; } const held = (doc: FormulaDoc, name: string): boolean => name.startsWith("r_") || unitOf(doc, name) === "%"; // ── 식 나무 ─────────────────────────────────────────────────────────── const isChain = (n: Node): boolean => n[0] === "bin" && (n[1] === "*" || n[1] === "/"); function factors(node: Node, sign = 1, out: Fac[] = []): Fac[] { if (node[0] === "bin" && (node[1] === "*" || node[1] === "/")) { factors(node[2], sign, out); factors(node[3], node[1] === "*" ? sign : -sign, out); } else out.push([sign, node]); return out; } /** (부호, 노드) 목록 → 곱 · 나눔 나무(차례 그대로 · 곱 먼저) */ function build(fs: Fac[]): Node { const tops = fs.filter(([s]) => s > 0).map(([, n]) => n); let node: Node = tops.length ? tops[0] : ["num", 1, "1"]; for (const n of tops.slice(1)) node = ["bin", "*", node, n]; for (const [s, n] of fs) if (s < 0) node = ["bin", "/", node, n]; return node; } function kids(node: Node): Node[] { switch (node[0]) { case "call": return node[2]; case "bin": return [node[2], node[3]]; case "neg": case "pct": case "field": return [node[1]]; default: return []; } } function uses(node: Node, sign: number, out: Map): void { if (isChain(node)) { for (const [s, n] of factors(node)) if (n[0] === "var") out.set(n[1], [...(out.get(n[1]) ?? []), s * sign]); else uses(n, 0, out); return; } if (node[0] === "var") { out.set(node[1], [...(out.get(node[1]) ?? []), 0]); return; } for (const k of kids(node)) uses(k, 0, out); } function rates(doc: FormulaDoc, node: Node): Set { const got = new Map(); uses(node, 1, got); return new Set( [...got].filter(([n, signs]) => signs.every((s) => s < 0) && unitOf(doc, n).endsWith("/hr")).map(([n]) => n), // prettier-ignore ); } /** 곱 · 나눔 줄 하나 → 일당 자리 | null */ function daily(doc: FormulaDoc, node: Node, rs: Set): Site | null { const fs = factors(node); const eight = fs.flatMap(([s, n], i) => (s > 0 && n[0] === "num" && n[1] === 8 ? [i] : [])); const den = fs.flatMap(([s, n], i) => (s < 0 && n[0] !== "num" ? [i] : [])); // 수 나눔(÷ 100) = 곱에 남김 if (!eight.length || den.length !== 1) return null; const d = fs[den[0]][1]; if (d[0] === "var" && rs.has(d[1])) return null; const crew = fs.flatMap(([s, n], i) => (s > 0 && n[0] === "var" && !held(doc, n[1]) ? [i] : [])); let per: Node = ["num", 8, "8"]; for (const i of crew) per = ["bin", "*", per, fs[i][1]]; const rate: Node = ["bin", "/", d, per]; const ns = names(d); const u = ns.length === 1 ? unitOf(doc, ns[0]).replace(/\/일$/, "") : ""; // ㎥/일 → ㎥(847-2) return { 꼴: DAILY, 노드: rate, 단위: u ? `${u}/hr` : perHour(doc), 율: "", 뺌: new Set([eight[0], den[0], ...crew]) }; // prettier-ignore } type Test = (cond: Node) => boolean | null; function find(doc: FormulaDoc, node: Node, rs: Set, test: Test | null, out: Site[]): void { if (node[0] === "call" && node[1] === "만약" && test && node[2].length === 3) { const t = test(node[2][0]); if (t !== null) return find(doc, t ? node[2][1] : node[2][2], rs, test, out); } if (isChain(node)) { const site = daily(doc, node, rs); if (site) { out.push(site); return; } for (const [s, n] of factors(node)) if (s < 0 && n[0] === "var" && rs.has(n[1])) out.push({ 꼴: "식", 노드: n, 단위: unitOf(doc, n[1]), 율: "" }); else if (n[0] !== "var") find(doc, n, rs, test, out); return; } for (const k of kids(node)) find(doc, k, rs, test, out); } /** 수량 글 → 시간당 작업량 자리 [{꼴, 노드, 율(글), 단위}] · test(조건 노드) → 참 · 거짓 · null(두 갈래 다) */ export function sites(doc: FormulaDoc, text: unknown, test: Test | null = null): Site[] { const node = parseOr(text); if (!node) return []; const out: Site[] = []; find(doc, node, rates(doc, node), test, out); for (const s of out) s.율 = textOf(s.노드); return out; } function swapNode(doc: FormulaDoc, node: Node, rs: Set): Node { if (isChain(node)) { const site = daily(doc, node, rs); const fs = factors(node); if (site) return build([...fs.filter((_, i) => !site.뺌!.has(i)), [-1, ["var", Q_NEW]]]); if (fs.some(([s, n]) => s < 0 && n[0] === "var" && rs.has(n[1]))) return build(fs.map(([s, n]) => [s, s < 0 && n[0] === "var" && rs.has(n[1]) ? ["var", Q_NEW] : n])); // prettier-ignore const next: Fac[] = fs.map(([s, n]) => [s, n[0] === "var" ? n : swapNode(doc, n, rs)]); return next.every((x, i) => x[1] === fs[i][1]) ? node : build(next); } const old = kids(node); const next = old.map((k) => swapNode(doc, k, rs)); if (next.every((x, i) => x === old[i])) return node; // 자리 없음 = 그대로(글 차례 안 바뀜) switch (node[0]) { case "call": return ["call", node[1], next]; case "field": return ["field", next[0], node[2]]; case "bin": return ["bin", node[1], next[0], next[1]]; case "neg": case "pct": return [node[0], next[0]]; default: return node; } } /** 수량 글의 작업량 자리(모든 갈래)를 `1 ÷ Q_NEW` 로 바꾼 글 */ export function swap(doc: FormulaDoc, text: unknown): string { const node = parseOr(text); return node ? textOf(swapNode(doc, node, rates(doc, node))) : String(text); } // ── 기계 작업량 · 덮음 ────────────────────────────────────────────────── /** 기계 값 칸 `작업량` → [{식, 단위, 변수}] (꼴 틀림 = 뺌) */ export const specsOf = (got: unknown): WorkSpec[] => (Array.isArray(got) ? got : []).filter( (x): x is WorkSpec => !!x && typeof x === "object" && typeof x.식 === "string" && !!x.식, ); /** 시간당 작업량 단위에 맞는 식 키(단위 모름 = 전부) */ export const fits = (specs: WorkSpec[], unit: string): string[] => specs.filter((s) => !unit || normUnit(s.단위) === unit).map((s) => s.식); /** 식 문서 입력 · 선택 기본 › 기계 변수 */ export function workDefaults( tpl: FormulaDoc | null | undefined, spec: WorkSpec | null | undefined, ): Record { const out: Record = {}; for (const v of tpl?.변수 ?? []) { const link = v.연결 ?? {}; if (["입력", "선택", "숫자"].includes(String(link.갈래)) && v.열쇠) out[String(v.열쇠)] = (link as { 값?: unknown }).값; } return { ...out, ...(spec?.변수 ?? {}) }; } const sameVal = (a: unknown, b: unknown): boolean => { const x = Number(a); const y = Number(b); return a !== "" && b !== "" && Number.isFinite(x) && Number.isFinite(y) ? Math.abs(x - y) <= 1e-9 * Math.max(1, Math.abs(x)) : String(a) === String(b); }; /** 작업량 덮음 정리 — 방식 시간당만 · 기본(`workDefaults`)과 같은 변수 뺌 · 남는 것 없음 = null */ export function pruneWork( want: WorkCover | null | undefined, base: Record | null = null, ): WorkCover | null { if (!want || want.방식 !== HOURLY) return null; const got = Object.entries(want.변수 ?? {}).filter( ([k, v]) => v !== null && v !== undefined && v !== "" && !(base && k in base && sameVal(v, base[k])), ); const out: WorkCover = { 방식: HOURLY }; if (want.식) out.식 = String(want.식); if (got.length) out.변수 = Object.fromEntries(got); for (const k of FIXED) if (want[k]) out[k] = String(want[k]); return out; } /** 그 줄 작업량 덮음 열쇠 — 단가 기호 › 기계 열쇠(옛 꼴) 가운데 덮음이 있는 것 · 없으면 단가 기호(새로 씀) */ export function workKey( cover: Cover | null | undefined, info: { 기계: string; 기호?: string }, ): string { const has = (k?: string): boolean => !!k && !!(cover?.[k] as { [WORK]?: WorkCover } | undefined)?.[WORK]; // prettier-ignore return has(info.기호) ? info.기호! : has(info.기계) ? info.기계 : (info.기호 ?? info.기계); } /** 문서 `기계덮음` 의 시간당 작업량 식 키(파이썬 `cover_calls` 짝) */ export function coverCalls(doc: FormulaDoc | null | undefined): string[] { const got = (doc as { 기계덮음?: Cover } | null | undefined)?.기계덮음; return Object.values(got && typeof got === "object" ? got : {}).flatMap((e) => { const w = (e as { [WORK]?: WorkCover })?.[WORK]; return w && w.방식 === HOURLY && w.식 ? [String(w.식), ...(w.키 ? [String(w.키)] : [])] : []; // 847-1 굳은 기계 식 문서 }); } // ── 셈(계산기 money 가 기계 줄마다 부름) ───────────────────────────────── type Scope = Record; /** 계산기 셈 한 벌(`Run`)에서 쓰는 몫 */ export interface WorkRun { doc: FormulaDoc; vars: Map; values: Map; marks: Mark[]; cover: Cover; links: { element(p: Record): unknown; doc(key: string): FormulaDoc | null | undefined }; // prettier-ignore expr(text: unknown, where?: string, scope?: Scope): unknown; ev(node: Node, scope: Scope | undefined, where: string): unknown; sub(p: Record, name: string): unknown; link(v: DocVar, name: string): unknown; mark(stop: { why: string }): unknown; } /** 계산기 몫(계산기 → 이 파일 부름만 · 거꾸로 import 없음) */ export interface WorkKit { Stop: new (why: string, kind?: string, sign?: string) => { why: string }; Gap: new (...a: never[]) => Error; Broken: new (...a: never[]) => Error; bad: (v: unknown) => boolean; plainText: (v: unknown) => string; } /** 기계 줄 단가 기호 → {작업 기계 입력 식, 단가 기호, 본 기계 칸인지(부착 기계 아님)} · 기계 줄 아님 = null · * 숫자 연결 + 입력 「기계」 = 가져온 식 엑셀 판 기계 줄(848-7) */ export function machineOf( vars: Map, line: { 단가?: unknown }, ): { expr: string; name: string; main: boolean } | null { const node = parseOr(line.단가); for (const name of node ? names(node) : []) { const link = (vars.get(name)?.연결 ?? {}) as { 갈래?: string; 입력?: Record }; // prettier-ignore const given = link.입력 ?? {}; if ((link.갈래 === "단가산출" || link.갈래 === "숫자") && "기계" in given) { const tool = Object.entries(given).filter(([k]) => k !== "기계" && !NOT_MACHINE.includes(k)); const expr = String(tool.length ? tool[tool.length - 1][1] : given.기계); return { expr, name, main: !tool.length }; } } return null; } /** 굳은 기계로 단가 기호 연결을 바꾼 변수(기계 입력 = 그 기계 · 기계 식 문서 = `키` 있으면 그것) */ export function fixedVar(v: DocVar, want: WorkCover): DocVar { const link = v.연결 ?? {}; return { ...v, 연결: { ...link, 입력: { ...(link.입력 ?? {}), 기계: `'${want.기계}'` }, ...(want.키 ? { 키: want.키 } : {}) }, // prettier-ignore }; } type Line = { 이름?: unknown; 수량?: unknown; 단가?: unknown; 묶음?: unknown; 부착?: unknown }; /** 부착 줄 → 같은 묶음 앞쪽 주 기계 줄(부착 아님 · 기계 줄) · 아님 = null */ export function hostOf( run: { doc: FormulaDoc; vars: Map }, line: Line, ): Line | null { if (!line[ATTACH]) return null; const lines = (run.doc.금액 ?? []) as Line[]; const at = lines.indexOf(line); for (let i = at - 1; i >= 0; i--) { const x = lines[i]; if (!x[ATTACH] && x.묶음 === line.묶음 && machineOf(run.vars, x)) return x; } return null; } /** 부착 줄 = 주 기계 줄 수량 그대로 · 답 칸 = 주 줄 답 + `따름`(주 기계 줄 작업량 답이 있을 때) */ function follow( run: WorkRun, line: Line, host: Line, scope: Scope, kit: WorkKit, key: string, sym: string, ): [string | { why: string } | null, Record, WorkInfo | null] { const n = run.marks.length; const seen = new Set(run.values.keys()); let got: ReturnType; try { got = lineWork(run, host, scope, kit); } finally { run.marks.length = n; // 주 기계 줄 셈의 흔적 = 그 줄이 냄 for (const k of [...run.values.keys()]) if (!seen.has(k)) run.values.delete(k); } let [swapped] = got; const [, more, info] = got; const where = String(line.이름 ?? ""); if (swapped instanceof kit.Stop) swapped = new kit.Stop(`${where} 주 기계 줄을 따름 — ${(swapped as { why: string }).why}`, "시간당 거절", where); // prettier-ignore const text = swapped === null ? host.수량 : swapped; const mine: WorkInfo | null = info ? { 기계: key, 기호: sym, 꼴: info.꼴 ?? "", 율: info.율 ?? "", 값: info.값, 단위: info.단위 ?? "", 식들: [], 따름: { 기호: info.기호 ?? "", 이름: String(host.이름 ?? ""), 꼴: info.꼴 ?? "" } } // prettier-ignore : null; const keep = Q_NEW in more ? { [Q_NEW]: more[Q_NEW] } : {}; return [text === line.수량 ? null : (text as string | { why: string }), keep, mine]; } /** 기계 줄 하나 → [바꾼 수량 글 | 멈춤(표지는 계산기가 담) | null, 범위 더함, 답 칸 | null] */ export function lineWork( run: WorkRun, line: Line, scope: Scope, kit: WorkKit, ): [string | { why: string } | null, Record, WorkInfo | null] { const got = machineOf(run.vars, line); if (got === null) return [null, {}, null]; const expr = got.expr; const where = String(line.이름 ?? ""); /** 흔적 없는 셈 — 표지 · 기억한 값을 되돌림(진짜 셈이 표지를 다시 냄) */ const quiet = (fn: () => T): T => { const n = run.marks.length; const seen = new Set(run.values.keys()); try { return fn(); } finally { run.marks.length = n; for (const k of [...run.values.keys()]) if (!seen.has(k)) run.values.delete(k); } }; const keyVal = quiet(() => run.expr(expr, where, scope)); if (kit.bad(keyVal)) return [null, {}, null]; const raw = kit.plainText(keyVal).trim(); const key = /^'.*'$/.test(raw) ? raw.slice(1, -1) : raw; // 덮음 기계 열쇠(cover machineKey 와 같음) const host = hostOf(run, line); if (host) return follow(run, line, host, scope, kit, key, got.name); // 848-4 부착 줄 const test: Test = (cond) => { const v = quiet(() => run.ev(cond, scope, where)); return kit.bad(v) ? null : !!v; }; const found = sites(run.doc, line.수량, test); const want = (run.cover?.[workKey(run.cover, { 기계: key, 기호: got.name })] as { [WORK]?: WorkCover } | undefined)?.[WORK]; // prettier-ignore const hourly = !!want && want.방식 === HOURLY; if (!found.length && !hourly) return [null, {}, null]; const fixed = hourly && got.main && want!.기계 ? String(want!.기계) : ""; // 847-1 굳은 기계 let specs: WorkSpec[] = []; try { specs = specsOf(run.links.element({ 키: `EQ:${fixed || key}`, 칸: WORK })); } catch (e) { if (!(e instanceof kit.Gap) && !(e instanceof kit.Broken)) throw e; } const unit = found.length ? found[0].단위 : ""; const info: WorkInfo = { 기계: key, 기호: got.name, 꼴: found.length ? found[0].꼴 : "", 율: found.length ? found[0].율 : "", 값: null, 단위: unit, 식들: fits(specs, unit), }; // prettier-ignore if (!hourly) { const v = quiet(() => run.ev(found[0].노드, scope, where)); info.값 = typeof v === "number" && Number.isFinite(v) ? v : null; return [null, {}, info]; } const pick = String(want!.식 ?? "") || (info.식들[0] ?? ""); const spec = specs.find((s) => s.식 === pick); const why = !specs.length ? "시간당 작업량 식 없는 기계" : !found.length ? "시간당 작업량 자리 없는 줄" : !spec || !info.식들.includes(pick) ? `단위 ${unit} 맞는 작업량 식 없음` : ""; info.꼴 = HOURLY; info.율 = pick; if (fixed) info.고정 = fixed; if (why) { info.까닭 = why; return [new kit.Stop(`${where} 시간당 거절 — ${why}`, "시간당 거절", where), {}, info]; } const given = { ...(spec!.변수 ?? {}), ...(want!.변수 ?? {}) }; let q: unknown; let tpl: FormulaDoc | null | undefined = null; try { q = run.sub({ 키: pick, 입력: given }, where); tpl = run.links.doc(pick); } catch (e) { if (!(e instanceof kit.Gap) && !(e instanceof kit.Broken)) throw e; q = new kit.Stop(e.message); } info.변수 = { ...workDefaults(tpl, spec), ...(want!.변수 ?? {}) }; if (typeof q !== "number" || !Number.isFinite(q) || q <= 0) { info.까닭 = `작업량 식 ${pick} 못 셈${kit.bad(q) ? ` — ${(q as { why: string }).why}` : ""}`; return [new kit.Stop(`${where} ${info.까닭}`, "시간당 거절", where), {}, info]; } info.값 = q; const more: Scope = { [Q_NEW]: q }; if (fixed) { const price = run.link(fixedVar(run.vars.get(got.name)!, want!), got.name); // 단가 = 굳은 기계 if (price instanceof kit.Stop) run.mark(price); more[got.name] = price; } return [swap(run.doc, line.수량), more, info]; }