Aislo/resources/tester/helper_349_0l_undo_draw.cjs

/* PLAN 349-0l sub7 헬퍼 — 열기 → 노선 꼭짓점 끌기 → 되돌리기 → 횡단 보기 → 종단 보기, 누가토량 · 측점 · 횡단이
 * 열 때와 같음 · 다시 셈 0. 진짜 TS — 종단도(`design_profile` · 낡음 판정 → crossPreview 예약) · 계산 묶음 ·
 * 상세 가게(`B06_Section_Section_Store`). 화면 부품(DOM · SVG · 오버레이 · 도구줄)과 서버 창구만 가짜 ·
 * 그리기는 진짜 `renderProfile` 의 낡음 판정 줄만 · 다시 셈 창구(`refreshCrossDesigns`)는 부른 수를 세고 면적을
 * 바꿈(서버와 다른 값 흉내). 검증_sub7 노선(관 11 · 구조물 1 은 시험이 관 자리에 놓음).
 * 되돌리기 = 화면 Ctrl+Z 꼴 — 사진첩이 세션 노선 초안 칸을 먼저 비운 뒤 다리에 알림(349-0m).
 * 입력 argv[2] JSON · argv[3] 격자 이진. 결과 = 표준출력 JSON. 짝 = `test_349_0l_undo_draw.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 windowBase = {
  sessionStorage: memoryStorage(),
  localStorage: memoryStorage(),
  setTimeout,
  clearTimeout,
  addEventListener: () => undefined,
  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,
};
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);
  },
  holdScreenAlignment: () => () => undefined,
  USER_TOUCHED_KEYS: [],
};
// 그리기 — 진짜 `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["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_Panel_Tools",
  "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 profileMod = load("A00_Common", "design", "design_profile.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)));
}

async function run() {
  const P = "proj-349l";
  const R = 7;
  window.localStorage.setItem("frd_current_project_id", P);
  opened = await sectionStore.loadSectionDetail(P, R);
  settleDesigns(opened);
  const profile = profileMod.createDesignProfile({
    projectId: P,
    view: "profile",
    onSelectStation: () => undefined,
  });
  const live = () => sectionStore.loadSectionDetail(P, R);
  pageMod.routeDraftBridge(P, profile, {
    stationIntervalM: job.interval,
    structureAreas: ({ cross_sections: rows }) =>
      layouts.applyStructureAreaRows(rows, layouts.structureAreaRows(rows)),
    // `design_view_profile` 의 holdDraft 그대로(349-0o)
    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";
      };
    },
  });
  // 종단 보기 `renderSections` · followSwap 그대로 — 새 상세 → render · 비정규 측점 · 가게 stations → 갈아끼움
  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 measure = async (mark, refreshMark) => {
    const detail = await live();
    return {
      runs: sliceRuns(mark),
      refresh: refreshCalls - refreshMark,
      lastKey: draws[draws.length - 1]?.key ?? null,
      drawnSaved: draws[draws.length - 1]?.saved ?? null,
      drawnLive: draws[draws.length - 1]?.ref === detail,
      sameObject: detail === opened,
      stations: detail.cross_sections.map((s) => s.chainage_m),
      final: finalOf(detail),
      cross: crossOf(detail),
      edits: JSON.stringify(profile.pipelineSource().edits),
      pipeEdits: JSON.stringify(pageMod.pagePipeline(P).input("alignment")),
    };
  };
  const open = await measure(0, 0);

  // 노선 꼭짓점 한 번 끌기 — 상세가 새 노선 측점으로 갈아끼워짐 · 그 횡단을 카드가 다시 셈(흉내)
  let mark = runs().length;
  let refreshMark = refreshCalls;
  const bridge = pageMod.routeDraftBridge(P, profile);
  bridge.edited(draftOf(shift(1, 6, -4)));
  await quiet();
  doubled(await live());
  const drag = await measure(mark, refreshMark);

  // 되돌리기 한 번(초안 버림) — 화면 Ctrl+Z 꼴(349-0m): 페이지 사진첩이 세션 route-draft 칸을 먼저 되쓰고
  // 편집기 되살림(fromPage → tell)이 다리에 null 을 알림 · 같은 알림이 한 번 더 와도 한 차례
  mark = runs().length;
  refreshMark = refreshCalls;
  pageState.writeState("route-draft", null, P);
  bridge.edited(null);
  bridge.edited(null);
  await quiet();
  const undo = await measure(mark, refreshMark);

  // 횡단 보기(B06) 다녀옴 — 종단도는 횡단 보기 자리에서 `shownDetail`(묶음 새 상세 없으면 저장 상세)을 그림
  mark = runs().length;
  refreshMark = refreshCalls;
  profile.setView("cross");
  show(pageMod.pipelineDetail(P) ?? (await live()));
  profile.setEarthworkContext({ conversion: job.conversion });
  await quiet();
  profile.setView("profile");
  profile.setActive(true);
  await quiet();
  const back = await measure(mark, refreshMark);
  const blocked = pageMod.pagePipeline(P).blockedWrites;
  stopListen();
  stopStore();
  pageMod.disposePagePipeline(P);
  return { open, drag, undo, back, blocked };
}

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);
  });