@portnet/ui 6.0.1 → 6.0.3

package/dist/v2/utils/fmtMoney.js

@@ -3,7 +3,7 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports["default"] = fmtMoney;
+exports.default = fmtMoney;
 /**
  * fmtMoney — format a number with locale-aware grouping.
  *
@@ -52,33 +52,31 @@ exports["default"] = fmtMoney;
  * an unmatched-but-valid tag negotiates down to fr-FR instead of to the host.
  * The `try/catch` is still required for genuinely malformed input.
  */
-var FALLBACK_LOCALE = "fr-FR";
-function fmtMoney(n) {
-  var currency = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : "";
-  var opts = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+const FALLBACK_LOCALE = "fr-FR";
+function fmtMoney(n, currency = "", opts = {}) {
   if (n == null || n === "") return "—";
-  var num = typeof n === "number" ? n : Number(n);
+  const num = typeof n === "number" ? n : Number(n);
   if (!Number.isFinite(num)) return "—";
-  var locale = opts.locale || FALLBACK_LOCALE;
-  var formatOpts = {};
+  const locale = opts.locale || FALLBACK_LOCALE;
+  const formatOpts = {};
   if (opts.minimumFractionDigits != null) {
     formatOpts.minimumFractionDigits = opts.minimumFractionDigits;
   }
   if (opts.maximumFractionDigits != null) {
     formatOpts.maximumFractionDigits = opts.maximumFractionDigits;
   }
-  var formatted;
+  let formatted;
   try {
     /* Requested locale first, fr-FR as the declared next preference — see
      * FALLBACK_LOCALE. A resolvable request ("en-US") still wins outright; an
      * unmatched-but-well-formed tag lands on fr-FR rather than on the host's
      * default locale. */
     formatted = new Intl.NumberFormat([locale, FALLBACK_LOCALE], formatOpts).format(num);
-  } catch (_unused) {
+  } catch {
     /* Reached only for a STRUCTURALLY invalid tag (RangeError) or a non-string
      * value from an untyped host — negotiation cannot help there. */
     formatted = new Intl.NumberFormat(FALLBACK_LOCALE, formatOpts).format(num);
   }
-  return currency ? "".concat(formatted, " ").concat(currency) : formatted;
+  return currency ? `${formatted} ${currency}` : formatted;
 }
 //# sourceMappingURL=fmtMoney.js.map

package/dist/v2/utils/fmtMoney.js.map

@@ -1 +1 @@
-{"version":3,"file":"fmtMoney.js","names":["FALLBACK_LOCALE","fmtMoney","n","currency","arguments","length","undefined","opts","num","Number","isFinite","locale","formatOpts","minimumFractionDigits","maximumFractionDigits","formatted","Intl","NumberFormat","format","_unused","concat"],"sources":["../../../src/lib/v2/utils/fmtMoney.ts"],"sourcesContent":["/**\r\n * fmtMoney — format a number with locale-aware grouping.\r\n *\r\n * Returns \"—\" for null / empty / non-finite inputs (graceful empty\r\n * cells in tables — never \"NaN\" or \"∞\").\r\n *\r\n * Defaults to \"fr-FR\" for back-compat with v1 callers; pass `locale`\r\n * (BCP-47 tag) to format under any locale supported by the runtime\r\n * Intl.NumberFormat. Currency placement is a trailing suffix in the\r\n * locale-formatted number; future evolution toward `style:\"currency\"`\r\n * (locale-correct symbol position, proper RTL handling) is deliberately\r\n * deferred to avoid breaking consumers that grep on the suffix.\r\n *\r\n *   fmtMoney(1234567.5)                              → \"1 234 567,5\"\r\n *   fmtMoney(1234567.5, \"EUR\")                       → \"1 234 567,5 EUR\"\r\n *   fmtMoney(1234567.5, \"EUR\", { locale: \"en-US\" })  → \"1,234,567.5 EUR\"\r\n *   fmtMoney(1234.5,    \"\",    { minimumFractionDigits: 2 })\r\n *                                                    → \"1 234,50\"\r\n *   fmtMoney(null) / fmtMoney(\"abc\") / fmtMoney(Infinity) → \"—\"\r\n */\r\ntype FmtMoneyOptions = {\r\n  locale?: string;\r\n  minimumFractionDigits?: number;\r\n  maximumFractionDigits?: number;\r\n};\r\n\r\n/**\r\n * The locale every unresolvable request falls back to.\r\n *\r\n * ── WHY THIS IS NEGOTIATED, NOT JUST CAUGHT ─────────────────────────────\r\n *\r\n * The previous implementation relied ONLY on `try/catch`, on the assumption that\r\n * an unusable locale throws `RangeError`. It does not — and the gap was a live\r\n * defect, not a theoretical one:\r\n *\r\n *   `Intl.NumberFormat` throws only on a STRUCTURALLY INVALID tag. A tag that is\r\n *   well-formed but has no data does NOT throw — it negotiates, and with a single\r\n *   unmatched tag the negotiation lands on the RUNTIME DEFAULT LOCALE.\r\n *\r\n * `\"not-a-real-locale\"` is well-formed: `not` parses as a 3-letter language\r\n * subtag and `-a-real-locale` as a singleton `a` extension sequence. So it never\r\n * threw, the `catch` never ran, and the result was formatted in whatever locale\r\n * the host happened to default to. On a German or Spanish host that renders\r\n * `\"1.234,5\"` — dot grouping — inside a French application.\r\n *\r\n * That is a real consistency breach (Charter §09: a French UI formats numbers in\r\n * French), and it is invisible on a French dev machine, which is exactly why it\r\n * survived: the unit test caught it only because CI ran under a non-FR default.\r\n *\r\n * Listing the fallback as the SECOND preference makes the guarantee explicit:\r\n * an unmatched-but-valid tag negotiates down to fr-FR instead of to the host.\r\n * The `try/catch` is still required for genuinely malformed input.\r\n */\r\nconst FALLBACK_LOCALE = \"fr-FR\";\r\n\r\nexport default function fmtMoney(\r\n  n: number | string | null | undefined,\r\n  currency: string = \"\",\r\n  opts: FmtMoneyOptions = {}\r\n): string {\r\n  if (n == null || n === \"\") return \"—\";\r\n  const num = typeof n === \"number\" ? n : Number(n);\r\n  if (!Number.isFinite(num)) return \"—\";\r\n\r\n  const locale = opts.locale || FALLBACK_LOCALE;\r\n\r\n  const formatOpts: Intl.NumberFormatOptions = {};\r\n  if (opts.minimumFractionDigits != null) {\r\n    formatOpts.minimumFractionDigits = opts.minimumFractionDigits;\r\n  }\r\n  if (opts.maximumFractionDigits != null) {\r\n    formatOpts.maximumFractionDigits = opts.maximumFractionDigits;\r\n  }\r\n\r\n  let formatted: string;\r\n  try {\r\n    /* Requested locale first, fr-FR as the declared next preference — see\r\n     * FALLBACK_LOCALE. A resolvable request (\"en-US\") still wins outright; an\r\n     * unmatched-but-well-formed tag lands on fr-FR rather than on the host's\r\n     * default locale. */\r\n    formatted = new Intl.NumberFormat(\r\n      [locale, FALLBACK_LOCALE],\r\n      formatOpts\r\n    ).format(num);\r\n  } catch {\r\n    /* Reached only for a STRUCTURALLY invalid tag (RangeError) or a non-string\r\n     * value from an untyped host — negotiation cannot help there. */\r\n    formatted = new Intl.NumberFormat(FALLBACK_LOCALE, formatOpts).format(num);\r\n  }\r\n\r\n  return currency ? `${formatted} ${currency}` : formatted;\r\n}\r\n"],"mappings":";;;;;;AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAOA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,IAAMA,eAAe,GAAG,OAAO;AAEhB,SAASC,QAAQA,CAC9BC,CAAqC,EAG7B;EAAA,IAFRC,QAAgB,GAAAC,SAAA,CAAAC,MAAA,QAAAD,SAAA,QAAAE,SAAA,GAAAF,SAAA,MAAG,EAAE;EAAA,IACrBG,IAAqB,GAAAH,SAAA,CAAAC,MAAA,QAAAD,SAAA,QAAAE,SAAA,GAAAF,SAAA,MAAG,CAAC,CAAC;EAE1B,IAAIF,CAAC,IAAI,IAAI,IAAIA,CAAC,KAAK,EAAE,EAAE,OAAO,GAAG;EACrC,IAAMM,GAAG,GAAG,OAAON,CAAC,KAAK,QAAQ,GAAGA,CAAC,GAAGO,MAAM,CAACP,CAAC,CAAC;EACjD,IAAI,CAACO,MAAM,CAACC,QAAQ,CAACF,GAAG,CAAC,EAAE,OAAO,GAAG;EAErC,IAAMG,MAAM,GAAGJ,IAAI,CAACI,MAAM,IAAIX,eAAe;EAE7C,IAAMY,UAAoC,GAAG,CAAC,CAAC;EAC/C,IAAIL,IAAI,CAACM,qBAAqB,IAAI,IAAI,EAAE;IACtCD,UAAU,CAACC,qBAAqB,GAAGN,IAAI,CAACM,qBAAqB;EAC/D;EACA,IAAIN,IAAI,CAACO,qBAAqB,IAAI,IAAI,EAAE;IACtCF,UAAU,CAACE,qBAAqB,GAAGP,IAAI,CAACO,qBAAqB;EAC/D;EAEA,IAAIC,SAAiB;EACrB,IAAI;IACF;AACJ;AACA;AACA;IACIA,SAAS,GAAG,IAAIC,IAAI,CAACC,YAAY,CAC/B,CAACN,MAAM,EAAEX,eAAe,CAAC,EACzBY,UACF,CAAC,CAACM,MAAM,CAACV,GAAG,CAAC;EACf,CAAC,CAAC,OAAAW,OAAA,EAAM;IACN;AACJ;IACIJ,SAAS,GAAG,IAAIC,IAAI,CAACC,YAAY,CAACjB,eAAe,EAAEY,UAAU,CAAC,CAACM,MAAM,CAACV,GAAG,CAAC;EAC5E;EAEA,OAAOL,QAAQ,MAAAiB,MAAA,CAAML,SAAS,OAAAK,MAAA,CAAIjB,QAAQ,IAAKY,SAAS;AAC1D","ignoreList":[]}
+{"version":3,"file":"fmtMoney.js","names":["FALLBACK_LOCALE","fmtMoney","n","currency","opts","num","Number","isFinite","locale","formatOpts","minimumFractionDigits","maximumFractionDigits","formatted","Intl","NumberFormat","format"],"sources":["../../../src/lib/v2/utils/fmtMoney.ts"],"sourcesContent":["/**\r\n * fmtMoney — format a number with locale-aware grouping.\r\n *\r\n * Returns \"—\" for null / empty / non-finite inputs (graceful empty\r\n * cells in tables — never \"NaN\" or \"∞\").\r\n *\r\n * Defaults to \"fr-FR\" for back-compat with v1 callers; pass `locale`\r\n * (BCP-47 tag) to format under any locale supported by the runtime\r\n * Intl.NumberFormat. Currency placement is a trailing suffix in the\r\n * locale-formatted number; future evolution toward `style:\"currency\"`\r\n * (locale-correct symbol position, proper RTL handling) is deliberately\r\n * deferred to avoid breaking consumers that grep on the suffix.\r\n *\r\n *   fmtMoney(1234567.5)                              → \"1 234 567,5\"\r\n *   fmtMoney(1234567.5, \"EUR\")                       → \"1 234 567,5 EUR\"\r\n *   fmtMoney(1234567.5, \"EUR\", { locale: \"en-US\" })  → \"1,234,567.5 EUR\"\r\n *   fmtMoney(1234.5,    \"\",    { minimumFractionDigits: 2 })\r\n *                                                    → \"1 234,50\"\r\n *   fmtMoney(null) / fmtMoney(\"abc\") / fmtMoney(Infinity) → \"—\"\r\n */\r\ntype FmtMoneyOptions = {\r\n  locale?: string | undefined;\r\n  minimumFractionDigits?: number | undefined;\r\n  maximumFractionDigits?: number | undefined;\r\n};\r\n\r\n/**\r\n * The locale every unresolvable request falls back to.\r\n *\r\n * ── WHY THIS IS NEGOTIATED, NOT JUST CAUGHT ─────────────────────────────\r\n *\r\n * The previous implementation relied ONLY on `try/catch`, on the assumption that\r\n * an unusable locale throws `RangeError`. It does not — and the gap was a live\r\n * defect, not a theoretical one:\r\n *\r\n *   `Intl.NumberFormat` throws only on a STRUCTURALLY INVALID tag. A tag that is\r\n *   well-formed but has no data does NOT throw — it negotiates, and with a single\r\n *   unmatched tag the negotiation lands on the RUNTIME DEFAULT LOCALE.\r\n *\r\n * `\"not-a-real-locale\"` is well-formed: `not` parses as a 3-letter language\r\n * subtag and `-a-real-locale` as a singleton `a` extension sequence. So it never\r\n * threw, the `catch` never ran, and the result was formatted in whatever locale\r\n * the host happened to default to. On a German or Spanish host that renders\r\n * `\"1.234,5\"` — dot grouping — inside a French application.\r\n *\r\n * That is a real consistency breach (Charter §09: a French UI formats numbers in\r\n * French), and it is invisible on a French dev machine, which is exactly why it\r\n * survived: the unit test caught it only because CI ran under a non-FR default.\r\n *\r\n * Listing the fallback as the SECOND preference makes the guarantee explicit:\r\n * an unmatched-but-valid tag negotiates down to fr-FR instead of to the host.\r\n * The `try/catch` is still required for genuinely malformed input.\r\n */\r\nconst FALLBACK_LOCALE = \"fr-FR\";\r\n\r\nexport default function fmtMoney(\r\n  n: number | string | null | undefined,\r\n  currency: string = \"\",\r\n  opts: FmtMoneyOptions = {}\r\n): string {\r\n  if (n == null || n === \"\") return \"—\";\r\n  const num = typeof n === \"number\" ? n : Number(n);\r\n  if (!Number.isFinite(num)) return \"—\";\r\n\r\n  const locale = opts.locale || FALLBACK_LOCALE;\r\n\r\n  const formatOpts: Intl.NumberFormatOptions = {};\r\n  if (opts.minimumFractionDigits != null) {\r\n    formatOpts.minimumFractionDigits = opts.minimumFractionDigits;\r\n  }\r\n  if (opts.maximumFractionDigits != null) {\r\n    formatOpts.maximumFractionDigits = opts.maximumFractionDigits;\r\n  }\r\n\r\n  let formatted: string;\r\n  try {\r\n    /* Requested locale first, fr-FR as the declared next preference — see\r\n     * FALLBACK_LOCALE. A resolvable request (\"en-US\") still wins outright; an\r\n     * unmatched-but-well-formed tag lands on fr-FR rather than on the host's\r\n     * default locale. */\r\n    formatted = new Intl.NumberFormat(\r\n      [locale, FALLBACK_LOCALE],\r\n      formatOpts\r\n    ).format(num);\r\n  } catch {\r\n    /* Reached only for a STRUCTURALLY invalid tag (RangeError) or a non-string\r\n     * value from an untyped host — negotiation cannot help there. */\r\n    formatted = new Intl.NumberFormat(FALLBACK_LOCALE, formatOpts).format(num);\r\n  }\r\n\r\n  return currency ? `${formatted} ${currency}` : formatted;\r\n}\r\n"],"mappings":";;;;;;AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAOA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAMA,eAAe,GAAG,OAAO;AAEhB,SAASC,QAAQA,CAC9BC,CAAqC,EACrCC,QAAgB,GAAG,EAAE,EACrBC,IAAqB,GAAG,CAAC,CAAC,EAClB;EACR,IAAIF,CAAC,IAAI,IAAI,IAAIA,CAAC,KAAK,EAAE,EAAE,OAAO,GAAG;EACrC,MAAMG,GAAG,GAAG,OAAOH,CAAC,KAAK,QAAQ,GAAGA,CAAC,GAAGI,MAAM,CAACJ,CAAC,CAAC;EACjD,IAAI,CAACI,MAAM,CAACC,QAAQ,CAACF,GAAG,CAAC,EAAE,OAAO,GAAG;EAErC,MAAMG,MAAM,GAAGJ,IAAI,CAACI,MAAM,IAAIR,eAAe;EAE7C,MAAMS,UAAoC,GAAG,CAAC,CAAC;EAC/C,IAAIL,IAAI,CAACM,qBAAqB,IAAI,IAAI,EAAE;IACtCD,UAAU,CAACC,qBAAqB,GAAGN,IAAI,CAACM,qBAAqB;EAC/D;EACA,IAAIN,IAAI,CAACO,qBAAqB,IAAI,IAAI,EAAE;IACtCF,UAAU,CAACE,qBAAqB,GAAGP,IAAI,CAACO,qBAAqB;EAC/D;EAEA,IAAIC,SAAiB;EACrB,IAAI;IACF;AACJ;AACA;AACA;IACIA,SAAS,GAAG,IAAIC,IAAI,CAACC,YAAY,CAC/B,CAACN,MAAM,EAAER,eAAe,CAAC,EACzBS,UACF,CAAC,CAACM,MAAM,CAACV,GAAG,CAAC;EACf,CAAC,CAAC,MAAM;IACN;AACJ;IACIO,SAAS,GAAG,IAAIC,IAAI,CAACC,YAAY,CAACd,eAAe,EAAES,UAAU,CAAC,CAACM,MAAM,CAACV,GAAG,CAAC;EAC5E;EAEA,OAAOF,QAAQ,GAAG,GAAGS,SAAS,IAAIT,QAAQ,EAAE,GAAGS,SAAS;AAC1D","ignoreList":[]}

package/dist/v2/utils/formikErrors.d.ts

@@ -0,0 +1,67 @@
+import type { FormErrorSummaryError } from "../patterns/FormErrorSummary";
+/**
+ * flattenFormikErrors — Formik's nested `errors` → the flat list
+ * `FormErrorSummary` consumes (capability gap G-38).
+ *
+ * ─────────────────────────────────────────────────────────────────────────────
+ * WHY THIS BELONGS IN THE LIBRARY
+ *
+ * The library already owns BOTH ends of the failed-submit recipe that R-FV.2
+ * and R-FV.3 make mandatory:
+ *
+ *   · `FormErrorSummary`  — the banner at the top of the form, whose items are
+ *                           `{ name, message }` and whose `onItemClick` hands
+ *                           back the field NAME;
+ *   · `FormikErrorFocus` / `focusFieldByName` — the counterpart that moves
+ *                           focus, resolving that same name as `[name="…"]`.
+ *
+ * What it never shipped is the step between them. Formik's `errors` mirrors the
+ * shape of `values` — a nested object whose leaves are message strings — and
+ * nothing in the library turned that tree into the flat list both ends speak.
+ * So every Formik host wrote the recursion itself, which is a duplication the
+ * Platform TypeScript Guidelines forbid outright, and which the library invited
+ * by publishing the type (`FormErrorSummaryError`) without the one function
+ * that produces it.
+ *
+ * >>> THE FAILURE MODE IS THE PATH, AND IT IS INVISIBLE TO REVIEW. Every
+ * >>> re-implementation gets `{ name, message }` right and the ACCUMULATED PATH
+ * >>> subtly wrong — a missing separator, a skipped array index, a `[0]`
+ * >>> written where Formik writes `.0`. Nothing throws. The banner renders,
+ * >>> lists the right messages, and its jump button targets a field that does
+ * >>> not exist: `focusFieldByName` finds no node and the click does nothing.
+ * >>> A user staring at a rejected form clicks the one affordance offered to
+ * >>> find the offending field, and it silently fails.
+ * >>>
+ * >>> Promoted from `refonte-frontend` (Area 5), where it had already been
+ * >>> extracted once — out of a single page and into module-common — for
+ * >>> exactly this reason, when a second form needed it. The next module along
+ * >>> would have been the third copy. <<<
+ * ─────────────────────────────────────────────────────────────────────────────
+ *
+ * ARRAY ERRORS ARE TRAVERSED AS OBJECTS, DELIBERATELY. `Yup.array()` produces
+ * errors keyed by index, so the path becomes `beneficiaires.0.nom` — dot,
+ * not bracket. That is the form Formik itself produces and therefore the form
+ * the corresponding field's `name` attribute carries, which is what makes the
+ * path usable by `focusFieldByName` and by `setFieldValue` alike. Rewriting it
+ * as `beneficiaires[0].nom` would read more naturally and match nothing.
+ *
+ * Non-string leaves that are not objects (a `false`, a `null` left by a custom
+ * validator) yield nothing rather than an item with an empty message: a summary
+ * line with no text is worse than one line fewer, since it is clickable, blank,
+ * and lists no reason.
+ *
+ * Usage:
+ *
+ *   <FormErrorSummary
+ *     errors={flattenFormikErrors(formik.errors)}
+ *     onItemClick={focusFieldByName}
+ *   />
+ *
+ * The `FormErrorSummaryError` import is TYPE-ONLY and therefore erased at
+ * build time: this util does not depend on ./patterns at runtime, and the
+ * item shape keeps a single declaration next to the component that renders it
+ * rather than being restated here.
+ */
+export declare function flattenFormikErrors(errors: unknown, prefix?: string): FormErrorSummaryError[];
+export default flattenFormikErrors;
+//# sourceMappingURL=formikErrors.d.ts.map

package/dist/v2/utils/formikErrors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"formikErrors.d.ts","sourceRoot":"","sources":["../../../src/lib/v2/utils/formikErrors.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,8BAA8B,CAAC;AAE1E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8DG;AACH,wBAAgB,mBAAmB,CACjC,MAAM,EAAE,OAAO,EACf,MAAM,SAAK,GACV,qBAAqB,EAAE,CAWzB;AAED,eAAe,mBAAmB,CAAC"}

package/dist/v2/utils/formikErrors.js

@@ -0,0 +1,85 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+exports.flattenFormikErrors = flattenFormikErrors;
+/**
+ * flattenFormikErrors — Formik's nested `errors` → the flat list
+ * `FormErrorSummary` consumes (capability gap G-38).
+ *
+ * ─────────────────────────────────────────────────────────────────────────────
+ * WHY THIS BELONGS IN THE LIBRARY
+ *
+ * The library already owns BOTH ends of the failed-submit recipe that R-FV.2
+ * and R-FV.3 make mandatory:
+ *
+ *   · `FormErrorSummary`  — the banner at the top of the form, whose items are
+ *                           `{ name, message }` and whose `onItemClick` hands
+ *                           back the field NAME;
+ *   · `FormikErrorFocus` / `focusFieldByName` — the counterpart that moves
+ *                           focus, resolving that same name as `[name="…"]`.
+ *
+ * What it never shipped is the step between them. Formik's `errors` mirrors the
+ * shape of `values` — a nested object whose leaves are message strings — and
+ * nothing in the library turned that tree into the flat list both ends speak.
+ * So every Formik host wrote the recursion itself, which is a duplication the
+ * Platform TypeScript Guidelines forbid outright, and which the library invited
+ * by publishing the type (`FormErrorSummaryError`) without the one function
+ * that produces it.
+ *
+ * >>> THE FAILURE MODE IS THE PATH, AND IT IS INVISIBLE TO REVIEW. Every
+ * >>> re-implementation gets `{ name, message }` right and the ACCUMULATED PATH
+ * >>> subtly wrong — a missing separator, a skipped array index, a `[0]`
+ * >>> written where Formik writes `.0`. Nothing throws. The banner renders,
+ * >>> lists the right messages, and its jump button targets a field that does
+ * >>> not exist: `focusFieldByName` finds no node and the click does nothing.
+ * >>> A user staring at a rejected form clicks the one affordance offered to
+ * >>> find the offending field, and it silently fails.
+ * >>>
+ * >>> Promoted from `refonte-frontend` (Area 5), where it had already been
+ * >>> extracted once — out of a single page and into module-common — for
+ * >>> exactly this reason, when a second form needed it. The next module along
+ * >>> would have been the third copy. <<<
+ * ─────────────────────────────────────────────────────────────────────────────
+ *
+ * ARRAY ERRORS ARE TRAVERSED AS OBJECTS, DELIBERATELY. `Yup.array()` produces
+ * errors keyed by index, so the path becomes `beneficiaires.0.nom` — dot,
+ * not bracket. That is the form Formik itself produces and therefore the form
+ * the corresponding field's `name` attribute carries, which is what makes the
+ * path usable by `focusFieldByName` and by `setFieldValue` alike. Rewriting it
+ * as `beneficiaires[0].nom` would read more naturally and match nothing.
+ *
+ * Non-string leaves that are not objects (a `false`, a `null` left by a custom
+ * validator) yield nothing rather than an item with an empty message: a summary
+ * line with no text is worse than one line fewer, since it is clickable, blank,
+ * and lists no reason.
+ *
+ * Usage:
+ *
+ *   <FormErrorSummary
+ *     errors={flattenFormikErrors(formik.errors)}
+ *     onItemClick={focusFieldByName}
+ *   />
+ *
+ * The `FormErrorSummaryError` import is TYPE-ONLY and therefore erased at
+ * build time: this util does not depend on ./patterns at runtime, and the
+ * item shape keeps a single declaration next to the component that renders it
+ * rather than being restated here.
+ */
+function flattenFormikErrors(errors, prefix = "") {
+  if (!errors || typeof errors !== "object") return [];
+  return Object.entries(errors).flatMap(([key, value]) => {
+    const path = prefix ? `${prefix}.${key}` : key;
+    if (typeof value === "string") {
+      return value.length > 0 ? [{
+        name: path,
+        message: value
+      }] : [];
+    }
+    return flattenFormikErrors(value, path);
+  });
+}
+var _default = exports.default = flattenFormikErrors;
+//# sourceMappingURL=formikErrors.js.map

package/dist/v2/utils/formikErrors.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"formikErrors.js","names":["flattenFormikErrors","errors","prefix","Object","entries","flatMap","key","value","path","length","name","message","_default","exports","default"],"sources":["../../../src/lib/v2/utils/formikErrors.ts"],"sourcesContent":["import type { FormErrorSummaryError } from \"../patterns/FormErrorSummary\";\r\n\r\n/**\r\n * flattenFormikErrors — Formik's nested `errors` → the flat list\r\n * `FormErrorSummary` consumes (capability gap G-38).\r\n *\r\n * ─────────────────────────────────────────────────────────────────────────────\r\n * WHY THIS BELONGS IN THE LIBRARY\r\n *\r\n * The library already owns BOTH ends of the failed-submit recipe that R-FV.2\r\n * and R-FV.3 make mandatory:\r\n *\r\n *   · `FormErrorSummary`  — the banner at the top of the form, whose items are\r\n *                           `{ name, message }` and whose `onItemClick` hands\r\n *                           back the field NAME;\r\n *   · `FormikErrorFocus` / `focusFieldByName` — the counterpart that moves\r\n *                           focus, resolving that same name as `[name=\"…\"]`.\r\n *\r\n * What it never shipped is the step between them. Formik's `errors` mirrors the\r\n * shape of `values` — a nested object whose leaves are message strings — and\r\n * nothing in the library turned that tree into the flat list both ends speak.\r\n * So every Formik host wrote the recursion itself, which is a duplication the\r\n * Platform TypeScript Guidelines forbid outright, and which the library invited\r\n * by publishing the type (`FormErrorSummaryError`) without the one function\r\n * that produces it.\r\n *\r\n * >>> THE FAILURE MODE IS THE PATH, AND IT IS INVISIBLE TO REVIEW. Every\r\n * >>> re-implementation gets `{ name, message }` right and the ACCUMULATED PATH\r\n * >>> subtly wrong — a missing separator, a skipped array index, a `[0]`\r\n * >>> written where Formik writes `.0`. Nothing throws. The banner renders,\r\n * >>> lists the right messages, and its jump button targets a field that does\r\n * >>> not exist: `focusFieldByName` finds no node and the click does nothing.\r\n * >>> A user staring at a rejected form clicks the one affordance offered to\r\n * >>> find the offending field, and it silently fails.\r\n * >>>\r\n * >>> Promoted from `refonte-frontend` (Area 5), where it had already been\r\n * >>> extracted once — out of a single page and into module-common — for\r\n * >>> exactly this reason, when a second form needed it. The next module along\r\n * >>> would have been the third copy. <<<\r\n * ─────────────────────────────────────────────────────────────────────────────\r\n *\r\n * ARRAY ERRORS ARE TRAVERSED AS OBJECTS, DELIBERATELY. `Yup.array()` produces\r\n * errors keyed by index, so the path becomes `beneficiaires.0.nom` — dot,\r\n * not bracket. That is the form Formik itself produces and therefore the form\r\n * the corresponding field's `name` attribute carries, which is what makes the\r\n * path usable by `focusFieldByName` and by `setFieldValue` alike. Rewriting it\r\n * as `beneficiaires[0].nom` would read more naturally and match nothing.\r\n *\r\n * Non-string leaves that are not objects (a `false`, a `null` left by a custom\r\n * validator) yield nothing rather than an item with an empty message: a summary\r\n * line with no text is worse than one line fewer, since it is clickable, blank,\r\n * and lists no reason.\r\n *\r\n * Usage:\r\n *\r\n *   <FormErrorSummary\r\n *     errors={flattenFormikErrors(formik.errors)}\r\n *     onItemClick={focusFieldByName}\r\n *   />\r\n *\r\n * The `FormErrorSummaryError` import is TYPE-ONLY and therefore erased at\r\n * build time: this util does not depend on ./patterns at runtime, and the\r\n * item shape keeps a single declaration next to the component that renders it\r\n * rather than being restated here.\r\n */\r\nexport function flattenFormikErrors(\r\n  errors: unknown,\r\n  prefix = \"\"\r\n): FormErrorSummaryError[] {\r\n  if (!errors || typeof errors !== \"object\") return [];\r\n  return Object.entries(errors as Record<string, unknown>).flatMap(\r\n    ([key, value]) => {\r\n      const path = prefix ? `${prefix}.${key}` : key;\r\n      if (typeof value === \"string\") {\r\n        return value.length > 0 ? [{ name: path, message: value }] : [];\r\n      }\r\n      return flattenFormikErrors(value, path);\r\n    }\r\n  );\r\n}\r\n\r\nexport default flattenFormikErrors;\r\n"],"mappings":";;;;;;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,SAASA,mBAAmBA,CACjCC,MAAe,EACfC,MAAM,GAAG,EAAE,EACc;EACzB,IAAI,CAACD,MAAM,IAAI,OAAOA,MAAM,KAAK,QAAQ,EAAE,OAAO,EAAE;EACpD,OAAOE,MAAM,CAACC,OAAO,CAACH,MAAiC,CAAC,CAACI,OAAO,CAC9D,CAAC,CAACC,GAAG,EAAEC,KAAK,CAAC,KAAK;IAChB,MAAMC,IAAI,GAAGN,MAAM,GAAG,GAAGA,MAAM,IAAII,GAAG,EAAE,GAAGA,GAAG;IAC9C,IAAI,OAAOC,KAAK,KAAK,QAAQ,EAAE;MAC7B,OAAOA,KAAK,CAACE,MAAM,GAAG,CAAC,GAAG,CAAC;QAAEC,IAAI,EAAEF,IAAI;QAAEG,OAAO,EAAEJ;MAAM,CAAC,CAAC,GAAG,EAAE;IACjE;IACA,OAAOP,mBAAmB,CAACO,KAAK,EAAEC,IAAI,CAAC;EACzC,CACF,CAAC;AACH;AAAC,IAAAI,QAAA,GAAAC,OAAA,CAAAC,OAAA,GAEcd,mBAAmB","ignoreList":[]}

package/dist/v2/utils/index.d.ts

@@ -1,9 +1,14 @@
 export { cx } from "./cx";
 export { default as fmtMoney } from "./fmtMoney";
+export { fmtDate, fmtDateTime } from "./fmtDate";
+export type { FmtDateInput, FmtDateOptions } from "./fmtDate";
 export { mergeLabels } from "./mergeLabels";
 export { downloadBase64File, getMimeType, openBase64FileInTab, downloadBlobFile, } from "./fileDownload";
+export { isForbiddenExecutable, isAcceptedFile, getFileRejection, describeAcceptedTypes, toAcceptAttribute, } from "./fileValidation";
+export type { FileAcceptPolicy, FileRejection, FileRejectionReason, } from "./fileValidation";
 export * as contrast from "./contrast";
 export { getApiErrorMessage, getApiErrorDetail, getApiErrorStatus, DEFAULT_API_ERROR_MESSAGE, } from "./apiError";
 export { networkStatus, createNetworkStatus } from "./networkStatus";
 export type { NetworkStatus, NetworkStatusListener } from "./networkStatus";
+export { flattenFormikErrors } from "./formikErrors";
 //# sourceMappingURL=index.d.ts.map

package/dist/v2/utils/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/lib/v2/utils/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,EAAE,EAAE,MAAuB,MAAM,CAAC;AAC3C,OAAO,EAAE,OAAO,IAAI,QAAQ,EAAE,MAAM,YAAY,CAAC;AASjD,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAM5C,OAAO,EACL,kBAAkB,EAClB,WAAW,EACX,mBAAmB,EACnB,gBAAgB,GACjB,MAAM,gBAAgB,CAAC;AAOxB,OAAO,KAAK,QAAQ,MAAM,YAAY,CAAC;AAavC,OAAO,EACL,kBAAkB,EAClB,iBAAiB,EACjB,iBAAiB,EACjB,yBAAyB,GAC1B,MAAM,YAAY,CAAC;AAMpB,OAAO,EAAE,aAAa,EAAE,mBAAmB,EAAE,MAAM,iBAAiB,CAAC;AACrE,YAAY,EAAE,aAAa,EAAE,qBAAqB,EAAE,MAAM,iBAAiB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/lib/v2/utils/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,EAAE,EAAE,MAAuB,MAAM,CAAC;AAC3C,OAAO,EAAE,OAAO,IAAI,QAAQ,EAAE,MAAM,YAAY,CAAC;AAcjD,OAAO,EAAE,OAAO,EAAE,WAAW,EAAE,MAAM,WAAW,CAAC;AACjD,YAAY,EAAE,YAAY,EAAE,cAAc,EAAE,MAAM,WAAW,CAAC;AAS9D,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAM5C,OAAO,EACL,kBAAkB,EAClB,WAAW,EACX,mBAAmB,EACnB,gBAAgB,GACjB,MAAM,gBAAgB,CAAC;AAYxB,OAAO,EACL,qBAAqB,EACrB,cAAc,EACd,gBAAgB,EAChB,qBAAqB,EACrB,iBAAiB,GAClB,MAAM,kBAAkB,CAAC;AAC1B,YAAY,EACV,gBAAgB,EAChB,aAAa,EACb,mBAAmB,GACpB,MAAM,kBAAkB,CAAC;AAO1B,OAAO,KAAK,QAAQ,MAAM,YAAY,CAAC;AAavC,OAAO,EACL,kBAAkB,EAClB,iBAAiB,EACjB,iBAAiB,EACjB,yBAAyB,GAC1B,MAAM,YAAY,CAAC;AAMpB,OAAO,EAAE,aAAa,EAAE,mBAAmB,EAAE,MAAM,iBAAiB,CAAC;AACrE,YAAY,EAAE,aAAa,EAAE,qBAAqB,EAAE,MAAM,iBAAiB,CAAC;AAS5E,OAAO,EAAE,mBAAmB,EAAE,MAAM,gBAAgB,CAAC"}

package/dist/v2/utils/index.js

@@ -1,97 +1,146 @@
 "use strict";
 
-function _typeof(obj) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, _typeof(obj); }
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
 Object.defineProperty(exports, "DEFAULT_API_ERROR_MESSAGE", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _apiError.DEFAULT_API_ERROR_MESSAGE;
   }
 });
 exports.contrast = void 0;
 Object.defineProperty(exports, "createNetworkStatus", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _networkStatus.createNetworkStatus;
   }
 });
 Object.defineProperty(exports, "cx", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _cx.cx;
   }
 });
+Object.defineProperty(exports, "describeAcceptedTypes", {
+  enumerable: true,
+  get: function () {
+    return _fileValidation.describeAcceptedTypes;
+  }
+});
 Object.defineProperty(exports, "downloadBase64File", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _fileDownload.downloadBase64File;
   }
 });
 Object.defineProperty(exports, "downloadBlobFile", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _fileDownload.downloadBlobFile;
   }
 });
+Object.defineProperty(exports, "flattenFormikErrors", {
+  enumerable: true,
+  get: function () {
+    return _formikErrors.flattenFormikErrors;
+  }
+});
+Object.defineProperty(exports, "fmtDate", {
+  enumerable: true,
+  get: function () {
+    return _fmtDate.fmtDate;
+  }
+});
+Object.defineProperty(exports, "fmtDateTime", {
+  enumerable: true,
+  get: function () {
+    return _fmtDate.fmtDateTime;
+  }
+});
 Object.defineProperty(exports, "fmtMoney", {
   enumerable: true,
-  get: function get() {
-    return _fmtMoney["default"];
+  get: function () {
+    return _fmtMoney.default;
   }
 });
 Object.defineProperty(exports, "getApiErrorDetail", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _apiError.getApiErrorDetail;
   }
 });
 Object.defineProperty(exports, "getApiErrorMessage", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _apiError.getApiErrorMessage;
   }
 });
 Object.defineProperty(exports, "getApiErrorStatus", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _apiError.getApiErrorStatus;
   }
 });
+Object.defineProperty(exports, "getFileRejection", {
+  enumerable: true,
+  get: function () {
+    return _fileValidation.getFileRejection;
+  }
+});
 Object.defineProperty(exports, "getMimeType", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _fileDownload.getMimeType;
   }
 });
+Object.defineProperty(exports, "isAcceptedFile", {
+  enumerable: true,
+  get: function () {
+    return _fileValidation.isAcceptedFile;
+  }
+});
+Object.defineProperty(exports, "isForbiddenExecutable", {
+  enumerable: true,
+  get: function () {
+    return _fileValidation.isForbiddenExecutable;
+  }
+});
 Object.defineProperty(exports, "mergeLabels", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _mergeLabels.mergeLabels;
   }
 });
 Object.defineProperty(exports, "networkStatus", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _networkStatus.networkStatus;
   }
 });
 Object.defineProperty(exports, "openBase64FileInTab", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _fileDownload.openBase64FileInTab;
   }
 });
+Object.defineProperty(exports, "toAcceptAttribute", {
+  enumerable: true,
+  get: function () {
+    return _fileValidation.toAcceptAttribute;
+  }
+});
 var _cx = require("./cx");
 var _fmtMoney = _interopRequireDefault(require("./fmtMoney"));
+var _fmtDate = require("./fmtDate");
 var _mergeLabels = require("./mergeLabels");
 var _fileDownload = require("./fileDownload");
+var _fileValidation = require("./fileValidation");
 var _contrast = _interopRequireWildcard(require("./contrast"));
 exports.contrast = _contrast;
 var _apiError = require("./apiError");
 var _networkStatus = require("./networkStatus");
-function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
-function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { "default": obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj["default"] = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+var _formikErrors = require("./formikErrors");
+function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
 //# sourceMappingURL=index.js.map

package/dist/v2/utils/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","names":["_cx","require","_fmtMoney","_interopRequireDefault","_mergeLabels","_fileDownload","_contrast","_interopRequireWildcard","exports","contrast","_apiError","_networkStatus","_getRequireWildcardCache","nodeInterop","WeakMap","cacheBabelInterop","cacheNodeInterop","obj","__esModule","_typeof","cache","has","get","newObj","hasPropertyDescriptor","Object","defineProperty","getOwnPropertyDescriptor","key","prototype","hasOwnProperty","call","desc","set"],"sources":["../../../src/lib/v2/utils/index.ts"],"sourcesContent":["export { cx }                  from \"./cx\";\r\nexport { default as fmtMoney } from \"./fmtMoney\";\r\n\r\n// Undefined-safe label merge. Every localisable component used to write\r\n// `labels ? { ...DEFAULTS, ...labels } : DEFAULTS`, and a spread does NOT skip\r\n// explicit `undefined` — so an override of `undefined` DELETED the default and\r\n// the component threw `L.x is not a function` at render. Eleven components\r\n// shipped that hazard; the `?: T` declarations hid it from the compiler by\r\n// asserting the merged value could never be undefined, which was false at\r\n// runtime. Surfaced by the G-14 widening. Latent runtime defect, not cosmetics.\r\nexport { mergeLabels } from \"./mergeLabels\";\r\n\r\n// Base64 → browser download, plus the extension→MIME map it uses.\r\n// Flat named exports (not a namespace like contrast below): two\r\n// independent functions with no shared state, and downloadBase64File\r\n// is the common call site — qualifying it would only add noise.\r\nexport {\r\n  downloadBase64File,\r\n  getMimeType,\r\n  openBase64FileInTab,\r\n  downloadBlobFile,\r\n} from \"./fileDownload\";\r\n\r\n// WCAG 2.1 contrast utilities. Re-exported under a namespace at\r\n// the public barrel (v2.contrast.*) so the named API is grouped\r\n// and self-describing for callers — used to validate runtime\r\n// brand overrides against WCAG 1.4.3 and to audit dark-mode\r\n// token pairs (F29).\r\nexport * as contrast from \"./contrast\";\r\n\r\n// `unknown`-rejection narrowing. Mandated by the platform's own\r\n// `useUnknownInCatchVariables` flag, which makes `catch (e)` bind `unknown` in\r\n// every consuming saga while `any` and unsafe assertions stay forbidden — the\r\n// library previously left no sanctioned route between those two rules, and the\r\n// modules that filled the gap filled it with the forbidden construct.\r\n// Raised as capability gap G-04 (procuration-portnet-fe Area 5).\r\n//\r\n// `getApiErrorDetail` is the LOGGING counterpart added with G-07: since\r\n// `getApiErrorMessage` now suppresses axios transport phrasings so they cannot\r\n// reach a user (Charter §09.3), operators still need the unfiltered string for a\r\n// console or an APM breadcrumb. Display one, log the other.\r\nexport {\r\n  getApiErrorMessage,\r\n  getApiErrorDetail,\r\n  getApiErrorStatus,\r\n  DEFAULT_API_ERROR_MESSAGE,\r\n} from \"./apiError\";\r\n\r\n// The feed behind NetworkErrorBanner. The banner was exported without the\r\n// plumbing that decides when it shows, so every module rebuilt the same\r\n// subscribe/report/clear channel. Raised as capability gap G-03\r\n// (procuration-portnet-fe Area 5).\r\nexport { networkStatus, createNetworkStatus } from \"./networkStatus\";\r\nexport type { NetworkStatus, NetworkStatusListener } from \"./networkStatus\";\r\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,IAAAA,GAAA,GAAAC,OAAA;AACA,IAAAC,SAAA,GAAAC,sBAAA,CAAAF,OAAA;AASA,IAAAG,YAAA,GAAAH,OAAA;AAMA,IAAAI,aAAA,GAAAJ,OAAA;AAKwB,IAAAK,SAAA,GAAAC,uBAAA,CAAAN,OAAA;AAAAO,OAAA,CAAAC,QAAA,GAAAH,SAAA;AAoBxB,IAAAI,SAAA,GAAAT,OAAA;AAWA,IAAAU,cAAA,GAAAV,OAAA;AAAqE,SAAAW,yBAAAC,WAAA,eAAAC,OAAA,kCAAAC,iBAAA,OAAAD,OAAA,QAAAE,gBAAA,OAAAF,OAAA,YAAAF,wBAAA,YAAAA,yBAAAC,WAAA,WAAAA,WAAA,GAAAG,gBAAA,GAAAD,iBAAA,KAAAF,WAAA;AAAA,SAAAN,wBAAAU,GAAA,EAAAJ,WAAA,SAAAA,WAAA,IAAAI,GAAA,IAAAA,GAAA,CAAAC,UAAA,WAAAD,GAAA,QAAAA,GAAA,aAAAE,OAAA,CAAAF,GAAA,yBAAAA,GAAA,uCAAAA,GAAA,UAAAG,KAAA,GAAAR,wBAAA,CAAAC,WAAA,OAAAO,KAAA,IAAAA,KAAA,CAAAC,GAAA,CAAAJ,GAAA,YAAAG,KAAA,CAAAE,GAAA,CAAAL,GAAA,SAAAM,MAAA,WAAAC,qBAAA,GAAAC,MAAA,CAAAC,cAAA,IAAAD,MAAA,CAAAE,wBAAA,WAAAC,GAAA,IAAAX,GAAA,QAAAW,GAAA,kBAAAH,MAAA,CAAAI,SAAA,CAAAC,cAAA,CAAAC,IAAA,CAAAd,GAAA,EAAAW,GAAA,SAAAI,IAAA,GAAAR,qBAAA,GAAAC,MAAA,CAAAE,wBAAA,CAAAV,GAAA,EAAAW,GAAA,cAAAI,IAAA,KAAAA,IAAA,CAAAV,GAAA,IAAAU,IAAA,CAAAC,GAAA,KAAAR,MAAA,CAAAC,cAAA,CAAAH,MAAA,EAAAK,GAAA,EAAAI,IAAA,YAAAT,MAAA,CAAAK,GAAA,IAAAX,GAAA,CAAAW,GAAA,SAAAL,MAAA,cAAAN,GAAA,MAAAG,KAAA,IAAAA,KAAA,CAAAa,GAAA,CAAAhB,GAAA,EAAAM,MAAA,YAAAA,MAAA;AAAA,SAAApB,uBAAAc,GAAA,WAAAA,GAAA,IAAAA,GAAA,CAAAC,UAAA,GAAAD,GAAA,gBAAAA,GAAA","ignoreList":[]}
+{"version":3,"file":"index.js","names":["_cx","require","_fmtMoney","_interopRequireDefault","_fmtDate","_mergeLabels","_fileDownload","_fileValidation","_contrast","_interopRequireWildcard","exports","contrast","_apiError","_networkStatus","_formikErrors","e","t","WeakMap","r","n","__esModule","o","i","f","__proto__","default","has","get","set","hasOwnProperty","call","Object","defineProperty","getOwnPropertyDescriptor"],"sources":["../../../src/lib/v2/utils/index.ts"],"sourcesContent":["export { cx }                  from \"./cx\";\r\nexport { default as fmtMoney } from \"./fmtMoney\";\r\n\r\n// Date rendering for DISPLAY (gap G-51) — the counterpart of fmtMoney, which\r\n// this folder has owned all along for the same reason: a cell must never read\r\n// \"NaN\". Nothing existed for dates, which GU screens render far more often than\r\n// amounts, so every module wrote it — and every copy fed `new Date(undefined)`\r\n// straight into `getDate()`, rendering the literal string \"NaN/NaN/NaN NaN:NaN\"\r\n// on any optional date field. One module had added the guard at eight CALL\r\n// SITES across four lots before moving it into its own helper; the formatter is\r\n// the only place it cannot be forgotten.\r\n//\r\n// REMINDER (the G-34 invariant): this barrel is re-exported from lib/index.ts by\r\n// EXPLICIT NAME LIST, so these two must be added there in the SAME commit or\r\n// they never reach a consumer.\r\nexport { fmtDate, fmtDateTime } from \"./fmtDate\";\r\nexport type { FmtDateInput, FmtDateOptions } from \"./fmtDate\";\r\n\r\n// Undefined-safe label merge. Every localisable component used to write\r\n// `labels ? { ...DEFAULTS, ...labels } : DEFAULTS`, and a spread does NOT skip\r\n// explicit `undefined` — so an override of `undefined` DELETED the default and\r\n// the component threw `L.x is not a function` at render. Eleven components\r\n// shipped that hazard; the `?: T` declarations hid it from the compiler by\r\n// asserting the merged value could never be undefined, which was false at\r\n// runtime. Surfaced by the G-14 widening. Latent runtime defect, not cosmetics.\r\nexport { mergeLabels } from \"./mergeLabels\";\r\n\r\n// Base64 → browser download, plus the extension→MIME map it uses.\r\n// Flat named exports (not a namespace like contrast below): two\r\n// independent functions with no shared state, and downloadBase64File\r\n// is the common call site — qualifying it would only add noise.\r\nexport {\r\n  downloadBase64File,\r\n  getMimeType,\r\n  openBase64FileInTab,\r\n  downloadBlobFile,\r\n} from \"./fileDownload\";\r\n\r\n// Upload validation (gap G-52). `Dropzone` takes an `accept` attribute and\r\n// reports rejections, but validates NOTHING — `accept` is a file-picker filter\r\n// that drag-and-drop ignores. So every host decided for itself, and each wrote\r\n// the same two non-business parts alongside its own extension allow-list: a\r\n// deny-list of executables and scripts, and an extension/MIME cross-check with\r\n// its browser tolerances. A security decision copied into fifteen modules\r\n// drifts, and drifts SILENTLY. The host keeps its allow-list; the library owns\r\n// the deny-list and the cross-check.\r\n//\r\n// REMINDER (the G-34 invariant): added to lib/index.ts in the same commit.\r\nexport {\r\n  isForbiddenExecutable,\r\n  isAcceptedFile,\r\n  getFileRejection,\r\n  describeAcceptedTypes,\r\n  toAcceptAttribute,\r\n} from \"./fileValidation\";\r\nexport type {\r\n  FileAcceptPolicy,\r\n  FileRejection,\r\n  FileRejectionReason,\r\n} from \"./fileValidation\";\r\n\r\n// WCAG 2.1 contrast utilities. Re-exported under a namespace at\r\n// the public barrel (v2.contrast.*) so the named API is grouped\r\n// and self-describing for callers — used to validate runtime\r\n// brand overrides against WCAG 1.4.3 and to audit dark-mode\r\n// token pairs (F29).\r\nexport * as contrast from \"./contrast\";\r\n\r\n// `unknown`-rejection narrowing. Mandated by the platform's own\r\n// `useUnknownInCatchVariables` flag, which makes `catch (e)` bind `unknown` in\r\n// every consuming saga while `any` and unsafe assertions stay forbidden — the\r\n// library previously left no sanctioned route between those two rules, and the\r\n// modules that filled the gap filled it with the forbidden construct.\r\n// Raised as capability gap G-04 (procuration-portnet-fe Area 5).\r\n//\r\n// `getApiErrorDetail` is the LOGGING counterpart added with G-07: since\r\n// `getApiErrorMessage` now suppresses axios transport phrasings so they cannot\r\n// reach a user (Charter §09.3), operators still need the unfiltered string for a\r\n// console or an APM breadcrumb. Display one, log the other.\r\nexport {\r\n  getApiErrorMessage,\r\n  getApiErrorDetail,\r\n  getApiErrorStatus,\r\n  DEFAULT_API_ERROR_MESSAGE,\r\n} from \"./apiError\";\r\n\r\n// The feed behind NetworkErrorBanner. The banner was exported without the\r\n// plumbing that decides when it shows, so every module rebuilt the same\r\n// subscribe/report/clear channel. Raised as capability gap G-03\r\n// (procuration-portnet-fe Area 5).\r\nexport { networkStatus, createNetworkStatus } from \"./networkStatus\";\r\nexport type { NetworkStatus, NetworkStatusListener } from \"./networkStatus\";\r\n\r\n// Formik's nested `errors` -> the flat `{ name, message }[]` that\r\n// FormErrorSummary consumes and focusFieldByName resolves. The library owned\r\n// both ends of the R-FV.2 / R-FV.3 recipe and not the step between them, so\r\n// every Formik host wrote the recursion — and each copy got the accumulated\r\n// PATH subtly wrong, which fails silently: the summary lists the right\r\n// messages and its jump button targets a field that does not exist.\r\n// Capability gap G-38 (refonte-frontend Area 5).\r\nexport { flattenFormikErrors } from \"./formikErrors\";\r\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,IAAAA,GAAA,GAAAC,OAAA;AACA,IAAAC,SAAA,GAAAC,sBAAA,CAAAF,OAAA;AAcA,IAAAG,QAAA,GAAAH,OAAA;AAUA,IAAAI,YAAA,GAAAJ,OAAA;AAMA,IAAAK,aAAA,GAAAL,OAAA;AAiBA,IAAAM,eAAA,GAAAN,OAAA;AAM0B,IAAAO,SAAA,GAAAC,uBAAA,CAAAR,OAAA;AAAAS,OAAA,CAAAC,QAAA,GAAAH,SAAA;AAyB1B,IAAAI,SAAA,GAAAX,OAAA;AAWA,IAAAY,cAAA,GAAAZ,OAAA;AAUA,IAAAa,aAAA,GAAAb,OAAA;AAAqD,SAAAQ,wBAAAM,CAAA,EAAAC,CAAA,6BAAAC,OAAA,MAAAC,CAAA,OAAAD,OAAA,IAAAE,CAAA,OAAAF,OAAA,YAAAR,uBAAA,YAAAA,CAAAM,CAAA,EAAAC,CAAA,SAAAA,CAAA,IAAAD,CAAA,IAAAA,CAAA,CAAAK,UAAA,SAAAL,CAAA,MAAAM,CAAA,EAAAC,CAAA,EAAAC,CAAA,KAAAC,SAAA,QAAAC,OAAA,EAAAV,CAAA,iBAAAA,CAAA,uBAAAA,CAAA,yBAAAA,CAAA,SAAAQ,CAAA,MAAAF,CAAA,GAAAL,CAAA,GAAAG,CAAA,GAAAD,CAAA,QAAAG,CAAA,CAAAK,GAAA,CAAAX,CAAA,UAAAM,CAAA,CAAAM,GAAA,CAAAZ,CAAA,GAAAM,CAAA,CAAAO,GAAA,CAAAb,CAAA,EAAAQ,CAAA,gBAAAP,CAAA,IAAAD,CAAA,gBAAAC,CAAA,OAAAa,cAAA,CAAAC,IAAA,CAAAf,CAAA,EAAAC,CAAA,OAAAM,CAAA,IAAAD,CAAA,GAAAU,MAAA,CAAAC,cAAA,KAAAD,MAAA,CAAAE,wBAAA,CAAAlB,CAAA,EAAAC,CAAA,OAAAM,CAAA,CAAAK,GAAA,IAAAL,CAAA,CAAAM,GAAA,IAAAP,CAAA,CAAAE,CAAA,EAAAP,CAAA,EAAAM,CAAA,IAAAC,CAAA,CAAAP,CAAA,IAAAD,CAAA,CAAAC,CAAA,WAAAO,CAAA,KAAAR,CAAA,EAAAC,CAAA;AAAA,SAAAb,uBAAAY,CAAA,WAAAA,CAAA,IAAAA,CAAA,CAAAK,UAAA,GAAAL,CAAA,KAAAU,OAAA,EAAAV,CAAA","ignoreList":[]}

package/dist/v2/utils/mergeLabels.js

@@ -3,14 +3,8 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports["default"] = void 0;
+exports.default = void 0;
 exports.mergeLabels = mergeLabels;
-function _typeof(obj) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, _typeof(obj); }
-function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
-function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
-function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
-function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return _typeof(key) === "symbol" ? key : String(key); }
-function _toPrimitive(input, hint) { if (_typeof(input) !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (_typeof(res) !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
 /**
  * mergeLabels — Portnet UI v2
  *
@@ -71,11 +65,10 @@ function mergeLabels(defaults, overrides) {
   // Single documented assertion, guarded by the `!overrides` check above: the
   // mapped parameter type deliberately says nothing about value types, so the
   // only way to read them is through an index signature.
-  var source = overrides;
-  var out;
-  for (var _i = 0, _Object$keys = Object.keys(source); _i < _Object$keys.length; _i++) {
-    var key = _Object$keys[_i];
-    var value = source[key];
+  const source = overrides;
+  let out;
+  for (const key of Object.keys(source)) {
+    const value = source[key];
     // THE point of this helper. `undefined` means "not specified", never
     // "unset the default".
     if (value === undefined) continue;
@@ -84,10 +77,12 @@ function mergeLabels(defaults, overrides) {
     // LAZILY — only once a real override is found — so the common paths (no
     // overrides at all, or an object whose every value is undefined) return the
     // defaults object itself and stay referentially stable across renders.
-    if (!out) out = _objectSpread({}, defaults);
+    if (!out) out = {
+      ...defaults
+    };
     out[key] = value;
   }
   return out === undefined ? defaults : out;
 }
-var _default = exports["default"] = mergeLabels;
+var _default = exports.default = mergeLabels;
 //# sourceMappingURL=mergeLabels.js.map

package/dist/v2/utils/mergeLabels.js.map

@@ -1 +1 @@
-{"version":3,"file":"mergeLabels.js","names":["mergeLabels","defaults","overrides","source","out","_i","_Object$keys","Object","keys","length","key","value","undefined","_objectSpread","_default","exports"],"sources":["../../../src/lib/v2/utils/mergeLabels.ts"],"sourcesContent":["/**\r\n * mergeLabels — Portnet UI v2\r\n *\r\n * Merges a consumer's partial label overrides onto a component's frozen\r\n * defaults, IGNORING keys whose value is `undefined`.\r\n *\r\n * ─────────────────────────────────────────────────────────────────────────────\r\n * WHY THIS EXISTS (capability gap G-14, latent runtime defect)\r\n *\r\n * Every localisable component in this library merged its labels like this:\r\n *\r\n *     const L = labels ? { ...DEFAULT_LABELS, ...labels } : DEFAULT_LABELS;\r\n *\r\n * A spread does NOT skip explicit `undefined`. `{ ...{a: 1}, ...{a: undefined} }`\r\n * is `{ a: undefined }` — so a consumer writing\r\n *\r\n *     <FilterTab labels={{ countLabel: maybeFn }} />   // maybeFn possibly undefined\r\n *\r\n * silently DELETED the default and the component then threw\r\n * `L.countLabel is not a function` at render time. Eleven components shipped\r\n * that hazard.\r\n *\r\n * It stayed invisible because the label interfaces declared `?: T` rather than\r\n * `?: T | undefined`: under that declaration TypeScript concluded the merged\r\n * value could never be `undefined`, which is false at runtime. Widening the\r\n * optional props (G-14) removed the blindfold and the compiler reported all\r\n * seventeen call sites at once. The types were wrong; the code was wrong; only\r\n * the combination of the two looked right.\r\n *\r\n * The fix restores what every call site already intended: an override REPLACES a\r\n * default, an absent or `undefined` override LEAVES it alone.\r\n * ─────────────────────────────────────────────────────────────────────────────\r\n *\r\n *     const L = mergeLabels(DEFAULT_LABELS, labels);\r\n *     //    ^ every key guaranteed present, typed from the defaults\r\n *\r\n * The return type is the DEFAULTS' type, deliberately: defaults are the\r\n * exhaustive, all-required shape, so the component can call `L.anything()`\r\n * without a null check. That is the whole point.\r\n *\r\n * `overrides` is a mapped type over `keyof TDefaults` with `unknown` values\r\n * rather than `Partial<TDefaults>`. Two reasons, both load-bearing:\r\n *   - a mapped type accepts an INTERFACE argument, whereas `Record<string,\r\n *     unknown>` would not (TypeScript grants implicit index signatures to type\r\n *     aliases, not to interfaces), and most label contracts here are interfaces;\r\n *   - some label interfaces legitimately widen a default's type (`React.ReactNode`\r\n *     where the default is a `string`), which `Partial<TDefaults>` would reject.\r\n *     Value types are already checked at the component's `labels` prop boundary,\r\n *     so nothing is lost by not re-checking them here.\r\n *\r\n * Returns the defaults object ITSELF when there is nothing to override, so the\r\n * common path allocates nothing and stays referentially stable across renders —\r\n * which matters because these results are routinely wrapped in `useMemo`.\r\n */\r\nexport function mergeLabels<TDefaults extends object>(\r\n  defaults: TDefaults,\r\n  overrides?: { readonly [K in keyof TDefaults]?: unknown } | undefined\r\n): TDefaults {\r\n  if (!overrides) return defaults;\r\n\r\n  // Single documented assertion, guarded by the `!overrides` check above: the\r\n  // mapped parameter type deliberately says nothing about value types, so the\r\n  // only way to read them is through an index signature.\r\n  const source = overrides as Record<string, unknown>;\r\n\r\n  let out: Record<string, unknown> | undefined;\r\n\r\n  for (const key of Object.keys(source)) {\r\n    const value = source[key];\r\n    // THE point of this helper. `undefined` means \"not specified\", never\r\n    // \"unset the default\".\r\n    if (value === undefined) continue;\r\n    // Second assertion, same cause: `TDefaults extends object` carries no index\r\n    // signature, so spreading it into a writable record needs one. Allocated\r\n    // LAZILY — only once a real override is found — so the common paths (no\r\n    // overrides at all, or an object whose every value is undefined) return the\r\n    // defaults object itself and stay referentially stable across renders.\r\n    if (!out) out = { ...(defaults as Record<string, unknown>) };\r\n    out[key] = value;\r\n  }\r\n\r\n  return out === undefined ? defaults : (out as TDefaults);\r\n}\r\n\r\nexport default mergeLabels;\r\n"],"mappings":";;;;;;;;;;;;;AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,SAASA,WAAWA,CACzBC,QAAmB,EACnBC,SAAqE,EAC1D;EACX,IAAI,CAACA,SAAS,EAAE,OAAOD,QAAQ;;EAE/B;EACA;EACA;EACA,IAAME,MAAM,GAAGD,SAAoC;EAEnD,IAAIE,GAAwC;EAE5C,SAAAC,EAAA,MAAAC,YAAA,GAAkBC,MAAM,CAACC,IAAI,CAACL,MAAM,CAAC,EAAAE,EAAA,GAAAC,YAAA,CAAAG,MAAA,EAAAJ,EAAA,IAAE;IAAlC,IAAMK,GAAG,GAAAJ,YAAA,CAAAD,EAAA;IACZ,IAAMM,KAAK,GAAGR,MAAM,CAACO,GAAG,CAAC;IACzB;IACA;IACA,IAAIC,KAAK,KAAKC,SAAS,EAAE;IACzB;IACA;IACA;IACA;IACA;IACA,IAAI,CAACR,GAAG,EAAEA,GAAG,GAAAS,aAAA,KAASZ,QAAQ,CAA8B;IAC5DG,GAAG,CAACM,GAAG,CAAC,GAAGC,KAAK;EAClB;EAEA,OAAOP,GAAG,KAAKQ,SAAS,GAAGX,QAAQ,GAAIG,GAAiB;AAC1D;AAAC,IAAAU,QAAA,GAAAC,OAAA,cAEcf,WAAW","ignoreList":[]}
+{"version":3,"file":"mergeLabels.js","names":["mergeLabels","defaults","overrides","source","out","key","Object","keys","value","undefined","_default","exports","default"],"sources":["../../../src/lib/v2/utils/mergeLabels.ts"],"sourcesContent":["/**\r\n * mergeLabels — Portnet UI v2\r\n *\r\n * Merges a consumer's partial label overrides onto a component's frozen\r\n * defaults, IGNORING keys whose value is `undefined`.\r\n *\r\n * ─────────────────────────────────────────────────────────────────────────────\r\n * WHY THIS EXISTS (capability gap G-14, latent runtime defect)\r\n *\r\n * Every localisable component in this library merged its labels like this:\r\n *\r\n *     const L = labels ? { ...DEFAULT_LABELS, ...labels } : DEFAULT_LABELS;\r\n *\r\n * A spread does NOT skip explicit `undefined`. `{ ...{a: 1}, ...{a: undefined} }`\r\n * is `{ a: undefined }` — so a consumer writing\r\n *\r\n *     <FilterTab labels={{ countLabel: maybeFn }} />   // maybeFn possibly undefined\r\n *\r\n * silently DELETED the default and the component then threw\r\n * `L.countLabel is not a function` at render time. Eleven components shipped\r\n * that hazard.\r\n *\r\n * It stayed invisible because the label interfaces declared `?: T` rather than\r\n * `?: T | undefined`: under that declaration TypeScript concluded the merged\r\n * value could never be `undefined`, which is false at runtime. Widening the\r\n * optional props (G-14) removed the blindfold and the compiler reported all\r\n * seventeen call sites at once. The types were wrong; the code was wrong; only\r\n * the combination of the two looked right.\r\n *\r\n * The fix restores what every call site already intended: an override REPLACES a\r\n * default, an absent or `undefined` override LEAVES it alone.\r\n * ─────────────────────────────────────────────────────────────────────────────\r\n *\r\n *     const L = mergeLabels(DEFAULT_LABELS, labels);\r\n *     //    ^ every key guaranteed present, typed from the defaults\r\n *\r\n * The return type is the DEFAULTS' type, deliberately: defaults are the\r\n * exhaustive, all-required shape, so the component can call `L.anything()`\r\n * without a null check. That is the whole point.\r\n *\r\n * `overrides` is a mapped type over `keyof TDefaults` with `unknown` values\r\n * rather than `Partial<TDefaults>`. Two reasons, both load-bearing:\r\n *   - a mapped type accepts an INTERFACE argument, whereas `Record<string,\r\n *     unknown>` would not (TypeScript grants implicit index signatures to type\r\n *     aliases, not to interfaces), and most label contracts here are interfaces;\r\n *   - some label interfaces legitimately widen a default's type (`React.ReactNode`\r\n *     where the default is a `string`), which `Partial<TDefaults>` would reject.\r\n *     Value types are already checked at the component's `labels` prop boundary,\r\n *     so nothing is lost by not re-checking them here.\r\n *\r\n * Returns the defaults object ITSELF when there is nothing to override, so the\r\n * common path allocates nothing and stays referentially stable across renders —\r\n * which matters because these results are routinely wrapped in `useMemo`.\r\n */\r\nexport function mergeLabels<TDefaults extends object>(\r\n  defaults: TDefaults,\r\n  overrides?: { readonly [K in keyof TDefaults]?: unknown } | undefined\r\n): TDefaults {\r\n  if (!overrides) return defaults;\r\n\r\n  // Single documented assertion, guarded by the `!overrides` check above: the\r\n  // mapped parameter type deliberately says nothing about value types, so the\r\n  // only way to read them is through an index signature.\r\n  const source = overrides as Record<string, unknown>;\r\n\r\n  let out: Record<string, unknown> | undefined;\r\n\r\n  for (const key of Object.keys(source)) {\r\n    const value = source[key];\r\n    // THE point of this helper. `undefined` means \"not specified\", never\r\n    // \"unset the default\".\r\n    if (value === undefined) continue;\r\n    // Second assertion, same cause: `TDefaults extends object` carries no index\r\n    // signature, so spreading it into a writable record needs one. Allocated\r\n    // LAZILY — only once a real override is found — so the common paths (no\r\n    // overrides at all, or an object whose every value is undefined) return the\r\n    // defaults object itself and stay referentially stable across renders.\r\n    if (!out) out = { ...(defaults as Record<string, unknown>) };\r\n    out[key] = value;\r\n  }\r\n\r\n  return out === undefined ? defaults : (out as TDefaults);\r\n}\r\n\r\nexport default mergeLabels;\r\n"],"mappings":";;;;;;;AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,SAASA,WAAWA,CACzBC,QAAmB,EACnBC,SAAqE,EAC1D;EACX,IAAI,CAACA,SAAS,EAAE,OAAOD,QAAQ;;EAE/B;EACA;EACA;EACA,MAAME,MAAM,GAAGD,SAAoC;EAEnD,IAAIE,GAAwC;EAE5C,KAAK,MAAMC,GAAG,IAAIC,MAAM,CAACC,IAAI,CAACJ,MAAM,CAAC,EAAE;IACrC,MAAMK,KAAK,GAAGL,MAAM,CAACE,GAAG,CAAC;IACzB;IACA;IACA,IAAIG,KAAK,KAAKC,SAAS,EAAE;IACzB;IACA;IACA;IACA;IACA;IACA,IAAI,CAACL,GAAG,EAAEA,GAAG,GAAG;MAAE,GAAIH;IAAqC,CAAC;IAC5DG,GAAG,CAACC,GAAG,CAAC,GAAGG,KAAK;EAClB;EAEA,OAAOJ,GAAG,KAAKK,SAAS,GAAGR,QAAQ,GAAIG,GAAiB;AAC1D;AAAC,IAAAM,QAAA,GAAAC,OAAA,CAAAC,OAAA,GAEcZ,WAAW","ignoreList":[]}