refactor(856-2): 단가산출 화면 머리 띠를 줄 쌓기 셈 답 · 사본 표지로 — 화면 /sangeun/calc 부름 1 → 0

- 머리 띠 근거 = 줄 쌓기 onAnswer(브라우저 셈 답 · 문서 읽기 사본 표지 · 못 읽은 까닭)
  - 까닭(빨강) = 못 읽음 · 못 셈(서버 run 까닭과 같은 차례 — 틀림 › 표지 › 까닭 › 빈값)
  - 빠진 줄 = 금액 없는 줄 · M01 개정 = 자동 따라옴 알림(갱신) · 프로젝트 층 M01 새 판
  - 짝 잃음 · 셈 머리 배지 걷음(덮개 없음 · 2-C1 뒤 서버 답이 늘 비어 지금도 안 뜸)
- Sangeun_Cover.ts 지움(calcSangeun · 부르는 곳 Detail 하나) · CSS 불러오기 · SkDoc 꼴은 Detail 로
- getDoc 의 바탕판 적기 걷음(서버가 저장 때 다시 적고 화면 값 버림)
- 줄 쌓기 못 읽음 두 자리를 한 함수로(머리 글 + 알림)
- setLogicApiPaths 전역 남김 — M02 새 재료 찾기 · 단위 환산 표가 그 길에 기댐(몫 밖 파일)
- 서버 길 /sangeun/calc · 본체 그대로(2-E2 몫)
- 시험 test_856_0: 부름 수 단언 1 → 0 · 띠 견본을 줄 쌓기 답 꼴로(옛 서버 답 견본은 그 길이 화면에서 빠져 낡음)

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
2026-11-18 01:10:39 +09:00
co-authored by Claude Opus 5.5
parent 303723bbd3
commit 35bde65aaa
6 changed files with 151 additions and 165 deletions
+20 -14
View File
@@ -97,6 +97,16 @@ export interface StackScreenOptions {
memory?: () => Record<string, unknown> | null;
/** 856-4 찾아 넣기 창(M01 · M02 = M02 `openFindPicker`) — 공용 화면은 M02 를 부르지 않음 */
find: StackFind;
/** 856-2 그릴 때마다 · 못 읽음 — 셈 답 · 사본 표지(M02 단가산출 머리 띠) */
onAnswer?: (got: StackAnswer) => void;
}
/** 856-2 머리 띠 재료 — 브라우저 셈 답 · 문서 읽기 사본 표지 · 못 읽은 까닭 */
export interface StackAnswer {
doc: StackDoc | null;
answer: DocAnswer | null;
mark?: CopyMark;
fail: string;
}
type Docs = Record<string, FormulaDoc>;
@@ -338,7 +348,15 @@ export function createStackScreen(opt: StackScreenOptions) {
if (cache.takeMissing()) ask();
return got;
};
/** 못 읽음 — 머리에 까닭 · 페이지에 알림(856-2) */
const failed = (e: unknown): void => {
const fail = e instanceof Error ? e.message : "";
const text = `${ft("Load_Failed")} — ${fail}`;
head.replaceChildren(el("p", { className: "ui-text ui-text--muted", text }));
opt.onAnswer?.({ doc, answer, mark, fail });
};
const draw = (): void => {
opt.onAnswer?.({ doc, answer, mark, fail: "" });
if (!doc || !answer) {
[head, left, right, foot].forEach((x) => x.replaceChildren());
opt.tools?.replaceChildren();
@@ -602,13 +620,7 @@ export function createStackScreen(opt: StackScreenOptions) {
recalc();
return draw();
} catch (e) {
if (mine === seq)
head.replaceChildren(
el("p", {
className: "ui-text ui-text--muted",
text: `${ft("Load_Failed")} — ${e instanceof Error ? e.message : ""}`,
}),
);
if (mine === seq) failed(e);
return;
}
}
@@ -645,13 +657,7 @@ export function createStackScreen(opt: StackScreenOptions) {
});
}
} catch (e) {
if (mine === seq)
head.replaceChildren(
el("p", {
className: "ui-text ui-text--muted",
text: `${ft("Load_Failed")} — ${e instanceof Error ? e.message : ""}`,
}),
);
if (mine === seq) failed(e);
}
};
@@ -1,50 +0,0 @@
/* =============================================================================
* M02_MasterTemplete_Sangeun_Cover.ts
* 단가산출(SK) 셈 길 부름(PLAN 717-2b · 856-1) — 머리 띠 · 배지용(856-2 에서 문서 답으로 바꾸고 이 파일 지움)
* · 셈 = `calcSangeun`(`POST /layers/{층}/sangeun/calc` · 저장 안 함 · 부르는 쪽이 최신 응답만 받음)
* ========================================================================== */
import { call, type Layer } from "./M02_MasterTemplete_Api_Fetch";
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` = 시험 입력(빈 칸 뺌) */
export function calcSangeun(
scope: SkScope,
doc: Record<string, unknown>,
given: Record<string, string> = {},
): Promise<SkAnswer> {
const 입력값 = Object.fromEntries(Object.entries(given).filter(([, v]) => String(v).trim()));
return call<SkAnswer>(`/layers/${scope.layer}/sangeun/calc${q(scope)}`, {
method: "POST",
body: JSON.stringify({ 문서: doc, 입력값, 보기: false }), // 보기 false = 글 · 중간 덧칸 안 지음(몸 걷음 · 856-1)
});
}
@@ -3,7 +3,9 @@
* M02 단가산출(SK) 화면(PLAN 717-2b · 804-8 · 856-1) — 머리(이름 · 단위 · 단위 환산 · 바탕) · 머리 띠 · 줄 쌓기(`_Sangeun_Tabs`).
* 모드(856-1 · 옛 키 글자 약속 `SK-000000` 대신) = page(단가산출 화면 · 일위대가 SK 모달 — 원문 패널 · 페이지 [저장] 한 번 ·
* 수식 먼저 → 판 · 수식 칸 새로) · ref(저장한 SK — 줄 쌓기 자기 저장 · 불러오기 저장 뒤) · memory(저장 전 가져온 식 · 보기만)
* 머리 띠(까닭 · M01 개정 · 빠진 줄 · 짝 잃음) · 머리 배지 = 서버 셈 길 최신 응답(856-2 에서 문서 답으로)
* 머리 띠(856-2) = 줄 쌓기 셈 답 · 문서 읽기 사본 표지(`onAnswer` · 서버 셈 길 안 부름) —
* 까닭(빨강) = 못 읽음 · 못 셈(서버 `M02_Sangeun_Calc.run` 「까닭」 과 같은 차례) · 빠진 줄 = 금액 없는 줄 까닭 ·
* M01 개정 = 자동 따라옴 알림(`갱신`) · 프로젝트 층 「M01 새 판」 · 짝 잃음 = 덮개 없음([재생성] 답이 알림)
* 옛 상세 몸(덮개 · 뺀줄 · 더한줄 · 재료 고름 · 줄 모달)은 856-1 에 걷음 — 고침은 줄 쌓기 한 벌
* ========================================================================== */
@@ -18,15 +20,26 @@ import {
setLogicApiPaths,
type LogicOne,
} from "../M01_MasterData/M01_MasterData_UI_Logic_Api";
import { isStale } from "../A00_Common/formula_doc_copy";
import type { StackAnswer } from "../A00_Common/line_stack_screen";
import { readTemplate, type Layer } from "./M02_MasterTemplete_Api_Fetch";
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 } 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;
@@ -42,6 +55,31 @@ export interface SangeunDetailOptions {
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) — 못 셈 까닭 · 금액 없는 줄 · M01 개정 */
export function bandsOf(got: StackAnswer | null): {
why: string;
gaps: { 이름: string; 까닭: string }[];
revised: boolean;
} {
const a = got?.answer;
const m = got?.mark;
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.까닭) }));
const revised = !!m?.갱신?.length || (!m?.자동 && isStale(m));
return { why, gaps, revised };
}
export function mountSangeunDetail(
host: HTMLElement,
doc0: unknown,
@@ -58,18 +96,15 @@ export function mountSangeunDetail(
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 ans: SkAnswer | null = null;
let got: StackAnswer | null = null; // 줄 쌓기 셈 답 · 사본 표지(856-2)
let fail = "";
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 flag = el("span"); // M01 개정 배지 자리(856-2 — 줄 쌓기가 그릴 때마다 머리 칸은 그대로)
let refreshing: Promise<void> = Promise.resolve();
const tabs = createSangeunTabs({
edit,
@@ -78,6 +113,10 @@ export function mountSangeunDetail(
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> {
@@ -110,35 +149,17 @@ export function mountSangeunDetail(
);
tabs.draw(opt.mode === "memory" ? "" : (doc.키 ?? ""));
// 바탕 없는 SK 의 지문 = 이름 · 단위 따라 바뀜 — 바탕이 있을 때만 M01 개정으로 봄(725-3)
const revisedBase = (): boolean =>
!!(doc.바탕 && doc.바탕판 && ans?.바탕판 && doc.바탕판 !== ans.바탕판);
const baseKey = (): string | null => doc.바탕?.로직 ?? null;
/** 고침 알림 — 기본(이름 · 단위 · 환산) + 수식 */
function report(): void {
if (alive) opt.onChanged(edit && (JSON.stringify(doc) !== saved || tabs.dirty()));
}
const touch = (again = true): void => {
const touch = (): void => {
report();
if (again) void recalc();
else drawHead();
drawHead();
};
/** 머리 띠 · 배지 = 서버 셈 한 번(최신 응답만) */
async function recalc(): Promise<void> {
const mine = ++seq;
try {
const got = await calcSangeun(scope, doc, values);
if (mine !== seq || !alive) return; // 늦게 온 답 — 버림
[ans, fail] = [got, ""];
} catch (error) {
if (mine !== seq || !alive) return;
[ans, fail] = [null, error instanceof Error ? error.message : String(error)];
}
draw();
}
function drawHead(): void {
const field = (label: string, key: "이름" | "단위"): HTMLElement => {
const box = createInputField({ label, value: doc[key] ?? "", compact: true, size: 28 });
@@ -147,7 +168,7 @@ export function mountSangeunDetail(
box.input.addEventListener("change", () => {
doc[key] = box.input.value.trim();
box.setError(doc[key] ? undefined : L("M02_SangeunNeed"));
touch(key === "단위");
touch();
});
return box.root;
};
@@ -173,44 +194,27 @@ export function mountSangeunDetail(
el("div", {
className: "m02-sk__tags",
attrs: { "data-sk-base": baseKey() ?? "" },
children: [
createText(`${L("M02_SangeunBase")} · ${baseText}`, "muted", 14),
...(ans?.머리 ? [createBadge(ans.머리, "info")] : []),
...(revisedBase() ? [createBadge(L("M02_SangeunRevisedBase"), "danger")] : []),
],
children: [createText(`${L("M02_SangeunBase")} · ${baseText}`, "muted", 14), flag],
}),
);
}
function drawNotes(): void {
const lost = ans?.짝잃음 ?? [];
const gaps = ans?.빠진줄 ?? [];
const { why, gaps, revised } = bandsOf(got);
notes.replaceChildren(
...(fail || ans?.까닭
? [createBanner({ tone: "danger", text: fail || String(ans?.까닭) })]
: []),
...(revisedBase()
? [createBanner({ tone: "warning", text: L("M02_SangeunRevisedNote") })]
: []),
...(fail || why ? [createBanner({ tone: "danger", text: fail || why })] : []),
...(revised ? [createBanner({ tone: "warning", text: L("M02_SangeunRevisedNote") })] : []),
...(gaps.length
? [
createBanner({
tone: "warning",
text: `${L("M02_SangeunGap")} — ${gaps.map((x) => x.이름 || x.cid).join(" · ")}`,
details: gaps.map((x) => `${x.이름 || x.cid} — ${x.까닭}`).join("\n"),
}),
]
: []),
...(lost.length
? [
createBanner({
tone: "warning",
text: L("M02_SangeunLost"),
details: lost.map((x) => `${x.cid} — ${x.까닭}`).join("\n"),
text: `${L("M02_SangeunGap")} — ${gaps.map((x) => x.이름).join(" · ")}`,
details: gaps.map((x) => `${x.이름} — ${x.까닭}`).join("\n"),
}),
]
: []),
);
flag.replaceChildren(...(revised ? [createBadge(L("M02_SangeunRevisedBase"), "danger")] : []));
}
function draw(): void {
@@ -229,15 +233,12 @@ export function mountSangeunDetail(
fail = error instanceof Error ? error.message : String(error);
}
}
if (!alive) return;
draw();
await recalc();
}
void loadBase();
return {
getDoc: () => {
if (ans?.바탕판 && doc.바탕) doc.바탕판 = ans.바탕판; // 저장 = 지금 바탕 확인(서버가 다시 적음)
saved = JSON.stringify(doc);
return clone(doc);
},
@@ -7,7 +7,7 @@
* [단가 갱신] · [재생성](808-1 · 요구 701-3) = `tools` — 머리 줄
* ========================================================================== */
import { createStackScreen } from "../A00_Common/line_stack_screen";
import { createStackScreen, type StackAnswer } from "../A00_Common/line_stack_screen";
import { el } from "@ui/ui_template_elements";
import type { Layer } from "./M02_MasterTemplete_Api_Fetch";
import { openFindPicker } from "./M02_MasterTemplete_Find_Pick";
@@ -21,6 +21,8 @@ export interface SkEquationOptions {
page?: () => void;
/** 저장 전 불러온 단가산출 문서(836-5 · 미리 보기 835-1) — 그 문서째 수식 보기 */
memory?: () => Record<string, unknown> | null;
/** 856-2 셈 답 · 사본 표지 — 머리 띠 */
onAnswer?: (got: StackAnswer) => void;
}
/** SK 수식 길 — 꼬리 물음(`/table?key=…`)에 주인 물음을 이어 붙임 */
@@ -58,6 +60,7 @@ export function createSangeunTabs(opt: SkEquationOptions): {
page: opt.page,
tools,
memory: opt.memory,
onAnswer: opt.onAnswer,
});
return {
tools,
+50 -35
View File
@@ -134,15 +134,19 @@ const ui = {
};
const grid = { onRowClick: null };
// 줄 쌓기 화면 = 그린 키 · 저장 전 문서만 적음
// 줄 쌓기 화면 = 그린 키 · 저장 전 문서만 적음 · 그릴 때 견본 셈 답 · 사본 표지를 알림(856-2)
const stacks = [];
let stackAns = () => ({ doc: {}, answer: plainAns(), mark: { 자동: true }, fail: "" });
const screen = {
createStackScreen: (opt) => {
const s = { root: box("div", { "data-stack": "" }), draws: [], opt };
stacks.push(s);
return {
root: s.root,
draw: (k) => s.draws.push({ key: k, memory: !k && !!opt.memory?.() }),
draw: (k) => {
s.draws.push({ key: k, memory: !k && !!opt.memory?.() });
setTimeout(() => opt.onAnswer?.(stackAns()), 0);
},
dirty: () => false,
save: async () => true,
discard: async () => {},
@@ -154,11 +158,9 @@ const screen = {
// 서버 부름 — 길 · 몸을 적고 견본 답
const calls = [];
let skAnswer = () => ({});
const api = {
call: async (p, init) => {
calls.push({ path: p, body: init?.body ? JSON.parse(init.body) : null });
if (p.includes("/sangeun/calc")) return skAnswer();
if (p.includes("/labor/")) return { 줄: [], 자재: [], 알약: [] };
return {};
},
@@ -207,7 +209,7 @@ const stubs = {
const real = new Set([
"M02_MasterTemplete_Sangeun_Detail",
"M02_MasterTemplete_Sangeun_Tabs",
"M02_MasterTemplete_Sangeun_Cover",
"formula_doc_copy",
"M02_MasterTemplete_Sangeun_BaseHead",
"M02_Sangeun_Cover_Model",
"M02_Sangeun_Undo",
@@ -266,17 +268,18 @@ const shown = (n) => {
return true;
};
const skCalls = () => calls.filter((c) => c.path.includes("/sangeun/calc"));
const plainAns = (o = {}) => ({
기준: null,
줄: [
{ 이름: "보통인부", cid: "labor:LB1#0", 수량: 1, 단가: 100, 금액: 100, 비목: { 노무비: 100 } },
],
정체: ["labor:LB1#0"],
짝잃음: [],
빠진줄: [],
바탕판: "v1",
...o,
});
/** 브라우저 셈 답(`calcDoc` 꼴) */
function plainAns(o = {}) {
return {
셈됨: true,
표지: [],
빈값: {},
줄: [{ 이름: "보통인부", 수량: 1, 단가: 100, 금액: 100, 비목: { 노무비: 100 } }],
계: 100,
머리: "계",
...o,
};
}
/** 단가산출 화면 한 벌 열기 — 부름 수 · 숨은 몸 · 줄 쌓기 그림 · 띠 */
async function openSk(doc, opt = {}) {
@@ -299,6 +302,7 @@ async function openSk(doc, opt = {}) {
bodyShown: all(host, (n) => "skCover" in n.dataset && shown(n)).length,
stack: s ? { shown: shown(s.root), draws: s.draws } : null,
banners: all(host, (n) => "banner" in n.dataset).map((n) => n.dataset.banner),
texts: all(host, (n) => "banner" in n.dataset).map((n) => n.textContent),
badges: all(host, (n) => "badge" in n.dataset).map((n) => [n.dataset.badge, n.textContent]),
};
h.destroy();
@@ -307,7 +311,6 @@ async function openSk(doc, opt = {}) {
(async () => {
const out = {};
skAnswer = () => plainAns();
// ① 단가산출 화면(페이지) — 바탕 있음 · 없음
out.page_base = await openSk(
{ 키: "SK-000001", 이름: "견본", 단위: "㎡", 바탕: { 로직: "GC001109" } },
@@ -315,26 +318,38 @@ async function openSk(doc, opt = {}) {
);
out.page_nobase = await openSk({ 키: "SK-000002", 이름: "견본", 단위: "㎡" }, { mode: "page" });
// 불러오기 미리 보기(저장 전 가져온 식)
out.memory = await openSk({ 이름: "가져온", 단위: "식", 가져온: { 파일: "x" } }, { mode: "memory" });
// ③ 머리 띠 넷(견본 답) — 까닭 · M01 개정 · 빠진 줄 · 짝 잃음 + 머리 배지
skAnswer = () =>
plainAns({
까닭: "못 셈",
빠진줄: [{ cid: "labor:LB2#1", 이름: "특별인부", 까닭: "입력 없음" }],
짝잃음: [{ cid: "labor:LB9#0", 까닭: "줄 없음" }],
바탕판: "v2",
머리: "계",
});
out.bands = await openSk(
{ 키: "SK-000003", 이름: "띠", 단위: "㎡", 바탕: { 로직: "GC001109" }, 바탕판: "v1" },
{ mode: "page" },
out.memory = await openSk(
{ 이름: "가져온", 단위: "식", 가져온: { 파일: "x" } },
{ mode: "memory" },
);
skAnswer = () => {
throw new Error("서버 못 닿음");
// ③ 머리 띠(856-2 — 줄 쌓기 셈 답 · 사본 표지) — 빠진 줄 · M01 개정(자동 따라옴 알림) · 못 셈 까닭 · 프로젝트 층 새 판 · 못 읽음
const gapLine = { 이름: "특별인부", 금액: null, 까닭: "입력 없음", 비목: {} };
const sk3 = { 키: "SK-000003", 이름: "띠", 단위: "㎡", 바탕: { 로직: "GC001109" } };
const bandCase = async (ans, key) => {
stackAns = () => ans;
const r = await openSk({ ...sk3, 키: key }, { mode: "page" });
stackAns = () => ({ doc: {}, answer: plainAns(), mark: { 자동: true }, fail: "" });
return r;
};
out.bands_fail = await openSk({ 키: "SK-000004", 이름: "띠", 단위: "㎡" }, { mode: "page" });
skAnswer = () => plainAns();
const ans = (a, mark = { 자동: true }, doc = {}) => ({ doc, answer: a, mark, fail: "" });
out.bands = await bandCase(
ans(plainAns({ 줄: [...plainAns().줄, gapLine] }), { 자동: true, 갱신: [{ 키: "M1" }] }),
"SK-000003",
);
out.bands_why = await bandCase(
ans(
plainAns({ 셈됨: false, 계: null, 표지: [{ 갈래: "빈 문서", 글: "금액 줄 · 결과 없음" }] }),
),
"SK-000005",
);
out.bands_broken = await bandCase(ans(plainAns({ 셈됨: false }), {}, { _틀림: "틀린 문서" }), "SK-000006"); // prettier-ignore
out.bands_stale = await bandCase(ans(plainAns(), { 자동: false, M01새판: true }), "SK-000007");
out.bands_auto_stale = await bandCase(
ans(plainAns(), { 자동: true, M01새판: true }),
"SK-000008",
);
out.bands_fail = await bandCase({ doc: null, answer: null, fail: "서버 못 닿음" }, "SK-000004");
// ② 일위대가 표 줄 누름 — SK 참조 줄 · M01 로직 줄 · 셈 주입(프로젝트 사본) SK 줄
const { mountLaborTable } = M("M02_MasterTemplete/M02_MasterTemplete_Labor_Table.ts");
+21 -10
View File
@@ -1,9 +1,9 @@
# -*- coding: utf-8 -*-
"""PLAN 856-0 — 단가산출 화면 지킴(가짜 DOM · 진짜 코드 · `helper_856_0_sk_screen.cjs`).
① 단가산출 화면을 열 때 서버 `/sangeun/calc` 부름 수 · 숨은 상세 몸 DOM · 줄 쌓기 그림
① 단가산출 화면을 열 때 서버 `/sangeun/calc` 부름 0(856-2) · 숨은 상세 몸 DOM · 줄 쌓기 그림
② 일위대가 표 줄 누름 — 단가산출(SK) 참조 줄 = 그 SK 줄 쌓기 · M01 로직 줄 · 셈 주입(프로젝트 사본) 줄
③ 머리 띠 넷(까닭 · M01 개정 · 빠진 줄 · 짝 잃음)이 뜨는 경우 — 견본 답
③ 머리 띠(까닭 · M01 개정 · 빠진 줄)가 뜨는 경우 — 줄 쌓기 셈 답 · 사본 표지 견본(856-2 · 짝 잃음 = 덮개 없음)
④ M01 로직 상세 그릇 = 기본정보 접힘 + 줄 쌓기
"""
@@ -31,9 +31,9 @@ def _run() -> dict:
def test_sk_page_open_calls_and_hidden_body() -> None:
got = _run()
# 856-1 — 셈 한 번(머리 띠용 · 바탕 원값 bare 셈 걷음) · 숨은 상세 몸 DOM 0 · 줄 쌓기 한 번 그림
# 856-2 — 서버 셈 길 안 부름(머리 띠 = 줄 쌓기 답) · 숨은 상세 몸 DOM 0 · 줄 쌓기 한 번 그림
for k in ("page_base", "page_nobase", "memory"):
assert got[k]["calc"] == 1, k
assert got[k]["calc"] == 0, k
assert got[k]["body"] == 0, k
assert got[k]["stack"]["shown"] is True, k
assert got["page_base"]["stack"]["draws"] == [{"key": "SK-000001", "memory": False}]
@@ -45,7 +45,7 @@ def test_labor_row_click() -> None:
sk, logic = _run()["labor"]
# 단가산출 참조 줄 = 그 SK 문서 모달 · 줄 쌓기가 그 키로 보임
assert sk["skModal"] == 1 and sk["stack"]["shown"] is True
assert sk["stack"]["draws"] == ["SK-000010"] and sk["calc"] == 1
assert sk["stack"]["draws"] == ["SK-000010"] and sk["calc"] == 0
# M01 로직 줄 = 줄 모달(안내 한 줄) · 상세 몸 · 줄 쌓기 · 셈 없음(856-1)
assert logic["skModal"] == 0 and logic["stack"] is None
assert logic["body"] == 0 and logic["banners"] == ["info"] and logic["calc"] == 0
@@ -59,13 +59,24 @@ def test_labor_row_click_inject() -> None:
assert row["body"] == 0 and row["banners"] == ["info"] and row["calc"] == 0
def test_head_bands_four() -> None:
def test_head_bands() -> None:
got = _run()
# 까닭(빨강) · M01 개정 · 빠진 줄 · 짝 잃음(노랑) + 머리 배지 · 개정 배지
assert got["bands"]["banners"] == ["danger", "warning", "warning", "warning"]
assert got["bands"]["badges"] == [["info", "계"], ["danger", "M02_SangeunRevisedBase"]]
# 서버 못 닿음 = 빨강 하나
# 자동 따라옴 알림 = M01 개정(노랑 + 빨강 배지) · 금액 없는 줄 = 빠진 줄(노랑)
b = got["bands"]
assert b["banners"] == ["warning", "warning"] and b["calc"] == 0
assert b["badges"] == [["danger", "M02_SangeunRevisedBase"]]
assert b["texts"][0] == "M02_SangeunRevisedNote"
assert b["texts"][1] == "M02_SangeunGap — 특별인부"
# 못 셈 = 빨강 하나 · 글 = 서버 `까닭` 과 같은 차례(틀림 › 표지 › 까닭 › 빈값)
assert got["bands_why"]["banners"] == ["danger"]
assert got["bands_why"]["texts"] == ["빈 문서 — 금액 줄 · 결과 없음"]
assert got["bands_broken"]["texts"] == ["틀린 문서"]
# 프로젝트 층(자동 아님) 「M01 새 판」 = M01 개정 · 자동 따라옴 층은 알림 없으면 띠 없음
assert got["bands_stale"]["banners"] == ["warning"]
assert got["bands_auto_stale"]["banners"] == [] and got["bands_auto_stale"]["badges"] == []
# 못 읽음 = 빨강 하나(그 까닭)
assert got["bands_fail"]["banners"] == ["danger"]
assert got["bands_fail"]["texts"] == ["서버 못 닿음"]
assert got["page_base"]["banners"] == [] and got["page_base"]["badges"] == []