Files
Aislo/common_util/common_util_formula_doc_cover.ts
T
eomsangdonandClaude Opus 5.5 c9df064389 fix(848-7): 엑셀 판 제어 구역 연결 문서 · 값 화면 캐시에 · 방식 없는 위 층(가져온 값) 변수 물려받음
- M02_Doc_Import.record — 엑셀 판도 기계 식 문서 · 값을 기록(없으면 제어 구역이 안 열림 · ORCA 에서 찾음)
- prune_work_layer ↔ pruneWorkLayer — 위 층에 방식 없이 식 · 변수만 있어도 같은 식이면 물려받음
  (저장 뒤 손대지 않은 경쟁사 값이 내 고침 · 파랑으로 남던 것)
- 시험 test_848_7 방식 없는 위 층 거울 · 관련 시험 442 통과

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

576 lines
26 KiB
TypeScript
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
/* =============================================================================
* common_util_formula_doc_cover.ts
* 기계 덮음(PLAN 836-1 · 요구 846 · 849 · 850 · 853) — 단가산출 안 기계 내부 값 고침(사본 줄은 그대로 · 고친 것만 따로)
* 자리 = 문서 칸 `기계덮음` {기계 입력 글: {값?: {칸: 값}, 조종원?: [{키, 인}], 잡품?: [{줄? | 키?, 이름?, 수량?, 율}]}}
* 기계 입력 글 = 부름 입력 `기계` 값(따옴표 뗌 · 원문번호 · 개인 EQP…) — 같은 기계 줄 여럿 = 한 벌
* 값 = 기계 식이 읽는 기계 칸(요소 `EQ:{S_기계}` 칸 — 조종원 · 조종원직종 · 잡재료율 빼고) · 조종원 = 인력 줄(노임 키 · 인/일) ·
* 잡품 = 재료 줄(율 % · 줄 = 그 금액 줄 단가 · 수량 따름(기본) · 키 = 고른 재료 요소) · 원본과 같은 칸 = 없음(`prune`)
* 셈 규칙(`coverDoc`) = 계산기가 기계 식을 부를 때 그 기계 덮음을 얹은 문서로 셈 — 덮음 없음 = 문서 그대로(금액 전후 같음)
* 기계 줄 목록(842-3 · `common_util_machine_crew`) = 바탕 덮음(`rowEntry` — 식 한 줄로 안 풀리는 부분만) ·
* 단가산출 덮음이 그 위에 부분별로 덮음(`mergeCover` — 값 = 칸별 · 조종원 · 잡품 = 목록 통째)
* 겹쳐 덮는 층(848-1 · 틀 문서 10 절) = ⓪ 정본(기계 줄) → ① 위 층(M01 기초 `기계덮음` · SK `수식.위덮음`) →
* ② 내 고침(SK `수식.문서.기계덮음`) · 칸 단위 합침(`mergeCover` · `mergeLayers` · `layeredCover` — 작업량 = 방식 ·
* 식 · 변수 열쇠 · 기계 고정) · 층마다 위 층과 같은 칸 지움(`prune` · `putCover` 의 `upper`) · 위 층 값(`upperOf`) ·
* 출처(`sourcesOf`)
* 파이썬 · TS 짝 — 짝 = resources/master_data/scripts/master_doc_cover.py · 거울 시험 test_836_1_machine_cover.py ·
* test_842_3_machine_crew.py · test_848_1_cover_layers.py
* · 화면 · DOM · fetch 없음
* ========================================================================== */
import {
names,
parse,
symId,
varId,
type DocVar,
type FormulaDoc,
type MoneyLine,
} from "./common_util_formula_doc";
import { DAILY, HOURLY, WORK, type WorkCover } from "./common_util_formula_doc_work";
import { CREW, MISC, code as jobOf } from "./common_util_machine_crew";
export const COVER = "기계덮음";
/** SK `수식` 칸 — ① 위 층 고침(848-1 · 꼴 = `기계덮음`) */
export const UPPER = "위덮음";
/** M01 문서 칸 — 빌더 결과와 셈 칸이 다른 문서(빌더가 안 덮음 · 848-1) */
export const HAND = "손고침";
/** 출처(`sourcesOf`) — 없는 칸 = 정본 */
export const MINE = "나";
export const ABOVE = "위";
export type Source = typeof MINE | typeof ABOVE;
/** 값 칸에서 빼는 기계 칸 — 줄(조종원 · 잡품)로 다룸 */
export const NOT_VALUE = ["조종원", "조종원직종", "잡재료율"];
const HOUR = "Q_시간환산";
/** 조종원 줄을 새로 넣을 때(조종원 없는 식) 시간환산 — GC000267 과 같은 꼴(1/8 × 16/12 × 25/20 · 건협기술-2230) */
const HOUR_VARS: DocVar[] = [
{
열쇠: "Q_분자^표", 기호: "Q", 아래: "분자", 위: "표", 이름: "건설기계 조종원 노임 시간 환산 계수.분자", 단위: "",
연결: { 갈래: "표", 표: "CC000336", 조건: { 구분: "'시간환산'" }, 칸: "분자" },
},
{
열쇠: "Q_분모^표", 기호: "Q", 아래: "분모", 위: "표", 이름: "건설기계 조종원 노임 시간 환산 계수.분모", 단위: "",
연결: { 갈래: "표", 표: "CC000336", 조건: { 구분: "'시간환산'" }, 칸: "분모" },
},
{
열쇠: "Q_분자2^표", 기호: "Q", 아래: "분자2", 위: "표", 이름: "건설기계 조종원 노임 시간 환산 계수.분자", 단위: "",
연결: { 갈래: "표", 표: "CC000336", 조건: { 구분: "'상여계수'" }, 칸: "분자" },
},
{
열쇠: "Q_분모2^표", 기호: "Q", 아래: "분모2", 위: "표", 이름: "건설기계 조종원 노임 시간 환산 계수.분모", 단위: "",
연결: { 갈래: "표", 표: "CC000336", 조건: { 구분: "'상여계수'" }, 칸: "분모" },
},
{
열쇠: "Q_분자3^표", 기호: "Q", 아래: "분자3", 위: "표", 이름: "건설기계 조종원 노임 시간 환산 계수.분자", 단위: "",
연결: { 갈래: "표", 표: "CC000336", 조건: { 구분: "'휴지계수'" }, 칸: "분자" },
},
{
열쇠: "Q_분모3^표", 기호: "Q", 아래: "분모3", 위: "표", 이름: "건설기계 조종원 노임 시간 환산 계수.분모", 단위: "",
연결: { 갈래: "표", 표: "CC000336", 조건: { 구분: "'휴지계수'" }, 칸: "분모" },
},
{ 열쇠: "시간환산", 기호: "Q", 아래: "시간환산", 위: "", 이름: "시간환산", 단위: "", 연결: { 갈래: "식" } },
]; // prettier-ignore
const HOUR_LINE = {
기호: HOUR,
식: "Q_분자^표 ÷ Q_분모^표 × Q_분자2^표 ÷ Q_분모2^표 × Q_분자3^표 ÷ Q_분모3^표",
};
export interface CrewRow {
키: string;
인: number;
/** 화면 이름(직종) — 셈 · 원본 대조 안 봄 */
이름?: string;
}
export interface MiscRow {
줄?: string;
키?: string;
이름?: string;
단위?: string;
수량?: number;
율: number;
}
export interface MachineCover {
값?: Record<string, number | string>;
조종원?: CrewRow[];
잡품?: MiscRow[];
}
export type Cover = Record<string, MachineCover>;
type Holder = FormulaDoc & { [COVER]?: Cover };
const clone = <T>(v: T): T => JSON.parse(JSON.stringify(v)) as T;
const plain = (n: number): string => String(Number(n.toPrecision(15)));
export const coverOf = (doc: FormulaDoc | null | undefined): Cover => {
const got = (doc as Holder | null | undefined)?.[COVER];
return got && typeof got === "object" && !Array.isArray(got) ? got : {};
};
/** 부름 입력 → 기계 열쇠(따옴표 뗌) · 기계 입력 없음 = "" */
export function machineKey(given: Record<string, unknown> | null | undefined): string {
const v = given?.기계;
if (v === undefined || v === null) return "";
const t = String(v).trim();
return /^'.*'$/.test(t) ? t.slice(1, -1) : t;
}
const namesOf = (text: unknown): string[] => {
if (text === null || text === undefined || String(text).trim() === "") return [];
try {
return names(parse(text));
} catch {
return [];
}
};
export interface CoverParts {
/** 값 칸 — 칸 이름 · 그 칸을 읽는 기호(차례 = 문서 변수 차례) */
fields: { 칸: string; ids: string[] }[];
/** 조종원 금액 줄 차례 · 사람 수 기호 */
crew: number[];
crewQty: Record<number, string>;
/** 잡품(잡재료비) 금액 줄 차례 · 율 기호 · 밑 재료 줄 차례 */
misc: number | null;
rate: string | null;
base: number[];
}
/** 기계 식 짜임 — 기계 칸 요소(`EQ:…{S_기계}…`) · 조종원 줄(노무비 · 수량이 칸 「조종원」) · 잡품 줄(재료비 누계 × 율) */
export function partsOf(doc: FormulaDoc): CoverParts {
const eq = new Map<string, string>();
for (const v of doc.변수 ?? []) {
const l = v.연결 ?? {};
const k = String(l.키 ?? "");
if (l.갈래 === "요소" && k.startsWith("EQ:") && k.includes("{S_기계}") && l.칸)
eq.set(varId(v), l.칸);
}
const fields: CoverParts["fields"] = [];
for (const [id, col] of eq) {
if (NOT_VALUE.includes(col)) continue;
const at = fields.find((f) => f.칸 === col);
if (at) at.ids.push(id);
else fields.push({ 칸: col, ids: [id] });
}
const lines = doc.금액 ?? [];
const crew: number[] = [];
const crewQty: Record<number, string> = {};
let misc: number | null = null;
let rate: string | null = null;
lines.forEach((l, i) => {
const q = namesOf(l.수량).find((n) => eq.get(n) === "조종원");
if (l.비목 === "노무비" && q) {
crew.push(i);
crewQty[i] = q;
}
const p = namesOf(l.단가);
const other = p.filter((n) => n !== "재료비");
if (misc === null && l.비목 === "재료비" && p.includes("재료비") && other.length === 1) {
misc = i;
rate = other[0];
}
});
const base =
misc === null
? []
: lines.flatMap((l, i) => (i < misc! && l.비목 === "재료비" && !l.합밖 ? [i] : []));
return { fields, crew, crewQty, misc, rate, base };
}
type Vals = Record<string, unknown>;
const num = (v: unknown): number | null => (typeof v === "number" && Number.isFinite(v) ? v : null);
/** 요소 키 글의 구멍을 값으로 채움(`LB:{S_직종}` → `LB:1048`) */
const fillKey = (text: string, vals: Vals): string =>
text.replace(/\{([^{}]+)\}/g, (_, h: string) => {
const v = vals[h];
return typeof v === "number" ? plain(v) : String(v ?? "");
});
/** 원본(단가산출 덮음 없음) 기본값 — 셈 답 값(`vals` = 그 기계로 셈한 원본 답 `값`) ·
* `base` = 기계 줄 바탕 덮음(`rowEntry`) — 있는 부분은 그 목록(빈 직종 키 = 식이 고른 직종) */
export function defaultsOf(
doc: FormulaDoc,
vals: Vals,
base?: MachineCover | null,
): Required<MachineCover> {
const parts = partsOf(doc);
const lines = doc.금액 ?? [];
const vars = new Map((doc.변수 ?? []).map((v) => [varId(v), v]));
const 값: Record<string, number | string> = {};
for (const f of parts.fields) {
const v = vals[f.ids[0]];
if (typeof v === "number" || typeof v === "string") 값[f.칸] = v;
}
const 조종원 = parts.crew.flatMap((i) => {
const n = num(vals[parts.crewQty[i]]);
const sym = namesOf(lines[i].단가)[0];
const key = String(vars.get(sym ?? "")?.연결?.키 ?? "");
return n && key ? [{ 키: fillKey(key, vals), 인: n }] : [];
});
const r = parts.rate ? num(vals[parts.rate]) : null;
let 잡품: MiscRow[] = r
? parts.base.map((i) => ({ 줄: String(lines[i].이름 ?? ""), 율: r }))
: [];
let crew: CrewRow[] = 조종원;
if (base?.조종원) {
const own = 조종원[0]?.키 ?? "";
crew = base.조종원.filter((x) => x.키 || own).map((x) => ({ ...x, 키: x.키 || own }));
}
if (base?.잡품) 잡품 = base.잡품;
return { 값, 조종원: crew, 잡품 };
}
/** 원본 대조 꼴 — 이름 · 단위(화면 글) · 빈 칸 뺌 · 수 12 자리 */
const LABEL = ["이름", "단위"];
const canon = (v: unknown): string =>
JSON.stringify(v, (_, x: unknown) =>
x && typeof x === "object" && !Array.isArray(x)
? Object.fromEntries(
Object.entries(x as Record<string, unknown>)
.filter(([k, y]) => y !== undefined && y !== null && y !== "" && !LABEL.includes(k))
.sort(([a], [b]) => (a < b ? -1 : 1)),
)
: typeof x === "number"
? Number(x.toPrecision(12))
: x,
);
const sameVal = (a: unknown, b: unknown): boolean =>
typeof a === "number" && typeof b === "number"
? Math.abs(a - b) <= 1e-9 * Math.max(1, Math.abs(a), Math.abs(b))
: String(a) === String(b);
/** 기계 덮음 + 시간당 작업량(846-1 · `common_util_formula_doc_work`) — `MachineCover` 는 그대로(Required 꼴 지킴) ·
* 848-1 한 층의 작업량은 바꾼 칸만 담을 수 있음(`방식` 없음 = 위 층 방식) — 읽을 때는 `mergeLayers` 답을 봄 */
export type CoverEntry = MachineCover & { [WORK]?: WorkCover };
/** 원본 기본값 + 작업량 기본 변수(`workDefaults` · 없으면 변수 그대로) */
export type CoverBase = Required<MachineCover> & { [WORK]?: Record<string, unknown> };
/** 위 층 값(`upperOf`) — 정본 기본 위에 ① · 작업량 = ① 층 그대로 */
export type UpperValue = Required<MachineCover> & { [WORK]?: WorkCover };
/** 작업량 한 층(848-1) — 바꾼 칸만(방식 없음 = 위 층 방식) */
export type WorkLayer = Partial<WorkCover>;
/** 위 층과 같은 칸 · 줄을 뺀 덮음(바꿨다 되돌림 = 안 고침) · 다 빠지면 null —
* `base` = 정본 기본(`defaultsOf` · 작업량 = 그 식 기본 변수) · `upper` = ① 그 열쇠 칸(848-1 · 없음 = 정본 위) */
export function prune(
entry: CoverEntry,
base: CoverBase,
upper?: CoverEntry | null,
): CoverEntry | null {
const up = upperOf(base, upper);
const out: CoverEntry = {};
const vals = Object.entries(entry.값 ?? {}).filter(
([k, v]) => v !== null && v !== undefined && v !== "" && !(k in up.값 && sameVal(v, up.값[k])),
);
if (vals.length) out.값 = Object.fromEntries(vals);
if (entry.조종원 && canon(entry.조종원) !== canon(up.조종원)) out.조종원 = entry.조종원;
if (entry.잡품 && canon(entry.잡품) !== canon(up.잡품)) out.잡품 = entry.잡품;
const work = pruneWorkLayer(entry[WORK], base[WORK] ?? null, upper?.[WORK] ?? null);
if (work) out[WORK] = work as WorkCover;
return Object.keys(out).length ? out : null;
}
// ── 층(848-1) ─────────────────────────────────────────────────────────
const FIXED = ["기계", "키", "이름"] as const;
const fixedOf = (w: WorkLayer): WorkLayer => {
const out: WorkLayer = {};
for (const k of FIXED) if (w[k]) out[k] = String(w[k]);
return out;
};
const sameNum = (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);
};
/** 작업량 한 층 정리 — 위 층(`upper` = ① 작업량 칸 · 없음 = 정본 일당)과 같은 칸 뺌 · `base` = 그 식 기본 변수
* (`workDefaults`) · 일당 = 방식만 · 남는 것 없음 = null(위 층 없음 = `pruneWork` 와 같음) */
export function pruneWorkLayer(
want: WorkLayer | null | undefined,
base: Record<string, unknown> | null = null,
upper: WorkLayer | null = null,
): WorkLayer | null {
if (!want || typeof want !== "object") return null;
const up = upper ?? {};
const upWay = up.방식 || DAILY;
const way = want.방식 || upWay;
const out: WorkLayer = way !== upWay ? { 방식: way } : {};
if (way !== HOURLY) return Object.keys(out).length ? out : null;
const upForm = upWay === HOURLY ? String(up.식 ?? "") : "";
const form = String(want.식 ?? "") || upForm;
if (form !== upForm) out.식 = form;
const same = form === String(up.식 ?? ""); // 848-7 방식 없는 위 층(가져온 값)도 같은 식이면 변수 물려받음
const held = { ...(base ?? {}), ...(same ? (up.변수 ?? {}) : {}) };
const got = Object.entries(want.변수 ?? {}).filter(
([k, v]) => v !== null && v !== undefined && v !== "" && !(k in held && sameNum(v, held[k])),
);
if (got.length) out.변수 = Object.fromEntries(got);
const fix = fixedOf(want);
const upFix = upWay === HOURLY ? fixedOf(up) : {};
if (
Object.keys(fix).length &&
(!Object.keys(upFix).length || fix.기계 !== upFix.기계 || fix.키 !== upFix.키)
)
Object.assign(out, fix);
return Object.keys(out).length ? out : null;
}
/** 작업량 층 합침 — 아래 층(`low`)이 칸마다 이김(방식 · 식 · 변수 열쇠 · 기계 고정 한 덩이) ·
* 식을 바꾼 아래 층 = 위 층 변수 안 물려받음 */
export function mergeWork(
top: WorkLayer | null | undefined,
low: WorkLayer | null | undefined,
): WorkLayer | null {
if (!top || !Object.keys(top).length) return low && Object.keys(low).length ? low : null;
if (!low || !Object.keys(low).length) return top;
let out: WorkLayer = { ...top };
if (low.방식) out.방식 = low.방식;
if (low.식 && String(low.식) !== String(top.식 ?? "")) {
out.식 = low.식;
delete out.변수;
}
const vals = { ...(out.변수 ?? {}), ...(low.변수 ?? {}) };
if (Object.keys(vals).length) out.변수 = vals;
if (low.기계) {
out = Object.fromEntries(
Object.entries(out).filter(([k]) => !(FIXED as readonly string[]).includes(k)),
) as WorkLayer;
Object.assign(out, fixedOf(low));
}
return out;
}
/** ① 위 층 고침 위에 ② 내 고침(열쇠마다 `mergeCover`) — 계산기 `cover` 인자 · 위 층 없음 = ② 그대로 */
export function mergeLayers(
upper: Cover | null | undefined,
mine: Cover | null | undefined,
): Cover {
if (!upper || !Object.keys(upper).length) return mine ?? {};
if (!mine || !Object.keys(mine).length) return upper;
const out: Cover = {};
for (const k of [...Object.keys(upper), ...Object.keys(mine).filter((k) => !(k in upper))]) {
const got = mergeCover(upper[k], mine[k]);
if (got) out[k] = got;
}
return out;
}
/** 화면 셈 cover — 문서 칸 `기계덮음`(②) 을 ① 위에 얹음(SK = 읽기 답 `위덮음` · M01 = 없음) */
export const layeredCover = (doc: FormulaDoc, upper?: Cover | null): Cover =>
mergeLayers(upper, coverOf(doc));
/** 위 층 값 — 정본 기본(`defaultsOf`) 위에 ① 그 열쇠 칸 · 작업량 = ① 층 그대로(기본 변수는 `workDefaults`) */
export function upperOf(base: CoverBase, upper?: CoverEntry | null): UpperValue {
const { [WORK]: _, ...rest } = base;
const out: UpperValue = { ...rest };
if (!upper) return out;
out.값 = { ...base.값, ...(upper.값 ?? {}) };
if (upper.조종원) out.조종원 = upper.조종원;
if (upper.잡품) out.잡품 = upper.잡품;
if (upper[WORK]) out[WORK] = upper[WORK];
return out;
}
/** 칸 경로 → 출처(「위」 = ① · 「나」 = ②) · 없는 경로 = 정본 — `값.<칸>` · 조종원 · 잡품 · `작업량.방식` ·
* `작업량.식` · `작업량.변수.<열쇠>` · `작업량.기계` */
export function sourcesOf(
upper: CoverEntry | null | undefined,
mine: CoverEntry | null | undefined,
): Record<string, Source> {
let out: Record<string, Source> = {};
const upForm = String((upper?.[WORK] as WorkLayer | undefined)?.식 ?? "");
for (const [layer, tag] of [
[upper, ABOVE],
[mine, MINE],
] as const) {
const e = layer ?? {};
for (const k of Object.keys(e.값 ?? {})) out[`값.${k}`] = tag;
if (e.조종원) out.조종원 = tag;
if (e.잡품) out.잡품 = tag;
const w = (e[WORK] ?? {}) as WorkLayer;
if (tag === MINE && w.식 && String(w.식) !== upForm)
out = Object.fromEntries(Object.entries(out).filter(([k]) => !k.startsWith("작업량.변수.")));
for (const k of ["방식", "식", "기계"] as const) if (w[k]) out[`작업량.${k}`] = tag;
for (const k of Object.keys(w.변수 ?? {})) out[`작업량.변수.${k}`] = tag;
}
return out;
}
/** 덮음 한 기계 고침 → 문서 칸(위 층 대조로 정리 · 비면 칸 지움) — `upper` = ① 그 열쇠 칸(848-1 · SK) */
export function putCover(
doc: FormulaDoc,
machine: string,
entry: CoverEntry,
base: CoverBase,
upper?: CoverEntry | null,
): void {
const box = doc as Holder;
const all = { ...coverOf(doc) };
const kept = prune(entry, base, upper);
if (kept) all[machine] = kept;
else delete all[machine];
if (Object.keys(all).length) box[COVER] = all;
else delete box[COVER];
}
// ── 셈 규칙 ───────────────────────────────────────────────────────────
/** 새 요소 기호(`w_조종원1` · `P_잡품1` — 문서에 없는 첫 번호) */
function addVar(doc: FormulaDoc, sign: string, low: string, name: string, key: string): string {
const have = new Set([
...(doc.변수 ?? []).map(varId),
...(doc.식 ?? []).map((l) => String(l.기호 ?? "")),
]);
let n = 1;
while (have.has(symId(sign, `${low}${n}`))) n++;
const 아래 = `${low}${n}`;
const id = symId(sign, 아래);
(doc.변수 ??= []).push({
열쇠: id, 기호: sign, 아래, 위: "", 이름: name, 단위: "", 연결: { 갈래: "요소", 키: key },
}); // prettier-ignore
return id;
}
/** 조종원 줄 — 빈 키 줄 = 식의 조종원 단가 기호(`own` · 식 입력 직종) · 없으면 뺌 */
function crewLines(doc: FormulaDoc, all: CrewRow[], own = ""): MoneyLine[] {
const rows = all.filter((r) => r.키 || own);
const have = (doc.변수 ?? []).some((v) => varId(v) === HOUR) || (doc.식 ?? []).some((l) => l.기호 === HOUR); // prettier-ignore
if (rows.length && !have) {
const ids = new Set((doc.변수 ?? []).map(varId));
for (const v of HOUR_VARS) if (!ids.has(varId(v))) (doc.변수 ??= []).push(clone(v));
(doc.식 ??= []).push({ ...HOUR_LINE });
}
return rows.map((r) => ({
이름: "조종원",
...(r.이름 ? { 규격: r.이름 } : {}),
단위: "인",
비목: "노무비",
수량: `${plain(r.인)} × ${HOUR}`,
단가: r.키 ? addVar(doc, "w", "조종원", "조종원 노임", r.키) : own,
}));
}
function miscLines(doc: FormulaDoc, rows: MiscRow[], lines: MoneyLine[]): MoneyLine[] {
return rows.flatMap((r) => {
let price: string;
let qty: string;
let label = r.이름 ?? "";
if (r.키) {
price = addVar(doc, "P", "잡품", label || r.키, r.키);
qty = plain(r.수량 ?? 1);
} else {
const b = lines.find((l) => String(l.이름 ?? "") === r.줄);
if (!b || !b.단가) return [];
price = String(b.단가);
qty = r.수량 !== undefined && r.수량 !== null ? plain(r.수량) : `(${b.수량 ?? 1})`;
label ||= String(b.이름 ?? "");
}
return [{ 이름: "잡품", 규격: label, 단위: "", 비목: "재료비", 수량: `${qty} × ${plain(r.율)} ÷ 100`, 단가: price } as MoneyLine]; // prettier-ignore
});
}
/** 기계 식 문서에 그 기계 덮음을 얹음(새 문서) — `base` = 기계 줄 바탕 덮음(`rowEntry`) · 덮음 없음 = 그대로(같은 물건) */
export function coverDoc(
doc: FormulaDoc,
given: Record<string, unknown> | null | undefined,
cover: Cover | null | undefined,
base?: MachineCover | null,
): FormulaDoc {
const key = machineKey(given);
const { [WORK]: _, ...top } = ((key ? cover?.[key] : undefined) ?? {}) as CoverEntry; // 작업량 = 부른 쪽 기계 줄 몫
const entry = mergeCover(base, Object.keys(top).length ? top : undefined);
if (!entry) return doc;
const out = clone(doc) as FormulaDoc & { 쌓기?: unknown };
delete out.쌓기; // 금액 차례가 바뀜 — 기본 차림
const parts = partsOf(out);
for (const f of parts.fields)
if (entry.값 && f.칸 in entry.값)
for (const v of out.변수 ?? [])
if (f.ids.includes(varId(v))) v.연결 = { 갈래: "숫자", 값: entry.값[f.칸] };
const lines = out.금액 ?? [];
const own = parts.crew.length ? String(lines[parts.crew[0]].단가 ?? "") : "";
const crew = entry.조종원 ? crewLines(out, entry.조종원, own) : null;
const misc = entry.잡품 && (parts.misc !== null || entry.잡품.length) ? miscLines(out, entry.잡품, lines) : null; // prettier-ignore
const gone = new Set([...(crew ? parts.crew : []), ...(misc && parts.misc !== null ? [parts.misc] : [])]); // prettier-ignore
const tail = lines.findIndex((l) => l.비목 === "경비");
const end = tail < 0 ? lines.length : tail;
const crewAt = parts.crew.length ? parts.crew[0] : end;
const miscAt = parts.misc ?? end;
const next: MoneyLine[] = [];
for (let i = 0; i <= lines.length; i++) {
if (crew && i === crewAt) next.push(...crew);
if (misc && i === miscAt) next.push(...misc);
if (i < lines.length && !gone.has(i)) next.push(lines[i]);
}
out.금액 = next;
return out;
}
// ── 기계 줄 목록 → 바탕 덮음(842-3) ─────────────────────────────────────
/** 기계 시간당 식 — 결과 원/시간 · 요소 `EQ:{S_기계}` 칸을 읽음 */
export const isMachine = (doc: FormulaDoc | null | undefined): boolean =>
!!doc &&
doc.결과단위 === "원/시간" &&
(doc.변수 ?? []).some(
(v) => v.연결?.갈래 === "요소" && String(v.연결?.키 ?? "").includes("{S_기계}"),
);
/** 기계 줄 목록(`인력` · `잡품`) 가운데 식 한 줄로 안 풀리는 부분 = 바탕 덮음 · 다 풀림 = null ·
* 식에 그 줄이 없음 = 안 얹음(손료만 식을 일부러 부른 단가산출) */
export function rowEntry(doc: FormulaDoc, vals: Vals | null | undefined): MachineCover | null {
if (!vals || !isMachine(doc)) return null;
const parts = partsOf(doc);
const lines = doc.금액 ?? [];
const out: MachineCover = {};
const crew = vals[CREW];
if (Array.isArray(crew) && parts.crew.length) {
const rows = crew as CrewRow[];
const jobs = new Set(rows.map((r) => jobOf(r?.키)));
if (!(rows.length && jobs.size === 1)) out.조종원 = rows;
}
const misc = vals[MISC];
if (Array.isArray(misc) && misc.length && parts.misc !== null) {
const rows = misc as MiscRow[];
const names = parts.base.map((i) => String(lines[i].이름 ?? "")).sort();
const plainMisc =
rows.every((r) => r && r.줄 && !r.키) &&
rows.every((r) => r.수량 === undefined || r.수량 === null) &&
new Set(rows.map((r) => canon(r.율))).size === 1 &&
JSON.stringify(rows.map((r) => String(r.줄)).sort()) === JSON.stringify(names);
if (!plainMisc) out.잡품 = rows;
}
return Object.keys(out).length ? out : null;
}
/** 바탕 덮음(위 층) 위에 단가산출 덮음(아래 층) — 값 = 칸별 · 조종원 · 잡품 = 목록 통째(있는 부분만) ·
* 작업량 = `mergeWork`(848-1) */
export function mergeCover(
base: CoverEntry | null | undefined,
top: CoverEntry | null | undefined,
): CoverEntry | null {
if (!base || !Object.keys(base).length) return top && Object.keys(top).length ? top : null;
if (!top || !Object.keys(top).length) return base;
const out: CoverEntry = { ...base, ...top };
const 값 = { ...(base.값 ?? {}), ...(top.값 ?? {}) };
if (Object.keys(값).length) out.값 = 값;
else delete out.값;
const work = mergeWork(base[WORK], top[WORK]);
if (work) out[WORK] = work as WorkCover;
else delete out[WORK];
return out;
}
/** 셈 연결로 그 기계 줄 목록 읽기 — {인력?, 잡품?} · 못 읽음 = 빈 묶음(요소 `EQ:<기계>` 칸) */
export function listsOf(
element: (p: { 키: string; 칸: string }) => unknown,
given: Record<string, unknown> | null | undefined,
): Vals {
const key = machineKey(given);
const out: Vals = {};
if (key)
for (const col of [CREW, MISC])
try {
out[col] = element({ 키: `EQ:${key}`, 칸: col });
} catch {
/* 못 읽음 = 그 목록 없음 */
}
return out;
}