pre-bemis

lib/reasonCatalog.ts

@@ -0,0 +1,200 @@
+import { readFile } from "fs/promises";
+import path from "path";
+
+type AnyRecord = Record<string, unknown>;
+
+export type ReasonCatalogKind = "downtime" | "scrap";
+
+export type ReasonCatalogDetail = {
+  id: string;
+  label: string;
+};
+
+export type ReasonCatalogCategory = {
+  id: string;
+  label: string;
+  details: ReasonCatalogDetail[];
+};
+
+export type ReasonCatalog = {
+  version: number;
+  downtime: ReasonCatalogCategory[];
+  scrap: ReasonCatalogCategory[];
+};
+
+function isPlainObject(value: unknown): value is AnyRecord {
+  return !!value && typeof value === "object" && !Array.isArray(value);
+}
+
+function canonicalId(input: unknown, fallback = "item") {
+  const text = String(input ?? "")
+    .normalize("NFD")
+    .replace(/[\u0300-\u036f]/g, "")
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, "-")
+    .replace(/^-+|-+$/g, "");
+  return text || fallback;
+}
+
+function buildReasonCode(categoryId: string, detailId: string) {
+  return `${canonicalId(categoryId)}__${canonicalId(detailId)}`.toUpperCase();
+}
+
+function toCategory(raw: unknown): ReasonCatalogCategory | null {
+  if (!isPlainObject(raw)) return null;
+  const labelRaw = String(raw.label ?? "").trim();
+  if (!labelRaw) return null;
+  const idRaw = String(raw.id ?? "").trim() || canonicalId(labelRaw, "category");
+  const detailsRaw =
+    (Array.isArray(raw.details) && raw.details) ||
+    (Array.isArray(raw.children) && raw.children) ||
+    (Array.isArray(raw.items) && raw.items) ||
+    [];
+
+  const details: ReasonCatalogDetail[] = [];
+  for (const detailRaw of detailsRaw) {
+    if (!isPlainObject(detailRaw)) continue;
+    const detailLabel = String(detailRaw.label ?? "").trim();
+    if (!detailLabel) continue;
+    const detailId = String(detailRaw.id ?? "").trim() || canonicalId(detailLabel, "detail");
+    details.push({ id: detailId, label: detailLabel });
+  }
+
+  if (!details.length) return null;
+  return { id: idRaw, label: labelRaw, details };
+}
+
+function normalizeKind(raw: unknown): ReasonCatalogCategory[] {
+  const arr =
+    (Array.isArray(raw) && raw) ||
+    (isPlainObject(raw) && Array.isArray(raw.categories) && raw.categories) ||
+    [];
+  const out: ReasonCatalogCategory[] = [];
+  for (const candidate of arr) {
+    const parsed = toCategory(candidate);
+    if (parsed) out.push(parsed);
+  }
+  return out;
+}
+
+export function normalizeReasonCatalog(raw: unknown): ReasonCatalog | null {
+  if (!isPlainObject(raw)) return null;
+  const downtime = normalizeKind(raw.downtime);
+  const scrap = normalizeKind(raw.scrap);
+  if (!downtime.length && !scrap.length) return null;
+  const versionNum = Number(raw.version);
+  const version = Number.isFinite(versionNum) ? Math.max(1, Math.trunc(versionNum)) : 1;
+  return {
+    version,
+    downtime,
+    scrap,
+  };
+}
+
+export function parseReasonCatalogMarkdown(markdown: string): ReasonCatalog {
+  const lines = markdown
+    .split(/\r?\n/)
+    .map((line) => line.trim())
+    .filter(Boolean);
+
+  const buckets: Record<ReasonCatalogKind, Map<string, ReasonCatalogCategory>> = {
+    downtime: new Map(),
+    scrap: new Map(),
+  };
+  let activeKind: ReasonCatalogKind = "downtime";
+
+  for (const line of lines) {
+    const lowered = line.toLowerCase();
+    if (lowered === "downtime") {
+      activeKind = "downtime";
+      continue;
+    }
+    if (lowered === "scrap") {
+      activeKind = "scrap";
+      continue;
+    }
+
+    const slash = line.indexOf("/");
+    if (slash < 1 || slash === line.length - 1) continue;
+
+    const categoryLabel = line.slice(0, slash).trim();
+    const detailLabel = line.slice(slash + 1).trim();
+    if (!categoryLabel || !detailLabel) continue;
+
+    const categoryId = canonicalId(categoryLabel, "category");
+    const detailId = canonicalId(detailLabel, "detail");
+
+    const existing =
+      buckets[activeKind].get(categoryId) ?? {
+        id: categoryId,
+        label: categoryLabel,
+        details: [] as ReasonCatalogDetail[],
+      };
+    if (!existing.details.some((d) => d.id === detailId)) {
+      existing.details.push({ id: detailId, label: detailLabel });
+    }
+    buckets[activeKind].set(categoryId, existing);
+  }
+
+  return {
+    version: 1,
+    downtime: [...buckets.downtime.values()],
+    scrap: [...buckets.scrap.values()],
+  };
+}
+
+let catalogPromise: Promise<ReasonCatalog> | null = null;
+
+export async function loadFallbackReasonCatalog() {
+  if (!catalogPromise) {
+    catalogPromise = readFile(path.join(process.cwd(), "downtime_menu.md"), "utf8")
+      .then((raw) => parseReasonCatalogMarkdown(raw))
+      .catch(() => ({ version: 1, downtime: [], scrap: [] }));
+  }
+  return catalogPromise;
+}
+
+export function flattenReasonCatalog(catalog: ReasonCatalog, kind: ReasonCatalogKind) {
+  return (catalog[kind] ?? []).flatMap((category) =>
+    category.details.map((detail) => ({
+      kind,
+      categoryId: category.id,
+      categoryLabel: category.label,
+      detailId: detail.id,
+      detailLabel: detail.label,
+      reasonCode: buildReasonCode(category.id, detail.id),
+      reasonLabel: `${category.label} > ${detail.label}`,
+    }))
+  );
+}
+
+export function findCatalogReason(
+  catalog: ReasonCatalog | null | undefined,
+  kind: ReasonCatalogKind,
+  categoryId: unknown,
+  detailId: unknown
+) {
+  if (!catalog) return null;
+  const catId = canonicalId(categoryId, "");
+  const detId = canonicalId(detailId, "");
+  if (!catId || !detId) return null;
+  const category = (catalog[kind] ?? []).find((c) => canonicalId(c.id, "") === catId);
+  if (!category) return null;
+  const detail = category.details.find((d) => canonicalId(d.id, "") === detId);
+  if (!detail) return null;
+  return {
+    categoryId: category.id,
+    categoryLabel: category.label,
+    detailId: detail.id,
+    detailLabel: detail.label,
+    reasonCode: buildReasonCode(category.id, detail.id),
+    reasonLabel: `${category.label} > ${detail.label}`,
+  };
+}
+
+export function toReasonCode(categoryId: unknown, detailId: unknown) {
+  const cat = canonicalId(categoryId, "");
+  const det = canonicalId(detailId, "");
+  if (!cat || !det) return null;
+  return buildReasonCode(cat, det);
+}