eomsangdonandClaude Opus 5.5
8206bf6bb4
- main_laptop_1 의 8b2473af(같은 충돌을 먼저 푼 것)를 다시 합칠 때 충돌 · autopush 가 표시째 올림
- 두 풀이를 견줘 더 넓은 쪽(63c6fa36)을 씀 — 위 [저장]이 도면 카드도 먼저 저장 · 다른 항목 고름 물음 한 번(discard) · 나머지는 같음
- 대상: ItemCards · Structure · UI_Main · test_m02_drawing_card(DrawingCard 는 이미 같음)
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Ly2oHAaTDYRjcniAmHR81z
538 lines
23 KiB
TypeScript
538 lines
23 KiB
TypeScript
/* =============================================================================
|
|
* M02_MasterTemplete_Structure.ts
|
|
* 구조물집계표 아래 설계 컨테이너 — 고른 열의 도면 정보 · 면적산출 · 재료산출 카드(보기만 + [수정]).
|
|
* 카드 셋은 좌측 패널과 같은 공용 ui-sidebar 틀 — 고침은 [수정] 이 여는 M02 메인 칸 전체 편집 화면
|
|
* (`M02_MasterTemplete_UI_Main.ts`)이 맡음.
|
|
* 면적산출 · 재료산출 = 스프레드시트(`A00_Common/spreadsheet/`) · 열마다 따로 파일(`area|material/<열 id>.json`) ·
|
|
* 부품은 카드를 열 때만 `import()` 로 받음(다른 페이지 번들에 안 섞임).
|
|
*
|
|
* 구조물 도면은 집계표 열마다 하나(`resources/master_template/structure/<열 id>.json`) ·
|
|
* 서버가 열마다 미리 만들어 둠(번호 자동 · 새 열도 집계표 저장 때 서버가 같이 만듦 — `M02_MasterTemplete_Store.py`).
|
|
* 이 칸은 표 부품 host 밖 형제 자리에 붙음 — 집계표는 그대로 두고 여기만 열마다 다시 그림.
|
|
* 집계표 일위대가 · 도면 · 면적산출 · 재료산출 줄의 조회 후 선택(`pick`)도 여기 — 일위대가 = M01 일위대가
|
|
* 목록에서 고름 · 나머지 = 다른 열 것을 골라 내용만 복사해 가져옴(번호 · 열은 그대로 · 서버가 복사).
|
|
* 글자는 이 파일에 둠(도면 부품 `M02_MasterTemplete_Drawing.ts` 와 같은 방식).
|
|
* ========================================================================== */
|
|
|
|
import {
|
|
createButton,
|
|
createInputField,
|
|
el,
|
|
showConfirmDialog,
|
|
showToast,
|
|
} from "@ui/ui_template_elements";
|
|
import { openModal } from "@ui/ui_template_modal";
|
|
import type { LinkOptions } from "../A00_Common/spreadsheet/spreadsheet_links";
|
|
import { searchMaterials } from "../M01_MasterData/M01_MasterData_Api_Fetch";
|
|
import { fetchComboInputs, fetchUsableCombos } from "./M02_MasterTemplete_Labor_Api";
|
|
import {
|
|
copyArea,
|
|
copyMaterial,
|
|
copyStructure,
|
|
fetchStructureNumbers,
|
|
getActiveLayer,
|
|
readTemplate,
|
|
saveTemplate,
|
|
type StructureNumbers,
|
|
type TreeEdit,
|
|
} from "./M02_MasterTemplete_Api_Fetch";
|
|
import {
|
|
createItemCards,
|
|
PART_FIELD,
|
|
PART_WORD,
|
|
type EditKind,
|
|
type SheetCardControl,
|
|
type SheetEditOptions,
|
|
type SheetKind,
|
|
} from "./M02_MasterTemplete_ItemCards";
|
|
import { buildMaterialPanel, loadMaterialState, toPills } from "./M02_MasterTemplete_Materials";
|
|
import { layerSource } from "./M02_MasterTemplete_ItemSource";
|
|
import { createInputsCard, inputPills, type InputsCardHandle } from "./M02_MasterTemplete_Inputs";
|
|
import "./M02_MasterTemplete_Structure.css";
|
|
|
|
export type { EditKind, SheetKind } from "./M02_MasterTemplete_ItemCards";
|
|
|
|
/** 구조물 도면이 걸리는 집계표 이름 — 서버 `M02_MasterTemplete_Store.STRUCTURE_TABLE` 과 같은 글 */
|
|
export const STRUCTURE_TABLE = "구조물집계표";
|
|
|
|
const TEXT = {
|
|
close: "닫기",
|
|
find: "찾기",
|
|
clear: "비움",
|
|
none: "고를 것이 없음",
|
|
pickPrice: "일위대가 고르기",
|
|
combosFailed: "일위대가 목록을 못 받음 — {value}",
|
|
saveFirst: "새 열은 구조물 조합을 먼저 저장해야 번호가 생김",
|
|
overwrite: "{from} 의 {what} 내용을 {to} 에 덮어씀 — 번호 · 열은 그대로",
|
|
pickCopy: "{value} 복사해 가져오기",
|
|
copied: "복사해 가져옴",
|
|
copyFailed: "복사 실패 — {value}",
|
|
noPrice: "이 열에 일위대가가 없어 알약 없음 — 구조물 조합 일위대가 줄에서 고름",
|
|
noInputs: "일위대가 {value} 에 입력값이 없어 알약 없음",
|
|
inputsFailed: "일위대가 입력값을 못 받음 — {value}",
|
|
discardCards: "카드(도면 · 면적산출 · 재료산출)에 저장 안 한 고침이 있음 — 버리고 넘어갈까?",
|
|
};
|
|
|
|
/** 집계표 열 하나에 딸린 문서 셋 — 번호 칸 · 이름 · 복사 */
|
|
const COPY: Record<EditKind, (to: string, from: string) => Promise<void>> = {
|
|
structure: copyStructure,
|
|
area: copyArea,
|
|
material: copyMaterial,
|
|
};
|
|
/** 집계표 줄 열쇠 → 문서 */
|
|
const ROW_KIND: Record<string, EditKind> = {
|
|
"s:drawing": "structure",
|
|
"s:area": "area",
|
|
"s:material": "material",
|
|
};
|
|
|
|
const why = (error: unknown): string => (error instanceof Error ? error.message : "");
|
|
const fill = (text: string, value: string): string => text.replace("{value}", value);
|
|
|
|
/** `{열 id: {도번, 면적번, 재료번}}` — 집계표 번호 줄(없는 열은 키 없음 = 「없음」) */
|
|
export type ColumnNumbers = Record<string, StructureNumbers>;
|
|
|
|
/** 일위대가 목록 — 이 층이 쓸 수 있는 세 층 조합(27-2c) · 고를 때마다 받음(층을 바꿔 다시 들어와도 맞게) */
|
|
const loadCombos = () => fetchUsableCombos(getActiveLayer());
|
|
const LAYER_WORD = { system: "마스터", company: "회사", personal: "개인" } as const;
|
|
|
|
interface Choice {
|
|
value: string;
|
|
key: string;
|
|
label: string;
|
|
}
|
|
|
|
/** 찾기 칸 + 목록 창 — 고른 값(「비움」 = 빈 글) · 그냥 닫으면 null */
|
|
function choose(title: string, items: Choice[], clearable: boolean): Promise<string | null> {
|
|
return new Promise((resolve) => {
|
|
let done = false;
|
|
const finish = (value: string | null): void => {
|
|
if (!done) resolve(value);
|
|
done = true;
|
|
};
|
|
openModal({
|
|
title,
|
|
closeLabel: TEXT.close,
|
|
dialogClass: "m02-modal m02-pick",
|
|
mount: (body, close) => {
|
|
const search = createInputField({ placeholder: TEXT.find, type: "search" });
|
|
const list = el("div", { className: "m02-pick__list" });
|
|
const paint = (): void => {
|
|
const words = search.input.value.trim().toLowerCase().split(/\s+/).filter(Boolean);
|
|
const hits = items.filter((it) =>
|
|
words.every((w) => `${it.key} ${it.label}`.toLowerCase().includes(w)),
|
|
);
|
|
list.replaceChildren(
|
|
...(hits.length
|
|
? hits.map((it) =>
|
|
el("button", {
|
|
className: "m02-pick__item",
|
|
attrs: { type: "button", "data-value": it.value },
|
|
children: [el("span", { className: "m02-pick__key", text: it.key }), it.label],
|
|
}),
|
|
)
|
|
: [el("p", { className: "m02-struct__empty", text: TEXT.none })]),
|
|
);
|
|
};
|
|
list.addEventListener("click", (event) => {
|
|
const item = (event.target as HTMLElement).closest<HTMLElement>("[data-value]");
|
|
if (!item) return;
|
|
finish(item.dataset.value!);
|
|
close();
|
|
});
|
|
search.input.addEventListener("input", paint);
|
|
search.input.addEventListener("keydown", (event) => {
|
|
if (event.key !== "Enter") return;
|
|
list.querySelector<HTMLElement>("[data-value]")?.click(); // 첫 줄
|
|
});
|
|
const foot = clearable
|
|
? [
|
|
createButton({
|
|
label: TEXT.clear,
|
|
variant: "ghost",
|
|
onClick: () => {
|
|
finish("");
|
|
close();
|
|
},
|
|
}),
|
|
]
|
|
: [];
|
|
body.append(search.root, list, ...foot);
|
|
paint();
|
|
search.input.focus();
|
|
},
|
|
});
|
|
// 닫기 단추 · Esc · 바깥 누르기 — 창이 빠지면 null
|
|
const watch = new MutationObserver(() => {
|
|
if (document.querySelector(".m02-pick")) return;
|
|
watch.disconnect();
|
|
finish(null);
|
|
});
|
|
watch.observe(document.body, { childList: true });
|
|
});
|
|
}
|
|
|
|
/** 일위대가 고르기 창 — 이 층이 쓸 수 있는 세 층 조합 · 찾기 = 띄어쓰기 AND · 「비움」 = 키 빈 글 · 닫으면 null
|
|
* (표 칸 고르기 · 항목 추가 창이 함께 씀 · PLAN 31-2) */
|
|
export async function pickCombo(title: string): Promise<{ key: string; label: string } | null> {
|
|
let list: Awaited<ReturnType<typeof loadCombos>>;
|
|
try {
|
|
list = await loadCombos();
|
|
} catch (error) {
|
|
showToast(fill(TEXT.combosFailed, why(error)), "error");
|
|
return null;
|
|
}
|
|
const items = list.map((c) => ({
|
|
value: c.키,
|
|
key: c.키,
|
|
// 이름에 단위가 이미 붙은 조합이 있음 — 겹치면 뺌
|
|
label: [
|
|
c.이름,
|
|
c.단위 && !c.이름.includes(`(${c.단위})`) && `(${c.단위})`,
|
|
c.구분,
|
|
`· ${LAYER_WORD[c.layer]}`,
|
|
]
|
|
.filter(Boolean)
|
|
.join(" "),
|
|
}));
|
|
const key = await choose(title, items, true);
|
|
if (key === null) return null;
|
|
return { key, label: items.find((it) => it.value === key)?.label ?? "" };
|
|
}
|
|
|
|
/** 집계표 열 — 머리 글(제목행 종류 · 분류1 · 분류2 · 분류3) · 꼴만 씀 */
|
|
export interface StructureColumn {
|
|
id: string;
|
|
머리: (string | null)[];
|
|
꼴?: string | null;
|
|
}
|
|
|
|
/** 구조물 열 = 꼴=수 — NO · 측점 · 비고 같은 글 열은 도면 · 면적산출 · 재료산출 · 번호가 없음(서버와 같은 규칙) */
|
|
export const isStructureColumn = (col: StructureColumn): boolean => col.꼴 === "수";
|
|
|
|
/** 관리 화면 「구조물 조합」에서 숨기는 것(PLAN 26-7b · 30-7) — NO · 측점 · 비고 열 · 전구간 줄(본문 줄) ·
|
|
* 합계 줄. 양식 파일은 그대로 — 보일 문서에서만 빼고 [저장] 때 저장본 것을 다시 끼움(`comboMerge`) ·
|
|
* 틀고정 열 수는 숨긴 열만큼 줄여 보이고 [저장] 때 저장본 값으로 되돌림. */
|
|
const HIDDEN_COLUMNS = ["no", "sta", "memo"];
|
|
type ComboView = { 틀고정?: { 열?: number } } & Record<string, unknown>;
|
|
type ComboDoc = { 열: StructureColumn[]; 줄?: unknown[]; 합계줄?: unknown[]; 보기?: ComboView };
|
|
|
|
export function comboView<T>(doc: T): T {
|
|
const d = doc as unknown as ComboDoc;
|
|
const all = d.열 ?? [];
|
|
const 열 = all.filter((c) => !HIDDEN_COLUMNS.includes(c.id));
|
|
const frozen = d.보기?.틀고정?.열;
|
|
const 보기 =
|
|
d.보기 && typeof frozen === "number"
|
|
? {
|
|
...d.보기,
|
|
틀고정: {
|
|
...d.보기.틀고정,
|
|
열: frozen - all.slice(0, frozen).filter((c) => HIDDEN_COLUMNS.includes(c.id)).length,
|
|
},
|
|
}
|
|
: d.보기;
|
|
return { ...d, 열, 줄: [], 합계줄: [], ...(보기 ? { 보기 } : {}) } as unknown as T;
|
|
}
|
|
|
|
/** 보인 표 고침 + 저장본의 숨긴 것 — 열 차례 · 틀고정은 저장본(표에서 열을 더하거나 지우지 않음 · 26-7d) */
|
|
export function comboMerge<T>(stored: unknown, edited: T): T {
|
|
const s = stored as ComboDoc;
|
|
const e = edited as unknown as ComboDoc;
|
|
const byId = new Map(e.열.map((c) => [c.id, c]));
|
|
const kept = (s.열 ?? []).flatMap((c) =>
|
|
HIDDEN_COLUMNS.includes(c.id) ? [c] : byId.has(c.id) ? [byId.get(c.id)!] : [],
|
|
);
|
|
const known = new Set(kept.map((c) => c.id));
|
|
const 열 = [...kept, ...e.열.filter((c) => !known.has(c.id))];
|
|
const 보기 = e.보기 && s.보기?.틀고정 ? { ...e.보기, 틀고정: s.보기.틀고정 } : e.보기;
|
|
return {
|
|
...e,
|
|
열,
|
|
줄: s.줄 ?? [],
|
|
합계줄: s.합계줄 ?? [],
|
|
...(보기 ? { 보기 } : {}),
|
|
} as unknown as T;
|
|
}
|
|
|
|
/** 표 머리 이름 칸 고침 → 나무 이름 바꾸기(PLAN 31-1 · 한 정본 = 나무) — 칸이 항목 이름(가장 깊은 칸)이면
|
|
* 항목(열 id 로 부름) · 위 칸이면 그 폴더(머리 앞마디 경로). */
|
|
export function headRenameEdit(col: StructureColumn, level: number, name: string): TreeEdit {
|
|
const named = (parts: (string | null)[]): string[] =>
|
|
parts.filter((p): p is string => !!p && p.trim() !== "");
|
|
const path = named(col.머리);
|
|
const upto = named(col.머리.slice(0, level + 1));
|
|
return upto.length >= path.length
|
|
? { op: "rename", 경로: path.slice(0, -1), 키: col.id, 이름: name }
|
|
: { op: "rename", 경로: upto, 이름: name };
|
|
}
|
|
|
|
/** 구조물 이름 + 변수값 — 제목행 층을 빈칸으로 이음(빈 층은 건너뜀 · 다 비면 열 id) */
|
|
export const columnHead = (col: StructureColumn): string =>
|
|
col.머리.filter((part): part is string => !!part && part.trim() !== "").join(" ") || col.id;
|
|
|
|
/** 번호가 맨 앞 — 「SD010101 돌기슭막이 H=1.0」(번호가 없으면 이름만) */
|
|
export const structureLabel = (number: string, col: StructureColumn): string =>
|
|
[number, columnHead(col)].filter(Boolean).join(" ");
|
|
|
|
/** 면적산출 · 재료산출 편집 화면 위 알약 막대 — 면적 = 그 열 일위대가 입력값(물량) · 재료 = 자재DB 찾기.
|
|
* 알약이 없으면 까닭 글(`notice`)을 같이 돌려줌 */
|
|
export async function pillsFor(
|
|
kind: SheetKind,
|
|
column: string,
|
|
): Promise<{ links: LinkOptions; notice?: string }> {
|
|
if (kind === "material") {
|
|
const own = await inputPills(column, "재료");
|
|
return { links: { 항목: own, 모드: "자재", 자재찾기: searchMaterials } };
|
|
}
|
|
const own = await inputPills(column, "면적"); // 선택 입력 카드가 면적산출로 고른 입력
|
|
const none = (notice: string) => ({ links: { 항목: own, 모드: "입력" as const }, notice });
|
|
const table = await readTemplate(getActiveLayer(), "table", STRUCTURE_TABLE, null).catch(
|
|
() => null,
|
|
);
|
|
const cols = (table?.문서 as { 열?: { id: string; 일위대가?: string | null }[] } | null)?.열;
|
|
const combo = cols?.find((c) => c.id === column)?.일위대가;
|
|
if (!combo) return none(TEXT.noPrice);
|
|
try {
|
|
const got = await fetchComboInputs(combo);
|
|
const 항목 = [...got.물량.map((q) => ({ 키: q.키, 이름: q.이름, 단위: q.단위 })), ...own];
|
|
return 항목.length ? { links: { 항목, 모드: "입력" } } : none(fill(TEXT.noInputs, combo));
|
|
} catch (error) {
|
|
return none(fill(TEXT.inputsFailed, why(error)));
|
|
}
|
|
}
|
|
|
|
/** 카드 미리보기 수정의 알약 · 자재 조합 판(31-3) — 전체 편집기(`UI_Main` `mountSheet`)와 같은 부품 ·
|
|
* 면적 = 그 열 일위대가 입력값(`pillsFor`) · 재료 = 자재 조합 담은 자재 + 선택 입력 · 아래 자재 조합 판 */
|
|
async function cardLinks(
|
|
kind: SheetKind,
|
|
ctl: SheetCardControl,
|
|
isAdmin: boolean,
|
|
): ReturnType<SheetEditOptions["links"]> {
|
|
if (kind === "area") return { links: (await pillsFor("area", ctl.column)).links };
|
|
const [state, own] = await Promise.all([
|
|
loadMaterialState(ctl.column),
|
|
inputPills(ctl.column, "재료"), // 「선택 입력」 카드가 재료산출로 고른 입력
|
|
]);
|
|
let items = state.combo?.담은자재 ?? [];
|
|
const links = (): LinkOptions => ({
|
|
항목: [...toPills(items), ...own],
|
|
모드: "자재",
|
|
자재찾기: searchMaterials,
|
|
// 알약 막대에서 추가 · 빼기 — 아래 판 표를 같은 목록으로
|
|
onItemsChange: (list) => {
|
|
items = list.flatMap((i) => (i.자재 ? [{ ...i.자재 }] : []));
|
|
panel.setItems(items);
|
|
},
|
|
});
|
|
const panel = buildMaterialPanel({
|
|
column: ctl.column,
|
|
label: ctl.label,
|
|
isAdmin,
|
|
state,
|
|
links: () =>
|
|
ctl
|
|
.handle()
|
|
?.getDoc()
|
|
.시트.flatMap((s) => s.연결 ?? []) ?? [],
|
|
// 판 표에서 고침 — 알약 막대만 이 목록으로 다시 만듦(저장 안 한 시트 고침은 그대로)
|
|
onChange: (list) => {
|
|
items = list;
|
|
ctl.remount(links());
|
|
},
|
|
goTo: (code) =>
|
|
ctl.host
|
|
.querySelector<HTMLElement>(`.ss-link.is-linked[data-key="${CSS.escape(code)}"]`)
|
|
?.click(),
|
|
unlink: (codes) => {
|
|
const book = ctl.handle()?.getDoc();
|
|
if (!book) return;
|
|
for (const sheet of book.시트) {
|
|
const rest = (sheet.연결 ?? []).filter((l) => !codes.includes(l.자재?.코드 ?? l.키));
|
|
if (rest.length) sheet.연결 = rest;
|
|
else delete sheet.연결;
|
|
}
|
|
ctl.handle()?.setDoc(book);
|
|
ctl.touched();
|
|
},
|
|
});
|
|
return { links: links(), below: panel.root, refresh: panel.refresh };
|
|
}
|
|
|
|
export interface StructurePanelOptions {
|
|
/** 시스템 관리자만 저장함(구조물 도면은 서버가 미리 만들어 둠) */
|
|
isAdmin: boolean;
|
|
/** [도면 수정] · [면적산출 수정] · [재료산출 수정] — 그 열을 CAD · 스프레드시트 전체 편집으로 엶
|
|
* (페이지의 `open`) · label 은 화면 제목에 씀 */
|
|
onEdit: (column: string, label: string, kind: EditKind) => void;
|
|
/** 집계표에 저장 안 한 고침이 있으면 버릴지 물음 — 취소면 false */
|
|
confirmLeave: () => Promise<boolean>;
|
|
/** 「선택 입력」 카드에서 자리를 골랐음 — 저장 안 한 고침 표시 */
|
|
onDirty?: () => void;
|
|
/** 카드 고침을 버리지 않고 머묾 — 표의 고른 열을 되돌림(31-3) */
|
|
keepColumn?: (colId: string) => void;
|
|
}
|
|
|
|
export interface StructurePanelHandle {
|
|
root: HTMLElement;
|
|
/** `{열 id: {도번, 면적번, 재료번}}` — 집계표 `drawingLabel` · `areaLabel` · `materialLabel` 이 씀 */
|
|
numbers: () => ColumnNumbers;
|
|
/** 번호 목록 다시 받기 */
|
|
reload: () => Promise<void>;
|
|
/** 「선택 입력」 카드에서 고른 자리를 서버에 저장 — 집계표 [저장] 뒤에 부름(실패하면 던짐) */
|
|
saveInputs: () => Promise<void>;
|
|
/** 카드에 저장 안 한 고침(도면 31-4 · 면적산출 · 재료산출 31-3) — 페이지가 떠날 때 함께 물음 */
|
|
dirty: () => boolean;
|
|
/** 고친 카드 저장(도면 · 엑셀) — 집계표 [저장] 이 카드를 다시 읽기 전에 부름(실패하면 던짐) */
|
|
saveCards: () => Promise<void>;
|
|
/** 고른 열이 바뀜 — 같은 열이면 이름만 새로(CAD 를 다시 안 띄움) */
|
|
show: (colId: string | null, columns: StructureColumn[]) => void;
|
|
/** 보던 열을 다시 읽음 — 집계표 [저장] 뒤(서버가 새 열 파일 · 번호를 만듦) */
|
|
refresh: (columns: StructureColumn[]) => void;
|
|
/** 집계표 조회 후 선택(`onPick`) — 일위대가 = 고른 키(「비움」 = 빈 글 · 닫으면 null) ·
|
|
* 도면 · 면적산출 · 재료산출 = 다른 열 것을 복사해 가져옴(돌려주는 글 없음) */
|
|
pick: (row: string, colId: string | null, columns: StructureColumn[]) => Promise<string | null>;
|
|
destroy: () => void;
|
|
}
|
|
|
|
export function createStructurePanel(opts: StructurePanelOptions): StructurePanelHandle {
|
|
let numbers: ColumnNumbers = {};
|
|
let shown: StructureColumn | null = null;
|
|
let column: string | null = null;
|
|
let columnLabel = "";
|
|
|
|
const inputs: InputsCardHandle = createInputsCard({
|
|
isAdmin: opts.isAdmin,
|
|
onDirty: () => opts.onDirty?.(),
|
|
});
|
|
// 카드 셋은 항목 카드 한 벌(`ItemCards`) — 여기서는 지금 층에서 열 하나를 읽어 넘기기만.
|
|
const cards = createItemCards({
|
|
source: layerSource,
|
|
editable: () => opts.isAdmin,
|
|
onEdit: (kind) => void openEdit(kind),
|
|
numberOf: (kind, id) => numbers[id]?.[PART_FIELD[kind]],
|
|
// 도번 목록에 있는 열인데 못 읽으면 알림 — 없는 열은 그냥 「도면 없음」
|
|
warnOnFail: (id) => !!numbers[id],
|
|
extraCards: [inputs.root],
|
|
// 면적산출 · 재료산출 카드 미리보기 수정(31-3) — 전체 편집기와 같은 알약 · 저장 길
|
|
sheetEdit: {
|
|
can: () => opts.isAdmin,
|
|
links: (kind, ctl) => cardLinks(kind, ctl, opts.isAdmin),
|
|
save: async (kind, at, doc, version) =>
|
|
(await saveTemplate(getActiveLayer(), kind, at, null, version, doc)).판,
|
|
},
|
|
});
|
|
const root = cards.root;
|
|
|
|
function load(col: StructureColumn | null): Promise<void> {
|
|
shown = col;
|
|
column = col?.id ?? null;
|
|
columnLabel = col ? columnHead(col) : "";
|
|
if (!col) void inputs.show(null, null);
|
|
// 집계표에 지금 고른 일위대가(저장 전일 수 있음) — 카드가 「먼저 저장」 안내를 고름
|
|
else void inputs.show(col.id, (col as { 일위대가?: string | null }).일위대가 ?? null);
|
|
return cards.load(col ? { id: col.id, label: columnLabel } : null);
|
|
}
|
|
|
|
/** 글 열(NO · 측점 · 비고)은 구조물이 아니라 컨테이너를 닫음 */
|
|
const show = (colId: string | null, columns: StructureColumn[]): void => {
|
|
const col = columns.find((c) => c.id === colId && isStructureColumn(c)) ?? null;
|
|
if ((col?.id ?? null) !== column && cards.dirty()) {
|
|
// 카드에 저장 안 한 고침 — 버릴지 물음 · 머물면 표의 고른 열을 되돌림
|
|
const from = column;
|
|
void showConfirmDialog(TEXT.discardCards).then((ok) => {
|
|
if (!ok) return void (from && opts.keepColumn?.(from));
|
|
cards.discard(); // 한 번 물었음 — 카드가 다시 묻지 않게
|
|
void load(col);
|
|
});
|
|
return;
|
|
}
|
|
if ((col?.id ?? null) !== column) return void load(col);
|
|
if (col) cards.setLabel((columnLabel = columnHead(col))); // 머리를 고쳤을 수 있음
|
|
};
|
|
|
|
const pickPrice = async (colId: string, columns: StructureColumn[]): Promise<string | null> => {
|
|
const col = columns.find((c) => c.id === colId);
|
|
const got = await pickCombo(col ? `${TEXT.pickPrice} — ${columnHead(col)}` : TEXT.pickPrice);
|
|
return got ? got.key : null;
|
|
};
|
|
|
|
/** 다른 열의 도면 · 면적산출 · 재료산출을 골라 내용만 복사 — 덮어쓰기 확인 · 보고 있던 열이면 다시 읽음 */
|
|
const pickCopy = async (
|
|
kind: EditKind,
|
|
colId: string,
|
|
columns: StructureColumn[],
|
|
): Promise<void> => {
|
|
const field = PART_FIELD[kind];
|
|
const word = PART_WORD[kind];
|
|
const copy = COPY[kind];
|
|
const to = columns.find((c) => c.id === colId);
|
|
const toNo = numbers[colId]?.[field];
|
|
if (!to || !toNo) return void showToast(TEXT.saveFirst, "error");
|
|
const items = columns
|
|
.filter((c) => c.id !== colId && numbers[c.id]?.[field])
|
|
.map((c) => ({ value: c.id, key: numbers[c.id][field]!, label: columnHead(c) }));
|
|
const from = await choose(
|
|
`${fill(TEXT.pickCopy, word)} — ${toNo} ${columnHead(to)}`,
|
|
items,
|
|
false,
|
|
);
|
|
const src = columns.find((c) => c.id === from);
|
|
if (!from || !src) return;
|
|
const ask = TEXT.overwrite
|
|
.replace("{from}", `${numbers[from][field]} ${columnHead(src)}`)
|
|
.replace("{what}", word)
|
|
.replace("{to}", `${toNo} ${columnHead(to)}`);
|
|
if (!(await showConfirmDialog(ask))) return;
|
|
try {
|
|
await copy(colId, from);
|
|
showToast(TEXT.copied, "success");
|
|
if (column === colId) void load(shown);
|
|
} catch (error) {
|
|
showToast(fill(TEXT.copyFailed, why(error)), "error");
|
|
}
|
|
};
|
|
|
|
const pick = async (
|
|
row: string,
|
|
colId: string | null,
|
|
columns: StructureColumn[],
|
|
): Promise<string | null> => {
|
|
if (!opts.isAdmin || !colId) return null;
|
|
if (row === "s:price") return pickPrice(colId, columns);
|
|
if (ROW_KIND[row]) await pickCopy(ROW_KIND[row], colId, columns);
|
|
return null;
|
|
};
|
|
|
|
async function openEdit(kind: EditKind): Promise<void> {
|
|
const at = column;
|
|
if (!at) return;
|
|
// 저장 전 새 열(분류 더하기) — 문서 · 번호가 아직 없음 · 떠나면 집계표 고침까지 버리게 됨
|
|
if (!numbers[at]?.[PART_FIELD[kind]]) return void showToast(TEXT.saveFirst, "info");
|
|
if (!(await opts.confirmLeave())) return;
|
|
opts.onEdit(at, columnLabel, kind);
|
|
}
|
|
return {
|
|
root,
|
|
numbers: () => numbers,
|
|
reload: async () => {
|
|
numbers = await fetchStructureNumbers().catch(() => ({}));
|
|
inputs.invalidate(); // 새 열 · 바뀐 일위대가를 서버 항목 목록에서 다시 찾게
|
|
},
|
|
saveInputs: () => inputs.save(),
|
|
dirty: () => cards.dirty(),
|
|
saveCards: () => cards.saveAll(),
|
|
show,
|
|
refresh: (columns) => {
|
|
const at = column;
|
|
column = null;
|
|
show(at, columns);
|
|
},
|
|
pick,
|
|
destroy: () => {
|
|
inputs.destroy();
|
|
cards.destroy();
|
|
},
|
|
};
|
|
}
|