@vuetify/v0 1.0.0-alpha.3 → 1.0.0-alpha.5

package/README.md

@@ -168,7 +168,9 @@ Base data structures that most other composables build upon:
 
 - [`createDataTable`](https://0.vuetifyjs.com/composables/data/create-data-table) - Data table with sort, filter, pagination, row selection, grouping, and adapter pattern
 - [`createFilter`](https://0.vuetifyjs.com/composables/data/create-filter) - Reactive array filtering with multiple modes
+- [`createKanban`](https://0.vuetifyjs.com/composables/data/create-kanban) - Two-level sortable orchestrator (columns + items)
 - [`createPagination`](https://0.vuetifyjs.com/composables/data/create-pagination) - Lightweight page navigation
+- [`createSortable`](https://0.vuetifyjs.com/composables/data/create-sortable) - Ordered-list state with `move` / `swap` / `reorder` and a `disabled` mutation gate
 - [`createVirtual`](https://0.vuetifyjs.com/composables/data/create-virtual) - Virtual scrolling for large lists
 
 #### Selection
@@ -187,6 +189,7 @@ Selection management composables built on `createRegistry`:
 - [`createForm`](https://0.vuetifyjs.com/composables/forms/create-form) - Form validation and state management with async rules
 - [`createInput`](https://0.vuetifyjs.com/composables/forms/create-input) - Shared form field state: validation, dirty/pristine, ARIA IDs
 - [`createNumberField`](https://0.vuetifyjs.com/composables/forms/create-number-field) - Numeric input state with formatting, stepping, and validation
+- [`createOtp`](https://0.vuetifyjs.com/composables/forms/create-otp) - OTP / verification code state with pattern-gated entry and decisional completion hook
 - [`createValidation`](https://0.vuetifyjs.com/composables/forms/create-validation) - Field-level validation with sync/async rules
 - [`createCombobox`](https://0.vuetifyjs.com/composables/forms/create-combobox) - Combobox state management with filtering and virtual focus
 - [`createRating`](https://0.vuetifyjs.com/composables/forms/create-rating) - Bounded rating value with discrete items and half-step support
@@ -206,12 +209,14 @@ Selection management composables built on `createRegistry`:
 
 - [`toArray`](https://0.vuetifyjs.com/composables/transformers/to-array) - Array transformation utilities
 - [`toElement`](https://0.vuetifyjs.com/composables/transformers/to-element) - Normalize refs, selectors, and elements to DOM elements
+- [`toHighlight`](https://0.vuetifyjs.com/composables/transformers/to-highlight) - Split text into matched and unmatched chunks for query highlighting
 - [`toReactive`](https://0.vuetifyjs.com/composables/transformers/to-reactive) - Reactive object conversion
 
 #### System
 
 - [`useClickOutside`](https://0.vuetifyjs.com/composables/system/use-click-outside) - Click outside detection with cleanup
 - [`useDelay`](https://0.vuetifyjs.com/composables/system/use-delay) - Schedule open and close transitions with configurable delays
+- [`useDragDrop`](https://0.vuetifyjs.com/composables/system/use-drag-drop) - Headless drag-and-drop primitive with two registries, pluggable adapters, and accessibility-first defaults
 - [`useEventListener`](https://0.vuetifyjs.com/composables/system/use-event-listener) - Lifecycle-managed event listeners
 - [`useHotkey`](https://0.vuetifyjs.com/composables/system/use-hotkey) - Hotkey combinations and sequences
 - [`useImage`](https://0.vuetifyjs.com/composables/system/use-image) - Image loading state machine with deferred loading and retry

package/dist/adapter-B6IrPwib.d.mts

@@ -0,0 +1,98 @@
+import { Temporal } from "@js-temporal/polyfill";
+
+//#region src/composables/useDate/adapters/adapter.d.ts
+declare abstract class DateAdapter<T = Temporal.PlainDateTime> {
+  /** Current locale for formatting */
+  abstract get locale(): string;
+  /** First day of week. 0=Sunday, 1=Monday, ... 6=Saturday. Managed by the plugin. */
+  abstract get firstDayOfWeek(): number;
+  abstract set locale(value: string);
+  abstract set firstDayOfWeek(value: number);
+  /** Create a date from various input types */
+  abstract date(value?: unknown): T | null;
+  /** Convert to JavaScript Date object */
+  abstract toJsDate(value: T): Date;
+  /** Parse ISO 8601 string */
+  abstract parseISO(date: string): T;
+  /** Convert to ISO 8601 string */
+  abstract toISO(date: T): string;
+  /** Parse date string with custom format */
+  abstract parse(value: string, format: string): T | null;
+  /** Check if value is a valid date (type predicate for narrowing) */
+  abstract isValid(date: unknown): date is T;
+  /** Check if value is null (type predicate for narrowing) */
+  abstract isNullish(value: T | null): value is null;
+  /** Get current locale code */
+  abstract getCurrentLocaleCode(): string;
+  /** Check if current locale uses 12-hour cycle */
+  abstract is12HourCycleInCurrentLocale(): boolean;
+  /** Format date using preset format key */
+  abstract format(date: T, formatString: string): string;
+  /** Format date using custom format string */
+  abstract formatByString(date: T, formatString: string): string;
+  /** Get helper text for format string (e.g., "mm/dd/yyyy") */
+  abstract getFormatHelperText(format: string): string;
+  /** Format number according to locale */
+  abstract formatNumber(numberToFormat: string): string;
+  /** Get meridiem text (AM/PM) for locale */
+  abstract getMeridiemText(ampm: 'am' | 'pm'): string;
+  abstract startOfDay(date: T): T;
+  abstract endOfDay(date: T): T;
+  abstract startOfWeek(date: T): T;
+  abstract endOfWeek(date: T): T;
+  abstract startOfMonth(date: T): T;
+  abstract endOfMonth(date: T): T;
+  abstract startOfYear(date: T): T;
+  abstract endOfYear(date: T): T;
+  abstract addSeconds(date: T, amount: number): T;
+  abstract addMinutes(date: T, amount: number): T;
+  abstract addHours(date: T, amount: number): T;
+  abstract addDays(date: T, amount: number): T;
+  abstract addWeeks(date: T, amount: number): T;
+  abstract addMonths(date: T, amount: number): T;
+  abstract addYears(date: T, amount: number): T;
+  abstract isAfter(date: T, comparing: T): boolean;
+  abstract isAfterDay(date: T, comparing: T): boolean;
+  abstract isAfterMonth(date: T, comparing: T): boolean;
+  abstract isAfterYear(date: T, comparing: T): boolean;
+  abstract isBefore(date: T, comparing: T): boolean;
+  abstract isBeforeDay(date: T, comparing: T): boolean;
+  abstract isBeforeMonth(date: T, comparing: T): boolean;
+  abstract isBeforeYear(date: T, comparing: T): boolean;
+  abstract isEqual(date: T, comparing: T): boolean;
+  abstract isSameDay(date: T, comparing: T): boolean;
+  abstract isSameMonth(date: T, comparing: T): boolean;
+  abstract isSameYear(date: T, comparing: T): boolean;
+  abstract isSameHour(date: T, comparing: T): boolean;
+  abstract isWithinRange(date: T, range: [T, T]): boolean;
+  abstract getYear(date: T): number;
+  abstract getMonth(date: T): number;
+  abstract getDate(date: T): number;
+  abstract getHours(date: T): number;
+  abstract getMinutes(date: T): number;
+  abstract getSeconds(date: T): number;
+  /** @param comparing - Can be T or ISO string */
+  abstract getDiff(date: T, comparing: T | string, unit?: string): number;
+  /** @param minimalDays - Minimum days in first week for it to count as week 1 */
+  abstract getWeek(date: T, minimalDays?: number): number;
+  /** Get number of days in the month */
+  abstract getDaysInMonth(date: T): number;
+  abstract setYear(date: T, year: number): T;
+  abstract setMonth(date: T, month: number): T;
+  abstract setDate(date: T, day: number): T;
+  abstract setHours(date: T, hours: number): T;
+  abstract setMinutes(date: T, minutes: number): T;
+  abstract setSeconds(date: T, seconds: number): T;
+  abstract getWeekdays(weekdayFormat?: 'long' | 'short' | 'narrow'): string[];
+  abstract getWeekArray(date: T): T[][];
+  /** Get array of months in a year (12 dates, one for each month) */
+  abstract getMonthArray(date: T): T[];
+  /** Get array of years between start and end dates */
+  abstract getYearRange(start: T, end: T): T[];
+  abstract getNextMonth(date: T): T;
+  abstract getPreviousMonth(date: T): T;
+  /** Merge date from one value with time from another */
+  abstract mergeDateAndTime(date: T, time: T): T;
+}
+//#endregion
+export { DateAdapter as t };

package/dist/adapter-BEJXp-ie.d.mts

@@ -0,0 +1,11 @@
+//#region src/composables/useLogger/adapters/adapter.d.ts
+declare abstract class LoggerAdapter {
+  abstract debug(message: string, ...args: unknown[]): void;
+  abstract info(message: string, ...args: unknown[]): void;
+  abstract warn(message: string, ...args: unknown[]): void;
+  abstract 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-BFSJsyv7.mjs

@@ -0,0 +1,481 @@
+import { clamp, isArray, isNaN, isNullOrUndefined, isNumber, isObject, isString, range } from "./utilities/index.mjs";
+import { i as useContext, t as createTrinity } from "./createTrinity-BTCs1pYx.mjs";
+import { t as toArray } from "./toArray-CD2-OxAz.mjs";
+import { computed, isRef, shallowRef, toRef, toValue } from "vue";
+//#region src/composables/createFilter/index.ts
+/**
+* @module createFilter
+*
+* @see https://0.vuetifyjs.com/composables/data/create-filter
+*
+* @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.
+*
+* @example
+* ```ts
+* import { createFilter } from '@vuetify/v0'
+*
+* const filter = createFilter({ mode: 'some' })
+* const { items } = filter.apply('an', ['apple', 'banana', 'cherry'])
+* console.log(items.value) // ['banana']
+* ```
+*/
+function defaultFilter(query, item, keys, mode = "some") {
+	const queries = (/* @__PURE__ */ 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 queries.some((q) => stringValues.some((val) => val.includes(q)));
+	if (mode === "every") return queries.every((q) => stringValues.every((val) => val.includes(q)));
+	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/data/create-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 = shallowRef("");
+	function apply(_query, items) {
+		return { items: computed(() => {
+			const q = toValue(_query);
+			query.value = q;
+			const queries = (/* @__PURE__ */ toArray(q)).filter((q) => String(q).trim());
+			if (queries.length === 0) return toValue(items);
+			const queryParam = queries.length === 1 ? queries[0] : queries;
+			return toValue(items).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/data/create-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;
+	return createTrinity(namespace, createFilter(options));
+}
+/**
+* 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/data/create-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/createPagination/index.ts
+/**
+* @module createPagination
+*
+* @see https://0.vuetifyjs.com/composables/data/create-pagination
+*
+* @remarks
+* Lightweight pagination composable for navigating through pages.
+*
+* Key features:
+* - No registry overhead - just a bounded integer
+* - Direct ref support for v-model compatibility
+* - Navigation methods: next, prev, first, last
+* - Computed visible items with ellipsis
+* - Trinity pattern for dependency injection
+*
+* Unlike registry-based composables, pagination tracks a single number
+* within a range, making it efficient for large page counts.
+*
+* @example
+* ```ts
+* import { createPagination } from '@vuetify/v0'
+*
+* const pagination = createPagination({ size: 100, itemsPerPage: 10 })
+* pagination.next()
+* console.log(pagination.page.value) // 2
+* ```
+*/
+/**
+* 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
+* ```
+*/
+function createPagination(_options = {}) {
+	const { page: _page = 1, itemsPerPage: _itemsPerPage = 10, size: _size = 0, visible: _visible = 7, ellipsis = "..." } = _options;
+	const _raw = isRef(_page) ? _page : shallowRef(_page);
+	const pages = computed(() => {
+		const size = toValue(_size);
+		const perPage = toValue(_itemsPerPage);
+		if (size <= 0 || /* @__PURE__ */ isNaN(size)) return 0;
+		return Math.ceil(size / perPage);
+	});
+	const page = computed({
+		get: () => {
+			const p = pages.value;
+			return p > 0 ? /* @__PURE__ */ clamp(_raw.value, 1, p) : _raw.value;
+		},
+		set: (v) => {
+			_raw.value = v;
+		}
+	});
+	function first() {
+		page.value = 1;
+	}
+	function last() {
+		page.value = Math.max(1, pages.value);
+	}
+	function next() {
+		if (page.value < pages.value) page.value++;
+	}
+	function prev() {
+		if (page.value > 1) page.value--;
+	}
+	function select(value) {
+		if (value < 1) page.value = 1;
+		else if (value > pages.value) page.value = Math.max(1, pages.value);
+		else page.value = value;
+	}
+	const isFirst = toRef(() => page.value <= 1);
+	const isLast = toRef(() => page.value >= pages.value);
+	const pageStart = toRef(() => (page.value - 1) * toValue(_itemsPerPage));
+	const pageStop = toRef(() => Math.min(pageStart.value + toValue(_itemsPerPage), toValue(_size)));
+	function toPage(value) {
+		return {
+			type: "page",
+			value
+		};
+	}
+	function toEllipsis() {
+		return ellipsis === false ? false : {
+			type: "ellipsis",
+			value: ellipsis
+		};
+	}
+	function filter(array) {
+		return array.filter((item) => item !== false);
+	}
+	return {
+		page,
+		ellipsis,
+		items: computed(() => {
+			const pageCount = pages.value;
+			const visible = toValue(_visible);
+			const current = page.value;
+			if (pageCount <= 0 || /* @__PURE__ */ isNaN(pageCount) || pageCount > Number.MAX_SAFE_INTEGER) return [];
+			if (visible <= 0) return [];
+			if (visible <= 2) return [toPage(current)];
+			if (pageCount <= visible) return (/* @__PURE__ */ range(pageCount, 1)).map(toPage);
+			if (visible === 3) {
+				const mid = current <= 1 ? 2 : current >= pageCount ? pageCount - 1 : current;
+				return [
+					toPage(1),
+					toPage(mid),
+					toPage(pageCount)
+				];
+			}
+			const boundary = visible - 2;
+			const middle = visible - 4;
+			if (middle <= 0) {
+				if (current <= boundary) return filter([
+					...(/* @__PURE__ */ range(boundary, 1)).map(toPage),
+					toEllipsis(),
+					toPage(pageCount)
+				]);
+				if (current > pageCount - boundary) return filter([
+					toPage(1),
+					toEllipsis(),
+					...(/* @__PURE__ */ range(boundary, pageCount - boundary + 1)).map(toPage)
+				]);
+				return current <= Math.ceil(pageCount / 2) ? filter([
+					toPage(1),
+					toPage(current),
+					toEllipsis(),
+					toPage(pageCount)
+				]) : filter([
+					toPage(1),
+					toEllipsis(),
+					toPage(current),
+					toPage(pageCount)
+				]);
+			}
+			const leftThreshold = boundary - 1;
+			const rightThreshold = pageCount - boundary + 2;
+			if (current <= leftThreshold) return filter([
+				...(/* @__PURE__ */ range(boundary, 1)).map(toPage),
+				toEllipsis(),
+				toPage(pageCount)
+			]);
+			else if (current >= rightThreshold) return filter([
+				toPage(1),
+				toEllipsis(),
+				...(/* @__PURE__ */ range(boundary, pageCount - boundary + 1)).map(toPage)
+			]);
+			else {
+				const start = current - Math.floor(middle / 2);
+				return filter([
+					toPage(1),
+					toEllipsis(),
+					...(/* @__PURE__ */ range(middle, start)).map(toPage),
+					toEllipsis(),
+					toPage(pageCount)
+				]);
+			}
+		}),
+		pageStart,
+		pageStop,
+		isFirst,
+		isLast,
+		first,
+		last,
+		next,
+		prev,
+		select,
+		get itemsPerPage() {
+			return toValue(_itemsPerPage);
+		},
+		get size() {
+			return toValue(_size);
+		},
+		get pages() {
+			return pages.value;
+		}
+	};
+}
+/**
+* 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()
+* ```
+*/
+function createPaginationContext(_options = {}) {
+	const { namespace = "v0:pagination", ...options } = _options;
+	return createTrinity(namespace, createPagination(options));
+}
+/**
+* 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>
+* ```
+*/
+function usePagination(namespace = "v0:pagination") {
+	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 subclass DataTableAdapter directly.
+*/
+function getNestedValue(obj, parts) {
+	let result = obj;
+	for (const k of parts) {
+		if (/* @__PURE__ */ isNullOrUndefined(result)) return void 0;
+		result = result[k];
+	}
+	return result;
+}
+function compareValues(a, b, collator) {
+	if (a === b) return 0;
+	const aNil = /* @__PURE__ */ isNullOrUndefined(a);
+	const bNil = /* @__PURE__ */ isNullOrUndefined(b);
+	if (aNil && bNil) return 0;
+	if (aNil) return 1;
+	if (bNil) return -1;
+	if (/* @__PURE__ */ isString(a) && /* @__PURE__ */ isString(b)) return collator ? collator.compare(a, b) : a.localeCompare(b);
+	if (/* @__PURE__ */ isNumber(a) && /* @__PURE__ */ isNumber(b)) {
+		if (/* @__PURE__ */ isNaN(a)) return 1;
+		if (/* @__PURE__ */ isNaN(b)) return -1;
+		return a - b;
+	}
+	const sa = String(a);
+	const sb = String(b);
+	return collator ? collator.compare(sa, sb) : sa.localeCompare(sb);
+}
+var DataTableAdapter = class {
+	/** Create the filter pipeline stage */
+	filter(context) {
+		const filter = createFilter({
+			...context.filterOptions,
+			keys: [...toValue(context.filterableKeys)],
+			customFilter: context.filterOptions.customFilter ?? ((query, item) => {
+				const columnFilters = toValue(context.customColumnFilters);
+				const keys = toValue(context.filterableKeys);
+				if (!/* @__PURE__ */ isObject(item)) return false;
+				const q = String(/* @__PURE__ */ isArray(query) ? query[0] : query).toLowerCase();
+				if (!q) return true;
+				const obj = item;
+				for (const key of keys) {
+					const customFn = columnFilters[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;
+			})
+		});
+		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 sorts = toValue(customSorts) ?? {};
+			const collator = new Intl.Collator(locale?.value);
+			const resolved = entries.map(({ key, direction }) => ({
+				parts: key.split("."),
+				direction,
+				custom: sorts[key]
+			}));
+			return filteredItems.value.toSorted((a, b) => {
+				for (const { parts, direction, custom } of resolved) {
+					const aVal = parts.length === 1 ? a[parts[0]] : getNestedValue(a, parts);
+					const bVal = parts.length === 1 ? b[parts[0]] : getNestedValue(b, parts);
+					const cmp = custom ? custom(aVal, bVal) : compareValues(aVal, bVal, collator);
+					if (cmp !== 0) return direction === "desc" ? -cmp : cmp;
+				}
+				return 0;
+			});
+		});
+	}
+};
+//#endregion
+export { createFilter as a, usePagination as i, createPagination as n, createFilterContext as o, createPaginationContext as r, useFilter as s, DataTableAdapter as t };

package/dist/{adapter-DlX3FA3A.d.mts → adapter-BO75n0Cn.d.mts}

@@ -1,4 +1,4 @@
-import { t as ContextTrinity } from "./index-DTvqw22G.mjs";
+import { t as ContextTrinity } from "./index-H_hl6-4b.mjs";
 import * as _$vue from "vue";
 import { ComputedRef, MaybeRefOrGetter, Ref, ShallowRef, WritableComputedRef } from "vue";
 
@@ -249,8 +249,8 @@ interface DataTableAdapterContext<T extends Record<string, unknown>> {
   items: MaybeRefOrGetter<T[]>;
   /** Search query ref */
   search: ShallowRef<string>;
-  /** Column keys eligible for filtering */
-  filterableKeys: readonly string[];
+  /** Column ids eligible for filtering (reactive — tracks the columns registry) */
+  filterableKeys: MaybeRefOrGetter<readonly string[]>;
   /** Current sort state derived from sort controls */
   sortBy: Readonly<Ref<SortEntry[]>>;
   /** Locale for sorting (reactive, from useLocale or options) */
@@ -259,10 +259,10 @@ interface DataTableAdapterContext<T extends Record<string, unknown>> {
   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>>;
+  /** Per-column custom sort comparators (reactive — tracks the columns registry). Keys are column ids, which may be `keyof T` or derived strings. */
+  customSorts: MaybeRefOrGetter<Partial<Record<string, (a: unknown, b: unknown) => number>>>;
+  /** Per-column custom filter functions (reactive — tracks the columns registry). Keys are column ids, which may be `keyof T` or derived strings. */
+  customColumnFilters: MaybeRefOrGetter<Partial<Record<string, (value: unknown, query: string) => boolean>>>;
 }
 /** Outputs returned by the adapter to createDataTable */
 interface DataTableAdapterResult<T extends Record<string, unknown>> {
@@ -283,19 +283,15 @@ interface DataTableAdapterResult<T extends Record<string, unknown>> {
   /** 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> {
+declare abstract class DataTableAdapter<T extends Record<string, unknown>> {
   /** Create the filter pipeline stage */
   protected filter(context: DataTableAdapterContext<T>): {
     allItems: Readonly<Ref<T[], T[]>>;
     filteredItems: _$vue.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[]>>;
+  protected sort(filteredItems: Readonly<Ref<readonly T[]>>, sortBy: Readonly<Ref<SortEntry[]>>, locale?: Readonly<Ref<string | undefined>>, customSorts?: MaybeRefOrGetter<Partial<Record<string, (a: unknown, b: unknown) => number>>>): Readonly<Ref<readonly T[]>>;
   abstract setup(context: DataTableAdapterContext<T>): DataTableAdapterResult<T>;
 }
 //#endregion
-export { createFilter as C, 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 };
+export { createFilterContext as C, createFilter as S, FilterMode as _, SortEntry as a, FilterResult as b, PaginationOptions as c, createPaginationContext as d, usePagination as f, FilterItem as g, FilterFunction as h, SortDirection as i, PaginationTicket as l, FilterContextOptions as m, DataTableAdapterContext as n, PaginationContext as o, FilterContext as p, DataTableAdapterResult as r, PaginationContextOptions as s, DataTableAdapter as t, createPagination as u, FilterOptions as v, useFilter as w, Primitive as x, FilterQuery as y };

package/dist/adapter-BSKx9WQ7.mjs

@@ -0,0 +1,4 @@
+//#region src/composables/useFeatures/adapters/adapter.ts
+var FeaturesAdapter = class {};
+//#endregion
+export { FeaturesAdapter as t };