@portnet/ui 5.0.32 → 6.0.1

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

@@ -0,0 +1,28 @@
+/**
+ * fmtMoney — format a number with locale-aware grouping.
+ *
+ * Returns "—" for null / empty / non-finite inputs (graceful empty
+ * cells in tables — never "NaN" or "∞").
+ *
+ * Defaults to "fr-FR" for back-compat with v1 callers; pass `locale`
+ * (BCP-47 tag) to format under any locale supported by the runtime
+ * Intl.NumberFormat. Currency placement is a trailing suffix in the
+ * locale-formatted number; future evolution toward `style:"currency"`
+ * (locale-correct symbol position, proper RTL handling) is deliberately
+ * deferred to avoid breaking consumers that grep on the suffix.
+ *
+ *   fmtMoney(1234567.5)                              → "1 234 567,5"
+ *   fmtMoney(1234567.5, "EUR")                       → "1 234 567,5 EUR"
+ *   fmtMoney(1234567.5, "EUR", { locale: "en-US" })  → "1,234,567.5 EUR"
+ *   fmtMoney(1234.5,    "",    { minimumFractionDigits: 2 })
+ *                                                    → "1 234,50"
+ *   fmtMoney(null) / fmtMoney("abc") / fmtMoney(Infinity) → "—"
+ */
+type FmtMoneyOptions = {
+    locale?: string;
+    minimumFractionDigits?: number;
+    maximumFractionDigits?: number;
+};
+export default function fmtMoney(n: number | string | null | undefined, currency?: string, opts?: FmtMoneyOptions): string;
+export {};
+//# sourceMappingURL=fmtMoney.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"fmtMoney.d.ts","sourceRoot":"","sources":["../../../src/lib/v2/utils/fmtMoney.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,KAAK,eAAe,GAAG;IACrB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,qBAAqB,CAAC,EAAE,MAAM,CAAC;IAC/B,qBAAqB,CAAC,EAAE,MAAM,CAAC;CAChC,CAAC;AA+BF,MAAM,CAAC,OAAO,UAAU,QAAQ,CAC9B,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,GAAG,SAAS,EACrC,QAAQ,GAAE,MAAW,EACrB,IAAI,GAAE,eAAoB,GACzB,MAAM,CAgCR"}

package/dist/v2/utils/fmtMoney.js

@@ -0,0 +1,84 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = fmtMoney;
+/**
+ * fmtMoney — format a number with locale-aware grouping.
+ *
+ * Returns "—" for null / empty / non-finite inputs (graceful empty
+ * cells in tables — never "NaN" or "∞").
+ *
+ * Defaults to "fr-FR" for back-compat with v1 callers; pass `locale`
+ * (BCP-47 tag) to format under any locale supported by the runtime
+ * Intl.NumberFormat. Currency placement is a trailing suffix in the
+ * locale-formatted number; future evolution toward `style:"currency"`
+ * (locale-correct symbol position, proper RTL handling) is deliberately
+ * deferred to avoid breaking consumers that grep on the suffix.
+ *
+ *   fmtMoney(1234567.5)                              → "1 234 567,5"
+ *   fmtMoney(1234567.5, "EUR")                       → "1 234 567,5 EUR"
+ *   fmtMoney(1234567.5, "EUR", { locale: "en-US" })  → "1,234,567.5 EUR"
+ *   fmtMoney(1234.5,    "",    { minimumFractionDigits: 2 })
+ *                                                    → "1 234,50"
+ *   fmtMoney(null) / fmtMoney("abc") / fmtMoney(Infinity) → "—"
+ */
+
+/**
+ * The locale every unresolvable request falls back to.
+ *
+ * ── WHY THIS IS NEGOTIATED, NOT JUST CAUGHT ─────────────────────────────
+ *
+ * The previous implementation relied ONLY on `try/catch`, on the assumption that
+ * an unusable locale throws `RangeError`. It does not — and the gap was a live
+ * defect, not a theoretical one:
+ *
+ *   `Intl.NumberFormat` throws only on a STRUCTURALLY INVALID tag. A tag that is
+ *   well-formed but has no data does NOT throw — it negotiates, and with a single
+ *   unmatched tag the negotiation lands on the RUNTIME DEFAULT LOCALE.
+ *
+ * `"not-a-real-locale"` is well-formed: `not` parses as a 3-letter language
+ * subtag and `-a-real-locale` as a singleton `a` extension sequence. So it never
+ * threw, the `catch` never ran, and the result was formatted in whatever locale
+ * the host happened to default to. On a German or Spanish host that renders
+ * `"1.234,5"` — dot grouping — inside a French application.
+ *
+ * That is a real consistency breach (Charter §09: a French UI formats numbers in
+ * French), and it is invisible on a French dev machine, which is exactly why it
+ * survived: the unit test caught it only because CI ran under a non-FR default.
+ *
+ * Listing the fallback as the SECOND preference makes the guarantee explicit:
+ * 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] : {};
+  if (n == null || n === "") return "—";
+  var num = typeof n === "number" ? n : Number(n);
+  if (!Number.isFinite(num)) return "—";
+  var locale = opts.locale || FALLBACK_LOCALE;
+  var formatOpts = {};
+  if (opts.minimumFractionDigits != null) {
+    formatOpts.minimumFractionDigits = opts.minimumFractionDigits;
+  }
+  if (opts.maximumFractionDigits != null) {
+    formatOpts.maximumFractionDigits = opts.maximumFractionDigits;
+  }
+  var 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) {
+    /* 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;
+}
+//# sourceMappingURL=fmtMoney.js.map

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

@@ -0,0 +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":[]}

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

@@ -0,0 +1,9 @@
+export { cx } from "./cx";
+export { default as fmtMoney } from "./fmtMoney";
+export { mergeLabels } from "./mergeLabels";
+export { downloadBase64File, getMimeType, openBase64FileInTab, downloadBlobFile, } from "./fileDownload";
+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";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +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"}

package/dist/v2/utils/index.js

@@ -0,0 +1,97 @@
+"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() {
+    return _apiError.DEFAULT_API_ERROR_MESSAGE;
+  }
+});
+exports.contrast = void 0;
+Object.defineProperty(exports, "createNetworkStatus", {
+  enumerable: true,
+  get: function get() {
+    return _networkStatus.createNetworkStatus;
+  }
+});
+Object.defineProperty(exports, "cx", {
+  enumerable: true,
+  get: function get() {
+    return _cx.cx;
+  }
+});
+Object.defineProperty(exports, "downloadBase64File", {
+  enumerable: true,
+  get: function get() {
+    return _fileDownload.downloadBase64File;
+  }
+});
+Object.defineProperty(exports, "downloadBlobFile", {
+  enumerable: true,
+  get: function get() {
+    return _fileDownload.downloadBlobFile;
+  }
+});
+Object.defineProperty(exports, "fmtMoney", {
+  enumerable: true,
+  get: function get() {
+    return _fmtMoney["default"];
+  }
+});
+Object.defineProperty(exports, "getApiErrorDetail", {
+  enumerable: true,
+  get: function get() {
+    return _apiError.getApiErrorDetail;
+  }
+});
+Object.defineProperty(exports, "getApiErrorMessage", {
+  enumerable: true,
+  get: function get() {
+    return _apiError.getApiErrorMessage;
+  }
+});
+Object.defineProperty(exports, "getApiErrorStatus", {
+  enumerable: true,
+  get: function get() {
+    return _apiError.getApiErrorStatus;
+  }
+});
+Object.defineProperty(exports, "getMimeType", {
+  enumerable: true,
+  get: function get() {
+    return _fileDownload.getMimeType;
+  }
+});
+Object.defineProperty(exports, "mergeLabels", {
+  enumerable: true,
+  get: function get() {
+    return _mergeLabels.mergeLabels;
+  }
+});
+Object.defineProperty(exports, "networkStatus", {
+  enumerable: true,
+  get: function get() {
+    return _networkStatus.networkStatus;
+  }
+});
+Object.defineProperty(exports, "openBase64FileInTab", {
+  enumerable: true,
+  get: function get() {
+    return _fileDownload.openBase64FileInTab;
+  }
+});
+var _cx = require("./cx");
+var _fmtMoney = _interopRequireDefault(require("./fmtMoney"));
+var _mergeLabels = require("./mergeLabels");
+var _fileDownload = require("./fileDownload");
+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 }; }
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +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":[]}

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

@@ -0,0 +1,59 @@
+/**
+ * mergeLabels — Portnet UI v2
+ *
+ * Merges a consumer's partial label overrides onto a component's frozen
+ * defaults, IGNORING keys whose value is `undefined`.
+ *
+ * ─────────────────────────────────────────────────────────────────────────────
+ * WHY THIS EXISTS (capability gap G-14, latent runtime defect)
+ *
+ * Every localisable component in this library merged its labels like this:
+ *
+ *     const L = labels ? { ...DEFAULT_LABELS, ...labels } : DEFAULT_LABELS;
+ *
+ * A spread does NOT skip explicit `undefined`. `{ ...{a: 1}, ...{a: undefined} }`
+ * is `{ a: undefined }` — so a consumer writing
+ *
+ *     <FilterTab labels={{ countLabel: maybeFn }} />   // maybeFn possibly undefined
+ *
+ * silently DELETED the default and the component then threw
+ * `L.countLabel is not a function` at render time. Eleven components shipped
+ * that hazard.
+ *
+ * It stayed invisible because the label interfaces declared `?: T` rather than
+ * `?: T | undefined`: under that declaration TypeScript concluded the merged
+ * value could never be `undefined`, which is false at runtime. Widening the
+ * optional props (G-14) removed the blindfold and the compiler reported all
+ * seventeen call sites at once. The types were wrong; the code was wrong; only
+ * the combination of the two looked right.
+ *
+ * The fix restores what every call site already intended: an override REPLACES a
+ * default, an absent or `undefined` override LEAVES it alone.
+ * ─────────────────────────────────────────────────────────────────────────────
+ *
+ *     const L = mergeLabels(DEFAULT_LABELS, labels);
+ *     //    ^ every key guaranteed present, typed from the defaults
+ *
+ * The return type is the DEFAULTS' type, deliberately: defaults are the
+ * exhaustive, all-required shape, so the component can call `L.anything()`
+ * without a null check. That is the whole point.
+ *
+ * `overrides` is a mapped type over `keyof TDefaults` with `unknown` values
+ * rather than `Partial<TDefaults>`. Two reasons, both load-bearing:
+ *   - a mapped type accepts an INTERFACE argument, whereas `Record<string,
+ *     unknown>` would not (TypeScript grants implicit index signatures to type
+ *     aliases, not to interfaces), and most label contracts here are interfaces;
+ *   - some label interfaces legitimately widen a default's type (`React.ReactNode`
+ *     where the default is a `string`), which `Partial<TDefaults>` would reject.
+ *     Value types are already checked at the component's `labels` prop boundary,
+ *     so nothing is lost by not re-checking them here.
+ *
+ * Returns the defaults object ITSELF when there is nothing to override, so the
+ * common path allocates nothing and stays referentially stable across renders —
+ * which matters because these results are routinely wrapped in `useMemo`.
+ */
+export declare function mergeLabels<TDefaults extends object>(defaults: TDefaults, overrides?: {
+    readonly [K in keyof TDefaults]?: unknown;
+} | undefined): TDefaults;
+export default mergeLabels;
+//# sourceMappingURL=mergeLabels.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"mergeLabels.d.ts","sourceRoot":"","sources":["../../../src/lib/v2/utils/mergeLabels.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqDG;AACH,wBAAgB,WAAW,CAAC,SAAS,SAAS,MAAM,EAClD,QAAQ,EAAE,SAAS,EACnB,SAAS,CAAC,EAAE;IAAE,QAAQ,EAAE,CAAC,IAAI,MAAM,SAAS,CAAC,CAAC,EAAE,OAAO;CAAE,GAAG,SAAS,GACpE,SAAS,CAyBX;AAED,eAAe,WAAW,CAAC"}

package/dist/v2/utils/mergeLabels.js

@@ -0,0 +1,93 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+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
+ *
+ * Merges a consumer's partial label overrides onto a component's frozen
+ * defaults, IGNORING keys whose value is `undefined`.
+ *
+ * ─────────────────────────────────────────────────────────────────────────────
+ * WHY THIS EXISTS (capability gap G-14, latent runtime defect)
+ *
+ * Every localisable component in this library merged its labels like this:
+ *
+ *     const L = labels ? { ...DEFAULT_LABELS, ...labels } : DEFAULT_LABELS;
+ *
+ * A spread does NOT skip explicit `undefined`. `{ ...{a: 1}, ...{a: undefined} }`
+ * is `{ a: undefined }` — so a consumer writing
+ *
+ *     <FilterTab labels={{ countLabel: maybeFn }} />   // maybeFn possibly undefined
+ *
+ * silently DELETED the default and the component then threw
+ * `L.countLabel is not a function` at render time. Eleven components shipped
+ * that hazard.
+ *
+ * It stayed invisible because the label interfaces declared `?: T` rather than
+ * `?: T | undefined`: under that declaration TypeScript concluded the merged
+ * value could never be `undefined`, which is false at runtime. Widening the
+ * optional props (G-14) removed the blindfold and the compiler reported all
+ * seventeen call sites at once. The types were wrong; the code was wrong; only
+ * the combination of the two looked right.
+ *
+ * The fix restores what every call site already intended: an override REPLACES a
+ * default, an absent or `undefined` override LEAVES it alone.
+ * ─────────────────────────────────────────────────────────────────────────────
+ *
+ *     const L = mergeLabels(DEFAULT_LABELS, labels);
+ *     //    ^ every key guaranteed present, typed from the defaults
+ *
+ * The return type is the DEFAULTS' type, deliberately: defaults are the
+ * exhaustive, all-required shape, so the component can call `L.anything()`
+ * without a null check. That is the whole point.
+ *
+ * `overrides` is a mapped type over `keyof TDefaults` with `unknown` values
+ * rather than `Partial<TDefaults>`. Two reasons, both load-bearing:
+ *   - a mapped type accepts an INTERFACE argument, whereas `Record<string,
+ *     unknown>` would not (TypeScript grants implicit index signatures to type
+ *     aliases, not to interfaces), and most label contracts here are interfaces;
+ *   - some label interfaces legitimately widen a default's type (`React.ReactNode`
+ *     where the default is a `string`), which `Partial<TDefaults>` would reject.
+ *     Value types are already checked at the component's `labels` prop boundary,
+ *     so nothing is lost by not re-checking them here.
+ *
+ * Returns the defaults object ITSELF when there is nothing to override, so the
+ * common path allocates nothing and stays referentially stable across renders —
+ * which matters because these results are routinely wrapped in `useMemo`.
+ */
+function mergeLabels(defaults, overrides) {
+  if (!overrides) return defaults;
+
+  // 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];
+    // THE point of this helper. `undefined` means "not specified", never
+    // "unset the default".
+    if (value === undefined) continue;
+    // Second assertion, same cause: `TDefaults extends object` carries no index
+    // signature, so spreading it into a writable record needs one. Allocated
+    // 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);
+    out[key] = value;
+  }
+  return out === undefined ? defaults : out;
+}
+var _default = exports["default"] = mergeLabels;
+//# sourceMappingURL=mergeLabels.js.map

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

@@ -0,0 +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":[]}

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

@@ -0,0 +1,88 @@
+/**
+ * networkStatus — the feed behind `NetworkErrorBanner`.
+ *
+ * ─────────────────────────────────────────────────────────────────────────────
+ * WHY THIS BELONGS IN THE LIBRARY (capability gap G-03)
+ *
+ * The library shipped `NetworkErrorBanner` — a presentational component — but
+ * not the plumbing that decides when it appears. Charter R-A.3 / R-4.3 make the
+ * banner MANDATORY ("erreur réseau → bandeau persistant top, bouton
+ * « Réessayer »"), so every consuming module had to invent the same
+ * subscribe / report / clear singleton and the same transport-interceptor
+ * bridge. Two audited modules (`procuration-portnet-fe`, `procuration-fe`) had
+ * each written their own.
+ *
+ * A presentational component whose trigger contract is left to consumers
+ * guarantees divergence in precisely the state users encounter least often and
+ * trust least — the offline path.
+ *
+ * NOT a redux slice, deliberately
+ * -------------------------------
+ * This state is presentation-only and high-frequency on a flaky link. Crossing a
+ * dispatch boundary on every retry would slow the alert path for no benefit, and
+ * would force the library to take an opinion on the host's store.
+ *
+ * Late subscribers are hydrated on subscribe, so a banner that mounts after the
+ * failure (lazy route, remount) still shows the current state instead of missing
+ * the edge.
+ * ─────────────────────────────────────────────────────────────────────────────
+ *
+ * Wiring (once, at the app root):
+ *
+ *   const [netError, setNetError] = useState<string | null>(null);
+ *   useEffect(() => networkStatus.subscribe(setNetError), []);
+ *
+ *   <NetworkErrorBanner
+ *     visible={Boolean(netError)}
+ *     message={netError ?? ""}
+ *     onRetry={() => { networkStatus.clear(); window.location.reload(); }}
+ *   />
+ *
+ * And in the transport layer:
+ *
+ *   instance.interceptors.response.use(
+ *     (response) => { networkStatus.clear(); return response; },
+ *     (error: unknown) => {
+ *       if (getApiErrorStatus(error) === undefined) {
+ *         networkStatus.report("Connexion perdue. Vérifiez votre réseau, puis réessayez.");
+ *       }
+ *       return Promise.reject(error);
+ *     }
+ *   );
+ *
+ * A status-less failure is the network case (offline, DNS, ingress timeout); a
+ * failure WITH a status is a server error and belongs in a toast (R-A.4).
+ */
+/** Receives the latest banner message, or `null` when the banner should clear. */
+export type NetworkStatusListener = (message: string | null) => void;
+/** Public shape of a network-status channel. */
+export interface NetworkStatus {
+    /**
+     * Subscribe to changes. The listener is invoked immediately with the current
+     * state when that state is non-null, so a late-mounting banner hydrates
+     * instead of missing the transition. Returns an unsubscribe function suitable
+     * for returning directly from `useEffect`.
+     */
+    subscribe(listener: NetworkStatusListener): () => void;
+    /** Report a global network failure. `null` (or omitted) clears. */
+    report(message?: string | null): void;
+    /** Clear the banner. Equivalent to `report(null)`. */
+    clear(): void;
+    /** Current message, or `null`. Useful in tests and for SSR snapshots. */
+    current(): string | null;
+}
+/**
+ * Create an independent network-status channel.
+ *
+ * Exported alongside the shared singleton so tests can use an isolated instance
+ * — a module-level singleton shared between test cases leaks state across them.
+ * Application code should normally use the `networkStatus` export below.
+ */
+export declare function createNetworkStatus(): NetworkStatus;
+/**
+ * The shared channel. One per bundle, which is the right granularity: the
+ * transport layer and the banner must agree, and both live in the same app.
+ */
+export declare const networkStatus: NetworkStatus;
+export default networkStatus;
+//# sourceMappingURL=networkStatus.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"networkStatus.d.ts","sourceRoot":"","sources":["../../../src/lib/v2/utils/networkStatus.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsDG;AAEH,kFAAkF;AAClF,MAAM,MAAM,qBAAqB,GAAG,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,KAAK,IAAI,CAAC;AAErE,gDAAgD;AAChD,MAAM,WAAW,aAAa;IAC5B;;;;;OAKG;IACH,SAAS,CAAC,QAAQ,EAAE,qBAAqB,GAAG,MAAM,IAAI,CAAC;IACvD,mEAAmE;IACnE,MAAM,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,IAAI,GAAG,IAAI,CAAC;IACtC,sDAAsD;IACtD,KAAK,IAAI,IAAI,CAAC;IACd,yEAAyE;IACzE,OAAO,IAAI,MAAM,GAAG,IAAI,CAAC;CAC1B;AAED;;;;;;GAMG;AACH,wBAAgB,mBAAmB,IAAI,aAAa,CA2CnD;AAED;;;GAGG;AACH,eAAO,MAAM,aAAa,EAAE,aAAqC,CAAC;AAElE,eAAe,aAAa,CAAC"}

package/dist/v2/utils/networkStatus.js

@@ -0,0 +1,121 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createNetworkStatus = createNetworkStatus;
+exports.networkStatus = exports["default"] = void 0;
+/**
+ * networkStatus — the feed behind `NetworkErrorBanner`.
+ *
+ * ─────────────────────────────────────────────────────────────────────────────
+ * WHY THIS BELONGS IN THE LIBRARY (capability gap G-03)
+ *
+ * The library shipped `NetworkErrorBanner` — a presentational component — but
+ * not the plumbing that decides when it appears. Charter R-A.3 / R-4.3 make the
+ * banner MANDATORY ("erreur réseau → bandeau persistant top, bouton
+ * « Réessayer »"), so every consuming module had to invent the same
+ * subscribe / report / clear singleton and the same transport-interceptor
+ * bridge. Two audited modules (`procuration-portnet-fe`, `procuration-fe`) had
+ * each written their own.
+ *
+ * A presentational component whose trigger contract is left to consumers
+ * guarantees divergence in precisely the state users encounter least often and
+ * trust least — the offline path.
+ *
+ * NOT a redux slice, deliberately
+ * -------------------------------
+ * This state is presentation-only and high-frequency on a flaky link. Crossing a
+ * dispatch boundary on every retry would slow the alert path for no benefit, and
+ * would force the library to take an opinion on the host's store.
+ *
+ * Late subscribers are hydrated on subscribe, so a banner that mounts after the
+ * failure (lazy route, remount) still shows the current state instead of missing
+ * the edge.
+ * ─────────────────────────────────────────────────────────────────────────────
+ *
+ * Wiring (once, at the app root):
+ *
+ *   const [netError, setNetError] = useState<string | null>(null);
+ *   useEffect(() => networkStatus.subscribe(setNetError), []);
+ *
+ *   <NetworkErrorBanner
+ *     visible={Boolean(netError)}
+ *     message={netError ?? ""}
+ *     onRetry={() => { networkStatus.clear(); window.location.reload(); }}
+ *   />
+ *
+ * And in the transport layer:
+ *
+ *   instance.interceptors.response.use(
+ *     (response) => { networkStatus.clear(); return response; },
+ *     (error: unknown) => {
+ *       if (getApiErrorStatus(error) === undefined) {
+ *         networkStatus.report("Connexion perdue. Vérifiez votre réseau, puis réessayez.");
+ *       }
+ *       return Promise.reject(error);
+ *     }
+ *   );
+ *
+ * A status-less failure is the network case (offline, DNS, ingress timeout); a
+ * failure WITH a status is a server error and belongs in a toast (R-A.4).
+ */
+
+/** Receives the latest banner message, or `null` when the banner should clear. */
+
+/** Public shape of a network-status channel. */
+
+/**
+ * Create an independent network-status channel.
+ *
+ * Exported alongside the shared singleton so tests can use an isolated instance
+ * — a module-level singleton shared between test cases leaks state across them.
+ * Application code should normally use the `networkStatus` export below.
+ */
+function createNetworkStatus() {
+  var subscribers = new Set();
+  var lastError = null;
+  var channel = {
+    subscribe: function subscribe(listener) {
+      subscribers.add(listener);
+      if (lastError !== null) listener(lastError);
+      return function () {
+        subscribers["delete"](listener);
+      };
+    },
+    report: function report(message) {
+      var next = message || null;
+      /* De-duplicated: a flaky link can fail many times per second, and
+       * re-notifying an unchanged message would re-render every subscriber for
+       * no visible difference. */
+      if (lastError === next) return;
+      lastError = next;
+      subscribers.forEach(function (listener) {
+        try {
+          listener(lastError);
+        } catch (e) {
+          /* One bad subscriber must not stop the others from being notified,
+           * and must not propagate into the transport layer that reported the
+           * failure. */
+          // eslint-disable-next-line no-console
+          console.error("[@portnet/ui networkStatus] subscriber threw:", e);
+        }
+      });
+    },
+    clear: function clear() {
+      channel.report(null);
+    },
+    current: function current() {
+      return lastError;
+    }
+  };
+  return channel;
+}
+
+/**
+ * The shared channel. One per bundle, which is the right granularity: the
+ * transport layer and the banner must agree, and both live in the same app.
+ */
+var networkStatus = exports.networkStatus = createNetworkStatus();
+var _default = exports["default"] = networkStatus;
+//# sourceMappingURL=networkStatus.js.map