Aislo/resources/tester/helper_356_4_undo_grade.cjs

/* PLAN 356-4 sub7 헬퍼 — 되돌리기 · 다시하기는 그 걸음 사진(노선 + 계획고 편집)을 그대로 되살림.
 * 판 = `helper_349_0q_undo_echo.cjs` 그대로(진짜 종단도 · 묶음 · 상세 가게 · 페이지 사진첩 · 서버 창구만 가짜).
 * 편집기 흉내 = 사진첩 되살림 훅 안에서 세션 노선 초안을 다리에 넘김(`_RouteEdit_Draft` fromPage 꼴).
 * 걸음 — 끌기 → 계획고 ▲(측점 C) → 다시 끌기(C 가 바뀐 구간 = 새 조작은 ▲ 버림) → 되돌리기 · 다시하기 →
 * 중심점 좌우 꼴(끌기 + C 높이 보정 · 한 걸음) → 되돌리기 · 다시하기 → 열기까지 되돌리기.
 * argv[4] = "off" 면 되살림 표시를 끔(옛 동작 대조). 결과 = 표준출력 JSON. 짝 = `test_356_4_undo_grade.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,
};
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 shiftMod = load("B05_Profile", "logic", "B05_Profile_RouteShift.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)));
}

async function run() {
  const P = "proj-3564";
  const R = 7;
  window.localStorage.setItem("frd_current_project_id", P);
  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();

  if (process.argv[4] === "off") historyMod.pageReplaying = () => false; // 옛 동작 대조
  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 grade = async (edits) => {
    pageMod.pipelineGrade(P, edits);
    await quiet();
  };
  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 state = () => ({
    route: designStore.get("routeDraft")?.nodes[1] ?? null,
    z: alignmentMod.planElevationAt(pipe().output("profile"), C),
    offs: JSON.stringify(pipe().input("alignment")?.station_offsets ?? {}),
    session: window.sessionStorage.getItem(`aislo:draft:alignment-draft:${P}:0`),
  });
  const out = { C, open: state() };
  await step(() => bridge.edited(draftOf(shift(1, 6, -4))));
  out.drag1 = state();
  await step(() => {
    const p = pipe();
    return grade(alignmentMod.adjustStation(p.output("planline"), p.input("alignment"), C, 0.3));
  });
  out.lift = state();
  await step(() => bridge.edited(draftOf(shift(1, 9, -6))));
  out.drag2 = state();
  album().undo();
  await quiet();
  out.undo1 = state();
  album().redo();
  await quiet();
  out.redo1 = state();
  // 중심점 좌우 꼴 — 끌기 + C 계획고를 끌기 전 값으로(한 걸음)
  const zBefore = state().z;
  await step(async () => {
    const before = pipe().output("profile");
    const lineBefore = pipe().output("route").line;
    bridge.edited(draftOf(shift(1, 12, -8)));
    await quiet();
    const p = pipe();
    const pinned = shiftMod.holdGrade(
      p.output("planline"),
      p.input("alignment"),
      before,
      lineBefore,
      p.output("route").line,
    ); // 364-7 노면 그대로
    if (pinned) await grade(pinned);
  });
  out.pinned = { ...state(), zBefore };
  album().undo();
  await quiet();
  out.undo2 = state();
  album().redo();
  await quiet();
  out.redo2 = state();
  for (let i = 0; i < 6 && album().canUndo(); i += 1) {
    album().undo();
    await quiet();
  }
  out.home = state();
  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);
  });