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

package/dist/{index-BJGcVy7e.d.mts → index-BmEu85PI.d.mts}

@@ -1,7 +1,8 @@
-import { a as ID } from "./index-DuddF-NR.mjs";
-import { t as ContextTrinity } from "./index-DTvqw22G.mjs";
-import { a as SortDirection, l as PaginationOptions, o as SortEntry, r as DataTableAdapterInterface, s as PaginationContext, y as FilterOptions } from "./adapter-DlX3FA3A.mjs";
-import { MaybeRefOrGetter, Ref, ShallowRef } from "vue";
+import { a as ID, i as Extensible } from "./index-CLR1QMM3.mjs";
+import { t as ContextTrinity } from "./index-H_hl6-4b.mjs";
+import { c as RegistryTicketInput, s as RegistryTicket, t as RegistryContext } from "./index-C0ewabdY.mjs";
+import { a as SortEntry, c as PaginationOptions, i as SortDirection, o as PaginationContext, t as DataTableAdapter, v as FilterOptions } from "./adapter-BO75n0Cn.mjs";
+import { Ref, ShallowRef } from "vue";
 
 //#region src/composables/createDataTable/columns.d.ts
 /**
@@ -10,15 +11,15 @@ import { MaybeRefOrGetter, Ref, ShallowRef } from "vue";
  * @remarks
  * Utilities for resolving recursive column definitions into flat leaf
  * columns and 2D header grids. Used by createDataTable for header
- * rendering and by createDataGrid for column layout.
+ * rendering.
  */
 interface ColumnNode {
-  readonly key: string;
+  readonly id: string;
   readonly title?: string;
   readonly children?: readonly ColumnNode[];
 }
 interface InternalHeader {
-  key: string;
+  id: string;
   title: string;
   colspan: number;
   rowspan: number;
@@ -50,31 +51,86 @@ declare function computeDepth(columns: readonly ColumnNode[]): number;
 declare function resolveHeaders(columns: readonly ColumnNode[]): InternalHeader[][];
 //#endregion
 //#region src/composables/createDataTable/index.d.ts
-/** Extract keys of T whose value type extends V */
-type KeysOfType<T, V> = { [K in keyof T]: T[K] extends V ? K : never }[keyof T] & string;
 type SelectStrategy = 'single' | 'page' | 'all';
-interface DataTableColumn<T extends Record<string, unknown> = Record<string, unknown>> {
-  readonly key: string;
-  readonly title?: string;
-  readonly sortable?: boolean;
-  readonly filterable?: boolean;
-  /** Custom sort comparator for this column */
-  readonly sort?: (a: unknown, b: unknown) => number;
-  /** Custom filter function for this column */
-  readonly filter?: (value: unknown, query: string) => boolean;
-  readonly children?: readonly DataTableColumn<T>[];
+/**
+ * Input shape passed to `register` / `onboard` on a data table's row registry.
+ *
+ * @template T Row value type.
+ *
+ * @example
+ * ```ts
+ * const table = createDataTable<User>()
+ * table.register({ id: user.id, value: user })
+ * ```
+ */
+type DataTableTicketInput<T extends Record<string, unknown>> = RegistryTicketInput<T>;
+/**
+ * Output ticket returned by row `register` / `onboard` / `get`.
+ *
+ * @template T Row value type.
+ */
+type DataTableTicket<T extends Record<string, unknown>> = RegistryTicket<T> & DataTableTicketInput<T>;
+/**
+ * Input shape passed to `table.columns.register` / `table.columns.onboard`.
+ *
+ * `id` is required and acts as the column identifier — selection, sort, and
+ * filter all key off it. The `Extensible<keyof T & string>` shape preserves
+ * autocomplete for the row's own keys while still accepting arbitrary strings
+ * for derived columns (computed totals, action columns, etc.).
+ *
+ * @template T Row value type.
+ *
+ * @example
+ * ```ts
+ * import { createDataTable } from '@vuetify/v0'
+ *
+ * interface User { id: number, name: string, email: string }
+ *
+ * const table = createDataTable<User>()
+ * table.columns.register({ id: 'name', title: 'Name', sortable: true })
+ * table.columns.register({
+ *   id: 'actions',
+ *   title: '',
+ *   sortable: false,
+ * })
+ * ```
+ */
+interface DataTableColumnTicketInput<T extends Record<string, unknown> = Record<string, unknown>> extends RegistryTicketInput {
+  /** Column identifier. Required — selection / sort / filter all key off it. */
+  id: Extensible<keyof T & string>;
+  /** Display title rendered in the header cell. */
+  title?: string;
+  /** Allow this column to participate in the sort pipeline. */
+  sortable?: boolean;
+  /** Allow this column to participate in the filter pipeline. */
+  filterable?: boolean;
+  /** Custom per-column sort comparator. */
+  sort?: (a: unknown, b: unknown) => number;
+  /** Custom per-column filter predicate. */
+  filter?: (value: unknown, query: string) => boolean;
+  /** Header-group children (recursive). Children are NOT separately registered. */
+  children?: readonly DataTableColumnTicketInput<T>[];
 }
+/**
+ * Output ticket returned by `table.columns.register` / `table.columns.onboard`.
+ *
+ * Combines the standard registry ticket fields (`index`, `valueIsIndex`,
+ * `unregister`) with the column-shape fields from {@link DataTableColumnTicketInput}.
+ *
+ * @template T Row value type.
+ */
+type DataTableColumnTicket<T extends Record<string, unknown> = Record<string, unknown>> = RegistryTicket<DataTableColumnTicketInput<T>['value']> & DataTableColumnTicketInput<T>;
 interface DataTableSort {
   /** Toggle sort for a column: none → asc → desc → none */
-  toggle: (key: string) => void;
+  toggle: (id: string) => void;
   /** Current sort columns derived from group state */
   columns: Readonly<Ref<SortEntry[]>>;
   /** Order of sort columns (for multi-sort priority) */
   order: readonly string[];
-  /** Get sort direction for a specific column key */
-  direction: (key: string) => SortDirection;
+  /** Get sort direction for a specific column id */
+  direction: (id: string) => SortDirection;
   /** Get sort priority index (0-based), or -1 if not sorted */
-  priority: (key: string) => number;
+  priority: (id: string) => number;
   /** Reset all sort state */
   reset: () => void;
 }
@@ -143,12 +199,6 @@ interface DataTableExpansion {
   collapseAll: () => void;
 }
 interface DataTableOptions<T extends Record<string, unknown>> {
-  /** Source items */
-  items: MaybeRefOrGetter<T[]>;
-  /** Column definitions */
-  columns: readonly DataTableColumn<T>[];
-  /** Property used as row identifier. Must resolve to a string or number value. @default 'id' */
-  itemValue?: KeysOfType<T, ID>;
   /** Filter options (keys derived from columns) */
   filter?: Omit<FilterOptions, 'keys'>;
   /** Pagination options (size derived from pipeline) */
@@ -163,7 +213,7 @@ interface DataTableOptions<T extends Record<string, unknown>> {
   selectStrategy?: SelectStrategy;
   /** Property that controls per-row selectability */
   itemSelectable?: keyof T & string;
-  /** Column key to group rows by */
+  /** Column id to group rows by */
   groupBy?: keyof T & string;
   /** Auto-open all groups on creation. @default false */
   openAll?: boolean;
@@ -171,10 +221,10 @@ interface DataTableOptions<T extends Record<string, unknown>> {
   expandMultiple?: boolean;
   /** Locale for sorting (defaults to useLocale's selected locale or browser default) */
   locale?: string;
-  /** Pipeline adapter. @default ClientAdapter */
-  adapter?: DataTableAdapterInterface<T>;
+  /** Pipeline adapter. @default ClientDataTableAdapter */
+  adapter?: DataTableAdapter<T>;
 }
-interface DataTableContext<T extends Record<string, unknown>> {
+interface DataTableContext<T extends Record<string, unknown>> extends RegistryContext<DataTableTicketInput<T>, DataTableTicket<T>> {
   /** Final paginated items for rendering */
   items: Readonly<Ref<readonly T[]>>;
   /** Raw unprocessed items */
@@ -183,11 +233,15 @@ interface DataTableContext<T extends Record<string, unknown>> {
   filteredItems: Readonly<Ref<readonly T[]>>;
   /** Items after filtering and sorting */
   sortedItems: Readonly<Ref<readonly T[]>>;
-  /** Column definitions */
-  columns: readonly DataTableColumn<T>[];
-  /** Leaf columns (no children) used by the data pipeline */
-  leaves: readonly DataTableColumn<T>[];
-  /** 2D header grid with colspan/rowspan for rendering thead */
+  /**
+   * Column registry. Use `columns.register({...})`, `columns.onboard([...])`,
+   * `columns.unregister(id)`, and `columns.clear()` to manage columns. The
+   * registry is reactive — `leaves` and `headers` recompute when it mutates.
+   */
+  columns: RegistryContext<DataTableColumnTicketInput<T>, DataTableColumnTicket<T>>;
+  /** Leaf columns (no children) used by the data pipeline. Reactive. */
+  leaves: Readonly<Ref<readonly DataTableColumnTicket<T>[]>>;
+  /** 2D header grid with colspan/rowspan for rendering thead. Reactive. */
   headers: Readonly<Ref<InternalHeader[][]>>;
   /** Set the search query */
   search: (value: string) => void;
@@ -217,45 +271,51 @@ interface DataTableContextOptions<T extends Record<string, unknown>> extends Dat
  * Creates a data table instance with sort controls, selection, and an
  * adapter-driven data pipeline.
  *
+ * Rows and columns are both managed via internal registries. Use
+ * `table.columns.register({ id, ... })` / `table.columns.onboard([...])` to
+ * add columns and `table.register({ id, value })` / `table.onboard([...])`
+ * for rows. Removing entries from the column registry reactively updates
+ * `leaves`, `headers`, the sort group, and the filter pipeline.
+ *
  * Must be called inside a component `setup()` or a Vue effect scope.
  * Calling at module scope in SSR environments causes request state leakage.
  *
- * @param options Data table options
- * @returns Data table context with pipeline stages and controls
+ * @param options Data table options (all optional)
+ * @returns Data table context with pipeline stages, controls, and registry surface
  *
  * @example
  * ```ts
  * import { createDataTable } from '@vuetify/v0'
  *
- * const table = createDataTable({
- *   items: users,
- *   columns: [
- *     { key: 'name', title: 'Name', sortable: true, filterable: true },
- *     { key: 'email', title: 'Email', sortable: true, filterable: true },
- *     { key: 'age', title: 'Age', sortable: true },
- *   ],
- * })
+ * const table = createDataTable<User>()
+ *
+ * table.columns.onboard([
+ *   { id: 'name', title: 'Name', sortable: true, filterable: true },
+ *   { id: 'email', title: 'Email', sortable: true, filterable: true },
+ *   { id: 'age', title: 'Age', sortable: true },
+ * ])
+ *
+ * table.onboard(users.map(value => ({ id: value.id, value })))
  *
- * // Search
  * table.search('john')
  *
- * // Sort
- * table.sort.toggle('name')          // asc
- * table.sort.toggle('name')          // desc
- * table.sort.toggle('name')          // none
- * console.log(table.sort.columns.value) // [{ key: 'name', direction: 'asc' }]
+ * table.sort.toggle('name')
+ * table.sort.toggle('name')
+ * table.sort.toggle('name')
  *
- * // Paginate
  * table.pagination.next()
  *
- * // Select rows
- * table.selection.toggle('user-1')
+ * table.selection.toggle(1)
  * ```
  */
-declare function createDataTable<T extends Record<string, unknown>>(options: DataTableOptions<T>): DataTableContext<T>;
+declare function createDataTable<T extends Record<string, unknown>>(options?: DataTableOptions<T>): DataTableContext<T>;
 /**
  * Creates a data table context with dependency injection support.
  *
+ * The returned context exposes both row and column registries. Columns must
+ * be onboarded after construction — pass them via `context.columns.onboard`,
+ * not in the factory options.
+ *
  * @param options Data table context options including namespace
  * @returns A trinity tuple: [useDataTable, provideDataTable, defaultContext]
  *
@@ -263,22 +323,23 @@ declare function createDataTable<T extends Record<string, unknown>>(options: Dat
  * ```ts
  * import { createDataTableContext } from '@vuetify/v0'
  *
- * const [useDataTable, provideDataTable, context] = createDataTableContext({
+ * const [useDataTable, provideDataTable, context] = createDataTableContext<User>({
  *   namespace: 'app:users',
- *   items: users,
- *   columns: [
- *     { key: 'name', title: 'Name', sortable: true },
- *   ],
  * })
  *
+ * context.columns.onboard([
+ *   { id: 'name', title: 'Name', sortable: true },
+ * ])
+ *
  * // Parent component
  * provideDataTable()
+ * context.onboard(users.map(value => ({ id: value.id, value })))
  *
  * // Child component
  * const table = useDataTable()
  * ```
  */
-declare function createDataTableContext<T extends Record<string, unknown>>(_options: DataTableContextOptions<T>): ContextTrinity<DataTableContext<T>>;
+declare function createDataTableContext<T extends Record<string, unknown>>(_options?: DataTableContextOptions<T>): ContextTrinity<DataTableContext<T>>;
 /**
  * Returns the current data table context from dependency injection.
  *
@@ -299,4 +360,4 @@ declare function createDataTableContext<T extends Record<string, unknown>>(_opti
  */
 declare function useDataTable<T extends Record<string, unknown>>(namespace?: string): DataTableContext<T>;
 //#endregion
-export { computeDepth as _, DataTableGroup as a, DataTableSelection as c, SelectStrategy as d, createDataTable as f, InternalHeader as g, ColumnNode as h, DataTableExpansion as i, DataTableSort as l, useDataTable as m, DataTableContext as n, DataTableGrouping as o, createDataTableContext as p, DataTableContextOptions as r, DataTableOptions as s, DataTableColumn as t, KeysOfType as u, extractLeaves as v, resolveHeaders as y };
+export { ColumnNode as _, DataTableExpansion as a, extractLeaves as b, DataTableOptions as c, DataTableTicket as d, DataTableTicketInput as f, useDataTable as g, createDataTableContext as h, DataTableContextOptions as i, DataTableSelection as l, createDataTable as m, DataTableColumnTicketInput as n, DataTableGroup as o, SelectStrategy as p, DataTableContext as r, DataTableGrouping as s, DataTableColumnTicket as t, DataTableSort as u, InternalHeader as v, resolveHeaders as x, computeDepth as y };