@vuetify/v0 1.1.0 → 1.2.1

package/dist/{index-DF0tMI2_.d.mts → index-CORslci7.d.mts}

@@ -1,4 +1,4 @@
-import { a as ID, c as V0ErrorCode, l as V0ErrorDetails, r as DeepPartial } from "./index-CyNk9FpR.mjs";
+import { a as ID, c as V0ErrorCode, l as V0ErrorDetails, r as DeepPartial } from "./index-DtiaWx5U.mjs";
 
 //#region src/utilities/color.d.ts
 interface RGB {
@@ -19,6 +19,77 @@ declare function rgbToHex({
 declare function apca(text: RGB, background: RGB): number;
 declare function foreground(hex: string): string;
 //#endregion
+//#region src/utilities/diacritics.d.ts
+/**
+ * @module utilities/diacritics
+ *
+ * @remarks
+ * Accent-folding search primitives. Pure string transforms — no DOM, no state,
+ * no reactivity. Powers the `ignoreAccents` option of `toHighlight` and any
+ * filter that wants a plain query to reach accented text.
+ */
+/**
+ * A `[start, end]` index pair where `end` is exclusive (matches
+ * `String.prototype.slice` convention).
+ *
+ * @example
+ * ```ts
+ * import type { MatchRange } from '@vuetify/v0'
+ *
+ * const ranges: MatchRange[] = [[0, 5], [12, 17]]
+ * ```
+ */
+type MatchRange = readonly [number, number];
+/**
+ * Which side of a comparison has its accents folded before matching.
+ *
+ * - `'query'` — folds the query, so typing `café` finds plain `cafe`
+ * - `'target'` — folds the text, so typing `cafe` finds accented `café`
+ * - `true` — both sides fold, so any accent variant matches any other
+ * - `false` — neither folds, exact match only
+ *
+ * `'query'` and `'target'` fold only one side, but a spelling that already
+ * agrees on both sides still matches verbatim — folding one side never
+ * hides a match the other side already has. They still don't fold each
+ * other's accents together, so `café` won't match `cafè` under either.
+ */
+type IgnoreAccents = boolean | 'query' | 'target';
+interface FindMatchRangesOptions {
+  ignoreCase?: boolean;
+  ignoreAccents?: IgnoreAccents;
+  matchAll?: boolean;
+}
+/**
+ * Finds `[start, end]` index pairs where `query` occurs in `text`, optionally
+ * folding accents on either side. Returned indices always address the original
+ * `text`, even when folding or case-conversion changed its length.
+ *
+ * Directional folding (`'query'` or `'target'`) only transforms one side, but
+ * a spelling that's already identical on both sides — accents and all — is
+ * merged in verbatim, so folding one side never hides a match the other side
+ * already has.
+ *
+ * @param text The string to search.
+ * @param query The term to look for. An empty query yields no ranges.
+ * @param options Optional `ignoreCase`, `ignoreAccents`, `matchAll`.
+ * @returns Ranges into `text`, where `end` is exclusive.
+ *
+ * @example
+ * ```ts
+ * import { findMatchRanges } from '@vuetify/v0'
+ *
+ * findMatchRanges('Zürich', 'zurich', { ignoreCase: true, ignoreAccents: true })
+ * // [[0, 6]]
+ *
+ * findMatchRanges('Łódź', 'Lo', { ignoreAccents: 'target' })
+ * // [[0, 2]]
+ *
+ * findMatchRanges('… Kraków …', 'Kraków', { ignoreAccents: 'query' })
+ * // [[2, 8]] — typing the exact accented name always finds itself
+ * ```
+ */
+declare function findMatchRanges(text: string, query: string, options?: FindMatchRangesOptions): MatchRange[];
+//#endregion
 //#region src/utilities/errors.d.ts
 /**
  * Structured error thrown by v0 internals.
@@ -263,6 +334,21 @@ declare function isArray<T>(item: T | NoInfer<T[]>): item is 0 extends (1 & T) ?
  * ```
  */
 declare function isElement(item: unknown): item is Element;
+/**
+ * Resolve the deepest focused element, piercing open shadow roots.
+ *
+ * `document.activeElement` returns the shadow *host* when focus is inside an
+ * open shadow root — walk down through open roots so focus/keyboard logic
+ * resolves the real focused element (e.g. a control inside a custom element).
+ * Returns the same value as `document.activeElement` in light DOM, and `null`
+ * under SSR. Closed shadow roots can't be traversed.
+ *
+ * @example
+ * ```ts
+ * const active = getActiveElement()
+ * ```
+ */
+declare function getActiveElement(): Element | null;
 /**
  * Checks if a value is null
  *
@@ -449,6 +535,39 @@ declare function clamp(value: number, min?: number, max?: number): number;
  * ```
  */
 declare function range(length: number, start?: number): number[];
+/**
+ * Parses a CSS pixel length into a number
+ *
+ * @param value The resolved CSS length, e.g. `getComputedStyle(el).marginLeft`
+ * @param fallback The value to return when `value` does not parse (default: 0)
+ * @returns The parsed number, or `fallback`
+ *
+ * @remarks
+ * Built for reading `getComputedStyle` output, where a length that does not
+ * apply resolves to `''` or `'auto'` rather than to a number. An unparseable
+ * length returns `fallback`; a length that legitimately parses to `0` returns
+ * `0`. That distinction is why this exists — `Number.parseFloat(v) || 0`
+ * collapses both cases onto `0`, which is only correct when the fallback is
+ * itself `0`.
+ *
+ * Only the leading number is read, matching `Number.parseFloat`, so any unit
+ * suffix is ignored. Values `getComputedStyle` never returns — percentages,
+ * `calc()` expressions, multi-value shorthands — are out of scope.
+ *
+ * @example
+ * ```ts
+ * pxToNumber('16px')          // 16
+ * pxToNumber('0px')           // 0
+ * pxToNumber('-4.5px')        // -4.5
+ * pxToNumber('auto')          // 0
+ * pxToNumber(undefined)       // 0
+ *
+ * // A non-zero fallback is the case `|| 0` cannot express
+ * pxToNumber('auto', 100)     // 100
+ * pxToNumber('0px', 100)      // 0
+ * ```
+ */
+declare function pxToNumber(value: string | undefined, fallback?: number): number;
 /**
  * Resolves an iterable of IDs to their items via a getter,
  * filtering out any that return undefined.
@@ -469,4 +588,4 @@ declare function resolveIndexes(items: Iterable<{
 declare function instanceExists(): boolean;
 declare function instanceName(): string | undefined;
 //#endregion
-export { rgbToHex as A, useId as C, foreground as D, apca as E, RGB as O, resolveIndexes as S, isV0Error as T, isThenable as _, isArray as a, range as b, isFunction as c, isNullOrUndefined as d, isNumber as f, isSymbol as g, isString as h, clamp as i, hexToRgb as k, isNaN as l, isPrimitive as m, instanceName as n, isBoolean as o, isObject as p, UNSAFE_KEYS as r, isElement as s, instanceExists as t, isNull as u, isUndefined as v, V0Error as w, resolveIds as x, mergeDeep as y };
+export { MatchRange as A, resolveIds as C, isV0Error as D, V0Error as E, hexToRgb as F, rgbToHex as I, apca as M, foreground as N, FindMatchRangesOptions as O, RGB as P, range as S, useId as T, isSymbol as _, getActiveElement as a, mergeDeep as b, isElement as c, isNull as d, isNullOrUndefined as f, isString as g, isPrimitive as h, clamp as i, findMatchRanges as j, IgnoreAccents as k, isFunction as l, isObject as m, instanceName as n, isArray as o, isNumber as p, UNSAFE_KEYS as r, isBoolean as s, instanceExists as t, isNaN as u, isThenable as v, resolveIndexes as w, pxToNumber as x, isUndefined as y };