@leavepulse/ui 0.43.4 → 0.44.0

package/dist/components/codeHighlight.js

@@ -173,23 +173,58 @@ const BOOLEANS = /* @__PURE__ */ new Set([
   "Err"
   // rust common variants read as constants
 ]);
-const MASTER = new RegExp(
-  [
-    "(\\/\\/[^\\n]*|#[^\\n]*|\\/\\*[\\s\\S]*?\\*\\/)",
-    // 1 comment
-    "(\"(?:\\\\.|[^\"\\\\])*\"|'(?:\\\\.|[^'\\\\])*'|`(?:\\\\.|[^`\\\\])*`)",
-    // 2 string
-    "(@[A-Za-z_$][\\w$]*)",
-    // 3 annotation (@Override, @ConfigSerializable — JVM)
-    "(\\b\\d[\\d_]*(?:\\.\\d+)?(?:e[+-]?\\d+)?[fFlLdD]?\\b)",
-    // 4 number (JVM suffixes)
-    "([A-Za-z_$][\\w$]*)",
-    // 5 identifier (keyword/bool/func/prop/plain)
-    "([{}()\\[\\];:,.<>=+\\-*/%!&|?]+)"
-    // 6 punctuation
-  ].join("|"),
-  "g"
-);
+const COMMENTS = {
+  ts: "c",
+  js: "c",
+  json: "none",
+  bash: "hash",
+  html: "html",
+  python: "hash",
+  rust: "c",
+  yaml: "hash",
+  toml: "hash",
+  kotlin: "c",
+  java: "c",
+  groovy: "c",
+  plain: "none"
+};
+const COMMENT_PATTERN = {
+  c: "\\/\\/[^\\n]*|\\/\\*[\\s\\S]*?\\*\\/",
+  // A `#` only starts a comment at the start of a word, so `a#b` in a URL or
+  // `${#arr[@]}` in shell stay code.
+  hash: "(?<![\\w$])#[^\\n]*",
+  html: "<!--[\\s\\S]*?-->",
+  none: "(?!)"
+};
+const BLOCK = {
+  c: { open: "/*", close: "*/" },
+  html: { open: "<!--", close: "-->" }
+};
+const masters = /* @__PURE__ */ new Map();
+function masterFor(style) {
+  let re = masters.get(style);
+  if (!re) {
+    re = new RegExp(
+      [
+        `(${COMMENT_PATTERN[style]})`,
+        // 1 comment
+        "(\"(?:\\\\.|[^\"\\\\])*\"|'(?:\\\\.|[^'\\\\])*'|`(?:\\\\.|[^`\\\\])*`)",
+        // 2 string
+        "(@[A-Za-z_$][\\w$]*)",
+        // 3 annotation (@Override, @ConfigSerializable — JVM)
+        "(\\b\\d[\\d_]*(?:\\.\\d+)?(?:e[+-]?\\d+)?[fFlLdD]?\\b)",
+        // 4 number (JVM suffixes)
+        "(#?[A-Za-z_$][\\w$]*)",
+        // 5 identifier (keyword/bool/func/prop/plain), incl. #private
+        "([{}()\\[\\];:,.<>=+\\-*/%!&|?]+)"
+        // 6 punctuation
+      ].join("|"),
+      "g"
+    );
+    masters.set(style, re);
+  }
+  return re;
+}
 function classifyIdent(name, before, after) {
   if (KEYWORDS.has(name)) return C.keyword;
   if (BOOLEANS.has(name)) return C.boolean;
@@ -198,11 +233,13 @@ function classifyIdent(name, before, after) {
   return "";
 }
 function tokenizeLine(line, lang) {
+  if (lang === "plain") return line ? [{ text: line, cls: "" }] : [];
   const out = [];
   let last = 0;
   let m;
-  MASTER.lastIndex = 0;
-  while ((m = MASTER.exec(line)) !== null) {
+  const master = masterFor(COMMENTS[lang]);
+  master.lastIndex = 0;
+  while ((m = master.exec(line)) !== null) {
     if (m.index > last) out.push({ text: line.slice(last, m.index), cls: "" });
     const [full, comment, str, annotation, num, ident, punct] = m;
     if (comment != null) out.push({ text: full, cls: C.comment });
@@ -225,6 +262,41 @@ function tokenizeLine(line, lang) {
   if (last < line.length) out.push({ text: line.slice(last), cls: "" });
   return out;
 }
+function tokenizeLines(lines, lang) {
+  const block = BLOCK[COMMENTS[lang]];
+  if (!block) return lines.map((line) => tokenizeLine(line, lang));
+  const out = [];
+  let open = false;
+  for (const line of lines) {
+    let rest = line;
+    const tokens = [];
+    if (open) {
+      const end = rest.indexOf(block.close);
+      if (end === -1) {
+        out.push(rest ? [{ text: rest, cls: C.comment }] : []);
+        continue;
+      }
+      tokens.push({ text: rest.slice(0, end + block.close.length), cls: C.comment });
+      rest = rest.slice(end + block.close.length);
+      open = false;
+    }
+    const lineTokens = tokenizeLine(rest, lang);
+    const at = lineTokens.findIndex(
+      (t) => t.cls !== C.comment && t.cls !== C.string && t.text.includes(block.open)
+    );
+    if (at >= 0) {
+      const cut = lineTokens[at].text.indexOf(block.open);
+      const tail = lineTokens.slice(at).map((t) => t.text).join("").slice(cut);
+      tokens.push(...lineTokens.slice(0, at));
+      if (cut > 0) tokens.push({ text: lineTokens[at].text.slice(0, cut), cls: lineTokens[at].cls });
+      tokens.push({ text: tail, cls: C.comment });
+      open = true;
+    } else tokens.push(...lineTokens);
+    out.push(tokens);
+  }
+  return out;
+}
 export {
-  tokenizeLine
+  tokenizeLine,
+  tokenizeLines
 };

package/dist/components/color.d.ts

@@ -17,7 +17,7 @@ export type ColorFormat = "hex" | "rgb" | "hsl";
 /** Wraps rather than clamps: hue is a circle, and 370° is 10°, not 360°. */
 export declare function normalizeHue(h: number): number;
 export declare function clampHsv(c: Hsv): Hsv;
-export declare function hsvToRgb({ h, s, v, a }: Hsv): Rgb;
+export declare function hsvToRgb(color: Hsv): Rgb;
 export declare function rgbToHsv({ r, g, b, a }: Rgb): Hsv;
 /** "#rrggbb", or "#rrggbbaa" when the colour is not fully opaque. */
 export declare function rgbToHex({ r, g, b, a }: Rgb): string;

package/dist/components/color.js

@@ -11,7 +11,12 @@ function clampHsv(c) {
     a: clamp(c.a, 0, 1)
   };
 }
-function hsvToRgb({ h, s, v, a }) {
+const finite = (n) => Number.isFinite(n) ? n : 0;
+function hsvToRgb(color) {
+  const h = finite(color.h);
+  const s = clamp(finite(color.s), 0, 1);
+  const v = clamp(finite(color.v), 0, 1);
+  const a = Number.isFinite(color.a) ? color.a : 1;
   const hue = normalizeHue(h) / 60;
   const c = v * s;
   const x = c * (1 - Math.abs(hue % 2 - 1));
@@ -52,9 +57,13 @@ function rgbToHsv({ r, g, b, a }) {
   };
 }
 const hex2 = (n) => clamp(Math.round(n), 0, 255).toString(16).padStart(2, "0");
+function alphaByte(a) {
+  return Math.round(clamp(a, 0, 1) * 255);
+}
 function rgbToHex({ r, g, b, a }) {
   const base = `#${hex2(r)}${hex2(g)}${hex2(b)}`;
-  return a >= 1 ? base : base + hex2(a * 255);
+  const byte = alphaByte(a);
+  return byte >= 255 ? base : base + hex2(byte);
 }
 function parseHex(input) {
   const s = input.trim().replace(/^#/, "");
@@ -105,16 +114,18 @@ function hsvToHsl({ h, s, v }) {
 }
 function formatColor(c, format) {
   const rgb = hsvToRgb(c);
-  const a = Math.round(clamp(c.a, 0, 1) * 100) / 100;
+  const byte = alphaByte(rgb.a);
+  const a = Math.round(byte / 255 * 1e3) / 1e3;
   if (format === "hex") return rgbToHex(rgb);
   if (format === "rgb") {
-    return a >= 1 ? `rgb(${rgb.r}, ${rgb.g}, ${rgb.b})` : `rgba(${rgb.r}, ${rgb.g}, ${rgb.b}, ${a})`;
+    return byte >= 255 ? `rgb(${rgb.r}, ${rgb.g}, ${rgb.b})` : `rgba(${rgb.r}, ${rgb.g}, ${rgb.b}, ${a})`;
   }
-  const { h, s, l } = hsvToHsl(c);
-  const hh = Math.round(h);
-  const ss = Math.round(s * 100);
-  const ll = Math.round(l * 100);
-  return a >= 1 ? `hsl(${hh}, ${ss}%, ${ll}%)` : `hsla(${hh}, ${ss}%, ${ll}%, ${a})`;
+  const { h, s, l } = hsvToHsl({ ...c, h: finite(c.h), s: clamp(finite(c.s), 0, 1), v: clamp(finite(c.v), 0, 1) });
+  const dec = (n) => Math.round(n * 10) / 10;
+  const hh = dec(h) % 360;
+  const ss = dec(s * 100);
+  const ll = dec(l * 100);
+  return byte >= 255 ? `hsl(${hh}, ${ss}%, ${ll}%)` : `hsla(${hh}, ${ss}%, ${ll}%, ${a})`;
 }
 function opaqueCss(c) {
   const { r, g, b } = hsvToRgb({ ...c, a: 1 });

package/dist/components/confirm.d.ts

@@ -0,0 +1,25 @@
+export interface ConfirmOptions {
+    title: string;
+    description?: string;
+    danger?: boolean;
+    icon?: string;
+    confirmLabel?: string;
+    cancelLabel?: string;
+    loadingLabel?: string;
+    /**
+     * Work to run on confirm. The dialog stays open with a loading state while it
+     * runs and shows the error's message if it rejects; the promise from
+     * `confirm()` resolves true only once it succeeded.
+     */
+    action?: () => unknown;
+}
+export interface ConfirmRequest extends ConfirmOptions {
+    id: number;
+    resolve: (confirmed: boolean) => void;
+}
+export declare const confirmQueue: ConfirmRequest[];
+/** Ask for confirmation. Resolves false when the user cancels or dismisses. */
+export declare function confirm(options: ConfirmOptions): Promise<boolean>;
+/** Settle a request and drop it from the queue. Used by the host. */
+export declare function settleConfirm(id: number, confirmed: boolean): void;
+export declare function useConfirm(): typeof confirm;

package/dist/components/confirm.js

@@ -0,0 +1,26 @@
+import { reactive } from "vue";
+const STATE_KEY = /* @__PURE__ */ Symbol.for("@leavepulse/ui:confirm-queue");
+const g = globalThis;
+const state = g[STATE_KEY] ??= { queue: reactive([]), nextId: 0 };
+const confirmQueue = state.queue;
+function confirm(options) {
+  if (typeof window === "undefined") return Promise.resolve(false);
+  return new Promise((resolve) => {
+    state.queue.push({ ...options, id: state.nextId++, resolve });
+  });
+}
+function settleConfirm(id, confirmed) {
+  const i = state.queue.findIndex((r) => r.id === id);
+  if (i === -1) return;
+  const [request] = state.queue.splice(i, 1);
+  request?.resolve(confirmed);
+}
+function useConfirm() {
+  return confirm;
+}
+export {
+  confirm,
+  confirmQueue,
+  settleConfirm,
+  useConfirm
+};

package/dist/components/countries.d.ts

@@ -18,3 +18,9 @@ export declare function loadCountries(): Promise<Country[]>;
  * country is preferred. Pass the list (from loadCountries). Undefined if none.
  */
 export declare function matchCountryByValue(value: string, list: Country[]): Country | undefined;
+/**
+ * Countries matching a search query: by name, or by dial code when the query
+ * carries digits ("+44", "44"). A query without digits must not match on the
+ * dial code at all, or every country would match the empty string.
+ */
+export declare function filterCountries(list: Country[], query: string): Country[];

package/dist/components/countries.js

@@ -31,7 +31,14 @@ function matchCountryByValue(value, list) {
   }
   return best;
 }
+function filterCountries(list, query) {
+  const q = query.trim().toLowerCase();
+  if (!q) return list;
+  const digits = q.replace(/\D/g, "");
+  return list.filter((c) => c.name.toLowerCase().includes(q) || digits !== "" && c.dial.includes(digits));
+}
 export {
+  filterCountries,
   flagEmoji,
   loadCountries,
   matchCountryByValue

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/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/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/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/composables/useField.d.ts

@@ -0,0 +1,34 @@
+import { type ComputedRef, type InjectionKey } from "vue";
+export interface FieldContext {
+    id: string;
+    /** Id of the visible label, for controls a `<label for>` cannot name (groups). */
+    labelId?: string;
+    describedBy?: string;
+    invalid: boolean;
+    required: boolean;
+    disabled: boolean;
+}
+export declare const LP_FIELD: InjectionKey<ComputedRef<FieldContext>>;
+export declare function provideField(context: ComputedRef<FieldContext>): void;
+/** The nearest LpFormField's context, or null outside one. */
+export declare function useField(): ComputedRef<FieldContext> | null;
+export declare function fieldMessageId(id: string): string;
+export interface FieldControlState {
+    /** The control wraps itself in its own LpFormField (it has a label, hint or error prop). */
+    wrapped: boolean;
+    /** That own field renders a hint or error line. */
+    hasMessage?: boolean;
+    /** An id the consumer set on the control, which must win over a generated one. */
+    id?: string;
+    invalid?: boolean;
+    required?: boolean;
+    disabled?: boolean;
+}
+/**
+ * The field state a control renders with: its own wrapping field when it has
+ * one, otherwise the field around it, with the control's own flags or-ed in.
+ * `id` is undefined only for a bare control outside any field.
+ */
+export declare function useFieldControl(own: () => FieldControlState): ComputedRef<Omit<FieldContext, "id"> & {
+    id?: string;
+}>;