@leavepulse/ui 0.43.4 → 0.45.0

package/dist/components/fileTree.js

@@ -75,7 +75,7 @@ function formatSize(bytes) {
   const units = ["KB", "MB", "GB", "TB", "PB"];
   let value = bytes / 1024;
   let i = 0;
-  while (value >= 1024 && i < units.length - 1) {
+  while (Math.round(value) >= 1024 && i < units.length - 1) {
     value /= 1024;
     i++;
   }
@@ -118,14 +118,18 @@ function checkStateOf(node, checked) {
   }
   let all = true;
   let any = false;
+  let considered = 0;
   for (const child of node.children) {
     const state = checkStateOf(child, checked);
+    if (child.disabled && state === "unchecked") continue;
+    considered++;
     if (state === "checked") any = true;
     else if (state === "indeterminate") {
       any = true;
       all = false;
     } else all = false;
   }
+  if (!considered) return checked.has(node.id) ? "checked" : "unchecked";
   if (all) return "checked";
   return any ? "indeterminate" : "unchecked";
 }
@@ -165,13 +169,17 @@ function computeStats(nodes, checked) {
     let total = 0;
     let bytes = 0;
     let sized = node.size !== void 0;
+    let considered = 0;
     for (const child of node.children) {
       const childStats = visit(child);
-      if (childStats.state === "checked") any = true;
-      else if (childStats.state === "indeterminate") {
-        any = true;
-        all = false;
-      } else all = false;
+      if (!child.disabled || childStats.state !== "unchecked") {
+        considered++;
+        if (childStats.state === "checked") any = true;
+        else if (childStats.state === "indeterminate") {
+          any = true;
+          all = false;
+        } else all = false;
+      }
       count += childStats.checked;
       total += childStats.total;
       if (childStats.size !== void 0) {
@@ -179,8 +187,9 @@ function computeStats(nodes, checked) {
         sized = true;
       }
     }
+    const own = checked.has(node.id) ? "checked" : "unchecked";
     const self = {
-      state: all ? "checked" : any ? "indeterminate" : "unchecked",
+      state: !considered ? own : all ? "checked" : any ? "indeterminate" : "unchecked",
       checked: count,
       total,
       // An explicit size on the directory wins: a server-side listing usually

package/dist/components/imageCrop.d.ts

@@ -0,0 +1,42 @@
+export interface Point {
+    x: number;
+    y: number;
+}
+export interface CropInput {
+    sourceWidth: number;
+    sourceHeight: number;
+    frameWidth: number;
+    frameHeight: number;
+    /** Accumulated rotation in degrees; any angle, not only quarter turns. */
+    rotation: number;
+    /** Zoom factor, 1 = the picture just covers the frame. */
+    scale: number;
+    /** Pan in frame pixels before the zoom, as useZoomPan reports it. */
+    offset: Point;
+}
+export interface CropGeometry {
+    /** CSS pixels per source pixel at zoom 1. */
+    cover: number;
+    /** Crop size in upright (source-pixel) units. */
+    width: number;
+    height: number;
+    /** Crop centre in upright space. */
+    centre: Point;
+}
+/** Rotate a point clockwise by `deg` in a y-down space. */
+export declare function rotatePoint(p: Point, deg: number): Point;
+/** The source pixel (from the source's top-left) under an upright-space point. */
+export declare function uprightToSource(u: Point, rotation: number, sourceWidth: number, sourceHeight: number): Point;
+/**
+ * Smallest scale at which the turned picture still covers the whole frame.
+ *
+ * Covering the bounding box of a turned picture is not enough at a free angle:
+ * its corners are empty. The frame, turned back by the same angle, has to fit
+ * inside the unturned picture; for a quarter turn this reduces to the usual
+ * object-cover of the swapped dimensions.
+ */
+export declare function coverScale(sourceWidth: number, sourceHeight: number, frameWidth: number, frameHeight: number, rotation: number): number;
+/** What the frame holds, in upright space. */
+export declare function cropGeometry(input: CropInput): CropGeometry;
+/** Whether the turn is closer to sideways than to upright. */
+export declare function isSideways(rotation: number): boolean;

package/dist/components/imageCrop.js

@@ -0,0 +1,47 @@
+const radians = (deg) => deg * Math.PI / 180;
+function rotatePoint(p, deg) {
+  const a = radians(deg);
+  const cos = Math.cos(a);
+  const sin = Math.sin(a);
+  return { x: p.x * cos - p.y * sin, y: p.x * sin + p.y * cos };
+}
+function uprightToSource(u, rotation, sourceWidth, sourceHeight) {
+  const q = rotatePoint(u, -rotation);
+  return { x: q.x + sourceWidth / 2, y: q.y + sourceHeight / 2 };
+}
+function coverScale(sourceWidth, sourceHeight, frameWidth, frameHeight, rotation) {
+  const a = radians(rotation);
+  const cos = Math.abs(Math.cos(a));
+  const sin = Math.abs(Math.sin(a));
+  return Math.max(
+    (frameWidth * cos + frameHeight * sin) / sourceWidth,
+    (frameWidth * sin + frameHeight * cos) / sourceHeight
+  );
+}
+function cropGeometry(input) {
+  const cover = coverScale(
+    input.sourceWidth,
+    input.sourceHeight,
+    input.frameWidth,
+    input.frameHeight,
+    input.rotation
+  );
+  const shown = cover * input.scale;
+  return {
+    cover,
+    width: input.frameWidth / shown,
+    height: input.frameHeight / shown,
+    centre: { x: -input.offset.x / cover, y: -input.offset.y / cover }
+  };
+}
+function isSideways(rotation) {
+  const quarters = Math.round(rotation / 90);
+  return (quarters % 2 + 2) % 2 === 1;
+}
+export {
+  coverScale,
+  cropGeometry,
+  isSideways,
+  rotatePoint,
+  uprightToSource
+};

package/dist/components/link.d.ts

@@ -0,0 +1,12 @@
+import type { Component } from "vue";
+export type LinkTarget = string | Record<string, unknown>;
+export interface ResolvedLink {
+    is: Component | string;
+    props: Record<string, unknown>;
+}
+/** An app-relative path: "/x", not "//host" or "https://…". */
+export declare function isInternalHref(href: string): boolean;
+export declare function resolveLink(linkComponent: Component | string, target: {
+    to?: LinkTarget;
+    href?: string;
+}): ResolvedLink | null;

package/dist/components/link.js

@@ -0,0 +1,19 @@
+function isInternalHref(href) {
+  return href.startsWith("/") && !href.startsWith("//");
+}
+function resolveLink(linkComponent, target) {
+  const router = linkComponent !== "a";
+  if (target.to != null) {
+    if (router) return { is: linkComponent, props: { to: target.to } };
+    return typeof target.to === "string" ? { is: "a", props: { href: target.to } } : null;
+  }
+  if (target.href != null) {
+    if (router && isInternalHref(target.href)) return { is: linkComponent, props: { to: target.href } };
+    return { is: "a", props: { href: target.href } };
+  }
+  return null;
+}
+export {
+  isInternalHref,
+  resolveLink
+};

package/dist/components/logSearch.d.ts

@@ -0,0 +1,18 @@
+/** The last `max` lines, and how many were cut from the front. */
+export declare function ringWindow<T>(lines: readonly T[], max: number | undefined): {
+    lines: readonly T[];
+    offset: number;
+};
+/** Lines per level, a line with no level counting as `fallback`. */
+export declare function countLevels<L extends string>(lines: readonly {
+    level?: L;
+}[], fallback: L): Map<L, number>;
+/** Case-insensitive substring test; an empty term matches nothing. */
+export declare function matchesTerm(message: string, term: string): boolean;
+/** Positions (into `rows`) of the rows whose message or source holds the term. */
+export declare function matchPositions(rows: readonly {
+    message: string;
+    source?: string;
+}[], term: string): number[];
+/** The next match cursor, wrapping at both ends; -1 when there are none. */
+export declare function stepMatch(current: number, total: number, direction: 1 | -1): number;

package/dist/components/logSearch.js

@@ -0,0 +1,36 @@
+function ringWindow(lines, max) {
+  if (!max || max <= 0 || lines.length <= max) return { lines, offset: 0 };
+  return { lines: lines.slice(lines.length - max), offset: lines.length - max };
+}
+function countLevels(lines, fallback) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const line of lines) {
+    const level = line.level ?? fallback;
+    counts.set(level, (counts.get(level) ?? 0) + 1);
+  }
+  return counts;
+}
+function matchesTerm(message, term) {
+  const needle = term.trim().toLowerCase();
+  return needle.length > 0 && message.toLowerCase().includes(needle);
+}
+function matchPositions(rows, term) {
+  if (!term.trim()) return [];
+  const out = [];
+  rows.forEach((row, i) => {
+    if (matchesTerm(row.message, term) || row.source !== void 0 && matchesTerm(row.source, term)) out.push(i);
+  });
+  return out;
+}
+function stepMatch(current, total, direction) {
+  if (total <= 0) return -1;
+  if (current < 0 || current >= total) return direction === 1 ? 0 : total - 1;
+  return (current + direction + total) % total;
+}
+export {
+  countLevels,
+  matchPositions,
+  matchesTerm,
+  ringWindow,
+  stepMatch
+};

package/dist/components/modalDepth.d.ts

@@ -1,11 +1,27 @@
 import { type ComputedRef } from "vue";
-export declare function useModalLayer(): {
+export interface ModalLayer {
+    /** Join the stack on top. Ignored on the server, where nothing would ever release it. */
     claim: () => void;
     release: () => void;
+    /** z-index values for this surface's scrim and panel, and whether another modal is under it. */
     layer: ComputedRef<{
         scrim: string;
         panel: string;
         nested: boolean;
     }>;
-};
+    /** Whether this surface is the topmost open one. */
+    top: ComputedRef<boolean>;
+}
+export interface ModalLayerOptions {
+    /** The surface's panel, so keyboard handling can tell what sits inside the top modal. */
+    element?: () => HTMLElement | null | undefined;
+}
+/**
+ * Put an overlay on the shared modal stack, so a surface opened from another
+ * one (a dialog from a drawer, a lightbox from a dialog) lands above it with
+ * its scrim, whatever component either of them is.
+ */
+export declare function useModalLayer(options?: ModalLayerOptions): ModalLayer;
 export declare function anyModalOpen(): boolean;
+/** The panel of the topmost modal, when it registered one. */
+export declare function topModalElement(): HTMLElement | null;

package/dist/components/modalDepth.js

@@ -1,18 +1,23 @@
 import { ref, computed } from "vue";
 const STEP = 20;
-const stack = ref([]);
-let nextId = 0;
-function useModalLayer() {
-  const id = nextId++;
+const STATE_KEY = /* @__PURE__ */ Symbol.for("@leavepulse/ui:modal-stack");
+const g = globalThis;
+const state = g[STATE_KEY] ??= { stack: ref([]), nextId: 0, elements: /* @__PURE__ */ new Map() };
+const stack = state.stack;
+function useModalLayer(options = {}) {
+  const id = state.nextId++;
   const fromTop = computed(() => {
     const at = stack.value.indexOf(id);
     return at === -1 ? 0 : stack.value.length - 1 - at;
   });
   return {
     claim: () => {
+      if (typeof window === "undefined") return;
+      if (options.element) state.elements.set(id, options.element);
       if (!stack.value.includes(id)) stack.value = [...stack.value, id];
     },
     release: () => {
+      state.elements.delete(id);
       stack.value = stack.value.filter((x) => x !== id);
     },
     layer: computed(() => {
@@ -22,13 +27,20 @@ function useModalLayer() {
         panel: `calc(var(--z-modal) - ${drop})`,
         nested: stack.value.indexOf(id) > 0
       };
-    })
+    }),
+    top: computed(() => stack.value[stack.value.length - 1] === id)
   };
 }
 function anyModalOpen() {
   return stack.value.length > 0;
 }
+function topModalElement() {
+  const id = stack.value[stack.value.length - 1];
+  if (id === void 0) return null;
+  return state.elements.get(id)?.() ?? null;
+}
 export {
   anyModalOpen,
+  topModalElement,
   useModalLayer
 };

package/dist/components/otp.d.ts

@@ -0,0 +1,5 @@
+export type OtpCells = (string | number | undefined)[];
+/** The code typed so far: the filled cells in order. */
+export declare function joinCells(cells: OtpCells): string;
+/** Cells for a code given from outside, one character each. */
+export declare function splitCode(code: string | undefined, length: number): string[];

package/dist/components/otp.js

@@ -0,0 +1,10 @@
+function joinCells(cells) {
+  return Array.from(cells, (c) => c === void 0 ? "" : String(c)).join("");
+}
+function splitCode(code, length) {
+  return (code ?? "").split("").slice(0, length);
+}
+export {
+  joinCells,
+  splitCode
+};

package/dist/components/phone.d.ts

@@ -0,0 +1,41 @@
+import type { CountryCode } from "libphonenumber-js/min";
+export type PhoneLib = typeof import("libphonenumber-js/min");
+type Examples = typeof import("libphonenumber-js/examples.mobile.json")["default"];
+export declare function loadPhoneLib(): Promise<PhoneLib>;
+export declare function loadPhoneExamples(): Promise<Examples>;
+/** E.164 allows at most 15 digits, country code included. */
+export declare const E164_MAX_DIGITS = 15;
+export declare function digitsOf(text: string): string;
+/** How many digits sit before `caret` in `text`. */
+export declare function digitsBefore(text: string, caret: number): number;
+/**
+ * The caret position in `formatted` that has `count` digits before it, placed
+ * right after the last of them so typing continues from there. Zero digits
+ * puts it after a leading "+".
+ */
+export declare function caretAfterDigits(formatted: string, count: number): number;
+export type PhoneProblem = "too-short" | "too-long" | "invalid" | "invalid-country";
+export interface FormattedPhone {
+    /** What the field shows: "+380 50 123 4567". */
+    display: string;
+    /** Normalised "+380501234567", or "" when there are no digits. */
+    e164: string;
+    /** Digits that were typed past the longest number the country allows. */
+    dropped: number;
+    /** The calling code the number starts with ("380"), once recognised. */
+    callingCode?: string;
+    /** Country libphonenumber recognised from the number, when it did. */
+    country?: CountryCode;
+    possible: boolean;
+    valid: boolean;
+    type?: string;
+    problem?: PhoneProblem;
+}
+/**
+ * Format what was typed, dropping digits beyond what the number may hold:
+ * the country's own maximum once libphonenumber knows the country, the E.164
+ * cap otherwise. The value always starts with "+", since the field holds a
+ * full international number.
+ */
+export declare function formatPhone(input: string, phone: PhoneLib | undefined): FormattedPhone;
+export {};

package/dist/components/phone.js

@@ -0,0 +1,80 @@
+let lib;
+let examples;
+function loadPhoneLib() {
+  lib ??= import("libphonenumber-js/min");
+  return lib;
+}
+function loadPhoneExamples() {
+  examples ??= import("libphonenumber-js/examples.mobile.json").then((m) => m.default);
+  return examples;
+}
+const E164_MAX_DIGITS = 15;
+function digitsOf(text) {
+  return text.replace(/\D/g, "");
+}
+function digitsBefore(text, caret) {
+  return digitsOf(text.slice(0, caret)).length;
+}
+function caretAfterDigits(formatted, count) {
+  if (count <= 0) return formatted.startsWith("+") ? 1 : 0;
+  let seen = 0;
+  for (let i = 0; i < formatted.length; i++) {
+    if (/\d/.test(formatted[i])) {
+      seen++;
+      if (seen === count) return i + 1;
+    }
+  }
+  return formatted.length;
+}
+function formatPhone(input, phone) {
+  let digits = digitsOf(input);
+  let dropped = 0;
+  if (digits.length > E164_MAX_DIGITS) {
+    dropped += digits.length - E164_MAX_DIGITS;
+    digits = digits.slice(0, E164_MAX_DIGITS);
+  }
+  if (!digits) return { display: input.trim().startsWith("+") ? "+" : "", e164: "", dropped, possible: false, valid: false };
+  if (!phone) return { display: `+${digits}`, e164: `+${digits}`, dropped, possible: false, valid: false };
+  while (digits.length > 1 && phone.validatePhoneNumberLength(`+${digits}`) === "TOO_LONG") {
+    digits = digits.slice(0, -1);
+    dropped++;
+  }
+  const isValid = (d) => phone.parsePhoneNumberFromString(`+${d}`)?.isValid() ?? false;
+  while (digits.length > 1 && !isValid(digits) && isValid(digits.slice(0, -1))) {
+    digits = digits.slice(0, -1);
+    dropped++;
+  }
+  const typer = new phone.AsYouType();
+  let display = typer.input(`+${digits}`);
+  const code = typer.getCallingCode();
+  if (code && !/\s/.test(display.slice(code.length + 2))) {
+    const national = digits.slice(code.length);
+    display = `+${code}${national ? " " + (national.match(/.{1,3}/g) ?? []).join(" ") : ""}`;
+  }
+  const parsed = phone.parsePhoneNumberFromString(`+${digits}`);
+  const country = typer.getCountry() ?? parsed?.country;
+  const possible = parsed?.isPossible() ?? false;
+  const valid = parsed?.isValid() ?? false;
+  const length = phone.validatePhoneNumberLength(`+${digits}`);
+  const problem = valid ? void 0 : length === "TOO_SHORT" || length === "NOT_A_NUMBER" ? "too-short" : length === "INVALID_COUNTRY" ? "invalid-country" : length === "TOO_LONG" ? "too-long" : "invalid";
+  return {
+    display,
+    e164: `+${digits}`,
+    dropped,
+    callingCode: code,
+    country,
+    possible,
+    valid,
+    type: valid ? parsed?.getType() : void 0,
+    problem
+  };
+}
+export {
+  E164_MAX_DIGITS,
+  caretAfterDigits,
+  digitsBefore,
+  digitsOf,
+  formatPhone,
+  loadPhoneExamples,
+  loadPhoneLib
+};

package/dist/components/sidebar.d.ts

@@ -3,8 +3,14 @@ export interface SidebarItem {
     id: string;
     label: string;
     icon?: string;
-    /** Render as a link instead of a button. */
+    /**
+     * Render as a link instead of a button. An app-relative path goes through
+     * the link component from provideLpConfig (NuxtLink under the Nuxt module),
+     * so it navigates client-side; other URLs render a plain anchor.
+     */
     href?: string;
+    /** Router destination (rendered through the configured link component). */
+    to?: string | Record<string, unknown>;
     /** Count chip on the right (number or short string). */
     badge?: number | string;
     disabled?: boolean;

package/dist/components/tableFilter.d.ts

@@ -0,0 +1,36 @@
+/** Hide everything except `keep`: "show only this" in one step. */
+export declare function onlyValues(values: readonly unknown[], keep: readonly unknown[]): Set<unknown>;
+/** Hide every value: the "None" step before ticking the few that matter. */
+export declare function hideAllValues(values: readonly unknown[]): Set<unknown>;
+/** Swap shown and hidden among the values the column holds. */
+export declare function invertHidden(values: readonly unknown[], hidden: ReadonlySet<unknown>): Set<unknown>;
+/** Show these values again, leaving the rest of the filter as it was. */
+export declare function unhideValues(hidden: ReadonlySet<unknown>, values: readonly unknown[]): Set<unknown>;
+/** Lower-cased and stripped of accents, so "cafe" finds "Café". */
+export declare function foldText(text: string): string;
+/** Every word of the query appears somewhere in the label, in any order. */
+export declare function matchesQuery(label: string, query: string): boolean;
+/** How many rows hold each value of a column. */
+export declare function countValues<Row extends Record<string, unknown>>(rows: readonly Row[], key: string): Map<unknown, number>;
+/**
+ * A chip's text for one column's filter: the values still shown, the first
+ * `listed` by name and the rest as "+N", which says more than "3 of 12".
+ */
+export declare function summarizeShown(shownLabels: readonly string[], listed?: number): string;
+export interface PersistedTableState {
+    sort?: {
+        key: string;
+        dir: "asc" | "desc";
+    } | null;
+    hidden?: Record<string, unknown[]>;
+    columns?: string[];
+}
+/**
+ * The state worth keeping across visits, as JSON. Only plain values survive:
+ * a Date or an object hidden in a filter cannot come back as the same value
+ * (the filter compares by identity), so it is left out rather than restored
+ * as something that matches nothing.
+ */
+export declare function serializeTableState(state: PersistedTableState): string;
+/** Read it back, dropping anything about columns the table no longer has. */
+export declare function parseTableState(raw: string | null, columnKeys: readonly string[]): PersistedTableState | null;

package/dist/components/tableFilter.js

@@ -0,0 +1,84 @@
+function onlyValues(values, keep) {
+  const kept = new Set(keep);
+  return new Set(values.filter((v) => !kept.has(v)));
+}
+function hideAllValues(values) {
+  return new Set(values);
+}
+function invertHidden(values, hidden) {
+  return new Set(values.filter((v) => !hidden.has(v)));
+}
+function unhideValues(hidden, values) {
+  const next = new Set(hidden);
+  for (const v of values) next.delete(v);
+  return next;
+}
+function foldText(text) {
+  return text.normalize("NFKD").replace(new RegExp("\\p{M}", "gu"), "").toLocaleLowerCase();
+}
+function matchesQuery(label, query) {
+  const words = foldText(query).split(/\s+/).filter(Boolean);
+  if (!words.length) return true;
+  const hay = foldText(label);
+  return words.every((w) => hay.includes(w));
+}
+function countValues(rows, key) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const row of rows) counts.set(row[key], (counts.get(row[key]) ?? 0) + 1);
+  return counts;
+}
+function summarizeShown(shownLabels, listed = 2) {
+  if (shownLabels.length <= listed) return shownLabels.join(", ");
+  return `${shownLabels.slice(0, listed).join(", ")} +${shownLabels.length - listed}`;
+}
+function isPlain(value) {
+  return value === null || ["string", "number", "boolean"].includes(typeof value);
+}
+function serializeTableState(state) {
+  const hidden = {};
+  for (const [key, values] of Object.entries(state.hidden ?? {})) {
+    const plain = values.filter(isPlain);
+    if (plain.length) hidden[key] = plain;
+  }
+  return JSON.stringify({ sort: state.sort ?? null, hidden, columns: state.columns ?? [] });
+}
+function parseTableState(raw, columnKeys) {
+  if (!raw) return null;
+  let data;
+  try {
+    data = JSON.parse(raw);
+  } catch {
+    return null;
+  }
+  if (!data || typeof data !== "object") return null;
+  const known = new Set(columnKeys);
+  const record = data;
+  const out = {};
+  const sort = record.sort;
+  if (sort === null) out.sort = null;
+  else if (sort && typeof sort.key === "string" && known.has(sort.key) && (sort.dir === "asc" || sort.dir === "desc")) {
+    out.sort = { key: sort.key, dir: sort.dir };
+  }
+  if (record.hidden && typeof record.hidden === "object") {
+    out.hidden = {};
+    for (const [key, values] of Object.entries(record.hidden)) {
+      if (known.has(key) && Array.isArray(values)) out.hidden[key] = values.filter(isPlain);
+    }
+  }
+  if (Array.isArray(record.columns)) {
+    out.columns = record.columns.filter((c) => typeof c === "string" && known.has(c));
+  }
+  return out;
+}
+export {
+  countValues,
+  foldText,
+  hideAllValues,
+  invertHidden,
+  matchesQuery,
+  onlyValues,
+  parseTableState,
+  serializeTableState,
+  summarizeShown,
+  unhideValues
+};

package/dist/components/tableSort.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Ascending order for raw cell values. Empty values (null, undefined, NaN, an
+ * invalid Date) come first; numbers, bigints and Dates compare by magnitude,
+ * booleans false before true, everything else as text with numeric runs read as
+ * numbers ("file 2" before "file 10"). Mixed kinds group by kind so the order
+ * is total and a sort is stable from one run to the next.
+ */
+export declare function compareValues(a: unknown, b: unknown): number;

package/dist/components/tableSort.js

@@ -0,0 +1,31 @@
+const COLLATOR = new Intl.Collator(void 0, { numeric: true });
+const rank = (v) => {
+  if (v == null || typeof v === "number" && Number.isNaN(v)) return 0;
+  if (typeof v === "boolean") return 1;
+  if (typeof v === "number" || typeof v === "bigint") return 2;
+  if (v instanceof Date) return Number.isNaN(v.getTime()) ? 0 : 3;
+  return 4;
+};
+function compareValues(a, b) {
+  const ra = rank(a);
+  const rb = rank(b);
+  if (ra !== rb) return ra - rb;
+  switch (ra) {
+    case 0:
+      return 0;
+    case 1:
+      return Number(a) - Number(b);
+    case 2: {
+      const x = a;
+      const y = b;
+      return x < y ? -1 : x > y ? 1 : 0;
+    }
+    case 3:
+      return a.getTime() - b.getTime();
+    default:
+      return COLLATOR.compare(String(a), String(b));
+  }
+}
+export {
+  compareValues
+};

package/dist/components/tags.d.ts

@@ -0,0 +1,20 @@
+export type TagDuplicates = "reject" | "ignore" | "allow";
+/** An error message for an invalid tag; anything else accepts it. */
+export type TagValidator = (tag: string, tags: readonly string[]) => string | null | undefined | void;
+export type TagRejection = {
+    value: string;
+    reason: "max" | "duplicate" | "invalid";
+    message?: string;
+};
+export interface AddTagsOptions {
+    max?: number;
+    duplicates?: TagDuplicates;
+    validate?: TagValidator;
+    normalize?: (tag: string) => string;
+}
+export declare function splitTags(text: string, delimiter: string | RegExp | readonly string[]): string[];
+export declare function addTags(current: readonly string[], candidates: readonly string[], options?: AddTagsOptions): {
+    tags: string[];
+    rejected: TagRejection[];
+    ignored: string[];
+};