@vuetify/v0 1.1.0 → 1.2.0

package/README.md

@@ -142,6 +142,7 @@ import { ... } from '@vuetify/v0/date'       // Date adapter and utilities
 
 | Component | Description |
 |-----------|-------------|
+| [Alert](https://0.vuetifyjs.com/components/semantic/alert) | Inline status message with ARIA live-region semantics |
 | [Avatar](https://0.vuetifyjs.com/components/semantic/avatar) | Image/fallback avatar with priority loading |
 | [Breadcrumbs](https://0.vuetifyjs.com/components/semantic/breadcrumbs) | Navigation breadcrumbs with overflow detection and truncation |
 | [Carousel](https://0.vuetifyjs.com/components/semantic/carousel) | Scroll-snap slide navigation with multi-slide display and drag/swipe |
@@ -152,6 +153,13 @@ import { ... } from '@vuetify/v0/date'       // Date adapter and utilities
 | [Snackbar](https://0.vuetifyjs.com/components/semantic/snackbar) | Toast notification with queue, positioning, and auto-dismiss |
 | [Splitter](https://0.vuetifyjs.com/components/semantic/splitter) | Resizable panel layout with drag handles |
 
+#### Data
+
+| Component | Description |
+|-----------|-------------|
+| [DataGrid](https://0.vuetifyjs.com/components/data/data-grid) | Headless data grid with column layout, cell editing, row ordering, and row spanning |
+| [DataTable](https://0.vuetifyjs.com/components/data/data-table) | Headless table with sorting, pagination, selection, and expansion |
+
 ### Composables
 
 #### Foundation

package/dist/{adapter-Butx_2UU.d.mts → adapter-BXunW_mw.d.mts}

@@ -1,4 +1,4 @@
-import { a as ID } from "./index-CyNk9FpR.mjs";
+import { a as ID } from "./index-DtiaWx5U.mjs";
 
 //#region src/composables/useFeatures/adapters/adapter.d.ts
 type FeaturesAdapterValue = boolean | {

package/dist/{createPagination-B5dfqY-a.mjs → adapter-BiQV5j8B.mjs}

@@ -1,6 +1,6 @@
-import { clamp, isNaN, isObject, range } 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-z-3q9QWR.mjs";
-import { t as toArray } from "./toArray-C89ZaEuF.mjs";
+import { t as toArray } from "./toArray-MY9Kb1Qy.mjs";
 import { computed, isRef, shallowRef, toRef, toValue } from "vue";
 //#region src/composables/createFilter/index.ts
 /**
@@ -383,4 +383,99 @@ function usePagination(namespace = "v0:pagination") {
 	return useContext(namespace);
 }
 //#endregion
-export { createFilterContext as a, createFilter as i, createPaginationContext as n, useFilter as o, usePagination as r, createPagination as t };
+//#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: filtered } = filter.apply(context.search, allItems);
+		return {
+			allItems,
+			filteredItems: filtered
+		};
+	}
+	/** 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-ClB-53_F.d.mts

@@ -0,0 +1,62 @@
+import { Ref } from "vue";
+
+//#region src/composables/usePopover/adapters/adapter.d.ts
+type PopoverSide = 'top' | 'bottom' | 'left' | 'right';
+type PopoverAlign = 'start' | 'center' | 'end';
+interface PopoverPlacement {
+  /** Which side of the anchor the content prefers to render on. */
+  side: PopoverSide;
+  /** Alignment along that side, relative to the anchor. */
+  align: PopoverAlign;
+  /**
+   * The `position-area` value this placement was derived from, verbatim.
+   * `side`/`align` are a best-effort normalization of the common cases
+   * (single keyword, or a keyword plus a `span-*`/`start`/`end` modifier) -
+   * `raw` is the escape hatch for compound values the normalization doesn't
+   * cover, and is what the default adapter renders back into CSS.
+   */
+  raw: string;
+}
+interface PopoverAdapterContext {
+  /** CSS anchor-name custom ident (e.g. `--popover-abc123`). */
+  anchorName: string;
+  /** The activator/reference element, once registered via `attachAnchor()`. */
+  anchorEl: Readonly<Ref<Element | null | undefined>>;
+  /** The content/floating element, once registered via `attach()`. */
+  contentEl: Readonly<Ref<HTMLElement | null | undefined>>;
+  /** Whether the popover is currently open. */
+  isOpen: Readonly<Ref<boolean>>;
+  /** Normalized placement intent, derived from the `positionArea` option. */
+  placement: Readonly<Ref<PopoverPlacement>>;
+  /** The `positionTry` option, verbatim - CSS `position-try-fallbacks` passthrough. */
+  positionTry: Readonly<Ref<string>>;
+}
+/**
+ * Positioning engine seam for `usePopover`. `V0PopoverAdapter` (the default)
+ * emits CSS anchor positioning and needs nothing installed. A consumer who
+ * wants a JS positioning library (floating-ui, Popper, or their own) extends
+ * this class and passes an instance via the `adapter` option.
+ *
+ * @see https://0.vuetifyjs.com/composables/system/use-popover
+ */
+declare abstract class PopoverAdapter {
+  /**
+   * Optional instance teardown; read lazily when the popover's scope disposes.
+   * Plugin-shared adapters must put per-popover cleanup in `setup()` +
+   * `onScopeDispose`, never `this.dispose` — assigning `dispose` on a shared
+   * instance clobbers the previous popover's teardown when `setup()` is
+   * re-entered. First-party `FloatingUIPopoverAdapter` already follows this.
+   */
+  dispose?: () => void;
+  /**
+   * Called once, synchronously, during `usePopover()` setup. Returns the
+   * reactive style object to spread onto the content element. Implementations
+   * that need to react to `isOpen`, `placement`, or the anchor/content
+   * elements becoming available should watch `context`'s refs themselves -
+   * `anchorEl`/`contentEl` populate asynchronously, after `attachAnchor()` /
+   * `attach()` run in the consuming component.
+   */
+  abstract setup(context: PopoverAdapterContext): Readonly<Ref<Record<string, string>>>;
+}
+//#endregion
+export { PopoverSide as a, PopoverPlacement as i, PopoverAdapterContext as n, PopoverAlign as r, PopoverAdapter as t };

package/dist/{adapter-hq9YlPOF.d.mts → adapter-CqS8xexO.d.mts}

@@ -1,5 +1,5 @@
-import { a as ID } from "./index-CyNk9FpR.mjs";
-import { c as TokenTicket, i as TokenContext } from "./index-QnpcDsV7.mjs";
+import { a as ID } from "./index-DtiaWx5U.mjs";
+import { c as TokenTicket, i as TokenContext } from "./index-D0ub61GV.mjs";
 import { Ref } from "vue";
 
 //#region src/composables/useLocale/adapters/adapter.d.ts

package/dist/adapter-CrRJuxRk.mjs

@@ -0,0 +1,21 @@
+//#region src/composables/usePopover/adapters/adapter.ts
+/**
+* Positioning engine seam for `usePopover`. `V0PopoverAdapter` (the default)
+* emits CSS anchor positioning and needs nothing installed. A consumer who
+* wants a JS positioning library (floating-ui, Popper, or their own) extends
+* this class and passes an instance via the `adapter` option.
+*
+* @see https://0.vuetifyjs.com/composables/system/use-popover
+*/
+var PopoverAdapter = class {
+	/**
+	* Optional instance teardown; read lazily when the popover's scope disposes.
+	* Plugin-shared adapters must put per-popover cleanup in `setup()` +
+	* `onScopeDispose`, never `this.dispose` — assigning `dispose` on a shared
+	* instance clobbers the previous popover's teardown when `setup()` is
+	* re-entered. First-party `FloatingUIPopoverAdapter` already follows this.
+	*/
+	dispose;
+};
+//#endregion
+export { PopoverAdapter as t };

package/dist/{adapter-_srNCBEi.d.mts → adapter-PDTe5nFT.d.mts}

@@ -1,5 +1,4 @@
-import { t as ContextTrinity } from "./index-DXMlYoiQ.mjs";
-import * as _$vue from "vue";
+import { t as ContextTrinity } from "./index-H_hl6-4b.mjs";
 import { ComputedRef, MaybeRefOrGetter, Ref, ShallowRef, WritableComputedRef } from "vue";
 
 //#region src/composables/createFilter/index.d.ts
@@ -244,7 +243,7 @@ interface SortEntry {
   direction: SortDirection;
 }
 /** Inputs provided by createDataTable to the adapter */
-interface DataTableAdapterContext<T extends Record<string, unknown>> {
+interface DataTableAdapterContext<T extends object> {
   /** Source items */
   items: MaybeRefOrGetter<T[]>;
   /** Search query ref */
@@ -265,7 +264,7 @@ interface DataTableAdapterContext<T extends Record<string, unknown>> {
   customColumnFilters: MaybeRefOrGetter<Partial<Record<string, (value: unknown, query: string) => boolean>>>;
 }
 /** Outputs returned by the adapter to createDataTable */
-interface DataTableAdapterResult<T extends Record<string, unknown>> {
+interface DataTableAdapterResult<T extends object> {
   /** Raw unprocessed items */
   allItems: Readonly<Ref<readonly T[]>>;
   /** Items after filtering */
@@ -283,11 +282,11 @@ interface DataTableAdapterResult<T extends Record<string, unknown>> {
   /** Error state (optional, for async adapters) */
   error?: Readonly<Ref<Error | null>>;
 }
-declare abstract class DataTableAdapter<T extends Record<string, unknown>> {
+declare abstract class DataTableAdapter<T extends object> {
   /** Create the filter pipeline stage */
   protected filter(context: DataTableAdapterContext<T>): {
-    allItems: Readonly<Ref<T[], T[]>>;
-    filteredItems: _$vue.ComputedRef<T[]>;
+    allItems: Readonly<Ref<T[]>>;
+    filteredItems: Readonly<Ref<readonly T[]>>;
   };
   /** Create the sort pipeline stage */
   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[]>>;