vectis-ui 0.1.0

package/dist/utils/date.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"date.js","names":[],"sources":["../../src/utils/date.ts"],"sourcesContent":["// @ssr @core — module-wide: every export below is @core unless tagged otherwise.\n/**\n * The date arithmetic behind VDatePicker and VDateInput, written as pure functions:\n * they read nothing outside their arguments and change nothing around them.\n *\n * The whole module speaks one language, the ISO `YYYY-MM-DD` string, and computes\n * everything in the reader's LOCAL time. Two shortcuts are therefore banned\n * throughout: `new Date('YYYY-MM-DD')`, which the language interprets as UTC and\n * which consequently lands on the previous or the next day depending on the time\n * zone, and `toISOString()`, which formats in UTC for the same reason. `Date`\n * objects exist here only as an intermediate step, built with `new Date(y, m, d)` —\n * local midnight — and turned back into text by concatenation.\n *\n * The names of months and days come from `Intl`, which is available on the server as\n * well as in the browser. They are formatted from REFERENCE dates pinned to\n * `timeZone: 'UTC'`, so that the resulting label never depends on the time zone of\n * the machine doing the rendering.\n */\n\nimport { digitsOf, pad2 } from './text'\n\nconst ISO_RE = /^\\d{4}-\\d{2}-\\d{2}$/\n\n/**\n * Tells whether a value is a real `YYYY-MM-DD` date. The shape alone is not enough:\n * `2026-02-31` matches the pattern, so the check goes through a parse and a\n * reformat, and only a value that survives the round trip unchanged is accepted.\n */\nexport function isValidISO(iso: unknown): iso is string {\n  if (typeof iso !== 'string' || !ISO_RE.test(iso)) return false\n  const d = parseISO(iso)\n  return d !== null && formatISO(d) === iso\n}\n\n/**\n * Turns an ISO string into a `Date` set at local midnight, or returns `null` when\n * the string is not one. Every caller here has to handle that `null`: the bounds a\n * consumer passes are raw strings and may be anything.\n */\nexport function parseISO(iso: string | null | undefined): Date | null {\n  if (typeof iso !== 'string' || !ISO_RE.test(iso)) return null\n  const parts = iso.split('-')\n  const date = new Date(Number(parts[0]), Number(parts[1]) - 1, Number(parts[2]))\n  return Number.isNaN(date.getTime()) ? null : date\n}\n\n/**\n * Writes a `Date` as an ISO string, reading its LOCAL components. This manual\n * concatenation is what `toISOString()` cannot do, since that one formats in UTC.\n */\nexport function formatISO(date: Date): string {\n  return `${date.getFullYear()}-${pad2(date.getMonth() + 1)}-${pad2(date.getDate())}`\n}\n\n/**\n * Builds an ISO string from separate values. The month is 0-indexed, as everywhere\n * in the language: 0 is January.\n */\nexport function isoOf(year: number, month0: number, day: number): string {\n  return formatISO(new Date(year, month0, day))\n}\n\n/**\n * Moves a date by a number of days, forwards or backwards. Crossing into another\n * month or year is handled by `Date` itself.\n */\nexport function addDays(iso: string, n: number): string {\n  const d = parseISO(iso)\n  if (!d) return iso\n  d.setDate(d.getDate() + n)\n  return formatISO(d)\n}\n\n/**\n * Moves a date by a number of months, keeping the day of the month where possible.\n * When the target month is too short the day is brought back to its last one: 31\n * January plus one month gives 28 or 29 February, and never spills over into March\n * the way a naive addition would.\n */\nexport function addMonths(iso: string, n: number): string {\n  const d = parseISO(iso)\n  if (!d) return iso\n  const day = d.getDate()\n  d.setDate(1)\n  d.setMonth(d.getMonth() + n)\n  d.setDate(Math.min(day, daysInMonth(d.getFullYear(), d.getMonth())))\n  return formatISO(d)\n}\n\n/**\n * How many days the given month holds, leap years included. Day 0 of the following\n * month is the last day of this one, which is what makes the leap year rule the\n * language's problem rather than ours.\n */\nexport function daysInMonth(year: number, month0: number): number {\n  return new Date(year, month0 + 1, 0).getDate()\n}\n\n/**\n * Compares two dates chronologically, returning the usual -1, 0 or 1. Because the\n * `YYYY-MM-DD` format puts its most significant part first, comparing the strings as\n * text already gives the chronological order: no parsing is needed.\n */\nexport function compareISO(a: string, b: string): number {\n  return a < b ? -1 : a > b ? 1 : 0\n}\n\n/**\n * Whether two dates are the same day, with a null on either side counting as no\n * date at all rather than as a match.\n */\nexport const isSameISO = (a: string | null, b: string | null) => !!a && a === b\n\n/**\n * Brings a date back inside the allowed interval, returning the bound it exceeded.\n * Both bounds are optional, and an absent one means unbounded on that side.\n */\nexport function clampISO(iso: string, min?: string, max?: string): string {\n  if (min && compareISO(iso, min) < 0) return min\n  if (max && compareISO(iso, max) > 0) return max\n  return iso\n}\n\n/** Whether a date falls inside the allowed interval, each bound being optional. */\nexport function isWithin(iso: string, min?: string, max?: string): boolean {\n  if (min && compareISO(iso, min) < 0) return false\n  if (max && compareISO(iso, max) > 0) return false\n  return true\n}\n\n/** One square of a month grid. */\nexport interface MonthCell {\n  /** The day it stands for, as an ISO `YYYY-MM-DD` string. */\n  iso: string\n  /**\n   * Which side of the displayed month this day belongs to when it is not part of it,\n   * and `null` when it is.\n   */\n  adjacent: 'prev' | 'next' | null\n}\n\n/**\n * Builds the grid of a month: 42 cells, six rows of seven, filled out at both ends\n * with the days of the neighbouring months. The count is fixed on purpose, so that\n * the calendar keeps the same height from one month to the next instead of jumping\n * by a row. `firstDayOfWeek` runs from 0 for Sunday to 6 for Saturday.\n */\nexport function buildMonthGrid(year: number, month0: number, firstDayOfWeek: number): MonthCell[] {\n  const first = new Date(year, month0, 1)\n  // How many cells the 1st of the month sits after the start of its row, which is\n  // exactly how many days of the previous month the grid has to open with.\n  const offset = (first.getDay() - firstDayOfWeek + 7) % 7\n  const cells: MonthCell[] = []\n  const start = new Date(year, month0, 1 - offset)\n  for (let i = 0; i < 42; i++) {\n    const d = new Date(start.getFullYear(), start.getMonth(), start.getDate() + i)\n    const adjacent =\n      d.getMonth() === month0 && d.getFullYear() === year\n        ? null\n        : compareISO(formatISO(d), formatISO(first)) < 0\n          ? 'prev'\n          : 'next'\n    cells.push({ iso: formatISO(d), adjacent })\n  }\n  return cells\n}\n\n// @fallback @ssr\n/**\n * The day the week starts on in a given locale, from 0 for Sunday to 6 for Saturday\n * — Sunday in the United States, Monday in most of Europe, Saturday in much of the\n * Middle East. It comes from `Intl.Locale`, whose own numbering runs from 1 for\n * Monday to 7 for Sunday.\n *\n * That part of `Intl` is not everywhere (some Node builds lack it), so the answer\n * falls back to Monday when it is missing. A component can always override the\n * result with its `firstDayOfWeek` prop.\n */\nconst firstDayCache = new Map<string, number>()\n\nexport function firstDayOfWeekFor(locale: string): number {\n  const cached = firstDayCache.get(locale)\n  if (cached !== undefined) return cached\n  const first = resolveFirstDayOfWeek(locale)\n  firstDayCache.set(locale, first)\n  return first\n}\n\nfunction resolveFirstDayOfWeek(locale: string): number {\n  try {\n    // Implementations disagree on the shape: Chrome and Safari expose `weekInfo` as\n    // a getter, others a `getWeekInfo()` method. Both are tried.\n    const loc = new Intl.Locale(locale) as Intl.Locale & {\n      weekInfo?: { firstDay: number }\n      getWeekInfo?: () => { firstDay: number }\n    }\n    const info = loc.getWeekInfo?.() ?? loc.weekInfo\n    if (info?.firstDay) return info.firstDay % 7 // brings Sunday, their 7, back to 0\n  } catch {\n    /* an invalid locale throws a RangeError: fall through to the fallback */\n  }\n  return 1 // Monday\n}\n\n// The reference instants the names are formatted from. Any Sunday will do for the\n// weekdays, and any year for the months; combined with `timeZone: 'UTC'` at every\n// call site, they pin the output whatever zone the machine is in.\nconst REF_SUNDAY = Date.UTC(2021, 7, 1) // 1 August 2021 fell on a Sunday\nconst MS_DAY = 86_400_000\n\n/**\n * The names of the seven days, starting from `firstDayOfWeek` so the list can be\n * dropped straight into a calendar header.\n */\nexport function weekdayNames(\n  locale: string,\n  firstDayOfWeek: number,\n  weekday: 'narrow' | 'short' | 'long' = 'short',\n): string[] {\n  const fmt = new Intl.DateTimeFormat(locale, { weekday, timeZone: 'UTC' })\n  return Array.from({ length: 7 }, (_, i) =>\n    fmt.format(REF_SUNDAY + ((firstDayOfWeek + i) % 7) * MS_DAY),\n  )\n}\n\n/** The names of the twelve months, in January-to-December order. */\nexport function monthNames(locale: string, month: 'long' | 'short' = 'long'): string[] {\n  const fmt = new Intl.DateTimeFormat(locale, { month, timeZone: 'UTC' })\n  return Array.from({ length: 12 }, (_, i) => fmt.format(Date.UTC(2021, i, 1)))\n}\n\n/**\n * Month names shortened for the picker's narrow cells: a name of four characters or\n * fewer is kept whole (\"May\", \"June\", \"July\"), a longer one is cut to three\n * characters followed by a dot (\"January\" becomes \"Jan.\"). The name is spread with\n * `[...n]` rather than indexed, so that an accented or non-Latin character counts as\n * one character and is never cut in half.\n */\nexport function monthNamesCompact(locale: string): string[] {\n  return monthNames(locale, 'long').map((n) => {\n    const chars = [...n]\n    return chars.length <= 4 ? n : chars.slice(0, 3).join('') + '.'\n  })\n}\n\n/**\n * One formatter kept per locale and set of options, for the lifetime of the module —\n * the same `formatterFor` idiom as in `utils/file.ts` and `utils/time.ts`.\n *\n * Building an `Intl.DateTimeFormat` costs one to two orders of magnitude more than\n * using one, and the three functions below are called ONE VALUE AT A TIME: VDateInput\n * formats a multiple selection inside a `.map`, so a fresh formatter would be built\n * for every date. `weekdayNames` and `monthNames` already hoist theirs out of their\n * loop; this cache gives the per-call functions the same property.\n *\n * The options object is part of the cache key. `JSON.stringify` is stable enough\n * here — these objects are literals written by the components, not data coming from\n * a user — and costs a fraction of a construction.\n */\nconst formatters = new Map<string, Intl.DateTimeFormat>()\n\nfunction formatterFor(locale: string, options: Intl.DateTimeFormatOptions): Intl.DateTimeFormat {\n  const key = `${locale}|${JSON.stringify(options)}`\n  let formatter = formatters.get(key)\n  if (!formatter) {\n    formatter = new Intl.DateTimeFormat(locale, options)\n    formatters.set(key, formatter)\n  }\n  return formatter\n}\n\n/** The name of one month, 0 being January. */\nexport function monthName(\n  locale: string,\n  month0: number,\n  month: 'long' | 'short' = 'long',\n): string {\n  return formatterFor(locale, { month, timeZone: 'UTC' }).format(Date.UTC(2021, month0, 1))\n}\n\n/**\n * A date written out for the reader, in the conventions of their locale — this is\n * what VDateInput shows in its field. An unparsable date yields an empty string\n * rather than a broken one.\n */\nexport function formatDisplay(\n  iso: string,\n  locale: string,\n  options: Intl.DateTimeFormatOptions,\n): string {\n  const d = parseISO(iso)\n  return d ? formatterFor(locale, options).format(d) : ''\n}\n\n/**\n * A period written out for the reader. `Intl`'s own `formatRange` is what factors\n * out the parts the two dates share, giving \"19–26 June 2026\" rather than the two\n * full dates side by side. A period of a single day is formatted as that one date.\n */\nexport function formatDisplayRange(\n  start: string,\n  end: string,\n  locale: string,\n  options: Intl.DateTimeFormatOptions,\n): string {\n  const a = parseISO(start)\n  const b = parseISO(end)\n  if (!a || !b) return ''\n  const fmt = formatterFor(locale, options)\n  return compareISO(start, end) === 0 ? fmt.format(a) : fmt.formatRange(a, b)\n}\n\n/*\n * The numeric input mask, used by VDateInput when its field can be typed into.\n *\n * A field being typed into never shows the long display format — \"10 June 2026\" is\n * not something one can type — but a purely numeric mask instead. The order of the\n * three fields and the separator between them are DERIVED from the locale rather\n * than hardcoded, which is what makes the same field work for a reader in Tokyo and\n * one in Chicago.\n */\n\nexport type DateMaskField = 'day' | 'month' | 'year'\n\n/** Everything a locale decides about how a date is typed. */\nexport interface DateMask {\n  /**\n   * The order the three fields appear in: day, month, year in the United Kingdom,\n   * month, day, year in the United States, year, month, day in Japan.\n   */\n  order: readonly DateMaskField[]\n  /** The single character between two fields, stripped of bidi marks and spaces. */\n  separator: string\n  /** How many digits each field takes, in the same order: 4 for the year, 2 otherwise. */\n  lengths: readonly number[]\n  /** How many digits the complete mask holds, which is always 8. */\n  size: number\n}\n\nconst MASK_FALLBACK: DateMask = {\n  order: ['day', 'month', 'year'],\n  separator: '/',\n  lengths: [2, 2, 4],\n  size: 8,\n}\n\n/**\n * The date the mask is read from: 22 November 2021. Its three numbers all differ, so\n * whichever order the locale prints them in, each one can be told apart.\n */\nconst REF_MASK_DATE = Date.UTC(2021, 10, 22)\n\n/** The invisible direction marks some locales insert, such as U+200F before \"/\" in ar-EG. */\nconst BIDI_MARKS = /[‎‏؜]/g\n\n/**\n * Works out how a date is typed in a given locale, by formatting a known date and\n * looking at what came out.\n *\n * The calendar and the numbering system are FORCED to Gregorian and Latin digits.\n * Without that, `fa-IR` answers with a Persian year (1400 rather than 2021) and\n * `ar-EG` with Arabic-Indic digits — two things a numeric field could neither\n * display nor read back. An invalid locale throws, and the answer then falls back to\n * day/month/year separated by \"/\".\n */\nconst maskCache = new Map<string, DateMask>()\n\nexport function dateMaskFor(locale: string): DateMask {\n  const cached = maskCache.get(locale)\n  if (cached) return cached\n  const mask = buildDateMask(locale)\n  maskCache.set(locale, mask)\n  return mask\n}\n\n/*\n * TRAP — the returned `DateMask` is SHARED between every caller for a locale, so it must be\n * treated as read-only. Nothing mutates it today (it is read field by field in\n * `formatDateMask`, `parseDateMask` and `maskPlaceholder`), and it is the same contract the\n * memoized `Intl` formatters in this file already have.\n */\nfunction buildDateMask(locale: string): DateMask {\n  try {\n    const parts = new Intl.DateTimeFormat(locale, {\n      day: '2-digit',\n      month: '2-digit',\n      year: 'numeric',\n      timeZone: 'UTC',\n      calendar: 'gregory',\n      numberingSystem: 'latn',\n    }).formatToParts(REF_MASK_DATE)\n\n    const order = parts\n      .map((p) => p.type)\n      .filter((t): t is DateMaskField => t === 'day' || t === 'month' || t === 'year')\n\n    // The separator is the first literal appearing AFTER the first field, and not\n    // simply the first literal: Hungarian and Korean end the whole format with a dot\n    // (\"2021. 11. 22.\"), which must not be mistaken for it.\n    const firstField = parts.findIndex((p) => p.type !== 'literal')\n    const separator = parts\n      .slice(firstField)\n      .find((p) => p.type === 'literal')\n      ?.value.replace(BIDI_MARKS, '')\n      .trim()\n\n    if (order.length === 3 && separator) {\n      const lengths = order.map((f) => (f === 'year' ? 4 : 2))\n      return { order, separator, lengths, size: 8 }\n    }\n  } catch {\n    /* an invalid locale throws a RangeError: fall through to the fallback */\n  }\n  return MASK_FALLBACK\n}\n\n/**\n * Lays a run of digits out as masked text. The separator appears AS SOON AS the field\n * before it is full — typing \"22\" already gives \"22/\" — so the reader sees their\n * progress without ever having to type a separator themselves.\n *\n * This has a consequence the component must honour: pressing Backspace on such a\n * separator has to delete the DIGIT before it. Deleting the separator alone would\n * see the mask write it straight back, and the key would look dead.\n */\nexport function formatDateMask(digits: string, mask: DateMask): string {\n  const all = digitsOf(digits).slice(0, mask.size)\n  let out = ''\n  let i = 0\n  for (let f = 0; f < mask.lengths.length; f++) {\n    const len = mask.lengths[f] as number\n    const chunk = all.slice(i, i + len)\n    if (!chunk) break\n    out += chunk\n    i += len\n    if (chunk.length < len) break // this field is still being typed: no separator yet\n    if (f < mask.lengths.length - 1) out += mask.separator\n  }\n  return out\n}\n\n/**\n * Writes an ISO date in the mask of the locale, ready to be put in the field: the\n * same day reads \"10/06/2026\" in London and \"06/10/2026\" in Chicago.\n */\nexport function isoToMask(iso: string, mask: DateMask): string {\n  if (!isValidISO(iso)) return ''\n  const [year, month, day] = iso.split('-') as [string, string, string]\n  const by: Record<DateMaskField, string> = { year, month, day }\n  return formatDateMask(mask.order.map((f) => by[f]).join(''), mask)\n}\n\nexport interface ParseMaskOptions {\n  /**\n   * The century a two-digit year is expanded into: with 2000, \"10/06/26\" is read as\n   * 2026. It is only accepted when the year is the LAST field of the mask, since\n   * elsewhere the following separator already tells the two apart.\n   *\n   * Leaving it out refuses any year shorter than four digits, and that is the mode\n   * used while the reader types — so that \"26\", passed through on the way to \"2026\",\n   * is never committed as a year of its own.\n   */\n  yearPivot?: number\n}\n\n/**\n * Reads masked text back into an ISO date, or returns `null` when the text is\n * incomplete, holds too many digits, or names a day that does not exist — 31\n * February passes every length check and is caught by the round trip `isValidISO`\n * performs.\n *\n * Whether the resulting date is allowed is a different question: the `min`/`max`\n * bounds and the disabled dates belong to the component, and this function knows\n * nothing about props.\n */\nexport function parseDateMask(\n  text: string,\n  mask: DateMask,\n  options: ParseMaskOptions = {},\n): string | null {\n  const digits = digitsOf(text)\n  const by: Partial<Record<DateMaskField, string>> = {}\n  let i = 0\n  for (let k = 0; k < mask.order.length; k++) {\n    const field = mask.order[k] as DateMaskField\n    const len = mask.lengths[k] as number\n    const chunk = digits.slice(i, i + len)\n    if (chunk.length === len) i += len\n    else if (\n      field === 'year' &&\n      options.yearPivot !== undefined &&\n      k === mask.order.length - 1 &&\n      chunk.length === 2\n    )\n      i += 2\n    else return null\n    by[field] = chunk\n  }\n  if (i !== digits.length) return null // digits are left over: the entry is too long\n  const year =\n    (by.year as string).length === 2\n      ? String((options.yearPivot as number) + Number(by.year))\n      : (by.year as string)\n  const iso = `${year}-${by.month}-${by.day}`\n  return isValidISO(iso) ? iso : null\n}\n\n/**\n * Where the caret has to go to sit just after the nth digit. Counting digits is the\n * only landmark that survives a reformat: an absolute position jumps by one the\n * moment a separator appears or disappears, so restoring it would leave the caret in\n * the wrong place on exactly the keystrokes that matter.\n *\n * When a separator is passed and it directly follows that position, the caret steps\n * over it: while typing, it must land in the NEXT field rather than in front of a\n * separator that has just been written. On deletion the argument is omitted, so the\n * caret stays before it and the next Backspace reaches the digit.\n */\nexport function caretAfterDigits(text: string, n: number, separator?: string): number {\n  let pos = 0\n  if (n > 0) {\n    pos = text.length\n    let seen = 0\n    for (let i = 0; i < text.length; i++) {\n      const code = text.charCodeAt(i)\n      if (code >= 48 && code <= 57 && ++seen === n) {\n        pos = i + 1\n        break\n      }\n    }\n  }\n  if (separator && text.startsWith(separator, pos)) pos += separator.length\n  return pos\n}\n\nconst PLACEHOLDER_FALLBACK: Record<DateMaskField, string> = { day: 'd', month: 'm', year: 'y' }\n\n/**\n * Ideographic scripts, which are excluded from the placeholder: a repeated \"日\" does\n * not read as a template the way a repeated letter does.\n */\nconst IDEOGRAPHIC = /[\\p{sc=Han}\\p{sc=Hangul}\\p{sc=Hiragana}\\p{sc=Katakana}]/u\n\n// @fallback\n/**\n * The empty template shown in the field: \"dd/mm/yyyy\" in English, \"jj/mm/aaaa\" in\n * French, \"tt.mm.jjjj\" in German, \"дд/мм/гггг\" in Russian.\n *\n * Each letter is the first letter of the field's own name in that language, taken\n * from `Intl.DisplayNames` — which lands on the attested convention of every\n * alphabetic script without a table to maintain. It falls back to the Latin letters\n * when that part of `Intl` is missing, or when the script is ideographic and the\n * repetition would mean nothing.\n */\nexport function maskPlaceholder(locale: string, mask: DateMask): string {\n  const letters = placeholderLetters(locale)\n  return mask.order.map((f, k) => letters[f].repeat(mask.lengths[k] as number)).join(mask.separator)\n}\n\n/**\n * The three letters a locale writes its date fields with, worked out once per locale.\n *\n * It is the LETTERS that are cached and not the finished placeholder, because the result\n * also depends on the mask handed in — caching the string would be wrong the moment a\n * caller passes a mask that is not `dateMaskFor(locale)`. All of the cost is here anyway:\n * `Intl.DisplayNames` is the most expensive constructor in this file by an order of\n * magnitude (measured at ~0.22 ms a call, against ~0.07 for `dateMaskFor`), and the string\n * assembly below it is a handful of `repeat` calls.\n */\nconst placeholderLetterCache = new Map<string, typeof PLACEHOLDER_FALLBACK>()\n\nfunction placeholderLetters(locale: string): typeof PLACEHOLDER_FALLBACK {\n  const cached = placeholderLetterCache.get(locale)\n  if (cached) return cached\n\n  const letters = { ...PLACEHOLDER_FALLBACK }\n  try {\n    const names = new Intl.DisplayNames(locale, { type: 'dateTimeField' })\n    for (const field of ['day', 'month', 'year'] as const) {\n      const first = [...(names.of(field) ?? '')][0]\n      if (first && /\\p{L}/u.test(first) && !IDEOGRAPHIC.test(first))\n        letters[field] = first.toLocaleLowerCase(locale)\n    }\n  } catch {\n    /* Intl.DisplayNames is unavailable here: keep the Latin letters */\n  }\n  placeholderLetterCache.set(locale, letters)\n  return letters\n}\n"],"mappings":"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"}

package/dist/utils/direction.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Whether an element is laid out right to left.
+ *
+ * The design system does almost everything in LOGICAL properties, which mirror themselves
+ * and need no help. This exists for the handful of places that cannot: a key name
+ * (`ArrowRight`), a pointer coordinate and a scroll delta are all PHYSICAL, so the code
+ * reading them has to know which way the inline axis runs before it can decide what
+ * "forward" means.
+ *
+ * It reads the COMPUTED direction rather than the `dir` attribute on purpose: `dir` may sit
+ * on any ancestor, or come from a stylesheet, and only the computed value accounts for both.
+ * That read forces a style recalculation, so callers ask at event time — never in a render
+ * or a loop.
+ *
+ * A null element answers `false`: a component whose ref is not set yet has nothing laid out,
+ * and left to right is the assumption the rest of the code already makes.
+ */
+export declare function isRtl(el: Element | null | undefined): boolean;

package/dist/utils/direction.js

@@ -0,0 +1,8 @@
+//#region src/utils/direction.ts
+function e(e) {
+	return e != null && getComputedStyle(e).direction === "rtl";
+}
+//#endregion
+export { e as isRtl };
+
+//# sourceMappingURL=direction.js.map

package/dist/utils/direction.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"direction.js","names":[],"sources":["../../src/utils/direction.ts"],"sourcesContent":["// @core\n/**\n * Whether an element is laid out right to left.\n *\n * The design system does almost everything in LOGICAL properties, which mirror themselves\n * and need no help. This exists for the handful of places that cannot: a key name\n * (`ArrowRight`), a pointer coordinate and a scroll delta are all PHYSICAL, so the code\n * reading them has to know which way the inline axis runs before it can decide what\n * \"forward\" means.\n *\n * It reads the COMPUTED direction rather than the `dir` attribute on purpose: `dir` may sit\n * on any ancestor, or come from a stylesheet, and only the computed value accounts for both.\n * That read forces a style recalculation, so callers ask at event time — never in a render\n * or a loop.\n *\n * A null element answers `false`: a component whose ref is not set yet has nothing laid out,\n * and left to right is the assumption the rest of the code already makes.\n */\nexport function isRtl(el: Element | null | undefined): boolean {\n  return el != null && getComputedStyle(el).direction === 'rtl'\n}\n"],"mappings":";AAkBA,SAAgB,EAAM,GAAyC;CAC7D,OAAO,KAAM,QAAQ,iBAAiB,CAAE,CAAC,CAAC,cAAc;AAC1D"}

package/dist/utils/env.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Whether the library is running in a development build. It is what the design system's
+ * warnings are gated on — an icon-only button with no name, two options that contradict
+ * each other — so that none of them reaches a finished application.
+ *
+ * The flag comes from the build tool the library is developed with, and it is looked up
+ * cautiously: an application built with a different tool may not provide it at all, and
+ * every warning then simply stays silent rather than failing.
+ */
+export declare const isDev: boolean;

package/dist/utils/file.d.ts

@@ -0,0 +1,95 @@
+/**
+ * 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.
+ *
+ * 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 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.
+ *
+ * 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.
+ */
+export declare function matchesAccept(file: FileCandidate, accept?: string): boolean;
+/**
+ * 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 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.
+ */
+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.
+ */
+export type FileRejectReason = 'type' | 'size' | 'count' | 'total-size';
+export interface FileRejection {
+    file: File;
+    reason: FileRejectReason;
+}
+export interface FileLimits {
+    accept?: string;
+    /** How large ONE file may be, in bytes. */
+    maxSize?: number;
+    /** Already settled by the caller: a field that takes a single file passes one. */
+    maxFiles?: number;
+    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.
+ *
+ * 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.
+ *
+ * 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.
+ */
+export declare function screenFiles(incoming: readonly File[], current: readonly File[], limits: FileLimits): {
+    accepted: File[];
+    rejected: FileRejection[];
+};

package/dist/utils/file.js

@@ -0,0 +1,70 @@
+//#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);
+}
+var t = [
+	"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, {
+		style: "unit",
+		unit: t[i],
+		unitDisplay: "short",
+		maximumFractionDigits: r(i)
+	}), n.set(a, o)), o;
+}
+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 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,
+				reason: "type"
+			});
+			continue;
+		}
+		if (r.maxSize !== void 0 && s.size > r.maxSize) {
+			a.push({
+				file: s,
+				reason: "size"
+			});
+			continue;
+		}
+		if (r.maxFiles !== void 0 && n.length + i.length >= r.maxFiles) {
+			a.push({
+				file: s,
+				reason: "count"
+			});
+			continue;
+		}
+		if (r.maxTotalSize !== void 0 && o + s.size > r.maxTotalSize) {
+			a.push({
+				file: s,
+				reason: "total-size"
+			});
+			continue;
+		}
+		i.push(s), o += s.size;
+	}
+	return {
+		accepted: i,
+		rejected: a
+	};
+}
+//#endregion
+export { a as formatBytes, e as matchesAccept, o as screenFiles };
+
+//# sourceMappingURL=file.js.map

package/dist/utils/file.js.map

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

package/dist/utils/focus.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Telling a keyboard focus apart from a pointer one.
+ *
+ * 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.
+ *
+ * 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.
+ */
+export declare function isKeyboardFocus(target: EventTarget | null): boolean;

package/dist/utils/focus.js

@@ -0,0 +1,13 @@
+//#region src/utils/focus.ts
+function e(e) {
+	if (!(e instanceof Element)) return !1;
+	try {
+		return e.matches(":focus-visible");
+	} catch {
+		return !0;
+	}
+}
+//#endregion
+export { e as isKeyboardFocus };
+
+//# sourceMappingURL=focus.js.map

package/dist/utils/focus.js.map

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

package/dist/utils/matcher.d.ts

@@ -0,0 +1,13 @@
+/**
+ * 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.
+ *
+ * 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.
+ */
+export declare function resolveMatcher<T>(matcher: readonly T[] | ((value: T) => boolean) | undefined): (value: T) => boolean;

package/dist/utils/matcher.js

@@ -0,0 +1,11 @@
+//#region src/utils/matcher.ts
+function e(e) {
+	if (!e) return () => !1;
+	if (typeof e == "function") return e;
+	let t = new Set(e);
+	return (e) => t.has(e);
+}
+//#endregion
+export { e as resolveMatcher };
+
+//# sourceMappingURL=matcher.js.map

package/dist/utils/matcher.js.map

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

package/dist/utils/number.d.ts

@@ -0,0 +1,9 @@
+/**
+ * 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.
+ */
+export declare function clamp(n: number, min: number, max: number): number;

package/dist/utils/number.js

@@ -0,0 +1,8 @@
+//#region src/utils/number.ts
+function e(e, t, n) {
+	return Math.max(t, Math.min(n, e));
+}
+//#endregion
+export { e as clamp };
+
+//# sourceMappingURL=number.js.map

package/dist/utils/number.js.map

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

package/dist/utils/text.d.ts

@@ -0,0 +1,19 @@
+/**
+ * The form of a text used for COMPARING it: capitals 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.
+ */
+export declare function normalizeText(s: 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.
+ *
+ * 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.
+ */
+export declare const digitsOf: (text: string) => string;

package/dist/utils/text.js

@@ -0,0 +1,12 @@
+//#region src/utils/text.ts
+function e(e) {
+	return e.normalize("NFD").replace(/[\u0300-\u036f]/g, "").toLowerCase();
+}
+function t(e) {
+	return String(e).padStart(2, "0");
+}
+var n = (e) => e.replace(/\D/g, "");
+//#endregion
+export { n as digitsOf, e as normalizeText, t as pad2 };
+
+//# sourceMappingURL=text.js.map

package/dist/utils/text.js.map

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

package/dist/utils/time.d.ts

@@ -0,0 +1,138 @@
+export type HourFormat = '12h' | '24h';
+export type Meridiem = 'AM' | 'PM';
+export interface TimeParts {
+    /** The hour on the 24-hour clock, from 0 to 23. */
+    hour: number;
+    minute: number;
+}
+/** Whether something is a time in the canonical form — two digits, a colon, two digits. */
+export declare function isValidTime(value: unknown): value is string;
+/** Reads a canonical time into its two numbers, or nothing at all if it is not one. */
+export declare function parseTime(value: string | null | undefined): TimeParts | null;
+/** Writes an hour and a minute back into the canonical form, both on two digits. */
+export declare function formatTime(hour: number, minute: number): string;
+/**
+ * Turns an hour of the 24-hour clock into the hour a 12-hour clock face shows, together
+ * with which half of the day it belongs to: midnight is 12 AM, noon is 12 PM, and eleven
+ * at night is 11 PM.
+ */
+export declare function to12h(hour24: number): {
+    hour: number;
+    meridiem: Meridiem;
+};
+/**
+ * The way back: an hour read off a 12-hour clock face, plus the half of the day it is in,
+ * gives the hour on the 24-hour clock — 12 in the morning is 0, 12 in the afternoon is 12.
+ */
+export declare function to24h(hour12: number, meridiem: Meridiem): number;
+export declare function hourCycleFor(locale: string): HourFormat;
+/**
+ * A time written out for a reader — "19:05", or "7:05 PM".
+ *
+ * The choice of clock is imposed on the browser rather than left to it, so that the text
+ * follows what the component settled on. A consumer may ask for a 24-hour clock in a
+ * language that would have chosen otherwise, and their choice must be the one that shows.
+ */
+export declare function formatDisplay(time: string, locale: string, format: HourFormat): string;
+/**
+ * Snaps a minute to the nearest one the component allows — every five minutes, say — and
+ * brings it back inside the hour.
+ *
+ * Both ends need that last part: 58 minutes snapped to five-minute steps lands on 60,
+ * which is 0, and stepping back from 0 with the keyboard goes through minus one, which is
+ * 59.
+ */
+export declare function snapMinute(minute: number, step: number): number;
+/**
+ * Where a finger landed on the clock face, given as an offset from the centre, becomes
+ * which mark it was pointing at.
+ *
+ * The marks are numbered from the twelve o'clock position and go round clockwise, and the
+ * nearest one wins. The offsets are the ones the screen uses, where going DOWN is
+ * positive, which is why the vertical one is negated to measure the angle from the top.
+ */
+export declare function angleToIndex(dx: number, dy: number, segments: number): number;
+/** How far from the centre a finger landed, as a fraction: nothing at the centre, one at the edge. */
+export declare function distanceFraction(dx: number, dy: number, radius: number): number;
+/**
+ * How close to the centre a finger has to land for it to be aiming at the INNER ring of
+ * numbers, the one holding the small hours of a 24-hour clock. It is the halfway mark
+ * between the two rings of numerals.
+ *
+ * TRAP — the number is DERIVED from the dial's size and the size of a numeral, both of
+ * which are decided in the stylesheet: a dial of 256px across and numerals of 48px put
+ * the two rings' centres at 104px and 56px from the middle, whose halfway point is
+ * 0.625 of the radius. Changing either size in the CSS without changing this leaves the
+ * threshold between two rings it no longer separates, and a tap near the boundary quietly
+ * sets the wrong hour.
+ */
+export declare const DIAL_INNER_THRESHOLD = 0.625;
+/**
+ * Which hour a mark stands for, on a dial laid out as two rings: the outer one carries 12
+ * then 1 to 11, the inner one carries midnight then 13 to 23. The first mark of each is
+ * the one at the twelve o'clock position.
+ */
+export declare function dialIndexToHour24(index: number, ring: 'outer' | 'inner'): number;
+/**
+ * The way back, which is what tells the hand where to point: midnight is the top of the
+ * inner ring, noon the top of the outer one, and three in the afternoon the third mark of
+ * the inner ring.
+ */
+export declare function hour24ToDial(hour: number): {
+    index: number;
+    ring: 'outer' | 'inner';
+};
+export interface TimeOption {
+    /** The canonical time, which is what the component's value will be set to. */
+    value: string;
+    /** The same time written out for the reader: "07:30", or "7:30 AM". */
+    label: string;
+}
+/**
+ * A time as a count of minutes since midnight, or nothing if it is not a time. It is what
+ * gives a time its position in a list.
+ */
+export declare function minutesOf(time: string | null | undefined): number | null;
+/**
+ * Every time of the day at a given interval, from midnight up to the last one before the
+ * next.
+ *
+ * There is deliberately no earliest or latest here, because the time picker itself has
+ * none: do not invent one.
+ *
+ * An interval that makes no sense — nothing, a fraction, more than an hour — falls back
+ * to one an hour. The list has to stay FINITE even when the warning the component prints
+ * about it was ignored, since an interval of zero would build times for ever.
+ */
+export declare function timeList(step: number, locale: string, format: HourFormat): TimeOption[];
+/**
+ * Lays a run of typed digits out as a time. The colon appears AS SOON AS the hour is
+ * complete — typing "09" already gives "09:" — exactly as a date's separators do.
+ */
+export declare function formatTimeMask(digits: string): string;
+/**
+ * Where the caret belongs so as to sit just after a given number of digits.
+ *
+ * It is a plain formula rather than a scan of the text, because a time's separator is
+ * always in the same place — which is exactly what the date's equivalent cannot assume,
+ * since the order and the width of its parts change from one language to the next.
+ *
+ * The flag says something was INSERTED, and the caret then steps over the colon into the
+ * minutes. On a deletion it stays in FRONT of it, or the next press of the key would step
+ * over the colon instead of erasing a digit, and the key would appear to do nothing.
+ */
+export declare function timeCaret(n: number, skipSeparator?: boolean): number;
+/**
+ * Writes a canonical time into the field, in whichever form is being SHOWN. On a 12-hour
+ * clock the hour is brought back into the range 1 to 12: which half of the day it is
+ * belongs to the pair of buttons beside the field, and never to the text itself.
+ */
+export declare function timeToMask(time: string | null | undefined, format: HourFormat): string;
+/**
+ * Reads what has been typed back into a canonical time, or nothing at all when it is
+ * incomplete, too long, or not a time anyone could point to.
+ *
+ * On a 12-hour clock the half of the day comes from the pair of buttons beside the field.
+ * This is the ONE place where what was typed and that choice meet.
+ */
+export declare function parseTimeMask(text: string, format: HourFormat, meridiem?: Meridiem): string | null;