Aislo/resources/tester/helper_126_ford_fill.cjs

/* 126-1 우클릭 세월교 · 물넘이포장 바로 추가 헬퍼 — `_Structures_Panel_AddAt`(판정 · 끝맺음 · 알림)과
 * `_Drainage_Ford_Fill`(유량 응답 뒤 빈 월류 높이 채움)을 Node 로 돌려 표준출력 JSON 한 벌로.
 * TS 로더는 `helper_116_right_click_add.cjs` 와 같다 · 설정값은 진짜 `config_frontend` 를 읽음.
 */
const fs = require("fs");
const path = require("path");
const ts = require(path.join(__dirname, "..", "..", "config", "node_modules", "typescript"));

const ROOT = path.join(__dirname, "..", "..");
const cache = new Map();
const toasts = [];
const STUBS = { "@ui/ui_template_elements": { showToast: (message) => toasts.push(message) } };

function loadTs(file) {
  const full = path.resolve(file);
  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 (STUBS[request]) return STUBS[request];
    if (request === "@config/config_frontend")
      return loadTs(path.join(ROOT, "config", "config_frontend.ts"));
    if (request.startsWith(".")) return loadTs(path.join(path.dirname(full), `${request}.ts`));
    if (request.startsWith("@")) return new Proxy({}, { get: () => () => {} });
    return require(request);
  };
  new Function("exports", "module", "require", js)(box.exports, box, localRequire);
  cache.set(full, box.exports);
  return box.exports;
}

const B05 = path.join(ROOT, "B05_Profile");
const { addsAtOnce, finishAdd, FORD_WAIT_NOTICE } = loadTs(
  path.join(B05, "B05_Profile_UI_Structures_Panel_AddAt.ts"),
);
const { fillFordHeights, waitsFordHeight } = loadTs(
  path.join(B05, "B05_Profile_UI_Drainage_Ford_Fill.ts"),
);
const { fordHeightM } = loadTs(
  path.join(ROOT, "A00_Common", "design", "design_structure_ford_calc.ts"),
);

// 동작 = 정의 종류 덧칸(앱의 `withDefinition` 과 같음 · 323-7 종류 키 대신 동작 이름)
const DEFINED = JSON.parse(
  fs.readFileSync(path.join(ROOT, "resources", "master_template", "구조물정의.json"), "utf8"),
);
const type = (type_id) => ({
  type_id,
  group: "A",
  managed_by: "pipe_points",
  behaviors: DEFINED.종류?.[type_id]?.동작 ?? [],
});

/** 우클릭 → 바로 추가 — 관 지점 정본에 한 번 넘기고 그 측점 관을 고름 · 알림 한 줄. */
async function rightClick(typeId) {
  toasts.length = 0;
  const picked = [];
  let commits = 0;
  const done = await finishAdd({
    type: type(typeId),
    anchorM: 120,
    structures: [],
    commit: async () => void commits++,
    pick: {
      selectById: (id) => picked.push(["id", id]),
      selectPipeByChainage: (at) => picked.push(["pipe", at]),
    },
  });
  return { done, commits, picked, toasts: [...toasts] };
}

/** 재계산 응답 한 번 — 응답 관 목록에 기다리던 높이를 얹은 결과. */
function respond(points, basins, pending) {
  const filled = fillFordHeights(points, basins, pending);
  return {
    filled,
    heights: points.map((p) => p.options?.ford_height_m ?? null),
    pending: [...pending],
  };
}

(async () => {
  const flow = 8.0;
  // 첫 응답은 유량 없음 → 빈칸 · 둘째 응답에 유량 → 그 항목에 채움(폭 = 항목 값)
  const pendingA = new Set([120]);
  const pointsA = () => [
    { chainage_m: 120.2, facility: "ford_bridge", options: { ford_width_m: 10 } },
  ];
  const noFlow = respond(pointsA(), [{ chainage_m: 120.2, design_flow_m3s: null }], pendingA);
  const withFlow = respond(pointsA(), [{ chainage_m: 120.2, design_flow_m3s: flow }], pendingA);
  // 손 값은 안 덮음
  const pendingB = new Set([300]);
  const hand = respond(
    [
      {
        chainage_m: 300,
        facility: "ford_pavement",
        options: { ford_width_m: 5, ford_height_m: 0.5 },
      },
    ],
    [{ chainage_m: 300, design_flow_m3s: flow }],
    pendingB,
  );
  // 기다리지 않는 측점(옛 세월교)의 빈 높이는 그대로 · 폭 없으면 기본 폭
  const pendingC = new Set([50]);
  const other = respond(
    [
      { chainage_m: 50, facility: "ford_pavement", options: {} },
      { chainage_m: 80, facility: "ford_bridge", options: { ford_width_m: 10 } },
    ],
    [
      { chainage_m: 50, design_flow_m3s: flow },
      { chainage_m: 80, design_flow_m3s: flow },
    ],
    pendingC,
  );
  // 종류가 바뀌었거나 관이 사라짐 → 그만 기다림
  const pendingD = new Set([10, 20]);
  const gone = respond([{ chainage_m: 10, facility: "pipe", options: {} }], [], pendingD);

  const out = {
    once: {
      fordBridge: addsAtOnce(type("ford_bridge"), []),
      fordPavement: addsAtOnce(type("ford_pavement"), []),
      pavement: addsAtOnce(
        {
          type_id: "pavement_concrete",
          managed_by: null,
          behaviors: DEFINED.종류?.pavement_concrete?.동작 ?? [],
        },
        [],
      ),
    },
    bridge: await rightClick("ford_bridge"),
    paveRc: await rightClick("ford_pavement"),
    pipe: await rightClick("pipe"),
    notice: FORD_WAIT_NOTICE,
    waits: {
      bridgeEmpty: waitsFordHeight("ford_bridge", { ford_width_m: 10 }),
      paveEmpty: waitsFordHeight("ford_pavement", undefined),
      bridgeHand: waitsFordHeight("ford_bridge", { ford_height_m: 0.4 }),
      pipe: waitsFordHeight("pipe", {}),
    },
    noFlow,
    withFlow,
    hand,
    other,
    gone,
    need: { w10: fordHeightM(flow, 10), w5: fordHeightM(flow, 5) },
  };
  process.stdout.write(JSON.stringify(out));
})();