From 4da510f6df3a9f0644a3cb2fdb1cf8a2748caa56 Mon Sep 17 00:00:00 2001 From: umsangdon Date: Mon, 19 Oct 2026 22:39:37 +0900 Subject: [PATCH] =?UTF-8?q?fix(482-1=20=EB=85=B8=EC=84=A0=20=EB=B0=94?= =?UTF-8?q?=EB=80=9C=20=EA=B5=AC=EC=A1=B0=EB=AC=BC=20=EC=B8=A1=EC=A0=90):?= =?UTF-8?q?=20=EB=85=B8=EC=84=A0=20=EC=B4=88=EC=95=88=20=EC=A4=91=20?= =?UTF-8?q?=EB=90=98=EB=8F=8C=EB=A6=AC=EA=B8=B0=20=C2=B7=20=EB=8B=A4?= =?UTF-8?q?=EC=8B=9C=ED=95=98=EA=B8=B0=EA=B0=80=20=EA=B4=80=20=C2=B7=20?= =?UTF-8?q?=EA=B5=AC=EC=A1=B0=EB=AC=BC=20=C2=B7=20=EC=B6=94=EA=B0=80=20?= =?UTF-8?q?=EC=B8=A1=EC=A0=90=EB=8F=84=20=EA=B7=B8=20=EA=B1=B8=EC=9D=8C=20?= =?UTF-8?q?=EC=82=AC=EC=A7=84=EC=9C=BC=EB=A1=9C=20=EB=AC=B6=EC=9D=8C?= =?UTF-8?q?=EC=97=90=20=EB=84=A3=EC=9D=8C=20=C2=B7=20=EC=B4=88=EC=95=88=20?= =?UTF-8?q?=EC=B8=A1=EC=A0=90=20=EB=A7=9E=EC=B6=A4=EC=9D=B4=20=EC=83=81?= =?UTF-8?q?=EC=84=B8=20=ED=8B=80(=EC=98=9B=20=C2=B7=20=EC=83=88=20?= =?UTF-8?q?=EB=85=B8=EC=84=A0)=EC=9D=84=20=EC=95=8E?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - design_pipeline_page follow 되살림 차례 = 계획고 사진 + 가게 관 · 구조물 · 추가 측점(묶음 측점 유령 · 빠짐 없앰) - Section_Store 가 노선 초안 동안 상세 틀을 정해 넘김 · Drafts = 옛 틀이면 저장분으로 맞춤 · 얹음 · 새 틀이면 저장분 종류 대조 안 함 - 새 시험 test_280_3_route_undo_facilities(헬퍼 둘 · 검증_sub4 읽기만) · 옛 코드에서 되돌리기 넷 실패 Co-Authored-By: Claude Opus 5.5 --- A00_Common/design/design_pipeline_page.ts | 6 +- B06_Section/B06_Section_Section_Drafts.ts | 19 +- B06_Section/B06_Section_Section_Store.ts | 13 +- resources/tester/helper_280_3_draft_frame.cjs | 192 +++++++ .../helper_280_3_route_undo_facilities.cjs | 481 ++++++++++++++++++ .../test_280_3_route_undo_facilities.py | 183 +++++++ 6 files changed, 886 insertions(+), 8 deletions(-) create mode 100644 resources/tester/helper_280_3_draft_frame.cjs create mode 100644 resources/tester/helper_280_3_route_undo_facilities.cjs create mode 100644 resources/tester/test_280_3_route_undo_facilities.py diff --git a/A00_Common/design/design_pipeline_page.ts b/A00_Common/design/design_pipeline_page.ts index 3a1c0b7fc..d5627c973 100644 --- a/A00_Common/design/design_pipeline_page.ts +++ b/A00_Common/design/design_pipeline_page.ts @@ -287,7 +287,11 @@ function createPagePipeline( follow: (ctx) => { const kept = replay && ctx.inputs.route ? readAlignmentDraft(DRAFT_ROUTE_ID) : null; replay = false; - if (kept) return { alignment: kept }; // 관 · 구조물도 세션 그대로(가게 · 쓰기 그대로) + // 관 · 구조물 · 추가 측점도 그 걸음 사진(사진첩이 되쓴 가게 값) — 묶음 입력에 넣어야 측점이 따라옴(280-3) + if (kept) { + const { pipes, structures, plusStations } = inputsNow(); + return { alignment: kept, pipes, structures, plusStations }; + } const line = ctx.before.route?.line ?? savedLine() ?? []; // 자리를 읽을 선 — 초안 둔 채 열기(앞 노선 없음)의 가게 값 = 이미 초안 노선 자리(앞 따라감이 씀 · 410) const frame = (list: unknown, saved: unknown) => diff --git a/B06_Section/B06_Section_Section_Drafts.ts b/B06_Section/B06_Section_Section_Drafts.ts index d0d9fc6f3..3d3602872 100644 --- a/B06_Section/B06_Section_Section_Drafts.ts +++ b/B06_Section/B06_Section_Section_Drafts.ts @@ -33,6 +33,9 @@ import { useStationKeys, useStationOwners } from "./B06_Section_Station_Keys"; import { type CrossSection, type SectionDetailResponse } from "./B06_Section_Api_Fetch"; type Pipes = PendingPipes; +/** 노선 초안 동안 상세의 틀(280-3) — old = 옛 노선 누가거리(저장 정본 · 초안 전 상세 · 초안 대신 저장분으로 + * 맞춤 · 얹음) · new = 묶음이 갈아끼운 새 노선 누가거리(저장분 종류 대조 안 함) · null = 노선 초안 없음. */ +export type RouteFrame = "old" | "new" | null; const near = (a: number, b: number): boolean => Math.abs(a - b) < SAME_STATION_M; const byChainage = (a: { chainage_m: number }, b: { chainage_m: number }) => @@ -128,9 +131,11 @@ export async function withDraftShapes( detail: SectionDetailResponse, projectId: string, swapped = false, + frame: RouteFrame = null, ): Promise { - const pipesDraft = readPendingPipes(projectId); - const structuresDraft = readPendingStructures(projectId); + const old = frame === "old"; // 옛 틀 = 저장분으로 얹음(280-3) + const pipesDraft = old ? null : readPendingPipes(projectId); + const structuresDraft = old ? null : readPendingStructures(projectId); const drafts = !!(pipesDraft || structuresDraft); if (!drafts && !swapped && !drafted.has(detail)) return; const inputs = await statusOf(projectId, pipesDraft, structuresDraft); @@ -161,11 +166,13 @@ export async function withDraftStations( detail: SectionDetailResponse, projectId: string, routeId: number, + frame: RouteFrame = null, ): Promise { const turn = (turns.get(detail) ?? 0) + 1; turns.set(detail, turn); - const pipesDraft = readPendingPipes(projectId); - const structuresDraft = readPendingStructures(projectId); + const old = frame === "old"; // 새 틀 초안을 옛 틀 측점에 견주지 않음(280-3) + const pipesDraft = old ? null : readPendingPipes(projectId); + const structuresDraft = old ? null : readPendingStructures(projectId); const all = [ ...detail.cross_sections.filter((section) => !section.preview), ...(parked.get(detail) ?? []), @@ -173,7 +180,7 @@ export async function withDraftStations( let live = all; let stale: CrossSection[] = []; // 추가 측점 초안(368-2)도 측점 계획을 바꿈 — 계획은 그 초안을 스스로 읽음 - if (!(pipesDraft || structuresDraft || readPlusDraft(projectId))) { + if (!(pipesDraft || structuresDraft || (!old && readPlusDraft(projectId)))) { // 초안 없음 = 저장분 계획으로 열쇠 주인만 — 관 = 저장 id(계산 묶음 열쇠와 같음 · 첫 옮김도 열쇠째 · 415 H1) const inputs = await statusOf(projectId, null, null); if (inputs) { @@ -210,7 +217,9 @@ export async function withDraftStations( ] .sort() .join(","); + // 새 틀 = 저장분(옛 틀 누가거리)과 같은 m 로 견주지 않음 — 측점 목록은 묶음 갈아끼움 몫(280-3) const replaced = (section: CrossSection): boolean => { + if (frame === "new") return false; const was = kindsAt(oldPipes, oldStructures, section.chainage_m); return was !== "" && was !== kindsAt(pipes, structures, section.chainage_m); }; diff --git a/B06_Section/B06_Section_Section_Store.ts b/B06_Section/B06_Section_Section_Store.ts index a65405da1..c1b91e2d1 100644 --- a/B06_Section/B06_Section_Section_Store.ts +++ b/B06_Section/B06_Section_Section_Store.ts @@ -45,6 +45,7 @@ import { keepHeldDetail, keepSavedDetail, savedDesigns, + savedSectionDetail, sessionDetail, } from "./B06_Section_Section_Canon"; import { fetchSectionDetail } from "./B06_Section_Api_Fetch"; @@ -90,8 +91,16 @@ async function withDraftWalls( setGeneralStations(detail.longitudinal?.stations); // 구조물 기준 측점이 붙을 일반 측점(234-1) setPlusStations(() => plusStationsOf(projectId)); // 측점 계획이 읽을 추가 측점(368-2) await loadSavedPlusStations(projectId); - await withDraftStations(detail, projectId, routeId); // 옛 자리 숨김 · 새 자리 미리 뜬 횡단(273-2) - await withDraftShapes(detail, projectId); + // 노선 초안 동안 틀(280-3) — 저장 정본 · 초안 전 상세 = 옛 노선 틀 · 그 밖 = 묶음이 갈아끼운 새 노선 틀 + const frame = + useDesignStore(projectId, null).get("routeDraft") === null + ? null + : detail === savedSectionDetail(projectId, routeId) || + detail === heldSectionDetail(projectId, routeId) + ? "old" + : "new"; + await withDraftStations(detail, projectId, routeId, frame); // 옛 자리 숨김 · 새 자리 미리 뜬 횡단(273-2) + await withDraftShapes(detail, projectId, false, frame); await withAdjustsAndAreas(detail, projectId, routeId); // 초안 자리 미리 뜬 횡단 = 서버가 저장 계획선으로 셈 · 묶음 cross 뒤에 얹힐 수 있음 — 다 돈 뒤 지금 계획선과 // 갈리면 cross 한 번 더(387-8 · 낡음 판정 = 가게 몫 · 종단 판이 접혀 그리기가 안 돌아도) diff --git a/resources/tester/helper_280_3_draft_frame.cjs b/resources/tester/helper_280_3_draft_frame.cjs new file mode 100644 index 000000000..b1e5fa8d3 --- /dev/null +++ b/resources/tester/helper_280_3_draft_frame.cjs @@ -0,0 +1,192 @@ +/* 요구 280-3 원인 3 헬퍼 — 노선 초안 동안 초안 측점 맞춤(`withDraftStations` · `withDraftShapes`)이 상세의 틀을 앎. + * old = 옛 노선 틀 상세(저장 정본 · 새로고침 첫 화면) → 새 틀 초안 대신 저장분으로 · new = 묶음이 갈아끼운 새 틀 → + * 저장분(옛 틀) 종류와 같은 m 로 견주지 않음 · null = 옛 동작(대조). 진짜 TS: Drafts · 측점 계획 · 형상 얹기 · 표. + * 결과 = 표준출력 JSON. 짝 = `test_280_3_route_undo_facilities.py`. */ +const fs = require("fs"); +const path = require("path"); +const ROOT = path.join(__dirname, "..", ".."); +const ts = require(path.join(ROOT, "config", "node_modules", "typescript")); +const CATALOG = require("./helper_322_catalog_module.cjs"); + +const S = { + savedPipes: [], + savedStructures: [], + draftPipes: null, + draftStructures: null, + types: [], +}; +const STUBS = { + design_page_data: { + forgetPageData: () => {}, + pagePipes: async () => ({ pipe_points: S.savedPipes }), + pageStructures: async () => ({ structures: S.savedStructures }), + }, + B05_Profile_Api_Structures: { + fetchStructureTypes: async () => S.types, + readPendingStructures: () => S.draftStructures, + }, + B05_Profile_Api_Pipes_Draft: { readPendingPipes: () => S.draftPipes }, + B05_Profile_Api_PlusStations: { readPlusDraft: () => null }, + B06_Section_Station_Keys: { useStationKeys: () => {}, useStationOwners: () => {} }, + ui_template_elements: { showToast: () => {} }, +}; +const cache = new Map(); +function resolveTs(base) { + for (const c of [`${base}.ts`, base]) if (fs.existsSync(c) && fs.statSync(c).isFile()) return c; + throw new Error(`없음: ${base}`); +} +function load(full) { + if (cache.has(full)) return cache.get(full).exports; + const js = ts.transpileModule(fs.readFileSync(full, "utf8"), { + compilerOptions: { module: ts.ModuleKind.CommonJS, target: ts.ScriptTarget.ES2020 }, + }).outputText; + const box = { exports: {} }; + cache.set(full, box); + const req = (r0) => { + if (CATALOG.isCatalogRequest(r0)) return CATALOG; + const r = r0.replace(/\.js$/, ""); + const stub = STUBS[r.split("/").pop()]; + if (stub) return stub; + if (r.endsWith(".json")) + return JSON.parse(fs.readFileSync(path.join(path.dirname(full), r), "utf8")); + if (r.startsWith("@util/")) return load(resolveTs(path.join(ROOT, "common_util", r.slice(6)))); + if (r.startsWith("@ui/")) return STUBS[r.split("/").pop()] ?? {}; + if (r.startsWith(".")) return load(resolveTs(path.join(path.dirname(full), r))); + return require(r); + }; + new Function("exports", "module", "require", js)(box.exports, box, req); + return box.exports; +} +const P = (...a) => path.join(ROOT, ...a); +const D = load(P("B06_Section", "B06_Section_Section_Drafts.ts")); +const def = JSON.parse( + fs.readFileSync(P("resources", "master_template", "구조물정의.json"), "utf8"), +); +S.types = def.types.map((t) => ({ + type_id: t.type_id, + group: t.group, + placement: t.placement, + managed_by: t.managed_by, + name: t.name, + options: (t.options || []).map((o) => ({ key: o.key, label: o.label, default: o.default })), +})); + +const sec = (m, kind, extra = {}) => ({ + station_id: `station_${String(Math.round(m * 1000)).padStart(12, "0")}`, + chainage_m: m, + label: "", + kind, + center_x: m, + center_y: 0, + center_z: 100, + frame: { left_xy: [0, 1] }, + samples: [{ offset_m: 0, elevation_m: 100, valid: true }], + design: { design_elevation_m: 100 }, + ...extra, +}); +const detailOf = (marks, len = 300) => { + const grid = []; + for (let m = 0; m <= len; m += 20) grid.push(m); + const all = [...new Set([...grid, ...marks.map((x) => x.m)])].sort((a, b) => a - b); + const cross = all.map((m, i) => { + const mk = marks.find((x) => x.m === m); + const kind = i === 0 ? "bp" : i === all.length - 1 ? "ep" : mk ? "irregular" : "regular"; + return sec(m, kind, mk ? { structure: mk.title, ...(m % 20 === 0 ? { grid: true } : {}) } : {}); + }); + return { longitudinal: { length_m: len, stations: [] }, cross_sections: cross }; +}; +const show = (detail) => + detail.cross_sections + .filter((s) => s.kind === "irregular" || s.structure || s.preview) + .map( + (s) => + `${s.chainage_m}:${s.kind}${s.grid ? "/grid" : ""}${s.preview ? "/preview" : ""}=${s.structure ?? "-"}[${Object.keys( + s, + ) + .filter( + (k) => + ![ + "station_id", + "chainage_m", + "label", + "kind", + "center_x", + "center_y", + "center_z", + "frame", + "samples", + "design", + "structure", + "grid", + "preview", + ].includes(k), + ) + .join(",")}]`, + ); + +const ud = (id, m) => ({ + structure_id: id, + type_id: "cross_underdrain", + placement: "point", + chainage_m: m, + start_m: null, + end_m: null, + options: {}, +}); +const rw = (id, s, a, e) => ({ + structure_id: id, + type_id: "retaining_wall", + placement: "interval", + chainage_m: a, + start_m: s, + end_m: e, + options: {}, +}); + +/** 상세 하나를 맞춘 뒤 — 숨김(빠진 측점) · 구조물 없는 사본 · 측점마다 카드 이름. */ +async function run(saved, draft, marks, frame) { + S.savedStructures = saved; + S.draftStructures = draft; + const detail = detailOf(marks); + const before = detail.cross_sections.map((s) => s.chainage_m); + await D.withDraftStations(detail, "p", 1, frame); + await D.withDraftShapes(detail, "p", false, frame); + const after = detail.cross_sections.map((s) => s.chainage_m); + return { + hidden: before.filter((m) => !after.includes(m)), + preview: detail.cross_sections.filter((s) => s.preview).map((s) => s.chainage_m), + names: Object.fromEntries( + detail.cross_sections.filter((s) => s.structure).map((s) => [s.chainage_m, s.structure]), + ), + }; +} + +(async () => { + const out = {}; + // 옛 틀 상세(저장 정본 · 새로고침) + 새 틀 초안(+20 m) — 저장분 자리 그대로여야 함 + const oldFrame = [ud("A", 100), rw("B", 153, 160, 167)]; + const oldMarks = [ + { m: 100, title: "맹암거" }, + { m: 153, title: "옹벽" }, + { m: 160, title: "옹벽" }, + { m: 167, title: "옹벽" }, + ]; + const shifted = [ud("A", 120), rw("B", 173, 180, 187)]; + for (const frame of ["old", null]) + out[`old_${frame}`] = await run(oldFrame, shifted, oldMarks, frame); + // 새 틀 상세(갈아끼움 뒤) — 옛 틀 B 중심 120 자리에 새 틀 A 가 옴(종류 다름) · 사본 · 숨김 없어야 함 + const savedB = [ud("A", 100), rw("B", 113, 120, 127)]; + const draftB = [ud("A", 120), rw("B", 133, 140, 147)]; + const newMarks = [ + { m: 120, title: "맹암거" }, + { m: 133, title: "옹벽" }, + { m: 140, title: "옹벽" }, + { m: 147, title: "옹벽" }, + ]; + for (const frame of ["new", null]) + out[`new_${frame}`] = await run(savedB, draftB, newMarks, frame); + process.stdout.write(JSON.stringify(out)); +})().catch((error) => { + process.stderr.write(String(error && error.stack ? error.stack : error)); + process.exit(1); +}); diff --git a/resources/tester/helper_280_3_route_undo_facilities.cjs b/resources/tester/helper_280_3_route_undo_facilities.cjs new file mode 100644 index 000000000..a92db1a09 --- /dev/null +++ b/resources/tester/helper_280_3_route_undo_facilities.cjs @@ -0,0 +1,481 @@ +/* 요구 280-3 헬퍼 — 노선 초안 중 ↶ · ↷ 가 관 · 구조물 · 추가 측점도 그 걸음 사진으로 묶음에 넣는지. + * 판 = `helper_356_4_undo_grade.cjs` 그대로(진짜 종단도 · 묶음 · 상세 가게 · 페이지 사진첩 · 서버 창구만 가짜). + * 걸음 — 끌기 1 → (계획고 ▲) → 시설 손 옮김(argv[4] = structure · pipe · plus · none) → 끌기 2 → ↶ → ↷. + * 잼 — ↶ · ↷ 첫 차례 · 조용해진 뒤 묶음 측점 시설 누가거리 · 초안 상세 비정규 측점 대 측점 계획(가게 값). + * 결과 = 표준출력 JSON. 짝 = `test_280_3_route_undo_facilities.py`. */ +const fs = require("fs"); +const path = require("path"); +const ts = require(path.join(__dirname, "..", "..", "config", "node_modules", "typescript")); +const CATALOG = require("./helper_322_catalog_module.cjs"); + +const ROOT = path.join(__dirname, "..", ".."); +const job = JSON.parse(fs.readFileSync(process.argv[2], "utf8")); + +function memoryStorage() { + const map = new Map(); + return { + getItem: (key) => (map.has(key) ? map.get(key) : null), + setItem: (key, value) => map.set(key, String(value)), + removeItem: (key) => map.delete(key), + key: (index) => [...map.keys()][index] ?? null, + get length() { + return map.size; + }, + }; +} +const winListeners = {}; +const windowBase = { + sessionStorage: memoryStorage(), + localStorage: memoryStorage(), + setTimeout, + clearTimeout, + addEventListener: (type, fn) => (winListeners[type] ??= []).push(fn), + removeEventListener: () => undefined, +}; +globalThis.window = new Proxy(windowBase, { + get: (t, key) => (key in t ? t[key] : undefined), + set: (t, key, value) => ((t[key] = value), true), +}); + +// 흙 배분 서버 — 늦게 답함 · 끊기면 버림 +globalThis.fetch = (url, init) => + new Promise((resolve, reject) => { + const timer = setTimeout( + () => resolve({ ok: true, json: async () => ({ haul_plan: { blocks: [], url } }) }), + 20, + ); + init.signal.addEventListener("abort", () => { + clearTimeout(timer); + reject(new Error("aborted")); + }); + }); + +const STUBS = {}; +const cache = new Map(); +function loadTs(full) { + if (cache.has(full)) return cache.get(full); + const js = ts.transpileModule(fs.readFileSync(full, "utf8"), { + compilerOptions: { module: ts.ModuleKind.CommonJS, target: ts.ScriptTarget.ES2020 }, + }).outputText; + const box = { exports: {} }; + cache.set(full, box.exports); + const localRequire = (request) => { + if (CATALOG.isCatalogRequest(request)) return CATALOG; + const key = Object.keys(STUBS).find((name) => request.endsWith(name)); + if (key) return STUBS[key]; + if (request.startsWith("@config/")) return { API_BASE_URL: "http://fake" }; + if (request.startsWith("@ui/")) return anyModule(); + if (request.endsWith(".css")) return {}; + if (request.endsWith(".json")) return require(path.join(path.dirname(full), request)); + if (request.startsWith("@util/")) + return loadTs(path.join(ROOT, "common_util", `${request.slice(6)}.ts`)); + if (request.startsWith(".")) return loadTs(path.join(path.dirname(full), `${request}.ts`)); + return require(request); + }; + new Function("exports", "module", "require", js)(box.exports, box, localRequire); + return box.exports; +} +const load = (...parts) => loadTs(path.join(ROOT, ...parts)); + +const sampler = load("common_util", "common_util_surface_sampler.ts"); +const bytes = fs.readFileSync(process.argv[3]); +const grid = sampler.parseDtmGrid( + bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.length), +); +const local = { grid, design: "las" }; + +/** 아무 화면 부품 — 무엇을 읽든 · 부르든 또 그것(DOM · 오버레이 · 도구줄 흉내). */ +function anyNode() { + const box = { dataset: {}, style: {}, classList: { add() {}, remove() {}, toggle() {} } }; + return new Proxy(function node() {}, { + get: (_t, key) => { + if (key in box) return box[key]; + if (key === "then" || typeof key === "symbol") return undefined; + return (box[key] = anyNode()); + }, + set: (_t, key, value) => ((box[key] = value), true), + apply: () => anyNode(), + }); +} +const anyModule = (own = {}) => + new Proxy(own, { + get: (t, key) => + key in t + ? t[key] + : key === "__esModule" + ? true + : typeof key === "symbol" + ? undefined + : anyNode(), + }); +globalThis.document = anyNode(); +globalThis.HTMLElement = function HTMLElement() {}; + +STUBS["B05_Profile_Api_Replan"] = { + analysisTerrain: () => "las", + fetchRoutePlan: async () => ({ + planned: job.line, + curves: job.curves, + min_radius_m: job.minRadius, + station_snap: job.stationSnap, + }), +}; +STUBS["B05_Profile_Api_Structures"] = anyModule({ + fetchStructures: async () => ({ structures: job.structures }), + fetchStructureTypes: async () => job.types, + readPendingStructures: () => null, +}); +STUBS["B05_Profile_Api_TerrainGrid"] = { + loadDesignTerrainGrid: async () => local, + groundStageDeps: () => ({ grid: () => local, remote: async () => [] }), +}; +STUBS["B04_PreProcess_Api_Fetch"] = { + fetchDetailPipePoints: async () => ({ + pipe_points: job.pipes.map((pipe) => ({ ...pipe, lonlat: [0, 0] })), + }), +}; +STUBS["B06_Section_UI_Standard_Panel"] = { + effectiveStandardCross: () => job.standard, + readRockBoundaryDefault: () => -0.5, +}; +// 구조물 초안 얹기(측점 계획 · 형상) — 이 시험 밖 · 아무 일 없음 +STUBS["B06_Section_Section_Drafts"] = { + withDraftStations: async () => undefined, + withDraftShapes: async () => undefined, + forgetDraftStations: () => undefined, + supersedeDraftStations: () => undefined, +}; +STUBS["B06_Section_Api_Fetch"] = { + fetchSectionDetail: async () => JSON.parse(JSON.stringify(job.detail)), + saveSections: async () => undefined, +}; +// 횡단 다시 셈(브라우저 · B05 crossPreview · B06 카드 같은 창구) — 부른 횟수 · 면적은 서버와 달라짐(두 배) +let refreshCalls = 0; +const doubled = (detail) => + detail.cross_sections.forEach((section) => { + if (!section.design) return; + const design = { ...section.design }; + for (const [key, value] of Object.entries(design)) + if (key.endsWith("_m2") && typeof value === "number") design[key] = value * 2; + section.design = design; + }); +STUBS["B06_Section_Cross_Refresh"] = { + refreshCrossDesigns: async ({ detail }) => { + refreshCalls += 1; + doubled(detail); + return detail.cross_sections.map((s) => s.chainage_m); + }, + // 화면 선 맡김 · 낡음 판정 = 진짜 `staleAgainstScreen` 그대로(화면 선 → 없으면 상세 자기 선) + holdScreenAlignment: (line) => { + screenLine = line; + return () => undefined; + }, + staleAgainstScreen: (detail, routeId) => { + const screen = screenLine?.(routeId); + if (!screen) return common.hasStaleDesigns(detail); + return common.hasStaleDesigns({ + longitudinal: { + design_profiles: [ + profileData.toDesignProfile(screen, detail.longitudinal.design_profiles?.[0]), + ], + }, + cross_sections: detail.cross_sections, + }); + }, + USER_TOUCHED_KEYS: [], +}; +let screenLine = null; +STUBS["B06_Section_UI_Cross_Detail"] = anyModule(); +STUBS["B06_Section_UI_Page_Common"] = anyModule({ L: (key) => key }); +// 그리기 — 진짜 `renderProfile` 의 낡음 판정 줄만(같은 함수 · 같은 인자) · SVG 는 안 그림 +const draws = []; +let opened = null; +STUBS["B05_Profile_UI_Profile_Render"] = { + renderProfile: (ctx) => { + const detail = ctx.detail(); + if (!detail) return; + const alignment = ctx.alignment(); + const longitudinal = detail.longitudinal; + const designProfiles = alignment + ? [profileData.toDesignProfile(alignment, longitudinal.design_profiles?.[0])] + : (longitudinal.design_profiles ?? []); + const key = common.staleKey({ + longitudinal: { design_profiles: designProfiles }, + cross_sections: detail.cross_sections, + }); + // 저장 상세를 그림 = 묶음 새 노선 상세(preview)가 아님 · 그린 객체(가게 것인지 견줌) + draws.push({ key, saved: !detail.cross_sections.some((s) => s.preview), ref: detail }); + ctx.onStaleDesigns?.(key); + }, +}; +STUBS["B05_Profile_UI_Profile_Tools"] = anyModule(); +STUBS["design_profile_free_view"] = anyModule(); +STUBS["B06_Section_UI_Cross_Panel_Base"] = anyModule(); +globalThis.sessionStorage = window.sessionStorage; +STUBS["common_util_view_window"] = { frameOf: (_root, fn) => fn() }; +for (const name of [ + "B05_Profile_UI_Profile_Balance", + "B05_Profile_UI_Profile_Heights", + "B05_Profile_UI_Profile_Zoom", + "B05_Profile_UI_Profile_Drag", + "B05_Profile_UI_Profile_MassHaul", + "design_profile_overlays", + "design_profile_viewport", + "design_save", + "B05_Profile_Api_Fetch", + "common_util_mass_haul_balance_view", +]) + STUBS[name] = anyModule(); + +const pageMod = load("A00_Common", "design", "design_pipeline_page.ts"); +const storeMod = load("A00_Common", "design", "design_store.ts"); +const sectionStore = load("B06_Section", "B06_Section_Section_Store.ts"); +const common = load("B06_Section", "B06_Section_UI_Section_Common.ts"); +const layouts = load("B06_Section", "B06_Section_Structure_Layouts.ts"); +const profileData = load("B05_Profile", "logic", "B05_Profile_UI_Profile_Data.ts"); +const alignmentMod = load("B05_Profile", "logic", "B05_Profile_UI_Profile_Alignment.ts"); +const baseMod = load("A00_Common", "design", "design_profile_base.ts"); +const pageState = load("A00_Common", "b_page_state.ts"); +const massHaul = load("common_util", "common_util_mass_haul.ts"); +const historyMod = load("B05_Profile", "B05_Profile_UI_Profile_History.ts"); +const profileMod = load("A00_Common", "design", "design_profile.ts"); +const designSync = load("B06_Section", "B06_Section_UI_Page_Design_Sync.ts"); +const designSession = load("B06_Section", "B06_Section_Cross_Design_Session.ts"); +const stationKeys = load("B06_Section", "B06_Section_Station_Keys.ts"); +// 진짜 다시 셈 창구(묶음 새 노선 상세를 안 고치는지만 봄 · 다른 곳은 위 가짜를 부름) +const realRefresh = loadTs(path.join(ROOT, "B06_Section", "B06_Section_Cross_Refresh.ts")); + +const tick = (ms = 0) => new Promise((resolve) => setTimeout(resolve, ms)); +const runs = () => globalThis.__aisloPipeline?.runs ?? []; +/** 묶음 · 상세 가게 · 다시 셈이 조용해질 때까지. */ +async function quiet() { + let seen = -1; + for (let i = 0; i < 400; i += 1) { + await tick(30); + const last = runs()[runs().length - 1]; + const count = runs().length + refreshCalls * 1000 + draws.length * 1e6; + if (count === seen && (!last || last.outcome !== "running")) return; + seen = count; + } + throw new Error("묶음이 조용해지지 않음"); +} +const n = job.nodes.length; +const draftOf = (nodes) => ({ + nodes, + curveOn: Array(n).fill(true), + curveRadius: Array(n).fill(null), + curveLock: Array(n).fill(null), + curveArc: Array(n).fill(null), + stationSnap: job.stationSnap, +}); +const shift = (index, dx, dy) => + job.nodes.map((node, i) => (i === index ? [node[0] + dx, node[1] + dy] : node)); +const sliceRuns = (mark) => + runs() + .slice(mark) + .map((r) => ({ + sources: r.sources, + outcome: r.outcome, + restored: r.restored ?? null, + why: r.restoreWhy ?? null, + })); +const finalOf = (detail) => { + const [series] = massHaul.computeMassHaulSeries( + detail.longitudinal, + detail.cross_sections, + job.conversion, + undefined, + ["cross"], + ); + const points = series?.result.points ?? []; + return points.length ? points[points.length - 1].cumulative_volume_m3 : null; +}; +const crossOf = (detail) => + JSON.stringify(detail.cross_sections.map((s) => [s.chainage_m, s.design, s.samples])); +/** 서버 정본 흉내 — 저장 횡단 계획고 = 열 때 종단도 계획선(낡음 0 · 서버가 낸 상세와 같음). */ +function settleDesigns(detail) { + const pa = detail.longitudinal.profile_alignment; + const base = baseMod.listedBase(alignmentMod.toAlignmentBase(pa), detail, []); + const samples = alignmentMod.buildAlignment(base, pa.edits).samples; + const at = (c) => { + const i = samples.findIndex((s) => s.chainage_m >= c); + if (i < 0) return samples[samples.length - 1].elevation_m; + if (i === 0) return samples[0].elevation_m; + const a = samples[i - 1]; + const b = samples[i]; + return ( + a.elevation_m + + ((b.elevation_m - a.elevation_m) * (c - a.chainage_m)) / (b.chainage_m - a.chainage_m) + ); + }; + detail.cross_sections.forEach((s) => (s.design.design_elevation_m = at(s.chainage_m))); +} + +const plan = load("common_util", "common_util_structure_station.ts"); +const plusApi = load("B05_Profile", "B05_Profile_Api_PlusStations.ts"); +const near = (a, b) => Math.abs(a - b) < 0.005; +const r2 = (v) => Math.round(v * 100) / 100; + +async function run() { + const P = "proj-2803"; + const R = 7; + const mode = process.argv[4] ?? "structure"; + window.localStorage.setItem("frd_current_project_id", P); + if (mode === "plus") plusApi.writePlusDraft(P, [Math.round(job.plusAt)]); // 열기 전 추가 측점 초안 + opened = await sectionStore.loadSectionDetail(P, R); + settleDesigns(opened); + stationKeys.useStationKeys(P, R, opened); + const profile = profileMod.createDesignProfile({ + projectId: P, + view: "profile", + onSelectStation: () => undefined, + }); + pageMod.routeDraftBridge(P, profile, { + stationIntervalM: job.interval, + structureAreas: ({ cross_sections: rows }) => + layouts.applyStructureAreaRows(rows, layouts.structureAreaRows(rows)), + holdDraft: (routeId, saved) => { + const hold = saved && sectionStore.holdSectionDetail(P, routeId, saved); + return async (stations) => { + if (!hold) { + await sectionStore.swapSectionStations(P, routeId, stations); + return "no-saved"; + } + const back = await sectionStore.restoreSectionDetail(P, routeId, hold, stations); + return !back ? "no-cache" : back.same ? "saved" : "saved-diff"; + }; + }, + }); + const show = (detail) => { + profile.render(detail, job.interval, R); + profile.setIrregularStations([]); + }; + const stopListen = sectionStore.subscribeSectionDetail(P, R, (next) => show(next)); + const stopStore = storeMod.useDesignStore(P, null).subscribe("stations", (stations) => { + if (stations?.length) void sectionStore.swapSectionStations(P, R, stations); + }); + show(opened); + profile.setEarthworkContext({ conversion: job.conversion }); + await quiet(); + + const bridge = pageMod.routeDraftBridge(P, profile); + const designStore = storeMod.useDesignStore(P, null); + historyMod.onPageHistory({ + restore: () => { + const kept = designStore.get("routeDraft"); + bridge.edited(kept ? draftOf(kept.nodes) : null); + }, + }); + const album = () => historyMod.pageHistory(); + const pipe = () => pageMod.pagePipeline(P); + const gesture = () => (winListeners.keydown ?? []).forEach((fn) => fn({})); + const step = async (fn) => { + gesture(); + album().pause(); + await fn(); + await quiet(); + album().resume(); + }; + /** 측점 계획(가게 관 · 구조물 · 추가 측점) 대 묶음 측점 · 초안 상세 — 유령 · 빠짐(누가거리). */ + const facilityStations = (stations) => + stations + .filter((s) => s.kind === "pipe" || s.kind === "structure" || s.kind === "plus") + .map((s) => r2(s.chainageM)); + const measure = (stations) => { + const p = pipe(); + const pipes = (designStore.get("pipes") ?? p.input("pipes")).filter((q) => !q.outside); + const structures = designStore.get("structures") ?? p.input("structures"); + const plus = plusApi.plusStationsOf(P); + const want = plan + .planStations(pipes, structures, job.types, undefined, plus) + .map((s) => r2(s.chainage_m)); + const got = [...new Set(facilityStations(stations))]; + const detail = pageMod.pipelineDetail(P); + const irr = detail + ? detail.longitudinal.stations + .filter((s) => s.kind === "irregular") + .map((s) => r2(s.chainage_m)) + : []; + const diff = (a, b) => a.filter((x) => !b.some((y) => near(x, y))); + return { + want, + ghost: diff(got, want), + missing: diff(want, got), + detailGhost: detail ? diff(irr, want) : null, // 초안 상세 = 노선 초안 동안만 + detailMissing: detail ? diff(want, irr) : null, + offs: JSON.stringify(p.input("alignment")?.station_offsets ?? {}), + }; + }; + /** ↶ · ↷ 첫 차례 묶음 측점(맞춤 한 바퀴 전) — ground 단계 출력. */ + let first = null; + pipe().subscribe((event) => { + if (event.kind === "stage" && event.stage === "ground" && !first) first = event.value.stations; + }, "280-3 잼"); + const replay = async (fn) => { + first = null; + fn(); + await quiet(); + return { + first: first ? measure(first) : null, + settled: measure(pipe().output("ground").stations), + }; + }; + const stations = pipe().output("ground").stations; + const [nx, ny] = job.nodes[1]; + const C = stations.reduce((a, b) => + Math.hypot(b.x - nx, b.y - ny) < Math.hypot(a.x - nx, a.y - ny) ? b : a, + ).chainageM; + const out = { mode, open: measure(stations) }; + await step(() => bridge.edited(draftOf(shift(1, 6, -4)))); + out.drag1 = measure(pipe().output("ground").stations); + await step(() => { + const p = pipe(); + pageMod.pipelineGrade( + P, + alignmentMod.adjustStation(p.output("planline"), p.input("alignment"), C, 0.3), + ); + }); + out.lift = measure(pipe().output("ground").stations); + // 손 옮김 — 화면 폼 · 방향키와 같은 가게 쓰기(좌표 지움 = 누가거리가 정본) + const by = (d) => (s) => ({ ...s, chainage_m: s.chainage_m + d, x: null, y: null }); + await step(() => { + if (mode === "structure") { + const list = designStore.get("structures") ?? pipe().input("structures"); + designStore.set( + "structures", + list.map((s, i) => (i === list.length - 1 ? by(3)(s) : s)), + ); + } else if (mode === "pipe") { + const list = designStore.get("pipes") ?? pipe().input("pipes"); + designStore.set( + "pipes", + list.map((q, i) => (i === 0 ? by(3)(q) : q)), + ); + } else if (mode === "plus") { + plusApi.writePlusDraft( + P, + plusApi.plusStationsOf(P).map((m) => m + 3), + ); + } + }); + out.moved = measure(pipe().output("ground").stations); + await step(() => bridge.edited(draftOf(shift(1, 9, -6)))); + out.drag2 = measure(pipe().output("ground").stations); + out.undo = await replay(() => album().undo()); + out.redo = await replay(() => album().redo()); + out.blocked = pipe().blockedWrites; + stopListen(); + stopStore(); + pageMod.disposePagePipeline(P); + return out; +} + +run() + .then((out) => { + process.stdout.write(JSON.stringify(out)); + process.exit(0); + }) + .catch((error) => { + process.stderr.write(String(error && error.stack ? error.stack : error)); + process.exit(1); + }); diff --git a/resources/tester/test_280_3_route_undo_facilities.py b/resources/tester/test_280_3_route_undo_facilities.py new file mode 100644 index 000000000..75418a39e --- /dev/null +++ b/resources/tester/test_280_3_route_undo_facilities.py @@ -0,0 +1,183 @@ +"""요구 280-3 — 노선 초안 중 ↶ · ↷ = 관 · 구조물 · 추가 측점도 그 걸음 사진(묶음 입력까지). + +· 옛 흠 — ↶ 차례 follow 가 계획고 사진만 내고 시설은 안 내 묶음 측점이 마지막 끌기 누가거리에 남음 + (구조물 없는 구조물 측점 · 측점 없는 구조물) · 끌기 사이 손 옮김이 있으면 맞춤도 건너뛰어 오래 남음 +· 잼 — ↶ · ↷ 첫 차례 · 조용해진 뒤 묶음 측점 시설 · 초안 상세 비정규 측점 = 측점 계획(가게 값) · 유령 0 · 빠짐 0 +· 계획고 사진(356-4 ▲)은 그대로 +짝: `helper_280_3_route_undo_facilities.cjs`(판 = 356-4 · 실제 TS 를 Node 로 · 화면 부품 · 서버 창구만 가짜). +""" + +from __future__ import annotations + +import json +import subprocess +import tempfile +from pathlib import Path + +import pytest + +import test_349_0q_undo_echo as base + +HERE = Path(__file__).resolve().parent +MODES = ("structure", "pipe", "plus", "none") +PROJECT = base.ROOT / "storage/1/3/c725d747-50ae-46b0-87ce-4d4e56a53cf3" # 검증_sub4(읽기만) +ROUTE = PROJECT / "B05_Profile/route" +SECTION = PROJECT / "B06_Section" +GRID = PROJECT / "B04_PreProcess/models/dtm_classification_smooth.npz" + + +def build_job() -> dict: + """입력 한 벌 — 349-0q 꼴 · 검증_sub4 초기 노선 · 구조물 둘(점 · 구간).""" + if not (GRID.is_file() and (SECTION / "longitudinal/longitudinal.json").is_file()): + pytest.skip("검증_sub4 없음") + curves = base._json(ROUTE / "planned_route_initial_curves.json") + sections = sorted( + (base._json(p) for p in (SECTION / "cross_sections").glob("cross_*.json")), + key=lambda s: s["chainage_m"], + ) + for i, section in enumerate(sections): + section["design"] = { + "ground_type": "soil", + "design_elevation_m": section["center_z"], + "cut_area_m2": 4.0 + (i % 5), + "fill_area_m2": 1.5 + (i % 3), + } + pipes = [ + {"id": f"p{n}", "source": "manual", "facility": "pipe", **base._between(sections, n)} + for n in (15, 20) + ] + point = base._between(sections, 25) + a, b = base._between(sections, 30), base._between(sections, 31) + return { + "line": base._csv(ROUTE / "planned_route_initial.csv"), + "nodes": base._csv(ROUTE / "planned_route_initial_nodes.csv"), + "curves": [ + {k: c[k] for k in ("start", "apex", "end", "radius_m")} for c in curves["curves"] + ], + "stationSnap": bool(curves.get("station_snap")), + "minRadius": curves["min_radius_m"], + "interval": 20.0, + "types": [ + {"type_id": t.type_id, "group": t.group, "placement": t.placement} + for t in base.structure_type_map().values() + ], + "pipes": pipes, + "standard": base.STANDARD_CROSS_SECTION, + "conversion": base.ONES, + "structures": [ + { + "structure_id": "s-2803a", + "type_id": "cross_underdrain", + "placement": "point", + **point, + }, + { + "structure_id": "s-2803b", + "type_id": "retaining_wall", + "placement": "interval", + "start_m": a["chainage_m"], + "chainage_m": round((a["chainage_m"] + b["chainage_m"]) / 2, 2), + "end_m": b["chainage_m"], + "x": (a["x"] + b["x"]) / 2, + "y": (a["y"] + b["y"]) / 2, + }, + ], + "touched": {}, + "detail": { + "longitudinal": base._json(SECTION / "longitudinal/longitudinal.json"), + "cross_sections": sections, + }, + } + + +def _run(job: dict, mode: str) -> dict: + with tempfile.TemporaryDirectory() as folder: + path = Path(folder) / "job.json" + path.write_text(json.dumps(job), encoding="utf-8") + grid = Path(folder) / "grid.bin" + grid.write_bytes(base.dtm_grid_bytes(GRID)) + proc = subprocess.run( # noqa: S603 — 고정 실행 파일 + [ + "node", + str(HERE / "helper_280_3_route_undo_facilities.cjs"), + str(path), + str(grid), + mode, + ], + capture_output=True, + text=True, + encoding="utf-8", + timeout=300, + ) + assert proc.returncode == 0, proc.stderr + return json.loads(proc.stdout) + + +@pytest.fixture(scope="module") +def runs() -> dict: + job = build_job() + # 추가 측점 — 끌면 밀리는 뒤쪽 두 측점 사이 + sections = job["detail"]["cross_sections"] + job["plusAt"] = (sections[-5]["chainage_m"] + sections[-4]["chainage_m"]) / 2 + return {mode: _run(job, mode) for mode in MODES} + + +def _clean(m: dict) -> None: + assert m["ghost"] == [] and m["missing"] == [], m + assert m["detailGhost"] in ([], None) and m["detailMissing"] in ([], None), m + + +@pytest.mark.parametrize("mode", MODES) +def test_되돌리기_다시하기_시설_측점_같음(runs, mode): + r = runs[mode] + assert r["moved"]["want"] != r["drag2"]["want"] or mode == "none" # 끌기 2 가 시설을 옮김 + for key in ("undo", "redo"): + _clean(r[key]["settled"]) + _clean(r[key]["first"]) # 맞춤 한 바퀴 전 첫 차례부터 + assert r[key]["settled"]["detailGhost"] is not None # 노선 초안 그대로(초안 상세를 잼) + assert r["undo"]["settled"]["want"] == r["moved"]["want"] # ↶ = 끌기 2 전 시설 자리 + assert r["redo"]["settled"]["want"] == r["drag2"]["want"] + assert r["blocked"] == 0 + + +@pytest.mark.parametrize("mode", MODES) +def test_끌기_손옮김_사이_측점_같음(runs, mode): + r = runs[mode] + for key in ("open", "drag1", "lift", "moved", "drag2"): + _clean(r[key]) + + +def test_계획고_사진_그대로(runs): + r = runs["structure"] + assert r["undo"]["settled"]["offs"] == r["moved"]["offs"] # ▲ 남음(356-4) + assert r["redo"]["settled"]["offs"] == r["drag2"]["offs"] + + +@pytest.fixture(scope="module") +def frames() -> dict: + proc = subprocess.run( # noqa: S603 — 고정 실행 파일 + ["node", str(HERE / "helper_280_3_draft_frame.cjs")], + capture_output=True, + text=True, + encoding="utf-8", + timeout=120, + ) + assert proc.returncode == 0, proc.stderr + return json.loads(proc.stdout) + + +def test_옛_틀_상세는_저장분으로_맞춤(frames): + r = frames["old_old"] # 새로고침 첫 화면 · 묶음 갈아끼움 전 + assert r["hidden"] == [] and r["preview"] == [] + assert r["names"] == {"100": "맹암거", "153": "옹벽", "160": "옹벽", "167": "옹벽"} + old = frames["old_null"] + assert ( + old["hidden"] and "180" in old["names"] + ) # 옛 동작 = 숨김 · 남의 자리 이름(시험이 흠을 잼) + + +def test_새_틀_상세는_저장분_종류와_안_견줌(frames): + r = frames["new_new"] # 묶음 갈아끼움 뒤 + assert r["hidden"] == [] and r["preview"] == [] + assert r["names"]["120"] == "맹암거" + assert frames["new_null"]["preview"] == [120] # 옛 동작 = 구조물 없는 사본