@vuetify/v0 0.1.3 → 0.1.5

package/dist/adapter-CJIj5ySf.d.mts

@@ -0,0 +1,11 @@
+//#region src/composables/useLogger/adapters/adapter.d.ts
+interface LoggerAdapter {
+  debug: (message: string, ...args: unknown[]) => void;
+  info: (message: string, ...args: unknown[]) => void;
+  warn: (message: string, ...args: unknown[]) => void;
+  error: (message: string, ...args: unknown[]) => void;
+  trace?: (message: string, ...args: unknown[]) => void;
+  fatal?: (message: string, ...args: unknown[]) => void;
+}
+//#endregion
+export { LoggerAdapter as t };

package/dist/adapter-Cmeg49W9.mjs

@@ -0,0 +1,229 @@
+import { d as isObject, l as isNullOrUndefined, p as isString, s as isNaN, u as isNumber } from "./utilities-Dx8wzGa5.mjs";
+import { i as useContext, n as createContext, t as createTrinity } from "./createTrinity-DkwPrPRS.mjs";
+import { t as toArray } from "./toArray-VIn8vYt3.mjs";
+import { computed, isRef, toRef, toValue } from "vue";
+
+//#region src/composables/createFilter/index.ts
+/**
+* @module useFilter
+*
+* @remarks
+* Reactive array filtering composable with multiple filter modes.
+*
+* Key features:
+* - Four filter modes: some, every, union, intersection
+* - Case-insensitive filtering
+* - Custom filter functions
+* - Reactive updates
+* - Context-based DI support
+* - Perfect for search, multi-criteria filtering
+*
+* Filters arrays based on query strings with configurable matching strategies.
+*/
+function defaultFilter(query, item, keys, mode = "some") {
+	const queries = toArray(query).map((q) => String(q).toLowerCase());
+	const stringValues = (/* @__PURE__ */ isObject(item) ? keys?.length ? keys.map((k) => item[k]) : Object.values(item) : [item]).map((v) => String(v).toLowerCase());
+	if (mode === "some") return stringValues.some((val) => val.includes(queries[0]));
+	if (mode === "every") return stringValues.every((val) => val.includes(queries[0]));
+	const joined = stringValues.join("\0");
+	if (mode === "union") return queries.some((q) => joined.includes(q));
+	if (mode === "intersection") return queries.every((q) => joined.includes(q));
+	return false;
+}
+/**
+* Creates a filter context with pre-configured options.
+*
+* @param options The filter options
+* @template Z The type of the items
+* @template E The type of the filter context
+* @returns A filter context
+*
+* @see https://0.vuetifyjs.com/composables/utilities/use-filter
+*
+* @example
+* ```ts
+* import { createFilter } from '@vuetify/v0'
+*
+* const filter = createFilter({
+*   mode: 'intersection',
+*   keys: ['name', 'email'],
+* })
+*
+* const { items } = filter.apply(query, users)
+* ```
+*/
+function createFilter(options = {}) {
+	const { customFilter, keys, mode = "some" } = options;
+	const filterFunction = customFilter ?? ((q, i) => defaultFilter(q, i, keys, mode));
+	const query = toRef("");
+	function apply(_query, items) {
+		const itemsRef = isRef(items) ? items : toRef(() => items);
+		const queryRef = toRef(_query);
+		return { items: computed(() => {
+			const q = toValue(queryRef);
+			query.value = q;
+			const queries = toArray(q).filter((q$1) => String(q$1).trim());
+			if (queries.length === 0) return itemsRef.value;
+			const queryParam = queries.length === 1 ? queries[0] : queries;
+			return itemsRef.value.filter((item) => filterFunction(queryParam, item));
+		}) };
+	}
+	return {
+		mode,
+		keys,
+		customFilter,
+		query,
+		apply
+	};
+}
+/**
+* Creates a filter context with dependency injection support.
+*
+* @param options The filter context options
+* @template Z The type of the items
+* @template E The type of the filter context
+* @returns A trinity tuple: [useContext, provideContext, defaultContext]
+*
+* @see https://0.vuetifyjs.com/composables/utilities/use-filter
+*
+* @example
+* ```ts
+* import { createFilterContext } from '@vuetify/v0'
+*
+* export const [useSearchFilter, provideSearchFilter, searchFilter] = createFilterContext({
+*   namespace: 'app:search',
+*   mode: 'union',
+*   keys: ['title', 'description'],
+* })
+*
+* // In parent component
+* provideSearchFilter()
+*
+* // In child component
+* const filter = useSearchFilter()
+* const { items } = filter.apply(query, products)
+* ```
+*/
+function createFilterContext(_options = {}) {
+	const { namespace = "v0:filter", ...options } = _options;
+	const [useFilterContext, _provideFilterContext] = createContext(namespace);
+	const context = createFilter(options);
+	function provideFilterContext(_context = context, app) {
+		return _provideFilterContext(_context, app);
+	}
+	return createTrinity(useFilterContext, provideFilterContext, context);
+}
+/**
+* Returns the current filter context from dependency injection.
+*
+* @param namespace The namespace for the filter context. Defaults to `'v0:filter'`.
+* @template Z The type of the items.
+* @template E The type of the filter context.
+* @returns The current filter context.
+*
+* @see https://0.vuetifyjs.com/composables/utilities/use-filter
+*
+* @example
+* ```vue
+* <script setup lang="ts">
+*   import { useFilter } from '@vuetify/v0'
+*
+*   const filter = useFilter()
+*   const { items } = filter.apply(query, products)
+* <\/script>
+* ```
+*/
+function useFilter(namespace = "v0:filter") {
+	return useContext(namespace);
+}
+
+//#endregion
+//#region src/composables/createDataTable/adapters/adapter.ts
+/**
+* @module createDataTable/adapters
+*
+* @remarks
+* Defines the adapter interface and abstract base class for data table
+* pipeline strategies. Adapters control how raw items are filtered, sorted,
+* and sliced into visible items.
+*
+* The abstract DataTableAdapter provides shared filter and sort pipelines
+* used by client-side adapters. Server adapters that delegate pipeline
+* operations externally can implement DataTableAdapterInterface directly.
+*/
+function getNestedValue(obj, key) {
+	const keys = key.split(".");
+	let result = obj;
+	for (const k of keys) {
+		if (/* @__PURE__ */ isNullOrUndefined(result)) return void 0;
+		result = result[k];
+	}
+	return result;
+}
+function compareValues(a, b, locale) {
+	if (a === b) return 0;
+	if (/* @__PURE__ */ isNullOrUndefined(a)) return 1;
+	if (/* @__PURE__ */ isNullOrUndefined(b)) return -1;
+	if (/* @__PURE__ */ isString(a) && /* @__PURE__ */ isString(b)) return a.localeCompare(b, locale);
+	if (/* @__PURE__ */ isNumber(a) && /* @__PURE__ */ isNumber(b)) {
+		if (/* @__PURE__ */ isNaN(a)) return 1;
+		if (/* @__PURE__ */ isNaN(b)) return -1;
+		return a - b;
+	}
+	return String(a).localeCompare(String(b), locale);
+}
+var DataTableAdapter = class {
+	/** Create the filter pipeline stage */
+	filter(context) {
+		const filter = createFilter(Object.keys(context.customColumnFilters).length > 0 && !context.filterOptions.customFilter ? {
+			...context.filterOptions,
+			keys: [...context.filterableKeys],
+			customFilter: (query, item) => {
+				if (!/* @__PURE__ */ isObject(item)) return false;
+				const q = String(Array.isArray(query) ? query[0] : query).toLowerCase();
+				if (!q) return true;
+				const obj = item;
+				for (const key of context.filterableKeys) {
+					const customFn = context.customColumnFilters[key];
+					if (customFn) {
+						if (customFn(obj[key], q)) return true;
+					} else {
+						const val = obj[key];
+						if (!/* @__PURE__ */ isNullOrUndefined(val) && String(val).toLowerCase().includes(q)) return true;
+					}
+				}
+				return false;
+			}
+		} : {
+			...context.filterOptions,
+			keys: [...context.filterableKeys]
+		});
+		const allItems = toRef(() => toValue(context.items));
+		const { items: filteredItems } = filter.apply(context.search, allItems);
+		return {
+			allItems,
+			filteredItems
+		};
+	}
+	/** Create the sort pipeline stage */
+	sort(filteredItems, sortBy, locale, customSorts) {
+		return computed(() => {
+			const entries = sortBy.value;
+			if (entries.length === 0) return filteredItems.value;
+			const loc = locale?.value;
+			return filteredItems.value.toSorted((a, b) => {
+				for (const { key, direction } of entries) {
+					const aVal = getNestedValue(a, key);
+					const bVal = getNestedValue(b, key);
+					const customSort = customSorts?.[key];
+					const cmp = customSort ? customSort(aVal, bVal) : compareValues(aVal, bVal, loc);
+					if (cmp !== 0) return direction === "desc" ? -cmp : cmp;
+				}
+				return 0;
+			});
+		});
+	}
+};
+
+//#endregion
+export { useFilter as i, createFilter as n, createFilterContext as r, DataTableAdapter as t };

package/dist/adapter-D2JoR-4d.d.mts

@@ -0,0 +1,344 @@
+import * as vue642 from "vue";
+import { App, ComputedRef, MaybeRef, MaybeRefOrGetter, Ref, ShallowRef } from "vue";
+
+//#region src/composables/createTrinity/index.d.ts
+
+type ContextTrinity<Z = unknown> = readonly [() => Z, (context?: Z, app?: App) => Z, Z];
+/**
+ * Creates a new trinity for a context composable and its provider.
+ *
+ * @param useContext The function that retrieves/uses the context (typically named `useContext`).
+ * @param provideContext The function that provides the context to descendants.
+ * @param context The default context instance to use when no custom context is provided.
+ * @template Z The type of the context.
+ * @returns A readonly tuple containing: [useContext function, provideContext wrapper function, default context instance].
+ *
+ * @remarks The trinity pattern is a foundational pattern used throughout the codebase for creating reusable context systems. It provides three related elements:
+ *
+ * 1. A function to retrieve/use the context
+ * 2. A function to provide the context (with default value support)
+ * 3. The default context instance
+ *
+ * The returned tuple is readonly (using `as const`) to ensure proper type inference.
+ *
+ * @see https://0.vuetifyjs.com/composables/foundation/create-trinity#create-trinity
+ *
+ * @example
+ * ```ts
+ * interface MyContext {
+ *   foo: string
+ *   bar: number
+ * }
+ *
+ * export function createMyFeature<E extends MyContext = MyContext>() {
+ *   const [useContext, _provideContext] = createContext<E>('my-context')
+ *
+ *   const context = { foo: 'hello', bar: 42 }
+ *
+ *   function provideContext (_context: E = context, app?: App): E {
+ *     return _provideContext(_context, app)
+ *   }
+ *
+ *   return createTrinity<E>(useContext, provideContext, context)
+ * }
+ * ```
+ */
+declare function createTrinity<Z = unknown>(useContext: () => Z, provideContext: (_context?: Z, app?: App) => Z, context: Z): ContextTrinity<Z>;
+//#endregion
+//#region src/composables/createFilter/index.d.ts
+type Primitive = string | number | boolean;
+type FilterQuery = MaybeRefOrGetter<Primitive | Primitive[]>;
+type FilterItem = Primitive | Record<string, any>;
+type FilterMode = 'some' | 'every' | 'union' | 'intersection';
+type FilterFunction = (query: Primitive | Primitive[], item: FilterItem) => boolean;
+interface FilterOptions {
+  customFilter?: FilterFunction;
+  keys?: string[];
+  mode?: FilterMode;
+}
+interface FilterResult<Z extends FilterItem = FilterItem> {
+  items: ComputedRef<Z[]>;
+}
+interface FilterContext<Z extends FilterItem = FilterItem> {
+  /** The filter mode */
+  mode: FilterMode;
+  /** Keys to filter on for object items */
+  keys: string[] | undefined;
+  /** Custom filter function */
+  customFilter: FilterFunction | undefined;
+  /** Current query ref */
+  query: ShallowRef<Primitive | Primitive[]>;
+  /**
+   * Apply filter to an array of items
+   *
+   * @param query The query to filter by
+   * @param items The items to filter
+   * @returns The filtered items as a computed ref
+   */
+  apply: <T extends Z>(query: FilterQuery, items: MaybeRef<T[]>) => FilterResult<T>;
+}
+interface FilterContextOptions extends FilterOptions {
+  namespace?: string;
+}
+/**
+ * Creates a filter context with pre-configured options.
+ *
+ * @param options The filter options
+ * @template Z The type of the items
+ * @template E The type of the filter context
+ * @returns A filter context
+ *
+ * @see https://0.vuetifyjs.com/composables/utilities/use-filter
+ *
+ * @example
+ * ```ts
+ * import { createFilter } from '@vuetify/v0'
+ *
+ * const filter = createFilter({
+ *   mode: 'intersection',
+ *   keys: ['name', 'email'],
+ * })
+ *
+ * const { items } = filter.apply(query, users)
+ * ```
+ */
+declare function createFilter<Z extends FilterItem = FilterItem, E extends FilterContext<Z> = FilterContext<Z>>(options?: FilterOptions): E;
+/**
+ * Creates a filter context with dependency injection support.
+ *
+ * @param options The filter context options
+ * @template Z The type of the items
+ * @template E The type of the filter context
+ * @returns A trinity tuple: [useContext, provideContext, defaultContext]
+ *
+ * @see https://0.vuetifyjs.com/composables/utilities/use-filter
+ *
+ * @example
+ * ```ts
+ * import { createFilterContext } from '@vuetify/v0'
+ *
+ * export const [useSearchFilter, provideSearchFilter, searchFilter] = createFilterContext({
+ *   namespace: 'app:search',
+ *   mode: 'union',
+ *   keys: ['title', 'description'],
+ * })
+ *
+ * // In parent component
+ * provideSearchFilter()
+ *
+ * // In child component
+ * const filter = useSearchFilter()
+ * const { items } = filter.apply(query, products)
+ * ```
+ */
+declare function createFilterContext<Z extends FilterItem = FilterItem, E extends FilterContext<Z> = FilterContext<Z>>(_options?: FilterContextOptions): ContextTrinity<E>;
+/**
+ * Returns the current filter context from dependency injection.
+ *
+ * @param namespace The namespace for the filter context. Defaults to `'v0:filter'`.
+ * @template Z The type of the items.
+ * @template E The type of the filter context.
+ * @returns The current filter context.
+ *
+ * @see https://0.vuetifyjs.com/composables/utilities/use-filter
+ *
+ * @example
+ * ```vue
+ * <script setup lang="ts">
+ *   import { useFilter } from '@vuetify/v0'
+ *
+ *   const filter = useFilter()
+ *   const { items } = filter.apply(query, products)
+ * </script>
+ * ```
+ */
+declare function useFilter<Z extends FilterItem = FilterItem, E extends FilterContext<Z> = FilterContext<Z>>(namespace?: string): E;
+//#endregion
+//#region src/composables/createPagination/index.d.ts
+type PaginationTicket = {
+  type: 'page';
+  value: number;
+} | {
+  type: 'ellipsis';
+  value: string;
+};
+interface PaginationContext {
+  /** Current page (1-indexed) */
+  page: ShallowRef<number>;
+  /** Items per page */
+  itemsPerPage: number;
+  /** Total number of items */
+  size: number;
+  /** Total number of pages (computed from size / itemsPerPage) */
+  pages: number;
+  /** Ellipsis character, or false if disabled */
+  ellipsis: string | false;
+  /** Visible page numbers and ellipsis for rendering */
+  items: ComputedRef<PaginationTicket[]>;
+  /** Start index of items on current page (0-indexed) */
+  pageStart: ComputedRef<number>;
+  /** End index of items on current page (exclusive, 0-indexed) */
+  pageStop: ComputedRef<number>;
+  /** Whether current page is the first page */
+  isFirst: ComputedRef<boolean>;
+  /** Whether current page is the last page */
+  isLast: ComputedRef<boolean>;
+  /** Go to first page */
+  first: () => void;
+  /** Go to last page */
+  last: () => void;
+  /** Go to next page */
+  next: () => void;
+  /** Go to previous page */
+  prev: () => void;
+  /** Go to specific page */
+  select: (value: number) => void;
+}
+interface PaginationOptions {
+  /** Initial page or ref for v-model (1-indexed). @default 1 */
+  page?: number | ShallowRef<number>;
+  /** Items per page. @default 10 */
+  itemsPerPage?: MaybeRefOrGetter<number>;
+  /** Total number of items. @default 0 */
+  size?: MaybeRefOrGetter<number>;
+  /** Maximum visible page buttons. @default 5 */
+  visible?: MaybeRefOrGetter<number>;
+  /** Ellipsis character. @default '…' */
+  ellipsis?: string | false;
+}
+interface PaginationContextOptions extends PaginationOptions {
+  /** Namespace for dependency injection */
+  namespace?: string;
+}
+/**
+ * Creates a pagination instance.
+ *
+ * @param options The options for the pagination instance.
+ * @returns A pagination context with navigation methods.
+ *
+ * @example
+ * ```ts
+ * import { createPagination } from '@vuetify/v0'
+ *
+ * // Basic usage
+ * const pagination = createPagination({ size: 100 })
+ * pagination.next()
+ * pagination.items.value // [{ type: 'page', value: 1 }, { type: 'page', value: 2 }, ...]
+ *
+ * // With v-model (pass a ref)
+ * const page = ref(1)
+ * const pagination = createPagination({ page, size: 100 })
+ * // Mutating pagination.page or the passed ref syncs both
+ * ```
+ */
+declare function createPagination(_options?: PaginationOptions): PaginationContext;
+/**
+ * Creates a pagination context for dependency injection.
+ *
+ * @param options The options including namespace.
+ * @returns A trinity: [usePagination, providePagination, defaultContext]
+ *
+ * @example
+ * ```ts
+ * // With default namespace 'v0:pagination'
+ * const [usePagination, providePaginationContext] = createPaginationContext({ size: 50 })
+ *
+ * // Or with custom namespace
+ * const [usePagination, providePaginationContext] = createPaginationContext({
+ *   namespace: 'my-pagination',
+ *   size: 50,
+ * })
+ *
+ * // Parent component
+ * providePaginationContext()
+ *
+ * // Child component
+ * const pagination = usePagination()
+ * pagination.next()
+ * ```
+ */
+declare function createPaginationContext(_options?: PaginationContextOptions): ContextTrinity<PaginationContext>;
+/**
+ * Returns the current pagination instance from context.
+ *
+ * @param namespace The namespace. @default 'v0:pagination'
+ * @returns The pagination context.
+ *
+ * @example
+ * ```vue
+ * <script setup lang="ts">
+ *  import { usePagination } from '@vuetify/v0'
+ *
+ *  const pagination = usePagination()
+ * </script>
+ *
+ * <template>
+ *   <button @click="pagination.prev()" :disabled="pagination.isFirst.value">Prev</button>
+ *   <button @click="pagination.next()" :disabled="pagination.isLast.value">Next</button>
+ * </template>
+ * ```
+ */
+declare function usePagination(namespace?: string): PaginationContext;
+//#endregion
+//#region src/composables/createDataTable/adapters/adapter.d.ts
+type SortDirection = 'asc' | 'desc' | 'none';
+interface SortEntry {
+  key: string;
+  direction: SortDirection;
+}
+/** Inputs provided by createDataTable to the adapter */
+interface DataTableAdapterContext<T extends Record<string, unknown>> {
+  /** Source items */
+  items: MaybeRefOrGetter<T[]>;
+  /** Search query ref */
+  search: ShallowRef<string>;
+  /** Column keys eligible for filtering */
+  filterableKeys: ReadonlyArray<keyof T & string>;
+  /** Current sort state derived from sort controls */
+  sortBy: Readonly<Ref<SortEntry[]>>;
+  /** Locale for sorting (reactive, from useLocale or options) */
+  locale: Readonly<Ref<string | undefined>>;
+  /** Filter options (keys excluded, derived from columns) */
+  filterOptions: Omit<FilterOptions, 'keys'>;
+  /** Pagination options (size excluded, derived from pipeline) */
+  paginationOptions: Omit<PaginationOptions, 'size'>;
+  /** Per-column custom sort comparators */
+  customSorts: Partial<Record<keyof T & string, (a: unknown, b: unknown) => number>>;
+  /** Per-column custom filter functions */
+  customColumnFilters: Partial<Record<keyof T & string, (value: unknown, query: string) => boolean>>;
+}
+/** Outputs returned by the adapter to createDataTable */
+interface DataTableAdapterResult<T extends Record<string, unknown>> {
+  /** Raw unprocessed items */
+  allItems: Readonly<Ref<readonly T[]>>;
+  /** Items after filtering */
+  filteredItems: Readonly<Ref<readonly T[]>>;
+  /** Items after filtering and sorting */
+  sortedItems: Readonly<Ref<readonly T[]>>;
+  /** Final visible items (paginated or virtualized) */
+  items: Readonly<Ref<readonly T[]>>;
+  /** Pagination controls */
+  pagination: PaginationContext;
+  /** Total row count for aria-rowcount */
+  total: Readonly<Ref<number>>;
+  /** Loading state (optional, for async adapters) */
+  loading?: Readonly<Ref<boolean>>;
+  /** Error state (optional, for async adapters) */
+  error?: Readonly<Ref<Error | null>>;
+}
+/** Pipeline adapter interface for data table strategies */
+interface DataTableAdapterInterface<T extends Record<string, unknown>> {
+  setup: (context: DataTableAdapterContext<T>) => DataTableAdapterResult<T>;
+}
+declare abstract class DataTableAdapter<T extends Record<string, unknown>> implements DataTableAdapterInterface<T> {
+  /** Create the filter pipeline stage */
+  protected filter(context: DataTableAdapterContext<T>): {
+    allItems: Readonly<Ref<T[], T[]>>;
+    filteredItems: vue642.ComputedRef<T[]>;
+  };
+  /** Create the sort pipeline stage */
+  protected sort(filteredItems: Readonly<Ref<readonly T[]>>, sortBy: Readonly<Ref<SortEntry[]>>, locale?: Readonly<Ref<string | undefined>>, customSorts?: Partial<Record<string, (a: unknown, b: unknown) => number>>): Readonly<Ref<readonly T[]>>;
+  abstract setup(context: DataTableAdapterContext<T>): DataTableAdapterResult<T>;
+}
+//#endregion
+export { createFilter as C, createTrinity as D, ContextTrinity as E, Primitive as S, useFilter as T, FilterItem as _, SortDirection as a, FilterQuery as b, PaginationContextOptions as c, createPagination as d, createPaginationContext as f, FilterFunction as g, FilterContextOptions as h, DataTableAdapterResult as i, PaginationOptions as l, FilterContext as m, DataTableAdapterContext as n, SortEntry as o, usePagination as p, DataTableAdapterInterface as r, PaginationContext as s, DataTableAdapter as t, PaginationTicket as u, FilterMode as v, createFilterContext as w, FilterResult as x, FilterOptions as y };

package/dist/adapters-BQ-Lr3PW.mjs

@@ -0,0 +1 @@
+export {  };

package/dist/adapters-DEXpW9If.mjs

@@ -0,0 +1 @@
+export {  };

package/dist/adapters-Q9WaOsJp.mjs

@@ -0,0 +1 @@
+export {  };

package/dist/adapters-SSDVth5e.mjs

@@ -0,0 +1 @@
+export {  };