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:
@@ -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;
|
||||
}
|
||||
|
||||
|
||||
Reference in New Issue
Block a user