refactor(856-1): 단가산출 상세 몸 걷기 — 줄 쌓기 한 벌 · 열 때 서버 셈 한 번
- 지움: M01 LogicLab_Ho · LogicLab_Cover · M02 Sangeun_Cover_Model · Sangeun_Undo · Sangeun_BaseHead · Labor_RowSk - Sangeun_Detail: 숨긴 몸 · 바탕 원값(bare) 셈 · 덮개 고침 · 재료 고름 · 키 글자 약속(SK-000000) 걷음 → 모드 옵션(page · ref · memory) - Sangeun_Tabs: 몸 그릇 · 숨김 걷음 · Sangeun_Cover: 뺀 줄 띠 걷음 · 셈 보기 덧칸 끔(머리 띠는 안 씀) · 머리 띠 타입만 둠(856-2 에서 파일째) - 일위대가 줄 모달: 로직 줄 · 셈 주입 줄 = 안내 한 줄(856-3 까지) · 상세 · [적용] 걷음 · 줄 패치 칸 · 타입 걷음(저장본 0) - M01 LogicLab_Detail: M02 몸 칸 걷음(M01 보기 그대로) · 지운 파일만 쓰던 글 키 16 · CSS 규칙 걷음 - 시험: 지운 몸만 붙든 시험 지움(717_3 · 722 · 748_0 · helper 728_2 · 748_0) · 섞인 파일은 몸 꼴 · 글 대조 함수 · 줄만 지움(서버 셈 시험 남김) · 856-0 단언 뒤집음 - 수치: 열 때 /sangeun/calc 2 → 1 · 숨은 몸 DOM 2 → 0 · 화면 파일 줄 −1.9 천 안팎 Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
@@ -111,6 +111,7 @@ export function openImported(o: ImportedOptions): void {
|
||||
layer: o.target.layer,
|
||||
owner: o.target.owner,
|
||||
readOnly,
|
||||
mode: sk ? "ref" : "memory", // 856-1 저장 전 = 가져온 식 문서째 보기
|
||||
onChanged: (d) => (dirty ||= d),
|
||||
});
|
||||
draw();
|
||||
|
||||
@@ -10,7 +10,6 @@ import {
|
||||
type SubBrief,
|
||||
} from "../M01_MasterData/M01_MasterData_UI_Logic_Api";
|
||||
import type { LaborCalc, LaborFixed, LaborRef, LaborSpec } from "./M02_MasterTemplete_Labor_Calc";
|
||||
import type { LinePatch } from "./logic/M02_Sangeun_Cover_Model";
|
||||
import {
|
||||
call,
|
||||
getActiveLayer,
|
||||
@@ -109,8 +108,6 @@ export interface LaborRow {
|
||||
자재표시?: Record<string, MatMarks>;
|
||||
/** 고정 줄(705-1 · 705-2 붙여넣기) — 숫자 그대로 · 로직 · 참조 없음 */
|
||||
고정?: LaborFixed;
|
||||
/** 그 줄 덮개(715-3 · 717-3 단가산출 모달) — 로직 줄 · SK 참조 줄 · 서버가 검사 */
|
||||
패치?: LinePatch;
|
||||
/** 넣어 펼친 줄 출처(740-1 · 740-2 꼬리표) — {층, 주인, 키, 이름, 때} · 셈에 안 씀 */
|
||||
본뜬?: Record<string, unknown>;
|
||||
}
|
||||
@@ -205,7 +202,6 @@ export function normalizeLabor(doc: unknown, column: string): LaborDoc {
|
||||
...(r.승격 === true && !r.참조 ? { 승격: true } : {}),
|
||||
...(r.참조 || r.고정 ? {} : cleanShown(r.자재표시)),
|
||||
...(r.고정 ? { 고정: r.고정 } : {}), // 705-1 — 읽을 때 떨구면 [저장]에서 줄이 사라짐
|
||||
...(r.패치 ? { 패치: r.패치 } : {}), // 717-3 — 떨구면 [저장]에서 줄 덮개가 사라짐
|
||||
...(r.본뜬 ? { 본뜬: r.본뜬 } : {}), // 740-2 — 출처 꼬리표
|
||||
})),
|
||||
자재: (d.자재 ?? []).map((m) => ({
|
||||
|
||||
@@ -1,31 +1,24 @@
|
||||
/* =============================================================================
|
||||
* M02_MasterTemplete_Labor_RowModal.ts
|
||||
* 일위대가표 줄 누름 모달(PLAN 723-2 · 723-3 · 요구서_내역16 2장 4 · 5) — 일위대가표에서 빠진 줄 동작을 모달 안으로.
|
||||
* · 로직 줄(단가산출 문서 없음) · 셈 주입 SK 줄 = 머리(이름 · 「1 ㎡ 당」) ·
|
||||
* 단가산출 상세 줄 모드(717-2b · `Labor_RowSk` · 수식 보기 하나(836-3) · 옛 [항목 추가] · [율 줄 추가] 없음) ·
|
||||
* 일위대가표 줄 누름 모달(PLAN 723-2 · 요구서_내역16 2장 4 · 5 · 856-1) — 일위대가표에서 빠진 줄 동작을 모달 안으로.
|
||||
* · 로직 줄(단가산출 문서 없음) · 셈 주입 줄(프로젝트 사본) = 머리(이름 · 「1 ㎡ 당」 · 옵션 값 · 메모) + 안내 한 줄
|
||||
* (856-1 — 옛 단가산출 상세 몸 · [적용] 걷음 · 고침 = 단가산출 줄 쌓기 · 856-3 에서 줄 쌓기 보기로) ·
|
||||
* 로직 자재(바꾸기 · 기본 · 세 칸 · `Labor_LogicMats`)
|
||||
* · [적용] = 그 줄 덮개(M02 변경 항목) + 옵션(상세 옵션 칸 → 그 줄 입력값)
|
||||
* · 808-1(요구 701-4 · 5) — 옛 [옵션] · [단가산출로도 저장] · [항목 추가] · [율 줄 추가] 걷음 · 일위대가 줄 = 저장 때
|
||||
* M01 로직 줄 + 고침으로 펼쳐 담김(740-1 · `본뜬` = 온 단가산출) → 수식 문서 없음 = 수식 보기 없이 단가산출 상세 몸만 +
|
||||
* 안내(온 단가산출 이름 · 수식은 그 단가산출에서 고쳐 다시 담음)
|
||||
* · 사용자 자재 줄 = 자재 모달(세 칸 · `Labor_MatTable` 한 줄)
|
||||
* · 고침 = 그 줄 화면 캐시(저장은 [저장]) · 금액은 표가 다시 셈 → `watch` 로 받아 다시 그림
|
||||
* ========================================================================== */
|
||||
|
||||
import { createBanner } from "@ui/ui_template_banner";
|
||||
import { createButton, el, showToast } from "@ui/ui_template_elements";
|
||||
import { askConfirm, openModal } from "@ui/ui_template_modal";
|
||||
import { el, showToast } from "@ui/ui_template_elements";
|
||||
import { openModal } from "@ui/ui_template_modal";
|
||||
import { createText } from "@ui/ui_template_text";
|
||||
import type { ItemLogic } from "./M02_MasterTemplete_Api_Fetch";
|
||||
import type { LaborCalc, LaborMat, LaborRow, MatMarkKey } from "./M02_MasterTemplete_Labor_Api";
|
||||
import { logicMatRows } from "./M02_MasterTemplete_Labor_LogicMats";
|
||||
import { setLogicMark, setMark } from "./M02_MasterTemplete_Labor_MatMarks";
|
||||
import { matTable } from "./M02_MasterTemplete_Labor_MatTable";
|
||||
import { mountRowSk, type RowSkHandle } from "./M02_MasterTemplete_Labor_RowSk";
|
||||
import { tc } from "./M02_MasterTemplete_Labor_Text";
|
||||
import type { SkScope } from "./M02_MasterTemplete_Sangeun_Cover";
|
||||
import { releaseTied } from "./M02_Labor_LogicMats_Model";
|
||||
import { keepKnown, valueLine } from "./M02_Labor_Values_Model";
|
||||
import { valueLine } from "./M02_Labor_Values_Model";
|
||||
|
||||
/** 표가 다시 센 답을 받음 — 돌려준 함수 = 그만 받음 */
|
||||
export type CalcWatch = (fn: (calc: LaborCalc | null) => void) => () => void;
|
||||
@@ -36,11 +29,8 @@ export interface RowModalOptions {
|
||||
title: string;
|
||||
/** 일위대가 머리(이름 · 「1 ㎡ 당」) */
|
||||
head: string;
|
||||
/** 줄 분모(SK 단위 기본) */
|
||||
unit: string;
|
||||
scope: SkScope;
|
||||
readOnly: boolean;
|
||||
/** 셈 주입(프로젝트 복사본) — 단가산출 상세 없음 */
|
||||
/** 셈 주입(프로젝트 복사본) — 안내 글이 다름 */
|
||||
inject: boolean;
|
||||
/** 사용자 자재 코드 — 로직 자재 [바꾸기]로 같은 품목 막음 */
|
||||
userMats: string[];
|
||||
@@ -50,16 +40,18 @@ export interface RowModalOptions {
|
||||
}
|
||||
|
||||
const TEXT = {
|
||||
Apply: ["적용", "Apply"],
|
||||
NoDoc: [
|
||||
"M01 로직을 바로 쓴 줄 — 수식 탭은 단가산출 문서가 있어야 열림(단가산출을 만들어 담음) · 여기서는 단가산출 상세만",
|
||||
"Uses the M01 logic directly — the equation tab needs a build-up document",
|
||||
"M01 로직을 바로 담은 줄 — 단가산출 화면 없음 · 고침은 단가산출로 담아(일위대가 [로직 추가]) 그 줄에서",
|
||||
"Uses the M01 logic directly — add it as a build-up to edit",
|
||||
],
|
||||
FromSk: [
|
||||
"단가산출 「{k}」 에서 담아 온 줄(담을 때 펼침) — 수식은 그 단가산출에서 고쳐 다시 담음 · 여기서는 단가산출 상세만",
|
||||
"Copied from build-up 「{k}」 — edit its equation there and re-add",
|
||||
"단가산출 「{k}」 에서 담아 온 줄 — 고침은 그 단가산출에서 고쳐 다시 담음",
|
||||
"Copied from build-up 「{k}」 — edit it there and re-add",
|
||||
],
|
||||
Inject: [
|
||||
"프로젝트 사본 줄 — 단가산출 화면 없음 · 수식 고침은 M02 단가산출에서 고쳐 [재생성]",
|
||||
"Project copy line — edit the build-up in M02 and regenerate",
|
||||
],
|
||||
Discard: ["적용 안 한 고침이 있음 — 버리고 닫을까?", "Discard unapplied edits?"],
|
||||
} as const;
|
||||
const t = (k: keyof typeof TEXT): string => TEXT[k][0];
|
||||
|
||||
@@ -69,7 +61,6 @@ export function openRowModal(o: RowModalOptions): void {
|
||||
const info = el("div", { attrs: { "data-row-head": "" } });
|
||||
const mats = el("div", { attrs: { "data-row-mats": "" } });
|
||||
let calc: LaborCalc | null = null;
|
||||
const line = () => calc?.줄.find((l) => !row.참조 && l.로직 === row.로직);
|
||||
|
||||
const draw = (): void => {
|
||||
const values = valueLine(o.logic?.입력 ?? [], row.입력값);
|
||||
@@ -117,84 +108,25 @@ export function openRowModal(o: RowModalOptions): void {
|
||||
);
|
||||
};
|
||||
|
||||
/** 옵션 → 그 줄 입력값(로직 줄만 · 아는 입력만) · 같으면 참 */
|
||||
function setValues(next: Record<string, string | number>): boolean {
|
||||
if (row.참조) return true;
|
||||
const values = o.logic ? keepKnown(o.logic.입력, next).kept : next;
|
||||
if (JSON.stringify(values) === JSON.stringify(row.입력값)) return true;
|
||||
const before = row.입력값;
|
||||
row.입력값 = values;
|
||||
releaseTied(row, before, line()?.재료 ?? []); // 바뀐 입력에 걸린 고름 = 기본(103-1)
|
||||
return false;
|
||||
}
|
||||
|
||||
// 단가산출 상세 줄 모드(723-3) — 셈 주입(프로젝트 복사본)엔 없음 · 수식 단추 = 모달 머리(808-1)
|
||||
const slot = el("span", { className: "m02-main__tools" });
|
||||
const skHost = el("div", { attrs: { "data-row-sk-host": "" } });
|
||||
let sk: RowSkHandle | null = null;
|
||||
const skMount = (): void => {
|
||||
if (o.inject) return;
|
||||
sk?.destroy();
|
||||
sk = mountRowSk(skHost, {
|
||||
row,
|
||||
scope: o.scope,
|
||||
title: o.title,
|
||||
unit: o.unit,
|
||||
readOnly: !edit,
|
||||
slot,
|
||||
});
|
||||
};
|
||||
let close = (): void => {};
|
||||
const finish = (): void => {
|
||||
stop();
|
||||
sk?.destroy();
|
||||
};
|
||||
const apply = createButton({
|
||||
label: t("Apply"),
|
||||
variant: "filled",
|
||||
onClick: () => {
|
||||
const got = sk?.take() ?? null;
|
||||
if (got) {
|
||||
if (got.patch) row.패치 = got.patch;
|
||||
else delete row.패치;
|
||||
setValues(got.values);
|
||||
o.done(true);
|
||||
draw();
|
||||
}
|
||||
finish(); // [적용] = 그 줄에 남기고 닫음(저장은 페이지 [저장]) · 코드 닫기는 beforeClose 안 거침
|
||||
close();
|
||||
},
|
||||
});
|
||||
// 수식 문서 없는 줄(808-1) — 안내 한 줄(온 단가산출 = `본뜬`)
|
||||
// 안내 한 줄(856-1) — 로직 줄 = 온 단가산출(`본뜬`) · 셈 주입 = 프로젝트 사본
|
||||
const from = row.본뜬 && typeof row.본뜬.이름 === "string" ? row.본뜬.이름 : "";
|
||||
const noDoc =
|
||||
!row.참조 && !o.inject
|
||||
? createBanner({
|
||||
tone: "info",
|
||||
text: from ? t("FromSk").replace("{k}", from) : t("NoDoc"),
|
||||
})
|
||||
: null;
|
||||
apply.dataset.rowApply = "";
|
||||
const note = createBanner({
|
||||
tone: "info",
|
||||
text: o.inject ? t("Inject") : from ? t("FromSk").replace("{k}", from) : t("NoDoc"),
|
||||
});
|
||||
const stop = o.watch((c) => {
|
||||
calc = c;
|
||||
draw();
|
||||
});
|
||||
const tools = edit && !o.inject ? [apply] : [];
|
||||
({ close } = openModal({
|
||||
openModal({
|
||||
title: o.title,
|
||||
closeLabel: tc("In_Close"),
|
||||
width: "1100px",
|
||||
wide: true,
|
||||
actions: row.참조 ? [slot, ...tools] : tools, // 로직 줄 = 머리 단추 없음(상세만)
|
||||
beforeClose: async () => {
|
||||
if (sk?.take() && !(await askConfirm({ message: t("Discard"), danger: true }))) return false;
|
||||
finish();
|
||||
return true;
|
||||
},
|
||||
mount: (body) => body.append(info, ...(noDoc ? [noDoc] : []), skHost, mats),
|
||||
}));
|
||||
beforeClose: () => (stop(), true),
|
||||
mount: (body) => body.append(info, note, mats),
|
||||
});
|
||||
draw();
|
||||
skMount();
|
||||
}
|
||||
|
||||
export interface MatModalOptions {
|
||||
|
||||
@@ -1,101 +0,0 @@
|
||||
/* =============================================================================
|
||||
* M02_MasterTemplete_Labor_RowSk.ts
|
||||
* 일위대가 줄 모달 안 단가산출 상세 = 717-2b 단가산출(SK) 상세 「줄 모드」(PLAN 723-3 · 정함 4 · 5).
|
||||
* · 줄 → 이름 없는 SK 문서(`lineDoc` · 고름 · 자재표시 = 바탕 줄 정체 cid) → `mountSangeunDetail` 그대로 얹음
|
||||
* (보기 넷 · 공용 상세(724-1 `LogicLab_Ho`) 줄 모달 품 · 단가 덮개 · 줄 빼기 · 더하기 · 박스 옵션 · 입력 칩)
|
||||
* · `take()` = [적용] 때 그 줄에 남길 것 — 패치 `{덮개, 뺀줄, 더한줄}`(M02 변경 항목 · M01 안 바뀜 · 내역 17-2) +
|
||||
* 옵션(시험 입력 → 그 줄 `입력값` · 정함 5)
|
||||
* · 옛 [단가산출로도 저장] 걷음(808-1 · 요구 701-4 — 일위대가 줄은 단가산출을 담아서만)
|
||||
* ========================================================================== */
|
||||
|
||||
import { el } from "@ui/ui_template_elements";
|
||||
import { createText } from "@ui/ui_template_text";
|
||||
import { fetchAuto } from "../M01_MasterData/M01_MasterData_UI_Logic_Api";
|
||||
import type { LaborRow } from "./M02_MasterTemplete_Labor_Api";
|
||||
import { calcSangeun, type SkScope } from "./M02_MasterTemplete_Sangeun_Cover";
|
||||
import { mountSangeunDetail } from "./M02_MasterTemplete_Sangeun_Detail";
|
||||
import { cleanPatch, lineDoc, needsIds, type LinePatch } from "./logic/M02_Sangeun_Cover_Model";
|
||||
|
||||
export interface RowSkHandle {
|
||||
/** 고친 것(패치 · 옵션) — 없으면 null */
|
||||
take: () => { patch: LinePatch | null; values: Record<string, string> } | null;
|
||||
destroy: () => void;
|
||||
}
|
||||
|
||||
const same = (a: unknown, b: unknown): boolean => JSON.stringify(a) === JSON.stringify(b);
|
||||
|
||||
/** 줄 모드 SK 상세를 `host` 에 — 바탕 줄 정체가 필요하면 먼저 셈 */
|
||||
export function mountRowSk(
|
||||
host: HTMLElement,
|
||||
o: {
|
||||
row: LaborRow;
|
||||
scope: SkScope;
|
||||
title: string;
|
||||
unit: string;
|
||||
readOnly: boolean;
|
||||
/** 모달 머리 칸(808-1) — 보기 고르기 · 수식 단추(옛 [항목 추가] · [율 줄 추가] 줄 없음) */
|
||||
slot?: HTMLElement;
|
||||
},
|
||||
): RowSkHandle {
|
||||
let handle: ReturnType<typeof mountSangeunDetail> | null = null;
|
||||
let alive = true;
|
||||
/** 자동값(상세가 빈 입력에 채움) — 손대지 않은 자동값은 줄에 안 남김(빈 값 = 자동값 그대로) */
|
||||
let auto: Record<string, unknown> = {};
|
||||
const before = cleanPatch(o.row.패치);
|
||||
const values0 = Object.fromEntries(
|
||||
Object.entries(o.row.입력값 ?? {}).map(([k, v]) => [k, String(v)]),
|
||||
);
|
||||
host.replaceChildren(createText("…", "muted"));
|
||||
void (async () => {
|
||||
let ids: string[] | null = null;
|
||||
try {
|
||||
if (needsIds(o.row))
|
||||
ids = (await calcSangeun(o.scope, lineDoc(o.row, null, null))).정체 ?? null;
|
||||
} catch {
|
||||
ids = null; // 정체 못 받음 = 고름 · 자재표시 없이(셈 까닭은 상세가 보임)
|
||||
}
|
||||
if (!alive) return;
|
||||
const doc = {
|
||||
...lineDoc(o.row, ids, before),
|
||||
...(before?.뺀더한줄 ? { 뺀더한줄: before.뺀더한줄 } : {}), // 되살림 기억(744-1 · 셈엔 안 듦)
|
||||
이름: o.title,
|
||||
단위: o.unit || "식",
|
||||
};
|
||||
const box = el("div", { attrs: { "data-row-sk": "" } });
|
||||
host.replaceChildren(box);
|
||||
handle = mountSangeunDetail(box, doc, {
|
||||
layer: o.scope.layer,
|
||||
owner: o.scope.owner,
|
||||
readOnly: o.readOnly,
|
||||
onChanged: () => undefined,
|
||||
slot: o.slot,
|
||||
});
|
||||
if (o.row.로직 && !o.row.참조) auto = await fetchAuto(o.row.로직).catch(() => ({}));
|
||||
})();
|
||||
return {
|
||||
take: () => {
|
||||
if (!handle) return null;
|
||||
const d = handle.getDoc();
|
||||
const patch = cleanPatch({
|
||||
덮개: d.덮개 as LinePatch["덮개"],
|
||||
뺀줄: d.뺀줄,
|
||||
더한줄: d.더한줄,
|
||||
뺀더한줄: d.뺀더한줄,
|
||||
});
|
||||
const values = o.row.참조
|
||||
? values0
|
||||
: Object.fromEntries(
|
||||
Object.entries(handle.getValues()).filter(
|
||||
([k, v]) =>
|
||||
String(v).trim() !== "" &&
|
||||
(k in values0 || auto[k] == null || String(auto[k]) !== String(v)),
|
||||
),
|
||||
);
|
||||
return same(patch, before) && same(values, values0) ? null : { patch, values };
|
||||
},
|
||||
destroy: () => {
|
||||
alive = false;
|
||||
handle?.destroy();
|
||||
},
|
||||
};
|
||||
}
|
||||
@@ -77,7 +77,7 @@ export async function openSkEdit(opt: SkEditOptions): Promise<void> {
|
||||
readOnly: opt.readOnly,
|
||||
onChanged: (d) => (dirty = d && !opt.readOnly),
|
||||
onVersion: (v) => (version = v), // 수식 저장이 파일 판을 바꿈 — 문서 저장이 이어 받음
|
||||
source: true, // 페이지와 같은 길 — 수식 저장 단추는 이 [저장] 한 번에 모임
|
||||
mode: "page", // 페이지와 같은 길 — 수식 저장 단추는 이 [저장] 한 번에 모임
|
||||
slot,
|
||||
});
|
||||
const ok = createButton({
|
||||
|
||||
@@ -7,7 +7,7 @@
|
||||
* 금액 빠짐) → 그 줄 금액 · 합계 바로(짝 셈 `Labor_Calc.settle`) · 구조물 조합 · 공사 알약이 이어지면 그 값이 앞섬
|
||||
* · 합계 열 = 「기준단위 단가」(줄 1 단위) · 「수량 반영 금액」(× 수량)
|
||||
* · 머리 단추 = [항목 추가](736-1 · 자재는 찾기 창에서 고름 → 자재 목록) · 줄 우클릭 · 줄 끝 ⋯ = 위로 · 아래로 · 별칭 · 삭제
|
||||
* · 줄 누름 = 줄 모달(`Labor_RowModal` — 옵션 · 메모 · 켜쌓기율 · 로직 자재 바꾸기 · 세 칸 · 단가산출) ·
|
||||
* · 줄 누름 = 줄 모달(`Labor_RowModal` — 옵션 · 메모 · 켜쌓기율 · 로직 자재 바꾸기 · 세 칸 · 안내 한 줄 · 856-1) ·
|
||||
* 사전조합 참조 줄 = 서고 원본 모달(`Labor_RefEdit`) · 사용자 자재 줄 = 자재 모달(세 칸)
|
||||
* · 금액 = 서버 calc(최신 응답만 · 저장 안 함) · [저장]은 UI_Main(서버가 다시 셈)
|
||||
* · 안 이은 고정 줄(729-3) = 격자 위 띠 · [연결](`Labor_Unlinked` — 이음만 · 저장은 [저장])
|
||||
@@ -333,7 +333,7 @@ export function mountLaborTable(
|
||||
closed: () => alive && recalc(),
|
||||
});
|
||||
if (row.고정) return; // 고정 줄 = 숫자 그대로(이름 · 별칭은 우클릭)
|
||||
// 단가산출(SK) 줄 = 그 단가산출 문서 모달(수식 탭 · 806-1) — 셈 주입(프로젝트 복사본)엔 옛 줄 모달
|
||||
// 단가산출(SK) 줄 = 그 단가산출 문서 모달(수식 탭 · 806-1) — 셈 주입(프로젝트 복사본)엔 줄 모달(안내 · 856-3 까지)
|
||||
if (isSkRef(row.참조) && !opt.calc)
|
||||
return void openSkEdit({
|
||||
ref: row.참조,
|
||||
@@ -347,9 +347,7 @@ export function mountLaborTable(
|
||||
logic: logics.get(row.로직) ?? null,
|
||||
title: nameOf(row),
|
||||
head: head(),
|
||||
unit: lineOf(row)?.분모 ?? "",
|
||||
watch,
|
||||
scope: { layer: opt.layer, owner: library.owner },
|
||||
readOnly: !edit,
|
||||
inject: !!opt.calc,
|
||||
userMats: cur.자재.map((m) => m.코드),
|
||||
|
||||
@@ -1,4 +1,4 @@
|
||||
/* M02 단가산출(SK) 상세 · 고침 표(PLAN 717-2b) — 표 · 단추 · 배지는 부품 상자 · 여기는 자리 · 고친 칸 색만 */
|
||||
/* M02 단가산출(SK) 화면(PLAN 717-2b · 856-1) — 표 · 단추 · 배지는 부품 상자 · 여기는 자리만 */
|
||||
|
||||
.m02-sk {
|
||||
display: flex;
|
||||
@@ -29,55 +29,9 @@
|
||||
min-width: 120px;
|
||||
}
|
||||
|
||||
.m02-sk__tags,
|
||||
.m02-sk__basehead,
|
||||
.m02-sk__removed,
|
||||
.m02-sk__removed-item {
|
||||
.m02-sk__tags {
|
||||
display: flex;
|
||||
flex-wrap: wrap;
|
||||
align-items: center;
|
||||
gap: 4px;
|
||||
}
|
||||
|
||||
.m02-sk__removed {
|
||||
gap: 8px;
|
||||
}
|
||||
|
||||
/* 748-0 둘째 기초 머리 줄 — 이름 · 수량 칸 · 단추 한 줄 */
|
||||
.m02-sk__basehead {
|
||||
gap: var(--spacing-8);
|
||||
align-items: flex-end;
|
||||
}
|
||||
|
||||
.m02-sk__basename {
|
||||
flex: 0 1 16em;
|
||||
min-width: 0;
|
||||
align-self: center;
|
||||
font-weight: var(--font-weight-bold);
|
||||
}
|
||||
|
||||
/* 740-2 이름 + 출처 꼬리표 한 줄 — 이름이 말줄임으로 줄고 꼬리표는 그대로 */
|
||||
.m02-sk .m01lab__namerow {
|
||||
display: flex;
|
||||
align-items: center;
|
||||
gap: var(--spacing-4);
|
||||
min-width: 0;
|
||||
}
|
||||
|
||||
.m02-sk .m01lab__namerow > span:first-child {
|
||||
min-width: 0;
|
||||
overflow: hidden;
|
||||
text-overflow: ellipsis;
|
||||
white-space: nowrap;
|
||||
}
|
||||
|
||||
/* 727-2 기초 출처 꼬리표 — 칸 폭 고정 · 넘치면 말줄임(풍선 = 온 글) · 이름 칸 폭을 안 바꿈 */
|
||||
.m02-sk .m01lab__src {
|
||||
display: inline-block;
|
||||
flex: none;
|
||||
max-width: 9em;
|
||||
overflow: hidden;
|
||||
text-overflow: ellipsis;
|
||||
white-space: nowrap;
|
||||
vertical-align: middle;
|
||||
}
|
||||
|
||||
@@ -1,92 +0,0 @@
|
||||
/* =============================================================================
|
||||
* M02_MasterTemplete_Sangeun_BaseHead.ts
|
||||
* 단가산출(SK) 둘째 기초 머리 줄(PLAN 748-0) — 기초마다 한 줄: 이름 · 「수량(기준단위 몇 개)」 칸 하나 ·
|
||||
* [되돌림](넣을 때 수량으로) · [기초 빼기]. 세부 품은 M01 원문 그대로 보임(머리 수량은 이 칸 하나로).
|
||||
* 값은 문서 `더한줄[k].수량`(화면배 t 로 나눈 화면 값) — 금액은 서버가 셈 · 여기는 칸 · 단추만.
|
||||
* ========================================================================== */
|
||||
|
||||
import { createBadge } from "@ui/ui_template_badge";
|
||||
import { createButton } from "@ui/ui_template_button";
|
||||
import { createCard } from "@ui/ui_template_card";
|
||||
import { el } from "@ui/ui_template_elements";
|
||||
import { createInputField } from "@ui/ui_template_input";
|
||||
import { t as L } from "@ui/ui_template_locale";
|
||||
import { createText } from "@ui/ui_template_text";
|
||||
import type { SkAnswer, SkDoc } from "./logic/M02_Sangeun_Cover_Model";
|
||||
|
||||
export interface BaseHeadOptions {
|
||||
doc: SkDoc;
|
||||
ans: SkAnswer | null;
|
||||
edit: boolean;
|
||||
/** 칸에서 고른 새 수량(화면 값) */
|
||||
onQty: (k: number, qty: number) => void;
|
||||
onReset: (k: number) => void;
|
||||
onDrop: (k: number, name: string) => void;
|
||||
}
|
||||
|
||||
const shown = (v: number): string => String(Number(v.toPrecision(8)));
|
||||
const same = (a: number, b: number): boolean => Math.abs(a - b) <= 1e-9 * Math.max(1, Math.abs(a));
|
||||
|
||||
/** 둘째 기초(더한줄 로직)마다 머리 줄 한 상자 — 없으면 빈 목록 */
|
||||
export function baseHeads(o: BaseHeadOptions): HTMLElement[] {
|
||||
const t = o.ans?.화면배 ?? 1;
|
||||
const rows = (o.doc.더한줄 ?? []).flatMap((one, k) => {
|
||||
if (one.종류 !== "로직") return [];
|
||||
const line = o.ans?.줄.find((x) => x.cid === `add:#${k}`);
|
||||
const name = line?.이름 || String(one.로직 ?? "");
|
||||
const box = createInputField({
|
||||
label: L("M02_SangeunBaseQty"),
|
||||
value: shown(one.수량 / t),
|
||||
compact: true,
|
||||
size: 28,
|
||||
});
|
||||
box.input.inputMode = "decimal";
|
||||
box.input.disabled = !o.edit;
|
||||
box.input.dataset.baseQty = String(k);
|
||||
box.input.addEventListener("change", () => {
|
||||
const v = Number(box.input.value.replaceAll(",", "").trim());
|
||||
if (box.input.value.trim() === "" || !Number.isFinite(v) || v < 0)
|
||||
return box.setError(L("M02_SangeunBaseQtyBad"));
|
||||
box.setError(undefined);
|
||||
if (!same(v, one.수량 / t)) o.onQty(k, v);
|
||||
});
|
||||
const first = one.처음수량;
|
||||
return [
|
||||
el("div", {
|
||||
className: "m02-sk__basehead",
|
||||
attrs: { "data-base-head": String(k) },
|
||||
children: [
|
||||
el("span", { className: "m02-sk__basename", text: name }),
|
||||
...(line?.꼬리표 ? [createBadge(line.꼬리표, "neutral")] : []),
|
||||
box.root,
|
||||
...(line?.단위 ? [createText(line.단위, "muted")] : []),
|
||||
...(o.edit && first != null && !same(first, one.수량)
|
||||
? [
|
||||
createButton({
|
||||
label: L("M02_SangeunQtyUndo"),
|
||||
variant: "ghost",
|
||||
size: 28,
|
||||
onClick: () => o.onReset(k),
|
||||
}),
|
||||
]
|
||||
: []),
|
||||
...(o.edit
|
||||
? [
|
||||
createButton({
|
||||
label: L("M02_SangeunDropBase"),
|
||||
variant: "danger-ghost",
|
||||
size: 28,
|
||||
onClick: () => o.onDrop(k, name),
|
||||
}),
|
||||
]
|
||||
: []),
|
||||
],
|
||||
}),
|
||||
];
|
||||
});
|
||||
if (!rows.length) return [];
|
||||
const card = createCard({ title: L("M02_SangeunBases"), pad: 12, body: rows });
|
||||
card.classList.add("m01lab__ho-box"); // 상자 제목 · 안 간격 = 공용 상세 상자와 같음
|
||||
card.dataset.baseHeads = "";
|
||||
return [card];
|
||||
}
|
||||
@@ -1,72 +1,50 @@
|
||||
/* =============================================================================
|
||||
* M02_MasterTemplete_Sangeun_Cover.ts
|
||||
* 단가산출(SK) 셈 길 부름 · 뺀 줄 띠(PLAN 717-2b · 717-3 · 724-1)
|
||||
* 단가산출(SK) 셈 길 부름(PLAN 717-2b · 856-1) — 머리 띠 · 배지용(856-2 에서 문서 답으로 바꾸고 이 파일 지움)
|
||||
* · 셈 = `calcSangeun`(`POST /layers/{층}/sangeun/calc` · 저장 안 함 · 부르는 쪽이 최신 응답만 받음)
|
||||
* · 고침 표는 공용 상세(`M01_MasterData_UI_LogicLab_Ho` · 724-1) — 여기는 뺀 줄 되살림 띠만
|
||||
* ========================================================================== */
|
||||
|
||||
import { createBadge } from "@ui/ui_template_badge";
|
||||
import { createButton } from "@ui/ui_template_button";
|
||||
import { el } from "@ui/ui_template_elements";
|
||||
import { t as L } from "@ui/ui_template_locale";
|
||||
import { createText } from "@ui/ui_template_text";
|
||||
import { call, type Layer } from "./M02_MasterTemplete_Api_Fetch";
|
||||
import type { SkAnswer } from "./logic/M02_Sangeun_Cover_Model";
|
||||
import "./M02_MasterTemplete_Sangeun.css";
|
||||
|
||||
export interface SkScope {
|
||||
layer: Layer;
|
||||
owner: string | null;
|
||||
}
|
||||
|
||||
/** SK 문서 중 화면 머리가 만지는 칸 */
|
||||
export interface SkDoc {
|
||||
키?: string;
|
||||
이름?: string;
|
||||
단위?: string;
|
||||
바탕?: { 로직?: string; 참조?: { 층?: string; 주인?: string | null; 키?: string } } | null;
|
||||
입력값?: Record<string, unknown>;
|
||||
바탕판?: string;
|
||||
[k: string]: unknown;
|
||||
}
|
||||
|
||||
/** 셈 답 중 머리 띠 · 배지가 읽는 칸 */
|
||||
export interface SkAnswer {
|
||||
까닭?: string | null;
|
||||
/** 못 셈 줄(725) — 그 줄만 빠지고 나머지 셈 */
|
||||
빠진줄?: { cid: string; 이름: string; 까닭: string }[];
|
||||
짝잃음?: { cid: string; 까닭: string }[];
|
||||
바탕판: string;
|
||||
머리?: string;
|
||||
}
|
||||
|
||||
const q = (scope: SkScope): string =>
|
||||
scope.owner && scope.layer !== "system" ? `?owner=${encodeURIComponent(scope.owner)}` : "";
|
||||
|
||||
/** 셈(저장 안 함) — 문서 = 화면 문서 · `given` = 시험 입력(빈 칸 뺌) · 서버가 M01 엔진 한 벌로 셈 */
|
||||
export function calcSangeun<T = SkAnswer>(
|
||||
/** 셈(저장 안 함) — 문서 = 화면 문서 · `given` = 시험 입력(빈 칸 뺌) */
|
||||
export function calcSangeun(
|
||||
scope: SkScope,
|
||||
doc: Record<string, unknown>,
|
||||
given: Record<string, string> = {},
|
||||
seen = true,
|
||||
): Promise<T> {
|
||||
): Promise<SkAnswer> {
|
||||
const 입력값 = Object.fromEntries(Object.entries(given).filter(([, v]) => String(v).trim()));
|
||||
return call<T>(`/layers/${scope.layer}/sangeun/calc${q(scope)}`, {
|
||||
return call<SkAnswer>(`/layers/${scope.layer}/sangeun/calc${q(scope)}`, {
|
||||
method: "POST",
|
||||
body: JSON.stringify({ 문서: doc, 입력값, 보기: seen }), // 보기 false = 글 · 중간 덧칸 안 지음(바탕 원값 셈)
|
||||
body: JSON.stringify({ 문서: doc, 입력값, 보기: false }), // 보기 false = 글 · 중간 덧칸 안 지음(몸 걷음 · 856-1)
|
||||
});
|
||||
}
|
||||
|
||||
/** 뺀 줄(cid · 이름) 띠 — 고칠 수 있으면 [되살림] */
|
||||
export function removedStrip(
|
||||
removed: { cid: string; 이름: string }[],
|
||||
edit: boolean,
|
||||
onRestore: (cid: string) => void,
|
||||
): HTMLElement[] {
|
||||
if (!removed.length) return [];
|
||||
return [
|
||||
el("div", {
|
||||
className: "m02-sk__removed",
|
||||
attrs: { "data-removed": "" },
|
||||
children: [
|
||||
createText(L("M02_SangeunRemoved")),
|
||||
...removed.map((x) =>
|
||||
el("span", {
|
||||
className: "m02-sk__removed-item",
|
||||
children: [
|
||||
createBadge(x.이름, "neutral"),
|
||||
...(edit
|
||||
? [
|
||||
createButton({
|
||||
label: L("M02_SangeunRestore"),
|
||||
variant: "ghost",
|
||||
size: 22,
|
||||
onClick: () => onRestore(x.cid),
|
||||
}),
|
||||
]
|
||||
: []),
|
||||
],
|
||||
}),
|
||||
),
|
||||
],
|
||||
}),
|
||||
];
|
||||
}
|
||||
|
||||
@@ -1,21 +1,14 @@
|
||||
/* =============================================================================
|
||||
* M02_MasterTemplete_Sangeun_Detail.ts
|
||||
* M02 단가산출(SK) 상세(PLAN 717-2b · 724-1 · 요구서 4장 3 · 4 · 13 · 17 · 24) — M01 「단가산출 로직」 상세 부품을 M02 길로.
|
||||
* 보기 둘(`_Sangeun_Tabs` · 799-2) = 수식(공용 수식 문서 화면 · 802-4b-2 · 저장 = 페이지 [저장] 한 번(804-8 · 수식 먼저 → 판 · 수식 칸 새로)) · 단가산출 상세(공용 상세 `LogicLab_Ho` · SK 셈 답 줄 = `hoView` · 줄 모달 그 자리 고침 =
|
||||
* HoEdit → SK 덮개 · 더한줄 · 줄 빼기 · 별도계상) · 기본정보 = 바탕 로직(맨 위 접힘) — 시트 · 인력·재료·경비 · 시험 계산 · 텍스트 수식은 걷음
|
||||
* 고침 = SK 덮개 · 더한줄(`Sangeun_Pick`) · 뺀줄(꼴 = 서버 `M02_Sangeun_Doc`) · 값 = 서버 셈 길 최신 응답만
|
||||
* 옵션 칸 = SK `입력값`(727-3 · 저장 · 열린입력만 시험 값) · [저장] = 화면 문서 → 서버가 다시 셈(원값 · 바탕판)
|
||||
* 둘째 기초(727-2) = 서버 `펼침` 세부 줄 · 인력 · 재료 · 경비 상자에 함께 + 꼬리표(기초 둘 이상) · 세부 덮개 ·
|
||||
* 뺀줄 · [기초 빼기] · M01 개정 알림 · 옵션 칸 = 바탕 입력 + 더한줄 기초 입력
|
||||
* [항목 추가] 기초 = 바탕 비었으면 바탕(727-2 · 단위가 비거나 「식」이면 기초 결과단위) · 있으면 더한줄 · 바탕 없이 줄만도 됨
|
||||
* 단가산출 화면(`source` · 804-8) = M01 과 같은 꼴 — 보기 고르기는 페이지 머리 줄(`slot`) · [항목 추가] · [율 줄 추가] 걷음
|
||||
* (줄 더하기 = 수식 탭 [+] 단가산출 복사) · 수식 고침도 페이지 [저장] 한 번에(`flush` 먼저) · 고침 알림 = 기본 + 수식
|
||||
* M02 단가산출(SK) 화면(PLAN 717-2b · 804-8 · 856-1) — 머리(이름 · 단위 · 단위 환산 · 바탕) · 머리 띠 · 줄 쌓기(`_Sangeun_Tabs`).
|
||||
* 모드(856-1 · 옛 키 글자 약속 `SK-000000` 대신) = page(단가산출 화면 · 일위대가 SK 모달 — 원문 패널 · 페이지 [저장] 한 번 ·
|
||||
* 수식 먼저 → 판 · 수식 칸 새로) · ref(저장한 SK — 줄 쌓기 자기 저장 · 불러오기 저장 뒤) · memory(저장 전 가져온 식 · 보기만)
|
||||
* 머리 띠(까닭 · M01 개정 · 빠진 줄 · 짝 잃음) · 머리 배지 = 서버 셈 길 최신 응답(856-2 에서 문서 답으로)
|
||||
* 옛 상세 몸(덮개 · 뺀줄 · 더한줄 · 재료 고름 · 줄 모달)은 856-1 에 걷음 — 고침은 줄 쌓기 한 벌
|
||||
* ========================================================================== */
|
||||
|
||||
import { createBadge } from "@ui/ui_template_badge";
|
||||
import { createBanner } from "@ui/ui_template_banner";
|
||||
import { createButton } from "@ui/ui_template_button";
|
||||
import { createCheckbox } from "@ui/ui_template_checkbox";
|
||||
import { el } from "@ui/ui_template_elements";
|
||||
import { createInputField } from "@ui/ui_template_input";
|
||||
import { t as L } from "@ui/ui_template_locale";
|
||||
@@ -23,47 +16,25 @@ import { createText } from "@ui/ui_template_text";
|
||||
import {
|
||||
fetchLogic,
|
||||
setLogicApiPaths,
|
||||
type CalcLine,
|
||||
type LogicInput,
|
||||
type LogicOne,
|
||||
type LogicRow,
|
||||
type TextAnswer,
|
||||
} from "../M01_MasterData/M01_MasterData_UI_Logic_Api";
|
||||
import { buildLabDetail } from "../M01_MasterData/M01_MasterData_UI_LogicLab_Detail";
|
||||
import { buildHo, type HoEdit } from "../M01_MasterData/M01_MasterData_UI_LogicLab_Ho";
|
||||
import { readTemplate, type Layer } from "./M02_MasterTemplete_Api_Fetch";
|
||||
import { baseHeads } from "./M02_MasterTemplete_Sangeun_BaseHead";
|
||||
import { calcSangeun, removedStrip } from "./M02_MasterTemplete_Sangeun_Cover";
|
||||
import { calcSangeun, type SkAnswer, type SkDoc } from "./M02_MasterTemplete_Sangeun_Cover";
|
||||
import { createSangeunTabs } from "./M02_MasterTemplete_Sangeun_Tabs";
|
||||
import { tl } from "../M01_MasterData/M01_MasterData_UI_LogicLab_Text";
|
||||
import { createSangeunSide, tabOf, type SourceTab } from "./M02_MasterTemplete_Sangeun_Side";
|
||||
import { baseUnitOf, buildUnitSwap, type SwapHow } from "./M02_MasterTemplete_Sangeun_Unit";
|
||||
import {
|
||||
dropBase,
|
||||
dropLine,
|
||||
goneRows,
|
||||
hoView,
|
||||
removedSubs,
|
||||
restoreLine,
|
||||
revisedAdds,
|
||||
rowsOf,
|
||||
setApart,
|
||||
setLineCover,
|
||||
type CoverRow,
|
||||
type HoView,
|
||||
type SkAnswer,
|
||||
type SkDoc,
|
||||
} from "./logic/M02_Sangeun_Cover_Model";
|
||||
import { resetQty, setQty } from "./logic/M02_Sangeun_Undo";
|
||||
import { createSangeunSide, tabOf } from "./M02_MasterTemplete_Sangeun_Side";
|
||||
import { buildUnitSwap, type SwapHow } from "./M02_MasterTemplete_Sangeun_Unit";
|
||||
|
||||
export type SangeunMode = "page" | "ref" | "memory";
|
||||
|
||||
export interface SangeunDetailOptions {
|
||||
layer: Layer;
|
||||
owner: string | null;
|
||||
readOnly: boolean;
|
||||
onChanged: (dirty: boolean) => void;
|
||||
/** 752-1 오른쪽 원문 패널 — 단가산출 화면만 켬(일위대가 줄 모달 안 상세는 끔) */
|
||||
source?: boolean;
|
||||
/** 수식 탭 저장 뒤 그 SK 새 판(페이지 [저장] 409 막음 · 802-4b-2) */
|
||||
/** 856-1 화면 모드 — 머리 글 */
|
||||
mode: SangeunMode;
|
||||
/** 수식 저장 뒤 그 SK 새 판(페이지 [저장] 409 막음 · 802-4b-2) */
|
||||
onVersion?: (version: string) => void;
|
||||
slot?: HTMLElement; // 페이지 머리 줄 빈 자리(804-8) — 보기 고르기를 M01 처럼 머리 줄에
|
||||
}
|
||||
@@ -77,49 +48,38 @@ export function mountSangeunDetail(
|
||||
opt: SangeunDetailOptions,
|
||||
): {
|
||||
getDoc: () => SkDoc;
|
||||
getValues: () => Record<string, string>;
|
||||
/** 페이지 [저장] 앞 — 수식 고침 저장 · 실패면 던짐 */
|
||||
flush: () => Promise<void>;
|
||||
destroy: () => void;
|
||||
} {
|
||||
setLogicApiPaths(LIB); // 상세 부품 길 = M02 로그인 길(717-1)
|
||||
setLogicApiPaths(LIB); // 바탕 정보 길 = M02 로그인 길(717-1)
|
||||
const doc = clone((doc0 ?? {}) as SkDoc);
|
||||
let saved = JSON.stringify(doc);
|
||||
const edit = !opt.readOnly;
|
||||
const page = opt.mode === "page";
|
||||
const scope = { layer: opt.layer, owner: opt.owner };
|
||||
const values: Record<string, string> = Object.fromEntries(
|
||||
Object.entries(doc.입력값 ?? {}).map(([k, v]) => [k, String(v)]),
|
||||
);
|
||||
let base: LogicOne | null = null;
|
||||
let text: TextAnswer | null = null;
|
||||
let lastText: TextAnswer | undefined;
|
||||
let ans: SkAnswer | null = null;
|
||||
let bare: SkAnswer | null = null;
|
||||
let fail = "";
|
||||
let extra: LogicInput[] = []; // 더한줄 로직 입력 중 바탕에 없는 것 = 옵션 칸(725-6 · 727-3)
|
||||
const inputsOf = new Map<string, LogicInput[]>();
|
||||
const infoOf = new Map<string, SourceTab>(); // 더한줄 로직 → 원문 탭(752-1)
|
||||
let extraKeys: string[] = [];
|
||||
const side = opt.source ? createSangeunSide() : null;
|
||||
const side = page ? createSangeunSide() : null;
|
||||
let seq = 0;
|
||||
let alive = true;
|
||||
|
||||
const head = el("div", { className: "m02-sk__head", attrs: { "data-sk-head": "" } });
|
||||
const notes = el("div");
|
||||
const editor = el("div", { className: "m01-logic__editor" });
|
||||
let refreshing: Promise<void> = Promise.resolve();
|
||||
const tabs = createSangeunTabs(editor, {
|
||||
const tabs = createSangeunTabs({
|
||||
edit,
|
||||
scope,
|
||||
onSaved: (v) => void (refreshing = formulaSaved(v)),
|
||||
page: opt.source ? () => report() : undefined, // 804-8 페이지 [저장] · [되돌림]
|
||||
page: page ? () => report() : undefined, // 804-8 페이지 [저장] · [되돌림]
|
||||
// 836-5 저장 전 가져온 식(불러오기 미리 보기) = 그 문서째 수식 보기
|
||||
memory: () =>
|
||||
doc.가져온 && !/^SK-(?!0{6})\d{6}$/.test(doc.키 ?? "")
|
||||
? (doc as Record<string, unknown>)
|
||||
: null,
|
||||
memory: opt.mode === "memory" ? () => doc as Record<string, unknown> : undefined,
|
||||
});
|
||||
/** 수식 탭 저장 = 파일 판 · `수식` 칸이 바뀜 — 페이지 판 · 이 화면 문서 `수식` 을 새로(상세 탭 셈이 씀) */
|
||||
/** 수식 저장 = 파일 판 · `수식` 칸이 바뀜 — 페이지 판 · 이 화면 문서 `수식` 을 새로 */
|
||||
async function formulaSaved(version: string): Promise<void> {
|
||||
opt.onVersion?.(version);
|
||||
try {
|
||||
@@ -134,7 +94,6 @@ export function mountSangeunDetail(
|
||||
/* 못 읽음 = 다음 열기 때 새로 */
|
||||
}
|
||||
}
|
||||
const ownHost = el("div");
|
||||
const main = el("div", {
|
||||
className: "m02-sk",
|
||||
attrs: { "data-sangeun-detail": doc.키 ?? "" },
|
||||
@@ -143,60 +102,20 @@ export function mountSangeunDetail(
|
||||
notes,
|
||||
...(opt.slot ? [] : [el("div", { className: "m02-sk__head", children: [tabs.tools] })]),
|
||||
tabs.host,
|
||||
editor,
|
||||
],
|
||||
});
|
||||
host.replaceChildren(side ? side.wrap(main) : main);
|
||||
opt.slot?.replaceChildren(
|
||||
el("span", { className: "ui-toolbar m02-main__tools", children: [tabs.tools] }),
|
||||
);
|
||||
tabs.draw(opt.mode === "memory" ? "" : (doc.키 ?? ""));
|
||||
|
||||
const opened = (): boolean => (doc.열린입력 ?? []).length > 0;
|
||||
// 바탕 없는 SK 의 지문 = 이름 · 단위 따라 바뀜 — 바탕이 있을 때만 M01 개정으로 봄(725-3) · 둘째 기초 지문(727-2)
|
||||
// 바탕 없는 SK 의 지문 = 이름 · 단위 따라 바뀜 — 바탕이 있을 때만 M01 개정으로 봄(725-3)
|
||||
const revisedBase = (): boolean =>
|
||||
!!(doc.바탕 && doc.바탕판 && ans?.바탕판 && doc.바탕판 !== ans.바탕판) ||
|
||||
revisedAdds(ans, doc).length > 0;
|
||||
!!(doc.바탕 && doc.바탕판 && ans?.바탕판 && doc.바탕판 !== ans.바탕판);
|
||||
const baseKey = (): string | null => doc.바탕?.로직 ?? null;
|
||||
|
||||
/** 바탕 없는 · 참조 바탕 SK 의 기본정보 자리 줄 */
|
||||
const standIn = (): LogicRow => ({
|
||||
키: doc.키 ?? "",
|
||||
원문번호: "",
|
||||
이름: doc.이름 ?? "",
|
||||
결과단위: `원/${doc.단위 ?? ""}`,
|
||||
출처: doc.바탕?.참조?.키 ?? L("M02_SangeunNoBase"),
|
||||
입력: extra,
|
||||
중간: [],
|
||||
호표: [],
|
||||
덧줄: [],
|
||||
});
|
||||
|
||||
/** 더한줄 로직들의 입력을 모음(같은 이름은 하나 · 바탕 입력에 있는 이름 뺌) */
|
||||
async function syncExtra(): Promise<void> {
|
||||
const keys = [
|
||||
...new Set((doc.더한줄 ?? []).flatMap((x) => ("로직" in x ? [String(x.로직)] : []))),
|
||||
];
|
||||
await Promise.all(
|
||||
keys
|
||||
.filter((k) => !inputsOf.has(k))
|
||||
.map((k) =>
|
||||
fetchLogic(k).then(
|
||||
(r) => {
|
||||
inputsOf.set(k, r.logic.입력 ?? []);
|
||||
infoOf.set(k, tabOf(r.logic));
|
||||
},
|
||||
() => void inputsOf.set(k, []),
|
||||
),
|
||||
),
|
||||
);
|
||||
extraKeys = keys;
|
||||
const seen = new Set<string>((base?.logic.입력 ?? []).map((i) => i.이름));
|
||||
extra = keys
|
||||
.flatMap((k) => inputsOf.get(k) ?? [])
|
||||
.filter((i) => !seen.has(i.이름) && seen.add(i.이름));
|
||||
}
|
||||
|
||||
/** 고침 알림 — 기본(이름 · 단위 · 옵션 · 덮개) + 수식 탭 */
|
||||
/** 고침 알림 — 기본(이름 · 단위 · 환산) + 수식 */
|
||||
function report(): void {
|
||||
if (alive) opt.onChanged(edit && (JSON.stringify(doc) !== saved || tabs.dirty()));
|
||||
}
|
||||
@@ -206,23 +125,16 @@ export function mountSangeunDetail(
|
||||
else drawHead();
|
||||
};
|
||||
|
||||
/** 머리 띠 · 배지 = 서버 셈 한 번(최신 응답만) */
|
||||
async function recalc(): Promise<void> {
|
||||
const mine = ++seq;
|
||||
await syncExtra();
|
||||
if (mine !== seq || !alive) return;
|
||||
const plain = { ...doc, 덮개: {}, 뺀줄: [], 더한줄: [] };
|
||||
try {
|
||||
const [got, was] = await Promise.all([
|
||||
calcSangeun(scope, doc, values),
|
||||
doc.바탕 ? calcSangeun(scope, plain, values, false) : Promise.resolve(null), // 바탕 원값 = 보기 덧칸 없이
|
||||
]);
|
||||
const got = await calcSangeun(scope, doc, values);
|
||||
if (mine !== seq || !alive) return; // 늦게 온 답 — 버림
|
||||
[ans, bare, fail] = [got, was, ""];
|
||||
text = got.글 ?? null; // 750-2 텍스트 수식 · 시험 계산 = 이 답 하나(바탕 로직 따로 셈 없음)
|
||||
if (text?.ok) lastText = text;
|
||||
[ans, fail] = [got, ""];
|
||||
} catch (error) {
|
||||
if (mine !== seq || !alive) return;
|
||||
[ans, text, fail] = [null, null, error instanceof Error ? error.message : String(error)];
|
||||
[ans, fail] = [null, error instanceof Error ? error.message : String(error)];
|
||||
}
|
||||
draw();
|
||||
}
|
||||
@@ -241,7 +153,6 @@ export function mountSangeunDetail(
|
||||
};
|
||||
const baseName = base ? `${base.logic.키} ${base.logic.이름}` : null;
|
||||
const baseText = baseName ?? doc.바탕?.참조?.키 ?? L("M02_SangeunNoBase");
|
||||
const revised = revisedBase();
|
||||
const swap = base
|
||||
? buildUnitSwap({
|
||||
result: base.logic.결과단위,
|
||||
@@ -265,8 +176,7 @@ export function mountSangeunDetail(
|
||||
children: [
|
||||
createText(`${L("M02_SangeunBase")} · ${baseText}`, "muted", 14),
|
||||
...(ans?.머리 ? [createBadge(ans.머리, "info")] : []),
|
||||
...(revised ? [createBadge(L("M02_SangeunRevisedBase"), "danger")] : []),
|
||||
...(opened() ? [createBadge(L("M02_SangeunScaleOnly"), "warning")] : []),
|
||||
...(revisedBase() ? [createBadge(L("M02_SangeunRevisedBase"), "danger")] : []),
|
||||
],
|
||||
}),
|
||||
);
|
||||
@@ -275,13 +185,13 @@ export function mountSangeunDetail(
|
||||
function drawNotes(): void {
|
||||
const lost = ans?.짝잃음 ?? [];
|
||||
const gaps = ans?.빠진줄 ?? [];
|
||||
const revised = revisedBase();
|
||||
|
||||
notes.replaceChildren(
|
||||
...(fail || ans?.까닭
|
||||
? [createBanner({ tone: "danger", text: fail || String(ans?.까닭) })]
|
||||
: []),
|
||||
...(revised ? [createBanner({ tone: "warning", text: L("M02_SangeunRevisedNote") })] : []),
|
||||
...(revisedBase()
|
||||
? [createBanner({ tone: "warning", text: L("M02_SangeunRevisedNote") })]
|
||||
: []),
|
||||
...(gaps.length
|
||||
? [
|
||||
createBanner({
|
||||
@@ -307,151 +217,11 @@ export function mountSangeunDetail(
|
||||
if (!alive) return;
|
||||
drawHead();
|
||||
drawNotes();
|
||||
const rows = ans ? rowsOf(ans, bare, doc) : [];
|
||||
const names = new Map((bare ? rowsOf(bare, null, {}) : []).map((r) => [r.cid, r.이름]));
|
||||
const removed = [
|
||||
...(doc.뺀줄 ?? []).map((cid) => ({ cid, 이름: names.get(cid) ?? cid })),
|
||||
...removedSubs(ans),
|
||||
...goneRows(doc), // 뺀 더한줄(744-1)
|
||||
];
|
||||
const row = base ? { ...base.logic, 입력: [...(base.logic.입력 ?? []), ...extra] } : standIn();
|
||||
const view = ans ? hoView(ans, bare, base?.logic ?? null, doc) : null;
|
||||
tabs.draw(/^SK-(?!0{6})\d{6}$/.test(doc.키 ?? "") ? (doc.키 ?? "") : ""); // SK-000000 = 줄 문서(808-1)
|
||||
const hoCtx = {
|
||||
row: view ? { ...row, 호표: view.호표, 덧줄: view.덧줄 } : row,
|
||||
prices: base?.prices ?? {},
|
||||
lines: (view?.lines ?? null) as CalcLine[] | null,
|
||||
text,
|
||||
lastText,
|
||||
values,
|
||||
onInput,
|
||||
edit: view && edit ? hoEdit(view, rows) : undefined,
|
||||
cids: view?.cids,
|
||||
pickMat: (idx: number) => pickMat(view?.cids[idx]),
|
||||
};
|
||||
const ho = el("div", {
|
||||
attrs: { "data-sk-cover": "" },
|
||||
children: [
|
||||
...removedStrip(removed, edit, (cid) => (restoreLine(doc, cid), touch())),
|
||||
...baseHeads({
|
||||
doc,
|
||||
ans,
|
||||
edit,
|
||||
onQty: (k, qty) => {
|
||||
const one = doc.더한줄?.[k];
|
||||
if (one) setQty(one, qty * (ans?.화면배 ?? 1));
|
||||
touch();
|
||||
},
|
||||
onReset: (k) => {
|
||||
const one = doc.더한줄?.[k];
|
||||
if (one) resetQty(one);
|
||||
touch();
|
||||
},
|
||||
onDrop: (k, name) => (dropBase(doc, k, name), touch()),
|
||||
}),
|
||||
...buildHo(hoCtx),
|
||||
],
|
||||
});
|
||||
buildLabDetail(editor, {
|
||||
row: base?.logic ?? row,
|
||||
file: base?.file ?? "",
|
||||
reasons: base?.reasons ?? [],
|
||||
ownHost,
|
||||
onChange: () => undefined,
|
||||
cover: { ho },
|
||||
});
|
||||
// prettier-ignore
|
||||
side?.set([
|
||||
...(base ? [tabOf(base.logic)] : []),
|
||||
...extraKeys.flatMap((k) => (k === baseKey() ? [] : infoOf.has(k) ? [infoOf.get(k)!] : [])),
|
||||
], doc);
|
||||
side?.set(base ? [tabOf(base.logic)] : [], doc);
|
||||
}
|
||||
|
||||
/** 재료 고름(줄 모달) = SK 문서 `고름`(cid → MT) — 둘째 기초 세부 줄은 보기만 */
|
||||
function pickMat(cid: string | undefined): ((it: { ref: string }) => void) | undefined {
|
||||
if (!cid || cid.startsWith("add:#")) return undefined;
|
||||
return (it) => {
|
||||
doc.고름 = { ...(doc.고름 ?? {}), [cid]: it.ref };
|
||||
touch();
|
||||
};
|
||||
}
|
||||
|
||||
/** 공용 상세 고침 고리 — 열쇠 = Ho 줄 차례 → cid · 고침 = SK 덮개 · 더한줄(M01 안 바뀜 · 내역 17-2) ·
|
||||
* 모달 덧 동작 = 줄 빼기 · 더한 재료 별도계상 */
|
||||
function hoEdit(view: HoView, rows: CoverRow[]): HoEdit {
|
||||
const by = new Map(rows.map((r) => [r.cid, r]));
|
||||
const at = (idx: number): CoverRow | undefined => by.get(view.cids[idx]);
|
||||
return {
|
||||
covers: view.covers,
|
||||
scope: "m02",
|
||||
set: (idx, c) => {
|
||||
const r = at(idx);
|
||||
if (!r) return;
|
||||
setLineCover(doc, r, c, opened());
|
||||
touch();
|
||||
},
|
||||
more: (idx, close) => {
|
||||
const r = at(idx);
|
||||
if (!r) return { head: [], body: [] };
|
||||
const drop = createButton({
|
||||
label: L("M02_SangeunDrop"),
|
||||
variant: "danger-ghost",
|
||||
size: 32,
|
||||
onClick: () => (close(), dropLine(doc, r), touch()),
|
||||
});
|
||||
drop.dataset.skDrop = "";
|
||||
const sub = r.sub;
|
||||
const whole = sub
|
||||
? [
|
||||
createButton({
|
||||
label: L("M02_SangeunDropBase"),
|
||||
variant: "danger-ghost",
|
||||
size: 28,
|
||||
onClick: () => (
|
||||
close(),
|
||||
dropBase(doc, sub.k, ans?.줄.find((x) => x.cid === `add:#${sub.k}`)?.이름),
|
||||
touch()
|
||||
),
|
||||
}),
|
||||
]
|
||||
: [];
|
||||
const apart = r.apartPick
|
||||
? [
|
||||
createCheckbox(L("M02_SangeunApart"), {
|
||||
chip: true,
|
||||
size: 28,
|
||||
checked: r.apart,
|
||||
onChange: (on) => (close(), setApart(doc, r, on), touch()),
|
||||
}).root,
|
||||
]
|
||||
: [];
|
||||
const rest = [...apart, ...whole];
|
||||
return {
|
||||
head: [drop],
|
||||
body: rest.length ? [el("div", { className: "m02-sk__tags", children: rest })] : [],
|
||||
};
|
||||
},
|
||||
};
|
||||
}
|
||||
|
||||
/** 옵션 칸(수식 탭 · 단가산출 상세) — 입력 고침 → SK `입력값`(727-3 · 열린입력 = 시험 값만) · 셈 */
|
||||
function onInput(name: string, v: string): void {
|
||||
values[name] = v;
|
||||
if (edit && !(doc.열린입력 ?? []).includes(name)) {
|
||||
const kept = { ...(doc.입력값 ?? {}) };
|
||||
if (String(v).trim()) kept[name] = v;
|
||||
else delete kept[name];
|
||||
doc.입력값 = kept;
|
||||
touch(false);
|
||||
}
|
||||
void recalc(); // 750-2 옵션 바꿈 = 서버 셈 한 번 — 수식 · 단가산출 상세가 그 답 하나로 다시 그려짐
|
||||
}
|
||||
|
||||
/** `fresh` = 막 넣은 바탕 — 단위가 비거나 「식」이면 기초 기준단위(「100본」 · 바꾸면 서버가 환산 · 728-2) */
|
||||
async function loadBase(fresh = false): Promise<void> {
|
||||
async function loadBase(): Promise<void> {
|
||||
const key = baseKey();
|
||||
base = null;
|
||||
text = null;
|
||||
if (key) {
|
||||
try {
|
||||
base = await fetchLogic(key);
|
||||
@@ -460,28 +230,17 @@ export function mountSangeunDetail(
|
||||
}
|
||||
}
|
||||
if (!alive) return;
|
||||
if (fresh && base && (!doc.단위 || doc.단위 === "식")) {
|
||||
doc.단위 = baseUnitOf(base.logic.결과단위) || doc.단위;
|
||||
touch(false);
|
||||
}
|
||||
draw();
|
||||
await recalc(); // 바탕 정체(bare) 먼저 — 시험 계산 칸 항목(재료 잡힌 품목)이 쓰임
|
||||
await recalc();
|
||||
}
|
||||
|
||||
void loadBase();
|
||||
return {
|
||||
getDoc: () => {
|
||||
if (ans?.바탕판 && doc.바탕) doc.바탕판 = ans.바탕판; // 저장 = 지금 바탕 확인(서버가 다시 적음)
|
||||
for (const l of ans?.줄 ?? []) {
|
||||
const one = l.바탕판
|
||||
? doc.더한줄?.[Number(/^add:#(\d+)$/.exec(l.cid)?.[1] ?? -1)]
|
||||
: undefined;
|
||||
if (one) one.바탕판 = l.바탕판; // 둘째 기초도 같음(727-2)
|
||||
}
|
||||
saved = JSON.stringify(doc);
|
||||
return clone(doc);
|
||||
},
|
||||
getValues: () => ({ ...values }), // 723-3 — 일위대가 줄 모달 [적용] = 옵션을 그 줄에 남김
|
||||
flush: async () => {
|
||||
if (!tabs.dirty()) return;
|
||||
if (!(await tabs.save())) throw new Error(tl("View_Equation"));
|
||||
|
||||
@@ -1,12 +1,10 @@
|
||||
/* =============================================================================
|
||||
* M02_MasterTemplete_Sangeun_Tabs.ts
|
||||
* M02 단가산출(SK) 상세 보기(PLAN 799-2 · 804-2 · 804-6 · 836-3) — 수식(줄 쌓기) 하나 · 보기 고르기 단추 없음.
|
||||
* M02 단가산출(SK) 수식 그릇(PLAN 799-2 · 804-2 · 804-6 · 836-3 · 856-1) — 줄 쌓기 하나 · 보기 고르기 단추 없음.
|
||||
* 수식 = 공용 줄 쌓기 화면(`A00_Common/line_stack_screen.ts` · M01 과 같은 꼴) — 길 앞머리만 M02 사본 길
|
||||
* (`/m02/layers/{층}/sangeun/{키}/doc` · 802-4a) · 층 쓰기 권한 없으면 읽기만
|
||||
* 저장(804-8 · `page` 있음 = 단가산출 화면) = 페이지 [저장] · [되돌림] 한 번에 — 탭 위 저장 단추 없음(M01 과 같음)
|
||||
* 수식 문서 없는 줄(일위대가 줄 모달 등) = 상세가 쥔 `editor`(단가산출 상세 몸)만 보임 — 빈 화면 없음
|
||||
* 저장 안 한 SK(일위대가 줄 모달 · 새 SK) = 「저장한 단가산출만」 글
|
||||
* [단가 갱신] · [재생성](808-1 · 요구 701-3) = `tools` — 머리 줄(수식 보기일 때만)
|
||||
* [단가 갱신] · [재생성](808-1 · 요구 701-3) = `tools` — 머리 줄
|
||||
* ========================================================================== */
|
||||
|
||||
import { createStackScreen } from "../A00_Common/line_stack_screen";
|
||||
@@ -20,7 +18,7 @@ export interface SkEquationOptions {
|
||||
onSaved: (version: string) => void;
|
||||
/** 페이지가 저장 · 되돌림을 맡음(804-8) — 수식 고침 있음이 바뀔 때 부름 */
|
||||
page?: () => void;
|
||||
/** 저장 전 불러온 단가산출 문서(836-5 · 미리 보기 835-1) — 있으면 그 문서째 수식 보기 · 없으면 null */
|
||||
/** 저장 전 불러온 단가산출 문서(836-5 · 미리 보기 835-1) — 그 문서째 수식 보기 */
|
||||
memory?: () => Record<string, unknown> | null;
|
||||
}
|
||||
|
||||
@@ -34,11 +32,8 @@ export function skDocPath(scope: SkEquationOptions["scope"], key: string, path:
|
||||
return ask ? `${at}?${ask}` : at;
|
||||
}
|
||||
|
||||
/** 수식 그릇 — `editor` = 단가산출 상세 그릇(수식 문서 있을 때 숨김) */
|
||||
export function createSangeunTabs(
|
||||
editor: HTMLElement,
|
||||
opt: SkEquationOptions,
|
||||
): {
|
||||
/** 수식 그릇 */
|
||||
export function createSangeunTabs(opt: SkEquationOptions): {
|
||||
/** 수식 화면 단추([단가 갱신] · [재생성]) — 머리 줄 */
|
||||
tools: HTMLElement;
|
||||
host: HTMLElement;
|
||||
@@ -62,20 +57,10 @@ export function createSangeunTabs(
|
||||
tools,
|
||||
memory: opt.memory,
|
||||
});
|
||||
const show = (doc: boolean): void => {
|
||||
stack.root.hidden = tools.hidden = !doc;
|
||||
editor.hidden = doc;
|
||||
};
|
||||
show(true);
|
||||
return {
|
||||
tools,
|
||||
host: el("div", { className: "m02-sk__views", children: [stack.root] }),
|
||||
draw: (k: string) => {
|
||||
// 문서 없는 줄(일위대가 로직 줄 모달 등 · 페이지 아님) = 단가산출 상세 몸만(808-1 · 수식은 문서가 있어야)
|
||||
const doc = !!k || !!opt.page || !!opt.memory?.();
|
||||
show(doc);
|
||||
if (doc) stack.draw(k);
|
||||
},
|
||||
draw: (k: string) => stack.draw(k),
|
||||
canLeave: () => stack.canLeave(),
|
||||
dirty: () => stack.dirty(),
|
||||
save: () => stack.save(),
|
||||
|
||||
@@ -23,7 +23,7 @@ export function mountSangeunView(
|
||||
doc: unknown,
|
||||
opt: SangeunViewOptions,
|
||||
): { getDoc: () => Promise<unknown>; destroy: () => void } {
|
||||
const one = mountSangeunDetail(host, doc, { ...opt, owner: opt.owner ?? null, source: true }); // 752-1
|
||||
const one = mountSangeunDetail(host, doc, { ...opt, owner: opt.owner ?? null, mode: "page" }); // 752-1 · 856-1
|
||||
return {
|
||||
getDoc: () => one.flush().then(() => one.getDoc()),
|
||||
destroy: () => one.destroy(),
|
||||
|
||||
@@ -2,7 +2,7 @@
|
||||
* M02_Born_Tag.ts
|
||||
* 넣은 줄 출처 꼬리표(740-2 · 요구 581) — 서버 `본뜬 {층, 주인, 키, 이름, 때}`(740-1) → 화면 글.
|
||||
* 순수 계산 — 화면 · fetch 없음. 첫 줄 = 줄 옆에 보이는 짧은 글 · 둘째 줄 = 풍선(키 · 이름 · 층 · 때).
|
||||
* 공용 상세 꼬리표 칸(`LogicLab_Ho` sourceTag)이 「\n」 앞만 보이고 전체를 풍선으로 씀.
|
||||
* 격자 비고 칸 · 줄 풍선이 「\n」 앞만 보이고 전체를 풍선으로 씀.
|
||||
* ========================================================================== */
|
||||
|
||||
export interface Born {
|
||||
@@ -40,14 +40,5 @@ export function bornText(born: unknown, before = ""): string {
|
||||
return `${shown}\n${tip}`;
|
||||
}
|
||||
|
||||
/** 단가산출 줄 열쇠(`add:#k` · `add:#k/…`) → 그 더한줄의 꼬리표 글 */
|
||||
export function bornOfCid(cid: string, adds: readonly object[] | undefined, before = ""): string {
|
||||
const hit = /^add:#(\d+)/.exec(cid);
|
||||
return bornText(
|
||||
hit ? (adds?.[Number(hit[1])] as { 본뜬?: unknown } | undefined)?.본뜬 : undefined,
|
||||
before,
|
||||
);
|
||||
}
|
||||
|
||||
/** 격자 비고 칸 글 — 「본뜬 SK-000012」 · 없으면 "" (첫 줄만) */
|
||||
export const bornNote = (born: unknown): string => bornText(born).split("\n")[0];
|
||||
|
||||
@@ -1,627 +0,0 @@
|
||||
/* =============================================================================
|
||||
* M02_MasterTemplete/logic/M02_Sangeun_Cover_Model.ts
|
||||
* 단가산출(SK) 고침 꼴(PLAN 717-2b · 717-3 · 724-1 — SK 상세 · 일위대가 줄 모드 같이 씀) —
|
||||
* 서버 셈 답(`/layers/{층}/sangeun/calc`) → 공용 상세(`M01_MasterData_UI_LogicLab_Ho`) 줄 · 계산서 줄 ·
|
||||
* 고친 칸(`LineCover` · 호표 차례 열쇠) → SK 문서 덮개 · 더한줄 · 뺀줄(꼴 = 서버 `M02_Sangeun_Doc`).
|
||||
* 금액은 늘 서버가 셈 — 여기는 줄 모양 · 문서 칸 옮김만.
|
||||
* 줄 정체 cid = `kind:키#n`(바탕 줄) · `add:#k`(더한줄 k 째) · 덮개 원값 = 저장 때 서버가 다시 적음
|
||||
* (화면은 고친 첫때 바탕 값을 적어 둠 — 곁 글용) · 열린입력 있는 SK = 품은 배율만
|
||||
* 일위대가 줄 → 이름 없는 SK 문서 = `lineDoc`(서버 `M02_Labor_Patch.as_doc` 꼴)
|
||||
* 둘째 기초(727-2) = 더한줄 로직 줄을 서버 `펼침`(세부 줄)으로 바꿔 놓음 · 열쇠 `add:#k/세부 cid` ·
|
||||
* 고침 = 그 더한줄의 `덮개` · `뺀줄`(품 = 화면 품 ÷ 수량 · 1 기준단위 몫) · 꼬리표 = 기초 둘 이상일 때만
|
||||
* SK 단위 환산(728-2) = 서버가 화면 줄을 SK 1 단위 몫으로(`화면배`) — 문서 품 = 화면 품 × 화면배(율 빼고)
|
||||
* 화면 · fetch · sessionStorage 없음(`CLAUDE.md` 4장).
|
||||
* ========================================================================== */
|
||||
|
||||
import type { CalcLine, TextAnswer } from "../../M01_MasterData/M01_MasterData_UI_Logic_Api";
|
||||
import { bornOfCid } from "./M02_Born_Tag";
|
||||
import { forgetAdd, goneName, reviveAdd, setQty, resetQty } from "./M02_Sangeun_Undo";
|
||||
|
||||
export type CoverPart = "labor" | "material" | "expense";
|
||||
export const PART_OF: Record<string, CoverPart> = {
|
||||
노무비: "labor",
|
||||
재료비: "material",
|
||||
경비: "expense",
|
||||
};
|
||||
const PARTS: CoverPart[] = ["labor", "material", "expense"];
|
||||
|
||||
export interface SkCover {
|
||||
qty?: number;
|
||||
배율?: number;
|
||||
labor?: number;
|
||||
material?: number;
|
||||
expense?: number;
|
||||
원값?: { qty?: number; 단가?: number };
|
||||
}
|
||||
|
||||
export interface SkAdded {
|
||||
종류?: string;
|
||||
수량: number;
|
||||
단가?: number;
|
||||
/** 둘째 기초 세부 고침(727-2) — 열쇠 = 세부 cid */
|
||||
덮개?: Record<string, SkCover>;
|
||||
뺀줄?: string[];
|
||||
바탕판?: string;
|
||||
/** 넣을 때 수량(744-1) — [되돌림] 값 */
|
||||
처음수량?: number;
|
||||
[k: string]: unknown;
|
||||
}
|
||||
|
||||
/** SK 문서 중 고침이 만지는 칸 */
|
||||
export interface SkDoc {
|
||||
키?: string;
|
||||
이름?: string;
|
||||
단위?: string;
|
||||
바탕?: { 로직?: string; 참조?: { 층?: string; 주인?: string | null; 키?: string } } | null;
|
||||
입력값?: Record<string, unknown>;
|
||||
열린입력?: string[];
|
||||
덮개?: Record<string, SkCover>;
|
||||
더한줄?: SkAdded[];
|
||||
뺀줄?: string[];
|
||||
/** 뺀 더한줄 기억(744-1) — [되살림] = 그 차례에 다시 끼움 */
|
||||
뺀더한줄?: { 차례: number; 줄: SkAdded }[];
|
||||
고름?: Record<string, string>;
|
||||
자재표시?: Record<string, unknown>;
|
||||
바탕판?: string;
|
||||
[k: string]: unknown;
|
||||
}
|
||||
|
||||
export interface SkLine {
|
||||
이름: string;
|
||||
단위?: string;
|
||||
수량: number | null;
|
||||
단가: number | null;
|
||||
금액: number | null;
|
||||
비목?: Record<string, number | null>;
|
||||
묶음?: string | null;
|
||||
cid: string;
|
||||
율?: number;
|
||||
/** % 줄 밑 이름(「노무비의 %」 · 율 줄 「인력의 %」) */
|
||||
규격?: string;
|
||||
/** 못 셈 줄(725) — 금액 없음 · 계에 안 듦 */
|
||||
까닭?: string;
|
||||
/** 둘째 기초(727-2) — 세부 줄 · 뺀 세부 · 그 기초 지문 · 원문번호 */
|
||||
펼침?: SkLine[];
|
||||
뺀세부?: { cid: string; 이름: string }[];
|
||||
바탕판?: string;
|
||||
꼬리표?: string;
|
||||
/** 세부 줄 — 덮기 전 1 기준단위 품 · 단가 */
|
||||
바탕값?: { qty?: number; 단가?: number } | null;
|
||||
/** 둘째 기초 세부 줄(744-1) — 그 기초 1 기준단위 몫(M01 원문 · 머리 수량 안 곱함) · 화면 품 칸 */
|
||||
원문?: { 수량: number | null; 금액: number | null; 비목?: Record<string, number | null> };
|
||||
/** 재료 줄이 잡은 품목(시험 계산 재료 칸 · 줄 모달) */
|
||||
품목?: CalcLine["품목"];
|
||||
/** (753-1) 옵션으로 빠진 줄 — 화면은 안 그림 */
|
||||
옵션꺼짐?: boolean;
|
||||
/** (796-2d) 합계에 안 드는 줄 — 엔진 표지 */
|
||||
합밖?: boolean;
|
||||
}
|
||||
|
||||
export interface SkMat {
|
||||
차례: number;
|
||||
이름: string;
|
||||
단위?: string;
|
||||
수량: number | null;
|
||||
단가: number | null;
|
||||
금액: number | null;
|
||||
}
|
||||
|
||||
export interface SkAnswer {
|
||||
기준: Record<string, number> | null;
|
||||
줄: SkLine[];
|
||||
재료?: SkMat[];
|
||||
까닭?: string | null;
|
||||
/** 못 셈 줄(725 · 입력 없음 · 수량 없음) — 그 줄만 빠지고 나머지 셈 */
|
||||
빠진줄?: { cid: string; 이름: string; 까닭: string }[];
|
||||
정체: string[];
|
||||
짝잃음: { cid: string; 까닭: string; 바탕?: string }[];
|
||||
바탕판: string;
|
||||
머리?: string;
|
||||
/** 바탕 원문번호(참조 바탕 = 그 키) */
|
||||
꼬리표?: string | null;
|
||||
/** 바탕 기준단위 → SK 단위 배(728-2) · 화면 줄을 나눈 배(없으면 1 · 문서 품 = 화면 품 × 화면배) */
|
||||
배?: number;
|
||||
화면배?: number;
|
||||
/** 보기 덧칸(750-1) — 텍스트 수식 글(줄마다 cid · 금액 = SK 줄) · 시험 계산 중간값 · 몸 `보기: false` 면 없음 */
|
||||
글?: TextAnswer;
|
||||
중간?: Record<string, unknown>;
|
||||
}
|
||||
|
||||
export interface CoverRow {
|
||||
cid: string;
|
||||
묶음: string;
|
||||
이름: string;
|
||||
단위: string;
|
||||
수량: number | null;
|
||||
단가: number | null;
|
||||
금액: number | null;
|
||||
/** 비목 몫 금액 */
|
||||
parts: Record<string, number>;
|
||||
/** % 덧줄 — 수량 = 율 · 단가 못 고침 */
|
||||
pct: boolean;
|
||||
/** 더한줄 차례 · 바탕 줄 = null */
|
||||
added: number | null;
|
||||
/** 기준 밖 재료(일위대가 자재목록으로 셈) — 금액이 계에 안 듦 */
|
||||
apart: boolean;
|
||||
covered: { qty: boolean; price: boolean };
|
||||
/** 덮개 배율(열린입력 SK) */
|
||||
배율: number | null;
|
||||
/** 바탕 값(덮개 · 더한줄 · 뺀줄 없이 셈) · 없으면 null */
|
||||
was: { qty: number | null; 단가: number | null } | null;
|
||||
/** 저장 때 적힌 원값이 지금 바탕 값과 다름(M01 개정) */
|
||||
revised: boolean;
|
||||
priceEdit: boolean;
|
||||
/** 더한 재료 줄 — 별도계상 고름(기본 계 안) */
|
||||
apartPick: boolean;
|
||||
/** 둘째 기초 세부 줄 — 더한줄 차례 · 세부 cid · 수량(배) · 바탕 줄 · 그 밖 = null */
|
||||
sub: { k: number; cid: string; scale: number } | null;
|
||||
/** 화면배(728-2) — 문서 품 = 화면 품 × t · `was` = 문서 몫 */
|
||||
t: number;
|
||||
/** (753-2) 옵션으로 빠진 줄 — 계산서에서 안 그림 */
|
||||
off: boolean;
|
||||
}
|
||||
|
||||
/* ── 순수 셈 ── */
|
||||
const BUNDLE_OF: Record<string, string> = { 노무비: "인력", 재료비: "재료", 경비: "경비" };
|
||||
const ADD_RE = /^add:#(\d+)$/;
|
||||
const SUB_RE = /^add:#(\d+)\/(.+)$/;
|
||||
|
||||
/** 세부 열쇠 `add:#k/세부 cid` → {k, cid} */
|
||||
export function subOf(key: string): { k: number; cid: string } | null {
|
||||
const m = SUB_RE.exec(key);
|
||||
return m ? { k: Number(m[1]), cid: m[2] } : null;
|
||||
}
|
||||
|
||||
/** 셈 답 줄 — 둘째 기초 줄은 세부 줄로 바꿔 놓음(정체도 같은 차례) */
|
||||
export function flatLines(ans: SkAnswer): SkLine[] {
|
||||
return ans.줄.flatMap((l) => l.펼침 ?? [l]);
|
||||
}
|
||||
function flatIds(ans: SkAnswer): string[] {
|
||||
const by = new Map(ans.줄.map((l) => [l.cid, l]));
|
||||
return ans.정체.flatMap((c) => by.get(c)?.펼침?.map((x) => x.cid) ?? [c]);
|
||||
}
|
||||
|
||||
/** 율 더한줄(778-4) 비율 — `add:#k` 의 고정 `비율` · 아니면 undefined */
|
||||
const rateOf = (doc: SkDoc, cid: string): { 비목: string } | undefined => {
|
||||
const hit = ADD_RE.exec(cid);
|
||||
const one = hit ? doc.더한줄?.[Number(hit[1])] : undefined;
|
||||
return (one?.고정 as { 비율?: { 비목: string } } | undefined)?.비율;
|
||||
};
|
||||
|
||||
/** 기초 수 — 로직 바탕 · 더한줄 로직 */
|
||||
const baseCount = (doc: SkDoc): number =>
|
||||
(doc.바탕?.로직 ? 1 : 0) + (doc.더한줄 ?? []).filter((x) => x.종류 === "로직").length;
|
||||
|
||||
/** 줄 꼬리표(기초 둘 이상일 때만) — 바탕 줄 = 바탕 원문번호 · 세부 줄 = 그 기초 원문번호 · 그 밖 = "" */
|
||||
export function tagsOf(ans: SkAnswer, doc: SkDoc): Map<string, string> {
|
||||
const out = new Map<string, string>();
|
||||
if (baseCount(doc) < 2) return out;
|
||||
for (const l of ans.줄) {
|
||||
if (l.펼침) for (const x of l.펼침) out.set(x.cid, l.꼬리표 ?? "");
|
||||
else if (!ADD_RE.test(l.cid) && ans.꼬리표) out.set(l.cid, ans.꼬리표);
|
||||
}
|
||||
return out;
|
||||
}
|
||||
|
||||
/** 뺀 세부 줄(되살림 띠) */
|
||||
export const removedSubs = (ans: SkAnswer | null): { cid: string; 이름: string }[] =>
|
||||
(ans?.줄 ?? []).flatMap((l) => l.뺀세부 ?? []);
|
||||
|
||||
/** M01 개정된 둘째 기초 — 저장 때 지문 ≠ 지금 지문 */
|
||||
export function revisedAdds(ans: SkAnswer | null, doc: SkDoc): number[] {
|
||||
return (ans?.줄 ?? []).flatMap((l) => {
|
||||
const hit = ADD_RE.exec(l.cid);
|
||||
const one = hit ? doc.더한줄?.[Number(hit[1])] : undefined;
|
||||
return one?.바탕판 && l.바탕판 && one.바탕판 !== l.바탕판 ? [Number(hit![1])] : [];
|
||||
});
|
||||
}
|
||||
const COVER_KEYS = ["qty", "배율", ...PARTS] as const;
|
||||
|
||||
const partsOf = (l: { 비목?: Record<string, number | null> }): Record<string, number> =>
|
||||
Object.fromEntries(Object.entries(l.비목 ?? {}).map(([k, v]) => [k, v ?? 0]));
|
||||
|
||||
/** 바탕 값 — 바탕 셈(덮개 · 더한줄 · 뺀줄 없이)의 줄마다 품(덧줄 = 율) · 단가 */
|
||||
export function baseValues(
|
||||
bare: SkAnswer | null,
|
||||
): Map<string, { qty: number | null; 단가: number | null }> {
|
||||
const out = new Map<string, { qty: number | null; 단가: number | null }>();
|
||||
if (!bare) return out;
|
||||
for (const l of bare.줄) out.set(l.cid, { qty: l.율 ?? l.수량, 단가: l.단가 });
|
||||
for (const m of bare.재료 ?? []) {
|
||||
const cid = bare.정체[m.차례];
|
||||
if (cid && !out.has(cid)) out.set(cid, { qty: m.수량, 단가: m.단가 });
|
||||
}
|
||||
return out;
|
||||
}
|
||||
|
||||
const near = (a: number | null | undefined, b: number | null | undefined): boolean =>
|
||||
a != null && b != null && Math.abs(a - b) <= 1e-9 * Math.max(1, Math.abs(a), Math.abs(b));
|
||||
|
||||
/** 셈 답 → 표 줄(엔진 줄 + 기준 밖 재료) */
|
||||
export function rowsOf(ans: SkAnswer, bare: SkAnswer | null, doc: SkDoc): CoverRow[] {
|
||||
const was = baseValues(bare);
|
||||
const t = ans.화면배 ?? 1;
|
||||
const rows: CoverRow[] = [];
|
||||
const row = (
|
||||
cid: string,
|
||||
l: {
|
||||
이름: string;
|
||||
단위?: string;
|
||||
수량: number | null;
|
||||
단가: number | null;
|
||||
금액: number | null;
|
||||
},
|
||||
parts: Record<string, number>,
|
||||
extra: {
|
||||
묶음?: string | null;
|
||||
율?: number;
|
||||
apart?: boolean;
|
||||
바탕값?: SkLine["바탕값"];
|
||||
옵션꺼짐?: boolean;
|
||||
},
|
||||
): CoverRow => {
|
||||
const hit = ADD_RE.exec(cid);
|
||||
const added = hit ? Number(hit[1]) : null;
|
||||
const at = subOf(cid);
|
||||
const one = added === null ? undefined : doc.더한줄?.[added];
|
||||
const owner = at ? doc.더한줄?.[at.k] : undefined;
|
||||
const cover = at ? owner?.덮개?.[at.cid] : added === null ? doc.덮개?.[cid] : undefined;
|
||||
const pct = (at?.cid ?? cid).startsWith("pct:") || !!rateOf(doc, cid); // 덧줄 · 율 줄(778-4)
|
||||
const keys = Object.keys(parts);
|
||||
const shown = added === null && !at ? (was.get(cid) ?? null) : null;
|
||||
const base = at
|
||||
? subWas(extra.바탕값)
|
||||
: shown && !pct && shown.qty != null
|
||||
? { ...shown, qty: shown.qty * t }
|
||||
: shown;
|
||||
const old = cover?.원값;
|
||||
return {
|
||||
cid,
|
||||
묶음: extra.묶음 || BUNDLE_OF[keys[0] ?? ""] || "하위",
|
||||
이름: l.이름,
|
||||
단위: pct ? "%" : (l.단위 ?? ""),
|
||||
수량: pct ? (extra.율 ?? l.수량) : l.수량,
|
||||
단가: pct ? null : l.단가,
|
||||
금액: l.금액,
|
||||
parts,
|
||||
pct,
|
||||
added,
|
||||
apart: !!extra.apart,
|
||||
covered: {
|
||||
qty: !!cover && ("qty" in cover || "배율" in cover),
|
||||
price: added === null ? PARTS.some((k) => cover?.[k] != null) : one?.단가 != null,
|
||||
},
|
||||
배율: cover?.배율 ?? null,
|
||||
was: base,
|
||||
revised:
|
||||
!!old &&
|
||||
!!base &&
|
||||
((old.qty != null && !near(old.qty, base.qty)) ||
|
||||
(old.단가 != null && !near(old.단가, base.단가))),
|
||||
priceEdit: !pct && (added === null || ["인력", "재료", "기계"].includes(String(one?.종류))),
|
||||
apartPick: one?.종류 === "재료",
|
||||
sub: at ? { ...at, scale: Number(owner?.수량 ?? 1) } : null,
|
||||
t: pct || at ? 1 : t, // 세부 줄 품 = M01 원문 그대로(744-1) — 화면배 안 곱함
|
||||
off: !!extra.옵션꺼짐,
|
||||
};
|
||||
};
|
||||
for (const l of flatLines(ans)) rows.push(row(l.cid, l, partsOf(l), l));
|
||||
const seen = new Set(rows.map((r) => r.cid));
|
||||
for (const m of ans.재료 ?? []) {
|
||||
const cid = ans.정체[m.차례];
|
||||
if (!cid || seen.has(cid)) continue;
|
||||
rows.push(row(cid, m, { 재료비: m.금액 ?? 0 }, { 묶음: "재료", apart: true }));
|
||||
}
|
||||
return rows;
|
||||
}
|
||||
|
||||
const subWas = (v: SkLine["바탕값"]): CoverRow["was"] =>
|
||||
v ? { qty: v.qty ?? null, 단가: v.단가 ?? null } : null;
|
||||
|
||||
const memo = (base: CoverRow["was"]): SkCover["원값"] | undefined => {
|
||||
if (!base) return undefined;
|
||||
const out: { qty?: number; 단가?: number } = {};
|
||||
if (base.qty != null) out.qty = base.qty;
|
||||
if (base.단가 != null) out.단가 = base.단가;
|
||||
return Object.keys(out).length ? out : undefined;
|
||||
};
|
||||
|
||||
function putCover(doc: SkDoc, r: CoverRow, cover: SkCover): void {
|
||||
const owner = r.sub ? doc.더한줄?.[r.sub.k] : doc;
|
||||
if (!owner) return;
|
||||
const key = r.sub?.cid ?? r.cid;
|
||||
const covers = { ...(owner.덮개 ?? {}) };
|
||||
if (COVER_KEYS.some((k) => cover[k] != null)) {
|
||||
const old = cover.원값 ?? memo(r.was);
|
||||
covers[key] = { ...cover, ...(old ? { 원값: old } : {}) };
|
||||
} else delete covers[key];
|
||||
if (r.sub && !Object.keys(covers).length) delete owner.덮개;
|
||||
else owner.덮개 = covers;
|
||||
}
|
||||
|
||||
/** 공용 상세 고침 칸(`LogicLab_Cover.LineCover` 와 같은 꼴) — 품 · 비목 단가(로직 줄 = 1 단위 노 · 재 · 경) */
|
||||
export type LineCover = Pick<SkCover, "qty" | CoverPart>;
|
||||
|
||||
/** 공용 상세 고침 한 줄 → 문서 — 더한줄 = 그 줄 수량 · 단가(요소 줄만) · 바탕 줄 = 덮개
|
||||
* (열린입력 SK = 품 대신 배율 = 고친 품 ÷ 바탕 품 · 바탕 값과 같은 품 = 덮개 안 둠) · `c` null = 고침 풂 */
|
||||
export function setLineCover(doc: SkDoc, r: CoverRow, c: LineCover | null, opened: boolean): void {
|
||||
const price = r.priceEdit ? PARTS.map((k) => c?.[k]).find((v) => v != null) : undefined;
|
||||
if (r.added !== null) {
|
||||
const one = doc.더한줄?.[r.added];
|
||||
if (!one) return;
|
||||
if (c?.qty != null) setQty(one, c.qty * r.t);
|
||||
else if (!c) resetQty(one); // [되돌림] = 넣을 때 수량(744-1)
|
||||
if (price == null) delete one.단가;
|
||||
else one.단가 = price;
|
||||
return;
|
||||
}
|
||||
const cover: SkCover = {};
|
||||
// 세부 줄 품 = 화면 품 그대로(M01 원문 = 1 기준단위 몫 · 744-1) — 화면배 · 머리 수량 안 곱함
|
||||
const qty = c?.qty == null ? c?.qty : c.qty * r.t;
|
||||
const open = opened && !r.sub; // 열린입력 = 바탕 입력 — 세부 줄은 품 그대로
|
||||
// ponytail: 열린입력 배율 = 고친 품 ÷ 바탕 품(바탕 품 0 · 없음 = 품 고침 못 함)
|
||||
if (qty != null && open && r.was?.qty) cover.배율 = qty / r.was.qty;
|
||||
if (qty != null && !open && !near(qty, r.was?.qty)) cover.qty = qty;
|
||||
if (r.priceEdit) for (const k of PARTS) if (c?.[k] != null) cover[k] = c[k];
|
||||
if (cover.배율 != null && near(cover.배율, 1)) delete cover.배율;
|
||||
putCover(doc, r, cover);
|
||||
}
|
||||
|
||||
/** 줄 빼기 — 더한줄 = 그 줄 지움 · 바탕 줄 = 뺀줄에 cid(덮개 · 고름 · 자재표시도 지움) */
|
||||
export function dropLine(doc: SkDoc, r: CoverRow): void {
|
||||
const one = r.sub ? doc.더한줄?.[r.sub.k] : undefined;
|
||||
if (one && r.sub) {
|
||||
one.뺀줄 = [...(one.뺀줄 ?? []).filter((c) => c !== r.sub!.cid), r.sub.cid];
|
||||
if (one.덮개) delete one.덮개[r.sub.cid];
|
||||
return;
|
||||
}
|
||||
if (r.added !== null) {
|
||||
forgetAdd(doc, r.added, r.이름); // 뺀더한줄 기억 — 744-1 [되살림]
|
||||
return;
|
||||
}
|
||||
doc.뺀줄 = [...(doc.뺀줄 ?? []).filter((c) => c !== r.cid), r.cid];
|
||||
for (const k of ["덮개", "고름", "자재표시"] as const) {
|
||||
const map = { ...((doc[k] as Record<string, unknown> | undefined) ?? {}) };
|
||||
delete map[r.cid];
|
||||
(doc as Record<string, unknown>)[k] = map;
|
||||
}
|
||||
}
|
||||
|
||||
/** 더한 재료 줄 별도계상 — 켬 = 계 밖(재료 목록만 · 서버 자재표시) · 끔 = 칸 지움(기본 계 안) */
|
||||
export function setApart(doc: SkDoc, r: CoverRow, on: boolean): void {
|
||||
const one = r.added === null ? undefined : doc.더한줄?.[r.added];
|
||||
if (!one || one.종류 !== "재료") return;
|
||||
if (on) one.별도계상 = true;
|
||||
else delete one.별도계상;
|
||||
}
|
||||
|
||||
/** 뺀 줄 되살림 — 세부 열쇠면 그 더한줄의 뺀줄 */
|
||||
export function restoreLine(doc: SkDoc, cid: string): void {
|
||||
const gone = /^gone:(\d+)$/.exec(cid); // 뺀 더한줄(744-1) — 그 차례에 다시 끼움
|
||||
if (gone) return reviveAdd(doc, Number(gone[1]));
|
||||
const at = subOf(cid);
|
||||
const one = at ? doc.더한줄?.[at.k] : undefined;
|
||||
if (one && at) {
|
||||
one.뺀줄 = (one.뺀줄 ?? []).filter((c) => c !== at.cid);
|
||||
if (!one.뺀줄.length) delete one.뺀줄;
|
||||
return;
|
||||
}
|
||||
doc.뺀줄 = (doc.뺀줄 ?? []).filter((c) => c !== cid);
|
||||
}
|
||||
|
||||
/** 둘째 기초 통째 빼기 — 그 더한줄을 뺌(기억 744-1 · 되살림 띠 글 = `name`) */
|
||||
export function dropBase(doc: SkDoc, k: number, name = ""): void {
|
||||
forgetAdd(doc, k, name);
|
||||
}
|
||||
|
||||
/** 뺀 더한줄 되살림 띠 항목 — 열쇠 `gone:n` */
|
||||
export const goneRows = (doc: SkDoc): { cid: string; 이름: string }[] =>
|
||||
(doc.뺀더한줄 ?? []).map((g, n) => ({ cid: `gone:${n}`, 이름: goneName(g.줄) }));
|
||||
|
||||
/* ── 공용 상세(Ho) 줄 ── */
|
||||
/** Ho 호표 · 덧줄 꼴(`M01_MasterData_UI_Logic_Api` HoLine · NamedFormula 중 쓰는 칸) */
|
||||
export interface HoItem {
|
||||
종류: string;
|
||||
요소: string;
|
||||
이름?: string;
|
||||
규격?: string;
|
||||
단위?: string;
|
||||
수량: string;
|
||||
비목?: string;
|
||||
/** 출처 꼬리표(727-2 · 기초 둘 이상) */
|
||||
꼬리표?: string;
|
||||
}
|
||||
export interface HoExtra {
|
||||
이름: string;
|
||||
식: string;
|
||||
비목?: string;
|
||||
꼬리표?: string;
|
||||
}
|
||||
export interface HoView {
|
||||
호표: HoItem[];
|
||||
덧줄: HoExtra[];
|
||||
/** Ho 줄 차례(호표 → 덧줄)의 셈 줄 — 셈 전 · 못 셈 = null · 별도계상 빠진 줄 = 빈 칸 */
|
||||
lines: (SkLine | undefined)[] | null;
|
||||
/** Ho 줄 차례 → cid(고침 열쇠 옮김) */
|
||||
cids: string[];
|
||||
/** Ho 줄 차례 → 지금 고침(덮개 · 더한줄) */
|
||||
covers: Record<number, LineCover>;
|
||||
}
|
||||
|
||||
const KIND_OF: Record<string, string> = { labor: "인력", material: "재료", machine: "기계" };
|
||||
const ELEMENT_KINDS = ["인력", "재료", "기계"];
|
||||
|
||||
/** SK 셈 답 → 공용 상세 줄 — 줄 차례 = 서버 `정체`(바탕 남은 호표 · 더한줄 · 바탕 남은 덧줄) ·
|
||||
* 바탕 로직 줄을 알면(`base` + 바탕 셈 `bare.정체` 차례) 그 줄 그대로(식 · 요소 · 규격) ·
|
||||
* 더한줄 = 문서 줄 · 그 밖(참조 바탕) = 셈 줄로 지음 */
|
||||
export function hoView(
|
||||
ans: SkAnswer,
|
||||
bare: SkAnswer | null,
|
||||
base: { 호표?: HoItem[]; 덧줄?: HoExtra[] } | null,
|
||||
doc: SkDoc,
|
||||
): HoView {
|
||||
const head = base?.호표 ?? [];
|
||||
const known = new Map<string, HoItem | HoExtra>();
|
||||
if (base && bare)
|
||||
bare.정체.forEach((cid, i) => {
|
||||
const it = i < head.length ? head[i] : base.덧줄?.[i - head.length];
|
||||
if (it) known.set(cid, it);
|
||||
});
|
||||
const lineBy = new Map(flatLines(ans).map((l) => [l.cid, l]));
|
||||
const tags = tagsOf(ans, doc);
|
||||
const t = ans.화면배 ?? 1;
|
||||
const single = (l?: SkLine): string | undefined => {
|
||||
const parts = Object.entries(l?.비목 ?? {}).filter(([, v]) => v);
|
||||
return parts.length === 1 ? parts[0][0] : undefined;
|
||||
};
|
||||
/** 세부 줄 = 수량만 M01 원문(금액 · 비목은 상자 합 몫 그대로) */
|
||||
const shown = (l?: SkLine): SkLine | undefined =>
|
||||
l?.원문 ? { ...l, 수량: l.원문.수량 ?? l.수량 } : l;
|
||||
const ho: [string, HoItem][] = [];
|
||||
const extra: [string, HoExtra][] = [];
|
||||
for (const cid of flatIds(ans)) {
|
||||
const l = lineBy.get(cid);
|
||||
const name = l?.이름 ?? cid;
|
||||
const at = subOf(cid);
|
||||
const born = bornOfCid(cid, doc.더한줄, tags.get(cid) ?? ""); // 넣은 줄 출처(740-2) — 기초 번호 뒤에 붙임
|
||||
const tag = born ? { 꼬리표: born } : {};
|
||||
if ((at?.cid ?? cid).startsWith("pct:")) {
|
||||
extra.push([cid, { ...((known.get(cid) as HoExtra) ?? { 이름: name, 식: "" }), ...tag }]);
|
||||
continue;
|
||||
}
|
||||
const rate = rateOf(doc, cid); // 율 더한줄(778-4) = 비목 상자 % 줄(식 = 「인력의 %」)
|
||||
if (rate) {
|
||||
extra.push([cid, { 이름: name, 식: String(l?.규격 ?? ""), 비목: rate.비목, ...tag }]);
|
||||
continue;
|
||||
}
|
||||
if (at) {
|
||||
const kind = KIND_OF[at.cid.split(":")[0]] ?? "로직";
|
||||
const qty = String(l?.율 ?? l?.원문?.수량 ?? l?.수량 ?? ""); // 세부 품 = M01 원문(744-1)
|
||||
const item = { 종류: kind, 요소: "", 이름: name, 단위: l?.단위 ?? "", 수량: qty };
|
||||
ho.push([cid, { ...item, 비목: single(l), ...tag }]);
|
||||
continue;
|
||||
}
|
||||
const hit = ADD_RE.exec(cid);
|
||||
const a = hit ? doc.더한줄?.[Number(hit[1])] : undefined;
|
||||
const kind = a
|
||||
? ELEMENT_KINDS.includes(String(a.종류))
|
||||
? String(a.종류)
|
||||
: "로직"
|
||||
: (KIND_OF[cid.split(":")[0]] ?? "로직");
|
||||
const made: HoItem = {
|
||||
종류: kind,
|
||||
요소: typeof a?.요소 === "string" ? a.요소 : "",
|
||||
이름: name,
|
||||
단위: l?.단위 ?? String(a?.단위 ?? ""),
|
||||
수량: String(a ? a.수량 / t : (l?.율 ?? l?.수량 ?? "")),
|
||||
비목: typeof a?.비목 === "string" ? a.비목 : single(l),
|
||||
};
|
||||
ho.push([cid, { ...(a ? made : ((known.get(cid) as HoItem) ?? made)), ...tag }]);
|
||||
}
|
||||
const cids = [...ho, ...extra].map(([cid]) => cid);
|
||||
const covers: Record<number, LineCover> = {};
|
||||
cids.forEach((cid, i) => {
|
||||
const hit = ADD_RE.exec(cid);
|
||||
const a = hit ? doc.더한줄?.[Number(hit[1])] : undefined;
|
||||
const part = PART_OF[String(a?.비목 ?? "")];
|
||||
const own = rateOf(doc, cid) ? 1 : t; // 율 = 그대로
|
||||
if (a) covers[i] = { qty: a.수량 / own, ...(a.단가 != null && part ? { [part]: a.단가 } : {}) };
|
||||
const at = subOf(cid);
|
||||
const owner = at ? doc.더한줄?.[at.k] : undefined;
|
||||
const c = hit ? undefined : at ? owner?.덮개?.[at.cid] : doc.덮개?.[cid];
|
||||
if (!c) return;
|
||||
const l = lineBy.get(cid);
|
||||
const out: LineCover = {};
|
||||
const per = at || cid.startsWith("pct:") ? 1 : t; // 율 · 세부 품 = 그대로
|
||||
if (c.qty != null) out.qty = c.qty / per;
|
||||
else if (c.배율 != null && l) out.qty = l.율 ?? l.수량 ?? undefined;
|
||||
for (const k of PARTS) if (c[k] != null) out[k] = c[k];
|
||||
covers[i] = out;
|
||||
});
|
||||
return {
|
||||
호표: ho.map(([, x]) => x),
|
||||
덧줄: extra.map(([, x]) => x),
|
||||
lines: ans.줄.length ? cids.map((c) => shown(lineBy.get(c))) : null,
|
||||
cids,
|
||||
covers,
|
||||
};
|
||||
}
|
||||
|
||||
/* ── 일위대가 줄 → SK 문서(717-3 · 723-3 줄 모드) ── */
|
||||
export interface LinePatch {
|
||||
덮개?: Record<string, SkCover>;
|
||||
뺀줄?: string[];
|
||||
더한줄?: unknown[];
|
||||
/** 뺀 더한줄 기억(744-1) */
|
||||
뺀더한줄?: SkDoc["뺀더한줄"];
|
||||
}
|
||||
|
||||
/** 줄 꼴(일위대가 `담은로직[]` 한 줄 · 쓰는 칸만) */
|
||||
export interface PatchRow {
|
||||
로직?: string;
|
||||
참조?: { 층: string; 주인?: string | null; 키: string };
|
||||
입력값?: Record<string, unknown>;
|
||||
켜쌓기율?: number | null;
|
||||
고름?: Record<string, unknown>;
|
||||
자재표시?: Record<string, unknown>;
|
||||
패치?: LinePatch;
|
||||
}
|
||||
|
||||
const keyed = (value: Record<string, unknown> | undefined, ids: string[]) =>
|
||||
Object.fromEntries(
|
||||
Object.entries(value ?? {}).flatMap(([n, v]) =>
|
||||
/^\d+$/.test(n) && Number(n) < ids.length ? [[ids[Number(n)], v]] : [],
|
||||
),
|
||||
);
|
||||
|
||||
/** 고름 · 자재표시가 있는 로직 줄 = 바탕 줄 정체가 먼저 있어야 함 */
|
||||
export const needsIds = (row: PatchRow): boolean =>
|
||||
!row.참조 &&
|
||||
(Object.keys(row.고름 ?? {}).length > 0 || Object.keys(row.자재표시 ?? {}).length > 0);
|
||||
|
||||
/** 줄 → 이름 없는 SK 문서 — `patch` null = 그 일위대가 고침 없는 원래 값 ·
|
||||
* 고름 · 자재표시(호표 차례 열쇠)는 바탕 줄 정체(`ids` · 셈 답 `정체`)로 cid 열쇠로 */
|
||||
export function lineDoc(
|
||||
row: PatchRow,
|
||||
ids: string[] | null,
|
||||
patch: LinePatch | null,
|
||||
): Record<string, unknown> {
|
||||
const head = {
|
||||
키: "SK-000000",
|
||||
이름: "줄",
|
||||
단위: "식",
|
||||
덮개: patch?.덮개 ?? {},
|
||||
뺀줄: patch?.뺀줄 ?? [],
|
||||
더한줄: patch?.더한줄 ?? [],
|
||||
줄모드: true, // 셈 = 일위대가 그 줄 셈(별도계상 기본 · 750-1 · 서버 `calc_doc`)
|
||||
};
|
||||
if (row.참조) return { ...head, 바탕: { 참조: row.참조 } };
|
||||
return {
|
||||
...head,
|
||||
...(row.켜쌓기율 != null ? { 켜쌓기율: row.켜쌓기율 } : {}),
|
||||
바탕: { 로직: row.로직 ?? "" },
|
||||
입력값: { ...(row.입력값 ?? {}) },
|
||||
고름: ids ? keyed(row.고름, ids) : {},
|
||||
자재표시: ids ? keyed(row.자재표시, ids) : {},
|
||||
};
|
||||
}
|
||||
|
||||
/** 빈 칸 · 원값 뺀 패치 — 다 비면 null(줄 칸 안 둠) */
|
||||
export function cleanPatch(patch: LinePatch | null | undefined): LinePatch | null {
|
||||
const covers = Object.fromEntries(
|
||||
Object.entries(patch?.덮개 ?? {}).flatMap(([cid, c]) => {
|
||||
const keep = Object.fromEntries(
|
||||
Object.entries(c ?? {}).filter(([k, v]) => k !== "원값" && typeof v === "number"),
|
||||
);
|
||||
return Object.keys(keep).length ? [[cid, keep]] : [];
|
||||
}),
|
||||
);
|
||||
const out: LinePatch = {
|
||||
...(Object.keys(covers).length ? { 덮개: covers } : {}),
|
||||
...(patch?.뺀줄?.length ? { 뺀줄: [...patch.뺀줄] } : {}),
|
||||
...(patch?.더한줄?.length ? { 더한줄: [...patch.더한줄] } : {}),
|
||||
...(patch?.뺀더한줄?.length ? { 뺀더한줄: [...patch.뺀더한줄] } : {}),
|
||||
};
|
||||
return Object.keys(out).length ? out : null;
|
||||
}
|
||||
/* ── 순수 셈 끝 ── */
|
||||
@@ -1,93 +0,0 @@
|
||||
/* =============================================================================
|
||||
* M02_MasterTemplete/logic/M02_Sangeun_Undo.ts
|
||||
* 단가산출(SK) 되돌리기 기억(PLAN 744-1 서버 · 748-0 화면) — 더한 기초 · 더한 항목 빼기 → 문서 `뺀더한줄`
|
||||
* `[{차례, 줄}]`(되살림 = 그 차례에 다시 끼움) · 더한 항목 수량 → `처음수량`(넣을 때 값) 되돌림.
|
||||
* 더한줄 지움 · 끼움 때 뒤 더한줄 열쇠 `add:#j[/…]`(덮개 · 고름 · 자재표시 · 율 줄 기준 목록 778-4)를
|
||||
* 한 칸씩 당김 · 밂(지운 줄을 가리킨 기준 열쇠는 버림 — 빈 목록 = 서버 짝잃음 알림).
|
||||
* 금액은 늘 서버가 셈 — 여기는 문서 칸 옮김만 · 화면 · fetch · sessionStorage 없음(`CLAUDE.md` 4장).
|
||||
* ========================================================================== */
|
||||
|
||||
import type { SkAdded, SkDoc } from "./M02_Sangeun_Cover_Model";
|
||||
|
||||
/* ── 순수 셈 ── */
|
||||
const KEYED = ["덮개", "고름", "자재표시"] as const;
|
||||
const KEY_RE = /^add:#(\d+)(.*)$/;
|
||||
|
||||
/** 문서 열쇠 맵의 `add:#j…` 를 옮김 — `drop` = 지운 j(그 열쇠는 버림) · 뒤 j 는 한 칸 당김 / `push` = 끼운 j 부터 한 칸 밂 */
|
||||
function moveKeys(doc: SkDoc, mode: { drop: number } | { push: number }): void {
|
||||
for (const name of KEYED) {
|
||||
const map = doc[name] as Record<string, unknown> | undefined;
|
||||
if (!map) continue;
|
||||
const out: Record<string, unknown> = {};
|
||||
for (const [key, value] of Object.entries(map)) {
|
||||
const hit = KEY_RE.exec(key);
|
||||
if (!hit) {
|
||||
out[key] = value;
|
||||
continue;
|
||||
}
|
||||
const j = Number(hit[1]);
|
||||
if ("drop" in mode) {
|
||||
if (j === mode.drop) continue;
|
||||
out[j > mode.drop ? `add:#${j - 1}${hit[2]}` : key] = value;
|
||||
} else out[j >= mode.push ? `add:#${j + 1}${hit[2]}` : key] = value;
|
||||
}
|
||||
(doc as Record<string, unknown>)[name] = out;
|
||||
}
|
||||
for (const one of doc.더한줄 ?? []) {
|
||||
const rate = (one.고정 as { 비율?: { 기준?: unknown } } | undefined)?.비율;
|
||||
if (!rate || !Array.isArray(rate.기준)) continue;
|
||||
rate.기준 = (rate.기준 as string[]).flatMap((key) => {
|
||||
const hit = KEY_RE.exec(key);
|
||||
if (!hit) return [key];
|
||||
const j = Number(hit[1]);
|
||||
if ("drop" in mode)
|
||||
return j === mode.drop ? [] : [j > mode.drop ? `add:#${j - 1}${hit[2]}` : key];
|
||||
return [j >= mode.push ? `add:#${j + 1}${hit[2]}` : key];
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
/** 더한줄 k 를 빼고 기억에 둠 — 이름은 되살림 띠 글(서버가 저장 때 다시 적음) */
|
||||
export function forgetAdd(doc: SkDoc, k: number, name: string): void {
|
||||
const one = doc.더한줄?.[k];
|
||||
if (!one) return;
|
||||
doc.뺀더한줄 = [
|
||||
...(doc.뺀더한줄 ?? []),
|
||||
{ 차례: k, 줄: JSON.parse(JSON.stringify({ ...one, ...(name ? { 이름: name } : {}) })) },
|
||||
];
|
||||
doc.더한줄 = (doc.더한줄 ?? []).filter((_, i) => i !== k);
|
||||
moveKeys(doc, { drop: k });
|
||||
}
|
||||
|
||||
/** 기억 n 번째를 그 차례에 다시 끼움(차례가 줄 수보다 크면 맨 끝) */
|
||||
export function reviveAdd(doc: SkDoc, n: number): void {
|
||||
const gone = doc.뺀더한줄?.[n];
|
||||
if (!gone) return;
|
||||
const list = [...(doc.더한줄 ?? [])];
|
||||
const at = Math.min(Math.max(gone.차례, 0), list.length);
|
||||
list.splice(at, 0, gone.줄);
|
||||
doc.더한줄 = list;
|
||||
moveKeys(doc, { push: at });
|
||||
const rest = (doc.뺀더한줄 ?? []).filter((_, i) => i !== n);
|
||||
if (rest.length) doc.뺀더한줄 = rest;
|
||||
else delete doc.뺀더한줄;
|
||||
}
|
||||
|
||||
/** 되살림 띠 글 — 줄 이름 · 없으면 로직 · 요소 · 참조 키 */
|
||||
export function goneName(one: SkAdded): string {
|
||||
const ref = (one.참조 as { 키?: string } | undefined)?.키;
|
||||
return String(one.이름 || one.로직 || one.요소 || ref || "");
|
||||
}
|
||||
|
||||
/** 더한줄 수량 고침 — 처음 값(옛 문서엔 없음)을 먼저 적어 둠 */
|
||||
export function setQty(one: SkAdded, qty: number): void {
|
||||
one.처음수량 ??= one.수량;
|
||||
one.수량 = qty;
|
||||
}
|
||||
|
||||
/** 더한줄 수량 처음 값으로 — 처음 값 모르면 그대로 */
|
||||
export function resetQty(one: SkAdded): void {
|
||||
if (one.처음수량 != null) one.수량 = one.처음수량;
|
||||
}
|
||||
|
||||
/* ── 순수 셈 끝 ── */
|
||||
Reference in New Issue
Block a user