@isi-ui7/bos7-shared 0.2.0

package/src/form-numeric.ts

@@ -0,0 +1,173 @@
+export type DecimalParseResult =
+  | { ok: true; value: number; normalized: string; scale: number }
+  | { ok: false; reason: "invalid" | "too-many-decimals" };
+
+export type DecimalSanitizeOptions = {
+  maxFractionDigits?: number;
+  allowNegative?: boolean;
+};
+
+export type CurrencyPrecisionConfig = {
+  precisionByCurrency: Record<string, number>;
+  defaultPrecision?: number;
+};
+
+export type PhoneRule = {
+  minDigits: number;
+  maxDigits: number;
+  allowedPrefixes?: string[];
+};
+
+function assertFiniteNonNegativeInteger(value: number, label: string): void {
+  if (!Number.isInteger(value) || value < 0) {
+    throw new Error(`Invalid ${label}: ${String(value)}`);
+  }
+}
+
+function extractDecimalParts(raw: string, allowNegative: boolean) {
+  const trimmed = raw.trim().replace(/\s+/g, "").replace(/-/g, "");
+  if (!trimmed) return { sign: "" as const, integer: "", fraction: "", hasDecimalPoint: false };
+
+  let sign: "" | "-" = "";
+  let body = trimmed;
+  if (raw.trim().startsWith("+")) {
+    body = body.slice(0);
+  } else if (raw.trim().startsWith("-")) {
+    if (!allowNegative) return { sign: "" as const, integer: "", fraction: "", hasDecimalPoint: false, invalid: true };
+    sign = "-";
+  }
+
+  body = body.replace(/,/g, ".");
+  const decimalMatch = body.match(/^[0-9]*\.?[0-9]*$/);
+  if (!decimalMatch) return { sign: "" as const, integer: "", fraction: "", hasDecimalPoint: false, invalid: true };
+
+  const hasDecimalPoint = body.includes(".");
+  const [integerRaw = "", fractionRaw = ""] = body.split(".", 2);
+
+  return {
+    sign,
+    integer: integerRaw.replace(/\D/g, ""),
+    fraction: fractionRaw.replace(/\D/g, ""),
+    hasDecimalPoint,
+  };
+}
+
+export function sanitizeDecimalInput(raw: string, options: DecimalSanitizeOptions = {}): string {
+  const parts = extractDecimalParts(raw, Boolean(options.allowNegative));
+  if ("invalid" in parts) return "";
+
+  const { sign, hasDecimalPoint } = parts;
+  let { integer, fraction } = parts;
+  if (!integer && !fraction) return "";
+
+  if (!integer) integer = "0";
+  if (typeof options.maxFractionDigits === "number") {
+    fraction = fraction.slice(0, options.maxFractionDigits);
+  }
+
+  if (fraction) return `${sign}${integer}.${fraction}`;
+  return hasDecimalPoint ? `${sign}${integer}.` : `${sign}${integer}`;
+}
+
+export function parseDecimalStrict(raw: string, options: DecimalSanitizeOptions = {}): DecimalParseResult {
+  const parts = extractDecimalParts(raw, Boolean(options.allowNegative));
+  if ("invalid" in parts) return { ok: false, reason: "invalid" };
+
+  const { integer, fraction, sign, hasDecimalPoint } = parts;
+  if (!integer && !fraction) return { ok: true, value: 0, normalized: "", scale: 0 };
+
+  const scale = fraction.length;
+  if (typeof options.maxFractionDigits === "number" && scale > options.maxFractionDigits) {
+    return { ok: false, reason: "too-many-decimals" };
+  }
+
+  const normalized = `${sign}${integer || "0"}${scale > 0 || hasDecimalPoint ? `.${fraction}` : ""}`;
+  const value = Number(normalized);
+  if (!Number.isFinite(value)) return { ok: false, reason: "invalid" };
+  return { ok: true, value, normalized, scale };
+}
+
+export function getCurrencyPrecision(currencyCode: string, config: CurrencyPrecisionConfig): number {
+  const explicit = config.precisionByCurrency[currencyCode];
+  if (typeof explicit === "number") {
+    assertFiniteNonNegativeInteger(explicit, `precision for ${currencyCode}`);
+    return explicit;
+  }
+  if (config.defaultPrecision === undefined) {
+    throw new Error(`Missing default currency precision for ${currencyCode}`);
+  }
+  assertFiniteNonNegativeInteger(config.defaultPrecision, "default currency precision");
+  return config.defaultPrecision;
+}
+
+export function formatCurrencyAmount(
+  value: number,
+  currencyCode: string,
+  config: CurrencyPrecisionConfig,
+  locale?: "id" | "en",
+): string {
+  const digits = getCurrencyPrecision(currencyCode, config);
+  const nloc = locale === "en" ? "en-US" : "id-ID";
+  try {
+    return new Intl.NumberFormat(nloc, {
+      style: "currency",
+      currency: currencyCode,
+      minimumFractionDigits: digits,
+      maximumFractionDigits: digits,
+    }).format(value);
+  } catch {
+    const formatted = new Intl.NumberFormat(nloc, {
+      minimumFractionDigits: digits,
+      maximumFractionDigits: digits,
+    }).format(value);
+    return `${currencyCode} ${formatted}`.trim();
+  }
+}
+
+export function normalizePhoneInput(raw: string): string {
+  const trimmed = raw.trim();
+  if (!trimmed) return "";
+  const digits = trimmed.replace(/\D/g, "");
+  if (!digits) return trimmed.startsWith("+") ? "+" : "";
+  return trimmed.startsWith("+") ? `+${digits}` : digits;
+}
+
+export function isValidPhoneInput(value: string, rule: PhoneRule): boolean {
+  const normalized = normalizePhoneInput(value);
+  if (!normalized) return false;
+  if (!/^\+?\d+$/.test(normalized)) return false;
+  const digitsOnly = normalized.startsWith("+") ? normalized.slice(1) : normalized;
+  if (digitsOnly.length < rule.minDigits || digitsOnly.length > rule.maxDigits) return false;
+  if (rule.allowedPrefixes?.length) {
+    return rule.allowedPrefixes.some((prefix) => normalized.startsWith(prefix));
+  }
+  return true;
+}
+
+export function normalizePhoneForSave(raw: string, rule: PhoneRule): string {
+  const normalized = normalizePhoneInput(raw);
+  if (!normalized) return "";
+  if (!isValidPhoneInput(normalized, rule)) return normalized;
+  return normalized;
+}
+
+// ── Pre-built defaults ─────────────────────────────────────────────────────────
+
+/** Indonesian phone: 08xx / +62xx, 10–15 digits. */
+export const INDONESIA_PHONE_RULE: PhoneRule = {
+  minDigits: 10,
+  maxDigits: 15,
+  allowedPrefixes: ["08", "+62"],
+};
+
+/** International phone: any valid digit sequence, 7–15 digits, no prefix restriction. */
+export const GLOBAL_PHONE_RULE: PhoneRule = {
+  minDigits: 7,
+  maxDigits: 15,
+};
+
+/** Standard currency precision for Indonesian banking (IDR 2 dec, USD 4 dec). */
+export const INDONESIA_CURRENCY_CONFIG: CurrencyPrecisionConfig = {
+  precisionByCurrency: { IDR: 2, USD: 4 },
+  defaultPrecision: 2,
+};

package/src/form-renderer-utils.ts

@@ -0,0 +1,139 @@
+import type { ApiPath, FieldValidation, FormField, FormLayout, FormMode } from "./form-types";
+import type { BosSharedLabels } from "./i18n";
+
+// Non-React fallback — callers (React components) should always pass i18n from useBosSharedI18n().
+const FALLBACK_I18N = {
+  validRequired: (label: string) => `${label} wajib diisi`,
+  validMinLength: (n: number) => `Minimal ${n} karakter`,
+  validMaxLength: (n: number) => `Maksimal ${n} karakter`,
+  validMin: (n: number) => `Nilai minimal ${n}`,
+  validMax: (n: number) => `Nilai maksimal ${n}`,
+  validPattern: "Format tidak valid",
+} as const;
+
+// ── Path resolution ───────────────────────────────────────────────────────────
+
+export function resolveApiPath(path: ApiPath, params: Record<string, string>): string {
+  if (typeof path === "function") return path(params);
+  return path.replace(/\{([^}]+)\}/g, (_, key: string) => params[key] ?? "");
+}
+
+// ── Validation ────────────────────────────────────────────────────────────────
+
+function msg(rule: unknown, fallback: string): string {
+  if (Array.isArray(rule) && typeof rule[1] === "string") return rule[1] as string;
+  if (typeof rule === "string") return rule;
+  return fallback;
+}
+
+function ruleVal<T>(rule: T | [T, string]): T {
+  return Array.isArray(rule) ? (rule[0] as T) : rule;
+}
+
+type ValidationI18n = Pick<
+  BosSharedLabels,
+  | "validRequired"
+  | "validMinLength"
+  | "validMaxLength"
+  | "validMin"
+  | "validMax"
+  | "validPattern"
+>;
+
+export function runFieldValidation<TData extends Record<string, unknown>>(
+  fields: FormField<TData>[],
+  data: TData,
+  mode: FormMode,
+  i18n?: Partial<ValidationI18n>,
+): Partial<Record<keyof TData, string>> {
+  const l: ValidationI18n = { ...FALLBACK_I18N, ...i18n };
+  const errors: Partial<Record<keyof TData, string>> = {};
+
+  for (const field of fields) {
+    const v: FieldValidation<TData> | undefined = field.validation;
+    if (!v) continue;
+
+    const isHidden = typeof field.hidden === "function"
+      ? field.hidden(mode, data)
+      : Boolean(field.hidden);
+    if (isHidden) continue;
+
+    if (field.mode) {
+      const allowed = Array.isArray(field.mode) ? field.mode : [field.mode];
+      if (!allowed.includes(mode)) continue;
+    }
+
+    const value = data[field.key];
+    const key = field.key;
+
+    const isEmpty = value === null || value === undefined || value === ""
+      || (typeof value === "string" && !value.trim());
+
+    if (v.required) {
+      if (isEmpty) {
+        errors[key] = msg(v.required, l.validRequired(String(field.label)));
+        continue;
+      }
+    }
+
+    if (isEmpty) continue;
+
+    if (!errors[key] && v.minLength !== undefined && typeof value === "string") {
+      if (value.length < ruleVal(v.minLength))
+        errors[key] = msg(v.minLength, l.validMinLength(ruleVal(v.minLength)));
+    }
+    if (!errors[key] && v.maxLength !== undefined && typeof value === "string") {
+      if (value.length > ruleVal(v.maxLength))
+        errors[key] = msg(v.maxLength, l.validMaxLength(ruleVal(v.maxLength)));
+    }
+    if (!errors[key] && v.min !== undefined && typeof value === "number") {
+      if (value < ruleVal(v.min))
+        errors[key] = msg(v.min, l.validMin(ruleVal(v.min)));
+    }
+    if (!errors[key] && v.max !== undefined && typeof value === "number") {
+      if (value > ruleVal(v.max))
+        errors[key] = msg(v.max, l.validMax(ruleVal(v.max)));
+    }
+    if (!errors[key] && v.pattern !== undefined && typeof value === "string") {
+      const regex = Array.isArray(v.pattern) ? v.pattern[0] : v.pattern;
+      if (!regex.test(value)) errors[key] = msg(v.pattern, l.validPattern);
+    }
+    if (!errors[key] && v.custom) {
+      const m = v.custom(value, data);
+      if (m) errors[key] = m;
+    }
+    if (!errors[key] && v.validators?.length) {
+      for (const fn of v.validators) {
+        const m = fn(value, data);
+        if (m) { errors[key] = m; break; }
+      }
+    }
+  }
+
+  return errors;
+}
+
+// ── Layout helpers ────────────────────────────────────────────────────────────
+
+export function collectAllFields<TData extends Record<string, unknown>>(
+  layout: FormLayout<TData>,
+): FormField<TData>[] {
+  const sections = layout.type === "single-page"
+    ? layout.sections
+    : layout.pages.flatMap((p) => p.sections);
+  return sections.flatMap((s) => s.fields);
+}
+
+export function collectPageFields<TData extends Record<string, unknown>>(
+  layout: FormLayout<TData>,
+  pageIndex: number,
+): FormField<TData>[] {
+  if (layout.type === "single-page") return collectAllFields(layout);
+  return (layout.pages[pageIndex]?.sections ?? []).flatMap((s) => s.fields);
+}
+
+export function getLayoutPageCount<TData extends Record<string, unknown>>(
+  layout: FormLayout<TData>,
+): number {
+  return layout.type === "single-page" ? 1 : layout.pages.length;
+}