538 lines
20 KiB
JavaScript
538 lines
20 KiB
JavaScript
/* 856-0 헬퍼 — 단가산출 화면 · 일위대가 줄 누름 · 머리 띠 · M01 로직 상세(가짜 DOM · 진짜 코드)
|
|
* 진짜 = M02 단가산출 화면(`Sangeun_Detail` 과 그 이웃) · 일위대가 표(`Labor_Table`) · 줄 모달 · M01 상세 그릇
|
|
* 가짜 = 부품 상자(표지 붙은 빈 상자) · 줄 쌓기 화면(그린 키만 적음) · 서버 부름(길 · 몸을 적고 견본 답) */
|
|
const fs = require("fs");
|
|
const path = require("path");
|
|
const ROOT = path.resolve(__dirname, "..", "..");
|
|
const ts = require(path.join(ROOT, "config", "node_modules", "typescript"));
|
|
|
|
const camel = (s) => s.replace(/-([a-z])/g, (_, c) => c.toUpperCase());
|
|
class Fake {
|
|
constructor(tag) {
|
|
this.tagName = String(tag).toUpperCase();
|
|
this.children = [];
|
|
this.parentElement = null;
|
|
this.dataset = {};
|
|
this.attrs = {};
|
|
this.style = { setProperty() {} };
|
|
this.hidden = false;
|
|
this.className = "";
|
|
this.textContent = "";
|
|
this.value = "";
|
|
this.disabled = false;
|
|
this.classList = { add() {}, remove() {}, toggle() {}, contains: () => false };
|
|
}
|
|
append(...xs) {
|
|
for (const x of xs)
|
|
if (x instanceof Fake) {
|
|
x.parentElement = this;
|
|
this.children.push(x);
|
|
}
|
|
}
|
|
prepend(...xs) {
|
|
this.append(...xs);
|
|
}
|
|
replaceChildren(...xs) {
|
|
this.children = [];
|
|
this.append(...xs);
|
|
}
|
|
remove() {}
|
|
get firstChild() {
|
|
return this.children[0] ?? null;
|
|
}
|
|
addEventListener(t, f) {
|
|
((this.on ??= {})[t] ??= []).push(f);
|
|
}
|
|
removeEventListener() {}
|
|
/** 사건 일으킴(⑥ 머리 칸 change) */
|
|
fire(t) {
|
|
for (const f of this.on?.[t] ?? []) f({ target: this });
|
|
}
|
|
setAttribute(k, v) {
|
|
this.attrs[k] = v;
|
|
if (k.startsWith("data-")) this.dataset[camel(k.slice(5))] = v;
|
|
}
|
|
removeAttribute() {}
|
|
contains() {
|
|
return false;
|
|
}
|
|
querySelector() {
|
|
return null;
|
|
}
|
|
focus() {}
|
|
}
|
|
globalThis.window = globalThis;
|
|
globalThis.addEventListener = () => {};
|
|
globalThis.removeEventListener = () => {};
|
|
globalThis.getComputedStyle = () => ({ overflowY: "visible" });
|
|
globalThis.requestAnimationFrame = (f) => setTimeout(f, 0);
|
|
globalThis.HTMLElement = Fake;
|
|
globalThis.HTMLInputElement = class extends Fake {};
|
|
globalThis.HTMLTextAreaElement = class extends Fake {};
|
|
globalThis.document = {
|
|
createElement: (t) => new Fake(t),
|
|
body: new Fake("body"),
|
|
activeElement: null,
|
|
};
|
|
globalThis.sessionStorage = { getItem: () => null, setItem() {}, removeItem() {} };
|
|
|
|
/** 표지 붙은 빈 상자 */
|
|
const box = (tag, mark = {}, text = "") => {
|
|
const n = new Fake(tag);
|
|
for (const [k, v] of Object.entries(mark)) n.setAttribute(k, v);
|
|
n.textContent = text;
|
|
return n;
|
|
};
|
|
const el = (tag, o = {}) => {
|
|
const n = box(tag, o.attrs ?? {}, o.text ?? "");
|
|
n.className = o.className ?? "";
|
|
n.append(...(o.children ?? []));
|
|
return n;
|
|
};
|
|
const button = (o = {}) => box("button", { "data-button": o.label ?? "" });
|
|
const input = (o = {}) => {
|
|
const i = box("input");
|
|
i.value = o.value ?? "";
|
|
const root = box("label", { "data-input": o.label ?? "" }, "");
|
|
root.append(i); // ⑥ 칸이 머리 나무에 달림
|
|
return { root, input: i, setError() {} };
|
|
};
|
|
const modals = []; // 열린 모달 — 제목 · 몸
|
|
const toasts = []; // 알림 글(856-3 M01 로직 줄 안내)
|
|
const ui = {
|
|
ui_template_elements: {
|
|
el,
|
|
createButton: button,
|
|
createInputField: input,
|
|
showToast: (text, kind) => toasts.push([kind, text]),
|
|
showConfirmDialog: async () => true,
|
|
},
|
|
ui_template_button: { createButton: button },
|
|
ui_template_input: { createInputField: input },
|
|
ui_template_banner: { createBanner: (o) => box("div", { "data-banner": o.tone }, o.text) },
|
|
ui_template_badge: { createBadge: (text, tone) => box("span", { "data-badge": tone }, text) },
|
|
ui_template_text: { createText: (text) => box("span", {}, text) },
|
|
ui_template_checkbox: { createCheckbox: () => ({ root: box("label") }) },
|
|
ui_template_card: { createCard: () => box("div") },
|
|
ui_template_locale: { t: (k) => k, currentLanguageIndex: 0 },
|
|
ui_template_modal: {
|
|
openModal: (o) => {
|
|
const body = box("div", { "data-modal": o.title });
|
|
const head = box("div");
|
|
const close = () => {};
|
|
o.mount?.(body, close, head);
|
|
modals.push({ title: o.title, body, head, actions: o.actions ?? [], shut: o.beforeClose });
|
|
return { close };
|
|
},
|
|
askConfirm: async () => true,
|
|
askText: async () => null,
|
|
showConfirmDialog: async () => true,
|
|
},
|
|
ui_template_side_panels: {
|
|
createSidePanels: () => ({ current: () => null, root: box("div"), wrap: (m) => m }),
|
|
},
|
|
ui_template_hopyo_grid: {
|
|
hopyoGrid: (blocks) => ({
|
|
at: new Map(blocks[0].lines.map((_, i) => [i, [0, i]])),
|
|
columns: [],
|
|
rows: [],
|
|
}),
|
|
createHopyoGrid: (_blocks, o) => ((grid.onRowClick = o.onRowClick), { root: box("table") }),
|
|
hopyoCellClass: () => "",
|
|
},
|
|
};
|
|
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?.() });
|
|
setTimeout(() => opt.onAnswer?.(stackAns()), 0);
|
|
},
|
|
dirty: () => false,
|
|
save: async () => true,
|
|
discard: async () => {},
|
|
canLeave: async () => true,
|
|
destroy() {},
|
|
};
|
|
},
|
|
};
|
|
|
|
// 서버 부름 — 길 · 몸을 적고 견본 답
|
|
const calls = [];
|
|
const files = { reads: 0, saves: 0 }; // 층 파일 읽기 · 저장 수
|
|
const api = {
|
|
call: async (p, init) => {
|
|
calls.push({ path: p, body: init?.body ? JSON.parse(init.body) : null });
|
|
if (p.includes("/labor/")) return { 줄: [], 자재: [], 알약: [] };
|
|
if (p.includes("/logic-lib/"))
|
|
return { items: [{ ref: "X1", 이름: "견본", 단위: "EA", 값: 1 }] }; // 찾아 넣기(⑤)
|
|
return {};
|
|
},
|
|
readTemplate: async (_l, _k, key) => (
|
|
files.reads++,
|
|
{ 문서: { 키: key, 이름: "견본", 단위: "㎡" }, 판: "1" }
|
|
),
|
|
saveTemplate: async () => (files.saves++, {}),
|
|
getActiveLayer: () => "system",
|
|
getActiveOwner: () => null,
|
|
};
|
|
const logicApi = {
|
|
fetchLogic: async (k) => ({
|
|
logic: { 키: k, 이름: "기초", 결과단위: "원/㎡", 입력: [] },
|
|
prices: {},
|
|
file: "",
|
|
reasons: [],
|
|
}),
|
|
fetchAuto: async () => ({}),
|
|
setLogicApiPaths() {},
|
|
ApiError: class extends Error {},
|
|
};
|
|
|
|
const stubs = {
|
|
...ui,
|
|
line_stack_screen: screen,
|
|
M02_MasterTemplete_Api_Fetch: api,
|
|
M01_MasterData_UI_Logic_Api: logicApi,
|
|
M02_MasterTemplete_Sangeun_Side: {
|
|
createSangeunSide: () => ({ wrap: (m) => m, set() {} }),
|
|
tabOf: () => ({}),
|
|
},
|
|
M01_MasterData_UI_LogicLab_Ho: { buildHo: () => [box("div", { "data-ho": "" })] },
|
|
M02_MasterTemplete_Sangeun_Unit: {
|
|
buildUnitSwap: () => (swaps.n++, box("div", { "data-swap": "" })), // ⑥ 환산 다시 그린 수
|
|
baseUnitOf: () => "",
|
|
},
|
|
M02_MasterTemplete_Labor_LogicMats: { logicMatRows: () => [] },
|
|
M02_Labor_Values_Model: {
|
|
valueLine: () => ({ text: "", empty: 0 }),
|
|
keepKnown: (_a, b) => ({ kept: b }),
|
|
},
|
|
M02_MasterTemplete_Labor_Grid: {
|
|
laborBlock: (cur) => ({ lines: cur.담은로직.map(() => ({ note: "", amounts: { sum: 1 } })) }),
|
|
},
|
|
ui_template_unit_pick: { createUnitPick: () => box("div"), NO_UNIT: "-" },
|
|
M02_MasterTemplete_Labor_Unlinked: { unlinkedBar: () => null },
|
|
M02_MasterTemplete_Labor_Text: { tc: (k) => k },
|
|
M02_MasterTemplete_Labor_LibMeta: { libMeta: () => [] },
|
|
M02_MasterTemplete_Labor_National: { nationalRows: () => [] },
|
|
// ⑤ 찾아 넣기 창 — 표 = 그린 줄 수 · 탭 · 찾기 맞춤 · 위 층 서고
|
|
ui_template_data_table: {
|
|
createDataTable: () => ({ root: box("table"), setRows: (r) => (picked.rows = r.length) }),
|
|
},
|
|
ui_template_tabs: { createTabs: () => ({ root: box("div"), setBadge() {} }) },
|
|
ui_template_logic_find: { matchLogic: () => ({ ok: true }), aliasNote: () => "" },
|
|
M02_MasterTemplete_Sangeun_Pick: {
|
|
SANGEUN_KIND: "sangeun",
|
|
listLayerDocs: async () => [{ ref: { 층: "system", 주인: null, 키: "SK-9" }, 이름: "s" }],
|
|
},
|
|
};
|
|
const picked = { rows: 0 };
|
|
const swaps = { n: 0 };
|
|
const real = new Set([
|
|
"M02_MasterTemplete_Sangeun_Detail",
|
|
"M02_MasterTemplete_Sangeun_Tabs",
|
|
"formula_doc_copy",
|
|
"M02_MasterTemplete_Sangeun_BaseHead",
|
|
"M02_Sangeun_Cover_Model",
|
|
"M02_Sangeun_Undo",
|
|
"M02_Born_Tag",
|
|
"M01_MasterData_UI_LogicLab_Detail",
|
|
"M02_MasterTemplete_Labor_Table",
|
|
"M02_MasterTemplete_Labor_SkEdit",
|
|
"M02_MasterTemplete_Labor_RowModal",
|
|
"M02_MasterTemplete_Labor_RowSk",
|
|
"M02_MasterTemplete_Labor_Api",
|
|
"M02_MasterTemplete_Labor_Calc",
|
|
"M02_MasterTemplete_Find_Pick",
|
|
"line_stack_pick",
|
|
]);
|
|
|
|
const empty = () =>
|
|
new Proxy(function () {}, {
|
|
get: (_, k) => (k === "then" ? undefined : empty()),
|
|
apply: () => undefined,
|
|
});
|
|
const cache = new Map();
|
|
function load(at) {
|
|
if (cache.has(at)) return cache.get(at);
|
|
const js = ts.transpileModule(fs.readFileSync(at, "utf8"), {
|
|
compilerOptions: { module: ts.ModuleKind.CommonJS, target: ts.ScriptTarget.ES2020 },
|
|
}).outputText;
|
|
const mod = { exports: {} };
|
|
cache.set(at, mod.exports);
|
|
const need = (p) => {
|
|
if (p.endsWith(".css")) return {};
|
|
const name = path.basename(p);
|
|
if (stubs[name]) return stubs[name];
|
|
if (p.startsWith("@config/")) return { API_BASE_URL: "" };
|
|
if (!p.startsWith(".")) return empty();
|
|
const r = `${path.resolve(path.dirname(at), p)}.ts`;
|
|
return real.has(path.basename(r, ".ts")) && fs.existsSync(r) ? load(r) : empty();
|
|
};
|
|
new Function("exports", "module", "require", js)(mod.exports, mod, need);
|
|
return mod.exports;
|
|
}
|
|
const M = (rel) => load(path.join(ROOT, rel));
|
|
const tick = () => new Promise((r) => setTimeout(r, 0));
|
|
const settle = async () => {
|
|
for (let i = 0; i < 20; i++) await tick();
|
|
};
|
|
const walk = (n, fn) => {
|
|
fn(n);
|
|
for (const c of n.children) walk(c, fn);
|
|
};
|
|
const all = (root, pred) => {
|
|
const out = [];
|
|
walk(root, (n) => pred(n) && out.push(n));
|
|
return out;
|
|
};
|
|
/** 숨은 조상까지 보고 보이는가 */
|
|
const shown = (n) => {
|
|
for (let x = n; x; x = x.parentElement) if (x.hidden) return false;
|
|
return true;
|
|
};
|
|
const skCalls = () => calls.filter((c) => c.path.includes("/sangeun/calc"));
|
|
/** 브라우저 셈 답(`calcDoc` 꼴) */
|
|
function plainAns(o = {}) {
|
|
return {
|
|
셈됨: true,
|
|
표지: [],
|
|
빈값: {},
|
|
줄: [{ 이름: "보통인부", 수량: 1, 단가: 100, 금액: 100, 비목: { 노무비: 100 } }],
|
|
계: 100,
|
|
머리: "계",
|
|
...o,
|
|
};
|
|
}
|
|
|
|
/** 단가산출 화면 한 벌 열기 — 부름 수 · 숨은 몸 · 줄 쌓기 그림 · 띠 */
|
|
async function openSk(doc, opt = {}) {
|
|
calls.length = 0;
|
|
stacks.length = 0;
|
|
const { mountSangeunDetail } = M("M02_MasterTemplete/M02_MasterTemplete_Sangeun_Detail.ts");
|
|
const host = box("div");
|
|
const h = mountSangeunDetail(host, doc, {
|
|
layer: "system",
|
|
owner: null,
|
|
readOnly: false,
|
|
onChanged() {},
|
|
...opt,
|
|
});
|
|
await settle();
|
|
const s = stacks[stacks.length - 1];
|
|
const r = {
|
|
calc: skCalls().length,
|
|
body: all(host, (n) => "skCover" in n.dataset || "ho" in n.dataset).length, // 몸 DOM(덮개 그릇 · 호표)
|
|
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();
|
|
return r;
|
|
}
|
|
|
|
(async () => {
|
|
const out = {};
|
|
// ① 단가산출 화면(페이지) — 바탕 있음 · 없음
|
|
out.page_base = await openSk(
|
|
{ 키: "SK-000001", 이름: "견본", 단위: "㎡", 바탕: { 로직: "GC001109" } },
|
|
{ mode: "page" },
|
|
);
|
|
out.page_nobase = await openSk({ 키: "SK-000002", 이름: "견본", 단위: "㎡" }, { mode: "page" });
|
|
// 불러오기 미리 보기(저장 전 가져온 식)
|
|
out.memory = await openSk(
|
|
{ 이름: "가져온", 단위: "식", 가져온: { 파일: "x" } },
|
|
{ mode: "memory" },
|
|
);
|
|
|
|
// ③ 머리 띠(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;
|
|
};
|
|
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 로직 줄 · 셈 주입(원본 층 카드) · 프로젝트 사본(856-3 굳힌 SK 문서)
|
|
const { mountLaborTable } = M("M02_MasterTemplete/M02_MasterTemplete_Labor_Table.ts");
|
|
const rows = [
|
|
{
|
|
참조: { 층: "system", 주인: null, 키: "SK-000010" },
|
|
별칭: null,
|
|
메모: null,
|
|
수량: { 손: 1 },
|
|
},
|
|
{ 로직: "GC001109", 별칭: null, 메모: null, 입력값: {}, 수량: { 손: 1 } },
|
|
];
|
|
const copyDoc = { 키: "SK-000010", 이름: "사본", 단위: "㎡", 수식: { 따로: true, 굳힘: true } };
|
|
const asked = [];
|
|
const click = async (calc, copy) => {
|
|
const res = [];
|
|
for (let i = 0; i < rows.length; i++) {
|
|
const t = mountLaborTable(
|
|
box("div"),
|
|
{ 담은로직: JSON.parse(JSON.stringify(rows)), 자재: [], 단위: "㎡" },
|
|
{
|
|
mode: "precombo",
|
|
layer: "system",
|
|
column: "공통",
|
|
readOnly: !!calc && !copy, // 셈 주입 카드 = 보기만 · 사본은 표가 열려 있어도 줄 쌓기는 보기만인지 봄
|
|
owner: null,
|
|
onChanged() {},
|
|
...(calc ? { calc: async () => ({ 줄: [], 자재: [] }) } : {}),
|
|
...(copy
|
|
? { skCopy: async (ref) => (asked.push(ref.키), ref.키 === copy.키 ? copy : null) }
|
|
: {}),
|
|
},
|
|
);
|
|
await settle();
|
|
modals.length = 0;
|
|
stacks.length = 0;
|
|
calls.length = 0;
|
|
toasts.length = 0;
|
|
files.reads = files.saves = 0;
|
|
grid.onRowClick(i);
|
|
await settle();
|
|
const m = modals[0];
|
|
const s = stacks[0];
|
|
res.push({
|
|
modal: m ? m.title : null,
|
|
skModal: m ? all(m.body, (n) => "laborSk" in n.dataset).length : 0, // 그 SK 문서 모달(806-1)
|
|
stack: s ? { shown: shown(s.root), draws: s.draws.map((d) => d.key) } : null,
|
|
memory: s ? s.draws.map((d) => d.memory) : [],
|
|
admin: s ? s.opt.admin : null, // 고침 칸(편집) 열림
|
|
save: m ? all(m.head, (n) => n.dataset.button === "Save").length : 0, // [저장] 단추
|
|
files: { ...files },
|
|
toasts: toasts.map((x) => x[0]),
|
|
body: m ? all(m.body, (n) => "skCover" in n.dataset && shown(n)).length : 0,
|
|
banners: m ? all(m.body, (n) => "banner" in n.dataset).map((n) => n.dataset.banner) : [],
|
|
calc: skCalls().length,
|
|
});
|
|
for (const one of modals) await one.shut?.(); // 닫기(같은 SK 다시 열 수 있게)
|
|
t.destroy?.();
|
|
}
|
|
return res;
|
|
};
|
|
out.labor = await click(false);
|
|
out.labor_inject = await click(true);
|
|
out.labor_copy = await click(true, copyDoc);
|
|
out.labor_copy_asked = asked.slice();
|
|
out.labor_copy_none = await click(true, { ...copyDoc, 키: "SK-999999" });
|
|
|
|
// ④ M01 로직 상세 그릇 — 기본정보 접힘 + 줄 쌓기
|
|
const { buildLabDetail } = M("M01_MasterData/M01_MasterData_UI_LogicLab_Detail.ts");
|
|
const host = box("div");
|
|
const stack = box("div", { "data-stack": "" });
|
|
buildLabDetail(host, {
|
|
row: {
|
|
키: "GC001109",
|
|
원문번호: "1-1",
|
|
이름: "기초",
|
|
결과단위: "원/㎡",
|
|
입력: [],
|
|
중간: [],
|
|
호표: [],
|
|
덧줄: [],
|
|
},
|
|
file: "f.json",
|
|
reasons: ["막힘"],
|
|
ownHost: box("div"),
|
|
onChange() {},
|
|
stack,
|
|
});
|
|
out.m01 = host.children.map((n) => n.tagName + (n.dataset.stack !== undefined ? ":stack" : ""));
|
|
|
|
// ⑤ 줄 쌓기 [+ 줄] 찾아 넣기(856-F) — 빈 낱말로 연 창 · 종류마다 부른 주소 · 그린 줄 수(M01 · M02)
|
|
const { openStackPick } = M("A00_Common/line_stack_pick.ts");
|
|
const { openFindPicker } = M("M02_MasterTemplete/M02_MasterTemplete_Find_Pick.ts");
|
|
const fetch0 = globalThis.fetch;
|
|
globalThis.fetch = async () => ({
|
|
ok: true,
|
|
json: async () => ({ logics: [{ 키: "GC1", 이름: "기초", 결과단위: "원/㎡" }], 줄: [] }),
|
|
});
|
|
out.find = {};
|
|
for (const m02 of [null, { layer: "system", owner: null, me: "SK-1", take() {} }])
|
|
for (const kind of ["인력", "재료", "기계", "단가산출"]) {
|
|
calls.length = 0;
|
|
picked.rows = 0;
|
|
openStackPick(openFindPicker, kind, () => {}, m02 ?? undefined);
|
|
await settle();
|
|
out.find[`${m02 ? "m02" : "m01"}_${kind}`] = {
|
|
paths: calls.map((c) => c.path.replace("/logic-lib/", "").replace(/&.*/, "")),
|
|
rows: picked.rows,
|
|
};
|
|
}
|
|
globalThis.fetch = fetch0;
|
|
|
|
// ⑥ 머리 칸 고침(856-G) — 이름 change 뒤 머리 칸 그대로(Tab 으로 옮긴 단위 칸 = 같은 칸 · 초점 유지) ·
|
|
// 단위 change = 환산만 새로 · 문서 · 고침 알림
|
|
{
|
|
const { mountSangeunDetail } = M("M02_MasterTemplete/M02_MasterTemplete_Sangeun_Detail.ts");
|
|
const host = box("div");
|
|
let dirty = false;
|
|
const doc = { 키: "SK-000011", 이름: "견본", 단위: "㎡", 바탕: { 로직: "GC001109" } };
|
|
const h = mountSangeunDetail(host, doc, {
|
|
layer: "system",
|
|
owner: null,
|
|
readOnly: false,
|
|
mode: "page",
|
|
onChanged: (d) => (dirty = d),
|
|
});
|
|
await settle();
|
|
const fields = () => all(host, (n) => n.dataset.sk === "이름" || n.dataset.sk === "단위");
|
|
const before = fields();
|
|
const [name, unit] = before;
|
|
const same = () => fields().length === 2 && fields().every((n, i) => n === before[i]);
|
|
let n0 = swaps.n;
|
|
name.value = " 고친 이름 ";
|
|
name.fire("change");
|
|
const afterName = { same: same(), swaps: swaps.n - n0, dirty };
|
|
n0 = swaps.n;
|
|
unit.value = "m2";
|
|
unit.fire("change");
|
|
const afterUnit = { same: same(), swaps: swaps.n - n0, shown: all(host, (n) => "swap" in n.dataset).length }; // prettier-ignore
|
|
const got = h.getDoc();
|
|
out.head = {
|
|
order: before.map((n) => n.dataset.sk),
|
|
afterName,
|
|
afterUnit,
|
|
doc: [got.이름, got.단위],
|
|
};
|
|
h.destroy();
|
|
}
|
|
console.log(JSON.stringify(out));
|
|
})().catch((e) => {
|
|
console.error(e.stack || String(e));
|
|
process.exit(1);
|
|
});
|