refactor(855-E L3ⓐ): M01 [로직 복사/생성] = 원본 수식 문서 복제 — 옛 별칭 꼴 시트 화면 걷음

- [로직 복사/생성] 누름 = 기본정보 창(있는 askBasicInfo · 원본 값 채움) → /logic/copy 로 원본 문서를 새 자체 GX 문서로 복제 → 그 기초를 줄 쌓기로 엶
- 걷음: 화면 LogicLab_Copy.ts · Logic_Calc.ts(부르는 곳 = 서로뿐) · API fetchLogicFormula · saveLogicFormula · previewLogicFormula · 꼴 셋 · 글 키 · CSS m01copy (서버 길 /logic/formula · save · preview 는 앞 auto 커밋 cce57c298 에서 걷음 · openapi 뜻한 셋만 빠짐)
- 시험: test_modal_top_and_add_word 복사 시트 창 줄 뺌(걷은 파일 · CSS 의 글자 대조 줄)

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
2026-11-18 08:37:59 +09:00
co-authored by Claude Opus 5.5
parent 7e6190f8d3
commit 9e38ef0446
9 changed files with 54 additions and 593 deletions
+29 -11
View File
@@ -6,6 +6,7 @@
* 데이터 흐름(CLAUDE.md 5장) — 고친 것은 캐시(sessionStorage)에 쌓고 [저장] 한 번에 `POST /save`.
* 409 = 그 사이 파일이 바뀜 · 422 = 검사 걸림(아무것도 안 씀) — 까닭은 서버 글 그대로 보임.
* 머리 단추(804-7 · 요구 687-2) = [신규 로직] · [로직 복사/생성] · [로직 삭제] · [되돌림] · [저장] · 목록에선 [신규 로직]만(요구 693)
* [로직 복사/생성] = 기본정보 창(원본 값) → 원본 수식 문서를 새 자체 기초로 복제(`/logic/copy` · 855 L3 ⓐ) → 그 기초를 엶(줄 쌓기에서 고침)
* [저장] = 기본정보 · 별칭(로직 줄 `/save`) + 수식(줄 쌓기 `/logic/doc/save`) 한 번에 · [되돌림] = 둘 다 저장 뒤 상태로
* [로직 삭제] = 확인 → 서버 정본에서 바로(`/logic/remove` — 로직 줄 + 수식 문서 · 부르는 곳 있으면 막고 까닭) → 로직 목록
* ========================================================================== */
@@ -21,6 +22,7 @@ import {
} from "@ui/ui_template_elements";
import {
ApiError,
copyLogic,
fetchLogic,
fetchLogicFiles,
fetchLogics,
@@ -37,7 +39,6 @@ import type { SideHandle } from "./M01_MasterData_UI_Side";
import { tx } from "./M01_MasterData_UI_Logic_Text";
import { buildLabDetail } from "./M01_MasterData_UI_LogicLab_Detail";
import { setLogicOpener } from "./M01_MasterData_UI_LogicLab_Modal";
import { openCopyScreen } from "./M01_MasterData_UI_LogicLab_Copy";
import { tl } from "./M01_MasterData_UI_LogicLab_Text";
import { askBasicInfo } from "./M01_MasterData_UI_LogicLab_Basic";
import { saveRevised } from "./M01_MasterData_UI_LogicLab_Revise";
@@ -428,6 +429,32 @@ export async function mountM01LogicLab(
}
};
/** [로직 복사/생성] — 저장된 원본 문서를 복제(고친 캐시는 안 따라감) · 새 기초를 줄 쌓기로 엶 */
const onCopy = async (): Promise<void> => {
const row = opened?.row;
if (!opened?.origKey || !row) return void showToast(tl("Copy_NeedOpen"), "info");
const key = opened.origKey;
const units = [...new Set(allLogics.map((x) => x.결과단위).filter(Boolean))];
const info = await askBasicInfo(units, {
이름: row.이름,
원문번호: row.원문번호 ?? "",
결과단위: row.결과단위 ?? "",
출처: row.출처 ?? "",
});
if (!info || !(await leave())) return;
showLoadingOverlay();
try {
const got = await copyLogic(key, info);
await reload();
await open(logicId("자체", got.key), "자체", got.key);
showToast(tl("Copy_Done"), "success");
} catch (error) {
failed(error);
} finally {
hideLoadingOverlay();
}
};
const saveButton = createButton({
label: tx("Bar_Save"),
iconStart: "check",
@@ -443,16 +470,7 @@ export async function mountM01LogicLab(
label: tl("Copy_Open"),
variant: "ghost",
iconStart: "copy",
onClick: () =>
opened?.origKey
? void openCopyScreen({
key: opened.origKey,
afterSave: async (newKey) => {
await reload();
await open(logicId("자체", newKey), "자체", newKey);
},
})
: showToast(tl("Copy_NeedOpen"), "info"),
onClick: () => void onCopy(),
});
const deleteButton = createButton({
label: tx("Bar_Delete"),
@@ -2,6 +2,7 @@
* M01_MasterData_UI_LogicLab_Basic.ts
* 「신규 로직」 기본정보 칸 — 이름 · 원문번호 · 결과 단위 · 출처(구분 = 자체). 확인하면 값을 돌려줌 · 취소면 null
* 저장은 하지 않음 — 부른 쪽이 빈 시트 줄로 캐시(drafts)에 넣고 [저장] 때 서버가 GX 새 키를 줌.
* [로직 복사/생성]도 이 창(원본 값을 채워 엶 · 855 L3 ⓐ) — 부른 쪽이 `/logic/copy` 로 문서를 복제.
* ========================================================================== */
import { currentLanguageIndex } from "@ui/ui_template_locale";
@@ -10,6 +11,7 @@ import { openModal } from "@ui/ui_template_modal";
const TEXT = {
Title: ["신규 로직", "New logic"],
CopyTitle: ["로직 복사/생성", "Copy / create logic"],
Name: ["이름", "Name"],
NamePh: ["예: 돌쌓기 메쌓기(인력)", "e.g. dry stone wall (labour)"],
Number: ["원문번호", "Source number"],
@@ -31,8 +33,8 @@ export interface BasicInfo {
출처: string;
}
/** 기본정보 묻기 — units = 결과 단위 후보(마스터 로직의 결과단위) */
export function askBasicInfo(units: string[]): Promise<BasicInfo | null> {
/** 기본정보 묻기 — units = 결과 단위 후보(마스터 로직의 결과단위) · start = 처음 값(복사 = 원본 값) */
export function askBasicInfo(units: string[], start?: BasicInfo): Promise<BasicInfo | null> {
return new Promise((resolve) => {
let done = false;
const finish = (v: BasicInfo | null): void => {
@@ -40,22 +42,33 @@ export function askBasicInfo(units: string[]): Promise<BasicInfo | null> {
done = true;
resolve(v);
};
const name = createInputField({ label: tb("Name"), placeholder: tb("NamePh"), compact: true });
const name = createInputField({
label: tb("Name"),
placeholder: tb("NamePh"),
value: start?.이름 ?? "",
compact: true,
});
const number = createInputField({
label: tb("Number"),
placeholder: tb("NumberPh"),
value: start?.원문번호 ?? "",
compact: true,
});
if (start?.결과단위 && !units.includes(start.결과단위)) units = [start.결과단위, ...units];
const unit = createSelectField({
label: tb("Unit"),
options: units.map((u) => ({ value: u, text: u })),
value: units[0] ?? "원",
value: start?.결과단위 || (units[0] ?? "원"),
compact: true,
});
const source = createInputField({
label: tb("Source"),
value: start?.출처 || "자체",
compact: true,
});
const source = createInputField({ label: tb("Source"), value: "자체", compact: true });
const why = el("p", { className: "ui-text ui-text--muted", attrs: { role: "alert" } });
const modal = openModal({
title: tb("Title"),
title: tb(start ? "CopyTitle" : "Title"),
closeLabel: tb("Close"),
beforeClose: () => {
finish(null);
@@ -1,373 +0,0 @@
/* =============================================================================
* M01_MasterData_UI_LogicLab_Copy.ts
* 복사해서 만들기(PLAN 3-4 · 계약 7장) — 정본·자체 로직을 별칭 꼴 식으로 펴 보이고
* 줄을 고치거나 더한 뒤 자체 로직(GX)으로 저장.
*
* [본떠 만들기] → GET /logic/formula(별칭 폼) → 별칭 표 바꾸기·로직 부르기 갈래 고르기·
* 식 줄 고치기·더하기 → [시험 계산](POST /logic/formula/preview 가 원문으로 되돌린 줄을 수식 문서로 지어 줌 →
* 문서 셈 `/logic/doc/preview` · 855 2-B4 — 저장하면 지을 문서와 같은 변환)
* → [저장](POST /logic/formula/save) → afterSave 로 새 키를 알림(정본은 손대지 않음).
* ========================================================================== */
import {
createButton,
createInputField,
createSelectField,
el,
hideLoadingOverlay,
showLoadingOverlay,
showToast,
} from "@ui/ui_template_elements";
import {
copyLogic,
fetchLogicFormula,
previewLogicFormula,
saveLogicFormula,
type FormulaAlias,
type FormulaLine,
type LogicRow,
} from "./M01_MasterData_UI_Logic_Api";
import { buildCalc } from "./M01_MasterData_UI_Logic_Calc";
import { fetchTables, type TableHead } from "./M01_MasterData_Api_Fetch";
import { tx } from "./M01_MasterData_UI_Logic_Text";
import { tl } from "./M01_MasterData_UI_LogicLab_Text";
import type { FormulaDoc } from "../common_util/common_util_formula_doc";
import "./M01_MasterData_UI_LogicLab_Style.css";
import { createBadge } from "@ui/ui_template_badge";
import { createText } from "@ui/ui_template_text";
import { openModal } from "@ui/ui_template_modal";
const OWNERS = ["현장", "공용"] as const;
const TABLE_GROUPS = ["소요량", "계수"] as const;
const GROUP_LABEL: Record<FormulaLine["갈래"], string> = {
중간: "중간",
호표: "호표",
덧줄: "덧줄",
결과: "결과",
};
export interface CopyOptions {
/** 본뜰 원본 키(정본·자체 둘 다) */
key: string;
/** 저장 뒤 새 GX 키를 알림 — 밖(LogicLab)이 목록 새로고침·그 키 열기를 함 */
afterSave: (newKey: string) => void | Promise<void>;
}
/** 자리표(`호표[0].수량` 등)로 로직 안 그 칸을 읽고 씀 — `master_copy.slots()` 와 같은 자리 */
function field(row: LogicRow, place: string): { get: () => string; set: (v: string) => void } {
if (place === "결과.식") {
return {
get: () => row.결과?.식 ?? "",
set: (v) => {
if (row.결과) row.결과.식 = v;
},
};
}
const m = /^(호표|중간|덧줄)\[(\d+)\]\.(.+)$/.exec(place);
if (!m) return { get: () => "", set: () => {} };
const [, group, idxStr, col] = m;
const idx = Number(idxStr);
const arr = row[group] as Record<string, unknown>[] | undefined;
return {
get: () => (arr?.[idx] ? String(arr[idx][col] ?? "") : ""),
set: (v) => {
if (arr?.[idx]) arr[idx][col] = v;
},
};
}
/** 별칭 원문의 키만 갈아 끼움 — 「찾기(QF000421, …)」 → 「찾기(QF999999, …)」(인자는 그대로) */
function swapKey(raw: string, newKey: string): string {
return raw.replace(/^(찾기|로직)\(\s*[A-Za-z0-9]+/, `$1(${newKey}`);
}
/** 표 바꾸기 모달 — 소요량·계수 두 그룹을 함께 찾음 */
function openTablePick(onPick: (table: TableHead) => void): void {
const search = createInputField({ type: "search", placeholder: tl("Copy_PickSearch") });
const list = el("div", { className: "m01-logic__pick-list" });
// 모달 부품 — 제목줄 [닫기] · 바깥 누르기 · Esc · 위 고정 · 찾기 칸에 커서
const { close } = openModal({
title: tl("Copy_PickTitle"),
closeLabel: tl("Modal_Close"),
dialogClass: "m01-logic__pick",
backdropClass: "m01-logic__backdrop",
mount: (body) => body.append(search.root, list),
});
let timer: number | undefined;
let seq = 0; // 늦게 온 옛 응답은 버림(829-1)
const run = async (): Promise<void> => {
const mine = ++seq;
const q = search.input.value.trim();
const pages = await Promise.all(
TABLE_GROUPS.map((group) => fetchTables(group, "", "", q, 1, 20)),
);
if (mine !== seq) return;
const hits = pages.flatMap((p) => p.tables);
list.replaceChildren(
...(hits.length
? hits.map((t) => {
const b = el("button", {
className: "m01-logic__pick-row ui-list-row ui-sidebar-row",
attrs: { type: "button", "data-size": "32" },
children: [
el("span", { text: `${t.이름 || t.키} · ${t.원문번호 || ""}` }),
el("span", { className: "ui-text ui-text--muted", text: t.키 }),
],
});
b.addEventListener("click", () => {
onPick(t);
close();
});
return b;
})
: [el("p", { className: "ui-text ui-text--muted", text: tl("Copy_PickNone") })]),
);
};
search.input.addEventListener("input", () => {
window.clearTimeout(timer);
timer = window.setTimeout(() => void run(), 250);
});
void run();
}
function aliasRow(a: FormulaAlias, onSwap: (raw: string) => void, sub: HTMLElement): HTMLElement {
const about =
a.종류 === "찾기"
? [a.밑이름 || a.참조, Object.keys(a.값칸).join("·")].filter(Boolean).join(" · ")
: [a.밑이름 || a.참조, a.결과단위].filter(Boolean).join(" · ");
return el("div", {
className: "m01lab__box",
children: [
el("div", {
className: "m01-logic__section-head",
children: [
el("strong", { text: a.이름 }),
el("span", { className: "ui-text ui-text--muted", text: about }),
],
}),
el("pre", { className: "m01lab__expr", text: a.원문 }),
sub,
...(a.종류 === "찾기"
? [
createButton({
label: tl("Copy_Alias_Swap"),
variant: "ghost",
onClick: () => openTablePick((t) => onSwap(swapKey(a.원문, t.키))),
}),
]
: []),
],
});
}
function logicAliasControls(
a: FormulaAlias,
onForked: (raw: string) => void,
): { root: HTMLElement } {
let forked = false;
const original = a.원문;
const status = el("span", { className: "ui-text ui-text--muted" });
const refBtn = createButton({
label: tl("Copy_Alias_Ref"),
variant: "ghost",
onClick: () => {
forked = false;
a.원문 = original;
refresh();
},
});
const forkBtn = createButton({
label: tl("Copy_Alias_Fork"),
variant: "ghost",
onClick: () => void doFork(),
});
const refresh = (): void => {
refBtn.disabled = !forked;
forkBtn.disabled = forked;
status.textContent = forked ? tl("Copy_Alias_Forked") : "";
};
const doFork = async (): Promise<void> => {
try {
const got = await copyLogic(a.참조);
forked = true;
a.원문 = swapKey(original, got.key);
onForked(a.원문);
refresh();
} catch (error) {
showToast(error instanceof Error ? error.message : tx("Load_Failed"), "error");
}
};
refresh();
return { root: el("div", { children: [refBtn, forkBtn, status] }) };
}
function lineBox(row: LogicRow, line: FormulaLine, onChange: () => void): HTMLElement {
const f = field(row, line.자리);
const box = el("textarea", { className: "ui-input ui-input--sm m01-logic__input m01lab__qty" });
box.value = f.get();
box.rows = Math.max(1, Math.ceil(box.value.length / 60));
box.addEventListener("input", () => {
f.set(box.value);
onChange();
});
const tag = [GROUP_LABEL[line.갈래], line.비목].filter(Boolean).join(" · ");
return el("div", {
className: "m01lab__box",
children: [
el("div", {
className: "m01-logic__section-head",
children: [
el("strong", { text: line.이름 || line.자리 }),
createBadge(tag, "accent"),
...(line.단위
? [el("span", { className: "ui-text ui-text--muted", text: line.단위 })]
: []),
],
}),
box,
],
});
}
function addExtra(row: LogicRow, onChange: () => void, redraw: () => void): void {
row.덧줄 = row.덧줄 ?? [];
row.덧줄.push({ 이름: tl("Copy_ExtraName"), 식: "0", 비목: "재료비" });
onChange();
redraw();
}
/** 복사 화면을 전체 덮는 시트로 엶 */
export async function openCopyScreen(opt: CopyOptions): Promise<void> {
showLoadingOverlay();
let got;
try {
got = await fetchLogicFormula(opt.key);
} catch (error) {
hideLoadingOverlay();
showToast(error instanceof Error ? error.message : tx("Load_Failed"), "error");
return;
}
hideLoadingOverlay();
const row: LogicRow = got.로직;
const marks: FormulaAlias[] = got.별칭;
const nameField = createInputField({ label: tl("Copy_Name"), value: `${row.이름} 복사본` });
const ownerField = createSelectField({
label: tl("Copy_Owner"),
options: OWNERS.map((o) => ({
value: o,
text: o === "현장" ? tl("Copy_Site") : tl("Copy_Shared"),
})),
value: "현장",
});
const aliasHost = el("div", { className: "m01-logic__scroll" });
const linesHost = el("div", { className: "m01-logic__scroll" });
const calcHost = el("div", { className: "m01lab__calc" });
const given: Record<string, unknown> = {}; // 시험 계산에서 고른 옵션 — 줄을 고쳐도 남음
let timer: number | undefined;
const refreshCalc = (): void => {
window.clearTimeout(timer);
timer = window.setTimeout(() => void runPreview(), 300);
};
const runPreview = async (): Promise<void> => {
try {
// 답의 `문서` = 저장하면 지을 수식 문서(서버 변환 · 못 지음 = null)
const preview = (await previewLogicFormula(row, marks)) as { 문서?: FormulaDoc | null };
buildCalc(calcHost, preview.문서 ?? null, given);
} catch (error) {
calcHost.replaceChildren(createText(error instanceof Error ? error.message : "", "error"));
}
};
const drawLines = (): void => {
linesHost.replaceChildren(...got.줄.map((line) => lineBox(row, line, refreshCalc)));
};
const drawAliases = (): void => {
aliasHost.replaceChildren(
...marks.map((a) => {
const sub =
a.종류 === "로직" ? logicAliasControls(a, refreshCalc).root : el("span", { text: "" });
return aliasRow(
a,
(raw) => {
a.원문 = raw;
refreshCalc();
},
sub,
);
}),
);
};
drawLines();
drawAliases();
refreshCalc();
let close = (): void => {};
const onSave = async (): Promise<void> => {
showLoadingOverlay();
try {
const saved = await saveLogicFormula({
로직: row,
별칭: marks,
owner: ownerField.select.value,
이름: nameField.input.value.trim() || row.이름,
본뜬키: opt.key,
});
showToast(tl("Copy_Saved"), "success");
close();
await opt.afterSave(saved.key);
} catch (error) {
showToast(error instanceof Error ? error.message : tx("Save_Failed"), "error");
} finally {
hideLoadingOverlay();
}
};
// 모달 부품 — 제목줄 [취소] · 바깥 누르기 · Esc · 위 고정 · 폭만 복사 시트 곁값
({ close } = openModal({
title: `${tl("Copy_Title")} — ${row.이름}(${opt.key})`,
closeLabel: tl("Copy_Cancel"),
dialogClass: "m01-logic__pick m01copy__sheet",
backdropClass: "m01-logic__backdrop",
mount: (body) =>
body.append(
el("div", {
className: "m01copy__head",
children: [nameField.root, ownerField.root],
}),
el("section", {
className: "m01-logic__section",
children: [el("h3", { text: tl("Copy_Aliases") }), aliasHost],
}),
el("section", {
className: "m01-logic__section",
children: [
el("div", {
className: "m01-logic__section-head",
children: [
el("h3", { text: tl("Copy_Lines") }),
createButton({
label: tl("Copy_AddExtra"),
variant: "ghost",
onClick: () => addExtra(row, refreshCalc, drawLines),
}),
],
}),
linesHost,
],
}),
el("section", { className: "m01-logic__section", children: [calcHost] }),
el("div", {
className: "m01-logic__pick-bar",
children: [
el("span", {}),
el("span", {}),
createButton({ label: tl("Copy_Save"), onClick: () => void onSave() }),
],
}),
),
}));
}
@@ -50,18 +50,6 @@
display: none;
}
/* 복사해서 만들기(3-4) — 별칭 꼴 식 시트 */
.ui-modal.m01copy__sheet {
width: min(1040px, 94vw);
--modal-max: 90vh;
}
.m01copy__head {
display: grid;
grid-template-columns: 2fr 1fr;
gap: var(--spacing-8);
}
.m01lab__own > :first-child {
display: none;
}
@@ -29,25 +29,7 @@ const TEXT = {
Pill_Back: ["← 단가산출 기초로 돌아가기", "← Back to unit-price logic"],
Copy_Open: ["로직 복사/생성", "Copy / create logic"],
Copy_NeedOpen: ["먼저 로직을 고르세요", "Pick a logic first"],
Copy_Title: ["복사해서 만들기", "Copy to edit"],
Copy_Name: ["새 이름", "New name"],
Copy_Owner: ["소유", "Owner"],
Copy_Site: ["현장", "Site"],
Copy_Shared: ["공용", "Shared"],
Copy_Aliases: ["부르는 표·로직", "Tables & logics used"],
Copy_Alias_Swap: ["표 바꾸기", "Change table"],
Copy_Alias_Ref: ["그대로 부르기", "Keep reference"],
Copy_Alias_Fork: ["같이 복사하기", "Copy along"],
Copy_Alias_Forked: ["복사됨", "Copied"],
Copy_Lines: ["식 줄 — 고치거나 더함", "Formula lines — edit or add"],
Copy_AddExtra: ["덧줄 추가", "Add extra line"],
Copy_ExtraName: ["새 덧줄", "New extra line"],
Copy_Save: ["저장(자체 로직)", "Save as mine"],
Copy_Cancel: ["취소", "Cancel"],
Copy_Saved: ["자체 로직으로 저장함", "Saved as your own logic"],
Copy_PickTitle: ["바꿀 표 찾기", "Find a table"],
Copy_PickSearch: ["표 이름·키로 찾기", "Search by table name or key"],
Copy_PickNone: ["찾는 표가 없음", "No matching tables"],
Copy_Done: ["복사해서 새 자체 로직을 만듦", "Copied to a new own logic"],
} as const satisfies Record<string, readonly [string, string]>;
export type LabTextKey = keyof typeof TEXT;
+4 -54
View File
@@ -234,60 +234,10 @@ export const removeLogic = (
개정확인 = false,
): Promise<unknown> => request("/logic/remove", { key, file, version, 개정확인 });
/** 본떠 만들기 — 정본·자체 둘 다 본뜸 · 새 키(`GX…`)는 서버가 줌(계약 5장) */
/** 본떠 만들기 = [복사/생성] — 원본 수식 문서를 새 자체 기초로 복제 · 새 키(`GX…`)는 서버가 줌(855 L3 ⓐ) ·
* 이름 · 원문번호 · 결과단위 · 출처 = 기본정보 창 값(빈 글 = 원본 그대로) */
export const copyLogic = (
key: string,
info: { 이름: string; 원문번호: string; 결과단위: string; 출처: string },
): Promise<{ file: string; version: string; key: string; logic: LogicRow }> =>
request("/logic/copy", { key });
/** 복사해서 만들기(계약 7장) — 찾기·로직 부르기 한 덩이를 이름 하나(별칭)로 보임 */
export interface FormulaAlias {
이름: string;
종류: "찾기" | "로직";
참조: string;
/** 되돌릴 원문 부르기 글 — 저장 때 이 글로 갈아 끼움 */
원문: string;
밑이름: string;
값칸: Record<string, string>;
결과단위: string;
자리: string[];
}
export interface FormulaLine {
자리: string;
갈래: "중간" | "호표" | "덧줄" | "결과";
차례: number;
이름: string;
단위: string;
비목: string;
식: string;
출처: string;
종류?: string;
요소?: unknown;
}
export interface LogicFormula {
file: string;
version: string;
key: string;
소유: string;
로직: LogicRow;
별칭: FormulaAlias[];
줄: FormulaLine[];
}
export const fetchLogicFormula = (key: string): Promise<LogicFormula> =>
request(`/logic/formula?${query({ key })}`);
export const saveLogicFormula = (body: {
로직: LogicRow;
별칭: FormulaAlias[];
owner: string;
이름?: string;
본뜬키?: string;
}): Promise<{ file: string; version: string; key: string; logic: LogicRow }> =>
request("/logic/formula/save", body);
/** 저장 전 시험 계산용 — 별칭을 원문으로 되돌린 로직 줄만(저장 안 함) */
export const previewLogicFormula = (
로직: LogicRow,
별칭: FormulaAlias[],
): Promise<{ logic: LogicRow }> => request("/logic/formula/preview", { 로직, 별칭 });
request("/logic/copy", { key, ...info });
@@ -1,105 +0,0 @@
/* =============================================================================
* M01_MasterData_UI_Logic_Calc.ts
* 시험 계산(로직 복사 화면 · 855 2-B4) — 저장하면 지을 수식 문서(`/logic/formula/preview` 의 `문서`)를
* 문서 셈(`POST /m01/logic/doc/preview` · 줄 쌓기 화면과 같은 계산기)으로 셈 · 파일에 안 씀
* 옵션 가로(`formula_doc_options`) · 합계 상자(`formula_doc_foot`) = 줄 쌓기 화면 부품 그대로 — 금액 = 그 로직 수식 화면 금액
* 옵션을 바꾸면 바로 다시 셈(늦게 온 옛 답은 버림)
* ========================================================================== */
import { API_BASE_URL } from "@config/config_frontend";
import { el } from "@ui/ui_template_elements";
import { createText } from "@ui/ui_template_text";
import type { FormulaDoc } from "../common_util/common_util_formula_doc";
import type { DocAnswer } from "../common_util/common_util_formula_doc_calc";
import { formatNumber } from "../common_util/common_util_money";
import { docFoot } from "../A00_Common/formula_doc_foot";
import { buildOptions } from "../A00_Common/formula_doc_options";
import { hiddenByWork } from "../A00_Common/formula_doc_render";
import "../A00_Common/line_stack.css";
import { safeReason, tx } from "./M01_MasterData_UI_Logic_Text";
/** 그릇마다 셈 차례 — 줄을 고쳐 다시 그려도 늦게 온 옛 답을 버림 */
const turns = new WeakMap<HTMLElement, number>();
async function previewDoc(문서: FormulaDoc, 입력: Record<string, unknown>): Promise<DocAnswer> {
const r = await fetch(`${API_BASE_URL}/m01/logic/doc/preview`, {
method: "POST",
credentials: "include",
headers: { "Content-Type": "application/json" },
body: JSON.stringify({ 문서: { ...문서, 키: "_새" }, 입력 }), // 저장 전 = 빈 키(줄 쌓기와 같음)
});
const data = (await r.json().catch(() => ({}))) as { 셈?: DocAnswer; detail?: unknown };
if (!r.ok || !data.셈)
throw new Error(typeof data.detail === "string" ? data.detail : r.statusText);
return data.셈;
}
function answerView(doc: FormulaDoc, a: DocAnswer): HTMLElement[] {
const stop =
!a.셈됨 && a.까닭
? [
el("div", {
className: "ui-banner ui-banner--danger m01-logic__reasons",
children: [
el("strong", { text: tx("Calc_Stopped") }),
el("div", { text: safeReason(a.까닭) }),
],
}),
]
: [];
if (!doc.결과) return [...stop, docFoot(a)]; // 줄 쌓기 아래 합계 상자와 같은 부품
const value =
typeof a.결과 === "number" ? `${formatNumber(a.결과)} ${doc.결과단위 ?? ""}`.trim() : "—";
return [
...stop,
el("dl", {
className: "m01-logic__sums",
children: [el("dt", { text: tx("Calc_Result") }), el("dd", { text: value })],
}),
];
}
/** `doc` = 저장하면 지을 수식 문서(못 지음 = null) · `given` = 고른 옵션(다시 그려도 남음) */
export function buildCalc(
host: HTMLElement,
doc: FormulaDoc | null,
given: Record<string, unknown>,
): void {
const title = el("h3", { text: tx("Calc_Title") });
const note = el("p", { className: "ui-text ui-text--muted", text: tx("Calc_Draft") });
if (!doc) {
host.replaceChildren(title, createText(tx("Calc_NoDoc"), "error"));
return;
}
const run = async (): Promise<void> => {
const mine = (turns.get(host) ?? 0) + 1;
turns.set(host, mine);
try {
const answer = await previewDoc(doc, given);
if (turns.get(host) !== mine) return;
const options = buildOptions(
doc,
given,
false,
(k, v, x) => {
// 고르기 글 → 목록 값 그대로(수 45 를 글 「45」 로 보내면 표 줄을 못 찾음 · 줄 쌓기 `usable` 과 같음)
const list = v.연결?.갈래 === "선택" ? (v.연결.목록 ?? []) : [];
given[k] = list.find((o) => String(o) === String(x)) ?? x;
void run();
},
undefined,
hiddenByWork(doc, answer), // 줄 쌓기와 같이 — 시간당 식 줄이 안 읽게 된 옵션은 숨김
);
host.replaceChildren(
title,
note,
...(options.length ? [el("div", { className: "fdoc__options", children: options })] : []),
...answerView(doc, answer),
);
} catch (error) {
if (turns.get(host) !== mine) return;
host.replaceChildren(title, createText(error instanceof Error ? error.message : "", "error"));
}
};
void run();
}
@@ -36,14 +36,6 @@ const TEXT = {
Head_Note: ["비고", "Note"],
Head_Blocked: ["막힌 까닭", "Why blocked"],
Formula: ["식", "Formula"],
Calc_Title: ["시험 계산", "Test calculation"],
Calc_Draft: ["고친 줄로 계산(저장 전)", "Using unsaved edits"],
Calc_NoDoc: [
"수식 문서로 못 바꿈 — 고친 식을 확인하세요",
"Cannot build a formula document — check the edits",
],
Calc_Stopped: ["멈춤", "Stopped"],
Calc_Result: ["결과", "Result"],
Pick_Title: ["요소 찾기", "Find element"],
Pick_Search: ["이름·키·원문번호", "Name · key · source no."],
Pick_Close: ["닫기", "Close"],
@@ -39,14 +39,10 @@ def test_공용_모달_위_고정():
def test_따로_둔_모달도_위_고정():
# M01 고르기 · 복사 · 조달 창 = 모달 부품(553-5) — 위 고정은 공용 .ui-modal 이 냄
assert "--modal-max: 90vh;" in _block(
_text("M01_MasterData/M01_MasterData_UI_LogicLab_Style.css"), ".ui-modal.m01copy__sheet"
)
# M01 고르기 · 조달 창 = 모달 부품(553-5) — 위 고정은 공용 .ui-modal 이 냄(복사 시트 창은 855 L3 ⓐ 에서 걷음)
for rel in (
"M01_MasterData/M01_MasterData_UI_Pick.ts",
"M01_MasterData/M01_MasterData_UI_Logic_PickTable.ts",
"M01_MasterData/M01_MasterData_UI_LogicLab_Copy.ts",
):
src = _text(rel)
assert "openModal(" in src and "document.body.append(" not in src, rel