From 6971c42c1e0a11c01611d47b62d9ab71ab0c9d31 Mon Sep 17 00:00:00 2001 From: umsangdon Date: Mon, 19 Oct 2026 07:27:40 +0900 Subject: [PATCH] =?UTF-8?q?fix(466=20=EC=83=81=EC=84=B8=20=EA=B0=80?= =?UTF-8?q?=EA=B2=8C=20=C2=B7=20=EB=AC=B6=EC=9D=8C=20=EC=B6=9C=EB=A0=A5):?= =?UTF-8?q?=20=ED=8E=98=EC=9D=B4=EC=A7=80=EB=A5=BC=20=EB=96=A0=EB=82=98?= =?UTF-8?q?=EB=A9=B4=20=EC=83=81=EC=84=B8=20=EB=A9=94=EB=AA=A8=EB=A6=AC=20?= =?UTF-8?q?=EB=B9=84=EC=9B=80=20=C2=B7=20=EC=A1=B0=EC=9A=A9=ED=95=9C=20?= =?UTF-8?q?=EC=B0=A8=EB=A1=80=EB=8F=84=20=EA=B0=80=EA=B2=8C=20=EC=B8=A1?= =?UTF-8?q?=EC=A0=90=20=3D=20=EC=83=81=EC=84=B8=20=EC=B8=A1=EC=A0=90?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - 상세 가게 forgetSectionMemory — 페이지 dispose 에서 메모리 · 받는 중 약속만 비움(세션 정본 그대로) · 다시 열기 = 새로고침 길 - 묶음 열 때 관 · 구조물 · 추가 측점 초안이 있으면 측점을 냄 — 새로고침 · 다시 열기 = 초안 측점(옛: 새로고침 뒤 관 초안 측점 빠짐) - 버린 노선 초안 차례 끝 · 조용히 연 차례 끝 = 가게 측점 · 종단 = 지금 상세 측점 · 저장 기준(갈아끼움 없음) - 화면 선만 바뀜(비정규 측점 도착) = 상세가 그 선 대비 낡았으면 cross 한 번 더(recrossIfStale) - 시험 test_272_detail_memory · test_272_drop_store_stations Co-Authored-By: Claude Opus 5.5 --- A00_Common/design/design_page.ts | 6 +- A00_Common/design/design_pipeline_page.ts | 30 ++- .../design/design_pipeline_page_publish.ts | 90 +++++++- B06_Section/B06_Section_Section_Store.ts | 18 ++ resources/tester/helper_272_detail_memory.mjs | 205 ++++++++++++++++++ .../tester/helper_272_detail_memory_entry.ts | 12 + resources/tester/test_272_detail_memory.py | 109 ++++++++++ .../tester/test_272_drop_store_stations.py | 56 +++++ 8 files changed, 514 insertions(+), 12 deletions(-) create mode 100644 resources/tester/helper_272_detail_memory.mjs create mode 100644 resources/tester/helper_272_detail_memory_entry.ts create mode 100644 resources/tester/test_272_detail_memory.py create mode 100644 resources/tester/test_272_drop_store_stations.py diff --git a/A00_Common/design/design_page.ts b/A00_Common/design/design_page.ts index e130381d3..ca861aca7 100644 --- a/A00_Common/design/design_page.ts +++ b/A00_Common/design/design_page.ts @@ -37,7 +37,10 @@ import { pipelineDetail, reconcilePagePipeline } from "./design_pipeline_page"; import { forgetPageData, onPageBusy } from "./design_page_data"; import { pageRouteId } from "./design_page_route"; import { setPipeSectionsSource } from "./design_structure_pipe_calc"; -import { peekSectionDetail } from "../../B06_Section/B06_Section_Section_Store"; +import { + forgetSectionMemory, + peekSectionDetail, +} from "../../B06_Section/B06_Section_Section_Store"; import "./design_page.css"; export type { DesignPageShared } from "./design_shared"; @@ -288,6 +291,7 @@ export function renderDesignPage(root: HTMLElement): MountedPage { shared.lane.dispose(); stopBusy(); forgetPageData(projectId, true); // 다시 열면 저장분 · 노선 id 새로(386-2) + forgetSectionMemory(projectId); // 다시 열면 상세 = 새로고침 길(세션 정본 + 초안 · 466) delete (window as unknown as { __designPage?: unknown }).__designPage; }, }; diff --git a/A00_Common/design/design_pipeline_page.ts b/A00_Common/design/design_pipeline_page.ts index 1332c800a..f5324ecec 100644 --- a/A00_Common/design/design_pipeline_page.ts +++ b/A00_Common/design/design_pipeline_page.ts @@ -15,9 +15,10 @@ * 고리(365-2) — 열 때 · 들어올 때 입력 대 묶음 입력 · 다르면 한 바퀴 · 최대 3 · 넘으면 `onUnstable`. * 출력 — 가게 stations · profile · footprint · generation · 노선 초안이 있으면 종단도가 새 첫 계획선 · * 옮긴 계획고 · 새 노선 상세(`pipelineDetail` — 지반 · 측점 · 횡단 면적 → 유토곡선)를 그림. - * 첫 계산 = 열 때 한 번(저장 노선 · 발자국 · 저장 안 한 노선 초안이 있으면 그 노선). - * 노선 초안을 버리면(되돌리기 · [저장 전으로]) 열 때처럼 — 측점 · 종단을 안 내고 초안 전 상세 · 횡단 초안 칸 - * 그대로(349-0k · 349-0o) · 그 뒤 같은 측점 목록은 가게에 다시 안 냄(상세 측점이 묶음과 달라도 · 349-0q). + * 첫 계산 = 열 때 한 번(저장 노선 · 발자국 · 저장 안 한 노선 초안이 있으면 그 노선) · 관 · 구조물 · 추가 측점 + * 초안이 있으면 측점을 냄(새로고침 · 다시 열기 = 초안 측점 · 466). + * 노선 초안을 버리면(되돌리기 · [저장 전으로]) 초안 전 상세 · 횡단 초안 칸 그대로(349-0k · 349-0o) · 가게 측점 · + * 종단 = 그 상세 측점 · 저장 기준(466) · 그 뒤 같은 측점 목록은 가게에 다시 안 냄(상세 측점이 묶음과 달라도 · 349-0q). * [저장](sub5)이 서버 정본 — 노선을 먼저 보내고 `pendingAlignment(DRAFT_ROUTE_ID)` 를 새 노선에 보냄. * ========================================================================== */ @@ -56,7 +57,11 @@ import { readAlignmentDraft, } from "../../B05_Profile/B05_Profile_UI_Profile_Edit"; import { readAlignment } from "../../B05_Profile/logic/B05_Profile_UI_Profile_Data"; -import { followPlusDraft, plusStationsOf } from "../../B05_Profile/B05_Profile_Api_PlusStations"; +import { + followPlusDraft, + plusStationsOf, + readPlusDraft, +} from "../../B05_Profile/B05_Profile_Api_PlusStations"; import { pageReplaying } from "../../B05_Profile/B05_Profile_UI_Profile_History"; import { analysisTerrain, @@ -380,7 +385,7 @@ function createPagePipeline( }, }, }); - publishPagePipeline(pipe, store, () => quietGeneration); + const publisher = publishPagePipeline(pipe, store, () => quietGeneration); /** 노선 초안을 버린 차례 끝 — 초안 전 상세로 되돌림(열 때와 같은 상태 · 측점이 달라도 · 다른 자리는 * 기록에) · 그 상세가 저장 정본(다시 하기도 같은 기준). 차례 끝에서 판정 — ground 를 건너뛰어도 · 사진첩 * 되돌리기가 가게 초안을 먼저 비워도(349-0m). */ @@ -409,6 +414,9 @@ function createPagePipeline( if (diff) record.restoreDiff = diff; } why = await restore(stations).catch(() => "error"); + // 가게 측점 · 종단 = 되돌린 상세 · 저장 기준(초안 측점이 남지 않게 · 466) + if (why.startsWith("saved") || why === "no-saved") + await publisher.shown(projectId, routeId as number).catch(() => undefined); } } Object.assign(record, { restored: why.startsWith("saved"), restoreWhy: why }); @@ -528,8 +536,12 @@ function createPagePipeline( const run = (lastRun = pipe.start(inputs)); trackPageBusy(projectId, run); // 「계산 중」 점(386-2) openGeneration = pipe.generation; - quietGeneration = inputs.route ? -1 : pipe.generation; - void run.then(() => reconcile()); // 열 때 셈하는 사이 바뀐 입력(세션 · 가게)도 맞춤 + // 관 · 구조물 · 추가 측점 초안이 있으면 측점을 냄 — 새로고침 · 다시 열기 = 초안 측점(갈아끼움 · 466) + const drafts = store.get("pipes") ?? store.get("structures") ?? readPlusDraft(projectId); + quietGeneration = inputs.route || drafts ? -1 : pipe.generation; + void run + .then(() => reconcile()) // 열 때 셈하는 사이 바뀐 입력(세션 · 가게)도 맞춤 + .then(() => publisher.opened(projectId, openGeneration, canon?.routeId)); // 466 }; /** 묶음에 넘긴 입력(follow 가 고치기 전) · 마지막으로 띄운 차례 — 고리가 견줌 · 기다림. */ @@ -657,8 +669,10 @@ function createPagePipeline( }, restart() { if (!started) return start(); - // 갈아끼움 · 같은 상세 다시 그림은 안 셈 · 보기가 심은 측점은 묶음이 입력으로 셈(386-3) + // 갈아끼움 · 같은 상세 다시 그림은 안 셈 · 보기가 심은 측점은 묶음이 입력으로 셈(386-3) · 화면 선만 + // 바뀜(비정규 측점 도착) = 상세가 그 선 대비 낡았으면 cross 한 번 더(466) if (canonChanged()) void loadPlan().then(start); + else if (typeof canon?.routeId === "number") publisher.recheck(projectId, canon.routeId); }, earthwork() { const cross = crossNow()?.input ?? null; diff --git a/A00_Common/design/design_pipeline_page_publish.ts b/A00_Common/design/design_pipeline_page_publish.ts index 7d5dccdd8..a4c037a00 100644 --- a/A00_Common/design/design_pipeline_page_publish.ts +++ b/A00_Common/design/design_pipeline_page_publish.ts @@ -2,24 +2,72 @@ * A00_Common/design/design_pipeline_page_publish.ts * 페이지 계산 묶음 → 가게(stations · profile · footprint · generation) 잇기(`design_pipeline_page` 700줄 쪼갬 · 466). * - * 조용한 차례(열 때 · 노선 초안을 버린 차례)는 측점 · 종단을 안 냄(상세 = 저장 정본 · 초안 전 상세 그대로) · + * 조용한 차례(열 때 · 노선 초안을 버린 차례)는 측점 · 종단을 바로 안 냄(상세 = 저장 정본 · 초안 전 상세 그대로) · * 그 목록을 「보인 측점」으로 적어 뒤 같은 목록 차례도 안 냄(관 · 구조물 메아리가 상세를 갈아끼우지 않게 · 349-0q). + * 조용한 차례 끝(열 때 · 버린 차례의 되돌림 뒤) = 가게 측점 · 종단 = 지금 상세가 쥔 측점 · 그 차례 저장 기준 종단 + * (466 · 요구 272) — 상세에서 지은 목록이라 갈아끼움은 「같은 목록」(349-0o 그대로) · 가게에 초안 측점이 안 남음. + * 화면 선만 바뀜(정본 그대로) = 상세가 그 선 대비 낡았으면 cross 한 번 더(`recrossIfStale` · 466). + * 상세 가게는 늦게 불러옴(가게 ↔ 묶음 순환 없음 · Section_Store `recrossSaved` 와 같은 꼴). * ========================================================================== */ import { publishToStore, type DesignPipeline } from "./logic/design_pipeline"; -import type { PipelineOutputs } from "./logic/design_pipeline_types"; +import type { PipelineOutputs, PipelineStation, StationKind } from "./logic/design_pipeline_types"; import type { DesignStore } from "./design_store"; +import type { CrossSection } from "../../B06_Section/B06_Section_Api_Fetch"; + +export interface PagePublisher { + /** 조용한 차례 끝(열 때 · 노선 초안을 버린 되돌림 뒤) — 가게 측점 = 지금 상세 측점 · 종단 = 그 차례 종단. + * 상세 없음(떠남 · 아직 안 받음) · 뒤 차례가 떴으면 안 냄(그 차례 몫). */ + shown(projectId: string, routeId: number): Promise; + /** 열고 맞춤까지 끝 — 그 뒤로 낸 측점이 없으면(조용히 엶) `shown`(지난 페이지 초안 측점이 남지 않게). */ + opened(projectId: string, since: number, routeId: unknown): Promise; + /** 화면 선만 바뀜 — 상세가 그 선 대비 낡았으면 다 돈 뒤 cross 한 번 더. */ + recheck(projectId: string, routeId: number): void; +} + +/** 열쇠 머리 → 측점 종류(`grid:` · `pipe:` · `structure:` · `end:` · `curve:`). */ +const kindOfKey = (key: string): StationKind => { + const head = key.slice(0, key.indexOf(":")); + return (["grid", "pipe", "structure", "end", "curve"] as const).find((k) => k === head) ?? "grid"; +}; + +/** 상세 횡단 → 가게 측점 꼴(같은 자리 · 열쇠 묶음 측점이 없을 때 — 자리 · 축은 상세 것 · 지반은 안 실음). */ +function fromSection(section: CrossSection, key: string): PipelineStation { + const kind = kindOfKey(key); + const raw = section as unknown as { + center_x?: number; + center_y?: number; + azimuth_deg?: number; + frame?: { left_xy?: [number, number] }; + }; + return { + key, + chainageM: section.chainage_m, + x: raw.center_x ?? 0, + y: raw.center_y ?? 0, + azimuthDeg: raw.azimuth_deg ?? 0, + left: raw.frame?.left_xy ?? [0, 0], + kind, + id: kind === "pipe" || kind === "structure" ? key.slice(key.indexOf(":") + 1) : null, + ground: null, + planRadiusM: null, + curveOuterSide: null, + curveWideningM: null, + }; +} /** 묶음 출력을 가게에 냄 — `quietGeneration` = 측점 · 종단을 안 내는 차례 번호(부를 때마다 읽음). */ export function publishPagePipeline( pipe: DesignPipeline, store: DesignStore, quietGeneration: () => number, -): void { +): PagePublisher { const publish = publishToStore(store); /** 상세가 맞춘 측점 목록(열쇠 · 자리) — 열 때 · 되돌린 차례 측점 · 마지막으로 낸 측점. 같은 목록이면 가게에 * 다시 안 냄(되돌린 상세 측점이 묶음 측점과 달라도 · 관 · 구조물 메아리가 상세를 갈아끼우지 않게 · 349-0q). */ let stationsShown: string | null = null; + /** 마지막으로 가게에 측점을 낸 차례 번호. */ + let published = -1; pipe.subscribe((event) => { const saved = event.kind === "stage" && (event.stage === "ground" || event.stage === "profile"); const quiet = saved && event.generation === quietGeneration(); @@ -36,5 +84,41 @@ export function publishPagePipeline( stationsShown = list; } if (!quiet) publish(event); + if (!quiet && event.kind === "stage" && event.stage === "ground") published = event.generation; }, "가게"); + + const publisher: PagePublisher = { + async opened(projectId, since, routeId) { + if (typeof routeId !== "number" || published >= since || pipe.input("route")) return; + await publisher.shown(projectId, routeId).catch(() => undefined); + }, + async shown(projectId, routeId) { + const generation = pipe.generation; + const [{ peekSectionDetail }, { registeredKeys, stationIntervalOf }] = await Promise.all([ + import("../../B06_Section/B06_Section_Section_Store"), + import("../../B06_Section/B06_Section_Station_Keys"), + ]); + if (pipe.generation !== generation || pipe.input("route")) return; + const detail = peekSectionDetail(projectId, routeId); + if (!detail) return; + const sections = detail.cross_sections; + const keys = registeredKeys(projectId, routeId, sections, stationIntervalOf(detail)); + const ground = pipe.output("ground")?.stations ?? []; + const stations = sections.map((section, i): PipelineStation => { + const hit = ground.find( + (station) => + station.key === keys[i] && Math.abs(station.chainageM - section.chainage_m) < 1e-3, + ); + return hit ? { ...hit, chainageM: section.chainage_m } : fromSection(section, keys[i]); + }); + store.set("stations", stations); + store.set("profile", pipe.output("profile")); + }, + recheck(projectId, routeId) { + void import("../../B06_Section/B06_Section_Section_Store") + .then((section) => section.recrossIfStale(projectId, routeId)) + .catch(() => undefined); + }, + }; + return publisher; } diff --git a/B06_Section/B06_Section_Section_Store.ts b/B06_Section/B06_Section_Section_Store.ts index f3d835590..c125ac7c6 100644 --- a/B06_Section/B06_Section_Section_Store.ts +++ b/B06_Section/B06_Section_Section_Store.ts @@ -293,6 +293,14 @@ function recrossSaved( .catch(() => undefined); } +/** 화면 계획선이 바뀜(비정규 측점 도착 · 다시 그림 — 정본은 그대로 · 466) — 지금 상세가 그 선 대비 낡았으면 + * 다 돈 뒤 cross 한 번 더(열 때 시설 줄이 측점을 늦게 내 그 사이 차례가 옛 선으로 셈한 측점). */ +export function recrossIfStale(projectId: string, routeId: number): void { + const key = keyOf(projectId, routeId); + const detail = cache.get(key); + if (detail) recrossSaved(projectId, key, detail, routeId); +} + /** 노선 초안 전 상태(349-0o) — 상세(초안 전 객체 그대로 · 되돌리면 캐시) · 측점 열쇠 · 측점 열쇠 칸 다섯(횡단 초안) · * 가게 관 · 구조물(440-4 · 묶음이 버릴 때 되씀). */ export interface SectionHold { @@ -401,6 +409,16 @@ export function invalidateSectionDetail(projectId: string, routeId?: number): vo } } +/** + * 페이지를 떠남(466 · 요구 272) — 메모리 상세 · 받는 중 약속만 비움(세션 정본 · 정본 사본 그대로). 다시 열면 + * 새로고침 길(세션 정본 + `withDraftWalls`) — 초안 때 갈아끼운 측점 목록이 다음 페이지의 저장 정본으로 남지 않게. + */ +export function forgetSectionMemory(projectId: string): void { + const prefix = `${projectId}:`; + for (const map of [cache, pending]) + for (const key of [...map.keys()]) if (key.startsWith(prefix)) map.delete(key); +} + /** 받아 둔 그 노선 상세(받지 않고 · 없으면 null) — 노선 = 페이지 노선 id(B05 평면 횡단 판 · 관 길이 · 416). */ export function peekSectionDetail( projectId: string, diff --git a/resources/tester/helper_272_detail_memory.mjs b/resources/tester/helper_272_detail_memory.mjs new file mode 100644 index 000000000..fe2b94ae8 --- /dev/null +++ b/resources/tester/helper_272_detail_memory.mjs @@ -0,0 +1,205 @@ +/* 466(요구 272) 헬퍼 — 진짜 상세 가게 · 가게 잇기(vite ssr 묶음 · helper_272_detail_memory_entry.ts). + * node helper_272_detail_memory.mjs <묶음.mjs> + * ① 관 초안 갈아끼움 → [폐기] → 페이지 떠남(forgetSectionMemory) → 다시 읽기 = 세션 정본(새로고침 길) + * ② 묶음 출력 → 가게 — 조용한 차례 · 버린 차례 끝(shown) · 열고 맞춤 끝(opened) · 메아리 + * 표준출력 JSON 한 벌. 짝 = test_272_detail_memory.py · test_272_drop_store_stations.py. */ +import { pathToFileURL } from "node:url"; + +const storage = () => { + const m = new Map(); + return { + getItem: (k) => (m.has(k) ? m.get(k) : null), + setItem: (k, v) => m.set(k, String(v)), + removeItem: (k) => m.delete(k), + key: (i) => [...m.keys()][i] ?? null, + get length() { + return m.size; + }, + clear: () => m.clear(), + }; +}; +globalThis.window = globalThis; +globalThis.sessionStorage = storage(); +globalThis.localStorage = storage(); +const any = new Proxy(function () {}, { + get: (_t, k) => (k === Symbol.toPrimitive ? () => 0 : any), + apply: () => any, + construct: () => any, +}); +globalThis.document = any; +globalThis.requestAnimationFrame = (run) => setTimeout(run, 0); +let fetches = 0; // 상세 GET 만 셈 +globalThis.fetch = (url) => { + if (/\/sections\/\d+\/detail/.test(String(url))) fetches += 1; + return Promise.reject(new Error("서버 없음")); +}; + +const m = await import(pathToFileURL(process.argv[2]).href); +const P = "p272"; +const R = 7; +localStorage.setItem("frd_current_project_id", P); + +const section = (chainage_m, kind) => ({ + station_id: `station_${String(Math.round(chainage_m * 1000)).padStart(12, "0")}`, + chainage_m, + label: "", + kind, + center_z: 100, + azimuth_deg: 90, + center_x: chainage_m, + center_y: 0, + frame: { left_xy: [0, 1] }, + samples: [{ offset_m: 0, elevation_m: 100, valid: true }], + design: { design_elevation_m: 101 }, +}); +const saved = { + longitudinal: { + length_m: 60, + stations: [], + profile_alignment: { policy: { station_interval_m: 20 } }, + }, + cross_sections: [ + section(0, "bp"), + section(20, "regular"), + section(40, "regular"), + section(60, "ep"), + ], +}; +const station = (key, chainageM, kind, x = chainageM) => ({ + key, + chainageM, + x, + y: 0, + azimuthDeg: 90, + left: [0, 1], + kind, + id: kind === "pipe" ? key.slice(5) : null, + ground: { centerZ: 99, left: [{ offsetM: 0.5, z: 99.1 }], right: [{ offsetM: 0.5, z: 98.9 }] }, + planRadiusM: null, + curveOuterSide: null, + curveWideningM: null, +}); +const chainages = (detail) => detail?.cross_sections.map((s) => s.chainage_m) ?? null; +const tick = () => new Promise((resolve) => setTimeout(resolve, 0)); +const shop = m.useDesignStore(P, null); +const out = {}; + +// ── ① 상세 메모리 ───────────────────────────────────────────────────────── +m.writeState("section-detail", saved, P, R); +const first = await m.loadSectionDetail(P, R); // 세션 한 벌 → 캐시(새로고침 길) +const keys = m.registeredKeys(P, R, first.cross_sections, m.stationIntervalOf(first)); +const saveList = () => first.cross_sections.map((s, i) => station(keys[i], s.chainage_m, "grid")); +// 관 초안(30 m) — 묶음 측점이 늘어 갈아끼움(메모리만) +shop.set("pipes", [{ id: "p1", chainage_m: 30, facility: "pipe" }]); +const drafted = [...saveList()]; +drafted.splice(2, 0, station("pipe:p1", 30, "pipe")); +const swap = await m.swapSectionStations(P, R, drafted); +const during = await m.loadSectionDetail(P, R); +out.memory = { + keys, + swapped: swap !== null, + during: chainages(during), + session: chainages(m.readState("section-detail", P, R)), +}; +// [폐기] = 초안 칸 지움 — 메모리는 그대로(페이지가 떠나며 비움) +m.discardDesignEdits(P); +out.memory.afterDiscard = chainages(await m.loadSectionDetail(P, R)); +out.memory.pipesAfterDiscard = shop.get("pipes"); +m.forgetSectionMemory(P); +out.memory.peekAfterForget = m.peekSectionDetail(P, R); +const fetchesBefore = fetches; +const again = await m.loadSectionDetail(P, R); +out.memory.reopened = chainages(again); +out.memory.reopenedSame = again === during; +out.memory.canonAsked = fetches - fetchesBefore; // 새로고침과 같은 뒤 판 확인(433-16) +// 다른 프로젝트 · 다른 노선 메모리는 그대로 +m.writeState("section-detail", saved, "other", R); +await m.loadSectionDetail("other", R); +m.forgetSectionMemory(P); +out.memory.otherKept = m.peekSectionDetail("other", R) !== null; + +// ── ② 가게 잇기 ─────────────────────────────────────────────────────────── +const fakePipe = () => { + const fns = []; + const outputs = {}; + const inputs = {}; + return { + generation: 0, + outputs, + inputs, + subscribe(fn) { + fns.push(fn); + return () => undefined; + }, + output: (name) => outputs[name] ?? null, + input: (name) => inputs[name] ?? null, + emit(event) { + fns.forEach((fn) => fn(event)); + }, + }; +}; +await m.loadSectionDetail(P, R); // 다시 연 페이지 — 세션 정본 +const pipe = fakePipe(); +let quiet = -1; +const publisher = m.publishPagePipeline(pipe, shop, () => quiet); +const sets = []; +const stopSets = shop.subscribe("stations", (value) => + sets.push( + value && chainages({ cross_sections: value.map((s) => ({ chainage_m: s.chainageM })) }), + ), +); +const ground = (gen, list) => { + pipe.outputs.ground = { stations: list, longitudinal: { chainageM: [], z: [] } }; + pipe.emit({ kind: "stage", stage: "ground", generation: gen, value: pipe.outputs.ground }); +}; +const profile = { tag: "saved-profile" }; +// 열 때(조용한 차례) — 묶음 측점 ≠ 상세 측점(저장 상세에 없는 덧 측점 50) · 가게에 안 냄 +const pipeline = [...saveList()]; +pipeline.splice(3, 0, station("grid:x50", 50, "grid")); +pipe.generation = 1; +quiet = 1; +shop.set("stations", drafted); // 지난 페이지 초안 측점이 가게에 남음 +sets.length = 0; +ground(1, pipeline); +out.store = { quietSets: sets.length }; +pipe.outputs.profile = profile; +await publisher.opened(P, 1, R); +await tick(); +out.store.opened = chainages(m.peekSectionDetail(P, R)); +out.store.openedStore = shop.get("stations").map((s) => s.chainageM); +out.store.openedProfile = shop.get("profile")?.tag ?? null; +out.store.openedSwap = await m.swapSectionStations(P, R, shop.get("stations")); +// 메아리(같은 묶음 목록 · 조용하지 않은 차례) — 가게에 안 냄(349-0q) +pipe.generation = 2; +sets.length = 0; +ground(2, pipeline); +out.store.echoSets = sets.length; +// 새 목록(관 옮김) = 냄 · 그 뒤 opened 는 안 냄(낸 차례가 더 새로움) +pipe.generation = 3; +sets.length = 0; +ground(3, drafted); +out.store.newSets = sets.length; +await publisher.opened(P, 1, R); +out.store.openedAfterPublish = shop.get("stations").map((s) => s.chainageM); +// 버린 차례 끝 — 묶음 측점(초안 목록)과 상세가 달라도 가게 = 상세 측점 · 갈아끼움 없음(349-0o) +pipe.generation = 4; +quiet = 4; +ground(4, drafted); +await publisher.shown(P, R); +out.store.dropped = shop.get("stations").map((s) => s.chainageM); +out.store.droppedKeys = shop.get("stations").map((s) => s.key); +out.store.droppedSwap = await m.swapSectionStations(P, R, shop.get("stations")); +out.store.droppedDetail = chainages(m.peekSectionDetail(P, R)); +// 노선 초안이 다시 섰거나 뒤 차례가 뜸 = 안 냄 · 상세 없음(떠남) = 안 냄 +pipe.inputs.route = { rev: 1 }; +shop.set("stations", drafted); +await publisher.shown(P, R); +out.store.routeSkip = shop.get("stations").length; +pipe.inputs.route = null; +m.forgetSectionMemory(P); +await publisher.shown(P, R); +out.store.goneSkip = shop.get("stations").length; +stopSets(); +await tick(); +process.stdout.write(JSON.stringify(out)); +process.exit(0); diff --git a/resources/tester/helper_272_detail_memory_entry.ts b/resources/tester/helper_272_detail_memory_entry.ts new file mode 100644 index 000000000..77e1410a8 --- /dev/null +++ b/resources/tester/helper_272_detail_memory_entry.ts @@ -0,0 +1,12 @@ +/* 466(요구 272) 시험 묶음 진입점 — 상세 가게 메모리 = 페이지 수명 · 버린 초안 차례 가게 측점(진짜 모듈 · vite ssr). */ +export { + forgetSectionMemory, + loadSectionDetail, + peekSectionDetail, + swapSectionStations, +} from "../../B06_Section/B06_Section_Section_Store"; +export { registeredKeys, stationIntervalOf } from "../../B06_Section/B06_Section_Station_Keys"; +export { publishPagePipeline } from "../../A00_Common/design/design_pipeline_page_publish"; +export { discardDesignEdits } from "../../A00_Common/design/design_leave"; +export { useDesignStore } from "../../A00_Common/design/design_store"; +export { readState, writeState } from "../../A00_Common/b_page_state"; diff --git a/resources/tester/test_272_detail_memory.py b/resources/tester/test_272_detail_memory.py new file mode 100644 index 000000000..1f447f018 --- /dev/null +++ b/resources/tester/test_272_detail_memory.py @@ -0,0 +1,109 @@ +"""PLAN 466 (요구 272 · 분석 4장 (A)) — 상세 가게 메모리 = 페이지 수명. + +못박는 것 + - 관 초안으로 갈아끼운 상세(메모리) → [폐기] → 페이지를 떠남 = 메모리 비움 → 다시 열기(B05 · B06 · B07) = + 세션 정본(새로고침 길 · 뒤에서 판 확인 한 번) · 초안 측점이 남지 않음. 다른 프로젝트 메모리는 그대로. + - 페이지 dispose 가 비움(`design_page`) · 묶음 열 때 관 · 구조물 · 추가 측점 초안이 있으면 측점을 냄 + (초안 남긴 채 떠남 · 새로고침 = 초안 측점 · 갈아끼움). + - 화면 선만 바뀜(비정규 측점 도착) = 상세가 그 선 대비 낡았으면 cross 한 번 더(`recrossIfStale`). +짝: `helper_272_detail_memory_entry.ts` + `helper_272_detail_memory.mjs`(진짜 상세 가게 · vite ssr). + + ./venv/Scripts/python.exe -m pytest resources/tester/test_272_detail_memory.py -q +""" + +from __future__ import annotations + +import json +import shutil +import subprocess +from pathlib import Path + +import pytest + +HERE = Path(__file__).resolve().parent +ROOT = HERE.parents[1] + +pytestmark = pytest.mark.skipif( + not (ROOT / "config" / "node_modules" / "vite").is_dir(), + reason="프론트엔드 의존성 미설치", +) + + +def run_helper(work: Path) -> dict: + """vite ssr 로 진짜 모듈을 묶어 헬퍼를 돌림 — 466 두 시험이 같이 씀.""" + build = subprocess.run( # noqa: S603 — 고정 실행 파일 + [ + "node", + str(ROOT / "config" / "node_modules" / "vite" / "bin" / "vite.js"), + "build", + "--configLoader", + "runner", + "--ssr", + "../resources/tester/helper_272_detail_memory_entry.ts", + "--outDir", + str(work), + "--logLevel", + "error", + ], + cwd=ROOT, + capture_output=True, + text=True, + encoding="utf-8", + timeout=300, + ) + assert build.returncode == 0, build.stderr + bundle = work / "bundle.mjs" + shutil.copy(work / "helper_272_detail_memory_entry.js", bundle) + proc = subprocess.run( # noqa: S603 — 고정 실행 파일 + ["node", str(HERE / "helper_272_detail_memory.mjs"), str(bundle)], + capture_output=True, + text=True, + encoding="utf-8", + timeout=120, + ) + assert proc.returncode == 0, proc.stderr + return json.loads(proc.stdout) + + +@pytest.fixture(scope="module") +def got(tmp_path_factory) -> dict: + return run_helper(tmp_path_factory.mktemp("b272")) + + +def test_초안_동안은_메모리만_갈아끼움(got) -> None: + m = got["memory"] + assert m["swapped"] and m["during"] == [0, 20, 30, 40, 60] + assert m["session"] == [0, 20, 40, 60] # 세션 = 저장 정본 + + +def test_폐기만으론_메모리_그대로_떠나면_정본(got) -> None: + m = got["memory"] + assert m["pipesAfterDiscard"] is None # 관 초안 지움 + assert m["afterDiscard"] == [0, 20, 30, 40, 60] # 같은 페이지 안 = 메모리(떠날 때 비움) + assert m["peekAfterForget"] is None + assert m["reopened"] == [0, 20, 40, 60] and m["reopenedSame"] is False # 새로고침 길 + assert m["canonAsked"] == 1 # 세션으로 서고 뒤에서 판 확인(새로고침과 같음) + assert m["otherKept"] is True + + +def test_페이지가_떠날_때_비움() -> None: + page = (ROOT / "A00_Common/design/design_page.ts").read_text(encoding="utf-8") + dispose = page[page.index(" covers: (route)") :] + assert "forgetSectionMemory(projectId);" in dispose[: dispose.index("\n };\n")] + + +def test_초안_있으면_열_때_측점_냄() -> None: + src = (ROOT / "A00_Common/design/design_pipeline_page.ts").read_text(encoding="utf-8") + start = src[src.index(" const start = (): void => {") :] + body = start[: start.index("\n };\n")] + assert 'store.get("pipes") ?? store.get("structures") ?? readPlusDraft(projectId)' in body + assert "quietGeneration = inputs.route || drafts ? -1 : pipe.generation;" in body + + +def test_화면_선만_바뀌면_낡음_다시_셈() -> None: + src = (ROOT / "A00_Common/design/design_pipeline_page.ts").read_text(encoding="utf-8") + restart = src[src.index(" restart() {") :] + assert "publisher.recheck(projectId, canon.routeId)" in restart[: restart.index(" },")] + store = (ROOT / "B06_Section/B06_Section_Section_Store.ts").read_text(encoding="utf-8") + fn = store[store.index("export function recrossIfStale(") :] + assert "recrossSaved(projectId, key, detail, routeId)" in fn[: fn.index("\n}\n")] diff --git a/resources/tester/test_272_drop_store_stations.py b/resources/tester/test_272_drop_store_stations.py new file mode 100644 index 000000000..ac9c36c58 --- /dev/null +++ b/resources/tester/test_272_drop_store_stations.py @@ -0,0 +1,56 @@ +"""PLAN 466 (요구 272 · 분석 4장 (A2)) — 조용한 차례(열 때 · 버린 노선 초안)도 가게 측점 = 상세 측점. + +못박는 것 + - 조용한 차례 = 묶음 측점을 바로 안 냄 · 열고 맞춤 끝(`opened`) = 가게 측점 · 종단 = 지금 상세 측점 · 그 차례 + 종단(지난 페이지 초안 측점이 안 남음) · 그 목록으로 갈아끼움 = 없음(같은 목록). + - 메아리(같은 묶음 목록) = 안 냄(349-0q) · 새 목록 = 냄 · 그 뒤 opened 는 안 덮음. + - 버린 차례 끝(`shown`) = 묶음 측점(초안)과 상세가 달라도 상세 측점 · 열쇠 · 갈아끼움 없음(349-0o) · + 노선 초안이 다시 섬 · 상세 없음(떠남) = 안 냄. +짝: `test_272_detail_memory.run_helper`(같은 헬퍼). + + ./venv/Scripts/python.exe -m pytest resources/tester/test_272_drop_store_stations.py -q +""" + +from __future__ import annotations + +import sys +from pathlib import Path + +import pytest + +HERE = Path(__file__).resolve().parent +if str(HERE) not in sys.path: + sys.path.insert(0, str(HERE)) + +import test_272_detail_memory as base # noqa: E402 + +pytestmark = base.pytestmark + + +@pytest.fixture(scope="module") +def got(tmp_path_factory) -> dict: + return base.run_helper(tmp_path_factory.mktemp("b272d"))["store"] + + +def test_조용히_연_차례_가게_상세_측점(got) -> None: + assert got["quietSets"] == 0 + assert got["opened"] == [0, 20, 40, 60] + assert got["openedStore"] == [0, 20, 40, 60] # 지난 페이지 초안(30) 안 남음 + assert got["openedProfile"] == "saved-profile" + assert got["openedSwap"] is None # 같은 목록 = 갈아끼움 없음 + + +def test_메아리는_안_내고_새_목록은_냄(got) -> None: + assert got["echoSets"] == 0 + assert got["newSets"] == 1 + assert got["openedAfterPublish"] == [0, 20, 30, 40, 60] # 낸 차례가 더 새로움 — 안 덮음 + + +def test_버린_차례_끝_가게_상세_측점(got) -> None: + assert got["dropped"] == [0, 20, 40, 60] and got["droppedDetail"] == [0, 20, 40, 60] + assert "pipe:p1" not in got["droppedKeys"] + assert got["droppedSwap"] is None + + +def test_초안_다시_섬_떠남은_안_냄(got) -> None: + assert got["routeSkip"] == 5 and got["goneSkip"] == 5