- 숨김 규칙(formula_doc_render hiddenByWork) — 금액 줄에서 따라가 시간당 식 줄이 더 안 읽는 기호만 숨김(옵션 가로 · 공식 묶음 · 산출근거) · 보이기만(문서 값 · 식 그대로) - 기계 굳음 — 시간당으로 바꿀 때 그 줄 기계를 덮음 `기계`에 담음 · 셈은 그 줄 단가를 굳은 기계로 다시 부름(계산기 단가 범위) · 작업량 식 · 변수도 그 기계 것 · 셈 답 `작업량.고정` · `기호` - 덮음 열쇠 = 그 줄 단가 기호(옵션이 기계를 바꿔도 같은 줄) › 기계 열쇠(846-1 옛 꼴 그대로 읽음) · 서버 정리 기본 변수 = 굳은 기계 작업량 칸 · 사본 부름에 굳은 기계 식 문서 - 기계 창으로 바꿈 — 새 기계 작업량 식 · 규격 변수로 다시 차림(같은 식 = 현장 변수 남김 · 다른 식 = 버림 + 알림 · 맞는 식 없음 = 품셈 일당 + 알림) - 수량 칸 = 「1 ÷ 시간당 작업량」 읽기 글 · 방식 하나뿐인 줄 = 고르기 없음 - 기계 밖 두 층 분수 = 짝 나란히 · 곱의 분수 항 펼침 · 중간 줄 이름(문서 키 사전) - 시험: test_847_1_work_hide 새로 · test_846_2 「식 없는 기계 잠김 글」 → 고르기 없음(요구 884 차림 바뀜) · test_846_1 셈 답 `기호` 칸 더함 · test_802_4b2 소스 글자 보는 줄(옵션 호출 글 · 사본 단추 글) 지움(규칙 — 결과 시험 아님 · 읽기만은 같은 시험의 403 이 봄) Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
484 lines
20 KiB
TypeScript
484 lines
20 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) = 덮음 `기계`(시간당으로 바꿀 때 그 줄 기계 · 기계 창으로 바꾼 기계) — 그 줄 단가를
|
|
* 그 기계(`키` = 기계 식 문서가 다를 때)로 다시 부르고 작업량 식 · 변수도 그 기계 것(옵션이 정하던 기계를 안 읽음) ·
|
|
* `이름` = 화면 이름만 · 부착 기계 줄 = 굳힘 없음
|
|
* 셈 답 기계 줄 칸 `작업량` = {기계, 꼴(일당 · 식 · 시간당), 율, 값, 단위, 식들, 변수?, 까닭?}(산출근거 자료)
|
|
* 파이썬 · 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 interface WorkInfo {
|
|
기계: string;
|
|
/** 그 줄 단가 기호(847-1 덮음 열쇠) */
|
|
기호?: string;
|
|
꼴: string;
|
|
율: string;
|
|
값: number | null;
|
|
단위: string;
|
|
식들: string[];
|
|
변수?: Record<string, unknown>;
|
|
까닭?: string;
|
|
/** 굳은 기계(덮음 `기계`) */
|
|
고정?: string;
|
|
}
|
|
interface Site {
|
|
꼴: string;
|
|
노드: Node;
|
|
단위: string;
|
|
율: string;
|
|
뺌?: Set<number>;
|
|
}
|
|
type Fac = [number, Node];
|
|
|
|
export const normUnit = (u: unknown): string =>
|
|
String(u ?? "")
|
|
.trim()
|
|
.replace(/m3/g, "㎥")
|
|
.replace(/m2/g, "㎡")
|
|
.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]) : "";
|
|
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 */
|
|
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.갈래 === "단가산출" && "기계" 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
|
|
};
|
|
}
|
|
|
|
/** 기계 줄 하나 → [바꾼 수량 글 | 멈춤(표지는 계산기가 담) | null, 범위 더함, 답 칸 | null] */
|
|
export function lineWork(
|
|
run: WorkRun,
|
|
line: { 이름?: unknown; 수량?: unknown; 단가?: unknown },
|
|
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 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];
|
|
}
|