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

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
@@ -212,6 +214,7 @@ Selection management composables built on `createRegistry`:
 
 - [`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-BSKx9WQ7.mjs

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

package/dist/{index-CT5SCLzW.d.mts → adapter-C6JmOyYo.d.mts}

@@ -1,12 +1,12 @@
-import { a as ID } from "./index-DuddF-NR.mjs";
+import { a as ID } from "./index-CLR1QMM3.mjs";
 
-//#region src/composables/useFeatures/adapters/generic/index.d.ts
+//#region src/composables/useFeatures/adapters/adapter.d.ts
 type FeaturesAdapterValue = boolean | {
   $value?: boolean;
   $variation?: unknown;
 };
 type FeaturesAdapterFlags = Record<ID, FeaturesAdapterValue>;
-interface FeaturesAdapterInterface {
+declare abstract class FeaturesAdapter {
   /**
    * Initialize the adapter and return initial flags.
    *
@@ -16,16 +16,13 @@ interface FeaturesAdapterInterface {
    * @remarks Called during plugin setup. Sets up change listeners
    * and returns the initial flag values.
    */
-  setup: (onUpdate: (flags: FeaturesAdapterFlags) => void) => FeaturesAdapterFlags;
+  abstract setup(onUpdate: (flags: FeaturesAdapterFlags) => void): FeaturesAdapterFlags;
   /**
    * Cleanup adapter resources.
    *
    * @remarks Called when the plugin is disposed.
    */
-  dispose?: () => void;
-}
-declare abstract class FeaturesAdapter implements FeaturesAdapterInterface {
-  abstract setup(onUpdate: (flags: FeaturesAdapterFlags) => void): FeaturesAdapterFlags;
+  dispose?(): void;
 }
 //#endregion
-export { FeaturesAdapterValue as i, FeaturesAdapterFlags as n, FeaturesAdapterInterface as r, FeaturesAdapter as t };
+export { FeaturesAdapterFlags as n, FeaturesAdapterValue as r, FeaturesAdapter as t };

package/dist/{adapter-gQ2SNKZq.mjs → adapter-C9cR4AcY.mjs}

@@ -1,7 +1,7 @@
-import { isArray, isNaN, isNullOrUndefined, isNumber, isObject, isString } from "./utilities/index.mjs";
+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-as9BWxBK.mjs";
-import { computed, shallowRef, toRef, toValue } from "vue";
+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
@@ -140,6 +140,249 @@ 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
@@ -151,7 +394,7 @@ function useFilter(namespace = "v0:filter") {
 *
 * 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.
+* operations externally subclass DataTableAdapter directly.
 */
 function getNestedValue(obj, parts) {
 	let result = obj;
@@ -235,4 +478,4 @@ var DataTableAdapter = class {
 	}
 };
 //#endregion
-export { useFilter as i, createFilter as n, createFilterContext as r, DataTableAdapter as t };
+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-Chznb9Ju.mjs

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

package/dist/{adapter-DlX3FA3A.d.mts → adapter-Cr7Bl4la.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";
 
@@ -283,11 +283,7 @@ 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[]>>;
@@ -298,4 +294,4 @@ declare abstract class DataTableAdapter<T extends Record<string, unknown>> imple
   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-D8zizQVP.mjs

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

package/dist/adapter-DgBBe_BW.d.mts

@@ -0,0 +1,17 @@
+import { a as ID } from "./index-CLR1QMM3.mjs";
+import { c as TokenTicket, i as TokenContext } from "./index-Cw04PFVO.mjs";
+import { Ref } from "vue";
+
+//#region src/composables/useLocale/adapters/adapter.d.ts
+interface LocaleAdapterContext {
+  tokens: TokenContext<TokenTicket>;
+  selectedId: Ref<ID | null | undefined>;
+  fallbackLocale: ID | undefined;
+  has: (id: ID) => boolean;
+}
+declare abstract class LocaleAdapter {
+  abstract t(key: string, ...params: unknown[]): string;
+  abstract n(value: number): string;
+}
+//#endregion
+export { LocaleAdapterContext as n, LocaleAdapter as t };

package/dist/adapter-Dzyrlbz7.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-o8r-2vUn.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/adapters-B25KaYU4.mjs

@@ -0,0 +1,2 @@
+import "./v0-CotC1PiS.mjs";
+export {};

package/dist/adapters-BcddLSNs.mjs

@@ -0,0 +1,4 @@
+import "./adapter-oM18AdUc.mjs";
+import "./v0-DadOcxFI.mjs";
+import "./unhead-dPyVkgiJ.mjs";
+export {};

package/dist/adapters-D64TORDu.mjs

@@ -0,0 +1,2 @@
+import "./v0-Dvu8fMl3.mjs";
+export {};

package/dist/adapters-Dv74Jk6A.mjs

@@ -0,0 +1,5 @@
+import "./adapter-C9cR4AcY.mjs";
+import "./v0-DAlKpCR8.mjs";
+import "./server-ZFXbgQoY.mjs";
+import "./virtual-Dnno49F8.mjs";
+export {};

package/dist/adapters-t6QC-zE8.mjs

@@ -0,0 +1,3 @@
+import "./pino-CIcYlW3u.mjs";
+import "./v0-YJQoTLsp.mjs";
+export {};