Files
Aislo/M02_MasterTemplete/M02_MasterTemplete_Sangeun_Detail.ts
T
eomsangdonandClaude Opus 5.5 c4050ccf73 feat(859-2 ㉯): M02 단가산출 M01 따라옴 알림 = 토스트 한 번 — [확인] 창 · 머리 띠 · 배지 걷음
- 화면: 열 때 알림 창(표 · [위 값으로] · [확인] · [나중에]) → 토스트 「M01 기초가 바뀌어 반영됨」(+ 「내가 고친 칸 n 은 내 값 그대로」 · 「다시 못 얹은 내 고침 n」) · 확인 단추 없음
- 되풀이 막기: 서버 읽기 답 `사본.따라옴` = 저장본 대 지금 사본의 M01 몫 지문(값 판 · 부른 문서 · 바탕 판 · 문서 계산 내용 · 같으면 null) ·
  화면 localStorage(SK 길마다 {따라옴 지문, 알림 글}) — 새 지문 · 새 알림일 때만 · [저장] 하면 지문 없음
- 머리 띠 「바탕 단가산출 기초가 저장 뒤 바뀜」 · 배지 「M01 개정 — 확인」 · 「지워짐 n」 배지 걷음 · 글 키 걷음
- 서버: [확인] 저장 할일 `갱신확인`(`renew.CONFIRM` · form/_covers/_soft confirm 갈래) · 수식 길 `할일` 칸 걷음 ·
  읽기 답 바뀜 표지(M01새판 · 지운키 · 단가새값 · 문서새판 · 자동 = 열 때마다 dc.state 셈) 걷음
- 자동 반영 · 내 고친 칸 지킴(파란 테두리 · 풍선 「원래 값」) 그대로
- 시험: 836_2 ㉧ 토스트 지문(만든 뒤 없음 · 바뀜 = 같은 지문 · 저장 뒤 없음 · 또 바뀜 = 다른 지문) · 848_10 따로 문서 옵션 따라옴 = 지문 ·
  확인 저장 단언은 [저장] 꼴로 · test_confirm_clears 지움 · 읽기 답 표지 단언 걷음 · 856_0 띠 = 빠진 줄만

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-18 23:34:39 +09:00

258 lines
9.6 KiB
TypeScript

/* =============================================================================
* M02_MasterTemplete_Sangeun_Detail.ts
* M02 단가산출(SK) 화면(PLAN 717-2b · 804-8 · 856-1) — 머리(이름 · 단위 · 단위 환산 · 바탕) · 머리 띠 · 줄 쌓기(`_Sangeun_Tabs`).
* 모드(856-1 · 옛 키 글자 약속 `SK-000000` 대신) = page(단가산출 화면 · 일위대가 SK 모달 — 원문 패널 · 페이지 [저장] 한 번 ·
* 수식 먼저 → 판 · 수식 칸 새로) · ref(저장한 SK — 줄 쌓기 자기 저장 · 불러오기 저장 뒤) · memory(저장 전 가져온 식 · 보기만)
* 머리 띠(856-2) = 줄 쌓기 셈 답 · 문서 읽기 사본 표지(`onAnswer` · 서버 셈 길 안 부름) —
* 까닭(빨강) = 못 읽음 · 못 셈(서버 `M02_Sangeun_Calc.run` 「까닭」 과 같은 차례) · 빠진 줄 = 금액 없는 줄 까닭 ·
* M01 개정 알림 = 줄 쌓기가 토스트 한 번(859-2 · 머리 띠 · 배지 없음)
* 옛 상세 몸(덮개 · 뺀줄 · 더한줄 · 재료 고름 · 줄 모달)은 856-1 에 걷음 — 고침은 줄 쌓기 한 벌
* ========================================================================== */
import { createBanner } from "@ui/ui_template_banner";
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 {
fetchLogic,
setLogicApiPaths,
type LogicOne,
} from "../M01_MasterData/M01_MasterData_UI_Logic_Api";
import type { StackAnswer } from "../A00_Common/line_stack_screen";
import { readTemplate, type Layer } from "./M02_MasterTemplete_Api_Fetch";
import { createSangeunTabs } from "./M02_MasterTemplete_Sangeun_Tabs";
import { tl } from "../M01_MasterData/M01_MasterData_UI_LogicLab_Text";
import { createSangeunSide, tabOf } from "./M02_MasterTemplete_Sangeun_Side";
import { buildUnitSwap, type SwapHow } from "./M02_MasterTemplete_Sangeun_Unit";
import "./M02_MasterTemplete_Sangeun.css";
export type SangeunMode = "page" | "ref" | "memory";
/** SK 문서 중 화면 머리가 만지는 칸 */
export interface SkDoc {
키?: string;
이름?: string;
단위?: string;
바탕?: { 로직?: string; 참조?: { 층?: string; 주인?: string | null; 키?: string } } | null;
[k: string]: unknown;
}
export interface SangeunDetailOptions {
layer: Layer;
owner: string | null;
readOnly: boolean;
onChanged: (dirty: boolean) => void;
/** 856-1 화면 모드 — 머리 글 */
mode: SangeunMode;
/** 수식 저장 뒤 그 SK 새 판(페이지 [저장] 409 막음 · 802-4b-2) */
onVersion?: (version: string) => void;
slot?: HTMLElement; // 페이지 머리 줄 빈 자리(804-8) — 보기 고르기를 M01 처럼 머리 줄에
}
const LIB = { read: "/m02/logic-lib", calc: "/m02/logic-lib" };
const clone = <T>(v: T): T => JSON.parse(JSON.stringify(v)) as T;
/** 머리 띠 재료(856-2) — 못 셈 까닭 · 금액 없는 줄 */
export function bandsOf(got: StackAnswer | null): {
why: string;
gaps: { 이름: string; 까닭: string }[];
} {
const a = got?.answer;
const marks = (a?.표지 ?? []).map((x) => `${x.갈래} — ${x.글}`).join(" · ");
const why =
got?.fail ||
(!a || a.셈됨 || "결과" in a
? ""
: String((got?.doc as { _틀림?: string } | null)?._틀림 ?? "") ||
marks ||
a.까닭 ||
Object.values(a.빈값 ?? {}).join(" · ") ||
"돈 아닌 문서");
const gaps = (a?.셈됨 ? (a.줄 ?? []) : [])
.filter((r) => r.까닭 && r.금액 == null)
.map((r) => ({ 이름: String(r.이름 ?? ""), 까닭: String(r.까닭) }));
return { why, gaps };
}
export function mountSangeunDetail(
host: HTMLElement,
doc0: unknown,
opt: SangeunDetailOptions,
): {
getDoc: () => SkDoc;
/** 페이지 [저장] 앞 — 수식 고침 저장 · 실패면 던짐 */
flush: () => Promise<void>;
destroy: () => void;
} {
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 };
let base: LogicOne | null = null;
let got: StackAnswer | null = null; // 줄 쌓기 셈 답 · 사본 표지(856-2)
let fail = "";
const side = page ? createSangeunSide() : null;
let alive = true;
const head = el("div", { className: "m02-sk__head", attrs: { "data-sk-head": "" } });
const notes = el("div");
let refreshing: Promise<void> = Promise.resolve();
const tabs = createSangeunTabs({
edit,
scope,
onSaved: (v) => void (refreshing = formulaSaved(v)),
page: page ? () => report() : undefined, // 804-8 페이지 [저장] · [되돌림]
// 836-5 저장 전 가져온 식(불러오기 미리 보기) = 그 문서째 수식 보기
memory: opt.mode === "memory" ? () => doc as Record<string, unknown> : undefined,
onAnswer: (next) => {
got = next;
if (alive) drawNotes();
},
});
/** 수식 저장 = 파일 판 · `수식` 칸이 바뀜 — 페이지 판 · 이 화면 문서 `수식` 을 새로 */
async function formulaSaved(version: string): Promise<void> {
opt.onVersion?.(version);
try {
const got = (await readTemplate(opt.layer, "sangeun", doc.키 ?? "", null, opt.owner))
.문서 as SkDoc;
if (!alive) return;
const was = JSON.parse(saved) as SkDoc;
[doc.수식, was.수식, doc.가져온, was.가져온] = [got.수식, got.수식, got.가져온, got.가져온]; // 807-1 단가기준
saved = JSON.stringify(was);
touch();
} catch {
/* 못 읽음 = 다음 열기 때 새로 */
}
}
const main = el("div", {
className: "m02-sk",
attrs: { "data-sangeun-detail": doc.키 ?? "" },
children: [
head,
notes,
...(opt.slot ? [] : [el("div", { className: "m02-sk__head", children: [tabs.tools] })]),
tabs.host,
],
});
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 baseKey = (): string | null => doc.바탕?.로직 ?? null;
/** 고침 알림 — 기본(이름 · 단위 · 환산) + 수식 */
function report(): void {
if (alive) opt.onChanged(edit && (JSON.stringify(doc) !== saved || tabs.dirty()));
}
const touch = (): void => {
report();
drawHead();
};
function drawHead(): void {
// 856-G 칸 고침 = 머리를 다시 그리지 않음(Tab 으로 옮긴 다음 칸 초점 · 타자 유지) · 환산만 새로
const field = (label: string, key: "이름" | "단위"): HTMLElement => {
const box = createInputField({ label, value: doc[key] ?? "", compact: true, size: 28 });
box.input.dataset.sk = key;
box.input.disabled = !edit;
box.input.addEventListener("change", () => {
doc[key] = box.input.value.trim();
box.setError(doc[key] ? undefined : L("M02_SangeunNeed"));
report();
if (key === "단위") drawSwap();
});
return box.root;
};
const baseName = base ? `${base.logic.키} ${base.logic.이름}` : null;
const baseText = baseName ?? doc.바탕?.참조?.키 ?? L("M02_SangeunNoBase");
const swapSlot = el("span", { className: "m02-sk__swap-slot" });
const drawSwap = (): void => {
const swap = base
? buildUnitSwap({
result: base.logic.결과단위,
unit: doc.단위 ?? "",
how: doc.환산 as SwapHow | undefined,
edit,
onChange: (how) => {
if (how) doc.환산 = how;
else delete doc.환산;
report();
drawSwap();
},
})
: null;
swapSlot.replaceChildren(...(swap ? [swap] : []));
};
drawSwap();
head.replaceChildren(
field(L("M02_Name"), "이름"),
field(L("M02_SangeunUnit"), "단위"),
swapSlot,
el("div", {
className: "m02-sk__tags",
attrs: { "data-sk-base": baseKey() ?? "" },
children: [createText(`${L("M02_SangeunBase")} · ${baseText}`, "muted", 14)],
}),
);
}
function drawNotes(): void {
const { why, gaps } = bandsOf(got);
notes.replaceChildren(
...(fail || why ? [createBanner({ tone: "danger", text: fail || why })] : []),
...(gaps.length
? [
createBanner({
tone: "warning",
text: `${L("M02_SangeunGap")} — ${gaps.map((x) => x.이름).join(" · ")}`,
details: gaps.map((x) => `${x.이름} — ${x.까닭}`).join("\n"),
}),
]
: []),
);
}
function draw(): void {
if (!alive) return;
drawHead();
drawNotes();
side?.set(base ? [tabOf(base.logic)] : [], doc);
}
async function loadBase(): Promise<void> {
const key = baseKey();
if (key) {
try {
base = await fetchLogic(key);
} catch (error) {
fail = error instanceof Error ? error.message : String(error);
}
}
draw();
}
void loadBase();
return {
getDoc: () => {
saved = JSON.stringify(doc);
return clone(doc);
},
flush: async () => {
if (!tabs.dirty()) return;
if (!(await tabs.save())) throw new Error(tl("View_Equation"));
await refreshing; // 새 판 · `수식` 칸 받은 뒤 페이지가 저장
},
destroy: () => {
alive = false;
if (tabs.dirty()) void tabs.discard(); // 페이지가 버리고 떠남 — 수식 캐시도 비움
tabs.destroy();
host.replaceChildren();
},
};
}