tempest-react-sdk 0.77.0 → 0.79.0

package/dist/utils/format.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"format.cjs","names":[],"sources":["../../src/utils/format.ts"],"sourcesContent":["import { fallbackText, isAbsent, type FormatFallbackOptions } from \"@/utils/absent\";\nimport { dateTimeFormat, numberFormat } from \"@/utils/intl-cache\";\n\n/**\n * Format a number as Brazilian Real currency.\n *\n * An absent or unrepresentable amount renders as `\"—\"` rather than as a number.\n * That branch is a data-correctness fix, not cosmetics: `Intl` coerces `null` to\n * zero, so an amount the backend left out used to reach the screen as\n * **`\"R$ 0,00\"`** — a plausible figure a reader has no way to question — and\n * `undefined` as `\"R$ NaN\"`.\n *\n * @example\n * ```typescript\n * formatCurrency(1234.56);                      // \"R$ 1.234,56\"\n * formatCurrency(null);                         // \"—\"\n * formatCurrency(null, { fallback: \"sem valor\" }); // \"sem valor\"\n * ```\n *\n * @param value - The amount in BRL, or `null`/`undefined` when there is none.\n * @param options - Text to render when there is nothing to format.\n * @returns A locale-formatted string, e.g. \"R$ 1.234,56\".\n */\nexport function formatCurrency(\n    value: number | null | undefined,\n    options?: FormatFallbackOptions,\n): string {\n    if (isAbsent(value) || !Number.isFinite(value)) return fallbackText(options);\n    return numberFormat(\"pt-BR\", { style: \"currency\", currency: \"BRL\" }).format(value);\n}\n\n/**\n * Format an ISO date or Date instance as `dd/MM/yyyy`.\n *\n * Absent input answers `\"—\"`. It used to **throw**: `new Date(null)` is epoch and\n * `null.getTime` is a `TypeError`, so a nullable column — which is every\n * `deleted_at`, `expires_at` and half the `updated_at` a FastAPI backend sends —\n * took the screen down instead of rendering a gap.\n *\n * A value that is present and unparseable still answers `\"\"`, deliberately: on a\n * screen that reads a log, \"nobody filled this in\" and \"what they filled in is\n * broken\" are different findings, and the second is the one worth chasing.\n *\n * @example\n * ```typescript\n * formatDate(\"2026-05-16T12:00:00Z\"); // \"16/05/2026\"\n * formatDate(null);                   // \"—\"\n * formatDate(\"banana\");               // \"\"\n * ```\n *\n * @param value - ISO string, Date, or `null`/`undefined`.\n * @param options - Text to render when the value is absent.\n * @returns Formatted date string, the fallback when absent, or empty string when\n *   the value is present and invalid.\n */\nexport function formatDate(\n    value: string | Date | null | undefined,\n    options?: FormatFallbackOptions,\n): string {\n    if (isAbsent(value)) return fallbackText(options);\n    const date = typeof value === \"string\" ? new Date(value) : value;\n    if (Number.isNaN(date.getTime())) return \"\";\n    return dateTimeFormat(\"pt-BR\").format(date);\n}\n\n/**\n * Format an ISO date or Date instance as `yyyy-MM-dd`, the value an\n * `<input type=\"date\">` accepts.\n *\n * Built from the **local** calendar parts rather than `toISOString().slice(0, 10)`,\n * which is the reflex and which is wrong: `toISOString` converts to UTC first, so\n * anything after 21:00 in UTC-3 reports the next day and the form opens on the\n * wrong date. `formatDate` cannot fill this role because a date input rejects\n * `dd/MM/yyyy` outright.\n *\n * A value that is already `yyyy-MM-dd` is returned untouched, and that shortcut\n * is load-bearing rather than an optimisation: `new Date(\"2026-05-16\")` is parsed\n * as **UTC** midnight, which in UTC-3 is the 15th at 21:00, so round-tripping the\n * exact value a backend sent would move it back a day.\n *\n * @example\n * <input type=\"date\" defaultValue={formatDateForInput(order.createdAt)} />\n *\n * Absent input answers `\"\"` here — **not** the em dash the reading formatters\n * use — because that is what an input reads as \"no value\"; an em dash would\n * arrive as content the user has to delete before typing a date.\n *\n * @param value - ISO string, Date, or `null`/`undefined`.\n * @param options - Text for an absent value; defaults to `\"\"`.\n * @returns The `yyyy-MM-dd` value, or an empty string when the input is invalid —\n *   which is what a date input reads as \"no value\", unlike `\"Invalid Date\"`.\n */\nexport function formatDateForInput(\n    value: string | Date | null | undefined,\n    options?: FormatFallbackOptions,\n): string {\n    if (isAbsent(value)) return fallbackText(options, \"\");\n    if (typeof value === \"string\" && /^\\d{4}-\\d{2}-\\d{2}$/.test(value)) return value;\n    const date = typeof value === \"string\" ? new Date(value) : value;\n    if (Number.isNaN(date.getTime())) return \"\";\n    const month = `${date.getMonth() + 1}`.padStart(2, \"0\");\n    const day = `${date.getDate()}`.padStart(2, \"0\");\n    return `${date.getFullYear()}-${month}-${day}`;\n}\n\n/**\n * Format an ISO date or Date instance as `yyyy-MM-ddTHH:mm`, the value an\n * `<input type=\"datetime-local\">` accepts.\n *\n * The sibling of {@link formatDateForInput}, and it exists for the same reason:\n * `toISOString().slice(0, 16)` is the reflex and it is wrong. `toISOString`\n * converts to UTC first, so a 22:00 appointment in UTC-3 opens the form on the\n * next day at 01:00 — here the trap costs the hour as well as the date.\n *\n * A value already in `yyyy-MM-ddTHH:mm` is returned untouched. A value carrying\n * a zone (`...Z`, `...-03:00`) deliberately does **not** take that shortcut: it\n * is a different instant from the naive string that looks like it, so it is\n * converted to the local calendar parts the input has to show.\n *\n * Seconds are dropped. A `datetime-local` steps by the minute unless the app\n * sets `step`, so a `:ss` the field cannot represent would be silently discarded\n * on the first edit anyway — truncating here keeps the rendered value and the\n * submitted value the same.\n *\n * @example\n * <input\n *     type=\"datetime-local\"\n *     defaultValue={formatDateTimeForInput(appointment.startsAt)}\n * />\n *\n * @param value - ISO string or Date.\n * @returns The `yyyy-MM-ddTHH:mm` value, or an empty string when the input is\n *   invalid — which is what a datetime input reads as \"no value\", unlike\n *   `\"Invalid Date\"`.\n */\nexport function formatDateTimeForInput(\n    value: string | Date | null | undefined,\n    options?: FormatFallbackOptions,\n): string {\n    if (isAbsent(value)) return fallbackText(options, \"\");\n    if (typeof value === \"string\" && /^\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}$/.test(value)) return value;\n    const date = typeof value === \"string\" ? new Date(value) : value;\n    if (Number.isNaN(date.getTime())) return \"\";\n    const month = `${date.getMonth() + 1}`.padStart(2, \"0\");\n    const day = `${date.getDate()}`.padStart(2, \"0\");\n    const hours = `${date.getHours()}`.padStart(2, \"0\");\n    const minutes = `${date.getMinutes()}`.padStart(2, \"0\");\n    return `${date.getFullYear()}-${month}-${day}T${hours}:${minutes}`;\n}\n\n/**\n * Format an ISO date or Date instance as `dd/MM/yyyy HH:mm`.\n *\n * Same contract as {@link formatDate}: absent answers the fallback (`\"—\"` by\n * default) instead of throwing, and present-but-invalid answers `\"\"`.\n *\n * @param value - ISO string, Date, or `null`/`undefined`.\n * @param options - Text to render when the value is absent.\n * @returns Formatted datetime string, the fallback when absent, or empty string\n *   when the value is present and invalid.\n */\nexport function formatDateTime(\n    value: string | Date | null | undefined,\n    options?: FormatFallbackOptions,\n): string {\n    if (isAbsent(value)) return fallbackText(options);\n    const date = typeof value === \"string\" ? new Date(value) : value;\n    if (Number.isNaN(date.getTime())) return \"\";\n    return dateTimeFormat(\"pt-BR\", { dateStyle: \"short\", timeStyle: \"short\" }).format(date);\n}\n\nexport interface FormatPhoneOptions {\n    /**\n     * Treat the number as a mobile line: insert the mandatory `9` after the area\n     * code when it is missing, and group the subscriber part `5+4` from the\n     * first digit typed instead of waiting for the eleventh.\n     *\n     * Default `false`, which keeps the length-based behaviour: `4+4` up to ten\n     * digits, `5+4` at eleven.\n     */\n    mobile?: boolean;\n}\n\n/**\n * Apply the Brazilian phone mask `(XX) XXXXX-XXXX` or `(XX) XXXX-XXXX`.\n *\n * By default the grouping is decided by **length**, which is what a field\n * accepting both landlines and mobiles needs.\n *\n * `mobile: true` is for a field that only accepts mobile numbers, and it exists\n * because the default is wrong as an as-you-type mask there. Reading anything up\n * to ten digits as a landline puts the hyphen after the fourth subscriber digit,\n * so a half-typed mobile renders `(11) 9123-4`; it only becomes `(11) 91234-5`\n * once the eleventh digit lands. The separator visibly jumps backwards while the\n * user is still typing. With `mobile`, the same input reads `(11) 91234` and the\n * hyphen never moves. It also inserts the leading `9` every Brazilian mobile\n * carries, so a ten-digit number gets corrected rather than masked as a landline.\n *\n * @param value - Raw digits or partially masked string.\n * @param options - Masking options.\n * @returns Masked phone string.\n *\n * @example\n * formatPhone(\"1191234\");                      // \"(11) 9123-4\"\n * formatPhone(\"1191234\", { mobile: true });    // \"(11) 91234\"\n * formatPhone(\"1112345678\", { mobile: true }); // \"(11) 91234-5678\" — 9 inserted\n */\nexport function formatPhone(value: string, options: FormatPhoneOptions = {}): string {\n    const digits = value.replace(/\\D/g, \"\").slice(0, 11);\n\n    if (!options.mobile) {\n        if (digits.length <= 10) {\n            return digits.replace(/(\\d{2})(\\d)/, \"($1) $2\").replace(/(\\d{4})(\\d)/, \"$1-$2\");\n        }\n        return digits.replace(/(\\d{2})(\\d)/, \"($1) $2\").replace(/(\\d{5})(\\d)/, \"$1-$2\");\n    }\n\n    if (digits.length <= 2) return digits;\n\n    const area = digits.slice(0, 2);\n    let subscriber = digits.slice(2);\n    if (subscriber[0] !== \"9\") subscriber = `9${subscriber}`;\n    subscriber = subscriber.slice(0, 9);\n\n    const prefix = subscriber.slice(0, 5);\n    const suffix = subscriber.slice(5);\n    return suffix ? `(${area}) ${prefix}-${suffix}` : `(${area}) ${prefix}`;\n}\n\n/**\n * Apply the Brazilian CPF mask `XXX.XXX.XXX-XX`.\n *\n * @param value - Raw digits or partially masked string.\n * @returns Masked CPF string.\n */\nexport function formatCPF(value: string): string {\n    return value\n        .replace(/\\D/g, \"\")\n        .slice(0, 11)\n        .replace(/(\\d{3})(\\d)/, \"$1.$2\")\n        .replace(/(\\d{3})(\\d)/, \"$1.$2\")\n        .replace(/(\\d{3})(\\d{1,2})$/, \"$1-$2\");\n}\n\n/** How {@link formatPercent} renders a fraction. */\nexport interface FormatPercentOptions extends FormatFallbackOptions {\n    /**\n     * Decimal places to show, fixed (padded as well as truncated).\n     *\n     * Defaults to `1`, which is what the function always did. Two is the case\n     * that produced this option: a confidence of 98,74% and one of 98,7% are the\n     * same number on a summary card and two different readings on a detail\n     * screen, so the precision belongs to the call site.\n     */\n    decimals?: number;\n}\n\n/**\n * Format a fraction (0-1) as a percentage.\n *\n * A non-finite input renders as `\"—\"` rather than `\"NaN%\"` or `\"∞%\"`, which is\n * what `Intl.NumberFormat` produces and what a division by zero upstream puts on\n * the screen. It matches `formatDurationMs`, which already answers that way.\n *\n * @example\n * ```typescript\n * formatPercent(0.9874);                // \"98,7%\"\n * formatPercent(0.9874, { decimals: 2 }); // \"98,74%\"\n * formatPercent(0 / 0);                 // \"—\"\n * ```\n *\n * @param value - Fraction between 0 and 1.\n * @param options - Rendering options; `decimals` defaults to 1.\n * @returns Formatted percent string, e.g. \"12,5%\", or `\"—\"` for a non-finite input.\n */\nexport function formatPercent(\n    value: number | null | undefined,\n    options: FormatPercentOptions = {},\n): string {\n    if (isAbsent(value) || !Number.isFinite(value)) return fallbackText(options);\n    const decimals = options.decimals ?? 1;\n    return numberFormat(\"pt-BR\", {\n        style: \"percent\",\n        minimumFractionDigits: decimals,\n        maximumFractionDigits: decimals,\n    }).format(value);\n}\n"],"mappings":"8DAuBA,SAAgB,EACZ,EACA,EACM,CAEN,OADI,EAAA,SAAS,CAAK,GAAK,CAAC,OAAO,SAAS,CAAK,EAAU,EAAA,aAAa,CAAO,EACpE,EAAA,aAAa,QAAS,CAAE,MAAO,WAAY,SAAU,KAAM,CAAC,CAAC,CAAC,OAAO,CAAK,CACrF,CA0BA,SAAgB,EACZ,EACA,EACM,CACN,GAAI,EAAA,SAAS,CAAK,EAAG,OAAO,EAAA,aAAa,CAAO,EAChD,IAAM,EAAO,OAAO,GAAU,SAAW,IAAI,KAAK,CAAK,EAAI,EAE3D,OADI,OAAO,MAAM,EAAK,QAAQ,CAAC,EAAU,GAClC,EAAA,eAAe,OAAO,CAAC,CAAC,OAAO,CAAI,CAC9C,CA6BA,SAAgB,EACZ,EACA,EACM,CACN,GAAI,EAAA,SAAS,CAAK,EAAG,OAAO,EAAA,aAAa,EAAS,EAAE,EACpD,GAAI,OAAO,GAAU,UAAY,sBAAsB,KAAK,CAAK,EAAG,OAAO,EAC3E,IAAM,EAAO,OAAO,GAAU,SAAW,IAAI,KAAK,CAAK,EAAI,EAC3D,GAAI,OAAO,MAAM,EAAK,QAAQ,CAAC,EAAG,MAAO,GACzC,IAAM,EAAQ,GAAG,EAAK,SAAS,EAAI,IAAI,SAAS,EAAG,GAAG,EAChD,EAAM,GAAG,EAAK,QAAQ,IAAI,SAAS,EAAG,GAAG,EAC/C,MAAO,GAAG,EAAK,YAAY,EAAE,GAAG,EAAM,GAAG,GAC7C,CAgCA,SAAgB,EACZ,EACA,EACM,CACN,GAAI,EAAA,SAAS,CAAK,EAAG,OAAO,EAAA,aAAa,EAAS,EAAE,EACpD,GAAI,OAAO,GAAU,UAAY,kCAAkC,KAAK,CAAK,EAAG,OAAO,EACvF,IAAM,EAAO,OAAO,GAAU,SAAW,IAAI,KAAK,CAAK,EAAI,EAC3D,GAAI,OAAO,MAAM,EAAK,QAAQ,CAAC,EAAG,MAAO,GACzC,IAAM,EAAQ,GAAG,EAAK,SAAS,EAAI,IAAI,SAAS,EAAG,GAAG,EAChD,EAAM,GAAG,EAAK,QAAQ,IAAI,SAAS,EAAG,GAAG,EACzC,EAAQ,GAAG,EAAK,SAAS,IAAI,SAAS,EAAG,GAAG,EAC5C,EAAU,GAAG,EAAK,WAAW,IAAI,SAAS,EAAG,GAAG,EACtD,MAAO,GAAG,EAAK,YAAY,EAAE,GAAG,EAAM,GAAG,EAAI,GAAG,EAAM,GAAG,GAC7D,CAaA,SAAgB,EACZ,EACA,EACM,CACN,GAAI,EAAA,SAAS,CAAK,EAAG,OAAO,EAAA,aAAa,CAAO,EAChD,IAAM,EAAO,OAAO,GAAU,SAAW,IAAI,KAAK,CAAK,EAAI,EAE3D,OADI,OAAO,MAAM,EAAK,QAAQ,CAAC,EAAU,GAClC,EAAA,eAAe,QAAS,CAAE,UAAW,QAAS,UAAW,OAAQ,CAAC,CAAC,CAAC,OAAO,CAAI,CAC1F,CAsCA,SAAgB,EAAY,EAAe,EAA8B,CAAC,EAAW,CACjF,IAAM,EAAS,EAAM,QAAQ,MAAO,EAAE,CAAC,CAAC,MAAM,EAAG,EAAE,EAEnD,GAAI,CAAC,EAAQ,OAIT,OAHI,EAAO,QAAU,GACV,EAAO,QAAQ,cAAe,SAAS,CAAC,CAAC,QAAQ,cAAe,OAAO,EAE3E,EAAO,QAAQ,cAAe,SAAS,CAAC,CAAC,QAAQ,cAAe,OAAO,EAGlF,GAAI,EAAO,QAAU,EAAG,OAAO,EAE/B,IAAM,EAAO,EAAO,MAAM,EAAG,CAAC,EAC1B,EAAa,EAAO,MAAM,CAAC,EAC3B,EAAW,KAAO,MAAK,EAAa,IAAI,KAC5C,EAAa,EAAW,MAAM,EAAG,CAAC,EAElC,IAAM,EAAS,EAAW,MAAM,EAAG,CAAC,EAC9B,EAAS,EAAW,MAAM,CAAC,EACjC,OAAO,EAAS,IAAI,EAAK,IAAI,EAAO,GAAG,IAAW,IAAI,EAAK,IAAI,GACnE,CAQA,SAAgB,EAAU,EAAuB,CAC7C,OAAO,EACF,QAAQ,MAAO,EAAE,CAAC,CAClB,MAAM,EAAG,EAAE,CAAC,CACZ,QAAQ,cAAe,OAAO,CAAC,CAC/B,QAAQ,cAAe,OAAO,CAAC,CAC/B,QAAQ,oBAAqB,OAAO,CAC7C,CAiCA,SAAgB,EACZ,EACA,EAAgC,CAAC,EAC3B,CACN,GAAI,EAAA,SAAS,CAAK,GAAK,CAAC,OAAO,SAAS,CAAK,EAAG,OAAO,EAAA,aAAa,CAAO,EAC3E,IAAM,EAAW,EAAQ,UAAY,EACrC,OAAO,EAAA,aAAa,QAAS,CACzB,MAAO,UACP,sBAAuB,EACvB,sBAAuB,CAC3B,CAAC,CAAC,CAAC,OAAO,CAAK,CACnB"}
+{"version":3,"file":"format.cjs","names":["isAbsent","fallbackText","numberFormat","dateTimeFormat","require_absent","require_intl_cache","formatCurrency","value","options","formatDate","date","formatDateForInput","month","day","formatDateTimeForInput","hours","minutes","formatDateTime","formatPhone","digits","area","subscriber","prefix","suffix","formatCPF","formatPercent","decimals"],"sources":["../../src/utils/format.ts"],"sourcesContent":["import { fallbackText, isAbsent, type FormatFallbackOptions } from \"@/utils/absent\";\nimport { dateTimeFormat, numberFormat } from \"@/utils/intl-cache\";\n\n/**\n * Format a number as Brazilian Real currency.\n *\n * An absent or unrepresentable amount renders as `\"—\"` rather than as a number.\n * That branch is a data-correctness fix, not cosmetics: `Intl` coerces `null` to\n * zero, so an amount the backend left out used to reach the screen as\n * **`\"R$ 0,00\"`** — a plausible figure a reader has no way to question — and\n * `undefined` as `\"R$ NaN\"`.\n *\n * @example\n * ```typescript\n * formatCurrency(1234.56);                      // \"R$ 1.234,56\"\n * formatCurrency(null);                         // \"—\"\n * formatCurrency(null, { fallback: \"sem valor\" }); // \"sem valor\"\n * ```\n *\n * @param value - The amount in BRL, or `null`/`undefined` when there is none.\n * @param options - Text to render when there is nothing to format.\n * @returns A locale-formatted string, e.g. \"R$ 1.234,56\".\n */\nexport function formatCurrency(\n    value: number | null | undefined,\n    options?: FormatFallbackOptions,\n): string {\n    if (isAbsent(value) || !Number.isFinite(value)) return fallbackText(options);\n    return numberFormat(\"pt-BR\", { style: \"currency\", currency: \"BRL\" }).format(value);\n}\n\n/**\n * Format an ISO date or Date instance as `dd/MM/yyyy`.\n *\n * Absent input answers `\"—\"`. It used to **throw**: `new Date(null)` is epoch and\n * `null.getTime` is a `TypeError`, so a nullable column — which is every\n * `deleted_at`, `expires_at` and half the `updated_at` a FastAPI backend sends —\n * took the screen down instead of rendering a gap.\n *\n * A value that is present and unparseable still answers `\"\"`, deliberately: on a\n * screen that reads a log, \"nobody filled this in\" and \"what they filled in is\n * broken\" are different findings, and the second is the one worth chasing.\n *\n * @example\n * ```typescript\n * formatDate(\"2026-05-16T12:00:00Z\"); // \"16/05/2026\"\n * formatDate(null);                   // \"—\"\n * formatDate(\"banana\");               // \"\"\n * ```\n *\n * @param value - ISO string, Date, or `null`/`undefined`.\n * @param options - Text to render when the value is absent.\n * @returns Formatted date string, the fallback when absent, or empty string when\n *   the value is present and invalid.\n */\nexport function formatDate(\n    value: string | Date | null | undefined,\n    options?: FormatFallbackOptions,\n): string {\n    if (isAbsent(value)) return fallbackText(options);\n    const date = typeof value === \"string\" ? new Date(value) : value;\n    if (Number.isNaN(date.getTime())) return \"\";\n    return dateTimeFormat(\"pt-BR\").format(date);\n}\n\n/**\n * Format an ISO date or Date instance as `yyyy-MM-dd`, the value an\n * `<input type=\"date\">` accepts.\n *\n * Built from the **local** calendar parts rather than `toISOString().slice(0, 10)`,\n * which is the reflex and which is wrong: `toISOString` converts to UTC first, so\n * anything after 21:00 in UTC-3 reports the next day and the form opens on the\n * wrong date. `formatDate` cannot fill this role because a date input rejects\n * `dd/MM/yyyy` outright.\n *\n * A value that is already `yyyy-MM-dd` is returned untouched, and that shortcut\n * is load-bearing rather than an optimisation: `new Date(\"2026-05-16\")` is parsed\n * as **UTC** midnight, which in UTC-3 is the 15th at 21:00, so round-tripping the\n * exact value a backend sent would move it back a day.\n *\n * @example\n * <input type=\"date\" defaultValue={formatDateForInput(order.createdAt)} />\n *\n * Absent input answers `\"\"` here — **not** the em dash the reading formatters\n * use — because that is what an input reads as \"no value\"; an em dash would\n * arrive as content the user has to delete before typing a date.\n *\n * @param value - ISO string, Date, or `null`/`undefined`.\n * @param options - Text for an absent value; defaults to `\"\"`.\n * @returns The `yyyy-MM-dd` value, or an empty string when the input is invalid —\n *   which is what a date input reads as \"no value\", unlike `\"Invalid Date\"`.\n */\nexport function formatDateForInput(\n    value: string | Date | null | undefined,\n    options?: FormatFallbackOptions,\n): string {\n    if (isAbsent(value)) return fallbackText(options, \"\");\n    if (typeof value === \"string\" && /^\\d{4}-\\d{2}-\\d{2}$/.test(value)) return value;\n    const date = typeof value === \"string\" ? new Date(value) : value;\n    if (Number.isNaN(date.getTime())) return \"\";\n    const month = `${date.getMonth() + 1}`.padStart(2, \"0\");\n    const day = `${date.getDate()}`.padStart(2, \"0\");\n    return `${date.getFullYear()}-${month}-${day}`;\n}\n\n/**\n * Format an ISO date or Date instance as `yyyy-MM-ddTHH:mm`, the value an\n * `<input type=\"datetime-local\">` accepts.\n *\n * The sibling of {@link formatDateForInput}, and it exists for the same reason:\n * `toISOString().slice(0, 16)` is the reflex and it is wrong. `toISOString`\n * converts to UTC first, so a 22:00 appointment in UTC-3 opens the form on the\n * next day at 01:00 — here the trap costs the hour as well as the date.\n *\n * A value already in `yyyy-MM-ddTHH:mm` is returned untouched. A value carrying\n * a zone (`...Z`, `...-03:00`) deliberately does **not** take that shortcut: it\n * is a different instant from the naive string that looks like it, so it is\n * converted to the local calendar parts the input has to show.\n *\n * Seconds are dropped. A `datetime-local` steps by the minute unless the app\n * sets `step`, so a `:ss` the field cannot represent would be silently discarded\n * on the first edit anyway — truncating here keeps the rendered value and the\n * submitted value the same.\n *\n * @example\n * <input\n *     type=\"datetime-local\"\n *     defaultValue={formatDateTimeForInput(appointment.startsAt)}\n * />\n *\n * @param value - ISO string or Date.\n * @returns The `yyyy-MM-ddTHH:mm` value, or an empty string when the input is\n *   invalid — which is what a datetime input reads as \"no value\", unlike\n *   `\"Invalid Date\"`.\n */\nexport function formatDateTimeForInput(\n    value: string | Date | null | undefined,\n    options?: FormatFallbackOptions,\n): string {\n    if (isAbsent(value)) return fallbackText(options, \"\");\n    if (typeof value === \"string\" && /^\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}$/.test(value)) return value;\n    const date = typeof value === \"string\" ? new Date(value) : value;\n    if (Number.isNaN(date.getTime())) return \"\";\n    const month = `${date.getMonth() + 1}`.padStart(2, \"0\");\n    const day = `${date.getDate()}`.padStart(2, \"0\");\n    const hours = `${date.getHours()}`.padStart(2, \"0\");\n    const minutes = `${date.getMinutes()}`.padStart(2, \"0\");\n    return `${date.getFullYear()}-${month}-${day}T${hours}:${minutes}`;\n}\n\n/**\n * Format an ISO date or Date instance as `dd/MM/yyyy HH:mm`.\n *\n * Same contract as {@link formatDate}: absent answers the fallback (`\"—\"` by\n * default) instead of throwing, and present-but-invalid answers `\"\"`.\n *\n * @param value - ISO string, Date, or `null`/`undefined`.\n * @param options - Text to render when the value is absent.\n * @returns Formatted datetime string, the fallback when absent, or empty string\n *   when the value is present and invalid.\n */\nexport function formatDateTime(\n    value: string | Date | null | undefined,\n    options?: FormatFallbackOptions,\n): string {\n    if (isAbsent(value)) return fallbackText(options);\n    const date = typeof value === \"string\" ? new Date(value) : value;\n    if (Number.isNaN(date.getTime())) return \"\";\n    return dateTimeFormat(\"pt-BR\", { dateStyle: \"short\", timeStyle: \"short\" }).format(date);\n}\n\nexport interface FormatPhoneOptions {\n    /**\n     * Treat the number as a mobile line: insert the mandatory `9` after the area\n     * code when it is missing, and group the subscriber part `5+4` from the\n     * first digit typed instead of waiting for the eleventh.\n     *\n     * Default `false`, which keeps the length-based behaviour: `4+4` up to ten\n     * digits, `5+4` at eleven.\n     */\n    mobile?: boolean;\n}\n\n/**\n * Apply the Brazilian phone mask `(XX) XXXXX-XXXX` or `(XX) XXXX-XXXX`.\n *\n * By default the grouping is decided by **length**, which is what a field\n * accepting both landlines and mobiles needs.\n *\n * `mobile: true` is for a field that only accepts mobile numbers, and it exists\n * because the default is wrong as an as-you-type mask there. Reading anything up\n * to ten digits as a landline puts the hyphen after the fourth subscriber digit,\n * so a half-typed mobile renders `(11) 9123-4`; it only becomes `(11) 91234-5`\n * once the eleventh digit lands. The separator visibly jumps backwards while the\n * user is still typing. With `mobile`, the same input reads `(11) 91234` and the\n * hyphen never moves. It also inserts the leading `9` every Brazilian mobile\n * carries, so a ten-digit number gets corrected rather than masked as a landline.\n *\n * @param value - Raw digits or partially masked string.\n * @param options - Masking options.\n * @returns Masked phone string.\n *\n * @example\n * formatPhone(\"1191234\");                      // \"(11) 9123-4\"\n * formatPhone(\"1191234\", { mobile: true });    // \"(11) 91234\"\n * formatPhone(\"1112345678\", { mobile: true }); // \"(11) 91234-5678\" — 9 inserted\n */\nexport function formatPhone(value: string, options: FormatPhoneOptions = {}): string {\n    const digits = value.replace(/\\D/g, \"\").slice(0, 11);\n\n    if (!options.mobile) {\n        if (digits.length <= 10) {\n            return digits.replace(/(\\d{2})(\\d)/, \"($1) $2\").replace(/(\\d{4})(\\d)/, \"$1-$2\");\n        }\n        return digits.replace(/(\\d{2})(\\d)/, \"($1) $2\").replace(/(\\d{5})(\\d)/, \"$1-$2\");\n    }\n\n    if (digits.length <= 2) return digits;\n\n    const area = digits.slice(0, 2);\n    let subscriber = digits.slice(2);\n    if (subscriber[0] !== \"9\") subscriber = `9${subscriber}`;\n    subscriber = subscriber.slice(0, 9);\n\n    const prefix = subscriber.slice(0, 5);\n    const suffix = subscriber.slice(5);\n    return suffix ? `(${area}) ${prefix}-${suffix}` : `(${area}) ${prefix}`;\n}\n\n/**\n * Apply the Brazilian CPF mask `XXX.XXX.XXX-XX`.\n *\n * @param value - Raw digits or partially masked string.\n * @returns Masked CPF string.\n */\nexport function formatCPF(value: string): string {\n    return value\n        .replace(/\\D/g, \"\")\n        .slice(0, 11)\n        .replace(/(\\d{3})(\\d)/, \"$1.$2\")\n        .replace(/(\\d{3})(\\d)/, \"$1.$2\")\n        .replace(/(\\d{3})(\\d{1,2})$/, \"$1-$2\");\n}\n\n/** How {@link formatPercent} renders a fraction. */\nexport interface FormatPercentOptions extends FormatFallbackOptions {\n    /**\n     * Decimal places to show, fixed (padded as well as truncated).\n     *\n     * Defaults to `1`, which is what the function always did. Two is the case\n     * that produced this option: a confidence of 98,74% and one of 98,7% are the\n     * same number on a summary card and two different readings on a detail\n     * screen, so the precision belongs to the call site.\n     */\n    decimals?: number;\n}\n\n/**\n * Format a fraction (0-1) as a percentage.\n *\n * A non-finite input renders as `\"—\"` rather than `\"NaN%\"` or `\"∞%\"`, which is\n * what `Intl.NumberFormat` produces and what a division by zero upstream puts on\n * the screen. It matches `formatDurationMs`, which already answers that way.\n *\n * @example\n * ```typescript\n * formatPercent(0.9874);                // \"98,7%\"\n * formatPercent(0.9874, { decimals: 2 }); // \"98,74%\"\n * formatPercent(0 / 0);                 // \"—\"\n * ```\n *\n * @param value - Fraction between 0 and 1.\n * @param options - Rendering options; `decimals` defaults to 1.\n * @returns Formatted percent string, e.g. \"12,5%\", or `\"—\"` for a non-finite input.\n */\nexport function formatPercent(\n    value: number | null | undefined,\n    options: FormatPercentOptions = {},\n): string {\n    if (isAbsent(value) || !Number.isFinite(value)) return fallbackText(options);\n    const decimals = options.decimals ?? 1;\n    return numberFormat(\"pt-BR\", {\n        style: \"percent\",\n        minimumFractionDigits: decimals,\n        maximumFractionDigits: decimals,\n    }).format(value);\n}\n"],"mappings":"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"}

package/dist/utils/format.js.map

@@ -1 +1 @@
-{"version":3,"file":"format.js","names":[],"sources":["../../src/utils/format.ts"],"sourcesContent":["import { fallbackText, isAbsent, type FormatFallbackOptions } from \"@/utils/absent\";\nimport { dateTimeFormat, numberFormat } from \"@/utils/intl-cache\";\n\n/**\n * Format a number as Brazilian Real currency.\n *\n * An absent or unrepresentable amount renders as `\"—\"` rather than as a number.\n * That branch is a data-correctness fix, not cosmetics: `Intl` coerces `null` to\n * zero, so an amount the backend left out used to reach the screen as\n * **`\"R$ 0,00\"`** — a plausible figure a reader has no way to question — and\n * `undefined` as `\"R$ NaN\"`.\n *\n * @example\n * ```typescript\n * formatCurrency(1234.56);                      // \"R$ 1.234,56\"\n * formatCurrency(null);                         // \"—\"\n * formatCurrency(null, { fallback: \"sem valor\" }); // \"sem valor\"\n * ```\n *\n * @param value - The amount in BRL, or `null`/`undefined` when there is none.\n * @param options - Text to render when there is nothing to format.\n * @returns A locale-formatted string, e.g. \"R$ 1.234,56\".\n */\nexport function formatCurrency(\n    value: number | null | undefined,\n    options?: FormatFallbackOptions,\n): string {\n    if (isAbsent(value) || !Number.isFinite(value)) return fallbackText(options);\n    return numberFormat(\"pt-BR\", { style: \"currency\", currency: \"BRL\" }).format(value);\n}\n\n/**\n * Format an ISO date or Date instance as `dd/MM/yyyy`.\n *\n * Absent input answers `\"—\"`. It used to **throw**: `new Date(null)` is epoch and\n * `null.getTime` is a `TypeError`, so a nullable column — which is every\n * `deleted_at`, `expires_at` and half the `updated_at` a FastAPI backend sends —\n * took the screen down instead of rendering a gap.\n *\n * A value that is present and unparseable still answers `\"\"`, deliberately: on a\n * screen that reads a log, \"nobody filled this in\" and \"what they filled in is\n * broken\" are different findings, and the second is the one worth chasing.\n *\n * @example\n * ```typescript\n * formatDate(\"2026-05-16T12:00:00Z\"); // \"16/05/2026\"\n * formatDate(null);                   // \"—\"\n * formatDate(\"banana\");               // \"\"\n * ```\n *\n * @param value - ISO string, Date, or `null`/`undefined`.\n * @param options - Text to render when the value is absent.\n * @returns Formatted date string, the fallback when absent, or empty string when\n *   the value is present and invalid.\n */\nexport function formatDate(\n    value: string | Date | null | undefined,\n    options?: FormatFallbackOptions,\n): string {\n    if (isAbsent(value)) return fallbackText(options);\n    const date = typeof value === \"string\" ? new Date(value) : value;\n    if (Number.isNaN(date.getTime())) return \"\";\n    return dateTimeFormat(\"pt-BR\").format(date);\n}\n\n/**\n * Format an ISO date or Date instance as `yyyy-MM-dd`, the value an\n * `<input type=\"date\">` accepts.\n *\n * Built from the **local** calendar parts rather than `toISOString().slice(0, 10)`,\n * which is the reflex and which is wrong: `toISOString` converts to UTC first, so\n * anything after 21:00 in UTC-3 reports the next day and the form opens on the\n * wrong date. `formatDate` cannot fill this role because a date input rejects\n * `dd/MM/yyyy` outright.\n *\n * A value that is already `yyyy-MM-dd` is returned untouched, and that shortcut\n * is load-bearing rather than an optimisation: `new Date(\"2026-05-16\")` is parsed\n * as **UTC** midnight, which in UTC-3 is the 15th at 21:00, so round-tripping the\n * exact value a backend sent would move it back a day.\n *\n * @example\n * <input type=\"date\" defaultValue={formatDateForInput(order.createdAt)} />\n *\n * Absent input answers `\"\"` here — **not** the em dash the reading formatters\n * use — because that is what an input reads as \"no value\"; an em dash would\n * arrive as content the user has to delete before typing a date.\n *\n * @param value - ISO string, Date, or `null`/`undefined`.\n * @param options - Text for an absent value; defaults to `\"\"`.\n * @returns The `yyyy-MM-dd` value, or an empty string when the input is invalid —\n *   which is what a date input reads as \"no value\", unlike `\"Invalid Date\"`.\n */\nexport function formatDateForInput(\n    value: string | Date | null | undefined,\n    options?: FormatFallbackOptions,\n): string {\n    if (isAbsent(value)) return fallbackText(options, \"\");\n    if (typeof value === \"string\" && /^\\d{4}-\\d{2}-\\d{2}$/.test(value)) return value;\n    const date = typeof value === \"string\" ? new Date(value) : value;\n    if (Number.isNaN(date.getTime())) return \"\";\n    const month = `${date.getMonth() + 1}`.padStart(2, \"0\");\n    const day = `${date.getDate()}`.padStart(2, \"0\");\n    return `${date.getFullYear()}-${month}-${day}`;\n}\n\n/**\n * Format an ISO date or Date instance as `yyyy-MM-ddTHH:mm`, the value an\n * `<input type=\"datetime-local\">` accepts.\n *\n * The sibling of {@link formatDateForInput}, and it exists for the same reason:\n * `toISOString().slice(0, 16)` is the reflex and it is wrong. `toISOString`\n * converts to UTC first, so a 22:00 appointment in UTC-3 opens the form on the\n * next day at 01:00 — here the trap costs the hour as well as the date.\n *\n * A value already in `yyyy-MM-ddTHH:mm` is returned untouched. A value carrying\n * a zone (`...Z`, `...-03:00`) deliberately does **not** take that shortcut: it\n * is a different instant from the naive string that looks like it, so it is\n * converted to the local calendar parts the input has to show.\n *\n * Seconds are dropped. A `datetime-local` steps by the minute unless the app\n * sets `step`, so a `:ss` the field cannot represent would be silently discarded\n * on the first edit anyway — truncating here keeps the rendered value and the\n * submitted value the same.\n *\n * @example\n * <input\n *     type=\"datetime-local\"\n *     defaultValue={formatDateTimeForInput(appointment.startsAt)}\n * />\n *\n * @param value - ISO string or Date.\n * @returns The `yyyy-MM-ddTHH:mm` value, or an empty string when the input is\n *   invalid — which is what a datetime input reads as \"no value\", unlike\n *   `\"Invalid Date\"`.\n */\nexport function formatDateTimeForInput(\n    value: string | Date | null | undefined,\n    options?: FormatFallbackOptions,\n): string {\n    if (isAbsent(value)) return fallbackText(options, \"\");\n    if (typeof value === \"string\" && /^\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}$/.test(value)) return value;\n    const date = typeof value === \"string\" ? new Date(value) : value;\n    if (Number.isNaN(date.getTime())) return \"\";\n    const month = `${date.getMonth() + 1}`.padStart(2, \"0\");\n    const day = `${date.getDate()}`.padStart(2, \"0\");\n    const hours = `${date.getHours()}`.padStart(2, \"0\");\n    const minutes = `${date.getMinutes()}`.padStart(2, \"0\");\n    return `${date.getFullYear()}-${month}-${day}T${hours}:${minutes}`;\n}\n\n/**\n * Format an ISO date or Date instance as `dd/MM/yyyy HH:mm`.\n *\n * Same contract as {@link formatDate}: absent answers the fallback (`\"—\"` by\n * default) instead of throwing, and present-but-invalid answers `\"\"`.\n *\n * @param value - ISO string, Date, or `null`/`undefined`.\n * @param options - Text to render when the value is absent.\n * @returns Formatted datetime string, the fallback when absent, or empty string\n *   when the value is present and invalid.\n */\nexport function formatDateTime(\n    value: string | Date | null | undefined,\n    options?: FormatFallbackOptions,\n): string {\n    if (isAbsent(value)) return fallbackText(options);\n    const date = typeof value === \"string\" ? new Date(value) : value;\n    if (Number.isNaN(date.getTime())) return \"\";\n    return dateTimeFormat(\"pt-BR\", { dateStyle: \"short\", timeStyle: \"short\" }).format(date);\n}\n\nexport interface FormatPhoneOptions {\n    /**\n     * Treat the number as a mobile line: insert the mandatory `9` after the area\n     * code when it is missing, and group the subscriber part `5+4` from the\n     * first digit typed instead of waiting for the eleventh.\n     *\n     * Default `false`, which keeps the length-based behaviour: `4+4` up to ten\n     * digits, `5+4` at eleven.\n     */\n    mobile?: boolean;\n}\n\n/**\n * Apply the Brazilian phone mask `(XX) XXXXX-XXXX` or `(XX) XXXX-XXXX`.\n *\n * By default the grouping is decided by **length**, which is what a field\n * accepting both landlines and mobiles needs.\n *\n * `mobile: true` is for a field that only accepts mobile numbers, and it exists\n * because the default is wrong as an as-you-type mask there. Reading anything up\n * to ten digits as a landline puts the hyphen after the fourth subscriber digit,\n * so a half-typed mobile renders `(11) 9123-4`; it only becomes `(11) 91234-5`\n * once the eleventh digit lands. The separator visibly jumps backwards while the\n * user is still typing. With `mobile`, the same input reads `(11) 91234` and the\n * hyphen never moves. It also inserts the leading `9` every Brazilian mobile\n * carries, so a ten-digit number gets corrected rather than masked as a landline.\n *\n * @param value - Raw digits or partially masked string.\n * @param options - Masking options.\n * @returns Masked phone string.\n *\n * @example\n * formatPhone(\"1191234\");                      // \"(11) 9123-4\"\n * formatPhone(\"1191234\", { mobile: true });    // \"(11) 91234\"\n * formatPhone(\"1112345678\", { mobile: true }); // \"(11) 91234-5678\" — 9 inserted\n */\nexport function formatPhone(value: string, options: FormatPhoneOptions = {}): string {\n    const digits = value.replace(/\\D/g, \"\").slice(0, 11);\n\n    if (!options.mobile) {\n        if (digits.length <= 10) {\n            return digits.replace(/(\\d{2})(\\d)/, \"($1) $2\").replace(/(\\d{4})(\\d)/, \"$1-$2\");\n        }\n        return digits.replace(/(\\d{2})(\\d)/, \"($1) $2\").replace(/(\\d{5})(\\d)/, \"$1-$2\");\n    }\n\n    if (digits.length <= 2) return digits;\n\n    const area = digits.slice(0, 2);\n    let subscriber = digits.slice(2);\n    if (subscriber[0] !== \"9\") subscriber = `9${subscriber}`;\n    subscriber = subscriber.slice(0, 9);\n\n    const prefix = subscriber.slice(0, 5);\n    const suffix = subscriber.slice(5);\n    return suffix ? `(${area}) ${prefix}-${suffix}` : `(${area}) ${prefix}`;\n}\n\n/**\n * Apply the Brazilian CPF mask `XXX.XXX.XXX-XX`.\n *\n * @param value - Raw digits or partially masked string.\n * @returns Masked CPF string.\n */\nexport function formatCPF(value: string): string {\n    return value\n        .replace(/\\D/g, \"\")\n        .slice(0, 11)\n        .replace(/(\\d{3})(\\d)/, \"$1.$2\")\n        .replace(/(\\d{3})(\\d)/, \"$1.$2\")\n        .replace(/(\\d{3})(\\d{1,2})$/, \"$1-$2\");\n}\n\n/** How {@link formatPercent} renders a fraction. */\nexport interface FormatPercentOptions extends FormatFallbackOptions {\n    /**\n     * Decimal places to show, fixed (padded as well as truncated).\n     *\n     * Defaults to `1`, which is what the function always did. Two is the case\n     * that produced this option: a confidence of 98,74% and one of 98,7% are the\n     * same number on a summary card and two different readings on a detail\n     * screen, so the precision belongs to the call site.\n     */\n    decimals?: number;\n}\n\n/**\n * Format a fraction (0-1) as a percentage.\n *\n * A non-finite input renders as `\"—\"` rather than `\"NaN%\"` or `\"∞%\"`, which is\n * what `Intl.NumberFormat` produces and what a division by zero upstream puts on\n * the screen. It matches `formatDurationMs`, which already answers that way.\n *\n * @example\n * ```typescript\n * formatPercent(0.9874);                // \"98,7%\"\n * formatPercent(0.9874, { decimals: 2 }); // \"98,74%\"\n * formatPercent(0 / 0);                 // \"—\"\n * ```\n *\n * @param value - Fraction between 0 and 1.\n * @param options - Rendering options; `decimals` defaults to 1.\n * @returns Formatted percent string, e.g. \"12,5%\", or `\"—\"` for a non-finite input.\n */\nexport function formatPercent(\n    value: number | null | undefined,\n    options: FormatPercentOptions = {},\n): string {\n    if (isAbsent(value) || !Number.isFinite(value)) return fallbackText(options);\n    const decimals = options.decimals ?? 1;\n    return numberFormat(\"pt-BR\", {\n        style: \"percent\",\n        minimumFractionDigits: decimals,\n        maximumFractionDigits: decimals,\n    }).format(value);\n}\n"],"mappings":"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"}
+{"version":3,"file":"format.js","names":["formatCurrency","isAbsent","value","fallbackText","options","numberFormat","formatDate","date","dateTimeFormat","formatDateForInput","month","day","formatDateTimeForInput","hours","minutes","formatDateTime","formatPhone","digits","area","subscriber","prefix","suffix","formatCPF","formatPercent","decimals"],"sources":["../../src/utils/format.ts"],"sourcesContent":["import { fallbackText, isAbsent, type FormatFallbackOptions } from \"@/utils/absent\";\nimport { dateTimeFormat, numberFormat } from \"@/utils/intl-cache\";\n\n/**\n * Format a number as Brazilian Real currency.\n *\n * An absent or unrepresentable amount renders as `\"—\"` rather than as a number.\n * That branch is a data-correctness fix, not cosmetics: `Intl` coerces `null` to\n * zero, so an amount the backend left out used to reach the screen as\n * **`\"R$ 0,00\"`** — a plausible figure a reader has no way to question — and\n * `undefined` as `\"R$ NaN\"`.\n *\n * @example\n * ```typescript\n * formatCurrency(1234.56);                      // \"R$ 1.234,56\"\n * formatCurrency(null);                         // \"—\"\n * formatCurrency(null, { fallback: \"sem valor\" }); // \"sem valor\"\n * ```\n *\n * @param value - The amount in BRL, or `null`/`undefined` when there is none.\n * @param options - Text to render when there is nothing to format.\n * @returns A locale-formatted string, e.g. \"R$ 1.234,56\".\n */\nexport function formatCurrency(\n    value: number | null | undefined,\n    options?: FormatFallbackOptions,\n): string {\n    if (isAbsent(value) || !Number.isFinite(value)) return fallbackText(options);\n    return numberFormat(\"pt-BR\", { style: \"currency\", currency: \"BRL\" }).format(value);\n}\n\n/**\n * Format an ISO date or Date instance as `dd/MM/yyyy`.\n *\n * Absent input answers `\"—\"`. It used to **throw**: `new Date(null)` is epoch and\n * `null.getTime` is a `TypeError`, so a nullable column — which is every\n * `deleted_at`, `expires_at` and half the `updated_at` a FastAPI backend sends —\n * took the screen down instead of rendering a gap.\n *\n * A value that is present and unparseable still answers `\"\"`, deliberately: on a\n * screen that reads a log, \"nobody filled this in\" and \"what they filled in is\n * broken\" are different findings, and the second is the one worth chasing.\n *\n * @example\n * ```typescript\n * formatDate(\"2026-05-16T12:00:00Z\"); // \"16/05/2026\"\n * formatDate(null);                   // \"—\"\n * formatDate(\"banana\");               // \"\"\n * ```\n *\n * @param value - ISO string, Date, or `null`/`undefined`.\n * @param options - Text to render when the value is absent.\n * @returns Formatted date string, the fallback when absent, or empty string when\n *   the value is present and invalid.\n */\nexport function formatDate(\n    value: string | Date | null | undefined,\n    options?: FormatFallbackOptions,\n): string {\n    if (isAbsent(value)) return fallbackText(options);\n    const date = typeof value === \"string\" ? new Date(value) : value;\n    if (Number.isNaN(date.getTime())) return \"\";\n    return dateTimeFormat(\"pt-BR\").format(date);\n}\n\n/**\n * Format an ISO date or Date instance as `yyyy-MM-dd`, the value an\n * `<input type=\"date\">` accepts.\n *\n * Built from the **local** calendar parts rather than `toISOString().slice(0, 10)`,\n * which is the reflex and which is wrong: `toISOString` converts to UTC first, so\n * anything after 21:00 in UTC-3 reports the next day and the form opens on the\n * wrong date. `formatDate` cannot fill this role because a date input rejects\n * `dd/MM/yyyy` outright.\n *\n * A value that is already `yyyy-MM-dd` is returned untouched, and that shortcut\n * is load-bearing rather than an optimisation: `new Date(\"2026-05-16\")` is parsed\n * as **UTC** midnight, which in UTC-3 is the 15th at 21:00, so round-tripping the\n * exact value a backend sent would move it back a day.\n *\n * @example\n * <input type=\"date\" defaultValue={formatDateForInput(order.createdAt)} />\n *\n * Absent input answers `\"\"` here — **not** the em dash the reading formatters\n * use — because that is what an input reads as \"no value\"; an em dash would\n * arrive as content the user has to delete before typing a date.\n *\n * @param value - ISO string, Date, or `null`/`undefined`.\n * @param options - Text for an absent value; defaults to `\"\"`.\n * @returns The `yyyy-MM-dd` value, or an empty string when the input is invalid —\n *   which is what a date input reads as \"no value\", unlike `\"Invalid Date\"`.\n */\nexport function formatDateForInput(\n    value: string | Date | null | undefined,\n    options?: FormatFallbackOptions,\n): string {\n    if (isAbsent(value)) return fallbackText(options, \"\");\n    if (typeof value === \"string\" && /^\\d{4}-\\d{2}-\\d{2}$/.test(value)) return value;\n    const date = typeof value === \"string\" ? new Date(value) : value;\n    if (Number.isNaN(date.getTime())) return \"\";\n    const month = `${date.getMonth() + 1}`.padStart(2, \"0\");\n    const day = `${date.getDate()}`.padStart(2, \"0\");\n    return `${date.getFullYear()}-${month}-${day}`;\n}\n\n/**\n * Format an ISO date or Date instance as `yyyy-MM-ddTHH:mm`, the value an\n * `<input type=\"datetime-local\">` accepts.\n *\n * The sibling of {@link formatDateForInput}, and it exists for the same reason:\n * `toISOString().slice(0, 16)` is the reflex and it is wrong. `toISOString`\n * converts to UTC first, so a 22:00 appointment in UTC-3 opens the form on the\n * next day at 01:00 — here the trap costs the hour as well as the date.\n *\n * A value already in `yyyy-MM-ddTHH:mm` is returned untouched. A value carrying\n * a zone (`...Z`, `...-03:00`) deliberately does **not** take that shortcut: it\n * is a different instant from the naive string that looks like it, so it is\n * converted to the local calendar parts the input has to show.\n *\n * Seconds are dropped. A `datetime-local` steps by the minute unless the app\n * sets `step`, so a `:ss` the field cannot represent would be silently discarded\n * on the first edit anyway — truncating here keeps the rendered value and the\n * submitted value the same.\n *\n * @example\n * <input\n *     type=\"datetime-local\"\n *     defaultValue={formatDateTimeForInput(appointment.startsAt)}\n * />\n *\n * @param value - ISO string or Date.\n * @returns The `yyyy-MM-ddTHH:mm` value, or an empty string when the input is\n *   invalid — which is what a datetime input reads as \"no value\", unlike\n *   `\"Invalid Date\"`.\n */\nexport function formatDateTimeForInput(\n    value: string | Date | null | undefined,\n    options?: FormatFallbackOptions,\n): string {\n    if (isAbsent(value)) return fallbackText(options, \"\");\n    if (typeof value === \"string\" && /^\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}$/.test(value)) return value;\n    const date = typeof value === \"string\" ? new Date(value) : value;\n    if (Number.isNaN(date.getTime())) return \"\";\n    const month = `${date.getMonth() + 1}`.padStart(2, \"0\");\n    const day = `${date.getDate()}`.padStart(2, \"0\");\n    const hours = `${date.getHours()}`.padStart(2, \"0\");\n    const minutes = `${date.getMinutes()}`.padStart(2, \"0\");\n    return `${date.getFullYear()}-${month}-${day}T${hours}:${minutes}`;\n}\n\n/**\n * Format an ISO date or Date instance as `dd/MM/yyyy HH:mm`.\n *\n * Same contract as {@link formatDate}: absent answers the fallback (`\"—\"` by\n * default) instead of throwing, and present-but-invalid answers `\"\"`.\n *\n * @param value - ISO string, Date, or `null`/`undefined`.\n * @param options - Text to render when the value is absent.\n * @returns Formatted datetime string, the fallback when absent, or empty string\n *   when the value is present and invalid.\n */\nexport function formatDateTime(\n    value: string | Date | null | undefined,\n    options?: FormatFallbackOptions,\n): string {\n    if (isAbsent(value)) return fallbackText(options);\n    const date = typeof value === \"string\" ? new Date(value) : value;\n    if (Number.isNaN(date.getTime())) return \"\";\n    return dateTimeFormat(\"pt-BR\", { dateStyle: \"short\", timeStyle: \"short\" }).format(date);\n}\n\nexport interface FormatPhoneOptions {\n    /**\n     * Treat the number as a mobile line: insert the mandatory `9` after the area\n     * code when it is missing, and group the subscriber part `5+4` from the\n     * first digit typed instead of waiting for the eleventh.\n     *\n     * Default `false`, which keeps the length-based behaviour: `4+4` up to ten\n     * digits, `5+4` at eleven.\n     */\n    mobile?: boolean;\n}\n\n/**\n * Apply the Brazilian phone mask `(XX) XXXXX-XXXX` or `(XX) XXXX-XXXX`.\n *\n * By default the grouping is decided by **length**, which is what a field\n * accepting both landlines and mobiles needs.\n *\n * `mobile: true` is for a field that only accepts mobile numbers, and it exists\n * because the default is wrong as an as-you-type mask there. Reading anything up\n * to ten digits as a landline puts the hyphen after the fourth subscriber digit,\n * so a half-typed mobile renders `(11) 9123-4`; it only becomes `(11) 91234-5`\n * once the eleventh digit lands. The separator visibly jumps backwards while the\n * user is still typing. With `mobile`, the same input reads `(11) 91234` and the\n * hyphen never moves. It also inserts the leading `9` every Brazilian mobile\n * carries, so a ten-digit number gets corrected rather than masked as a landline.\n *\n * @param value - Raw digits or partially masked string.\n * @param options - Masking options.\n * @returns Masked phone string.\n *\n * @example\n * formatPhone(\"1191234\");                      // \"(11) 9123-4\"\n * formatPhone(\"1191234\", { mobile: true });    // \"(11) 91234\"\n * formatPhone(\"1112345678\", { mobile: true }); // \"(11) 91234-5678\" — 9 inserted\n */\nexport function formatPhone(value: string, options: FormatPhoneOptions = {}): string {\n    const digits = value.replace(/\\D/g, \"\").slice(0, 11);\n\n    if (!options.mobile) {\n        if (digits.length <= 10) {\n            return digits.replace(/(\\d{2})(\\d)/, \"($1) $2\").replace(/(\\d{4})(\\d)/, \"$1-$2\");\n        }\n        return digits.replace(/(\\d{2})(\\d)/, \"($1) $2\").replace(/(\\d{5})(\\d)/, \"$1-$2\");\n    }\n\n    if (digits.length <= 2) return digits;\n\n    const area = digits.slice(0, 2);\n    let subscriber = digits.slice(2);\n    if (subscriber[0] !== \"9\") subscriber = `9${subscriber}`;\n    subscriber = subscriber.slice(0, 9);\n\n    const prefix = subscriber.slice(0, 5);\n    const suffix = subscriber.slice(5);\n    return suffix ? `(${area}) ${prefix}-${suffix}` : `(${area}) ${prefix}`;\n}\n\n/**\n * Apply the Brazilian CPF mask `XXX.XXX.XXX-XX`.\n *\n * @param value - Raw digits or partially masked string.\n * @returns Masked CPF string.\n */\nexport function formatCPF(value: string): string {\n    return value\n        .replace(/\\D/g, \"\")\n        .slice(0, 11)\n        .replace(/(\\d{3})(\\d)/, \"$1.$2\")\n        .replace(/(\\d{3})(\\d)/, \"$1.$2\")\n        .replace(/(\\d{3})(\\d{1,2})$/, \"$1-$2\");\n}\n\n/** How {@link formatPercent} renders a fraction. */\nexport interface FormatPercentOptions extends FormatFallbackOptions {\n    /**\n     * Decimal places to show, fixed (padded as well as truncated).\n     *\n     * Defaults to `1`, which is what the function always did. Two is the case\n     * that produced this option: a confidence of 98,74% and one of 98,7% are the\n     * same number on a summary card and two different readings on a detail\n     * screen, so the precision belongs to the call site.\n     */\n    decimals?: number;\n}\n\n/**\n * Format a fraction (0-1) as a percentage.\n *\n * A non-finite input renders as `\"—\"` rather than `\"NaN%\"` or `\"∞%\"`, which is\n * what `Intl.NumberFormat` produces and what a division by zero upstream puts on\n * the screen. It matches `formatDurationMs`, which already answers that way.\n *\n * @example\n * ```typescript\n * formatPercent(0.9874);                // \"98,7%\"\n * formatPercent(0.9874, { decimals: 2 }); // \"98,74%\"\n * formatPercent(0 / 0);                 // \"—\"\n * ```\n *\n * @param value - Fraction between 0 and 1.\n * @param options - Rendering options; `decimals` defaults to 1.\n * @returns Formatted percent string, e.g. \"12,5%\", or `\"—\"` for a non-finite input.\n */\nexport function formatPercent(\n    value: number | null | undefined,\n    options: FormatPercentOptions = {},\n): string {\n    if (isAbsent(value) || !Number.isFinite(value)) return fallbackText(options);\n    const decimals = options.decimals ?? 1;\n    return numberFormat(\"pt-BR\", {\n        style: \"percent\",\n        minimumFractionDigits: decimals,\n        maximumFractionDigits: decimals,\n    }).format(value);\n}\n"],"mappings":"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"}

package/dist/utils/functions.cjs

@@ -1,2 +1,2 @@
-function e(e,t){let n,r=(...r)=>{n!==void 0&&clearTimeout(n),n=setTimeout(()=>{n=void 0,e(...r)},t)};return r.cancel=()=>{n!==void 0&&(clearTimeout(n),n=void 0)},r}function t(e,t){let n,r,i=0,a=t=>{i=Date.now(),e(...t)},o=(...e)=>{let o=t-(Date.now()-i);o<=0?(n!==void 0&&(clearTimeout(n),n=void 0),a(e)):(r=e,n===void 0&&(n=setTimeout(()=>{if(n=void 0,r!==void 0){let e=r;r=void 0,a(e)}},o)))};return o.cancel=()=>{n!==void 0&&(clearTimeout(n),n=void 0),r=void 0,i=0},o}function n(e){let t=!1,n;return(...r)=>(t||(t=!0,n=e(...r)),n)}function r(e){let t=!1,n,r,i=e=>{if(!t||e.length!==n.length)return!1;for(let t=0;t<e.length;t++)if(!Object.is(e[t],n[t]))return!1;return!0};return(...a)=>i(a)?r:(n=a,r=e(...a),t=!0,r)}exports.debounce=e,exports.memoizeOne=r,exports.once=n,exports.throttle=t;
+function e(e,t){let n,r=(...r)=>{n!==void 0&&clearTimeout(n),n=setTimeout(()=>{n=void 0,e(...r)},t)};return r.cancel=()=>{n!==void 0&&(clearTimeout(n),n=void 0)},r}function t(e,t){let n,r,i=0,a=t=>{i=Date.now(),e(...t)},o=(...e)=>{let o=t-(Date.now()-i);o<=0?(n!==void 0&&(clearTimeout(n),n=void 0),a(e)):(r=e,n===void 0&&(n=setTimeout(()=>{if(n=void 0,r!==void 0){let e=r;r=void 0,a(e)}},o)))};return o.cancel=()=>{n!==void 0&&(clearTimeout(n),n=void 0),r=void 0,i=0},o}function n(e){let t=!1,n;return(...r)=>(t||(t=!0,n=e(...r)),n)}function r(e){let t=!1,n,r,i=e=>{if(!t||e.length!==n.length)return!1;for(let t=0;t<e.length;t++)if(!Object.is(e[t],n[t]))return!1;return!0};return(...a)=>(i(a)||(n=a,r=e(...a),t=!0),r)}exports.debounce=e,exports.memoizeOne=r,exports.once=n,exports.throttle=t;
 //# sourceMappingURL=functions.cjs.map

package/dist/utils/functions.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"functions.cjs","names":[],"sources":["../../src/utils/functions.ts"],"sourcesContent":["/**\n * Create a trailing-edge debounced version of `fn`.\n *\n * The wrapped function delays invoking `fn` until `wait` milliseconds have\n * elapsed since the last time it was called. Only the latest arguments are\n * used. Call `.cancel()` to clear any pending invocation.\n *\n * @example\n * const save = debounce((q: string) => search(q), 300);\n * save(\"a\"); save(\"ab\"); save(\"abc\"); // only \"abc\" runs after 300ms\n * save.cancel();                       // nothing runs\n */\nexport function debounce<A extends unknown[]>(\n    fn: (...args: A) => void,\n    wait: number,\n): ((...args: A) => void) & { cancel: () => void } {\n    let timer: ReturnType<typeof setTimeout> | undefined;\n\n    const debounced = (...args: A): void => {\n        if (timer !== undefined) clearTimeout(timer);\n        timer = setTimeout(() => {\n            timer = undefined;\n            fn(...args);\n        }, wait);\n    };\n\n    debounced.cancel = (): void => {\n        if (timer !== undefined) {\n            clearTimeout(timer);\n            timer = undefined;\n        }\n    };\n\n    return debounced;\n}\n\n/**\n * Create a throttled version of `fn` with leading and trailing edges.\n *\n * `fn` runs immediately on the first call (leading edge), then at most once\n * per `wait` milliseconds. If calls happen during the wait window, the last\n * one fires on the trailing edge. Call `.cancel()` to drop any pending\n * trailing call and reset the window.\n *\n * @example\n * const onScroll = throttle(() => render(), 200);\n * window.addEventListener(\"scroll\", onScroll);\n * onScroll.cancel();\n */\nexport function throttle<A extends unknown[]>(\n    fn: (...args: A) => void,\n    wait: number,\n): ((...args: A) => void) & { cancel: () => void } {\n    let timer: ReturnType<typeof setTimeout> | undefined;\n    let lastArgs: A | undefined;\n    let lastInvoke = 0;\n\n    const invoke = (args: A): void => {\n        lastInvoke = Date.now();\n        fn(...args);\n    };\n\n    const throttled = (...args: A): void => {\n        const now = Date.now();\n        const remaining = wait - (now - lastInvoke);\n\n        if (remaining <= 0) {\n            if (timer !== undefined) {\n                clearTimeout(timer);\n                timer = undefined;\n            }\n            invoke(args);\n        } else {\n            lastArgs = args;\n            if (timer === undefined) {\n                timer = setTimeout(() => {\n                    timer = undefined;\n                    if (lastArgs !== undefined) {\n                        const pending = lastArgs;\n                        lastArgs = undefined;\n                        invoke(pending);\n                    }\n                }, remaining);\n            }\n        }\n    };\n\n    throttled.cancel = (): void => {\n        if (timer !== undefined) {\n            clearTimeout(timer);\n            timer = undefined;\n        }\n        lastArgs = undefined;\n        lastInvoke = 0;\n    };\n\n    return throttled;\n}\n\n/**\n * Wrap `fn` so it runs at most once; subsequent calls return the cached result.\n *\n * @example\n * const init = once(() => expensiveSetup());\n * init(); // runs expensiveSetup()\n * init(); // returns the same cached result, no re-run\n */\nexport function once<A extends unknown[], R>(fn: (...args: A) => R): (...args: A) => R {\n    let called = false;\n    let result: R;\n\n    return (...args: A): R => {\n        if (!called) {\n            called = true;\n            result = fn(...args);\n        }\n        return result;\n    };\n}\n\n/**\n * Memoize only the most recent call of `fn`, keyed by shallow-equal arguments.\n *\n * If the next call has the same arguments (compared with `Object.is` per\n * position and equal length), the cached result is returned without re-running\n * `fn`. Any different argument list recomputes and replaces the cache.\n *\n * @example\n * const select = memoizeOne((a: number, b: number) => a + b);\n * select(1, 2); // computes 3\n * select(1, 2); // cached 3\n * select(2, 2); // recomputes 4\n */\nexport function memoizeOne<A extends unknown[], R>(fn: (...args: A) => R): (...args: A) => R {\n    let hasCache = false;\n    let lastArgs: A;\n    let lastResult: R;\n\n    const sameArgs = (next: A): boolean => {\n        if (!hasCache || next.length !== lastArgs.length) return false;\n        for (let i = 0; i < next.length; i++) {\n            if (!Object.is(next[i], lastArgs[i])) return false;\n        }\n        return true;\n    };\n\n    return (...args: A): R => {\n        if (sameArgs(args)) return lastResult;\n        lastArgs = args;\n        lastResult = fn(...args);\n        hasCache = true;\n        return lastResult;\n    };\n}\n"],"mappings":"AAYA,SAAgB,EACZ,EACA,EAC+C,CAC/C,IAAI,EAEE,GAAa,GAAG,IAAkB,CAChC,IAAU,IAAA,IAAW,aAAa,CAAK,EAC3C,EAAQ,eAAiB,CACrB,EAAQ,IAAA,GACR,EAAG,GAAG,CAAI,CACd,EAAG,CAAI,CACX,EASA,MAPA,GAAU,WAAqB,CACvB,IAAU,IAAA,KACV,aAAa,CAAK,EAClB,EAAQ,IAAA,GAEhB,EAEO,CACX,CAeA,SAAgB,EACZ,EACA,EAC+C,CAC/C,IAAI,EACA,EACA,EAAa,EAEX,EAAU,GAAkB,CAC9B,EAAa,KAAK,IAAI,EACtB,EAAG,GAAG,CAAI,CACd,EAEM,GAAa,GAAG,IAAkB,CAEpC,IAAM,EAAY,GADN,KAAK,IACS,EAAM,GAE5B,GAAa,GACT,IAAU,IAAA,KACV,aAAa,CAAK,EAClB,EAAQ,IAAA,IAEZ,EAAO,CAAI,IAEX,EAAW,EACP,IAAU,IAAA,KACV,EAAQ,eAAiB,CAErB,GADA,EAAQ,IAAA,GACJ,IAAa,IAAA,GAAW,CACxB,IAAM,EAAU,EAChB,EAAW,IAAA,GACX,EAAO,CAAO,CAClB,CACJ,EAAG,CAAS,GAGxB,EAWA,MATA,GAAU,WAAqB,CACvB,IAAU,IAAA,KACV,aAAa,CAAK,EAClB,EAAQ,IAAA,IAEZ,EAAW,IAAA,GACX,EAAa,CACjB,EAEO,CACX,CAUA,SAAgB,EAA6B,EAA0C,CACnF,IAAI,EAAS,GACT,EAEJ,OAAQ,GAAG,KACF,IACD,EAAS,GACT,EAAS,EAAG,GAAG,CAAI,GAEhB,EAEf,CAeA,SAAgB,EAAmC,EAA0C,CACzF,IAAI,EAAW,GACX,EACA,EAEE,EAAY,GAAqB,CACnC,GAAI,CAAC,GAAY,EAAK,SAAW,EAAS,OAAQ,MAAO,GACzD,IAAK,IAAI,EAAI,EAAG,EAAI,EAAK,OAAQ,IAC7B,GAAI,CAAC,OAAO,GAAG,EAAK,GAAI,EAAS,EAAE,EAAG,MAAO,GAEjD,MAAO,EACX,EAEA,OAAQ,GAAG,IACH,EAAS,CAAI,EAAU,GAC3B,EAAW,EACX,EAAa,EAAG,GAAG,CAAI,EACvB,EAAW,GACJ,EAEf"}
+{"version":3,"file":"functions.cjs","names":["debounce","timer","debounced","args","fn","wait","throttle","lastArgs","lastInvoke","invoke","throttled","remaining","pending","once","called","result","memoizeOne","hasCache","lastResult","sameArgs","next","i"],"sources":["../../src/utils/functions.ts"],"sourcesContent":["/**\n * Create a trailing-edge debounced version of `fn`.\n *\n * The wrapped function delays invoking `fn` until `wait` milliseconds have\n * elapsed since the last time it was called. Only the latest arguments are\n * used. Call `.cancel()` to clear any pending invocation.\n *\n * @example\n * const save = debounce((q: string) => search(q), 300);\n * save(\"a\"); save(\"ab\"); save(\"abc\"); // only \"abc\" runs after 300ms\n * save.cancel();                       // nothing runs\n */\nexport function debounce<A extends unknown[]>(\n    fn: (...args: A) => void,\n    wait: number,\n): ((...args: A) => void) & { cancel: () => void } {\n    let timer: ReturnType<typeof setTimeout> | undefined;\n\n    const debounced = (...args: A): void => {\n        if (timer !== undefined) clearTimeout(timer);\n        timer = setTimeout(() => {\n            timer = undefined;\n            fn(...args);\n        }, wait);\n    };\n\n    debounced.cancel = (): void => {\n        if (timer !== undefined) {\n            clearTimeout(timer);\n            timer = undefined;\n        }\n    };\n\n    return debounced;\n}\n\n/**\n * Create a throttled version of `fn` with leading and trailing edges.\n *\n * `fn` runs immediately on the first call (leading edge), then at most once\n * per `wait` milliseconds. If calls happen during the wait window, the last\n * one fires on the trailing edge. Call `.cancel()` to drop any pending\n * trailing call and reset the window.\n *\n * @example\n * const onScroll = throttle(() => render(), 200);\n * window.addEventListener(\"scroll\", onScroll);\n * onScroll.cancel();\n */\nexport function throttle<A extends unknown[]>(\n    fn: (...args: A) => void,\n    wait: number,\n): ((...args: A) => void) & { cancel: () => void } {\n    let timer: ReturnType<typeof setTimeout> | undefined;\n    let lastArgs: A | undefined;\n    let lastInvoke = 0;\n\n    const invoke = (args: A): void => {\n        lastInvoke = Date.now();\n        fn(...args);\n    };\n\n    const throttled = (...args: A): void => {\n        const now = Date.now();\n        const remaining = wait - (now - lastInvoke);\n\n        if (remaining <= 0) {\n            if (timer !== undefined) {\n                clearTimeout(timer);\n                timer = undefined;\n            }\n            invoke(args);\n        } else {\n            lastArgs = args;\n            if (timer === undefined) {\n                timer = setTimeout(() => {\n                    timer = undefined;\n                    if (lastArgs !== undefined) {\n                        const pending = lastArgs;\n                        lastArgs = undefined;\n                        invoke(pending);\n                    }\n                }, remaining);\n            }\n        }\n    };\n\n    throttled.cancel = (): void => {\n        if (timer !== undefined) {\n            clearTimeout(timer);\n            timer = undefined;\n        }\n        lastArgs = undefined;\n        lastInvoke = 0;\n    };\n\n    return throttled;\n}\n\n/**\n * Wrap `fn` so it runs at most once; subsequent calls return the cached result.\n *\n * @example\n * const init = once(() => expensiveSetup());\n * init(); // runs expensiveSetup()\n * init(); // returns the same cached result, no re-run\n */\nexport function once<A extends unknown[], R>(fn: (...args: A) => R): (...args: A) => R {\n    let called = false;\n    let result: R;\n\n    return (...args: A): R => {\n        if (!called) {\n            called = true;\n            result = fn(...args);\n        }\n        return result;\n    };\n}\n\n/**\n * Memoize only the most recent call of `fn`, keyed by shallow-equal arguments.\n *\n * If the next call has the same arguments (compared with `Object.is` per\n * position and equal length), the cached result is returned without re-running\n * `fn`. Any different argument list recomputes and replaces the cache.\n *\n * @example\n * const select = memoizeOne((a: number, b: number) => a + b);\n * select(1, 2); // computes 3\n * select(1, 2); // cached 3\n * select(2, 2); // recomputes 4\n */\nexport function memoizeOne<A extends unknown[], R>(fn: (...args: A) => R): (...args: A) => R {\n    let hasCache = false;\n    let lastArgs: A;\n    let lastResult: R;\n\n    const sameArgs = (next: A): boolean => {\n        if (!hasCache || next.length !== lastArgs.length) return false;\n        for (let i = 0; i < next.length; i++) {\n            if (!Object.is(next[i], lastArgs[i])) return false;\n        }\n        return true;\n    };\n\n    return (...args: A): R => {\n        if (sameArgs(args)) return lastResult;\n        lastArgs = args;\n        lastResult = fn(...args);\n        hasCache = true;\n        return lastResult;\n    };\n}\n"],"mappings":"AAYA,SAAgBA,EACZ,EACA,EAC+C,CAC/C,IAAIC,EAEEC,GAAa,GAAGC,IAAkB,CAChCF,IAAU,IAAA,IAAW,aAAaA,CAAK,EAC3C,EAAQ,eAAiB,CACrB,EAAQ,IAAA,GACRG,EAAG,GAAGD,CAAI,CACd,EAAGE,CAAI,CACX,EASA,MAPA,GAAU,WAAqB,CACvBJ,IAAU,IAAA,KACV,aAAaA,CAAK,EAClB,EAAQ,IAAA,GAEhB,EAEOC,CACX,CAeA,SAAgBI,EACZ,EACA,EAC+C,CAC/C,IAAIL,EACAM,EACAC,EAAa,EAEXC,EAAU,GAAkB,CAC9B,EAAa,KAAK,IAAI,EACtBL,EAAG,GAAGD,CAAI,CACd,EAEMO,GAAa,GAAGP,IAAkB,CAEpC,IAAMQ,EAAYN,GADN,KAAK,IACS,EAAMG,GAE5BG,GAAa,GACTV,IAAU,IAAA,KACV,aAAaA,CAAK,EAClB,EAAQ,IAAA,IAEZQ,EAAON,CAAI,IAEX,EAAWA,EACPF,IAAU,IAAA,KACV,EAAQ,eAAiB,CAErB,GADA,EAAQ,IAAA,GACJM,IAAa,IAAA,GAAW,CACxB,IAAMK,EAAUL,EAChB,EAAW,IAAA,GACXE,EAAOG,CAAO,CAClB,CACJ,EAAGD,CAAS,GAGxB,EAWA,MATA,GAAU,WAAqB,CACvBV,IAAU,IAAA,KACV,aAAaA,CAAK,EAClB,EAAQ,IAAA,IAEZ,EAAW,IAAA,GACX,EAAa,CACjB,EAEOS,CACX,CAUA,SAAgBG,EAA6B,EAA0C,CACnF,IAAIC,EAAS,GACTC,EAEJ,OAAQ,GAAGZ,KACFW,IACD,EAAS,GACT,EAASV,EAAG,GAAGD,CAAI,GAEhBY,EAEf,CAeA,SAAgBC,EAAmC,EAA0C,CACzF,IAAIC,EAAW,GACXV,EACAW,EAEEC,EAAY,GAAqB,CACnC,GAAI,CAACF,GAAYG,EAAK,SAAWb,EAAS,OAAQ,MAAO,GACzD,IAAK,IAAIc,EAAI,EAAGA,EAAID,EAAK,OAAQ,IAC7B,GAAI,CAAC,OAAO,GAAGA,EAAKC,GAAId,EAASc,EAAE,EAAG,MAAO,GAEjD,MAAO,EACX,EAEA,OAAQ,GAAGlB,KACHgB,EAAShB,CAAI,IACjB,EAAWA,EACX,EAAaC,EAAG,GAAGD,CAAI,EACvB,EAAW,IACJe,EAEf,C"}

package/dist/utils/functions.js

@@ -35,7 +35,7 @@ function r(e) {
 		for (let t = 0; t < e.length; t++) if (!Object.is(e[t], n[t])) return !1;
 		return !0;
 	};
-	return (...a) => i(a) ? r : (n = a, r = e(...a), t = !0, r);
+	return (...a) => (i(a) || (n = a, r = e(...a), t = !0), r);
 }
 //#endregion
 export { e as debounce, r as memoizeOne, n as once, t as throttle };

package/dist/utils/functions.js.map

@@ -1 +1 @@
-{"version":3,"file":"functions.js","names":[],"sources":["../../src/utils/functions.ts"],"sourcesContent":["/**\n * Create a trailing-edge debounced version of `fn`.\n *\n * The wrapped function delays invoking `fn` until `wait` milliseconds have\n * elapsed since the last time it was called. Only the latest arguments are\n * used. Call `.cancel()` to clear any pending invocation.\n *\n * @example\n * const save = debounce((q: string) => search(q), 300);\n * save(\"a\"); save(\"ab\"); save(\"abc\"); // only \"abc\" runs after 300ms\n * save.cancel();                       // nothing runs\n */\nexport function debounce<A extends unknown[]>(\n    fn: (...args: A) => void,\n    wait: number,\n): ((...args: A) => void) & { cancel: () => void } {\n    let timer: ReturnType<typeof setTimeout> | undefined;\n\n    const debounced = (...args: A): void => {\n        if (timer !== undefined) clearTimeout(timer);\n        timer = setTimeout(() => {\n            timer = undefined;\n            fn(...args);\n        }, wait);\n    };\n\n    debounced.cancel = (): void => {\n        if (timer !== undefined) {\n            clearTimeout(timer);\n            timer = undefined;\n        }\n    };\n\n    return debounced;\n}\n\n/**\n * Create a throttled version of `fn` with leading and trailing edges.\n *\n * `fn` runs immediately on the first call (leading edge), then at most once\n * per `wait` milliseconds. If calls happen during the wait window, the last\n * one fires on the trailing edge. Call `.cancel()` to drop any pending\n * trailing call and reset the window.\n *\n * @example\n * const onScroll = throttle(() => render(), 200);\n * window.addEventListener(\"scroll\", onScroll);\n * onScroll.cancel();\n */\nexport function throttle<A extends unknown[]>(\n    fn: (...args: A) => void,\n    wait: number,\n): ((...args: A) => void) & { cancel: () => void } {\n    let timer: ReturnType<typeof setTimeout> | undefined;\n    let lastArgs: A | undefined;\n    let lastInvoke = 0;\n\n    const invoke = (args: A): void => {\n        lastInvoke = Date.now();\n        fn(...args);\n    };\n\n    const throttled = (...args: A): void => {\n        const now = Date.now();\n        const remaining = wait - (now - lastInvoke);\n\n        if (remaining <= 0) {\n            if (timer !== undefined) {\n                clearTimeout(timer);\n                timer = undefined;\n            }\n            invoke(args);\n        } else {\n            lastArgs = args;\n            if (timer === undefined) {\n                timer = setTimeout(() => {\n                    timer = undefined;\n                    if (lastArgs !== undefined) {\n                        const pending = lastArgs;\n                        lastArgs = undefined;\n                        invoke(pending);\n                    }\n                }, remaining);\n            }\n        }\n    };\n\n    throttled.cancel = (): void => {\n        if (timer !== undefined) {\n            clearTimeout(timer);\n            timer = undefined;\n        }\n        lastArgs = undefined;\n        lastInvoke = 0;\n    };\n\n    return throttled;\n}\n\n/**\n * Wrap `fn` so it runs at most once; subsequent calls return the cached result.\n *\n * @example\n * const init = once(() => expensiveSetup());\n * init(); // runs expensiveSetup()\n * init(); // returns the same cached result, no re-run\n */\nexport function once<A extends unknown[], R>(fn: (...args: A) => R): (...args: A) => R {\n    let called = false;\n    let result: R;\n\n    return (...args: A): R => {\n        if (!called) {\n            called = true;\n            result = fn(...args);\n        }\n        return result;\n    };\n}\n\n/**\n * Memoize only the most recent call of `fn`, keyed by shallow-equal arguments.\n *\n * If the next call has the same arguments (compared with `Object.is` per\n * position and equal length), the cached result is returned without re-running\n * `fn`. Any different argument list recomputes and replaces the cache.\n *\n * @example\n * const select = memoizeOne((a: number, b: number) => a + b);\n * select(1, 2); // computes 3\n * select(1, 2); // cached 3\n * select(2, 2); // recomputes 4\n */\nexport function memoizeOne<A extends unknown[], R>(fn: (...args: A) => R): (...args: A) => R {\n    let hasCache = false;\n    let lastArgs: A;\n    let lastResult: R;\n\n    const sameArgs = (next: A): boolean => {\n        if (!hasCache || next.length !== lastArgs.length) return false;\n        for (let i = 0; i < next.length; i++) {\n            if (!Object.is(next[i], lastArgs[i])) return false;\n        }\n        return true;\n    };\n\n    return (...args: A): R => {\n        if (sameArgs(args)) return lastResult;\n        lastArgs = args;\n        lastResult = fn(...args);\n        hasCache = true;\n        return lastResult;\n    };\n}\n"],"mappings":";AAYA,SAAgB,EACZ,GACA,GAC+C;CAC/C,IAAI,GAEE,KAAa,GAAG,MAAkB;EAEpC,AADI,MAAU,KAAA,KAAW,aAAa,CAAK,GAC3C,IAAQ,iBAAiB;GAErB,AADA,IAAQ,KAAA,GACR,EAAG,GAAG,CAAI;EACd,GAAG,CAAI;CACX;CASA,OAPA,EAAU,eAAqB;EAC3B,AAAI,MAAU,KAAA,MACV,aAAa,CAAK,GAClB,IAAQ,KAAA;CAEhB,GAEO;AACX;AAeA,SAAgB,EACZ,GACA,GAC+C;CAC/C,IAAI,GACA,GACA,IAAa,GAEX,KAAU,MAAkB;EAE9B,AADA,IAAa,KAAK,IAAI,GACtB,EAAG,GAAG,CAAI;CACd,GAEM,KAAa,GAAG,MAAkB;EAEpC,IAAM,IAAY,KADN,KAAK,IACS,IAAM;EAEhC,AAAI,KAAa,KACT,MAAU,KAAA,MACV,aAAa,CAAK,GAClB,IAAQ,KAAA,IAEZ,EAAO,CAAI,MAEX,IAAW,GACP,MAAU,KAAA,MACV,IAAQ,iBAAiB;GAErB,IADA,IAAQ,KAAA,GACJ,MAAa,KAAA,GAAW;IACxB,IAAM,IAAU;IAEhB,AADA,IAAW,KAAA,GACX,EAAO,CAAO;GAClB;EACJ,GAAG,CAAS;CAGxB;CAWA,OATA,EAAU,eAAqB;EAM3B,AALI,MAAU,KAAA,MACV,aAAa,CAAK,GAClB,IAAQ,KAAA,IAEZ,IAAW,KAAA,GACX,IAAa;CACjB,GAEO;AACX;AAUA,SAAgB,EAA6B,GAA0C;CACnF,IAAI,IAAS,IACT;CAEJ,QAAQ,GAAG,OACF,MACD,IAAS,IACT,IAAS,EAAG,GAAG,CAAI,IAEhB;AAEf;AAeA,SAAgB,EAAmC,GAA0C;CACzF,IAAI,IAAW,IACX,GACA,GAEE,KAAY,MAAqB;EACnC,IAAI,CAAC,KAAY,EAAK,WAAW,EAAS,QAAQ,OAAO;EACzD,KAAK,IAAI,IAAI,GAAG,IAAI,EAAK,QAAQ,KAC7B,IAAI,CAAC,OAAO,GAAG,EAAK,IAAI,EAAS,EAAE,GAAG,OAAO;EAEjD,OAAO;CACX;CAEA,QAAQ,GAAG,MACH,EAAS,CAAI,IAAU,KAC3B,IAAW,GACX,IAAa,EAAG,GAAG,CAAI,GACvB,IAAW,IACJ;AAEf"}
+{"version":3,"file":"functions.js","names":["debounce","timer","debounced","args","fn","wait","throttle","lastArgs","lastInvoke","invoke","throttled","remaining","pending","once","called","result","memoizeOne","hasCache","lastResult","sameArgs","next","i"],"sources":["../../src/utils/functions.ts"],"sourcesContent":["/**\n * Create a trailing-edge debounced version of `fn`.\n *\n * The wrapped function delays invoking `fn` until `wait` milliseconds have\n * elapsed since the last time it was called. Only the latest arguments are\n * used. Call `.cancel()` to clear any pending invocation.\n *\n * @example\n * const save = debounce((q: string) => search(q), 300);\n * save(\"a\"); save(\"ab\"); save(\"abc\"); // only \"abc\" runs after 300ms\n * save.cancel();                       // nothing runs\n */\nexport function debounce<A extends unknown[]>(\n    fn: (...args: A) => void,\n    wait: number,\n): ((...args: A) => void) & { cancel: () => void } {\n    let timer: ReturnType<typeof setTimeout> | undefined;\n\n    const debounced = (...args: A): void => {\n        if (timer !== undefined) clearTimeout(timer);\n        timer = setTimeout(() => {\n            timer = undefined;\n            fn(...args);\n        }, wait);\n    };\n\n    debounced.cancel = (): void => {\n        if (timer !== undefined) {\n            clearTimeout(timer);\n            timer = undefined;\n        }\n    };\n\n    return debounced;\n}\n\n/**\n * Create a throttled version of `fn` with leading and trailing edges.\n *\n * `fn` runs immediately on the first call (leading edge), then at most once\n * per `wait` milliseconds. If calls happen during the wait window, the last\n * one fires on the trailing edge. Call `.cancel()` to drop any pending\n * trailing call and reset the window.\n *\n * @example\n * const onScroll = throttle(() => render(), 200);\n * window.addEventListener(\"scroll\", onScroll);\n * onScroll.cancel();\n */\nexport function throttle<A extends unknown[]>(\n    fn: (...args: A) => void,\n    wait: number,\n): ((...args: A) => void) & { cancel: () => void } {\n    let timer: ReturnType<typeof setTimeout> | undefined;\n    let lastArgs: A | undefined;\n    let lastInvoke = 0;\n\n    const invoke = (args: A): void => {\n        lastInvoke = Date.now();\n        fn(...args);\n    };\n\n    const throttled = (...args: A): void => {\n        const now = Date.now();\n        const remaining = wait - (now - lastInvoke);\n\n        if (remaining <= 0) {\n            if (timer !== undefined) {\n                clearTimeout(timer);\n                timer = undefined;\n            }\n            invoke(args);\n        } else {\n            lastArgs = args;\n            if (timer === undefined) {\n                timer = setTimeout(() => {\n                    timer = undefined;\n                    if (lastArgs !== undefined) {\n                        const pending = lastArgs;\n                        lastArgs = undefined;\n                        invoke(pending);\n                    }\n                }, remaining);\n            }\n        }\n    };\n\n    throttled.cancel = (): void => {\n        if (timer !== undefined) {\n            clearTimeout(timer);\n            timer = undefined;\n        }\n        lastArgs = undefined;\n        lastInvoke = 0;\n    };\n\n    return throttled;\n}\n\n/**\n * Wrap `fn` so it runs at most once; subsequent calls return the cached result.\n *\n * @example\n * const init = once(() => expensiveSetup());\n * init(); // runs expensiveSetup()\n * init(); // returns the same cached result, no re-run\n */\nexport function once<A extends unknown[], R>(fn: (...args: A) => R): (...args: A) => R {\n    let called = false;\n    let result: R;\n\n    return (...args: A): R => {\n        if (!called) {\n            called = true;\n            result = fn(...args);\n        }\n        return result;\n    };\n}\n\n/**\n * Memoize only the most recent call of `fn`, keyed by shallow-equal arguments.\n *\n * If the next call has the same arguments (compared with `Object.is` per\n * position and equal length), the cached result is returned without re-running\n * `fn`. Any different argument list recomputes and replaces the cache.\n *\n * @example\n * const select = memoizeOne((a: number, b: number) => a + b);\n * select(1, 2); // computes 3\n * select(1, 2); // cached 3\n * select(2, 2); // recomputes 4\n */\nexport function memoizeOne<A extends unknown[], R>(fn: (...args: A) => R): (...args: A) => R {\n    let hasCache = false;\n    let lastArgs: A;\n    let lastResult: R;\n\n    const sameArgs = (next: A): boolean => {\n        if (!hasCache || next.length !== lastArgs.length) return false;\n        for (let i = 0; i < next.length; i++) {\n            if (!Object.is(next[i], lastArgs[i])) return false;\n        }\n        return true;\n    };\n\n    return (...args: A): R => {\n        if (sameArgs(args)) return lastResult;\n        lastArgs = args;\n        lastResult = fn(...args);\n        hasCache = true;\n        return lastResult;\n    };\n}\n"],"mappings":";AAYA,SAAgBA,EACZ,GACA,GAC+C;CAC/C,IAAIC,GAEEC,KAAa,GAAGC,MAAkB;EAEpC,AADIF,MAAU,KAAA,KAAW,aAAaA,CAAK,GAC3C,IAAQ,iBAAiB;GAErB,AADA,IAAQ,KAAA,GACRG,EAAG,GAAGD,CAAI;EACd,GAAGE,CAAI;CACX;CASA,OAPA,EAAU,eAAqB;EAC3B,AAAIJ,MAAU,KAAA,MACV,aAAaA,CAAK,GAClB,IAAQ,KAAA;CAEhB,GAEOC;AACX;AAeA,SAAgBI,EACZ,GACA,GAC+C;CAC/C,IAAIL,GACAM,GACAC,IAAa,GAEXC,KAAU,MAAkB;EAE9B,AADA,IAAa,KAAK,IAAI,GACtBL,EAAG,GAAGD,CAAI;CACd,GAEMO,KAAa,GAAGP,MAAkB;EAEpC,IAAMQ,IAAYN,KADN,KAAK,IACS,IAAMG;EAEhC,AAAIG,KAAa,KACTV,MAAU,KAAA,MACV,aAAaA,CAAK,GAClB,IAAQ,KAAA,IAEZQ,EAAON,CAAI,MAEX,IAAWA,GACPF,MAAU,KAAA,MACV,IAAQ,iBAAiB;GAErB,IADA,IAAQ,KAAA,GACJM,MAAa,KAAA,GAAW;IACxB,IAAMK,IAAUL;IAEhB,AADA,IAAW,KAAA,GACXE,EAAOG,CAAO;GAClB;EACJ,GAAGD,CAAS;CAGxB;CAWA,OATA,EAAU,eAAqB;EAM3B,AALIV,MAAU,KAAA,MACV,aAAaA,CAAK,GAClB,IAAQ,KAAA,IAEZ,IAAW,KAAA,GACX,IAAa;CACjB,GAEOS;AACX;AAUA,SAAgBG,EAA6B,GAA0C;CACnF,IAAIC,IAAS,IACTC;CAEJ,QAAQ,GAAGZ,OACFW,MACD,IAAS,IACT,IAASV,EAAG,GAAGD,CAAI,IAEhBY;AAEf;AAeA,SAAgBC,EAAmC,GAA0C;CACzF,IAAIC,IAAW,IACXV,GACAW,GAEEC,KAAY,MAAqB;EACnC,IAAI,CAACF,KAAYG,EAAK,WAAWb,EAAS,QAAQ,OAAO;EACzD,KAAK,IAAIc,IAAI,GAAGA,IAAID,EAAK,QAAQ,KAC7B,IAAI,CAAC,OAAO,GAAGA,EAAKC,IAAId,EAASc,EAAE,GAAG,OAAO;EAEjD,OAAO;CACX;CAEA,QAAQ,GAAGlB,OACHgB,EAAShB,CAAI,MACjB,IAAWA,GACX,IAAaC,EAAG,GAAGD,CAAI,GACvB,IAAW,KACJe;AAEf"}

package/dist/utils/guards.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"guards.cjs","names":[],"sources":["../../src/utils/guards.ts"],"sourcesContent":["/**\n * Type guard asserting a value is neither `null` nor `undefined`.\n *\n * Useful for narrowing in `Array.prototype.filter` to drop nullish entries\n * while preserving the element type.\n *\n * @example\n * const xs: (number | null)[] = [1, null, 2];\n * const clean: number[] = xs.filter(isDefined); // [1, 2]\n */\nexport function isDefined<T>(value: T | null | undefined): value is T {\n    return value !== null && value !== undefined;\n}\n\n/**\n * Type guard asserting a value is a string primitive.\n *\n * @example\n * isString(\"hi\"); // true\n * isString(42);   // false\n */\nexport function isString(value: unknown): value is string {\n    return typeof value === \"string\";\n}\n\n/**\n * Type guard asserting a value is a number, excluding `NaN`.\n *\n * @example\n * isNumber(42);       // true\n * isNumber(NaN);      // false\n * isNumber(\"42\");     // false\n */\nexport function isNumber(value: unknown): value is number {\n    return typeof value === \"number\" && !Number.isNaN(value);\n}\n\n/**\n * Type guard asserting a value is a plain object literal.\n *\n * Returns `false` for arrays, `null`, dates, maps, sets, and class instances —\n * only objects created from `{}` / `Object.create(null)` / object literals pass.\n *\n * @example\n * isPlainObject({ a: 1 });     // true\n * isPlainObject([]);           // false\n * isPlainObject(null);         // false\n * isPlainObject(new Date());   // false\n */\nexport function isPlainObject(value: unknown): value is Record<string, unknown> {\n    if (typeof value !== \"object\" || value === null) return false;\n    const proto = Object.getPrototypeOf(value);\n    return proto === Object.prototype || proto === null;\n}\n\n/**\n * Assert that a code path is unreachable, throwing at runtime if reached.\n *\n * Use in the `default` branch of an exhaustive `switch` so TypeScript flags any\n * unhandled union member at compile time and the runtime fails loudly if an\n * unexpected value slips through.\n *\n * @param value - The value that should be of type `never`.\n * @param message - Optional custom error message.\n * @throws {Error} Always.\n *\n * @example\n * type Shape = \"circle\" | \"square\";\n * function area(shape: Shape): number {\n *   switch (shape) {\n *     case \"circle\": return 1;\n *     case \"square\": return 2;\n *     default: return assertNever(shape);\n *   }\n * }\n */\nexport function assertNever(value: never, message?: string): never {\n    throw new Error(message ?? `Unexpected value: ${String(value)}`);\n}\n"],"mappings":"AAUA,SAAgB,EAAa,EAAyC,CAClE,OAAO,GAAU,IACrB,CASA,SAAgB,EAAS,EAAiC,CACtD,OAAO,OAAO,GAAU,QAC5B,CAUA,SAAgB,EAAS,EAAiC,CACtD,OAAO,OAAO,GAAU,UAAY,CAAC,OAAO,MAAM,CAAK,CAC3D,CAcA,SAAgB,EAAc,EAAkD,CAC5E,GAAI,OAAO,GAAU,WAAY,EAAgB,MAAO,GACxD,IAAM,EAAQ,OAAO,eAAe,CAAK,EACzC,OAAO,IAAU,OAAO,WAAa,IAAU,IACnD,CAuBA,SAAgB,EAAY,EAAc,EAAyB,CAC/D,MAAU,MAAM,GAAW,qBAAqB,OAAO,CAAK,GAAG,CACnE"}
+{"version":3,"file":"guards.cjs","names":["isDefined","value","isString","isNumber","isPlainObject","proto","assertNever","message"],"sources":["../../src/utils/guards.ts"],"sourcesContent":["/**\n * Type guard asserting a value is neither `null` nor `undefined`.\n *\n * Useful for narrowing in `Array.prototype.filter` to drop nullish entries\n * while preserving the element type.\n *\n * @example\n * const xs: (number | null)[] = [1, null, 2];\n * const clean: number[] = xs.filter(isDefined); // [1, 2]\n */\nexport function isDefined<T>(value: T | null | undefined): value is T {\n    return value !== null && value !== undefined;\n}\n\n/**\n * Type guard asserting a value is a string primitive.\n *\n * @example\n * isString(\"hi\"); // true\n * isString(42);   // false\n */\nexport function isString(value: unknown): value is string {\n    return typeof value === \"string\";\n}\n\n/**\n * Type guard asserting a value is a number, excluding `NaN`.\n *\n * @example\n * isNumber(42);       // true\n * isNumber(NaN);      // false\n * isNumber(\"42\");     // false\n */\nexport function isNumber(value: unknown): value is number {\n    return typeof value === \"number\" && !Number.isNaN(value);\n}\n\n/**\n * Type guard asserting a value is a plain object literal.\n *\n * Returns `false` for arrays, `null`, dates, maps, sets, and class instances —\n * only objects created from `{}` / `Object.create(null)` / object literals pass.\n *\n * @example\n * isPlainObject({ a: 1 });     // true\n * isPlainObject([]);           // false\n * isPlainObject(null);         // false\n * isPlainObject(new Date());   // false\n */\nexport function isPlainObject(value: unknown): value is Record<string, unknown> {\n    if (typeof value !== \"object\" || value === null) return false;\n    const proto = Object.getPrototypeOf(value);\n    return proto === Object.prototype || proto === null;\n}\n\n/**\n * Assert that a code path is unreachable, throwing at runtime if reached.\n *\n * Use in the `default` branch of an exhaustive `switch` so TypeScript flags any\n * unhandled union member at compile time and the runtime fails loudly if an\n * unexpected value slips through.\n *\n * @param value - The value that should be of type `never`.\n * @param message - Optional custom error message.\n * @throws {Error} Always.\n *\n * @example\n * type Shape = \"circle\" | \"square\";\n * function area(shape: Shape): number {\n *   switch (shape) {\n *     case \"circle\": return 1;\n *     case \"square\": return 2;\n *     default: return assertNever(shape);\n *   }\n * }\n */\nexport function assertNever(value: never, message?: string): never {\n    throw new Error(message ?? `Unexpected value: ${String(value)}`);\n}\n"],"mappings":"AAUA,SAAgBA,EAAa,EAAyC,CAClE,OAAOC,GAAU,IACrB,CASA,SAAgBC,EAAS,EAAiC,CACtD,OAAO,OAAOD,GAAU,QAC5B,CAUA,SAAgBE,EAAS,EAAiC,CACtD,OAAO,OAAOF,GAAU,UAAY,CAAC,OAAO,MAAMA,CAAK,CAC3D,CAcA,SAAgBG,EAAc,EAAkD,CAC5E,GAAI,OAAOH,GAAU,WAAYA,EAAgB,MAAO,GACxD,IAAMI,EAAQ,OAAO,eAAeJ,CAAK,EACzC,OAAOI,IAAU,OAAO,WAAaA,IAAU,IACnD,CAuBA,SAAgBC,EAAY,EAAc,EAAyB,CAC/D,MAAU,MAAMC,GAAW,qBAAqB,OAAON,CAAK,GAAG,CACnE,C"}

package/dist/utils/guards.js.map

@@ -1 +1 @@
-{"version":3,"file":"guards.js","names":[],"sources":["../../src/utils/guards.ts"],"sourcesContent":["/**\n * Type guard asserting a value is neither `null` nor `undefined`.\n *\n * Useful for narrowing in `Array.prototype.filter` to drop nullish entries\n * while preserving the element type.\n *\n * @example\n * const xs: (number | null)[] = [1, null, 2];\n * const clean: number[] = xs.filter(isDefined); // [1, 2]\n */\nexport function isDefined<T>(value: T | null | undefined): value is T {\n    return value !== null && value !== undefined;\n}\n\n/**\n * Type guard asserting a value is a string primitive.\n *\n * @example\n * isString(\"hi\"); // true\n * isString(42);   // false\n */\nexport function isString(value: unknown): value is string {\n    return typeof value === \"string\";\n}\n\n/**\n * Type guard asserting a value is a number, excluding `NaN`.\n *\n * @example\n * isNumber(42);       // true\n * isNumber(NaN);      // false\n * isNumber(\"42\");     // false\n */\nexport function isNumber(value: unknown): value is number {\n    return typeof value === \"number\" && !Number.isNaN(value);\n}\n\n/**\n * Type guard asserting a value is a plain object literal.\n *\n * Returns `false` for arrays, `null`, dates, maps, sets, and class instances —\n * only objects created from `{}` / `Object.create(null)` / object literals pass.\n *\n * @example\n * isPlainObject({ a: 1 });     // true\n * isPlainObject([]);           // false\n * isPlainObject(null);         // false\n * isPlainObject(new Date());   // false\n */\nexport function isPlainObject(value: unknown): value is Record<string, unknown> {\n    if (typeof value !== \"object\" || value === null) return false;\n    const proto = Object.getPrototypeOf(value);\n    return proto === Object.prototype || proto === null;\n}\n\n/**\n * Assert that a code path is unreachable, throwing at runtime if reached.\n *\n * Use in the `default` branch of an exhaustive `switch` so TypeScript flags any\n * unhandled union member at compile time and the runtime fails loudly if an\n * unexpected value slips through.\n *\n * @param value - The value that should be of type `never`.\n * @param message - Optional custom error message.\n * @throws {Error} Always.\n *\n * @example\n * type Shape = \"circle\" | \"square\";\n * function area(shape: Shape): number {\n *   switch (shape) {\n *     case \"circle\": return 1;\n *     case \"square\": return 2;\n *     default: return assertNever(shape);\n *   }\n * }\n */\nexport function assertNever(value: never, message?: string): never {\n    throw new Error(message ?? `Unexpected value: ${String(value)}`);\n}\n"],"mappings":";AAUA,SAAgB,EAAa,GAAyC;CAClE,OAAO,KAAU;AACrB;AASA,SAAgB,EAAS,GAAiC;CACtD,OAAO,OAAO,KAAU;AAC5B;AAUA,SAAgB,EAAS,GAAiC;CACtD,OAAO,OAAO,KAAU,YAAY,CAAC,OAAO,MAAM,CAAK;AAC3D;AAcA,SAAgB,EAAc,GAAkD;CAC5E,IAAI,OAAO,KAAU,aAAY,GAAgB,OAAO;CACxD,IAAM,IAAQ,OAAO,eAAe,CAAK;CACzC,OAAO,MAAU,OAAO,aAAa,MAAU;AACnD;AAuBA,SAAgB,EAAY,GAAc,GAAyB;CAC/D,MAAU,MAAM,KAAW,qBAAqB,OAAO,CAAK,GAAG;AACnE"}
+{"version":3,"file":"guards.js","names":["isDefined","value","isString","isNumber","isPlainObject","proto","assertNever","message"],"sources":["../../src/utils/guards.ts"],"sourcesContent":["/**\n * Type guard asserting a value is neither `null` nor `undefined`.\n *\n * Useful for narrowing in `Array.prototype.filter` to drop nullish entries\n * while preserving the element type.\n *\n * @example\n * const xs: (number | null)[] = [1, null, 2];\n * const clean: number[] = xs.filter(isDefined); // [1, 2]\n */\nexport function isDefined<T>(value: T | null | undefined): value is T {\n    return value !== null && value !== undefined;\n}\n\n/**\n * Type guard asserting a value is a string primitive.\n *\n * @example\n * isString(\"hi\"); // true\n * isString(42);   // false\n */\nexport function isString(value: unknown): value is string {\n    return typeof value === \"string\";\n}\n\n/**\n * Type guard asserting a value is a number, excluding `NaN`.\n *\n * @example\n * isNumber(42);       // true\n * isNumber(NaN);      // false\n * isNumber(\"42\");     // false\n */\nexport function isNumber(value: unknown): value is number {\n    return typeof value === \"number\" && !Number.isNaN(value);\n}\n\n/**\n * Type guard asserting a value is a plain object literal.\n *\n * Returns `false` for arrays, `null`, dates, maps, sets, and class instances —\n * only objects created from `{}` / `Object.create(null)` / object literals pass.\n *\n * @example\n * isPlainObject({ a: 1 });     // true\n * isPlainObject([]);           // false\n * isPlainObject(null);         // false\n * isPlainObject(new Date());   // false\n */\nexport function isPlainObject(value: unknown): value is Record<string, unknown> {\n    if (typeof value !== \"object\" || value === null) return false;\n    const proto = Object.getPrototypeOf(value);\n    return proto === Object.prototype || proto === null;\n}\n\n/**\n * Assert that a code path is unreachable, throwing at runtime if reached.\n *\n * Use in the `default` branch of an exhaustive `switch` so TypeScript flags any\n * unhandled union member at compile time and the runtime fails loudly if an\n * unexpected value slips through.\n *\n * @param value - The value that should be of type `never`.\n * @param message - Optional custom error message.\n * @throws {Error} Always.\n *\n * @example\n * type Shape = \"circle\" | \"square\";\n * function area(shape: Shape): number {\n *   switch (shape) {\n *     case \"circle\": return 1;\n *     case \"square\": return 2;\n *     default: return assertNever(shape);\n *   }\n * }\n */\nexport function assertNever(value: never, message?: string): never {\n    throw new Error(message ?? `Unexpected value: ${String(value)}`);\n}\n"],"mappings":";AAUA,SAAgBA,EAAa,GAAyC;CAClE,OAAOC,KAAU;AACrB;AASA,SAAgBC,EAAS,GAAiC;CACtD,OAAO,OAAOD,KAAU;AAC5B;AAUA,SAAgBE,EAAS,GAAiC;CACtD,OAAO,OAAOF,KAAU,YAAY,CAAC,OAAO,MAAMA,CAAK;AAC3D;AAcA,SAAgBG,EAAc,GAAkD;CAC5E,IAAI,OAAOH,KAAU,aAAYA,GAAgB,OAAO;CACxD,IAAMI,IAAQ,OAAO,eAAeJ,CAAK;CACzC,OAAOI,MAAU,OAAO,aAAaA,MAAU;AACnD;AAuBA,SAAgBC,EAAY,GAAc,GAAyB;CAC/D,MAAU,MAAMC,KAAW,qBAAqB,OAAON,CAAK,GAAG;AACnE"}

package/dist/utils/ids.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"ids.cjs","names":[],"sources":["../../src/utils/ids.ts"],"sourcesContent":["/**\n * Generate a collision-resistant id suitable for client-side UI keys.\n *\n * Uses `crypto.randomUUID()` when available, falling back to a\n * timestamp + `Math.random()` combination otherwise. When `prefix` is given,\n * the result is formatted as `${prefix}-${id}`.\n *\n * @example\n * randomId();          // \"9f1c2b3a-...\" (uuid) or \"lq3f8k-4a9z1\" (fallback)\n * randomId(\"user\");    // \"user-9f1c2b3a-...\"\n */\nexport function randomId(prefix?: string): string {\n    let id: string;\n\n    if (typeof crypto !== \"undefined\" && typeof crypto.randomUUID === \"function\") {\n        id = crypto.randomUUID();\n    } else {\n        const time = Date.now().toString(36);\n        const rand = Math.random().toString(36).slice(2, 10);\n        id = `${time}-${rand}`;\n    }\n\n    return prefix ? `${prefix}-${id}` : id;\n}\n"],"mappings":"AAWA,SAAgB,EAAS,EAAyB,CAC9C,IAAI,EAUJ,MARA,CAKI,EALA,OAAO,OAAW,KAAe,OAAO,OAAO,YAAe,WACzD,OAAO,WAAW,EAIlB,GAFQ,KAAK,IAAI,CAAC,CAAC,SAAS,EAEzB,EAAK,GADA,KAAK,OAAO,CAAC,CAAC,SAAS,EAAE,CAAC,CAAC,MAAM,EAAG,EACjC,IAGb,EAAS,GAAG,EAAO,GAAG,IAAO,CACxC"}
+{"version":3,"file":"ids.cjs","names":["randomId","id","prefix"],"sources":["../../src/utils/ids.ts"],"sourcesContent":["/**\n * Generate a collision-resistant id suitable for client-side UI keys.\n *\n * Uses `crypto.randomUUID()` when available, falling back to a\n * timestamp + `Math.random()` combination otherwise. When `prefix` is given,\n * the result is formatted as `${prefix}-${id}`.\n *\n * @example\n * randomId();          // \"9f1c2b3a-...\" (uuid) or \"lq3f8k-4a9z1\" (fallback)\n * randomId(\"user\");    // \"user-9f1c2b3a-...\"\n */\nexport function randomId(prefix?: string): string {\n    let id: string;\n\n    if (typeof crypto !== \"undefined\" && typeof crypto.randomUUID === \"function\") {\n        id = crypto.randomUUID();\n    } else {\n        const time = Date.now().toString(36);\n        const rand = Math.random().toString(36).slice(2, 10);\n        id = `${time}-${rand}`;\n    }\n\n    return prefix ? `${prefix}-${id}` : id;\n}\n"],"mappings":"AAWA,SAAgBA,EAAS,EAAyB,CAC9C,IAAIC,EAUJ,MARA,CAKIA,EALA,OAAO,OAAW,KAAe,OAAO,OAAO,YAAe,WACzD,OAAO,WAAW,EAIlB,GAFQ,KAAK,IAAI,CAAC,CAAC,SAAS,EAEzB,EAAK,GADA,KAAK,OAAO,CAAC,CAAC,SAAS,EAAE,CAAC,CAAC,MAAM,EAAG,EACjC,IAGbC,EAAS,GAAGA,EAAO,GAAGD,IAAOA,CACxC,C"}

package/dist/utils/ids.js.map

@@ -1 +1 @@
-{"version":3,"file":"ids.js","names":[],"sources":["../../src/utils/ids.ts"],"sourcesContent":["/**\n * Generate a collision-resistant id suitable for client-side UI keys.\n *\n * Uses `crypto.randomUUID()` when available, falling back to a\n * timestamp + `Math.random()` combination otherwise. When `prefix` is given,\n * the result is formatted as `${prefix}-${id}`.\n *\n * @example\n * randomId();          // \"9f1c2b3a-...\" (uuid) or \"lq3f8k-4a9z1\" (fallback)\n * randomId(\"user\");    // \"user-9f1c2b3a-...\"\n */\nexport function randomId(prefix?: string): string {\n    let id: string;\n\n    if (typeof crypto !== \"undefined\" && typeof crypto.randomUUID === \"function\") {\n        id = crypto.randomUUID();\n    } else {\n        const time = Date.now().toString(36);\n        const rand = Math.random().toString(36).slice(2, 10);\n        id = `${time}-${rand}`;\n    }\n\n    return prefix ? `${prefix}-${id}` : id;\n}\n"],"mappings":";AAWA,SAAgB,EAAS,GAAyB;CAC9C,IAAI;CAUJ,OARA,AAKI,IALA,OAAO,SAAW,OAAe,OAAO,OAAO,cAAe,aACzD,OAAO,WAAW,IAIlB,GAFQ,KAAK,IAAI,CAAC,CAAC,SAAS,EAEzB,EAAK,GADA,KAAK,OAAO,CAAC,CAAC,SAAS,EAAE,CAAC,CAAC,MAAM,GAAG,EACjC,KAGb,IAAS,GAAG,EAAO,GAAG,MAAO;AACxC"}
+{"version":3,"file":"ids.js","names":["randomId","id","prefix"],"sources":["../../src/utils/ids.ts"],"sourcesContent":["/**\n * Generate a collision-resistant id suitable for client-side UI keys.\n *\n * Uses `crypto.randomUUID()` when available, falling back to a\n * timestamp + `Math.random()` combination otherwise. When `prefix` is given,\n * the result is formatted as `${prefix}-${id}`.\n *\n * @example\n * randomId();          // \"9f1c2b3a-...\" (uuid) or \"lq3f8k-4a9z1\" (fallback)\n * randomId(\"user\");    // \"user-9f1c2b3a-...\"\n */\nexport function randomId(prefix?: string): string {\n    let id: string;\n\n    if (typeof crypto !== \"undefined\" && typeof crypto.randomUUID === \"function\") {\n        id = crypto.randomUUID();\n    } else {\n        const time = Date.now().toString(36);\n        const rand = Math.random().toString(36).slice(2, 10);\n        id = `${time}-${rand}`;\n    }\n\n    return prefix ? `${prefix}-${id}` : id;\n}\n"],"mappings":";AAWA,SAAgBA,EAAS,GAAyB;CAC9C,IAAIC;CAUJ,OARA,AAKIA,IALA,OAAO,SAAW,OAAe,OAAO,OAAO,cAAe,aACzD,OAAO,WAAW,IAIlB,GAFQ,KAAK,IAAI,CAAC,CAAC,SAAS,EAEzB,EAAK,GADA,KAAK,OAAO,CAAC,CAAC,SAAS,EAAE,CAAC,CAAC,MAAM,GAAG,EACjC,KAGbC,IAAS,GAAGA,EAAO,GAAGD,MAAOA;AACxC"}

package/dist/utils/intl-cache.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"intl-cache.cjs","names":[],"sources":["../../src/utils/intl-cache.ts"],"sourcesContent":["/**\n * Cached `Intl` formatter factories.\n *\n * Constructing an `Intl.NumberFormat` or `Intl.DateTimeFormat` resolves locale\n * data, which is the expensive half; formatting with one afterwards is cheap.\n * Building a fresh formatter per call is therefore the difference between a\n * table of money cells costing microseconds and costing a frame: measured at\n * 15.56 µs per construct-and-format against 0.29 µs when the formatter is\n * reused, so a 500 × 3 grid goes from 23.1 ms to 0.4 ms.\n *\n * The cache is keyed by locale plus the serialised options, so two call sites\n * asking for the same shape share one formatter. It is capped and cleared\n * wholesale when it overflows: a caller that varies its options per call (a\n * fraction-digit count driven by data, say) would otherwise grow the map without\n * bound, and dropping everything is both correct and cheaper than tracking\n * recency for a map this small.\n */\n\n/** Largest number of distinct formatter shapes kept before the cache resets. */\nconst MAX_ENTRIES = 64;\n\nconst numberFormats = new Map<string, Intl.NumberFormat>();\nconst dateTimeFormats = new Map<string, Intl.DateTimeFormat>();\n\n/**\n * Build the cache key for a locale and options pair.\n *\n * @param locale - The BCP 47 locale, or `undefined` for the runtime default.\n * @param options - The formatter options, or `undefined`.\n * @returns A string that is equal exactly when both inputs are equivalent.\n */\nfunction keyFor(locale: string | undefined, options: object | undefined): string {\n    return `${locale ?? \"\"}|${options === undefined ? \"\" : JSON.stringify(options)}`;\n}\n\n/**\n * Get an `Intl.NumberFormat`, reusing one already built for the same shape.\n *\n * @param locale - The BCP 47 locale, or `undefined` for the runtime default.\n * @param options - Standard `Intl.NumberFormat` options.\n * @returns A formatter that must not be mutated by the caller.\n */\nexport function numberFormat(\n    locale?: string,\n    options?: Intl.NumberFormatOptions,\n): Intl.NumberFormat {\n    const key = keyFor(locale, options);\n    const hit = numberFormats.get(key);\n    if (hit) return hit;\n    if (numberFormats.size >= MAX_ENTRIES) numberFormats.clear();\n    const formatter = new Intl.NumberFormat(locale, options);\n    numberFormats.set(key, formatter);\n    return formatter;\n}\n\n/**\n * Get an `Intl.DateTimeFormat`, reusing one already built for the same shape.\n *\n * @param locale - The BCP 47 locale, or `undefined` for the runtime default.\n * @param options - Standard `Intl.DateTimeFormat` options.\n * @returns A formatter that must not be mutated by the caller.\n */\nexport function dateTimeFormat(\n    locale?: string,\n    options?: Intl.DateTimeFormatOptions,\n): Intl.DateTimeFormat {\n    const key = keyFor(locale, options);\n    const hit = dateTimeFormats.get(key);\n    if (hit) return hit;\n    if (dateTimeFormats.size >= MAX_ENTRIES) dateTimeFormats.clear();\n    const formatter = new Intl.DateTimeFormat(locale, options);\n    dateTimeFormats.set(key, formatter);\n    return formatter;\n}\n\n/**\n * Drop every cached formatter.\n *\n * Exists for tests that assert on cache behaviour; production code has no\n * reason to call it, because a formatter never goes stale.\n *\n * @returns Nothing.\n */\nexport function clearIntlCache(): void {\n    numberFormats.clear();\n    dateTimeFormats.clear();\n}\n"],"mappings":"AAmBA,IAEM,EAAgB,IAAI,IACpB,EAAkB,IAAI,IAS5B,SAAS,EAAO,EAA4B,EAAqC,CAC7E,MAAO,GAAG,GAAU,GAAG,GAAG,IAAY,IAAA,GAAY,GAAK,KAAK,UAAU,CAAO,GACjF,CASA,SAAgB,EACZ,EACA,EACiB,CACjB,IAAM,EAAM,EAAO,EAAQ,CAAO,EAC5B,EAAM,EAAc,IAAI,CAAG,EACjC,GAAI,EAAK,OAAO,EACZ,EAAc,MAAQ,IAAa,EAAc,MAAM,EAC3D,IAAM,EAAY,IAAI,KAAK,aAAa,EAAQ,CAAO,EAEvD,OADA,EAAc,IAAI,EAAK,CAAS,EACzB,CACX,CASA,SAAgB,EACZ,EACA,EACmB,CACnB,IAAM,EAAM,EAAO,EAAQ,CAAO,EAC5B,EAAM,EAAgB,IAAI,CAAG,EACnC,GAAI,EAAK,OAAO,EACZ,EAAgB,MAAQ,IAAa,EAAgB,MAAM,EAC/D,IAAM,EAAY,IAAI,KAAK,eAAe,EAAQ,CAAO,EAEzD,OADA,EAAgB,IAAI,EAAK,CAAS,EAC3B,CACX"}
+{"version":3,"file":"intl-cache.cjs","names":["numberFormats","dateTimeFormats","keyFor","locale","options","numberFormat","key","hit","formatter","dateTimeFormat"],"sources":["../../src/utils/intl-cache.ts"],"sourcesContent":["/**\n * Cached `Intl` formatter factories.\n *\n * Constructing an `Intl.NumberFormat` or `Intl.DateTimeFormat` resolves locale\n * data, which is the expensive half; formatting with one afterwards is cheap.\n * Building a fresh formatter per call is therefore the difference between a\n * table of money cells costing microseconds and costing a frame: measured at\n * 15.56 µs per construct-and-format against 0.29 µs when the formatter is\n * reused, so a 500 × 3 grid goes from 23.1 ms to 0.4 ms.\n *\n * The cache is keyed by locale plus the serialised options, so two call sites\n * asking for the same shape share one formatter. It is capped and cleared\n * wholesale when it overflows: a caller that varies its options per call (a\n * fraction-digit count driven by data, say) would otherwise grow the map without\n * bound, and dropping everything is both correct and cheaper than tracking\n * recency for a map this small.\n */\n\n/** Largest number of distinct formatter shapes kept before the cache resets. */\nconst MAX_ENTRIES = 64;\n\nconst numberFormats = new Map<string, Intl.NumberFormat>();\nconst dateTimeFormats = new Map<string, Intl.DateTimeFormat>();\n\n/**\n * Build the cache key for a locale and options pair.\n *\n * @param locale - The BCP 47 locale, or `undefined` for the runtime default.\n * @param options - The formatter options, or `undefined`.\n * @returns A string that is equal exactly when both inputs are equivalent.\n */\nfunction keyFor(locale: string | undefined, options: object | undefined): string {\n    return `${locale ?? \"\"}|${options === undefined ? \"\" : JSON.stringify(options)}`;\n}\n\n/**\n * Get an `Intl.NumberFormat`, reusing one already built for the same shape.\n *\n * @param locale - The BCP 47 locale, or `undefined` for the runtime default.\n * @param options - Standard `Intl.NumberFormat` options.\n * @returns A formatter that must not be mutated by the caller.\n */\nexport function numberFormat(\n    locale?: string,\n    options?: Intl.NumberFormatOptions,\n): Intl.NumberFormat {\n    const key = keyFor(locale, options);\n    const hit = numberFormats.get(key);\n    if (hit) return hit;\n    if (numberFormats.size >= MAX_ENTRIES) numberFormats.clear();\n    const formatter = new Intl.NumberFormat(locale, options);\n    numberFormats.set(key, formatter);\n    return formatter;\n}\n\n/**\n * Get an `Intl.DateTimeFormat`, reusing one already built for the same shape.\n *\n * @param locale - The BCP 47 locale, or `undefined` for the runtime default.\n * @param options - Standard `Intl.DateTimeFormat` options.\n * @returns A formatter that must not be mutated by the caller.\n */\nexport function dateTimeFormat(\n    locale?: string,\n    options?: Intl.DateTimeFormatOptions,\n): Intl.DateTimeFormat {\n    const key = keyFor(locale, options);\n    const hit = dateTimeFormats.get(key);\n    if (hit) return hit;\n    if (dateTimeFormats.size >= MAX_ENTRIES) dateTimeFormats.clear();\n    const formatter = new Intl.DateTimeFormat(locale, options);\n    dateTimeFormats.set(key, formatter);\n    return formatter;\n}\n\n/**\n * Drop every cached formatter.\n *\n * Exists for tests that assert on cache behaviour; production code has no\n * reason to call it, because a formatter never goes stale.\n *\n * @returns Nothing.\n */\nexport function clearIntlCache(): void {\n    numberFormats.clear();\n    dateTimeFormats.clear();\n}\n"],"mappings":"AAmBA,IAEMA,EAAgB,IAAI,IACpBC,EAAkB,IAAI,IAS5B,SAASC,EAAO,EAA4B,EAAqC,CAC7E,MAAO,GAAGC,GAAU,GAAG,GAAGC,IAAY,IAAA,GAAY,GAAK,KAAK,UAAUA,CAAO,GACjF,CASA,SAAgBC,EACZ,EACA,EACiB,CACjB,IAAMC,EAAMJ,EAAOC,EAAQC,CAAO,EAC5BG,EAAMP,EAAc,IAAIM,CAAG,EACjC,GAAIC,EAAK,OAAOA,EACZP,EAAc,MAAQ,IAAaA,EAAc,MAAM,EAC3D,IAAMQ,EAAY,IAAI,KAAK,aAAaL,EAAQC,CAAO,EAEvD,OADAJ,EAAc,IAAIM,EAAKE,CAAS,EACzBA,CACX,CASA,SAAgBC,EACZ,EACA,EACmB,CACnB,IAAMH,EAAMJ,EAAOC,EAAQC,CAAO,EAC5BG,EAAMN,EAAgB,IAAIK,CAAG,EACnC,GAAIC,EAAK,OAAOA,EACZN,EAAgB,MAAQ,IAAaA,EAAgB,MAAM,EAC/D,IAAMO,EAAY,IAAI,KAAK,eAAeL,EAAQC,CAAO,EAEzD,OADAH,EAAgB,IAAIK,EAAKE,CAAS,EAC3BA,CACX,C"}

package/dist/utils/intl-cache.js.map

@@ -1 +1 @@
-{"version":3,"file":"intl-cache.js","names":[],"sources":["../../src/utils/intl-cache.ts"],"sourcesContent":["/**\n * Cached `Intl` formatter factories.\n *\n * Constructing an `Intl.NumberFormat` or `Intl.DateTimeFormat` resolves locale\n * data, which is the expensive half; formatting with one afterwards is cheap.\n * Building a fresh formatter per call is therefore the difference between a\n * table of money cells costing microseconds and costing a frame: measured at\n * 15.56 µs per construct-and-format against 0.29 µs when the formatter is\n * reused, so a 500 × 3 grid goes from 23.1 ms to 0.4 ms.\n *\n * The cache is keyed by locale plus the serialised options, so two call sites\n * asking for the same shape share one formatter. It is capped and cleared\n * wholesale when it overflows: a caller that varies its options per call (a\n * fraction-digit count driven by data, say) would otherwise grow the map without\n * bound, and dropping everything is both correct and cheaper than tracking\n * recency for a map this small.\n */\n\n/** Largest number of distinct formatter shapes kept before the cache resets. */\nconst MAX_ENTRIES = 64;\n\nconst numberFormats = new Map<string, Intl.NumberFormat>();\nconst dateTimeFormats = new Map<string, Intl.DateTimeFormat>();\n\n/**\n * Build the cache key for a locale and options pair.\n *\n * @param locale - The BCP 47 locale, or `undefined` for the runtime default.\n * @param options - The formatter options, or `undefined`.\n * @returns A string that is equal exactly when both inputs are equivalent.\n */\nfunction keyFor(locale: string | undefined, options: object | undefined): string {\n    return `${locale ?? \"\"}|${options === undefined ? \"\" : JSON.stringify(options)}`;\n}\n\n/**\n * Get an `Intl.NumberFormat`, reusing one already built for the same shape.\n *\n * @param locale - The BCP 47 locale, or `undefined` for the runtime default.\n * @param options - Standard `Intl.NumberFormat` options.\n * @returns A formatter that must not be mutated by the caller.\n */\nexport function numberFormat(\n    locale?: string,\n    options?: Intl.NumberFormatOptions,\n): Intl.NumberFormat {\n    const key = keyFor(locale, options);\n    const hit = numberFormats.get(key);\n    if (hit) return hit;\n    if (numberFormats.size >= MAX_ENTRIES) numberFormats.clear();\n    const formatter = new Intl.NumberFormat(locale, options);\n    numberFormats.set(key, formatter);\n    return formatter;\n}\n\n/**\n * Get an `Intl.DateTimeFormat`, reusing one already built for the same shape.\n *\n * @param locale - The BCP 47 locale, or `undefined` for the runtime default.\n * @param options - Standard `Intl.DateTimeFormat` options.\n * @returns A formatter that must not be mutated by the caller.\n */\nexport function dateTimeFormat(\n    locale?: string,\n    options?: Intl.DateTimeFormatOptions,\n): Intl.DateTimeFormat {\n    const key = keyFor(locale, options);\n    const hit = dateTimeFormats.get(key);\n    if (hit) return hit;\n    if (dateTimeFormats.size >= MAX_ENTRIES) dateTimeFormats.clear();\n    const formatter = new Intl.DateTimeFormat(locale, options);\n    dateTimeFormats.set(key, formatter);\n    return formatter;\n}\n\n/**\n * Drop every cached formatter.\n *\n * Exists for tests that assert on cache behaviour; production code has no\n * reason to call it, because a formatter never goes stale.\n *\n * @returns Nothing.\n */\nexport function clearIntlCache(): void {\n    numberFormats.clear();\n    dateTimeFormats.clear();\n}\n"],"mappings":";AAmBA,IAEM,oBAAgB,IAAI,IAA+B,GACnD,oBAAkB,IAAI,IAAiC;AAS7D,SAAS,EAAO,GAA4B,GAAqC;CAC7E,OAAO,GAAG,KAAU,GAAG,GAAG,MAAY,KAAA,IAAY,KAAK,KAAK,UAAU,CAAO;AACjF;AASA,SAAgB,EACZ,GACA,GACiB;CACjB,IAAM,IAAM,EAAO,GAAQ,CAAO,GAC5B,IAAM,EAAc,IAAI,CAAG;CACjC,IAAI,GAAK,OAAO;CAChB,AAAI,EAAc,QAAQ,MAAa,EAAc,MAAM;CAC3D,IAAM,IAAY,IAAI,KAAK,aAAa,GAAQ,CAAO;CAEvD,OADA,EAAc,IAAI,GAAK,CAAS,GACzB;AACX;AASA,SAAgB,EACZ,GACA,GACmB;CACnB,IAAM,IAAM,EAAO,GAAQ,CAAO,GAC5B,IAAM,EAAgB,IAAI,CAAG;CACnC,IAAI,GAAK,OAAO;CAChB,AAAI,EAAgB,QAAQ,MAAa,EAAgB,MAAM;CAC/D,IAAM,IAAY,IAAI,KAAK,eAAe,GAAQ,CAAO;CAEzD,OADA,EAAgB,IAAI,GAAK,CAAS,GAC3B;AACX"}
+{"version":3,"file":"intl-cache.js","names":["numberFormats","dateTimeFormats","keyFor","locale","options","numberFormat","key","hit","formatter","dateTimeFormat"],"sources":["../../src/utils/intl-cache.ts"],"sourcesContent":["/**\n * Cached `Intl` formatter factories.\n *\n * Constructing an `Intl.NumberFormat` or `Intl.DateTimeFormat` resolves locale\n * data, which is the expensive half; formatting with one afterwards is cheap.\n * Building a fresh formatter per call is therefore the difference between a\n * table of money cells costing microseconds and costing a frame: measured at\n * 15.56 µs per construct-and-format against 0.29 µs when the formatter is\n * reused, so a 500 × 3 grid goes from 23.1 ms to 0.4 ms.\n *\n * The cache is keyed by locale plus the serialised options, so two call sites\n * asking for the same shape share one formatter. It is capped and cleared\n * wholesale when it overflows: a caller that varies its options per call (a\n * fraction-digit count driven by data, say) would otherwise grow the map without\n * bound, and dropping everything is both correct and cheaper than tracking\n * recency for a map this small.\n */\n\n/** Largest number of distinct formatter shapes kept before the cache resets. */\nconst MAX_ENTRIES = 64;\n\nconst numberFormats = new Map<string, Intl.NumberFormat>();\nconst dateTimeFormats = new Map<string, Intl.DateTimeFormat>();\n\n/**\n * Build the cache key for a locale and options pair.\n *\n * @param locale - The BCP 47 locale, or `undefined` for the runtime default.\n * @param options - The formatter options, or `undefined`.\n * @returns A string that is equal exactly when both inputs are equivalent.\n */\nfunction keyFor(locale: string | undefined, options: object | undefined): string {\n    return `${locale ?? \"\"}|${options === undefined ? \"\" : JSON.stringify(options)}`;\n}\n\n/**\n * Get an `Intl.NumberFormat`, reusing one already built for the same shape.\n *\n * @param locale - The BCP 47 locale, or `undefined` for the runtime default.\n * @param options - Standard `Intl.NumberFormat` options.\n * @returns A formatter that must not be mutated by the caller.\n */\nexport function numberFormat(\n    locale?: string,\n    options?: Intl.NumberFormatOptions,\n): Intl.NumberFormat {\n    const key = keyFor(locale, options);\n    const hit = numberFormats.get(key);\n    if (hit) return hit;\n    if (numberFormats.size >= MAX_ENTRIES) numberFormats.clear();\n    const formatter = new Intl.NumberFormat(locale, options);\n    numberFormats.set(key, formatter);\n    return formatter;\n}\n\n/**\n * Get an `Intl.DateTimeFormat`, reusing one already built for the same shape.\n *\n * @param locale - The BCP 47 locale, or `undefined` for the runtime default.\n * @param options - Standard `Intl.DateTimeFormat` options.\n * @returns A formatter that must not be mutated by the caller.\n */\nexport function dateTimeFormat(\n    locale?: string,\n    options?: Intl.DateTimeFormatOptions,\n): Intl.DateTimeFormat {\n    const key = keyFor(locale, options);\n    const hit = dateTimeFormats.get(key);\n    if (hit) return hit;\n    if (dateTimeFormats.size >= MAX_ENTRIES) dateTimeFormats.clear();\n    const formatter = new Intl.DateTimeFormat(locale, options);\n    dateTimeFormats.set(key, formatter);\n    return formatter;\n}\n\n/**\n * Drop every cached formatter.\n *\n * Exists for tests that assert on cache behaviour; production code has no\n * reason to call it, because a formatter never goes stale.\n *\n * @returns Nothing.\n */\nexport function clearIntlCache(): void {\n    numberFormats.clear();\n    dateTimeFormats.clear();\n}\n"],"mappings":";AAmBA,IAEMA,oBAAgB,IAAI,IAA+B,GACnDC,oBAAkB,IAAI,IAAiC;AAS7D,SAASC,EAAO,GAA4B,GAAqC;CAC7E,OAAO,GAAGC,KAAU,GAAG,GAAGC,MAAY,KAAA,IAAY,KAAK,KAAK,UAAUA,CAAO;AACjF;AASA,SAAgBC,EACZ,GACA,GACiB;CACjB,IAAMC,IAAMJ,EAAOC,GAAQC,CAAO,GAC5BG,IAAMP,EAAc,IAAIM,CAAG;CACjC,IAAIC,GAAK,OAAOA;CAChB,AAAIP,EAAc,QAAQ,MAAaA,EAAc,MAAM;CAC3D,IAAMQ,IAAY,IAAI,KAAK,aAAaL,GAAQC,CAAO;CAEvD,OADAJ,EAAc,IAAIM,GAAKE,CAAS,GACzBA;AACX;AASA,SAAgBC,EACZ,GACA,GACmB;CACnB,IAAMH,IAAMJ,EAAOC,GAAQC,CAAO,GAC5BG,IAAMN,EAAgB,IAAIK,CAAG;CACnC,IAAIC,GAAK,OAAOA;CAChB,AAAIN,EAAgB,QAAQ,MAAaA,EAAgB,MAAM;CAC/D,IAAMO,IAAY,IAAI,KAAK,eAAeL,GAAQC,CAAO;CAEzD,OADAH,EAAgB,IAAIK,GAAKE,CAAS,GAC3BA;AACX"}

package/dist/utils/json-frame.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"json-frame.cjs","names":[],"sources":["../../src/utils/json-frame.ts"],"sourcesContent":["import { isDevBuild } from \"./dev-mode\";\nimport { validateWithSchema, type SchemaIssue, type SchemaLike } from \"./schema-like\";\n\n/**\n * The one decoder behind `createWebSocket`, `useWebSocket` and\n * `createEventStream`.\n *\n * Internal, and imported by path rather than through the `utils` barrel: it\n * exists so the three transports share one answer to \"the frame is not JSON\",\n * not so consumers can call it.\n *\n * That question used to have three identical copies of the same wrong answer —\n * `return raw as unknown as T`, which hands the consumer a `string` announced as\n * `T`. The failure never surfaced at the parse; it surfaced later, on the first\n * `message.id`, with nothing left to say the frame had not been JSON.\n */\n\n/** Outcome of decoding one frame. */\nexport interface DecodedFrame<T> {\n    /** Whether the message should reach `onMessage`. */\n    delivered: boolean;\n    /** The decoded payload. Only meaningful when `delivered` is `true`. */\n    data: T;\n}\n\n/** How one frame should be turned into `T`, and who hears about failures. */\nexport interface DecodeFrameOptions<T> {\n    /** Caller-supplied decoder, which owns the frame completely. */\n    parser?: (raw: string) => T;\n    /** Caller-supplied handler for a frame that is not valid JSON. */\n    onParseError?: (error: unknown, raw: string) => void;\n    /** Caller-supplied schema the decoded payload must satisfy. */\n    schema?: SchemaLike<T>;\n    /** Caller-supplied handler for a payload the schema refused. */\n    onValidationError?: (issues: SchemaIssue[], raw: string) => void;\n}\n\nconst warned = new Set<string>();\n\n/**\n * Warn once per transport that a frame arrived which was not JSON.\n *\n * Once, because a stream sending text frames sends many, and a console line per\n * frame buries the one that mattered. Development builds only.\n *\n * @param transport - Label used in the message, e.g. `\"createWebSocket\"`.\n * @returns Nothing.\n */\nfunction warnOnce(transport: string): void {\n    if (!isDevBuild() || warned.has(transport)) return;\n    warned.add(transport);\n    console.warn(\n        `[tempest-react-sdk] ${transport}: a frame was not valid JSON, so the raw string is ` +\n            `being delivered as if it were your message type. Pass \\`parser\\` to decode it, or ` +\n            `\\`onParseError\\` to drop it and handle the failure. This warning appears once.`,\n    );\n}\n\n/**\n * Warn once per transport that a frame was dropped by the schema.\n *\n * A dropped frame with no `onValidationError` is otherwise completely silent —\n * the stream looks healthy and the payload simply never arrives, which is the\n * hardest shape of failure to notice. Development builds only, once, for the\n * same reason as {@link warnOnce}.\n *\n * @param transport - Label used in the message, e.g. `\"createEventStream\"`.\n * @param issues - The issues the schema reported, summarized into the message.\n * @returns Nothing.\n */\nfunction warnValidationOnce(transport: string, issues: SchemaIssue[]): void {\n    const key = `${transport}:schema`;\n    if (!isDevBuild() || warned.has(key)) return;\n    warned.add(key);\n    const summary = issues.map((issue) => `${issue.path}: ${issue.message}`).join(\"; \");\n    console.warn(\n        `[tempest-react-sdk] ${transport}: a frame did not match \\`schema\\` and was dropped ` +\n            `(${summary}). Pass \\`onValidationError\\` to handle it yourself. This warning ` +\n            `appears once.`,\n    );\n}\n\n/**\n * Decode one frame, reporting whether it should be delivered.\n *\n * A caller-supplied `parser` owns the frame completely: its result is delivered\n * as it is, or validated when a `schema` was also supplied — decoding text,\n * binary-as-base64 or a protocol of its own is the point of that option.\n *\n * Without one, the frame is parsed as JSON. When that throws:\n *\n * - with `onParseError`, the callback fires and the frame is **not** delivered,\n *   because a consumer that asked to hear about failures did not ask to also\n *   receive the broken frame;\n * - with `schema` and no `onParseError`, the raw string goes to the schema,\n *   which refuses it — a caller who asked for validation never receives an\n *   unvalidated payload, and a frame the server sent empty is exactly this case;\n * - with neither, the raw string is delivered as `T` — the behaviour every\n *   version before this one had, kept so nothing breaks — and development builds\n *   warn once that it happened.\n *\n * With a `schema`, a payload the schema refuses is not delivered, and\n * `onValidationError` hears the issues. The value delivered is the schema's\n * **output**, so a schema that coerces or defaults is honoured.\n *\n * @param raw - The frame body as text.\n * @param transport - Label used in the development warnings.\n * @param options - Caller-supplied decoder, schema and failure handlers.\n * @returns Whether to deliver, and the payload.\n */\nexport function decodeFrame<T>(\n    raw: string,\n    transport: string,\n    options: DecodeFrameOptions<T>,\n): DecodedFrame<T> {\n    const { parser, onParseError, schema, onValidationError } = options;\n\n    /**\n     * Put one decoded payload through the schema, when there is one.\n     *\n     * @param value - The payload as parsing produced it.\n     * @returns Whether to deliver, and the payload the consumer should see.\n     */\n    function gate(value: unknown): DecodedFrame<T> {\n        if (!schema) return { delivered: true, data: value as T };\n        const result = validateWithSchema(schema, value);\n        if (result.ok) return { delivered: true, data: result.data };\n        if (onValidationError) onValidationError(result.issues, raw);\n        else warnValidationOnce(transport, result.issues);\n        return { delivered: false, data: undefined as T };\n    }\n\n    if (parser) return gate(parser(raw));\n    let parsed: unknown;\n    try {\n        parsed = JSON.parse(raw);\n    } catch (error) {\n        if (onParseError) {\n            onParseError(error, raw);\n            return { delivered: false, data: undefined as T };\n        }\n        if (schema) return gate(raw);\n        warnOnce(transport);\n        return { delivered: true, data: raw as unknown as T };\n    }\n    return gate(parsed);\n}\n\n/**\n * Forget which transports have already warned.\n *\n * Exists for tests, which would otherwise see the first case swallow the\n * warning for every case after it.\n *\n * @returns Nothing.\n */\nexport function resetFrameWarnings(): void {\n    warned.clear();\n}\n"],"mappings":"iEAqCA,IAAM,EAAS,IAAI,IAWnB,SAAS,EAAS,EAAyB,CAClC,EAAA,WAAW,GAAK,GAAO,IAAI,CAAS,IACzC,EAAO,IAAI,CAAS,EACpB,QAAQ,KACJ,uBAAuB,EAAU,oNAGrC,EACJ,CAcA,SAAS,EAAmB,EAAmB,EAA6B,CACxE,IAAM,EAAM,GAAG,EAAU,SACzB,GAAI,CAAC,EAAA,WAAW,GAAK,EAAO,IAAI,CAAG,EAAG,OACtC,EAAO,IAAI,CAAG,EACd,IAAM,EAAU,EAAO,IAAK,GAAU,GAAG,EAAM,KAAK,IAAI,EAAM,SAAS,CAAC,CAAC,KAAK,IAAI,EAClF,QAAQ,KACJ,uBAAuB,EAAU,sDACzB,EAAQ,gFAEpB,CACJ,CA8BA,SAAgB,EACZ,EACA,EACA,EACe,CACf,GAAM,CAAE,SAAQ,eAAc,SAAQ,qBAAsB,EAQ5D,SAAS,EAAK,EAAiC,CAC3C,GAAI,CAAC,EAAQ,MAAO,CAAE,UAAW,GAAM,KAAM,CAAW,EACxD,IAAM,EAAS,EAAA,mBAAmB,EAAQ,CAAK,EAI/C,OAHI,EAAO,GAAW,CAAE,UAAW,GAAM,KAAM,EAAO,IAAK,GACvD,EAAmB,EAAkB,EAAO,OAAQ,CAAG,EACtD,EAAmB,EAAW,EAAO,MAAM,EACzC,CAAE,UAAW,GAAO,KAAM,IAAA,EAAe,EACpD,CAEA,GAAI,EAAQ,OAAO,EAAK,EAAO,CAAG,CAAC,EACnC,IAAI,EACJ,GAAI,CACA,EAAS,KAAK,MAAM,CAAG,CAC3B,OAAS,EAAO,CAOZ,OANI,GACA,EAAa,EAAO,CAAG,EAChB,CAAE,UAAW,GAAO,KAAM,IAAA,EAAe,GAEhD,EAAe,EAAK,CAAG,GAC3B,EAAS,CAAS,EACX,CAAE,UAAW,GAAM,KAAM,CAAoB,EACxD,CACA,OAAO,EAAK,CAAM,CACtB"}
+{"version":3,"file":"json-frame.cjs","names":["isDevBuild","validateWithSchema","require_dev_mode","require_schema_like","warned","warnOnce","transport","warnValidationOnce","key","summary","issues","issue","decodeFrame","options","gate","schema","value","result","onValidationError","raw","parser","parsed","error","onParseError"],"sources":["../../src/utils/json-frame.ts"],"sourcesContent":["import { isDevBuild } from \"./dev-mode\";\nimport { validateWithSchema, type SchemaIssue, type SchemaLike } from \"./schema-like\";\n\n/**\n * The one decoder behind `createWebSocket`, `useWebSocket` and\n * `createEventStream`.\n *\n * Internal, and imported by path rather than through the `utils` barrel: it\n * exists so the three transports share one answer to \"the frame is not JSON\",\n * not so consumers can call it.\n *\n * That question used to have three identical copies of the same wrong answer —\n * `return raw as unknown as T`, which hands the consumer a `string` announced as\n * `T`. The failure never surfaced at the parse; it surfaced later, on the first\n * `message.id`, with nothing left to say the frame had not been JSON.\n */\n\n/** Outcome of decoding one frame. */\nexport interface DecodedFrame<T> {\n    /** Whether the message should reach `onMessage`. */\n    delivered: boolean;\n    /** The decoded payload. Only meaningful when `delivered` is `true`. */\n    data: T;\n}\n\n/** How one frame should be turned into `T`, and who hears about failures. */\nexport interface DecodeFrameOptions<T> {\n    /** Caller-supplied decoder, which owns the frame completely. */\n    parser?: (raw: string) => T;\n    /** Caller-supplied handler for a frame that is not valid JSON. */\n    onParseError?: (error: unknown, raw: string) => void;\n    /** Caller-supplied schema the decoded payload must satisfy. */\n    schema?: SchemaLike<T>;\n    /** Caller-supplied handler for a payload the schema refused. */\n    onValidationError?: (issues: SchemaIssue[], raw: string) => void;\n}\n\nconst warned = new Set<string>();\n\n/**\n * Warn once per transport that a frame arrived which was not JSON.\n *\n * Once, because a stream sending text frames sends many, and a console line per\n * frame buries the one that mattered. Development builds only.\n *\n * @param transport - Label used in the message, e.g. `\"createWebSocket\"`.\n * @returns Nothing.\n */\nfunction warnOnce(transport: string): void {\n    if (!isDevBuild() || warned.has(transport)) return;\n    warned.add(transport);\n    console.warn(\n        `[tempest-react-sdk] ${transport}: a frame was not valid JSON, so the raw string is ` +\n            `being delivered as if it were your message type. Pass \\`parser\\` to decode it, or ` +\n            `\\`onParseError\\` to drop it and handle the failure. This warning appears once.`,\n    );\n}\n\n/**\n * Warn once per transport that a frame was dropped by the schema.\n *\n * A dropped frame with no `onValidationError` is otherwise completely silent —\n * the stream looks healthy and the payload simply never arrives, which is the\n * hardest shape of failure to notice. Development builds only, once, for the\n * same reason as {@link warnOnce}.\n *\n * @param transport - Label used in the message, e.g. `\"createEventStream\"`.\n * @param issues - The issues the schema reported, summarized into the message.\n * @returns Nothing.\n */\nfunction warnValidationOnce(transport: string, issues: SchemaIssue[]): void {\n    const key = `${transport}:schema`;\n    if (!isDevBuild() || warned.has(key)) return;\n    warned.add(key);\n    const summary = issues.map((issue) => `${issue.path}: ${issue.message}`).join(\"; \");\n    console.warn(\n        `[tempest-react-sdk] ${transport}: a frame did not match \\`schema\\` and was dropped ` +\n            `(${summary}). Pass \\`onValidationError\\` to handle it yourself. This warning ` +\n            `appears once.`,\n    );\n}\n\n/**\n * Decode one frame, reporting whether it should be delivered.\n *\n * A caller-supplied `parser` owns the frame completely: its result is delivered\n * as it is, or validated when a `schema` was also supplied — decoding text,\n * binary-as-base64 or a protocol of its own is the point of that option.\n *\n * Without one, the frame is parsed as JSON. When that throws:\n *\n * - with `onParseError`, the callback fires and the frame is **not** delivered,\n *   because a consumer that asked to hear about failures did not ask to also\n *   receive the broken frame;\n * - with `schema` and no `onParseError`, the raw string goes to the schema,\n *   which refuses it — a caller who asked for validation never receives an\n *   unvalidated payload, and a frame the server sent empty is exactly this case;\n * - with neither, the raw string is delivered as `T` — the behaviour every\n *   version before this one had, kept so nothing breaks — and development builds\n *   warn once that it happened.\n *\n * With a `schema`, a payload the schema refuses is not delivered, and\n * `onValidationError` hears the issues. The value delivered is the schema's\n * **output**, so a schema that coerces or defaults is honoured.\n *\n * @param raw - The frame body as text.\n * @param transport - Label used in the development warnings.\n * @param options - Caller-supplied decoder, schema and failure handlers.\n * @returns Whether to deliver, and the payload.\n */\nexport function decodeFrame<T>(\n    raw: string,\n    transport: string,\n    options: DecodeFrameOptions<T>,\n): DecodedFrame<T> {\n    const { parser, onParseError, schema, onValidationError } = options;\n\n    /**\n     * Put one decoded payload through the schema, when there is one.\n     *\n     * @param value - The payload as parsing produced it.\n     * @returns Whether to deliver, and the payload the consumer should see.\n     */\n    function gate(value: unknown): DecodedFrame<T> {\n        if (!schema) return { delivered: true, data: value as T };\n        const result = validateWithSchema(schema, value);\n        if (result.ok) return { delivered: true, data: result.data };\n        if (onValidationError) onValidationError(result.issues, raw);\n        else warnValidationOnce(transport, result.issues);\n        return { delivered: false, data: undefined as T };\n    }\n\n    if (parser) return gate(parser(raw));\n    let parsed: unknown;\n    try {\n        parsed = JSON.parse(raw);\n    } catch (error) {\n        if (onParseError) {\n            onParseError(error, raw);\n            return { delivered: false, data: undefined as T };\n        }\n        if (schema) return gate(raw);\n        warnOnce(transport);\n        return { delivered: true, data: raw as unknown as T };\n    }\n    return gate(parsed);\n}\n\n/**\n * Forget which transports have already warned.\n *\n * Exists for tests, which would otherwise see the first case swallow the\n * warning for every case after it.\n *\n * @returns Nothing.\n */\nexport function resetFrameWarnings(): void {\n    warned.clear();\n}\n"],"mappings":"A,iEAqCA,IAAMI,EAAS,IAAI,IAWnB,SAASC,EAAS,EAAyB,CAClCL,EAAAA,WAAW,GAAK,GAAO,IAAIM,CAAS,IACzCF,EAAO,IAAIE,CAAS,EACpB,QAAQ,KACJ,uBAAuBA,EAAU,oNAGrC,EACJ,CAcA,SAASC,EAAmB,EAAmB,EAA6B,CACxE,IAAMC,EAAM,GAAGF,EAAU,SACzB,GAAI,CAACN,EAAAA,WAAW,GAAKI,EAAO,IAAII,CAAG,EAAG,OACtCJ,EAAO,IAAII,CAAG,EACd,IAAMC,EAAUC,EAAO,IAAK,GAAU,GAAGC,EAAM,KAAK,IAAIA,EAAM,SAAS,CAAC,CAAC,KAAK,IAAI,EAClF,QAAQ,KACJ,uBAAuBL,EAAU,sDACzBG,EAAQ,gFAEpB,CACJ,CA8BA,SAAgBG,EACZ,EACA,EACA,EACe,CACf,GAAM,CAAE,SAAQ,eAAc,SAAQ,qBAAsBC,EAQ5D,SAASC,EAAK,EAAiC,CAC3C,GAAI,CAACC,EAAQ,MAAO,CAAE,UAAW,GAAM,KAAMC,CAAW,EACxD,IAAMC,EAAShB,EAAAA,mBAAmBc,EAAQC,CAAK,EAI/C,OAHIC,EAAO,GAAW,CAAE,UAAW,GAAM,KAAMA,EAAO,IAAK,GACvDC,EAAmBA,EAAkBD,EAAO,OAAQE,CAAG,EACtDZ,EAAmBD,EAAWW,EAAO,MAAM,EACzC,CAAE,UAAW,GAAO,KAAM,IAAA,EAAe,EACpD,CAEA,GAAIG,EAAQ,OAAON,EAAKM,EAAOD,CAAG,CAAC,EACnC,IAAIE,EACJ,GAAI,CACA,EAAS,KAAK,MAAMF,CAAG,CAC3B,OAASG,EAAO,CAOZ,OANIC,GACAA,EAAaD,EAAOH,CAAG,EAChB,CAAE,UAAW,GAAO,KAAM,IAAA,EAAe,GAEhDJ,EAAeD,EAAKK,CAAG,GAC3Bd,EAASC,CAAS,EACX,CAAE,UAAW,GAAM,KAAMa,CAAoB,EACxD,CACA,OAAOL,EAAKO,CAAM,CACtB,C"}

package/dist/utils/json-frame.js.map

@@ -1 +1 @@
-{"version":3,"file":"json-frame.js","names":[],"sources":["../../src/utils/json-frame.ts"],"sourcesContent":["import { isDevBuild } from \"./dev-mode\";\nimport { validateWithSchema, type SchemaIssue, type SchemaLike } from \"./schema-like\";\n\n/**\n * The one decoder behind `createWebSocket`, `useWebSocket` and\n * `createEventStream`.\n *\n * Internal, and imported by path rather than through the `utils` barrel: it\n * exists so the three transports share one answer to \"the frame is not JSON\",\n * not so consumers can call it.\n *\n * That question used to have three identical copies of the same wrong answer —\n * `return raw as unknown as T`, which hands the consumer a `string` announced as\n * `T`. The failure never surfaced at the parse; it surfaced later, on the first\n * `message.id`, with nothing left to say the frame had not been JSON.\n */\n\n/** Outcome of decoding one frame. */\nexport interface DecodedFrame<T> {\n    /** Whether the message should reach `onMessage`. */\n    delivered: boolean;\n    /** The decoded payload. Only meaningful when `delivered` is `true`. */\n    data: T;\n}\n\n/** How one frame should be turned into `T`, and who hears about failures. */\nexport interface DecodeFrameOptions<T> {\n    /** Caller-supplied decoder, which owns the frame completely. */\n    parser?: (raw: string) => T;\n    /** Caller-supplied handler for a frame that is not valid JSON. */\n    onParseError?: (error: unknown, raw: string) => void;\n    /** Caller-supplied schema the decoded payload must satisfy. */\n    schema?: SchemaLike<T>;\n    /** Caller-supplied handler for a payload the schema refused. */\n    onValidationError?: (issues: SchemaIssue[], raw: string) => void;\n}\n\nconst warned = new Set<string>();\n\n/**\n * Warn once per transport that a frame arrived which was not JSON.\n *\n * Once, because a stream sending text frames sends many, and a console line per\n * frame buries the one that mattered. Development builds only.\n *\n * @param transport - Label used in the message, e.g. `\"createWebSocket\"`.\n * @returns Nothing.\n */\nfunction warnOnce(transport: string): void {\n    if (!isDevBuild() || warned.has(transport)) return;\n    warned.add(transport);\n    console.warn(\n        `[tempest-react-sdk] ${transport}: a frame was not valid JSON, so the raw string is ` +\n            `being delivered as if it were your message type. Pass \\`parser\\` to decode it, or ` +\n            `\\`onParseError\\` to drop it and handle the failure. This warning appears once.`,\n    );\n}\n\n/**\n * Warn once per transport that a frame was dropped by the schema.\n *\n * A dropped frame with no `onValidationError` is otherwise completely silent —\n * the stream looks healthy and the payload simply never arrives, which is the\n * hardest shape of failure to notice. Development builds only, once, for the\n * same reason as {@link warnOnce}.\n *\n * @param transport - Label used in the message, e.g. `\"createEventStream\"`.\n * @param issues - The issues the schema reported, summarized into the message.\n * @returns Nothing.\n */\nfunction warnValidationOnce(transport: string, issues: SchemaIssue[]): void {\n    const key = `${transport}:schema`;\n    if (!isDevBuild() || warned.has(key)) return;\n    warned.add(key);\n    const summary = issues.map((issue) => `${issue.path}: ${issue.message}`).join(\"; \");\n    console.warn(\n        `[tempest-react-sdk] ${transport}: a frame did not match \\`schema\\` and was dropped ` +\n            `(${summary}). Pass \\`onValidationError\\` to handle it yourself. This warning ` +\n            `appears once.`,\n    );\n}\n\n/**\n * Decode one frame, reporting whether it should be delivered.\n *\n * A caller-supplied `parser` owns the frame completely: its result is delivered\n * as it is, or validated when a `schema` was also supplied — decoding text,\n * binary-as-base64 or a protocol of its own is the point of that option.\n *\n * Without one, the frame is parsed as JSON. When that throws:\n *\n * - with `onParseError`, the callback fires and the frame is **not** delivered,\n *   because a consumer that asked to hear about failures did not ask to also\n *   receive the broken frame;\n * - with `schema` and no `onParseError`, the raw string goes to the schema,\n *   which refuses it — a caller who asked for validation never receives an\n *   unvalidated payload, and a frame the server sent empty is exactly this case;\n * - with neither, the raw string is delivered as `T` — the behaviour every\n *   version before this one had, kept so nothing breaks — and development builds\n *   warn once that it happened.\n *\n * With a `schema`, a payload the schema refuses is not delivered, and\n * `onValidationError` hears the issues. The value delivered is the schema's\n * **output**, so a schema that coerces or defaults is honoured.\n *\n * @param raw - The frame body as text.\n * @param transport - Label used in the development warnings.\n * @param options - Caller-supplied decoder, schema and failure handlers.\n * @returns Whether to deliver, and the payload.\n */\nexport function decodeFrame<T>(\n    raw: string,\n    transport: string,\n    options: DecodeFrameOptions<T>,\n): DecodedFrame<T> {\n    const { parser, onParseError, schema, onValidationError } = options;\n\n    /**\n     * Put one decoded payload through the schema, when there is one.\n     *\n     * @param value - The payload as parsing produced it.\n     * @returns Whether to deliver, and the payload the consumer should see.\n     */\n    function gate(value: unknown): DecodedFrame<T> {\n        if (!schema) return { delivered: true, data: value as T };\n        const result = validateWithSchema(schema, value);\n        if (result.ok) return { delivered: true, data: result.data };\n        if (onValidationError) onValidationError(result.issues, raw);\n        else warnValidationOnce(transport, result.issues);\n        return { delivered: false, data: undefined as T };\n    }\n\n    if (parser) return gate(parser(raw));\n    let parsed: unknown;\n    try {\n        parsed = JSON.parse(raw);\n    } catch (error) {\n        if (onParseError) {\n            onParseError(error, raw);\n            return { delivered: false, data: undefined as T };\n        }\n        if (schema) return gate(raw);\n        warnOnce(transport);\n        return { delivered: true, data: raw as unknown as T };\n    }\n    return gate(parsed);\n}\n\n/**\n * Forget which transports have already warned.\n *\n * Exists for tests, which would otherwise see the first case swallow the\n * warning for every case after it.\n *\n * @returns Nothing.\n */\nexport function resetFrameWarnings(): void {\n    warned.clear();\n}\n"],"mappings":";;;AAqCA,IAAM,oBAAS,IAAI,IAAY;AAW/B,SAAS,EAAS,GAAyB;CACnC,AAAC,EAAW,KAAK,GAAO,IAAI,CAAS,MACzC,EAAO,IAAI,CAAS,GACpB,QAAQ,KACJ,uBAAuB,EAAU,oNAGrC;AACJ;AAcA,SAAS,EAAmB,GAAmB,GAA6B;CACxE,IAAM,IAAM,GAAG,EAAU;CACzB,IAAI,CAAC,EAAW,KAAK,EAAO,IAAI,CAAG,GAAG;CACtC,EAAO,IAAI,CAAG;CACd,IAAM,IAAU,EAAO,KAAK,MAAU,GAAG,EAAM,KAAK,IAAI,EAAM,SAAS,CAAC,CAAC,KAAK,IAAI;CAClF,QAAQ,KACJ,uBAAuB,EAAU,sDACzB,EAAQ,gFAEpB;AACJ;AA8BA,SAAgB,EACZ,GACA,GACA,GACe;CACf,IAAM,EAAE,WAAQ,iBAAc,WAAQ,yBAAsB;CAQ5D,SAAS,EAAK,GAAiC;EAC3C,IAAI,CAAC,GAAQ,OAAO;GAAE,WAAW;GAAM,MAAM;EAAW;EACxD,IAAM,IAAS,EAAmB,GAAQ,CAAK;EAI/C,OAHI,EAAO,KAAW;GAAE,WAAW;GAAM,MAAM,EAAO;EAAK,KACvD,IAAmB,EAAkB,EAAO,QAAQ,CAAG,IACtD,EAAmB,GAAW,EAAO,MAAM,GACzC;GAAE,WAAW;GAAO,MAAM,KAAA;EAAe;CACpD;CAEA,IAAI,GAAQ,OAAO,EAAK,EAAO,CAAG,CAAC;CACnC,IAAI;CACJ,IAAI;EACA,IAAS,KAAK,MAAM,CAAG;CAC3B,SAAS,GAAO;EAOZ,OANI,KACA,EAAa,GAAO,CAAG,GAChB;GAAE,WAAW;GAAO,MAAM,KAAA;EAAe,KAEhD,IAAe,EAAK,CAAG,KAC3B,EAAS,CAAS,GACX;GAAE,WAAW;GAAM,MAAM;EAAoB;CACxD;CACA,OAAO,EAAK,CAAM;AACtB"}
+{"version":3,"file":"json-frame.js","names":["warned","warnOnce","isDevBuild","transport","warnValidationOnce","key","summary","issues","issue","decodeFrame","options","gate","schema","value","result","validateWithSchema","onValidationError","raw","parser","parsed","error","onParseError"],"sources":["../../src/utils/json-frame.ts"],"sourcesContent":["import { isDevBuild } from \"./dev-mode\";\nimport { validateWithSchema, type SchemaIssue, type SchemaLike } from \"./schema-like\";\n\n/**\n * The one decoder behind `createWebSocket`, `useWebSocket` and\n * `createEventStream`.\n *\n * Internal, and imported by path rather than through the `utils` barrel: it\n * exists so the three transports share one answer to \"the frame is not JSON\",\n * not so consumers can call it.\n *\n * That question used to have three identical copies of the same wrong answer —\n * `return raw as unknown as T`, which hands the consumer a `string` announced as\n * `T`. The failure never surfaced at the parse; it surfaced later, on the first\n * `message.id`, with nothing left to say the frame had not been JSON.\n */\n\n/** Outcome of decoding one frame. */\nexport interface DecodedFrame<T> {\n    /** Whether the message should reach `onMessage`. */\n    delivered: boolean;\n    /** The decoded payload. Only meaningful when `delivered` is `true`. */\n    data: T;\n}\n\n/** How one frame should be turned into `T`, and who hears about failures. */\nexport interface DecodeFrameOptions<T> {\n    /** Caller-supplied decoder, which owns the frame completely. */\n    parser?: (raw: string) => T;\n    /** Caller-supplied handler for a frame that is not valid JSON. */\n    onParseError?: (error: unknown, raw: string) => void;\n    /** Caller-supplied schema the decoded payload must satisfy. */\n    schema?: SchemaLike<T>;\n    /** Caller-supplied handler for a payload the schema refused. */\n    onValidationError?: (issues: SchemaIssue[], raw: string) => void;\n}\n\nconst warned = new Set<string>();\n\n/**\n * Warn once per transport that a frame arrived which was not JSON.\n *\n * Once, because a stream sending text frames sends many, and a console line per\n * frame buries the one that mattered. Development builds only.\n *\n * @param transport - Label used in the message, e.g. `\"createWebSocket\"`.\n * @returns Nothing.\n */\nfunction warnOnce(transport: string): void {\n    if (!isDevBuild() || warned.has(transport)) return;\n    warned.add(transport);\n    console.warn(\n        `[tempest-react-sdk] ${transport}: a frame was not valid JSON, so the raw string is ` +\n            `being delivered as if it were your message type. Pass \\`parser\\` to decode it, or ` +\n            `\\`onParseError\\` to drop it and handle the failure. This warning appears once.`,\n    );\n}\n\n/**\n * Warn once per transport that a frame was dropped by the schema.\n *\n * A dropped frame with no `onValidationError` is otherwise completely silent —\n * the stream looks healthy and the payload simply never arrives, which is the\n * hardest shape of failure to notice. Development builds only, once, for the\n * same reason as {@link warnOnce}.\n *\n * @param transport - Label used in the message, e.g. `\"createEventStream\"`.\n * @param issues - The issues the schema reported, summarized into the message.\n * @returns Nothing.\n */\nfunction warnValidationOnce(transport: string, issues: SchemaIssue[]): void {\n    const key = `${transport}:schema`;\n    if (!isDevBuild() || warned.has(key)) return;\n    warned.add(key);\n    const summary = issues.map((issue) => `${issue.path}: ${issue.message}`).join(\"; \");\n    console.warn(\n        `[tempest-react-sdk] ${transport}: a frame did not match \\`schema\\` and was dropped ` +\n            `(${summary}). Pass \\`onValidationError\\` to handle it yourself. This warning ` +\n            `appears once.`,\n    );\n}\n\n/**\n * Decode one frame, reporting whether it should be delivered.\n *\n * A caller-supplied `parser` owns the frame completely: its result is delivered\n * as it is, or validated when a `schema` was also supplied — decoding text,\n * binary-as-base64 or a protocol of its own is the point of that option.\n *\n * Without one, the frame is parsed as JSON. When that throws:\n *\n * - with `onParseError`, the callback fires and the frame is **not** delivered,\n *   because a consumer that asked to hear about failures did not ask to also\n *   receive the broken frame;\n * - with `schema` and no `onParseError`, the raw string goes to the schema,\n *   which refuses it — a caller who asked for validation never receives an\n *   unvalidated payload, and a frame the server sent empty is exactly this case;\n * - with neither, the raw string is delivered as `T` — the behaviour every\n *   version before this one had, kept so nothing breaks — and development builds\n *   warn once that it happened.\n *\n * With a `schema`, a payload the schema refuses is not delivered, and\n * `onValidationError` hears the issues. The value delivered is the schema's\n * **output**, so a schema that coerces or defaults is honoured.\n *\n * @param raw - The frame body as text.\n * @param transport - Label used in the development warnings.\n * @param options - Caller-supplied decoder, schema and failure handlers.\n * @returns Whether to deliver, and the payload.\n */\nexport function decodeFrame<T>(\n    raw: string,\n    transport: string,\n    options: DecodeFrameOptions<T>,\n): DecodedFrame<T> {\n    const { parser, onParseError, schema, onValidationError } = options;\n\n    /**\n     * Put one decoded payload through the schema, when there is one.\n     *\n     * @param value - The payload as parsing produced it.\n     * @returns Whether to deliver, and the payload the consumer should see.\n     */\n    function gate(value: unknown): DecodedFrame<T> {\n        if (!schema) return { delivered: true, data: value as T };\n        const result = validateWithSchema(schema, value);\n        if (result.ok) return { delivered: true, data: result.data };\n        if (onValidationError) onValidationError(result.issues, raw);\n        else warnValidationOnce(transport, result.issues);\n        return { delivered: false, data: undefined as T };\n    }\n\n    if (parser) return gate(parser(raw));\n    let parsed: unknown;\n    try {\n        parsed = JSON.parse(raw);\n    } catch (error) {\n        if (onParseError) {\n            onParseError(error, raw);\n            return { delivered: false, data: undefined as T };\n        }\n        if (schema) return gate(raw);\n        warnOnce(transport);\n        return { delivered: true, data: raw as unknown as T };\n    }\n    return gate(parsed);\n}\n\n/**\n * Forget which transports have already warned.\n *\n * Exists for tests, which would otherwise see the first case swallow the\n * warning for every case after it.\n *\n * @returns Nothing.\n */\nexport function resetFrameWarnings(): void {\n    warned.clear();\n}\n"],"mappings":";;;AAqCA,IAAMA,oBAAS,IAAI,IAAY;AAW/B,SAASC,EAAS,GAAyB;CACvC,AAAKC,EAAW,KAAK,GAAO,IAAIC,CAAS,MACzCH,EAAO,IAAIG,CAAS,GACpB,QAAQ,KACJ,uBAAuBA,EAAU,oNAGrC;AACJ;AAcA,SAASC,EAAmB,GAAmB,GAA6B;CACxE,IAAMC,IAAM,GAAGF,EAAU;CACzB,IAAI,CAACD,EAAW,KAAKF,EAAO,IAAIK,CAAG,GAAG;CACtC,EAAO,IAAIA,CAAG;CACd,IAAMC,IAAUC,EAAO,KAAK,MAAU,GAAGC,EAAM,KAAK,IAAIA,EAAM,SAAS,CAAC,CAAC,KAAK,IAAI;CAClF,QAAQ,KACJ,uBAAuBL,EAAU,sDACzBG,EAAQ,gFAEpB;AACJ;AA8BA,SAAgBG,EACZ,GACA,GACA,GACe;CACf,IAAM,EAAE,WAAQ,iBAAc,WAAQ,yBAAsBC;CAQ5D,SAASC,EAAK,GAAiC;EAC3C,IAAI,CAACC,GAAQ,OAAO;GAAE,WAAW;GAAM,MAAMC;EAAW;EACxD,IAAMC,IAASC,EAAmBH,GAAQC,CAAK;EAI/C,OAHIC,EAAO,KAAW;GAAE,WAAW;GAAM,MAAMA,EAAO;EAAK,KACvDE,IAAmBA,EAAkBF,EAAO,QAAQG,CAAG,IACtDb,EAAmBD,GAAWW,EAAO,MAAM,GACzC;GAAE,WAAW;GAAO,MAAM,KAAA;EAAe;CACpD;CAEA,IAAII,GAAQ,OAAOP,EAAKO,EAAOD,CAAG,CAAC;CACnC,IAAIE;CACJ,IAAI;EACA,IAAS,KAAK,MAAMF,CAAG;CAC3B,SAASG,GAAO;EAOZ,OANIC,KACAA,EAAaD,GAAOH,CAAG,GAChB;GAAE,WAAW;GAAO,MAAM,KAAA;EAAe,KAEhDL,IAAeD,EAAKM,CAAG,KAC3BhB,EAASE,CAAS,GACX;GAAE,WAAW;GAAM,MAAMc;EAAoB;CACxD;CACA,OAAON,EAAKQ,CAAM;AACtB"}

package/dist/utils/numbers.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"numbers.cjs","names":[],"sources":["../../src/utils/numbers.ts"],"sourcesContent":["import { fallbackText, isAbsent, type FormatFallbackOptions } from \"@/utils/absent\";\nimport { numberFormat } from \"@/utils/intl-cache\";\n/**\n * Clamp `value` between `min` and `max` (inclusive).\n *\n * @example\n * clamp(120, 0, 100); // 100\n * clamp(-5, 0, 100);  // 0\n * clamp(42, 0, 100);  // 42\n */\nexport function clamp(value: number, min: number, max: number): number {\n    if (Number.isNaN(value)) return value;\n    if (min > max) {\n        const swap = min;\n        min = max;\n        max = swap;\n    }\n    if (value < min) return min;\n    if (value > max) return max;\n    return value;\n}\n\n/**\n * Format a byte count as a human-readable size string.\n *\n * Scales through B, KB, MB, GB and TB using 1024 as the base. `decimals`\n * controls the fractional digits for scaled units (default 1); `0` bytes\n * always renders as `\"0 B\"`.\n *\n * An absent or unrepresentable count renders as `\"—\"`. It used to render as\n * **`\"NaN undefined\"`**: `Math.log(NaN)` walks the exponent off the end of the\n * unit table, so the unit itself came out `undefined` — the size was not merely\n * unreadable, it claimed a unit that does not exist.\n *\n * @example\n * formatBytes(0);       // \"0 B\"\n * formatBytes(1536);    // \"1.5 KB\"\n * formatBytes(1048576); // \"1 MB\"\n * formatBytes(1536, 2); // \"1.50 KB\"\n * formatBytes(null);    // \"—\"\n */\nexport function formatBytes(\n    bytes: number | null | undefined,\n    decimals: number = 1,\n    options?: FormatFallbackOptions,\n): string {\n    if (isAbsent(bytes) || !Number.isFinite(bytes)) return fallbackText(options);\n    if (bytes === 0) return \"0 B\";\n\n    const units = [\"B\", \"KB\", \"MB\", \"GB\", \"TB\"];\n    const base = 1024;\n    const exponent = Math.min(\n        Math.floor(Math.log(Math.abs(bytes)) / Math.log(base)),\n        units.length - 1,\n    );\n    const value = bytes / base ** exponent;\n    const digits = exponent === 0 ? 0 : Math.max(0, decimals);\n    const formatted = parseFloat(value.toFixed(digits)).toString();\n\n    return `${formatted} ${units[exponent]}`;\n}\n\n/**\n * What percentage of `total` is `part`, with an empty base yielding `0`.\n *\n * The guard is the whole point: `(part / total) * 100` produces `NaN` when the\n * base is zero and `Infinity` when only the base is missing, and both reach the\n * screen as a broken label — `NaN%` on an empty dashboard is the single most\n * common way a panel announces that it has no data yet.\n *\n * Returns a **0–100** number, which is what a bar width and a label want.\n * `formatPercent` takes a 0–1 fraction instead, so pair them as\n * `formatPercent(percentOf(a, b) / 100)` — or skip `percentOf` and pass the\n * fraction straight in.\n *\n * The result is not clamped: 120% of a target is a real number somebody wants to\n * see, and capping it would hide the interesting case.\n *\n * @example\n * percentOf(3, 4);  // 75\n * percentOf(5, 0);  // 0\n * percentOf(12, 8); // 150\n *\n * @param part - The measured amount.\n * @param total - The base it is measured against.\n * @returns The percentage, or `0` when the base is zero or either input is not finite.\n */\nexport function percentOf(part: number, total: number): number {\n    if (!Number.isFinite(part) || !Number.isFinite(total) || total === 0) return 0;\n    return (part / total) * 100;\n}\n\n/**\n * Format a number using compact notation (e.g. `1.2K`, `3.4M`).\n *\n * Wraps `Intl.NumberFormat` with `notation: \"compact\"`. The `locale` defaults\n * to `\"en-US\"`.\n *\n * An absent or unrepresentable value renders as `\"—\"`. The `null` case is the\n * one that matters: `Intl` coerces it to zero, so a count the backend left out\n * used to read as **`\"0\"`** — a number the reader has no reason to doubt.\n *\n * @example\n * formatCompactNumber(1234);            // \"1.2K\"\n * formatCompactNumber(5600000);         // \"5.6M\"\n * formatCompactNumber(1234, \"pt-BR\");   // \"1,2 mil\"\n * formatCompactNumber(null);            // \"—\"\n */\nexport function formatCompactNumber(\n    value: number | null | undefined,\n    locale: string = \"en-US\",\n    options?: FormatFallbackOptions,\n): string {\n    if (isAbsent(value) || !Number.isFinite(value)) return fallbackText(options);\n    return numberFormat(locale, { notation: \"compact\", maximumFractionDigits: 1 }).format(value);\n}\n"],"mappings":"8DAUA,SAAgB,EAAM,EAAe,EAAa,EAAqB,CACnE,GAAI,OAAO,MAAM,CAAK,EAAG,OAAO,EAChC,GAAI,EAAM,EAAK,CACX,IAAM,EAAO,EACb,EAAM,EACN,EAAM,CACV,CAGA,OAFI,EAAQ,EAAY,EACpB,EAAQ,EAAY,EACjB,CACX,CAqBA,SAAgB,EACZ,EACA,EAAmB,EACnB,EACM,CACN,GAAI,EAAA,SAAS,CAAK,GAAK,CAAC,OAAO,SAAS,CAAK,EAAG,OAAO,EAAA,aAAa,CAAO,EAC3E,GAAI,IAAU,EAAG,MAAO,MAExB,IAAM,EAAQ,CAAC,IAAK,KAAM,KAAM,KAAM,IAAI,EACpC,EAAO,KACP,EAAW,KAAK,IAClB,KAAK,MAAM,KAAK,IAAI,KAAK,IAAI,CAAK,CAAC,EAAI,KAAK,IAAI,CAAI,CAAC,EACrD,EAAM,OAAS,CACnB,EACM,EAAQ,EAAQ,GAAQ,EACxB,EAAS,IAAa,EAAI,EAAI,KAAK,IAAI,EAAG,CAAQ,EAGxD,MAAO,GAFW,WAAW,EAAM,QAAQ,CAAM,CAAC,CAAC,CAAC,SAE1C,EAAU,GAAG,EAAM,IACjC,CA2BA,SAAgB,EAAU,EAAc,EAAuB,CAE3D,MADI,CAAC,OAAO,SAAS,CAAI,GAAK,CAAC,OAAO,SAAS,CAAK,GAAK,IAAU,EAAU,EACrE,EAAO,EAAS,GAC5B,CAkBA,SAAgB,EACZ,EACA,EAAiB,QACjB,EACM,CAEN,OADI,EAAA,SAAS,CAAK,GAAK,CAAC,OAAO,SAAS,CAAK,EAAU,EAAA,aAAa,CAAO,EACpE,EAAA,aAAa,EAAQ,CAAE,SAAU,UAAW,sBAAuB,CAAE,CAAC,CAAC,CAAC,OAAO,CAAK,CAC/F"}
+{"version":3,"file":"numbers.cjs","names":["isAbsent","fallbackText","numberFormat","require_absent","require_intl_cache","clamp","value","min","max","swap","formatBytes","bytes","options","units","base","exponent","digits","decimals","percentOf","part","total","formatCompactNumber","locale"],"sources":["../../src/utils/numbers.ts"],"sourcesContent":["import { fallbackText, isAbsent, type FormatFallbackOptions } from \"@/utils/absent\";\nimport { numberFormat } from \"@/utils/intl-cache\";\n/**\n * Clamp `value` between `min` and `max` (inclusive).\n *\n * @example\n * clamp(120, 0, 100); // 100\n * clamp(-5, 0, 100);  // 0\n * clamp(42, 0, 100);  // 42\n */\nexport function clamp(value: number, min: number, max: number): number {\n    if (Number.isNaN(value)) return value;\n    if (min > max) {\n        const swap = min;\n        min = max;\n        max = swap;\n    }\n    if (value < min) return min;\n    if (value > max) return max;\n    return value;\n}\n\n/**\n * Format a byte count as a human-readable size string.\n *\n * Scales through B, KB, MB, GB and TB using 1024 as the base. `decimals`\n * controls the fractional digits for scaled units (default 1); `0` bytes\n * always renders as `\"0 B\"`.\n *\n * An absent or unrepresentable count renders as `\"—\"`. It used to render as\n * **`\"NaN undefined\"`**: `Math.log(NaN)` walks the exponent off the end of the\n * unit table, so the unit itself came out `undefined` — the size was not merely\n * unreadable, it claimed a unit that does not exist.\n *\n * @example\n * formatBytes(0);       // \"0 B\"\n * formatBytes(1536);    // \"1.5 KB\"\n * formatBytes(1048576); // \"1 MB\"\n * formatBytes(1536, 2); // \"1.50 KB\"\n * formatBytes(null);    // \"—\"\n */\nexport function formatBytes(\n    bytes: number | null | undefined,\n    decimals: number = 1,\n    options?: FormatFallbackOptions,\n): string {\n    if (isAbsent(bytes) || !Number.isFinite(bytes)) return fallbackText(options);\n    if (bytes === 0) return \"0 B\";\n\n    const units = [\"B\", \"KB\", \"MB\", \"GB\", \"TB\"];\n    const base = 1024;\n    const exponent = Math.min(\n        Math.floor(Math.log(Math.abs(bytes)) / Math.log(base)),\n        units.length - 1,\n    );\n    const value = bytes / base ** exponent;\n    const digits = exponent === 0 ? 0 : Math.max(0, decimals);\n    const formatted = parseFloat(value.toFixed(digits)).toString();\n\n    return `${formatted} ${units[exponent]}`;\n}\n\n/**\n * What percentage of `total` is `part`, with an empty base yielding `0`.\n *\n * The guard is the whole point: `(part / total) * 100` produces `NaN` when the\n * base is zero and `Infinity` when only the base is missing, and both reach the\n * screen as a broken label — `NaN%` on an empty dashboard is the single most\n * common way a panel announces that it has no data yet.\n *\n * Returns a **0–100** number, which is what a bar width and a label want.\n * `formatPercent` takes a 0–1 fraction instead, so pair them as\n * `formatPercent(percentOf(a, b) / 100)` — or skip `percentOf` and pass the\n * fraction straight in.\n *\n * The result is not clamped: 120% of a target is a real number somebody wants to\n * see, and capping it would hide the interesting case.\n *\n * @example\n * percentOf(3, 4);  // 75\n * percentOf(5, 0);  // 0\n * percentOf(12, 8); // 150\n *\n * @param part - The measured amount.\n * @param total - The base it is measured against.\n * @returns The percentage, or `0` when the base is zero or either input is not finite.\n */\nexport function percentOf(part: number, total: number): number {\n    if (!Number.isFinite(part) || !Number.isFinite(total) || total === 0) return 0;\n    return (part / total) * 100;\n}\n\n/**\n * Format a number using compact notation (e.g. `1.2K`, `3.4M`).\n *\n * Wraps `Intl.NumberFormat` with `notation: \"compact\"`. The `locale` defaults\n * to `\"en-US\"`.\n *\n * An absent or unrepresentable value renders as `\"—\"`. The `null` case is the\n * one that matters: `Intl` coerces it to zero, so a count the backend left out\n * used to read as **`\"0\"`** — a number the reader has no reason to doubt.\n *\n * @example\n * formatCompactNumber(1234);            // \"1.2K\"\n * formatCompactNumber(5600000);         // \"5.6M\"\n * formatCompactNumber(1234, \"pt-BR\");   // \"1,2 mil\"\n * formatCompactNumber(null);            // \"—\"\n */\nexport function formatCompactNumber(\n    value: number | null | undefined,\n    locale: string = \"en-US\",\n    options?: FormatFallbackOptions,\n): string {\n    if (isAbsent(value) || !Number.isFinite(value)) return fallbackText(options);\n    return numberFormat(locale, { notation: \"compact\", maximumFractionDigits: 1 }).format(value);\n}\n"],"mappings":"A,8DAUA,SAAgBK,EAAM,EAAe,EAAa,EAAqB,CACnE,GAAI,OAAO,MAAMC,CAAK,EAAG,OAAOA,EAChC,GAAIC,EAAMC,EAAK,CACX,IAAMC,EAAOF,EACb,EAAMC,EACN,EAAMC,CACV,CAGA,OAFIH,EAAQC,EAAYA,EACpBD,EAAQE,EAAYA,EACjBF,CACX,CAqBA,SAAgBI,EACZ,EACA,EAAmB,EACnB,EACM,CACN,GAAIV,EAAAA,SAASW,CAAK,GAAK,CAAC,OAAO,SAASA,CAAK,EAAG,OAAOV,EAAAA,aAAaW,CAAO,EAC3E,GAAID,IAAU,EAAG,MAAO,MAExB,IAAME,EAAQ,CAAC,IAAK,KAAM,KAAM,KAAM,IAAI,EACpCC,EAAO,KACPC,EAAW,KAAK,IAClB,KAAK,MAAM,KAAK,IAAI,KAAK,IAAIJ,CAAK,CAAC,EAAI,KAAK,IAAIG,CAAI,CAAC,EACrDD,EAAM,OAAS,CACnB,EACMP,EAAQK,EAAQG,GAAQC,EACxBC,EAASD,IAAa,EAAI,EAAI,KAAK,IAAI,EAAGE,CAAQ,EAGxD,MAAO,GAFW,WAAWX,EAAM,QAAQU,CAAM,CAAC,CAAC,CAAC,SAE1C,EAAU,GAAGH,EAAME,IACjC,CA2BA,SAAgBG,EAAU,EAAc,EAAuB,CAE3D,MADI,CAAC,OAAO,SAASC,CAAI,GAAK,CAAC,OAAO,SAASC,CAAK,GAAKA,IAAU,EAAU,EACrED,EAAOC,EAAS,GAC5B,CAkBA,SAAgBC,EACZ,EACA,EAAiB,QACjB,EACM,CAEN,OADIrB,EAAAA,SAASM,CAAK,GAAK,CAAC,OAAO,SAASA,CAAK,EAAUL,EAAAA,aAAaW,CAAO,EACpEV,EAAAA,aAAaoB,EAAQ,CAAE,SAAU,UAAW,sBAAuB,CAAE,CAAC,CAAC,CAAC,OAAOhB,CAAK,CAC/F,C"}

package/dist/utils/numbers.js.map

@@ -1 +1 @@
-{"version":3,"file":"numbers.js","names":[],"sources":["../../src/utils/numbers.ts"],"sourcesContent":["import { fallbackText, isAbsent, type FormatFallbackOptions } from \"@/utils/absent\";\nimport { numberFormat } from \"@/utils/intl-cache\";\n/**\n * Clamp `value` between `min` and `max` (inclusive).\n *\n * @example\n * clamp(120, 0, 100); // 100\n * clamp(-5, 0, 100);  // 0\n * clamp(42, 0, 100);  // 42\n */\nexport function clamp(value: number, min: number, max: number): number {\n    if (Number.isNaN(value)) return value;\n    if (min > max) {\n        const swap = min;\n        min = max;\n        max = swap;\n    }\n    if (value < min) return min;\n    if (value > max) return max;\n    return value;\n}\n\n/**\n * Format a byte count as a human-readable size string.\n *\n * Scales through B, KB, MB, GB and TB using 1024 as the base. `decimals`\n * controls the fractional digits for scaled units (default 1); `0` bytes\n * always renders as `\"0 B\"`.\n *\n * An absent or unrepresentable count renders as `\"—\"`. It used to render as\n * **`\"NaN undefined\"`**: `Math.log(NaN)` walks the exponent off the end of the\n * unit table, so the unit itself came out `undefined` — the size was not merely\n * unreadable, it claimed a unit that does not exist.\n *\n * @example\n * formatBytes(0);       // \"0 B\"\n * formatBytes(1536);    // \"1.5 KB\"\n * formatBytes(1048576); // \"1 MB\"\n * formatBytes(1536, 2); // \"1.50 KB\"\n * formatBytes(null);    // \"—\"\n */\nexport function formatBytes(\n    bytes: number | null | undefined,\n    decimals: number = 1,\n    options?: FormatFallbackOptions,\n): string {\n    if (isAbsent(bytes) || !Number.isFinite(bytes)) return fallbackText(options);\n    if (bytes === 0) return \"0 B\";\n\n    const units = [\"B\", \"KB\", \"MB\", \"GB\", \"TB\"];\n    const base = 1024;\n    const exponent = Math.min(\n        Math.floor(Math.log(Math.abs(bytes)) / Math.log(base)),\n        units.length - 1,\n    );\n    const value = bytes / base ** exponent;\n    const digits = exponent === 0 ? 0 : Math.max(0, decimals);\n    const formatted = parseFloat(value.toFixed(digits)).toString();\n\n    return `${formatted} ${units[exponent]}`;\n}\n\n/**\n * What percentage of `total` is `part`, with an empty base yielding `0`.\n *\n * The guard is the whole point: `(part / total) * 100` produces `NaN` when the\n * base is zero and `Infinity` when only the base is missing, and both reach the\n * screen as a broken label — `NaN%` on an empty dashboard is the single most\n * common way a panel announces that it has no data yet.\n *\n * Returns a **0–100** number, which is what a bar width and a label want.\n * `formatPercent` takes a 0–1 fraction instead, so pair them as\n * `formatPercent(percentOf(a, b) / 100)` — or skip `percentOf` and pass the\n * fraction straight in.\n *\n * The result is not clamped: 120% of a target is a real number somebody wants to\n * see, and capping it would hide the interesting case.\n *\n * @example\n * percentOf(3, 4);  // 75\n * percentOf(5, 0);  // 0\n * percentOf(12, 8); // 150\n *\n * @param part - The measured amount.\n * @param total - The base it is measured against.\n * @returns The percentage, or `0` when the base is zero or either input is not finite.\n */\nexport function percentOf(part: number, total: number): number {\n    if (!Number.isFinite(part) || !Number.isFinite(total) || total === 0) return 0;\n    return (part / total) * 100;\n}\n\n/**\n * Format a number using compact notation (e.g. `1.2K`, `3.4M`).\n *\n * Wraps `Intl.NumberFormat` with `notation: \"compact\"`. The `locale` defaults\n * to `\"en-US\"`.\n *\n * An absent or unrepresentable value renders as `\"—\"`. The `null` case is the\n * one that matters: `Intl` coerces it to zero, so a count the backend left out\n * used to read as **`\"0\"`** — a number the reader has no reason to doubt.\n *\n * @example\n * formatCompactNumber(1234);            // \"1.2K\"\n * formatCompactNumber(5600000);         // \"5.6M\"\n * formatCompactNumber(1234, \"pt-BR\");   // \"1,2 mil\"\n * formatCompactNumber(null);            // \"—\"\n */\nexport function formatCompactNumber(\n    value: number | null | undefined,\n    locale: string = \"en-US\",\n    options?: FormatFallbackOptions,\n): string {\n    if (isAbsent(value) || !Number.isFinite(value)) return fallbackText(options);\n    return numberFormat(locale, { notation: \"compact\", maximumFractionDigits: 1 }).format(value);\n}\n"],"mappings":";;;AAUA,SAAgB,EAAM,GAAe,GAAa,GAAqB;CACnE,IAAI,OAAO,MAAM,CAAK,GAAG,OAAO;CAChC,IAAI,IAAM,GAAK;EACX,IAAM,IAAO;EAEb,AADA,IAAM,GACN,IAAM;CACV;CAGA,OAFI,IAAQ,IAAY,IACpB,IAAQ,IAAY,IACjB;AACX;AAqBA,SAAgB,EACZ,GACA,IAAmB,GACnB,GACM;CACN,IAAI,EAAS,CAAK,KAAK,CAAC,OAAO,SAAS,CAAK,GAAG,OAAO,EAAa,CAAO;CAC3E,IAAI,MAAU,GAAG,OAAO;CAExB,IAAM,IAAQ;EAAC;EAAK;EAAM;EAAM;EAAM;CAAI,GACpC,IAAO,MACP,IAAW,KAAK,IAClB,KAAK,MAAM,KAAK,IAAI,KAAK,IAAI,CAAK,CAAC,IAAI,KAAK,IAAI,CAAI,CAAC,GACrD,EAAM,SAAS,CACnB,GACM,IAAQ,IAAQ,KAAQ,GACxB,IAAS,MAAa,IAAI,IAAI,KAAK,IAAI,GAAG,CAAQ;CAGxD,OAAO,GAFW,WAAW,EAAM,QAAQ,CAAM,CAAC,CAAC,CAAC,SAE1C,EAAU,GAAG,EAAM;AACjC;AA2BA,SAAgB,EAAU,GAAc,GAAuB;CAE3D,OADI,CAAC,OAAO,SAAS,CAAI,KAAK,CAAC,OAAO,SAAS,CAAK,KAAK,MAAU,IAAU,IACrE,IAAO,IAAS;AAC5B;AAkBA,SAAgB,EACZ,GACA,IAAiB,SACjB,GACM;CAEN,OADI,EAAS,CAAK,KAAK,CAAC,OAAO,SAAS,CAAK,IAAU,EAAa,CAAO,IACpE,EAAa,GAAQ;EAAE,UAAU;EAAW,uBAAuB;CAAE,CAAC,CAAC,CAAC,OAAO,CAAK;AAC/F"}
+{"version":3,"file":"numbers.js","names":["clamp","value","min","max","swap","formatBytes","isAbsent","bytes","fallbackText","options","units","base","exponent","digits","decimals","percentOf","part","total","formatCompactNumber","numberFormat","locale"],"sources":["../../src/utils/numbers.ts"],"sourcesContent":["import { fallbackText, isAbsent, type FormatFallbackOptions } from \"@/utils/absent\";\nimport { numberFormat } from \"@/utils/intl-cache\";\n/**\n * Clamp `value` between `min` and `max` (inclusive).\n *\n * @example\n * clamp(120, 0, 100); // 100\n * clamp(-5, 0, 100);  // 0\n * clamp(42, 0, 100);  // 42\n */\nexport function clamp(value: number, min: number, max: number): number {\n    if (Number.isNaN(value)) return value;\n    if (min > max) {\n        const swap = min;\n        min = max;\n        max = swap;\n    }\n    if (value < min) return min;\n    if (value > max) return max;\n    return value;\n}\n\n/**\n * Format a byte count as a human-readable size string.\n *\n * Scales through B, KB, MB, GB and TB using 1024 as the base. `decimals`\n * controls the fractional digits for scaled units (default 1); `0` bytes\n * always renders as `\"0 B\"`.\n *\n * An absent or unrepresentable count renders as `\"—\"`. It used to render as\n * **`\"NaN undefined\"`**: `Math.log(NaN)` walks the exponent off the end of the\n * unit table, so the unit itself came out `undefined` — the size was not merely\n * unreadable, it claimed a unit that does not exist.\n *\n * @example\n * formatBytes(0);       // \"0 B\"\n * formatBytes(1536);    // \"1.5 KB\"\n * formatBytes(1048576); // \"1 MB\"\n * formatBytes(1536, 2); // \"1.50 KB\"\n * formatBytes(null);    // \"—\"\n */\nexport function formatBytes(\n    bytes: number | null | undefined,\n    decimals: number = 1,\n    options?: FormatFallbackOptions,\n): string {\n    if (isAbsent(bytes) || !Number.isFinite(bytes)) return fallbackText(options);\n    if (bytes === 0) return \"0 B\";\n\n    const units = [\"B\", \"KB\", \"MB\", \"GB\", \"TB\"];\n    const base = 1024;\n    const exponent = Math.min(\n        Math.floor(Math.log(Math.abs(bytes)) / Math.log(base)),\n        units.length - 1,\n    );\n    const value = bytes / base ** exponent;\n    const digits = exponent === 0 ? 0 : Math.max(0, decimals);\n    const formatted = parseFloat(value.toFixed(digits)).toString();\n\n    return `${formatted} ${units[exponent]}`;\n}\n\n/**\n * What percentage of `total` is `part`, with an empty base yielding `0`.\n *\n * The guard is the whole point: `(part / total) * 100` produces `NaN` when the\n * base is zero and `Infinity` when only the base is missing, and both reach the\n * screen as a broken label — `NaN%` on an empty dashboard is the single most\n * common way a panel announces that it has no data yet.\n *\n * Returns a **0–100** number, which is what a bar width and a label want.\n * `formatPercent` takes a 0–1 fraction instead, so pair them as\n * `formatPercent(percentOf(a, b) / 100)` — or skip `percentOf` and pass the\n * fraction straight in.\n *\n * The result is not clamped: 120% of a target is a real number somebody wants to\n * see, and capping it would hide the interesting case.\n *\n * @example\n * percentOf(3, 4);  // 75\n * percentOf(5, 0);  // 0\n * percentOf(12, 8); // 150\n *\n * @param part - The measured amount.\n * @param total - The base it is measured against.\n * @returns The percentage, or `0` when the base is zero or either input is not finite.\n */\nexport function percentOf(part: number, total: number): number {\n    if (!Number.isFinite(part) || !Number.isFinite(total) || total === 0) return 0;\n    return (part / total) * 100;\n}\n\n/**\n * Format a number using compact notation (e.g. `1.2K`, `3.4M`).\n *\n * Wraps `Intl.NumberFormat` with `notation: \"compact\"`. The `locale` defaults\n * to `\"en-US\"`.\n *\n * An absent or unrepresentable value renders as `\"—\"`. The `null` case is the\n * one that matters: `Intl` coerces it to zero, so a count the backend left out\n * used to read as **`\"0\"`** — a number the reader has no reason to doubt.\n *\n * @example\n * formatCompactNumber(1234);            // \"1.2K\"\n * formatCompactNumber(5600000);         // \"5.6M\"\n * formatCompactNumber(1234, \"pt-BR\");   // \"1,2 mil\"\n * formatCompactNumber(null);            // \"—\"\n */\nexport function formatCompactNumber(\n    value: number | null | undefined,\n    locale: string = \"en-US\",\n    options?: FormatFallbackOptions,\n): string {\n    if (isAbsent(value) || !Number.isFinite(value)) return fallbackText(options);\n    return numberFormat(locale, { notation: \"compact\", maximumFractionDigits: 1 }).format(value);\n}\n"],"mappings":";;;AAUA,SAAgBA,EAAM,GAAe,GAAa,GAAqB;CACnE,IAAI,OAAO,MAAMC,CAAK,GAAG,OAAOA;CAChC,IAAIC,IAAMC,GAAK;EACX,IAAMC,IAAOF;EAEb,AADA,IAAMC,GACN,IAAMC;CACV;CAGA,OAFIH,IAAQC,IAAYA,IACpBD,IAAQE,IAAYA,IACjBF;AACX;AAqBA,SAAgBI,EACZ,GACA,IAAmB,GACnB,GACM;CACN,IAAIC,EAASC,CAAK,KAAK,CAAC,OAAO,SAASA,CAAK,GAAG,OAAOC,EAAaC,CAAO;CAC3E,IAAIF,MAAU,GAAG,OAAO;CAExB,IAAMG,IAAQ;EAAC;EAAK;EAAM;EAAM;EAAM;CAAI,GACpCC,IAAO,MACPC,IAAW,KAAK,IAClB,KAAK,MAAM,KAAK,IAAI,KAAK,IAAIL,CAAK,CAAC,IAAI,KAAK,IAAII,CAAI,CAAC,GACrDD,EAAM,SAAS,CACnB,GACMT,IAAQM,IAAQI,KAAQC,GACxBC,IAASD,MAAa,IAAI,IAAI,KAAK,IAAI,GAAGE,CAAQ;CAGxD,OAAO,GAFW,WAAWb,EAAM,QAAQY,CAAM,CAAC,CAAC,CAAC,SAE1C,EAAU,GAAGH,EAAME;AACjC;AA2BA,SAAgBG,EAAU,GAAc,GAAuB;CAE3D,OADI,CAAC,OAAO,SAASC,CAAI,KAAK,CAAC,OAAO,SAASC,CAAK,KAAKA,MAAU,IAAU,IACrED,IAAOC,IAAS;AAC5B;AAkBA,SAAgBC,EACZ,GACA,IAAiB,SACjB,GACM;CAEN,OADIZ,EAASL,CAAK,KAAK,CAAC,OAAO,SAASA,CAAK,IAAUO,EAAaC,CAAO,IACpEU,EAAaC,GAAQ;EAAE,UAAU;EAAW,uBAAuB;CAAE,CAAC,CAAC,CAAC,OAAOnB,CAAK;AAC/F"}

package/dist/utils/objects.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"objects.cjs","names":[],"sources":["../../src/utils/objects.ts"],"sourcesContent":["/**\n * Determine whether a value is a plain object literal.\n *\n * Returns `false` for arrays, `null`, dates, maps, sets, and class instances.\n *\n * @internal\n */\nfunction isPlainRecord(value: unknown): value is Record<string, unknown> {\n    if (typeof value !== \"object\" || value === null) return false;\n    const proto = Object.getPrototypeOf(value);\n    return proto === Object.prototype || proto === null;\n}\n\n/**\n * Create a new object containing only the given `keys` from `obj`.\n *\n * Missing keys are skipped. The input is never mutated.\n *\n * @example\n * pick({ id: 1, name: \"Ana\", age: 30 }, [\"id\", \"name\"]);\n * // { id: 1, name: \"Ana\" }\n */\nexport function pick<T extends object, K extends keyof T>(obj: T, keys: K[]): Pick<T, K> {\n    const result = {} as Pick<T, K>;\n    for (const key of keys) {\n        if (Object.prototype.hasOwnProperty.call(obj, key)) {\n            result[key] = obj[key];\n        }\n    }\n    return result;\n}\n\n/**\n * Create a new object with the given `keys` removed from `obj`.\n *\n * The input is never mutated.\n *\n * @example\n * omit({ id: 1, name: \"Ana\", age: 30 }, [\"age\"]);\n * // { id: 1, name: \"Ana\" }\n */\nexport function omit<T extends object, K extends keyof T>(obj: T, keys: K[]): Omit<T, K> {\n    const exclude = new Set<PropertyKey>(keys);\n    const result = {} as Record<PropertyKey, unknown>;\n    for (const key of Object.keys(obj) as (keyof T)[]) {\n        if (!exclude.has(key)) {\n            result[key] = obj[key];\n        }\n    }\n    return result as Omit<T, K>;\n}\n\n/**\n * Recursively merge `source` into `target`, returning a new object.\n *\n * - Plain objects are merged key by key, recursing into nested plain objects.\n * - Arrays and non-plain values (dates, class instances, primitives) replace\n *   the target value entirely — they are not merged element by element.\n * - Neither `target` nor `source` is mutated.\n *\n * @example\n * deepMerge(\n *   { a: 1, nested: { x: 1, y: 2 } },\n *   { nested: { y: 20, z: 30 } },\n * );\n * // { a: 1, nested: { x: 1, y: 20, z: 30 } }\n *\n * @example\n * deepMerge({ tags: [\"a\", \"b\"] }, { tags: [\"c\"] });\n * // { tags: [\"c\"] } (arrays replaced, not merged)\n */\nexport function deepMerge<T>(target: T, source: Partial<T>): T {\n    if (!isPlainRecord(target) || !isPlainRecord(source)) {\n        return (source === undefined ? target : (source as unknown as T)) as T;\n    }\n    const result: Record<string, unknown> = { ...target };\n    for (const key of Object.keys(source)) {\n        const sourceValue = (source as Record<string, unknown>)[key];\n        const targetValue = result[key];\n        if (isPlainRecord(targetValue) && isPlainRecord(sourceValue)) {\n            result[key] = deepMerge(targetValue, sourceValue);\n        } else {\n            result[key] = sourceValue;\n        }\n    }\n    return result as T;\n}\n\n/**\n * Check whether a value is considered \"empty\".\n *\n * Returns `true` for `null`, `undefined`, empty strings, empty arrays, empty\n * plain objects, and empty `Map`/`Set` instances. Returns `false` for numbers\n * (including `0` and `NaN`), booleans, and dates, which are never empty.\n *\n * @example\n * isEmpty(null);       // true\n * isEmpty(\"\");         // true\n * isEmpty([]);         // true\n * isEmpty({});         // true\n * isEmpty(new Map());  // true\n * isEmpty(0);          // false\n * isEmpty(false);      // false\n * isEmpty(new Date()); // false\n */\nexport function isEmpty(value: unknown): boolean {\n    if (value === null || value === undefined) return true;\n    if (typeof value === \"string\") return value.length === 0;\n    if (Array.isArray(value)) return value.length === 0;\n    if (value instanceof Map || value instanceof Set) return value.size === 0;\n    if (isPlainRecord(value)) return Object.keys(value).length === 0;\n    return false;\n}\n"],"mappings":"AAOA,SAAS,EAAc,EAAkD,CACrE,GAAI,OAAO,GAAU,WAAY,EAAgB,MAAO,GACxD,IAAM,EAAQ,OAAO,eAAe,CAAK,EACzC,OAAO,IAAU,OAAO,WAAa,IAAU,IACnD,CAWA,SAAgB,EAA0C,EAAQ,EAAuB,CACrF,IAAM,EAAS,CAAC,EAChB,IAAK,IAAM,KAAO,EACV,OAAO,UAAU,eAAe,KAAK,EAAK,CAAG,IAC7C,EAAO,GAAO,EAAI,IAG1B,OAAO,CACX,CAWA,SAAgB,EAA0C,EAAQ,EAAuB,CACrF,IAAM,EAAU,IAAI,IAAiB,CAAI,EACnC,EAAS,CAAC,EAChB,IAAK,IAAM,KAAO,OAAO,KAAK,CAAG,EACxB,EAAQ,IAAI,CAAG,IAChB,EAAO,GAAO,EAAI,IAG1B,OAAO,CACX,CAqBA,SAAgB,EAAa,EAAW,EAAuB,CAC3D,GAAI,CAAC,EAAc,CAAM,GAAK,CAAC,EAAc,CAAM,EAC/C,OAAQ,IAAW,IAAA,GAAY,EAAU,EAE7C,IAAM,EAAkC,CAAE,GAAG,CAAO,EACpD,IAAK,IAAM,KAAO,OAAO,KAAK,CAAM,EAAG,CACnC,IAAM,EAAe,EAAmC,GAClD,EAAc,EAAO,GAC3B,AAGI,EAAO,GAHP,EAAc,CAAW,GAAK,EAAc,CAAW,EACzC,EAAU,EAAa,CAAW,EAElC,CAEtB,CACA,OAAO,CACX,CAmBA,SAAgB,EAAQ,EAAyB,CAM7C,OALI,GAAU,KAAoC,GAC9C,OAAO,GAAU,UACjB,MAAM,QAAQ,CAAK,EAAU,EAAM,SAAW,EAC9C,aAAiB,KAAO,aAAiB,IAAY,EAAM,OAAS,EACpE,EAAc,CAAK,EAAU,OAAO,KAAK,CAAK,CAAC,CAAC,SAAW,EACxD,EACX"}
+{"version":3,"file":"objects.cjs","names":["isPlainRecord","value","proto","pick","result","key","keys","obj","omit","exclude","deepMerge","target","source","sourceValue","targetValue","isEmpty"],"sources":["../../src/utils/objects.ts"],"sourcesContent":["/**\n * Determine whether a value is a plain object literal.\n *\n * Returns `false` for arrays, `null`, dates, maps, sets, and class instances.\n *\n * @internal\n */\nfunction isPlainRecord(value: unknown): value is Record<string, unknown> {\n    if (typeof value !== \"object\" || value === null) return false;\n    const proto = Object.getPrototypeOf(value);\n    return proto === Object.prototype || proto === null;\n}\n\n/**\n * Create a new object containing only the given `keys` from `obj`.\n *\n * Missing keys are skipped. The input is never mutated.\n *\n * @example\n * pick({ id: 1, name: \"Ana\", age: 30 }, [\"id\", \"name\"]);\n * // { id: 1, name: \"Ana\" }\n */\nexport function pick<T extends object, K extends keyof T>(obj: T, keys: K[]): Pick<T, K> {\n    const result = {} as Pick<T, K>;\n    for (const key of keys) {\n        if (Object.prototype.hasOwnProperty.call(obj, key)) {\n            result[key] = obj[key];\n        }\n    }\n    return result;\n}\n\n/**\n * Create a new object with the given `keys` removed from `obj`.\n *\n * The input is never mutated.\n *\n * @example\n * omit({ id: 1, name: \"Ana\", age: 30 }, [\"age\"]);\n * // { id: 1, name: \"Ana\" }\n */\nexport function omit<T extends object, K extends keyof T>(obj: T, keys: K[]): Omit<T, K> {\n    const exclude = new Set<PropertyKey>(keys);\n    const result = {} as Record<PropertyKey, unknown>;\n    for (const key of Object.keys(obj) as (keyof T)[]) {\n        if (!exclude.has(key)) {\n            result[key] = obj[key];\n        }\n    }\n    return result as Omit<T, K>;\n}\n\n/**\n * Recursively merge `source` into `target`, returning a new object.\n *\n * - Plain objects are merged key by key, recursing into nested plain objects.\n * - Arrays and non-plain values (dates, class instances, primitives) replace\n *   the target value entirely — they are not merged element by element.\n * - Neither `target` nor `source` is mutated.\n *\n * @example\n * deepMerge(\n *   { a: 1, nested: { x: 1, y: 2 } },\n *   { nested: { y: 20, z: 30 } },\n * );\n * // { a: 1, nested: { x: 1, y: 20, z: 30 } }\n *\n * @example\n * deepMerge({ tags: [\"a\", \"b\"] }, { tags: [\"c\"] });\n * // { tags: [\"c\"] } (arrays replaced, not merged)\n */\nexport function deepMerge<T>(target: T, source: Partial<T>): T {\n    if (!isPlainRecord(target) || !isPlainRecord(source)) {\n        return (source === undefined ? target : (source as unknown as T)) as T;\n    }\n    const result: Record<string, unknown> = { ...target };\n    for (const key of Object.keys(source)) {\n        const sourceValue = (source as Record<string, unknown>)[key];\n        const targetValue = result[key];\n        if (isPlainRecord(targetValue) && isPlainRecord(sourceValue)) {\n            result[key] = deepMerge(targetValue, sourceValue);\n        } else {\n            result[key] = sourceValue;\n        }\n    }\n    return result as T;\n}\n\n/**\n * Check whether a value is considered \"empty\".\n *\n * Returns `true` for `null`, `undefined`, empty strings, empty arrays, empty\n * plain objects, and empty `Map`/`Set` instances. Returns `false` for numbers\n * (including `0` and `NaN`), booleans, and dates, which are never empty.\n *\n * @example\n * isEmpty(null);       // true\n * isEmpty(\"\");         // true\n * isEmpty([]);         // true\n * isEmpty({});         // true\n * isEmpty(new Map());  // true\n * isEmpty(0);          // false\n * isEmpty(false);      // false\n * isEmpty(new Date()); // false\n */\nexport function isEmpty(value: unknown): boolean {\n    if (value === null || value === undefined) return true;\n    if (typeof value === \"string\") return value.length === 0;\n    if (Array.isArray(value)) return value.length === 0;\n    if (value instanceof Map || value instanceof Set) return value.size === 0;\n    if (isPlainRecord(value)) return Object.keys(value).length === 0;\n    return false;\n}\n"],"mappings":"AAOA,SAASA,EAAc,EAAkD,CACrE,GAAI,OAAOC,GAAU,WAAYA,EAAgB,MAAO,GACxD,IAAMC,EAAQ,OAAO,eAAeD,CAAK,EACzC,OAAOC,IAAU,OAAO,WAAaA,IAAU,IACnD,CAWA,SAAgBC,EAA0C,EAAQ,EAAuB,CACrF,IAAMC,EAAS,CAAC,EAChB,IAAK,IAAMC,KAAOC,EACV,OAAO,UAAU,eAAe,KAAKC,EAAKF,CAAG,IAC7C,EAAOA,GAAOE,EAAIF,IAG1B,OAAOD,CACX,CAWA,SAAgBI,EAA0C,EAAQ,EAAuB,CACrF,IAAMC,EAAU,IAAI,IAAiBH,CAAI,EACnCF,EAAS,CAAC,EAChB,IAAK,IAAMC,KAAO,OAAO,KAAKE,CAAG,EACxBE,EAAQ,IAAIJ,CAAG,IAChB,EAAOA,GAAOE,EAAIF,IAG1B,OAAOD,CACX,CAqBA,SAAgBM,EAAa,EAAW,EAAuB,CAC3D,GAAI,CAACV,EAAcW,CAAM,GAAK,CAACX,EAAcY,CAAM,EAC/C,OAAQA,IAAW,IAAA,GAAYD,EAAUC,EAE7C,IAAMR,EAAkC,CAAE,GAAGO,CAAO,EACpD,IAAK,IAAMN,KAAO,OAAO,KAAKO,CAAM,EAAG,CACnC,IAAMC,EAAeD,EAAmCP,GAClDS,EAAcV,EAAOC,GAC3B,AAGID,EAAOC,GAHPL,EAAcc,CAAW,GAAKd,EAAca,CAAW,EACzCH,EAAUI,EAAaD,CAAW,EAElCA,CAEtB,CACA,OAAOT,CACX,CAmBA,SAAgBW,EAAQ,EAAyB,CAM7C,OALId,GAAU,KAAoC,GAC9C,OAAOA,GAAU,UACjB,MAAM,QAAQA,CAAK,EAAUA,EAAM,SAAW,EAC9CA,aAAiB,KAAOA,aAAiB,IAAYA,EAAM,OAAS,EACpED,EAAcC,CAAK,EAAU,OAAO,KAAKA,CAAK,CAAC,CAAC,SAAW,EACxD,EACX,C"}