feat(848-1): 겹쳐 덮는 층 — SK 수식.위덮음 · 칸 단위 합침 · 위 층 대조 지움 · M01 기초 덮음 저장 · 빌더 이어받기

- 층 셈(파이썬 · TS 짝 master_doc_cover ↔ common_util_formula_doc_cover): merge 에 작업량 칸 단위(merge_work) · merge_layers · layeredCover · upper_of · sources · prune(…, upper) · prune_work_layer
- prune_doc(…, upper): 작업량 · 굳은 기계를 얹고 정본 셈 · 문서 안(선택 목록 · 따옴표 글 · 변수 기호)에 든 열쇠 고침은 안 불려도 남김
- SK: 셈 cover = ① 위덮음 + ② 문서 기계덮음(사본 셈 · 빈틈 · 연결 기록) · 프로젝트 층 밖 = 지금 기초 것 · 저장 때 굳음 · 굳히기 = 그때 기초 것 · derive 는 기초 덮음을 떼고 복사 · 읽기 답에 위덮음
- M01 저장: 기계덮음 검사 · 정본과 같은 칸 지움 · 빌더 결과와 셈 칸이 다르면 손고침 표지
- 빌더: 저장본 기계덮음 이어받음 · 손고침 문서 저장본 그대로 + 목록
- 시험 test_848_1_cover_layers(거울 36 경우 · M01 · SK · 굳힘 · A→B)

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
2026-11-16 20:19:31 +09:00
co-authored by Claude Opus 5.5
parent f7df6e3ca1
commit c33d200a68
12 changed files with 906 additions and 52 deletions
+172 -18
View File
@@ -8,8 +8,12 @@
* 셈 규칙(`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_842_3_machine_crew.py · test_848_1_cover_layers.py
* · 화면 · DOM · fetch 없음
* ========================================================================== */
@@ -22,10 +26,18 @@ import {
type FormulaDoc,
type MoneyLine,
} from "./common_util_formula_doc";
import { WORK, pruneWork, type WorkCover } from "./common_util_formula_doc_work";
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_시간환산";
@@ -224,36 +236,174 @@ const sameVal = (a: unknown, b: unknown): boolean =>
? 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 꼴 지킴) */
/** 기계 덮음 + 시간당 작업량(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 */
export function prune(entry: CoverEntry, base: CoverBase): CoverEntry | null {
/** 위 층과 같은 칸 · 줄을 뺀 덮음(바꿨다 되돌림 = 안 고침) · 다 빠지면 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 base.값 && sameVal(v, base.값[k])),
([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(base.조종원)) out.조종원 = entry.조종원;
if (entry.잡품 && canon(entry.잡품) !== canon(base.잡품)) out.잡품 = entry.잡품;
const work = pruneWork(entry[WORK], base[WORK] ?? null);
if (work) out[WORK] = work;
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 held = { ...(base ?? {}), ...(form === upForm ? (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);
const kept = prune(entry, base, upper);
if (kept) all[machine] = kept;
else delete all[machine];
if (Object.keys(all).length) box[COVER] = all;
@@ -388,17 +538,21 @@ export function rowEntry(doc: FormulaDoc, vals: Vals | null | undefined): Machin
return Object.keys(out).length ? out : null;
}
/** 바탕 덮음 위에 단가산출 덮음 — 값 = 칸별 · 조종원 · 잡품 = 목록 통째(있는 부분만) */
/** 바탕 덮음(위 층) 위에 단가산출 덮음(아래 층) — 값 = 칸별 · 조종원 · 잡품 = 목록 통째(있는 부분만) ·
* 작업량 = `mergeWork`(848-1) */
export function mergeCover(
base: MachineCover | null | undefined,
top: MachineCover | null | undefined,
): MachineCover | null {
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: MachineCover = { ...base, ...top };
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;
}