Aislo/resources/tester/helper_m02_hopyo_check.cjs

/* M02 일위대가 실무자료 확인 창(338-3) 헬퍼 — `Hopyo_Check` · `Hopyo_Choose` · `Hopyo_Ledger` · `Hopyo_Sheet`
 * 도우미와 `Hopyo_Api` 길을 트랜스파일해 Node 로 돌림 · fetch 대역이 부른 길 · 몸을 모음 · sessionStorage 대역 ·
 * stdin = {lines, rows, ledger} · stdout = {check, choose, ledger, sheet, calls, pick} JSON. */
const fs = require("fs");
const path = require("path");
const ts = require(path.join(__dirname, "..", "..", "config", "node_modules", "typescript"));

const ROOT = path.join(__dirname, "..", "..");
const STUBS = { "@config/config_frontend": { API_BASE_URL: "/api" } };
// DOM · 모듈 메타를 쓰는 창은 대역(도우미 · 길만 시험)
const STUB_FILES = [
  "M02_MasterTemplete_Labor_Pick",
  "M02_Material_Pick",
  "M02_MasterTemplete_Labor_Api",
  "M02_MasterTemplete_Labor_Input",
  "M01_MasterData_UI_LogicLab_Source",
];
const opened = [];
const stub = new Proxy(
  {},
  {
    get: (_t, k) =>
      k === "currentLanguageIndex"
        ? () => 0
        : k === "openModal"
          ? (o) => opened.push(o.title)
          : () => {},
  },
);
const cache = new Map();
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 (STUB_FILES.some((name) => request.endsWith(name))) return stub;
    if (request.startsWith(".") && !request.endsWith(".css"))
      return loadTs(`${path.resolve(path.dirname(full), request)}.ts`);
    return stub;
  };
  new Function("exports", "module", "require", js)(box.exports, box, localRequire);
  return box.exports;
}

const store = new Map();
global.sessionStorage = {
  getItem: (k) => (store.has(k) ? store.get(k) : null),
  setItem: (k, v) => store.set(k, String(v)),
  removeItem: (k) => store.delete(k),
};

let out0 = null;
(async () => {
  const input = JSON.parse(fs.readFileSync(0, "utf8"));
  const calls = [];
  global.fetch = async (url, init = {}) => {
    calls.push({
      url,
      method: init.method ?? "GET",
      body: init.body ? JSON.parse(init.body) : null,
    });
    const body = url.includes("/hopyo-picks") || url.includes("/hopyo-ledger") ? { 줄: [] } : {};
    return { status: 200, ok: true, json: async () => body };
  };
  const M02 = path.join(ROOT, "M02_MasterTemplete");
  const check = loadTs(path.join(M02, "M02_MasterTemplete_Hopyo_Check.ts"));
  const choose = loadTs(path.join(M02, "M02_MasterTemplete_Hopyo_Choose.ts"));
  const ledger = loadTs(path.join(M02, "M02_MasterTemplete_Hopyo_Ledger.ts"));
  const sheet = loadTs(path.join(M02, "M02_MasterTemplete_Hopyo_Sheet.ts"));
  const api = loadTs(path.join(M02, "M02_MasterTemplete_Hopyo_Api.ts"));
  const pick = loadTs(path.join(M02, "M02_MasterTemplete_Hopyo_Pick.ts"));
  if (input.real) {
    // 실물 맞춤 응답(338-4) — 서버 줄을 그대로 먹여 체크 · 몸 · 빠질 줄 · 품 비교 · 글
    const lines = input.real;
    const d = check.loadDraft("real");
    out0 = {
      body: check.bodyOf(lines, d),
      leftOut: check.leftOut(lines, d),
      sure: check.sureLines(lines, d).map((l) => l.차례),
      lines: lines.map((l) => {
        const p = check.partsOf(l, d)[0];
        return {
          이름: l.이름,
          상태: l.맞춤.상태,
          checkable: check.checkable(l, d),
          checked: check.isChecked(l, d),
          compare: check.compareText(l.맞춤.품),
          qty: choose.qtyText(l.맞춤.품?.엑셀),
          target: choose.targetText(p),
          inputs: p ? choose.inputsText(p.입력값 ?? {}, p.못읽음 ?? [], p.출처 ?? {}) : "",
          cands: (l.맞춤.후보 ?? []).map((c) => [
            choose.targetText(c),
            c.판정 ?? "",
            choose.basisTag(c.근거),
          ]),
        };
      }),
    };
    process.stdout.write(JSON.stringify(out0));
    return;
  }
  const { lines } = input;
  const scope = { layer: "personal", owner: null };
  const key = check.draftKey(scope, "HP-000001", 3);

  // 서버 제안 그대로 → 사용자가 만짐(체크 끔 · 뺌 · 고른 대상) → 캐시 다시 읽음
  const fresh = check.loadDraft(key);
  const suggested = check.bodyOf(lines, fresh);
  const d = check.loadDraft(key);
  d.체크[1] = false; // 맞음 줄 체크 끔
  d.뺌[3] = "우리에 없음";
  d.체크[3] = true;
  d.대상[4] = [{ 로직: "GF000211", 이름: "고임돌", 입력값: { 유형: "보통" }, 배: 0.1, 몫: 0.1 }];
  d.체크[4] = true;
  check.saveDraft(key, d);
  const again = check.loadDraft(key);
  const ask = check.newest();
  const a = ask(1);
  const b = ask(1);
  const c = ask(2);
  const out = {
    check: {
      key,
      suggested,
      edited: check.bodyOf(lines, again),
      leftOut: check.leftOut(lines, again),
      checkable: lines.map((l) => check.checkable(l, fresh)),
      sure: check.sureLines(lines, fresh).map((l) => l.차례),
      compare: check.compareText(lines[1].맞춤.품),
      compareMany: check.compareText(lines[3].맞춤.품),
      toTarget: [
        check.toTarget({ 호표: 46, 이름: "고화매트", 입력값: {}, 배: 2.3 }),
        check.toTarget({ 자재: "MT1", 이름: "레미콘", 입력값: {}, 배: 1, 몫: null }),
      ],
      newest: [a(), b(), c()],
      dropped: (check.dropDraft(key), store.has(key)),
    },
    choose: {
      hint: [
        choose.searchHint({
          이름: "레미콘타설(장비사용)",
          근거: { 출처: [["건설품셈", "6-1-1"]], 직종: [], 행: [1, 1] },
        }),
        choose.searchHint({ 이름: "(소)고임돌 채집 및 운반" }),
      ],
      picked: choose.pickedTargets([
        { c: { 로직: "GC000206" }, 몫: null },
        { c: { 로직: "GF000211" }, 몫: 0.1 },
      ]),
      inputs: choose.inputsText({ 소량감률: 50, 지역: "서울" }, ["측압"], {
        소량감률: "블록",
        지역: "자동값",
      }),
      word: [choose.builtWord({ 다시씀: false }), choose.builtWord({ 다시씀: true })],
      qty: choose.qtyText(lines[1].맞춤.품.엑셀),
      target: choose.targetText({ 호표: 46, 단위: "㎡" }),
    },
    ledger: (() => {
      const rows = input.ledger;
      const edits = {
        "가|b|m3": null, // 지움
        "나||m3": { 원래: { 품명: "나", 규격: "", 단위: "m3" }, 갈래: "안 씀", 짝: [] },
        "다||개": ledger.entryOf(rows[2]), // 위 층 → 내 층
      };
      const merged = ledger.mergeRows(rows, edits, { layer: "personal", owner: "7/42" });
      return {
        key: ledger.ledgerKey({ layer: "company", owner: "7" }),
        merged: merged.map((r) => [r.열쇠, r.층, r.고침, !!r.고친, r.갈래]),
        filter: ledger.filterRows(merged, "MT1", "").map((r) => r.열쇠),
        kind: ledger.filterRows(merged, "", "안 씀").map((r) => r.열쇠),
        pair: ledger.pairText({ 로직: "GC000198", 입력값: { 소량감률: 50 }, 배: 1, 몫: 0.1 }),
        entry: ledger.entryOf({ ...rows[0], 갈래: "우리에 없음" }),
      };
    })(),
    sheet: {
      order: sheet.buildOrder([
        { 번: 45, 아래: [46] },
        { 번: 46, 아래: [] },
        { 번: 3, 아래: [] },
        { 번: 7, 아래: [8] },
        { 번: 8, 아래: [7] },
      ]),
    },
  };
  // 길 — 만들기(줄 · 통째) · 호표 하나(만들 층) · 미리 셈 · 장부
  const from = { 층: "system", 주인: null, 키: "HP-000001", 번: 3 };
  const target = { layer: "company", owner: "7" };
  await api.buildHopyo(target, from, suggested);
  await api.buildHopyo(target, from, [], { 대상: [{ 로직: "GF000225", 배: 1 }] });
  await api.readHopyoOne({ layer: "system", owner: null }, "HP-000001", 3, target);
  await api.guessHopyo(scope, "HP-000001", 3, 4, [
    { 로직: "GF000211", 입력값: {}, 배: 0.1, 몫: 0.1 },
  ]);
  await api.readLedger(target);
  await api.saveLedger(target, { "가|b|m3": null });
  out.calls = calls.splice(0);
  // [로직 추가] 실무 호표 — 확인된 것 = 바로 참조 · 아닌 것 = 확인 창(만들기 길 안 부름)
  const picked = [];
  const lib = {
    layer: "company",
    owner: "7",
    pick: (ref, name, alias) => picked.push({ ref, name, alias }),
  };
  for (const row of input.rows) await pick.pickHopyo(row, lib);
  await new Promise((r) => setTimeout(r, 0));
  out.pick = { picked, calls: calls.splice(0), opened };
  process.stdout.write(JSON.stringify(out));
})().catch((error) => {
  process.stderr.write(String(error?.stack ?? error));
  process.exit(1);
});