vectis-ui 0.1.0 → 0.8.0

package/dist/utils/file.d.ts

@@ -1,68 +1,58 @@
-/**
- * Everything the design system has to decide about a file the browser hands it, before
- * that file is accepted: is it of a kind we asked for, how do we write its size out, and
- * which of a batch may come in.
- *
- * The three are grouped because they are about the same SUBJECT, not because they share
- * any code — the same arrangement as the text helpers.
- *
- * Nothing here knows anything about components, which is what gives the screening its
- * shape: it HANDS BACK the files it refused instead of announcing them. One body then
- * serves a component that reports refusals one at a time and a test that reads them all
- * as a list.
- */
 /** All the matching needs of a file, so that a test does not have to counterfeit one. */
 export interface FileCandidate {
     name: string;
     type: string;
 }
 /**
- * Decides whether a file is one of the kinds a component said it would take.
+ * An `accept` list read into its tokens: split on commas, trimmed, lowercased, the empty ones
+ * dropped. An empty result accepts everything.
+ */
+export declare function parseAccept(accept?: string): string[];
+/**
+ * Whether a file matches an `accept` list, written exactly as the HTML attribute is:
+ * `.pdf` (case-insensitive), `image/*`, or one precise MIME type. An empty list accepts
+ * everything.
  *
- * The list of accepted kinds is written exactly as HTML has always written it, and it
- * admits three forms: an extension such as ".pdf", regardless of capitals; a whole family
- * such as "image/*"; or one precise kind. Saying nothing at all accepts everything, which
- * is what saying nothing has always meant.
+ * The rule is applied in JS because the ATTRIBUTE only governs the dialog the browser
+ * opens: a DROPPED file bypasses it entirely. Without this second reading, dropping
+ * smuggles anything past a restriction the consumer believes is enforced.
  *
- * The reason this exists in code rather than being left to the browser is that the
- * browser only applies that list to the dialog it opens. A file DROPPED onto the page
- * goes around it entirely and arrives untouched. Without this second reading, dropping
- * would smuggle in anything at all past a restriction the consumer believes is being
- * enforced.
+ * The list may be handed over already read by `parseAccept`, which is what a batch does:
+ * screening a hundred dropped files would otherwise split the same string a hundred times.
  *
- * TRAP — the kind of a file is the BROWSER's guess, and it is often simply empty: an
- * extension it has never heard of, or certain Linux setups. A list written only in terms
- * of kinds then turns away a perfectly good file, which is why the documentation asks for
- * extensions to be spelled out alongside them — "image/*,.heic" rather than "image/*" on
- * its own.
+ * TRAP — `file.type` is the browser's GUESS and is often empty (an unknown extension, some
+ * Linux setups). A list written only in MIME types then turns away a perfectly good file,
+ * which is why the docs ask for extensions alongside: `image/*,.heic`, not `image/*` alone.
  */
-export declare function matchesAccept(file: FileCandidate, accept?: string): boolean;
+export declare function matchesAccept(file: FileCandidate, accept?: string | readonly string[]): boolean;
+export declare function fileKey(file: File): number;
 /**
- * Writes a size out the way a reader expects to see it: 1 200 000 becomes "1.2 MB" in
- * English and "1,2 Mo" in French.
- *
- * The design system's rule about language applies here unchanged. The FORM comes from the
- * browser, which already knows the unit in every language and where the decimal mark
- * goes; only the WORDS around it come from the dictionary. Nothing in this function is
- * translatable.
- *
- * A kilobyte is a thousand bytes, and each rung of the ladder is a thousand of the one
- * below. That is exactly what the unit names the browser prints mean. Using the other,
- * computing convention of 1024 would have a file of 1024 bytes shown as "1.02 kB" — a
- * discrepancy no reader could explain to themselves.
+ * A file size as a reader expects it: 1 200 000 gives "1.2 MB" in English, "1,2 Mo" in
+ * French. Nothing here is translatable — `Intl` knows the unit names and the decimal mark.
  *
- * A size that is negative, or not a number at all, is treated as nothing rather than
- * producing nonsense. The number comes straight from the file, and a size shown beside a
- * name must never be the thing that breaks.
+ * SI base 1000, which is what the unit names `Intl` prints actually mean. The computing
+ * convention of 1024 would show a 1024-byte file as "1.02 kB", a discrepancy no reader can
+ * explain to themselves. A negative or non-finite size reads as 0: the number comes straight
+ * off the file, and a size beside a name must never be the thing that breaks.
  */
 export declare function formatBytes(bytes: number, locale: string): string;
 /**
- * Why a file was turned away. Each component declares its own public name for this: a
- * type belongs to the component that exposes it, and nothing in here is public.
+ * Why a file was turned away: its kind, its size, how many there already are, or the
+ * total.
+ *
+ * VFileInput and VFilePicker screen a batch through the same `screenFiles` below, so the
+ * two report the same thing and the type is declared ONCE, here, rather than copied into
+ * each of them under a name of its own. It is the `TimePickerAllowed` arrangement: the type
+ * lives beside the rule that produces it, and `index.ts` is what makes it public — the
+ * MODULE stays internal, and a handler written for one of the two components can be
+ * handed to the other.
  */
 export type FileRejectReason = 'type' | 'size' | 'count' | 'total-size';
+/** One file that was turned away, and the reason it was. */
 export interface FileRejection {
+    /** The file itself, so a message can name it. */
     file: File;
+    /** What it fell foul of. */
     reason: FileRejectReason;
 }
 export interface FileLimits {
@@ -74,20 +64,18 @@ export interface FileLimits {
     maxTotalSize?: number;
 }
 /**
- * Sorts an arriving batch of files into those that may come in and those that may not,
- * given what has already been chosen.
- *
- * The checks run in the order a reader can act on. A file of the wrong KIND is reported
- * as such even when it is also too big, because being told to shrink a file that would
- * never have been accepted anyway is worse than useless.
+ * Screens an arriving batch against what is already chosen, returning the accepted files
+ * and one rejection per refusal.
  *
- * Nothing is set aside for being chosen twice. There is no reliable way to tell one file
- * from another — two files in different folders may perfectly well share a name — so
- * "already chosen" is deliberately not one of the reasons a file can be refused.
+ * The order `type → size → count → total-size` is a contract both `.mdx` pages state, and
+ * it is the order a reader can act on: a file of the wrong KIND is reported as such even
+ * when it is also too big, since being told to shrink a file that would never be accepted
+ * is worse than useless.
  *
- * What is already chosen counts towards BOTH the number of files and the running total,
- * which is what makes a second drop obey the same limits as the first rather than
- * starting again from nothing.
+ * Duplicates are deliberately NOT a reason: two files in different folders may share a
+ * name, and there is no reliable way to tell one from another. What is already chosen
+ * counts towards both the count and the running total, so a second drop obeys the same
+ * limits as the first instead of starting over.
  */
 export declare function screenFiles(incoming: readonly File[], current: readonly File[], limits: FileLimits): {
     accepted: File[];

package/dist/utils/file.js

@@ -1,70 +1,77 @@
+import { memo as e } from "./memo.js";
 //#region src/utils/file.ts
-function e(e, t) {
-	if (!t) return !0;
-	let n = t.split(",").map((e) => e.trim().toLowerCase()).filter(Boolean);
-	if (n.length === 0) return !0;
-	let r = e.name.toLowerCase(), i = e.type.toLowerCase();
-	return n.some((e) => e === "*" || e === "*/*" ? !0 : e.startsWith(".") ? r.endsWith(e) : e.endsWith("/*") ? i !== "" && i.startsWith(e.slice(0, -1)) : i === e);
+function t(e) {
+	return e ? e.split(",").map((e) => e.trim().toLowerCase()).filter(Boolean) : [];
 }
-var t = [
+function n(e, n) {
+	let r = typeof n == "string" || n === void 0 ? t(n) : n;
+	if (r.length === 0) return !0;
+	let i = e.name.toLowerCase(), a = e.type.toLowerCase();
+	return r.some((e) => e === "*" || e === "*/*" ? !0 : e.startsWith(".") ? i.endsWith(e) : e.endsWith("/*") ? a !== "" && a.startsWith(e.slice(0, -1)) : a === e);
+}
+var r = /* @__PURE__ */ new WeakMap(), i = 0;
+function a(e) {
+	let t = r.get(e);
+	return t === void 0 && (t = i++, r.set(e, t)), t;
+}
+var o = [
 	"byte",
 	"kilobyte",
 	"megabyte",
 	"gigabyte",
 	"terabyte"
-], n = /* @__PURE__ */ new Map(), r = (e) => e === 0 ? 0 : 1;
-function i(e, i) {
-	let a = `${e}|${i}`, o = n.get(a);
-	return o || (o = new Intl.NumberFormat(e, {
+], s = /* @__PURE__ */ new Map(), c = (e) => e === 0 ? 0 : 1;
+function l(t, n) {
+	return e(s, `${t}|${n}`, () => new Intl.NumberFormat(t, {
 		style: "unit",
-		unit: t[i],
+		unit: o[n],
 		unitDisplay: "short",
-		maximumFractionDigits: r(i)
-	}), n.set(a, o)), o;
+		maximumFractionDigits: c(n)
+	}));
 }
-function a(e, n) {
-	let a = Number.isFinite(e) && e > 0 ? e : 0, o = a === 0 ? 0 : Math.min(t.length - 1, Math.max(0, Math.floor(Math.log10(a) / 3))), s = a / 1e3 ** o;
-	return Math.round(s * 10 ** r(o)) / 10 ** r(o) >= 1e3 && o < t.length - 1 && (o += 1, s = a / 1e3 ** o), i(n, o).format(s);
+function u(e, t) {
+	let n = Number.isFinite(e) && e > 0 ? e : 0, r = n === 0 ? 0 : Math.min(o.length - 1, Math.max(0, Math.floor(Math.log10(n) / 3))), i = n / 1e3 ** r;
+	return Math.round(i * 10 ** c(r)) / 10 ** c(r) >= 1e3 && r < o.length - 1 && (r += 1, i = n / 1e3 ** r), l(t, r).format(i);
 }
-function o(t, n, r) {
-	let i = [], a = [], o = n.reduce((e, t) => e + t.size, 0);
-	for (let s of t) {
-		if (!e(s, r.accept)) {
-			a.push({
-				file: s,
+function d(e, r, i) {
+	let a = [], o = [], s = r.reduce((e, t) => e + t.size, 0), c = t(i.accept);
+	for (let t of e) {
+		if (!n(t, c)) {
+			o.push({
+				file: t,
 				reason: "type"
 			});
 			continue;
 		}
-		if (r.maxSize !== void 0 && s.size > r.maxSize) {
-			a.push({
-				file: s,
+		if (i.maxSize !== void 0 && t.size > i.maxSize) {
+			o.push({
+				file: t,
 				reason: "size"
 			});
 			continue;
 		}
-		if (r.maxFiles !== void 0 && n.length + i.length >= r.maxFiles) {
-			a.push({
-				file: s,
+		if (i.maxFiles !== void 0 && r.length + a.length >= i.maxFiles) {
+			o.push({
+				file: t,
 				reason: "count"
 			});
 			continue;
 		}
-		if (r.maxTotalSize !== void 0 && o + s.size > r.maxTotalSize) {
-			a.push({
-				file: s,
+		if (i.maxTotalSize !== void 0 && s + t.size > i.maxTotalSize) {
+			o.push({
+				file: t,
 				reason: "total-size"
 			});
 			continue;
 		}
-		i.push(s), o += s.size;
+		a.push(t), s += t.size;
 	}
 	return {
-		accepted: i,
-		rejected: a
+		accepted: a,
+		rejected: o
 	};
 }
 //#endregion
-export { a as formatBytes, e as matchesAccept, o as screenFiles };
+export { a as fileKey, u as formatBytes, n as matchesAccept, t as parseAccept, d as screenFiles };
 
 //# sourceMappingURL=file.js.map

package/dist/utils/file.js.map

@@ -1 +1 @@
-{"version":3,"file":"file.js","names":[],"sources":["../../src/utils/file.ts"],"sourcesContent":["// @core — module-wide: pure domain logic, no a11y, no DOM, no environment guard.\n/**\n * Everything the design system has to decide about a file the browser hands it, before\n * that file is accepted: is it of a kind we asked for, how do we write its size out, and\n * which of a batch may come in.\n *\n * The three are grouped because they are about the same SUBJECT, not because they share\n * any code — the same arrangement as the text helpers.\n *\n * Nothing here knows anything about components, which is what gives the screening its\n * shape: it HANDS BACK the files it refused instead of announcing them. One body then\n * serves a component that reports refusals one at a time and a test that reads them all\n * as a list.\n */\n\n/** All the matching needs of a file, so that a test does not have to counterfeit one. */\nexport interface FileCandidate {\n  name: string\n  type: string\n}\n\n/**\n * Decides whether a file is one of the kinds a component said it would take.\n *\n * The list of accepted kinds is written exactly as HTML has always written it, and it\n * admits three forms: an extension such as \".pdf\", regardless of capitals; a whole family\n * such as \"image/*\"; or one precise kind. Saying nothing at all accepts everything, which\n * is what saying nothing has always meant.\n *\n * The reason this exists in code rather than being left to the browser is that the\n * browser only applies that list to the dialog it opens. A file DROPPED onto the page\n * goes around it entirely and arrives untouched. Without this second reading, dropping\n * would smuggle in anything at all past a restriction the consumer believes is being\n * enforced.\n *\n * TRAP — the kind of a file is the BROWSER's guess, and it is often simply empty: an\n * extension it has never heard of, or certain Linux setups. A list written only in terms\n * of kinds then turns away a perfectly good file, which is why the documentation asks for\n * extensions to be spelled out alongside them — \"image/*,.heic\" rather than \"image/*\" on\n * its own.\n */\nexport function matchesAccept(file: FileCandidate, accept?: string): boolean {\n  if (!accept) return true\n\n  const tokens = accept\n    .split(',')\n    .map((token) => token.trim().toLowerCase())\n    .filter(Boolean)\n  if (tokens.length === 0) return true\n\n  const name = file.name.toLowerCase()\n  const type = file.type.toLowerCase()\n\n  return tokens.some((token) => {\n    if (token === '*' || token === '*/*') return true\n    if (token.startsWith('.')) return name.endsWith(token)\n    if (token.endsWith('/*')) return type !== '' && type.startsWith(token.slice(0, -1))\n    return type === token\n  })\n}\n\n/** The units a size can be written in, smallest first — the rungs of the ladder. */\nconst UNITS = ['byte', 'kilobyte', 'megabyte', 'gigabyte', 'terabyte'] as const\n\n/**\n * Building a number formatter costs one to two orders of magnitude more than using one,\n * and a running total is rewritten every time a file is added — so one is built per\n * language and rung, and kept for as long as the page lives.\n */\nconst formatters = new Map<string, Intl.NumberFormat>()\n\n/** Bytes are counted whole; above that, one decimal is what reads as a size. */\nconst digitsFor = (step: number) => (step === 0 ? 0 : 1)\n\nfunction formatterFor(locale: string, step: number): Intl.NumberFormat {\n  const key = `${locale}|${step}`\n  let formatter = formatters.get(key)\n  if (!formatter) {\n    formatter = new Intl.NumberFormat(locale, {\n      style: 'unit',\n      unit: UNITS[step]!,\n      unitDisplay: 'short',\n      maximumFractionDigits: digitsFor(step),\n    })\n    formatters.set(key, formatter)\n  }\n  return formatter\n}\n\n/**\n * Writes a size out the way a reader expects to see it: 1 200 000 becomes \"1.2 MB\" in\n * English and \"1,2 Mo\" in French.\n *\n * The design system's rule about language applies here unchanged. The FORM comes from the\n * browser, which already knows the unit in every language and where the decimal mark\n * goes; only the WORDS around it come from the dictionary. Nothing in this function is\n * translatable.\n *\n * A kilobyte is a thousand bytes, and each rung of the ladder is a thousand of the one\n * below. That is exactly what the unit names the browser prints mean. Using the other,\n * computing convention of 1024 would have a file of 1024 bytes shown as \"1.02 kB\" — a\n * discrepancy no reader could explain to themselves.\n *\n * A size that is negative, or not a number at all, is treated as nothing rather than\n * producing nonsense. The number comes straight from the file, and a size shown beside a\n * name must never be the thing that breaks.\n */\nexport function formatBytes(bytes: number, locale: string): string {\n  const n = Number.isFinite(bytes) && bytes > 0 ? bytes : 0\n\n  let step = n === 0 ? 0 : Math.min(UNITS.length - 1, Math.max(0, Math.floor(Math.log10(n) / 3)))\n  let value = n / 1000 ** step\n\n  /*\n   * The carry. A size of 999 999 bytes belongs on the kilobyte rung, and at one decimal\n   * it ROUNDS to 1000 — so the rung and the rounding have to agree, or the reader is\n   * shown \"1,000 kB\" where they expect \"1 MB\". The rounding is done first and the step up\n   * second: the other order lets exactly the same discrepancy through one rung higher.\n   */\n  const rounded = Math.round(value * 10 ** digitsFor(step)) / 10 ** digitsFor(step)\n  if (rounded >= 1000 && step < UNITS.length - 1) {\n    step += 1\n    value = n / 1000 ** step\n  }\n\n  return formatterFor(locale, step).format(value)\n}\n\n/**\n * Why a file was turned away. Each component declares its own public name for this: a\n * type belongs to the component that exposes it, and nothing in here is public.\n */\nexport type FileRejectReason = 'type' | 'size' | 'count' | 'total-size'\n\nexport interface FileRejection {\n  file: File\n  reason: FileRejectReason\n}\n\nexport interface FileLimits {\n  accept?: string\n  /** How large ONE file may be, in bytes. */\n  maxSize?: number\n  /** Already settled by the caller: a field that takes a single file passes one. */\n  maxFiles?: number\n  maxTotalSize?: number\n}\n\n/**\n * Sorts an arriving batch of files into those that may come in and those that may not,\n * given what has already been chosen.\n *\n * The checks run in the order a reader can act on. A file of the wrong KIND is reported\n * as such even when it is also too big, because being told to shrink a file that would\n * never have been accepted anyway is worse than useless.\n *\n * Nothing is set aside for being chosen twice. There is no reliable way to tell one file\n * from another — two files in different folders may perfectly well share a name — so\n * \"already chosen\" is deliberately not one of the reasons a file can be refused.\n *\n * What is already chosen counts towards BOTH the number of files and the running total,\n * which is what makes a second drop obey the same limits as the first rather than\n * starting again from nothing.\n */\nexport function screenFiles(\n  incoming: readonly File[],\n  current: readonly File[],\n  limits: FileLimits,\n): { accepted: File[]; rejected: FileRejection[] } {\n  const accepted: File[] = []\n  const rejected: FileRejection[] = []\n  let total = current.reduce((sum, file) => sum + file.size, 0)\n\n  for (const file of incoming) {\n    if (!matchesAccept(file, limits.accept)) {\n      rejected.push({ file, reason: 'type' })\n      continue\n    }\n    if (limits.maxSize !== undefined && file.size > limits.maxSize) {\n      rejected.push({ file, reason: 'size' })\n      continue\n    }\n    if (limits.maxFiles !== undefined && current.length + accepted.length >= limits.maxFiles) {\n      rejected.push({ file, reason: 'count' })\n      continue\n    }\n    if (limits.maxTotalSize !== undefined && total + file.size > limits.maxTotalSize) {\n      rejected.push({ file, reason: 'total-size' })\n      continue\n    }\n    accepted.push(file)\n    total += file.size\n  }\n\n  return { accepted, rejected }\n}\n"],"mappings":";AAyCA,SAAgB,EAAc,GAAqB,GAA0B;CAC3E,IAAI,CAAC,GAAQ,OAAO;CAEpB,IAAM,IAAS,EACZ,MAAM,GAAG,CAAC,CACV,KAAK,MAAU,EAAM,KAAK,CAAC,CAAC,YAAY,CAAC,CAAC,CAC1C,OAAO,OAAO;CACjB,IAAI,EAAO,WAAW,GAAG,OAAO;CAEhC,IAAM,IAAO,EAAK,KAAK,YAAY,GAC7B,IAAO,EAAK,KAAK,YAAY;CAEnC,OAAO,EAAO,MAAM,MACd,MAAU,OAAO,MAAU,QAAc,KACzC,EAAM,WAAW,GAAG,IAAU,EAAK,SAAS,CAAK,IACjD,EAAM,SAAS,IAAI,IAAU,MAAS,MAAM,EAAK,WAAW,EAAM,MAAM,GAAG,EAAE,CAAC,IAC3E,MAAS,CACjB;AACH;AAGA,IAAM,IAAQ;CAAC;CAAQ;CAAY;CAAY;CAAY;AAAU,GAO/D,oBAAa,IAAI,IAA+B,GAGhD,KAAa,MAAkB,MAAS,IAAI,IAAI;AAEtD,SAAS,EAAa,GAAgB,GAAiC;CACrE,IAAM,IAAM,GAAG,EAAO,GAAG,KACrB,IAAY,EAAW,IAAI,CAAG;CAUlC,OATK,MACH,IAAY,IAAI,KAAK,aAAa,GAAQ;EACxC,OAAO;EACP,MAAM,EAAM;EACZ,aAAa;EACb,uBAAuB,EAAU,CAAI;CACvC,CAAC,GACD,EAAW,IAAI,GAAK,CAAS,IAExB;AACT;AAoBA,SAAgB,EAAY,GAAe,GAAwB;CACjE,IAAM,IAAI,OAAO,SAAS,CAAK,KAAK,IAAQ,IAAI,IAAQ,GAEpD,IAAO,MAAM,IAAI,IAAI,KAAK,IAAI,EAAM,SAAS,GAAG,KAAK,IAAI,GAAG,KAAK,MAAM,KAAK,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,GAC1F,IAAQ,IAAI,OAAQ;CAcxB,OANgB,KAAK,MAAM,IAAQ,MAAM,EAAU,CAAI,CAAC,IAAI,MAAM,EAAU,CAAI,KACjE,OAAQ,IAAO,EAAM,SAAS,MAC3C,KAAQ,GACR,IAAQ,IAAI,OAAQ,IAGf,EAAa,GAAQ,CAAI,CAAC,CAAC,OAAO,CAAK;AAChD;AAsCA,SAAgB,EACd,GACA,GACA,GACiD;CACjD,IAAM,IAAmB,CAAC,GACpB,IAA4B,CAAC,GAC/B,IAAQ,EAAQ,QAAQ,GAAK,MAAS,IAAM,EAAK,MAAM,CAAC;CAE5D,KAAK,IAAM,KAAQ,GAAU;EAC3B,IAAI,CAAC,EAAc,GAAM,EAAO,MAAM,GAAG;GACvC,EAAS,KAAK;IAAE;IAAM,QAAQ;GAAO,CAAC;GACtC;EACF;EACA,IAAI,EAAO,YAAY,KAAA,KAAa,EAAK,OAAO,EAAO,SAAS;GAC9D,EAAS,KAAK;IAAE;IAAM,QAAQ;GAAO,CAAC;GACtC;EACF;EACA,IAAI,EAAO,aAAa,KAAA,KAAa,EAAQ,SAAS,EAAS,UAAU,EAAO,UAAU;GACxF,EAAS,KAAK;IAAE;IAAM,QAAQ;GAAQ,CAAC;GACvC;EACF;EACA,IAAI,EAAO,iBAAiB,KAAA,KAAa,IAAQ,EAAK,OAAO,EAAO,cAAc;GAChF,EAAS,KAAK;IAAE;IAAM,QAAQ;GAAa,CAAC;GAC5C;EACF;EAEA,AADA,EAAS,KAAK,CAAI,GAClB,KAAS,EAAK;CAChB;CAEA,OAAO;EAAE;EAAU;CAAS;AAC9B"}
+{"version":3,"file":"file.js","names":[],"sources":["../../src/utils/file.ts"],"sourcesContent":["// @core — module-wide: pure domain logic, no a11y, no DOM, no environment guard.\n/**\n * The FILE domain: whether a file is of an accepted kind, how its size is written out, and\n * which of a batch may come in. Grouped by subject rather than by shared code, like `text.ts`.\n *\n * Nothing here knows about components, which is what shapes the screening: it RETURNS its\n * refusals instead of emitting them. One body then serves VFileInput, which reports them one\n * at a time, and a test that reads them all as a list without a mount.\n */\nimport { memo } from './memo'\n\n/** All the matching needs of a file, so that a test does not have to counterfeit one. */\nexport interface FileCandidate {\n  name: string\n  type: string\n}\n\n/**\n * An `accept` list read into its tokens: split on commas, trimmed, lowercased, the empty ones\n * dropped. An empty result accepts everything.\n */\nexport function parseAccept(accept?: string): string[] {\n  if (!accept) return []\n  return accept\n    .split(',')\n    .map((token) => token.trim().toLowerCase())\n    .filter(Boolean)\n}\n\n/**\n * Whether a file matches an `accept` list, written exactly as the HTML attribute is:\n * `.pdf` (case-insensitive), `image/*`, or one precise MIME type. An empty list accepts\n * everything.\n *\n * The rule is applied in JS because the ATTRIBUTE only governs the dialog the browser\n * opens: a DROPPED file bypasses it entirely. Without this second reading, dropping\n * smuggles anything past a restriction the consumer believes is enforced.\n *\n * The list may be handed over already read by `parseAccept`, which is what a batch does:\n * screening a hundred dropped files would otherwise split the same string a hundred times.\n *\n * TRAP — `file.type` is the browser's GUESS and is often empty (an unknown extension, some\n * Linux setups). A list written only in MIME types then turns away a perfectly good file,\n * which is why the docs ask for extensions alongside: `image/*,.heic`, not `image/*` alone.\n */\nexport function matchesAccept(file: FileCandidate, accept?: string | readonly string[]): boolean {\n  const tokens = typeof accept === 'string' || accept === undefined ? parseAccept(accept) : accept\n  if (tokens.length === 0) return true\n\n  const name = file.name.toLowerCase()\n  const type = file.type.toLowerCase()\n\n  return tokens.some((token) => {\n    if (token === '*' || token === '*/*') return true\n    if (token.startsWith('.')) return name.endsWith(token)\n    if (token.endsWith('/*')) return type !== '' && type.startsWith(token.slice(0, -1))\n    return type === token\n  })\n}\n\n/**\n * A stable key per FILE OBJECT, for the `v-for` of a file list.\n *\n * An index-based key re-keys every row after a removal, which remounts them — a thumbnail's\n * `<img>` included — and a name is not unique across folders. A File travels through a\n * v-model unproxied (reactivity only wraps plain objects and collections), so its identity is\n * a key that survives both. The map is weak, so a file that leaves every list is not held.\n */\nconst fileIds = new WeakMap<File, number>()\nlet nextFileId = 0\n\nexport function fileKey(file: File): number {\n  let id = fileIds.get(file)\n  if (id === undefined) {\n    id = nextFileId++\n    fileIds.set(file, id)\n  }\n  return id\n}\n\n/** The units a size can be written in, smallest first — the rungs of the ladder. */\nconst UNITS = ['byte', 'kilobyte', 'megabyte', 'gigabyte', 'terabyte'] as const\n\n/**\n * Building a number formatter costs one to two orders of magnitude more than using one,\n * and a running total is rewritten every time a file is added — so one is built per\n * language and rung, and kept for as long as the page lives.\n */\nconst formatters = new Map<string, Intl.NumberFormat>()\n\n/** Bytes are counted whole; above that, one decimal is what reads as a size. */\nconst digitsFor = (step: number) => (step === 0 ? 0 : 1)\n\nfunction formatterFor(locale: string, step: number): Intl.NumberFormat {\n  return memo(\n    formatters,\n    `${locale}|${step}`,\n    () =>\n      new Intl.NumberFormat(locale, {\n        style: 'unit',\n        unit: UNITS[step]!,\n        unitDisplay: 'short',\n        maximumFractionDigits: digitsFor(step),\n      }),\n  )\n}\n\n/**\n * A file size as a reader expects it: 1 200 000 gives \"1.2 MB\" in English, \"1,2 Mo\" in\n * French. Nothing here is translatable — `Intl` knows the unit names and the decimal mark.\n *\n * SI base 1000, which is what the unit names `Intl` prints actually mean. The computing\n * convention of 1024 would show a 1024-byte file as \"1.02 kB\", a discrepancy no reader can\n * explain to themselves. A negative or non-finite size reads as 0: the number comes straight\n * off the file, and a size beside a name must never be the thing that breaks.\n */\nexport function formatBytes(bytes: number, locale: string): string {\n  const n = Number.isFinite(bytes) && bytes > 0 ? bytes : 0\n\n  let step = n === 0 ? 0 : Math.min(UNITS.length - 1, Math.max(0, Math.floor(Math.log10(n) / 3)))\n  let value = n / 1000 ** step\n\n  /*\n   * The carry. 999 999 bytes belongs on the kB rung and ROUNDS to 1000 at one decimal, so\n   * rung and rounding have to agree or the reader is shown \"1,000 kB\" for \"1 MB\". Round\n   * first, then step up: the other order lets the same discrepancy through one rung higher.\n   */\n  const rounded = Math.round(value * 10 ** digitsFor(step)) / 10 ** digitsFor(step)\n  if (rounded >= 1000 && step < UNITS.length - 1) {\n    step += 1\n    value = n / 1000 ** step\n  }\n\n  return formatterFor(locale, step).format(value)\n}\n\n/**\n * Why a file was turned away: its kind, its size, how many there already are, or the\n * total.\n *\n * VFileInput and VFilePicker screen a batch through the same `screenFiles` below, so the\n * two report the same thing and the type is declared ONCE, here, rather than copied into\n * each of them under a name of its own. It is the `TimePickerAllowed` arrangement: the type\n * lives beside the rule that produces it, and `index.ts` is what makes it public — the\n * MODULE stays internal, and a handler written for one of the two components can be\n * handed to the other.\n */\nexport type FileRejectReason = 'type' | 'size' | 'count' | 'total-size'\n\n/** One file that was turned away, and the reason it was. */\nexport interface FileRejection {\n  /** The file itself, so a message can name it. */\n  file: File\n  /** What it fell foul of. */\n  reason: FileRejectReason\n}\n\nexport interface FileLimits {\n  accept?: string\n  /** How large ONE file may be, in bytes. */\n  maxSize?: number\n  /** Already settled by the caller: a field that takes a single file passes one. */\n  maxFiles?: number\n  maxTotalSize?: number\n}\n\n/**\n * Screens an arriving batch against what is already chosen, returning the accepted files\n * and one rejection per refusal.\n *\n * The order `type → size → count → total-size` is a contract both `.mdx` pages state, and\n * it is the order a reader can act on: a file of the wrong KIND is reported as such even\n * when it is also too big, since being told to shrink a file that would never be accepted\n * is worse than useless.\n *\n * Duplicates are deliberately NOT a reason: two files in different folders may share a\n * name, and there is no reliable way to tell one from another. What is already chosen\n * counts towards both the count and the running total, so a second drop obeys the same\n * limits as the first instead of starting over.\n */\nexport function screenFiles(\n  incoming: readonly File[],\n  current: readonly File[],\n  limits: FileLimits,\n): { accepted: File[]; rejected: FileRejection[] } {\n  const accepted: File[] = []\n  const rejected: FileRejection[] = []\n  let total = current.reduce((sum, file) => sum + file.size, 0)\n  const accept = parseAccept(limits.accept)\n\n  for (const file of incoming) {\n    if (!matchesAccept(file, accept)) {\n      rejected.push({ file, reason: 'type' })\n      continue\n    }\n    if (limits.maxSize !== undefined && file.size > limits.maxSize) {\n      rejected.push({ file, reason: 'size' })\n      continue\n    }\n    if (limits.maxFiles !== undefined && current.length + accepted.length >= limits.maxFiles) {\n      rejected.push({ file, reason: 'count' })\n      continue\n    }\n    if (limits.maxTotalSize !== undefined && total + file.size > limits.maxTotalSize) {\n      rejected.push({ file, reason: 'total-size' })\n      continue\n    }\n    accepted.push(file)\n    total += file.size\n  }\n\n  return { accepted, rejected }\n}\n"],"mappings":";;AAqBA,SAAgB,EAAY,GAA2B;CAErD,OADK,IACE,EACJ,MAAM,GAAG,CAAC,CACV,KAAK,MAAU,EAAM,KAAK,CAAC,CAAC,YAAY,CAAC,CAAC,CAC1C,OAAO,OAAO,IAJG,CAAC;AAKvB;AAkBA,SAAgB,EAAc,GAAqB,GAA8C;CAC/F,IAAM,IAAS,OAAO,KAAW,YAAY,MAAW,KAAA,IAAY,EAAY,CAAM,IAAI;CAC1F,IAAI,EAAO,WAAW,GAAG,OAAO;CAEhC,IAAM,IAAO,EAAK,KAAK,YAAY,GAC7B,IAAO,EAAK,KAAK,YAAY;CAEnC,OAAO,EAAO,MAAM,MACd,MAAU,OAAO,MAAU,QAAc,KACzC,EAAM,WAAW,GAAG,IAAU,EAAK,SAAS,CAAK,IACjD,EAAM,SAAS,IAAI,IAAU,MAAS,MAAM,EAAK,WAAW,EAAM,MAAM,GAAG,EAAE,CAAC,IAC3E,MAAS,CACjB;AACH;AAUA,IAAM,oBAAU,IAAI,QAAsB,GACtC,IAAa;AAEjB,SAAgB,EAAQ,GAAoB;CAC1C,IAAI,IAAK,EAAQ,IAAI,CAAI;CAKzB,OAJI,MAAO,KAAA,MACT,IAAK,KACL,EAAQ,IAAI,GAAM,CAAE,IAEf;AACT;AAGA,IAAM,IAAQ;CAAC;CAAQ;CAAY;CAAY;CAAY;AAAU,GAO/D,oBAAa,IAAI,IAA+B,GAGhD,KAAa,MAAkB,MAAS,IAAI,IAAI;AAEtD,SAAS,EAAa,GAAgB,GAAiC;CACrE,OAAO,EACL,GACA,GAAG,EAAO,GAAG,WAEX,IAAI,KAAK,aAAa,GAAQ;EAC5B,OAAO;EACP,MAAM,EAAM;EACZ,aAAa;EACb,uBAAuB,EAAU,CAAI;CACvC,CAAC,CACL;AACF;AAWA,SAAgB,EAAY,GAAe,GAAwB;CACjE,IAAM,IAAI,OAAO,SAAS,CAAK,KAAK,IAAQ,IAAI,IAAQ,GAEpD,IAAO,MAAM,IAAI,IAAI,KAAK,IAAI,EAAM,SAAS,GAAG,KAAK,IAAI,GAAG,KAAK,MAAM,KAAK,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,GAC1F,IAAQ,IAAI,OAAQ;CAaxB,OANgB,KAAK,MAAM,IAAQ,MAAM,EAAU,CAAI,CAAC,IAAI,MAAM,EAAU,CAAI,KACjE,OAAQ,IAAO,EAAM,SAAS,MAC3C,KAAQ,GACR,IAAQ,IAAI,OAAQ,IAGf,EAAa,GAAQ,CAAI,CAAC,CAAC,OAAO,CAAK;AAChD;AA8CA,SAAgB,EACd,GACA,GACA,GACiD;CACjD,IAAM,IAAmB,CAAC,GACpB,IAA4B,CAAC,GAC/B,IAAQ,EAAQ,QAAQ,GAAK,MAAS,IAAM,EAAK,MAAM,CAAC,GACtD,IAAS,EAAY,EAAO,MAAM;CAExC,KAAK,IAAM,KAAQ,GAAU;EAC3B,IAAI,CAAC,EAAc,GAAM,CAAM,GAAG;GAChC,EAAS,KAAK;IAAE;IAAM,QAAQ;GAAO,CAAC;GACtC;EACF;EACA,IAAI,EAAO,YAAY,KAAA,KAAa,EAAK,OAAO,EAAO,SAAS;GAC9D,EAAS,KAAK;IAAE;IAAM,QAAQ;GAAO,CAAC;GACtC;EACF;EACA,IAAI,EAAO,aAAa,KAAA,KAAa,EAAQ,SAAS,EAAS,UAAU,EAAO,UAAU;GACxF,EAAS,KAAK;IAAE;IAAM,QAAQ;GAAQ,CAAC;GACvC;EACF;EACA,IAAI,EAAO,iBAAiB,KAAA,KAAa,IAAQ,EAAK,OAAO,EAAO,cAAc;GAChF,EAAS,KAAK;IAAE;IAAM,QAAQ;GAAa,CAAC;GAC5C;EACF;EAEA,AADA,EAAS,KAAK,CAAI,GAClB,KAAS,EAAK;CAChB;CAEA,OAAO;EAAE;EAAU;CAAS;AAC9B"}

package/dist/utils/focus.d.ts

@@ -1,24 +1,15 @@
 /**
- * Telling a keyboard focus apart from a pointer one.
+ * Whether this element is focused the way a keyboard user focuses things.
  *
- * The distinction is needed because `focus` alone does not carry it: an element focused by a
- * mouse click and one reached with the Tab key are in exactly the same state, and a component
- * reading a bare focus flag treats a passing click as a reader settling in. The browser already
- * makes that judgement for its own focus rings, and `:focus-visible` is where it publishes it —
- * a pointer click on a button does not match it, a Tab does.
- */
-/**
- * Whether this element is focused in the way a keyboard user focuses things.
- *
- * The `try` is for a selector engine that does not know the pseudo-class, and throws on one it
- * cannot parse rather than answering false. Every caller treats the keyboard as the careful
- * answer — it is the one that keeps a component reachable — so that is what an environment
- * unable to be asked returns.
+ * A `focus` event does not carry the distinction: a mouse click and a Tab leave an element in
+ * the same state. The browser already makes the judgement for its own focus rings and
+ * publishes it as `:focus-visible`, so that is what gets asked. The `try` covers a selector
+ * engine that throws on a pseudo-class it cannot parse; the keyboard is the careful answer
+ * there, being the one that keeps a component reachable.
  *
  * TRAP for the tests — jsdom is NOT that environment. It parses `:focus-visible` happily and
  * answers `false` for everything, a genuinely focused element included, so the `catch` never
- * runs there and every test silently takes the pointer branch. A test that means to exercise
- * the keyboard one has to stub `matches` on the element being asked; what it then locks is
- * that the component ASKS and branches, never what jsdom would have answered.
+ * runs and every test silently takes the pointer branch. Stub `matches` on the element being
+ * asked; what that locks is that the component ASKS and branches, never jsdom's answer.
  */
 export declare function isKeyboardFocus(target: EventTarget | null): boolean;

package/dist/utils/focus.js.map

@@ -1 +1 @@
-{"version":3,"file":"focus.js","names":[],"sources":["../../src/utils/focus.ts"],"sourcesContent":["/**\n * Telling a keyboard focus apart from a pointer one.\n *\n * The distinction is needed because `focus` alone does not carry it: an element focused by a\n * mouse click and one reached with the Tab key are in exactly the same state, and a component\n * reading a bare focus flag treats a passing click as a reader settling in. The browser already\n * makes that judgement for its own focus rings, and `:focus-visible` is where it publishes it —\n * a pointer click on a button does not match it, a Tab does.\n */\n\n// @a11y @fallback\n/**\n * Whether this element is focused in the way a keyboard user focuses things.\n *\n * The `try` is for a selector engine that does not know the pseudo-class, and throws on one it\n * cannot parse rather than answering false. Every caller treats the keyboard as the careful\n * answer — it is the one that keeps a component reachable — so that is what an environment\n * unable to be asked returns.\n *\n * TRAP for the tests — jsdom is NOT that environment. It parses `:focus-visible` happily and\n * answers `false` for everything, a genuinely focused element included, so the `catch` never\n * runs there and every test silently takes the pointer branch. A test that means to exercise\n * the keyboard one has to stub `matches` on the element being asked; what it then locks is\n * that the component ASKS and branches, never what jsdom would have answered.\n */\nexport function isKeyboardFocus(target: EventTarget | null): boolean {\n  if (!(target instanceof Element)) return false\n  try {\n    return target.matches(':focus-visible')\n  } catch {\n    return true\n  }\n}\n"],"mappings":";AAyBA,SAAgB,EAAgB,GAAqC;CACnE,IAAI,EAAE,aAAkB,UAAU,OAAO;CACzC,IAAI;EACF,OAAO,EAAO,QAAQ,gBAAgB;CACxC,QAAQ;EACN,OAAO;CACT;AACF"}
+{"version":3,"file":"focus.js","names":[],"sources":["../../src/utils/focus.ts"],"sourcesContent":["// @a11y @fallback\n/**\n * Whether this element is focused the way a keyboard user focuses things.\n *\n * A `focus` event does not carry the distinction: a mouse click and a Tab leave an element in\n * the same state. The browser already makes the judgement for its own focus rings and\n * publishes it as `:focus-visible`, so that is what gets asked. The `try` covers a selector\n * engine that throws on a pseudo-class it cannot parse; the keyboard is the careful answer\n * there, being the one that keeps a component reachable.\n *\n * TRAP for the tests — jsdom is NOT that environment. It parses `:focus-visible` happily and\n * answers `false` for everything, a genuinely focused element included, so the `catch` never\n * runs and every test silently takes the pointer branch. Stub `matches` on the element being\n * asked; what that locks is that the component ASKS and branches, never jsdom's answer.\n */\nexport function isKeyboardFocus(target: EventTarget | null): boolean {\n  if (!(target instanceof Element)) return false\n  try {\n    return target.matches(':focus-visible')\n  } catch {\n    return true\n  }\n}\n"],"mappings":";AAeA,SAAgB,EAAgB,GAAqC;CACnE,IAAI,EAAE,aAAkB,UAAU,OAAO;CACzC,IAAI;EACF,OAAO,EAAO,QAAQ,gBAAgB;CACxC,QAAQ;EACN,OAAO;CACT;AACF"}

package/dist/utils/hostWarns.d.ts

@@ -0,0 +1,12 @@
+import { InjectionKey } from 'vue';
+/**
+ * Provided by a component that renders another with props it has ALREADY checked and
+ * reported on: VDateInput for VDatePicker's bounds, VTimeInput for VTimePicker's step and
+ * restrictions, both forwarded as they stand. The component inside then keeps those warnings
+ * to itself — the consumer wrote the host, and a second copy of the same sentence under a
+ * name they never typed is noise.
+ *
+ * A module of its own and not a line in `env.ts`: that one is in nearly every closure, where a
+ * key only four components read added bytes to all of them.
+ */
+export declare const hostWarnsKey: InjectionKey<true>;

package/dist/utils/hostWarns.js

@@ -0,0 +1,6 @@
+//#region src/utils/hostWarns.ts
+var e = Symbol("vectisHostWarns");
+//#endregion
+export { e as hostWarnsKey };
+
+//# sourceMappingURL=hostWarns.js.map

package/dist/utils/hostWarns.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"hostWarns.js","names":[],"sources":["../../src/utils/hostWarns.ts"],"sourcesContent":["import type { InjectionKey } from 'vue'\n\n/**\n * Provided by a component that renders another with props it has ALREADY checked and\n * reported on: VDateInput for VDatePicker's bounds, VTimeInput for VTimePicker's step and\n * restrictions, both forwarded as they stand. The component inside then keeps those warnings\n * to itself — the consumer wrote the host, and a second copy of the same sentence under a\n * name they never typed is noise.\n *\n * A module of its own and not a line in `env.ts`: that one is in nearly every closure, where a\n * key only four components read added bytes to all of them.\n */\nexport const hostWarnsKey: InjectionKey<true> = Symbol('vectisHostWarns')\n"],"mappings":";AAYA,IAAa,IAAmC,OAAO,iBAAiB"}

package/dist/utils/ids.d.ts

@@ -0,0 +1,10 @@
+/**
+ * An IDREF list — the value of `aria-describedby` or `aria-labelledby` — assembled from
+ * references that may each be absent. The empty ones are dropped by TRUTHINESS, so an empty
+ * string contributes nothing, and a list left with no reference at all is `undefined`, which
+ * removes the attribute instead of writing an empty one.
+ *
+ * A module of its own rather than a line in `text.ts`: every field loads it, and none of them
+ * should pay for the text helpers to get it.
+ */
+export declare function joinIds(...ids: (string | false | null | undefined)[]): string | undefined;

package/dist/utils/ids.js

@@ -0,0 +1,8 @@
+//#region src/utils/ids.ts
+function e(...e) {
+	return e.filter(Boolean).join(" ") || void 0;
+}
+//#endregion
+export { e as joinIds };
+
+//# sourceMappingURL=ids.js.map

package/dist/utils/ids.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ids.js","names":[],"sources":["../../src/utils/ids.ts"],"sourcesContent":["// @a11y\n/**\n * An IDREF list — the value of `aria-describedby` or `aria-labelledby` — assembled from\n * references that may each be absent. The empty ones are dropped by TRUTHINESS, so an empty\n * string contributes nothing, and a list left with no reference at all is `undefined`, which\n * removes the attribute instead of writing an empty one.\n *\n * A module of its own rather than a line in `text.ts`: every field loads it, and none of them\n * should pay for the text helpers to get it.\n */\nexport function joinIds(...ids: (string | false | null | undefined)[]): string | undefined {\n  return ids.filter(Boolean).join(' ') || undefined\n}\n"],"mappings":";AAUA,SAAgB,EAAQ,GAAG,GAAgE;CACzF,OAAO,EAAI,OAAO,OAAO,CAAC,CAAC,KAAK,GAAG,KAAK,KAAA;AAC1C"}

package/dist/utils/matcher.d.ts

@@ -1,13 +1,9 @@
 /**
- * Turns any of the design system's "which entries are unavailable" props into a
- * single function to ask. Those props — `disabledDates`, `disabledPages` and their
- * kind — accept either a LIST of the values concerned or a FUNCTION deciding for
- * each one, and this is what lets the components stop caring which of the two they
- * were handed.
+ * Turns the design system's "which entries are unavailable" props — `disabledDates`,
+ * `disabledPages` and their kind, each accepting a list OR a predicate — into one
+ * function to ask, so components need not care which they were handed.
  *
- * It is meant to be resolved ONCE, inside a `computed`, and not called afresh for
- * every value: a list is converted into a `Set` here, so each lookup is then
- * immediate, where an `includes` would walk the whole list again for every cell on
- * screen.
+ * Resolve it ONCE inside a `computed`, never per value: the list becomes a `Set` here, so
+ * each lookup is immediate where an `includes` would rescan it for every cell on screen.
  */
 export declare function resolveMatcher<T>(matcher: readonly T[] | ((value: T) => boolean) | undefined): (value: T) => boolean;

package/dist/utils/matcher.js.map

@@ -1 +1 @@
-{"version":3,"file":"matcher.js","names":[],"sources":["../../src/utils/matcher.ts"],"sourcesContent":["// @core\n/**\n * Turns any of the design system's \"which entries are unavailable\" props into a\n * single function to ask. Those props — `disabledDates`, `disabledPages` and their\n * kind — accept either a LIST of the values concerned or a FUNCTION deciding for\n * each one, and this is what lets the components stop caring which of the two they\n * were handed.\n *\n * It is meant to be resolved ONCE, inside a `computed`, and not called afresh for\n * every value: a list is converted into a `Set` here, so each lookup is then\n * immediate, where an `includes` would walk the whole list again for every cell on\n * screen.\n */\nexport function resolveMatcher<T>(\n  matcher: readonly T[] | ((value: T) => boolean) | undefined,\n): (value: T) => boolean {\n  if (!matcher) return () => false\n  if (typeof matcher === 'function') return matcher\n  const set = new Set(matcher)\n  return (value: T) => set.has(value)\n}\n"],"mappings":";AAaA,SAAgB,EACd,GACuB;CACvB,IAAI,CAAC,GAAS,aAAa;CAC3B,IAAI,OAAO,KAAY,YAAY,OAAO;CAC1C,IAAM,IAAM,IAAI,IAAI,CAAO;CAC3B,QAAQ,MAAa,EAAI,IAAI,CAAK;AACpC"}
+{"version":3,"file":"matcher.js","names":[],"sources":["../../src/utils/matcher.ts"],"sourcesContent":["// @core\n/**\n * Turns the design system's \"which entries are unavailable\" props — `disabledDates`,\n * `disabledPages` and their kind, each accepting a list OR a predicate — into one\n * function to ask, so components need not care which they were handed.\n *\n * Resolve it ONCE inside a `computed`, never per value: the list becomes a `Set` here, so\n * each lookup is immediate where an `includes` would rescan it for every cell on screen.\n */\nexport function resolveMatcher<T>(\n  matcher: readonly T[] | ((value: T) => boolean) | undefined,\n): (value: T) => boolean {\n  if (!matcher) return () => false\n  if (typeof matcher === 'function') return matcher\n  const set = new Set(matcher)\n  return (value: T) => set.has(value)\n}\n"],"mappings":";AASA,SAAgB,EACd,GACuB;CACvB,IAAI,CAAC,GAAS,aAAa;CAC3B,IAAI,OAAO,KAAY,YAAY,OAAO;CAC1C,IAAM,IAAM,IAAI,IAAI,CAAO;CAC3B,QAAQ,MAAa,EAAI,IAAI,CAAK;AACpC"}

package/dist/utils/memo.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Reads a module-level cache, building the entry on its first miss.
+ *
+ * The `Intl` helpers in `date.ts`, `time.ts` and `file.ts` all keep one: an `Intl` object
+ * costs one to two orders of magnitude more to build than to use, and those helpers are
+ * called one value at a time. What each cache holds is the helper's own business; the
+ * get-or-build around it is the same everywhere, and written here once.
+ *
+ * `undefined` is the miss marker, so a builder must never return it — none does, every entry
+ * being an object, a string or a number.
+ */
+export declare function memo<K, V>(cache: Map<K, V>, key: K, build: () => V): V;

package/dist/utils/memo.js

@@ -0,0 +1,9 @@
+//#region src/utils/memo.ts
+function e(e, t, n) {
+	let r = e.get(t);
+	return r === void 0 && (r = n(), e.set(t, r)), r;
+}
+//#endregion
+export { e as memo };
+
+//# sourceMappingURL=memo.js.map

package/dist/utils/memo.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"memo.js","names":[],"sources":["../../src/utils/memo.ts"],"sourcesContent":["// @core\n/**\n * Reads a module-level cache, building the entry on its first miss.\n *\n * The `Intl` helpers in `date.ts`, `time.ts` and `file.ts` all keep one: an `Intl` object\n * costs one to two orders of magnitude more to build than to use, and those helpers are\n * called one value at a time. What each cache holds is the helper's own business; the\n * get-or-build around it is the same everywhere, and written here once.\n *\n * `undefined` is the miss marker, so a builder must never return it — none does, every entry\n * being an object, a string or a number.\n */\nexport function memo<K, V>(cache: Map<K, V>, key: K, build: () => V): V {\n  let value = cache.get(key)\n  if (value === undefined) {\n    value = build()\n    cache.set(key, value)\n  }\n  return value\n}\n"],"mappings":";AAYA,SAAgB,EAAW,GAAkB,GAAQ,GAAmB;CACtE,IAAI,IAAQ,EAAM,IAAI,CAAG;CAKzB,OAJI,MAAU,KAAA,MACZ,IAAQ,EAAM,GACd,EAAM,IAAI,GAAK,CAAK,IAEf;AACT"}

package/dist/utils/number.d.ts

@@ -1,9 +1,8 @@
 /**
  * Holds a number between a lower and an upper bound.
  *
- * When the two bounds cross over — which happens as soon as the upper one is worked out
- * from something empty, the last position of a list with nothing in it being one short of
- * the first — the LOWER bound wins. It is the one that is always a position something can
- * sit at.
+ * On an empty interval the LOWER bound wins, which is deliberate: `max` is often derived
+ * from a list, and an empty one puts its last position one short of its first. The lower
+ * bound is the one that is always somewhere a value can sit.
  */
 export declare function clamp(n: number, min: number, max: number): number;

package/dist/utils/number.js.map

@@ -1 +1 @@
-{"version":3,"file":"number.js","names":[],"sources":["../../src/utils/number.ts"],"sourcesContent":["// @core\n/**\n * Holds a number between a lower and an upper bound.\n *\n * When the two bounds cross over — which happens as soon as the upper one is worked out\n * from something empty, the last position of a list with nothing in it being one short of\n * the first — the LOWER bound wins. It is the one that is always a position something can\n * sit at.\n */\nexport function clamp(n: number, min: number, max: number): number {\n  return Math.max(min, Math.min(max, n))\n}\n"],"mappings":";AASA,SAAgB,EAAM,GAAW,GAAa,GAAqB;CACjE,OAAO,KAAK,IAAI,GAAK,KAAK,IAAI,GAAK,CAAC,CAAC;AACvC"}
+{"version":3,"file":"number.js","names":[],"sources":["../../src/utils/number.ts"],"sourcesContent":["// @core\n/**\n * Holds a number between a lower and an upper bound.\n *\n * On an empty interval the LOWER bound wins, which is deliberate: `max` is often derived\n * from a list, and an empty one puts its last position one short of its first. The lower\n * bound is the one that is always somewhere a value can sit.\n */\nexport function clamp(n: number, min: number, max: number): number {\n  return Math.max(min, Math.min(max, n))\n}\n"],"mappings":";AAQA,SAAgB,EAAM,GAAW,GAAa,GAAqB;CACjE,OAAO,KAAK,IAAI,GAAK,KAAK,IAAI,GAAK,CAAC,CAAC;AACvC"}

package/dist/utils/text.d.ts

@@ -1,19 +1,30 @@
 /**
- * The form of a text used for COMPARING it: capitals and accents no longer count.
+ * The form of a text used for COMPARING it: case and accents no longer count.
  *
- * The accents are removed by pulling each letter apart into the plain letter and the mark
- * above it, then dropping the marks. This is used wherever the design system matches a
- * list against what someone has typed — searching for "e" must find "é", since nobody
- * expects to have to reach for the right accent to find a name.
+ * NFD splits each letter into the plain letter and its mark, and the marks are dropped.
+ * Used wherever the library matches a list against what someone typed: searching "e" has
+ * to find "é", nobody reaching for the right accent to find a name.
  */
 export declare function normalizeText(s: string): string;
+/**
+ * A memory of `normalizeText` results, filed under the object a text belongs to — a table row,
+ * a combobox option — and under a field name when one object holds several texts.
+ *
+ * A filter normalizes the whole list again on every keystroke, and normalizing decomposes,
+ * strips and lowercases each string: this is what makes the second keystroke cost a lookup.
+ *
+ * The raw text is passed on EVERY call and compared with the one remembered, rather than the
+ * list being derived once: that is what notices a label edited in place, which a value keyed
+ * on the list alone would not. And the memory is a `WeakMap` keyed by the owner, so replacing
+ * the list lets the old entries be collected with no invalidation written anywhere.
+ */
+export declare function createNormalizedCache<K extends object>(): (owner: K, raw: string, field?: string) => string;
 /** A whole number written on two digits, so that 7 becomes "07" — as dates and times are. */
 export declare function pad2(n: number): string;
 /**
- * Just the digits of a text, everything else thrown away.
+ * Just the digits of a string, everything else dropped.
  *
- * It knows nothing of dates or of times, and that is why it lives among the text helpers
- * rather than with either of them: the fields one types a date or a time into only ever
- * deal in the run of digits, and place the separators between them themselves.
+ * It knows nothing of dates or times, which is why it lives here rather than with either:
+ * the masked fields only ever handle the run of digits and place the separators themselves.
  */
 export declare const digitsOf: (text: string) => string;

package/dist/utils/text.js

@@ -2,11 +2,25 @@
 function e(e) {
 	return e.normalize("NFD").replace(/[\u0300-\u036f]/g, "").toLowerCase();
 }
-function t(e) {
+function t() {
+	let t = /* @__PURE__ */ new WeakMap();
+	return (n, r, i = "") => {
+		let a = t.get(n);
+		a || (a = /* @__PURE__ */ new Map(), t.set(n, a));
+		let o = a.get(i);
+		if (o && o.raw === r) return o.normalized;
+		let s = e(r);
+		return a.set(i, {
+			raw: r,
+			normalized: s
+		}), s;
+	};
+}
+function n(e) {
 	return String(e).padStart(2, "0");
 }
-var n = (e) => e.replace(/\D/g, "");
+var r = (e) => e.replace(/\D/g, "");
 //#endregion
-export { n as digitsOf, e as normalizeText, t as pad2 };
+export { t as createNormalizedCache, r as digitsOf, e as normalizeText, n as pad2 };
 
 //# sourceMappingURL=text.js.map

package/dist/utils/text.js.map

@@ -1 +1 @@
-{"version":3,"file":"text.js","names":[],"sources":["../../src/utils/text.ts"],"sourcesContent":["// @core\n/**\n * The form of a text used for COMPARING it: capitals and accents no longer count.\n *\n * The accents are removed by pulling each letter apart into the plain letter and the mark\n * above it, then dropping the marks. This is used wherever the design system matches a\n * list against what someone has typed — searching for \"e\" must find \"é\", since nobody\n * expects to have to reach for the right accent to find a name.\n */\nexport function normalizeText(s: string): string {\n  return s\n    .normalize('NFD')\n    .replace(/[\\u0300-\\u036f]/g, '')\n    .toLowerCase()\n}\n\n// @core\n/** A whole number written on two digits, so that 7 becomes \"07\" — as dates and times are. */\nexport function pad2(n: number): string {\n  return String(n).padStart(2, '0')\n}\n\n// @core\n/**\n * Just the digits of a text, everything else thrown away.\n *\n * It knows nothing of dates or of times, and that is why it lives among the text helpers\n * rather than with either of them: the fields one types a date or a time into only ever\n * deal in the run of digits, and place the separators between them themselves.\n */\nexport const digitsOf = (text: string): string => text.replace(/\\D/g, '')\n"],"mappings":";AASA,SAAgB,EAAc,GAAmB;CAC/C,OAAO,EACJ,UAAU,KAAK,CAAC,CAChB,QAAQ,oBAAoB,EAAE,CAAC,CAC/B,YAAY;AACjB;AAIA,SAAgB,EAAK,GAAmB;CACtC,OAAO,OAAO,CAAC,CAAC,CAAC,SAAS,GAAG,GAAG;AAClC;AAUA,IAAa,KAAY,MAAyB,EAAK,QAAQ,OAAO,EAAE"}
+{"version":3,"file":"text.js","names":[],"sources":["../../src/utils/text.ts"],"sourcesContent":["// @core\n/**\n * The form of a text used for COMPARING it: case and accents no longer count.\n *\n * NFD splits each letter into the plain letter and its mark, and the marks are dropped.\n * Used wherever the library matches a list against what someone typed: searching \"e\" has\n * to find \"é\", nobody reaching for the right accent to find a name.\n */\nexport function normalizeText(s: string): string {\n  return s\n    .normalize('NFD')\n    .replace(/[\\u0300-\\u036f]/g, '')\n    .toLowerCase()\n}\n\n// @core\n/**\n * A memory of `normalizeText` results, filed under the object a text belongs to — a table row,\n * a combobox option — and under a field name when one object holds several texts.\n *\n * A filter normalizes the whole list again on every keystroke, and normalizing decomposes,\n * strips and lowercases each string: this is what makes the second keystroke cost a lookup.\n *\n * The raw text is passed on EVERY call and compared with the one remembered, rather than the\n * list being derived once: that is what notices a label edited in place, which a value keyed\n * on the list alone would not. And the memory is a `WeakMap` keyed by the owner, so replacing\n * the list lets the old entries be collected with no invalidation written anywhere.\n */\nexport function createNormalizedCache<K extends object>() {\n  const cache = new WeakMap<K, Map<string, { raw: string; normalized: string }>>()\n  return (owner: K, raw: string, field = ''): string => {\n    let texts = cache.get(owner)\n    if (!texts) {\n      texts = new Map()\n      cache.set(owner, texts)\n    }\n    const hit = texts.get(field)\n    if (hit && hit.raw === raw) return hit.normalized\n    const normalized = normalizeText(raw)\n    texts.set(field, { raw, normalized })\n    return normalized\n  }\n}\n\n// @core\n/** A whole number written on two digits, so that 7 becomes \"07\" — as dates and times are. */\nexport function pad2(n: number): string {\n  return String(n).padStart(2, '0')\n}\n\n// @core\n/**\n * Just the digits of a string, everything else dropped.\n *\n * It knows nothing of dates or times, which is why it lives here rather than with either:\n * the masked fields only ever handle the run of digits and place the separators themselves.\n */\nexport const digitsOf = (text: string): string => text.replace(/\\D/g, '')\n"],"mappings":";AAQA,SAAgB,EAAc,GAAmB;CAC/C,OAAO,EACJ,UAAU,KAAK,CAAC,CAChB,QAAQ,oBAAoB,EAAE,CAAC,CAC/B,YAAY;AACjB;AAeA,SAAgB,IAA0C;CACxD,IAAM,oBAAQ,IAAI,QAA6D;CAC/E,QAAQ,GAAU,GAAa,IAAQ,OAAe;EACpD,IAAI,IAAQ,EAAM,IAAI,CAAK;EAC3B,AAAK,MACH,oBAAQ,IAAI,IAAI,GAChB,EAAM,IAAI,GAAO,CAAK;EAExB,IAAM,IAAM,EAAM,IAAI,CAAK;EAC3B,IAAI,KAAO,EAAI,QAAQ,GAAK,OAAO,EAAI;EACvC,IAAM,IAAa,EAAc,CAAG;EAEpC,OADA,EAAM,IAAI,GAAO;GAAE;GAAK;EAAW,CAAC,GAC7B;CACT;AACF;AAIA,SAAgB,EAAK,GAAmB;CACtC,OAAO,OAAO,CAAC,CAAC,CAAC,SAAS,GAAG,GAAG;AAClC;AASA,IAAa,KAAY,MAAyB,EAAK,QAAQ,OAAO,EAAE"}