@vuetify/v0 0.1.2 → 0.1.4

package/dist/useTheme-Bcw1Ebyt.mjs

@@ -0,0 +1,135 @@
+import { o as createPluginContext } from "./useLogger-CO9JwbSJ.mjs";
+import { t as createTokens } from "./createTokens-BlhLdHXE.mjs";
+import { t as createSingle } from "./createSingle-B59ya3aa.mjs";
+import { t as Vuetify0ThemeAdapter } from "./v0-ONBWyQYQ.mjs";
+import { computed, shallowRef, toRef } from "vue";
+
+//#region src/composables/useTheme/index.ts
+/**
+* @module useTheme
+*
+* @see https://0.vuetifyjs.com/composables/plugins/use-theme
+*
+* @remarks
+* Theme management composable with token resolution and CSS variable injection.
+*
+* Key features:
+* - Single-selection theme switching (extends createSingle)
+* - Token alias resolution via useTokens
+* - Lazy theme loading (compute colors only when selected)
+* - CSS variable generation via adapter pattern
+* - SSR support with head integration
+* - Theme cycling
+*
+* Integrates with createSingle for selection and useTokens for color resolution.
+*/
+/**
+* Creates a new theme instance.
+*
+* @param options The options for the theme instance.
+* @template Z The type of the theme ticket.
+* @template E The type of the theme context.
+* @returns A new theme instance.
+*
+* @see https://0.vuetifyjs.com/composables/plugins/use-theme
+*
+* @example
+* ```ts
+* import { createTheme } from '@vuetify/v0'
+*
+* export const [useTheme, provideTheme] = createTheme({
+*   namespace: 'v0:theme',
+*   default: 'light',
+*   themes: {
+*     light: {
+*       dark: false,
+*       colors: {
+*         primary: '#3b82f6',
+*       },
+*     },
+*     dark: {
+*       dark: true,
+*       colors: {
+*         primary: '#675496',
+*       },
+*     },
+*   },
+* })
+* ```
+*/
+function createTheme(_options = {}) {
+	const { themes = {}, palette = {}, ...options } = _options;
+	const tokens = createTokens({
+		palette,
+		...themes
+	}, { flat: true });
+	const registry = createSingle(options);
+	for (const id in themes) {
+		const { colors: value, ...theme } = themes[id];
+		register({
+			id,
+			value,
+			...theme
+		});
+		if (id === options.default && !registry.selectedId.value) registry.select(id);
+	}
+	const names = computed(() => registry.keys());
+	const colors = computed(() => {
+		const resolved = {};
+		for (const theme of registry.values()) {
+			if (theme.lazy && theme.id !== registry.selectedId.value) continue;
+			resolved[theme.id] = resolve(theme.value);
+		}
+		return resolved;
+	});
+	const isDark = toRef(() => registry.selectedItem.value?.dark ?? false);
+	function cycle(themes$1 = names.value) {
+		const current = themes$1.indexOf(registry.selectedId.value ?? "");
+		const next = current === -1 ? 0 : (current + 1) % themes$1.length;
+		registry.select(themes$1[next]);
+	}
+	function resolve(colors$1) {
+		const resolved = {};
+		for (const [key, value] of Object.entries(colors$1)) resolved[key] = tokens.isAlias(value) ? tokens.resolve(value) : value;
+		return resolved;
+	}
+	function register(registration = {}) {
+		const item = {
+			lazy: false,
+			dark: false,
+			...registration
+		};
+		return registry.register(item);
+	}
+	function onboard(registrations) {
+		return registry.batch(() => registrations.map((registration) => register(registration)));
+	}
+	return {
+		...registry,
+		colors,
+		isDark,
+		register,
+		onboard,
+		cycle,
+		get size() {
+			return registry.size;
+		}
+	};
+}
+function createThemeFallback() {
+	return {
+		size: 0,
+		colors: computed(() => ({})),
+		isDark: shallowRef(false),
+		cycle: () => {}
+	};
+}
+const [createThemeContext, createThemePlugin, useTheme] = createPluginContext("v0:theme", (options) => createTheme(options), {
+	fallback: () => createThemeFallback(),
+	setup: (context, app, { adapter = new Vuetify0ThemeAdapter(), target }) => {
+		adapter.setup(app, context, target);
+	}
+});
+
+//#endregion
+export { useTheme as i, createThemeContext as n, createThemePlugin as r, createTheme as t };

package/dist/utilities/index.d.mts

@@ -1,3 +1,3 @@
-import "../index-DlxrzbvZ.mjs";
-import { _ as mergeDeep, a as isArray, c as isNaN, d as isNumber, f as isObject, g as isUndefined, h as isSymbol, i as debounce, l as isNull, m as isString, n as instanceName, o as isBoolean, p as isPrimitive, r as clamp, s as isFunction, t as instanceExists, u as isNullOrUndefined, v as range, y as useId } from "../index-CoO8LW8o.mjs";
-export { clamp, debounce, instanceExists, instanceName, isArray, isBoolean, isFunction, isNaN, isNull, isNullOrUndefined, isNumber, isObject, isPrimitive, isString, isSymbol, isUndefined, mergeDeep, range, useId };
+import "../index-BFBN5Zl3.mjs";
+import { _ as isUndefined, a as isArray, b as useId, c as isFunction, d as isNullOrUndefined, f as isNumber, g as isSymbol, h as isString, i as debounce, l as isNaN, m as isPrimitive, n as instanceName, o as isBoolean, p as isObject, r as clamp, s as isElement, t as instanceExists, u as isNull, v as mergeDeep, y as range } from "../index-UNwEBkQT.mjs";
+export { clamp, debounce, instanceExists, instanceName, isArray, isBoolean, isElement, isFunction, isNaN, isNull, isNullOrUndefined, isNumber, isObject, isPrimitive, isString, isSymbol, isUndefined, mergeDeep, range, useId };

package/dist/utilities/index.mjs

@@ -1,3 +1,4 @@
-import { _ as useId, a as isFunction, c as isNullOrUndefined, d as isPrimitive, f as isString, g as range, h as mergeDeep, i as isBoolean, l as isNumber, m as isUndefined, n as debounce, o as isNaN, p as isSymbol, r as isArray, s as isNull, t as clamp, u as isObject, v as instanceExists, y as instanceName } from "../utilities-B58TiS_S.mjs";
+import "../globals-B_GVfG06.mjs";
+import { _ as range, a as isElement, b as instanceName, c as isNull, d as isObject, f as isPrimitive, g as mergeDeep, h as isUndefined, i as isBoolean, l as isNullOrUndefined, m as isSymbol, n as debounce, o as isFunction, p as isString, r as isArray, s as isNaN, t as clamp, u as isNumber, v as useId, y as instanceExists } from "../utilities-BqS1sC1W.mjs";
 
-export { clamp, debounce, instanceExists, instanceName, isArray, isBoolean, isFunction, isNaN, isNull, isNullOrUndefined, isNumber, isObject, isPrimitive, isString, isSymbol, isUndefined, mergeDeep, range, useId };
+export { clamp, debounce, instanceExists, instanceName, isArray, isBoolean, isElement, isFunction, isNaN, isNull, isNullOrUndefined, isNumber, isObject, isPrimitive, isString, isSymbol, isUndefined, mergeDeep, range, useId };

package/dist/{utilities-B58TiS_S.mjs → utilities-BqS1sC1W.mjs}

@@ -1,3 +1,4 @@
+import { t as IN_BROWSER } from "./globals-B_GVfG06.mjs";
 import * as Vue from "vue";
 import { useId } from "vue";
 
@@ -28,6 +29,13 @@ function instanceName() {
 //#endregion
 //#region src/utilities/helpers.ts
 /**
+* @module utilities/helpers
+*
+* @remarks
+* Collection of utility functions for type checking, object manipulation,
+* and common transformations. All exports are tree-shakeable.
+*/
+/**
 * Checks if a value is a function
 *
 * @param item The value to check
@@ -138,6 +146,23 @@ function isArray(item) {
 	return Array.isArray(item);
 }
 /**
+* Checks if a value is a DOM Element
+*
+* @param item The value to check
+* @returns True if the value is a DOM Element
+*
+* @example
+* ```ts
+* isElement(document.body) // true
+* isElement('string')      // false
+* isElement(null)          // false
+* ```
+*/
+/* @__NO_SIDE_EFFECTS__ */
+function isElement(item) {
+	return item instanceof Element;
+}
+/**
 * Checks if a value is null
 *
 * @param item The value to check
@@ -328,6 +353,7 @@ let idCounter = 0;
 /* @__NO_SIDE_EFFECTS__ */
 function useId$1() {
 	if (instanceExists()) return useId();
+	if (!/* @__PURE__ */ isUndefined(process.env.NODE_ENV !== "production") && process.env.NODE_ENV !== "production" && !IN_BROWSER) console.warn("[v0 warn] useId() called outside component context during SSR. Provide explicit ID to avoid hydration mismatch.");
 	return `v0-${idCounter++}`;
 }
 /**
@@ -400,4 +426,4 @@ function debounce(fn, delay) {
 }
 
 //#endregion
-export { useId$1 as _, isFunction as a, isNullOrUndefined as c, isPrimitive as d, isString as f, range as g, mergeDeep as h, isBoolean as i, isNumber as l, isUndefined as m, debounce as n, isNaN as o, isSymbol as p, isArray as r, isNull as s, clamp as t, isObject as u, instanceExists as v, instanceName as y };
+export { range as _, isElement as a, instanceName as b, isNull as c, isObject as d, isPrimitive as f, mergeDeep as g, isUndefined as h, isBoolean as i, isNullOrUndefined as l, isSymbol as m, debounce as n, isFunction as o, isString as p, isArray as r, isNaN as s, clamp as t, isNumber as u, useId$1 as v, instanceExists as y };

package/dist/v0-B40YkIQ-.mjs

@@ -0,0 +1,21 @@
+import { o as isFunction } from "./utilities-BqS1sC1W.mjs";
+
+//#region src/composables/usePermissions/adapters/adapter.ts
+var PermissionAdapter = class {};
+
+//#endregion
+//#region src/composables/usePermissions/adapters/v0.ts
+var Vuetify0PermissionAdapter = class extends PermissionAdapter {
+	constructor() {
+		super();
+	}
+	can(role, action, subject, context, permissions) {
+		const access = `${role}.${action}.${subject}`;
+		const ticket = permissions.get(access);
+		if (!ticket || !ticket.value) return false;
+		return /* @__PURE__ */ isFunction(ticket.value) ? ticket.value(context) : ticket.value;
+	}
+};
+
+//#endregion
+export { PermissionAdapter as n, Vuetify0PermissionAdapter as t };

package/dist/v0-BOxb3nD1.d.mts

@@ -0,0 +1,33 @@
+import { t as LoggerAdapter } from "./adapter-CJIj5ySf.mjs";
+
+//#region src/composables/useLogger/adapters/v0.d.ts
+
+/**
+ * Vuetify0.x logger adapter implementation
+ *
+ * This adapter provides console-based logging with proper formatting,
+ * color coding, timestamps, and log level filtering for development
+ * and production environments.
+ */
+declare class Vuetify0LoggerAdapter implements LoggerAdapter {
+  private prefix;
+  private colors;
+  private timestamps;
+  constructor(options?: {
+    prefix?: string;
+    colors?: boolean;
+    timestamps?: boolean;
+  });
+  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;
+  private format;
+  private timestamp;
+  private style;
+  private log;
+}
+//#endregion
+export { Vuetify0LoggerAdapter as t };

package/dist/v0-BogbIzpM.mjs

@@ -0,0 +1,41 @@
+import { t as createPagination } from "./createPagination-cyOWlpfH.mjs";
+import { t as DataTableAdapter } from "./adapter-D_0ptsPm.mjs";
+import { computed, toRef, watch } from "vue";
+
+//#region src/composables/createDataTable/adapters/v0.ts
+/**
+* @module createDataTable/adapters/v0
+*
+* @remarks
+* Default data table adapter that performs all pipeline operations client-side:
+* filtering via createFilter, sorting via computed comparisons, and pagination
+* via createPagination. Automatically resets to page 1 on filter/sort changes.
+*/
+var ClientAdapter = class extends DataTableAdapter {
+	setup(context) {
+		const { search, sortBy, locale, paginationOptions, customSorts } = context;
+		const { allItems, filteredItems } = this.filter(context);
+		const sortedItems = this.sort(filteredItems, sortBy, locale, customSorts);
+		const pagination = createPagination({
+			...paginationOptions,
+			size: toRef(() => sortedItems.value.length)
+		});
+		const items = computed(() => {
+			return sortedItems.value.slice(pagination.pageStart.value, pagination.pageStop.value);
+		});
+		watch([search, sortBy], () => {
+			pagination.first();
+		});
+		return {
+			allItems,
+			filteredItems,
+			sortedItems,
+			items,
+			pagination,
+			total: toRef(() => sortedItems.value.length)
+		};
+	}
+};
+
+//#endregion
+export { ClientAdapter as t };

package/dist/v0-BtQCSBOG.mjs

@@ -0,0 +1,37 @@
+import { t as IN_BROWSER } from "./globals-B_GVfG06.mjs";
+import { d as isObject, h as isUndefined } from "./utilities-BqS1sC1W.mjs";
+
+//#region src/composables/useLocale/adapters/v0.ts
+/**
+* Vuetify0.x locale adapter implementation
+*
+* This adapter provides translation and number formatting
+* capabilities using the Intl API and supports both
+* numbered ({0}, {1}) and named ({name}) variables in translation strings.
+*/
+var Vuetify0LocaleAdapter = class {
+	t(message, ...params) {
+		let resolvedMessage = message;
+		if (params.length > 0 && /* @__PURE__ */ isObject(params[0])) {
+			const variables = params[0];
+			resolvedMessage = resolvedMessage.replace(/{([a-zA-Z][a-zA-Z0-9_]*)}/g, (match, name) => {
+				return /* @__PURE__ */ isUndefined(variables[name]) ? match : String(variables[name]);
+			});
+			params = params.slice(1);
+		}
+		resolvedMessage = resolvedMessage.replace(/\{(\d+)\}/g, (match, index) => {
+			const idx = Number.parseInt(index, 10);
+			if (!/* @__PURE__ */ isUndefined(params[idx])) return String(params[idx]);
+			return match;
+		});
+		return resolvedMessage;
+	}
+	n(value, locale, ...params) {
+		if (!IN_BROWSER || !locale) return value.toString();
+		const options = params[0];
+		return new Intl.NumberFormat(String(locale), options).format(value);
+	}
+};
+
+//#endregion
+export { Vuetify0LocaleAdapter as t };

package/dist/v0-C-9dv_1S.d.mts

@@ -0,0 +1,10 @@
+import { o as ID } from "./index-BFBN5Zl3.mjs";
+import { Nt as PermissionTicket, Rt as PermissionAdapter, kt as PermissionContext } from "./index-Dd0m0LIJ.mjs";
+
+//#region src/composables/usePermissions/adapters/v0.d.ts
+declare class Vuetify0PermissionAdapter extends PermissionAdapter {
+  constructor();
+  can<Z extends PermissionTicket = PermissionTicket>(role: ID, action: string, subject: string, context: Record<string, any>, permissions: PermissionContext<Z>): boolean;
+}
+//#endregion
+export { Vuetify0PermissionAdapter as t };

package/dist/v0-CtjuUUPl.mjs

@@ -0,0 +1,73 @@
+import { t as IN_BROWSER } from "./globals-B_GVfG06.mjs";
+import { o as isFunction } from "./utilities-BqS1sC1W.mjs";
+
+//#region src/composables/useLogger/adapters/v0.ts
+/**
+* Vuetify0.x logger adapter implementation
+*
+* This adapter provides console-based logging with proper formatting,
+* color coding, timestamps, and log level filtering for development
+* and production environments.
+*/
+var Vuetify0LoggerAdapter = class {
+	prefix;
+	colors;
+	timestamps;
+	constructor(options = {}) {
+		this.prefix = options.prefix || "v0";
+		this.colors = options.colors !== false;
+		this.timestamps = options.timestamps !== false;
+	}
+	debug(message, ...args) {
+		this.log("debug", "debug", message, ...args);
+	}
+	info(message, ...args) {
+		this.log("info", "info", message, ...args);
+	}
+	warn(message, ...args) {
+		this.log("warn", "warn", message, ...args);
+	}
+	error(message, ...args) {
+		this.log("error", "error", message, ...args);
+	}
+	trace(message, ...args) {
+		this.log("trace", "trace", message, ...args);
+	}
+	fatal(message, ...args) {
+		this.log("fatal", "error", message, ...args);
+	}
+	format(level, message, ...args) {
+		return [[
+			this.timestamps ? this.timestamp() : "",
+			`[${this.prefix} ${level.toLowerCase()}]`,
+			message
+		].filter(Boolean).join(" "), ...args];
+	}
+	timestamp() {
+		if (!IN_BROWSER) return (/* @__PURE__ */ new Date()).toISOString();
+		/* v8 ignore next -- defensive fallback, toTimeString always returns valid format */
+		return (/* @__PURE__ */ new Date()).toTimeString().split(" ")[0] ?? "";
+	}
+	style(level) {
+		if (!this.colors || !IN_BROWSER) return "";
+		/* v8 ignore next -- LogLevel union is exhaustive */
+		return {
+			trace: "color: #64748b",
+			debug: "color: #3b82f6",
+			info: "color: #10b981",
+			warn: "color: #f59e0b",
+			error: "color: #ef4444",
+			fatal: "color: #dc2626; font-weight: bold",
+			silent: ""
+		}[level] || "";
+	}
+	log(level, method, message, ...args) {
+		const [formattedMessage, ...restArgs] = this.format(level, message, ...args);
+		const style = this.style(level);
+		if (IN_BROWSER && style && /* @__PURE__ */ isFunction(console[method])) console[method](`%c${formattedMessage}`, style, ...restArgs);
+		else if (/* @__PURE__ */ isFunction(console[method])) console[method](formattedMessage, ...restArgs);
+	}
+};
+
+//#endregion
+export { Vuetify0LoggerAdapter as t };

package/dist/v0-DHMoZ7dS.d.mts

@@ -0,0 +1,22 @@
+import { o as ID } from "./index-BFBN5Zl3.mjs";
+
+//#region src/composables/useLocale/adapters/adapter.d.ts
+interface LocaleAdapter {
+  t: (message: string, ...params: unknown[]) => string;
+  n: (value: number, locale: ID | undefined, ...params: unknown[]) => string;
+}
+//#endregion
+//#region src/composables/useLocale/adapters/v0.d.ts
+/**
+ * Vuetify0.x locale adapter implementation
+ *
+ * This adapter provides translation and number formatting
+ * capabilities using the Intl API and supports both
+ * numbered ({0}, {1}) and named ({name}) variables in translation strings.
+ */
+declare class Vuetify0LocaleAdapter implements LocaleAdapter {
+  t(message: string, ...params: unknown[]): string;
+  n(value: number, locale: ID | undefined, ...params: unknown[]): string;
+}
+//#endregion
+export { LocaleAdapter as n, Vuetify0LocaleAdapter as t };

package/dist/v0-ONBWyQYQ.mjs

@@ -0,0 +1,83 @@
+import { t as IN_BROWSER } from "./globals-B_GVfG06.mjs";
+import { c as isNull, h as isUndefined, p as isString } from "./utilities-BqS1sC1W.mjs";
+import { onScopeDispose, watch } from "vue";
+
+//#region src/composables/useTheme/adapters/adapter.ts
+var ThemeAdapter = class {
+	stylesheetId = "v0-theme-stylesheet";
+	prefix;
+	constructor(prefix) {
+		this.prefix = prefix;
+	}
+	generate(colors, isDark) {
+		let css = "";
+		for (const theme in colors) {
+			const themeColors = colors[theme];
+			if (!themeColors) continue;
+			const vars = Object.entries(themeColors).map(([key, val]) => `  --${this.prefix}-${key}: ${val};`).join("\n");
+			css += `[data-theme="${theme}"] {\n${vars}\n}\n`;
+		}
+		if (!/* @__PURE__ */ isUndefined(isDark)) css += `:root {\n  color-scheme: ${isDark ? "dark" : "light"};\n}\n`;
+		return css;
+	}
+};
+
+//#endregion
+//#region src/composables/useTheme/adapters/v0.ts
+/**
+* Theme adapter implementation for Vuetify v0 design system.
+* This adapter generates CSS custom properties and injects them into the DOM
+* as a stylesheet, allowing themes to be applied globally.
+*/
+var Vuetify0ThemeAdapter = class extends ThemeAdapter {
+	cspNonce;
+	sheet;
+	constructor(options = {}) {
+		super(options.prefix ?? "v0");
+		this.cspNonce = options.cspNonce;
+		this.stylesheetId = options.stylesheetId ?? this.stylesheetId;
+	}
+	setup(app, context, target) {
+		if (IN_BROWSER) {
+			this.update(context.colors.value, context.isDark.value);
+			onScopeDispose(watch([context.colors, context.isDark], ([colors, isDark]) => {
+				this.update(colors, isDark);
+			}), true);
+			if (/* @__PURE__ */ isNull(target)) return;
+			const targetEl = target instanceof HTMLElement ? target : /* @__PURE__ */ isString(target) ? document.querySelector(target) : app._container || document.querySelector("#app") || document.body;
+			if (!targetEl) return;
+			if (context.selectedId.value) targetEl.dataset.theme = String(context.selectedId.value);
+			onScopeDispose(watch(context.selectedId, (id) => {
+				if (!id) return;
+				targetEl.dataset.theme = String(id);
+			}), true);
+		} else {
+			const head = app._context?.provides?.usehead ?? app._context?.provides?.head;
+			if (head?.push) {
+				const id = context.selectedId.value;
+				head.push({
+					htmlAttrs: { "data-theme": id ? String(id) : "" },
+					style: [{
+						innerHTML: this.generate(context.colors.value, context.isDark.value),
+						id: this.stylesheetId
+					}]
+				});
+			}
+		}
+	}
+	update(colors, isDark) {
+		if (!IN_BROWSER) return;
+		this.upsert(this.generate(colors, isDark));
+	}
+	upsert(styles) {
+		if (!IN_BROWSER) return;
+		if (!this.sheet) {
+			this.sheet = new CSSStyleSheet();
+			document.adoptedStyleSheets = [...document.adoptedStyleSheets, this.sheet];
+		}
+		this.sheet.replaceSync(styles);
+	}
+};
+
+//#endregion
+export { ThemeAdapter as n, Vuetify0ThemeAdapter as t };

package/dist/v0-RepwEY1F.d.mts

@@ -0,0 +1,9 @@
+import { i as DataTableAdapterResult, n as DataTableAdapterContext, t as DataTableAdapter } from "./adapter-BN-h5JbD.mjs";
+
+//#region src/composables/createDataTable/adapters/v0.d.ts
+
+declare class ClientAdapter<T extends Record<string, unknown>> extends DataTableAdapter<T> {
+  setup(context: DataTableAdapterContext<T>): DataTableAdapterResult<T>;
+}
+//#endregion
+export { ClientAdapter as t };

package/dist/virtual-B3IPkHC0.d.mts

@@ -0,0 +1,9 @@
+import { i as DataTableAdapterResult, n as DataTableAdapterContext, t as DataTableAdapter } from "./adapter-BN-h5JbD.mjs";
+
+//#region src/composables/createDataTable/adapters/virtual.d.ts
+
+declare class VirtualAdapter<T extends Record<string, unknown>> extends DataTableAdapter<T> {
+  setup(context: DataTableAdapterContext<T>): DataTableAdapterResult<T>;
+}
+//#endregion
+export { VirtualAdapter as t };

package/dist/virtual-BP9WXRzN.mjs

@@ -0,0 +1,44 @@
+import { t as createPagination } from "./createPagination-cyOWlpfH.mjs";
+import { t as DataTableAdapter } from "./adapter-D_0ptsPm.mjs";
+import { toRef, watch } from "vue";
+
+//#region src/composables/createDataTable/adapters/virtual.ts
+/**
+* @module createDataTable/adapters/virtual
+*
+* @remarks
+* Virtual scrolling data table adapter. Performs client-side filtering
+* and sorting (via DataTableAdapter base) but skips pagination slicing,
+* returning all sorted items for use with createVirtual at the component level.
+*
+* Pagination is created with itemsPerPage matching the total item count,
+* effectively placing all items on a single page. The consumer wraps
+* `table.items` (or `table.sortedItems`) with createVirtual to render
+* only the visible viewport.
+*/
+var VirtualAdapter = class extends DataTableAdapter {
+	setup(context) {
+		const { search, sortBy, locale, customSorts } = context;
+		const { allItems, filteredItems } = this.filter(context);
+		const sortedItems = this.sort(filteredItems, sortBy, locale, customSorts);
+		const size = toRef(() => sortedItems.value.length);
+		const pagination = createPagination({
+			size,
+			itemsPerPage: size
+		});
+		watch([search, sortBy], () => {
+			pagination.first();
+		});
+		return {
+			allItems,
+			filteredItems,
+			sortedItems,
+			items: sortedItems,
+			pagination,
+			total: toRef(() => sortedItems.value.length)
+		};
+	}
+};
+
+//#endregion
+export { VirtualAdapter as t };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vuetify/v0",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "description": "Vuetify0",
   "license": "MIT",
   "main": "./dist/index.mjs",
@@ -8,7 +8,8 @@
   "types": "./dist/index.d.mts",
   "type": "module",
   "files": [
-    "dist"
+    "dist",
+    "SKILL.md"
   ],
   "repository": {
     "type": "git",
@@ -36,20 +37,52 @@
     "@vue/test-utils": "^2.4.6",
     "flagsmith": "^10.0.0",
     "launchdarkly-js-client-sdk": "^3.9.0",
-    "posthog-js": "^1.310.1",
+    "posthog-js": "1.310.1",
     "tsdown": "^0.16.8",
-    "tsx": "^4.21.0",
+    "tsx": "4.21.0",
     "typescript": "5.9.3",
     "unplugin-vue": "^7.1.0",
     "vue": "3.5.24",
     "vue-component-meta": "^3.2.2"
   },
+  "imports": {
+    "#v0/*": {
+      "development": "./src/*",
+      "default": "./dist/*"
+    }
+  },
   "exports": {
     ".": "./dist/index.mjs",
     "./components": "./dist/components/index.mjs",
     "./composables": "./dist/composables/index.mjs",
     "./constants": "./dist/constants/index.mjs",
+    "./data-table": "./dist/data-table/index.mjs",
+    "./data-table/adapters": "./dist/data-table/adapters/index.mjs",
+    "./data-table/adapters/client": "./dist/data-table/adapters/client/index.mjs",
+    "./data-table/adapters/server": "./dist/data-table/adapters/server/index.mjs",
+    "./data-table/adapters/virtual": "./dist/data-table/adapters/virtual/index.mjs",
     "./date": "./dist/date/index.mjs",
+    "./features": "./dist/features/index.mjs",
+    "./features/adapters/flagsmith": "./dist/features/adapters/flagsmith/index.mjs",
+    "./features/adapters/launchdarkly": "./dist/features/adapters/launchdarkly/index.mjs",
+    "./features/adapters/posthog": "./dist/features/adapters/posthog/index.mjs",
+    "./locale": "./dist/locale/index.mjs",
+    "./locale/adapters": "./dist/locale/adapters/index.mjs",
+    "./locale/adapters/v0": "./dist/locale/adapters/v0/index.mjs",
+    "./logger": "./dist/logger/index.mjs",
+    "./logger/adapters": "./dist/logger/adapters/index.mjs",
+    "./logger/adapters/consola": "./dist/logger/adapters/consola/index.mjs",
+    "./logger/adapters/pino": "./dist/logger/adapters/pino/index.mjs",
+    "./logger/adapters/v0": "./dist/logger/adapters/v0/index.mjs",
+    "./permissions": "./dist/permissions/index.mjs",
+    "./permissions/adapters": "./dist/permissions/adapters/index.mjs",
+    "./permissions/adapters/v0": "./dist/permissions/adapters/v0/index.mjs",
+    "./storage": "./dist/storage/index.mjs",
+    "./storage/adapters": "./dist/storage/adapters/index.mjs",
+    "./storage/adapters/memory": "./dist/storage/adapters/memory/index.mjs",
+    "./theme": "./dist/theme/index.mjs",
+    "./theme/adapters": "./dist/theme/adapters/index.mjs",
+    "./theme/adapters/v0": "./dist/theme/adapters/v0/index.mjs",
     "./types": "./dist/types/index.mjs",
     "./utilities": "./dist/utilities/index.mjs",
     "./package.json": "./package.json",