Files
Aislo/common_util/common_util_formula_doc_work.ts
T
eomsangdonandClaude Opus 5.5 a071391aac feat(848-7): 불러오기 엑셀 판 기계 정체 · 가져온 값 층 · 비목곱(세 줄 → 기계 한 줄) — 서버 · 계산기 짝
- 엑셀 판 기계 정체: view ↔ importView 가 기계 줄 숫자 연결에 입력 · 잠금(값 · 조종원 · 잡품) 남김 ·
  작업량 엔진 기계 찾기(_machine_of ↔ machineOf)가 숫자 + 입력 기계도 봄 → 엑셀 판 작업량 줄 0 → 1,634 블록
- 가져온 값 층(새 M02_Doc_Import_Carry): 경쟁사 Q 식(굴착기 8-2-3 · 덤프 8-2-8 단일 구간) 변수 →
  수식.위덮음 {단가 기호: {작업량: {식, 변수}}}(방식 없음) · 우리 식 Q = 경쟁사 Q 인 줄만(759 줄 · 571 블록) ·
  M02_Doc_Import.run(upper) · M02_Doc_Sk copy_of · run 이 실음
- 비목곱: 금액 줄 선택 칸 {비목: 식} — 비목 수량 = 수량 × 곱(계산기 짝 master_doc_calc ↔ calc.ts) ·
  M02_Doc_Import_Shape 세 줄 합침이 「두 줄 같은 수량 + 더한 인수」 꼴도 한 줄로(301 줄)
- 단위 정규화 「톤/hr」 = 「ton/hr」(norm_unit ↔ normUnit)
- 굳히기: 수식 고침 저장한 가져온 식 SK 사본 = 가져온 식 셈 유지(M02_Item_Sangeun · 전엔 사본 0 원) → B09 = M02
- 시험 test_848_7_import_carry 14(거울 · 견본 · 임시 storage B09)
- 전수 3,241 블록 엑셀 · 우리 판 계 · 비목 · 검산 전후 다름 0

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-17 00:13:08 +09:00

545 lines
23 KiB
TypeScript

/* =============================================================================
* 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<string, unknown>;
}
/** 덮음 `작업량` */
export interface WorkCover {
방식: string;
식?: string;
변수?: Record<string, unknown>;
/** 굳은 기계 입력 글(따옴표 뗌) */
기계?: 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, unknown>;
까닭?: string;
/** 굳은 기계(덮음 `기계`) */
고정?: string;
/** 848-4 부착 줄 — 따르는 주 기계 줄 */
따름?: { 기호: string; 이름: string; 꼴: string };
}
interface Site {
꼴: string;
노드: Node;
단위: string;
율: string;
뺌?: Set<number>;
}
type Fac = [number, Node];
export const normUnit = (u: unknown): string =>
String(u ?? "")
.trim()
.replace(/[mM]3/g, "㎥") // 848-6 대문자 꼴
.replace(/[mM]2/g, "㎡")
.replace(/(?<![A-Za-z])(M|HR|Hr|TON|Ton)(?![A-Za-z])/g, (s) => 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<string, number[]>): 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<string> {
const got = new Map<string, number[]>();
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<string>): 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<string>, 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<string>): 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<string, unknown> {
const out: Record<string, unknown> = {};
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<string, unknown> | 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<string, unknown>;
/** 계산기 셈 한 벌(`Run`)에서 쓰는 몫 */
export interface WorkRun {
doc: FormulaDoc;
vars: Map<string, DocVar>;
values: Map<string, unknown>;
marks: Mark[];
cover: Cover;
links: { element(p: Record<string, unknown>): 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<string, unknown>, 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<string, DocVar>,
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<string, unknown> }; // 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<string, DocVar> },
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<string, unknown>, WorkInfo | null] {
const n = run.marks.length;
const seen = new Set(run.values.keys());
let got: ReturnType<typeof lineWork>;
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<string, unknown>, WorkInfo | null] {
const got = machineOf(run.vars, line);
if (got === null) return [null, {}, null];
const expr = got.expr;
const where = String(line.이름 ?? "");
/** 흔적 없는 셈 — 표지 · 기억한 값을 되돌림(진짜 셈이 표지를 다시 냄) */
const quiet = <T>(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];
}