Files
Aislo/common_util/common_util_show_digits.ts
T
eomsangdonandClaude Opus 5.5 aa36c4fb6b feat(859-3): 보이는 수 자릿수 규칙 한 쌍 — 줄 쌓기 화면 · 서버 계산서 글(셈 · 금액 그대로)
- 규칙 한 벌 = common_util_show_digits.ts ↔ master_doc_digits.py(짝 · 거울 시험 test_859_3)
  표 값 = 고른 줄의 원문 글자 자리(끝 0 살림 · 서버 표 캐시에 줄마다 `자리` 실음) ·
  식 값 = Q 3 · n 2 · cm 3(8-1 주①) › 원 단위 · 비목 이름 = 소수 한 자리 › 그 밖 유효숫자 3(소수 2~6) ·
  입력 · 요소 = 자료 그대로 · 만약으로 고른 기호 하나인 식은 그 값의 갈래를 따름
- 줄 쌓기 오른쪽(공식 줄 · 값 묶음 · 금액 줄 수량 · 단가 식 · 결과) · 왼쪽 값 · 작업량 줄 · M02 계산서 글
- test_845_2 기대 글 고침(노무비 계수 0.208333 → 0.208 — 뜻한 바뀜 · 금액 59,020.2 그대로)
- 관련 시험 + 관문 256 통과 · typecheck 0

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-18 21:55:48 +09:00

155 lines
7.2 KiB
TypeScript

/* =============================================================================
* common_util_show_digits.ts
* 보이는 수의 자릿수 규칙 한 벌(PLAN 859-3 · 856-5 · 요구 898 · 902) — 셈 값 · 저장 값 · 금액은 그대로 · 그리는 글자만
* ⚠ 짝 = resources/master_data/scripts/master_doc_digits.py(같은 규칙 · 한쪽을 고치면 다른 쪽도) ·
* 거울 시험 resources/tester/test_859_3_show_digits.py
* 갈래(`digitKind`) = 문서 식 줄 → 「식」 · 변수 연결 표 → 「표」 · 입력 · 선택 → 「입력」 · 그 밖(요소 · 단가산출) → 「요소」
* 규칙(자리 값은 `RULE` 한 곳):
* 표 = 고른 표 줄의 원문 글자 자리(끝 0 살림 — 건설 · 산림 1-2-2 1 [주]② 「항목에서 제시한 소수자리 우선」 ·
* 서버가 표 캐시에 줄마다 `자리` 를 실음) · 글자 자리를 모르면(끝 0 빠진 자료 · 사용자가 바꾼 값) 자료 수 그대로
* 식 = 기호 Q 3 · n 2 · cm 3 자리(건설 8-1 [주]① 계산값의 맺음) ›
* 단위가 원(원/…) · 비목 이름(노무비 · 재료비 · 경비)이면 소수 한 자리(1-2-2 2 「일위대가표의 금액란 0.1 원」 준용) ›
* 그 밖 = 유효숫자 3 · 소수 최소 2 · 최대 6(1-2-2 3 시공단위 품 표 근사 · 정수는 정수)
* 입력 · 요소 = 자료 수 그대로(소수 여섯 자리까지 · 끝 0 뗌 — `eqText`)
* 수 꼴 = 천 단위 쉼표 · 반올림(Intl — 짧은 10 진 글 기준 0.5 올림) · 화면 · fetch 없음
* ========================================================================== */
import { varId, type DocVar, type FormulaDoc } from "./common_util_formula_doc";
import { findRow, type DocTable } from "./common_util_formula_doc_table";
import { evalNode, tryParse, type Values } from "./common_util_formula_doc_view";
/** 자리 값 표 — 사용자 확정 값이 바뀌면 여기만 고침(짝 PY `RULE`) */
export const RULE = {
/** 입력 · 요소 · 자리 모르는 표 값 = 최대 자리(끝 0 뗌) */
plain: 6,
/** 건설 8-1 [주]① — 식이 낸 값 · 기호 그대로 */
symbol: { Q: 3, n: 2, cm: 3 } as Record<string, number>,
/** 원 단위 중간 값(율 줄 단가 · 원/… 식 값) */
money: 1,
/** 단위 없는 비목 값(기계 시간당 식) = 원 */
moneyNames: ["노무비", "재료비", "경비"],
/** 그 밖 식 값 — 유효숫자 · 소수 최소(정수는 정수) · 최대 */
sig: 3,
min: 2,
max: 6,
};
export type DigitKind = "식" | "표" | "입력" | "요소";
/** 서버 표 캐시 줄마다 원문 글자 자리(끝 0 있는 칸만) — `master_doc_record` 가 실음 */
export type PlacedTable = DocTable & { 자리?: (Record<string, number> | null)[] | null };
const formats = new Map<string, Intl.NumberFormat>();
/** 소수 `hi` 자리 반올림 · 끝 0 은 `lo` 자리까지 뗌 · 천 단위 쉼표 */
export function fmt(n: number, lo: number, hi: number): string {
const k = `${lo}:${hi}`;
let f = formats.get(k);
if (!f) {
f = new Intl.NumberFormat("ko-KR", { minimumFractionDigits: lo, maximumFractionDigits: hi });
formats.set(k, f);
}
return f.format(n);
}
/** 짧은 10 진 글의 [소수 자리, 맨 앞 자리 지수] — 0.0278 → [4, -2] */
function digits(n: number): [number, number] {
const [m, e] = Math.abs(n).toExponential().split("e");
const exp = Number(e);
const frac = (m.split(".")[1] ?? "").length;
return [Math.max(0, frac - exp), exp];
}
/** 표 값의 원문 글자 자리 — 지금 조건으로 고른 줄의 그 칸 · 값이 그 줄 값과 같을 때만(사용자가 바꾼 값 = undefined) */
export function tablePlaces(
v: DocVar | undefined,
value: unknown,
vals: Values,
tableOf?: (ref: string) => PlacedTable | null | undefined,
): number | undefined {
const k = v?.연결;
const ref = String(k?.표 ?? "");
const col = k?.칸;
if (!tableOf || !ref || !col || ref.includes("{")) return undefined;
const 조건: Record<string, unknown> = {};
for (const [c, t] of Object.entries(k?.조건 ?? {})) {
const n = tryParse(t);
if (n) 조건[c] = evalNode(n, vals);
}
try {
const t = tableOf(ref);
if (!t?.줄) return undefined;
const row = findRow(t, 조건, col);
if (typeof row[col] !== "number" || row[col] !== value) return undefined;
return t.자리?.[t.줄.indexOf(row)]?.[col] ?? undefined;
} catch {
return undefined;
}
}
/** 값 갈래 — 식 · 표 · 입력 · 요소 */
export function digitKind(doc: Pick<FormulaDoc, "식">, name: string, v?: DocVar): DigitKind {
if ((doc.식 ?? []).some((x) => String(x.기호 ?? "") === name)) return "식";
const kind = v?.연결?.갈래;
if (kind === "표") return "표";
if (kind === "입력" || kind === "선택") return "입력";
return v ? "요소" : "식";
}
/** 보이는 수 글 — `places` = 표 원문 글자 자리(모르면 없음) · 수가 아니면 글 그대로 */
export function showDigits(
value: unknown,
kind: DigitKind = "요소",
name = "",
unit = "",
places?: number,
): string {
if (value === null || value === undefined || value === "") return "";
if (typeof value !== "number" || !Number.isFinite(value)) return String(value);
const [own, exp] = digits(value);
if (kind === "표") {
const p = Math.max(places ?? 0, own);
return p <= RULE.plain ? fmt(value, p, p) : fmt(value, 0, RULE.plain);
}
if (kind !== "식") return fmt(value, 0, RULE.plain);
if (Object.prototype.hasOwnProperty.call(RULE.symbol, name))
return fmt(value, 0, RULE.symbol[name]);
if (unit.trim().startsWith("원") || RULE.moneyNames.includes(name))
return fmt(value, 0, RULE.money);
if (Number.isInteger(value)) return fmt(value, 0, 0);
const hi = Math.max(RULE.min, Math.min(RULE.max, RULE.sig - 1 - exp));
return fmt(value, RULE.min, hi);
}
/** 값이 온 기호 — 식 줄이 기호 하나(만약 = 지금 탄 갈래)면 그 기호로 따라감(K = 만약(K_입력 > 0, K_입력, K_2) → K_2) */
export function digitSource(doc: Pick<FormulaDoc, "식">, name: string, vals: Values): string {
const lines = new Map((doc.식 ?? []).map((x) => [String(x.기호 ?? ""), x.식]));
let at = name;
for (let hop = 0; hop < 8 && lines.has(at); hop++) {
let n = tryParse(lines.get(at));
while (n && n[0] === "call" && n[1] === "만약" && n[2].length === 3) {
const t = evalNode(n[2][0], vals);
if (t === undefined) return at;
n = n[2][t ? 1 : 2];
}
if (!n || n[0] !== "var" || n[1] === at) return at;
at = n[1];
}
return at;
}
/** 문서 기호 값 글 한 벌 — 값이 온 기호의 갈래 · 표 원문 글자 자리 · 단위(`unit` = 부르는 쪽이 정한 단위) */
export function showValue(
doc: Pick<FormulaDoc, "식" | "변수">,
name: string,
value: unknown,
vals: Values,
tableOf?: (ref: string) => PlacedTable | null | undefined,
unit?: string,
): string {
const src = digitSource(doc, name, vals);
const v = (doc.변수 ?? []).find((x) => varId(x) === src);
const kind = digitKind(doc, src, v);
const places = kind === "표" ? tablePlaces(v, value, vals, tableOf) : undefined;
return showDigits(value, kind, src, unit ?? String(v?.단위 ?? ""), places);
}