@vuetify/v0 0.1.3 → 0.1.4

package/dist/index-7mWYFHA6.d.mts

@@ -0,0 +1,251 @@
+import { o as ID } from "./index-BFBN5Zl3.mjs";
+import { E as ContextTrinity, a as SortDirection, l as PaginationOptions, o as SortEntry, r as DataTableAdapterInterface, s as PaginationContext, y as FilterOptions } from "./adapter-BN-h5JbD.mjs";
+import { MaybeRefOrGetter, Ref, ShallowRef } from "vue";
+
+//#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: keyof T & 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;
+}
+interface DataTableSort {
+  /** Toggle sort for a column: none → asc → desc → none */
+  toggle: (key: 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 priority index (0-based), or -1 if not sorted */
+  priority: (key: string) => number;
+  /** Reset all sort state */
+  reset: () => void;
+}
+interface DataTableSelection {
+  /** Currently selected row IDs */
+  selectedIds: ReadonlySet<ID>;
+  /** Select a row by ID */
+  select: (id: ID) => void;
+  /** Unselect a row by ID */
+  unselect: (id: ID) => void;
+  /** Toggle a row's selection */
+  toggle: (id: ID) => void;
+  /** Whether a row is selected */
+  isSelected: (id: ID) => boolean;
+  /** Whether a row can be selected (based on itemSelectable) */
+  isSelectable: (id: ID) => boolean;
+  /** Select all items within strategy scope */
+  selectAll: () => void;
+  /** Unselect all items across all pages */
+  unselectAll: () => void;
+  /** Toggle all items within strategy scope */
+  toggleAll: () => void;
+  /** Whether all items within strategy scope are selected */
+  isAllSelected: Readonly<Ref<boolean>>;
+  /** Whether some but not all items within strategy scope are selected */
+  isMixed: Readonly<Ref<boolean>>;
+}
+interface DataTableGroup<T extends Record<string, unknown>> {
+  /** Stringified group identifier */
+  key: string;
+  /** Raw value of the groupBy column for this group */
+  value: T[keyof T & string];
+  /** Items belonging to this group */
+  items: readonly T[];
+}
+interface DataTableGrouping<T extends Record<string, unknown>> {
+  /** Grouped items derived from sortedItems */
+  groups: Readonly<Ref<DataTableGroup<T>[]>>;
+  /** Toggle a group's open/closed state */
+  toggle: (groupKey: string) => void;
+  /** Whether a group is open */
+  isOpen: (groupKey: string) => boolean;
+  /** Open a group */
+  open: (groupKey: string) => void;
+  /** Close a group */
+  close: (groupKey: string) => void;
+  /** Open all groups */
+  openAll: () => void;
+  /** Close all groups */
+  closeAll: () => void;
+}
+interface DataTableExpansion {
+  /** Currently expanded row IDs */
+  expandedIds: ReadonlySet<ID>;
+  /** Expand a row by ID */
+  expand: (id: ID) => void;
+  /** Collapse a row by ID */
+  collapse: (id: ID) => void;
+  /** Toggle a row's expanded state */
+  toggle: (id: ID) => void;
+  /** Whether a row is expanded */
+  isExpanded: (id: ID) => boolean;
+  /** Expand all visible (paginated) items. Requires expandMultiple=true. */
+  expandAll: () => void;
+  /** Collapse all expanded items across all pages (not page-scoped like expandAll) */
+  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) */
+  pagination?: Omit<PaginationOptions, 'size'>;
+  /** Enable multi-column sort. @default false */
+  sortMultiple?: boolean;
+  /** Prevent clearing sort (asc → desc → asc cycle). @default false */
+  mandate?: boolean;
+  /** Direction for first sort click. @default 'asc' */
+  firstSortOrder?: 'asc' | 'desc';
+  /** Selection strategy: 'single' selects one row, 'page' operates on visible items, 'all' operates on all filtered items. @default 'page' */
+  selectStrategy?: SelectStrategy;
+  /** Property that controls per-row selectability */
+  itemSelectable?: keyof T & string;
+  /** Column key to group rows by */
+  groupBy?: keyof T & string;
+  /** Auto-open all groups on creation. @default false */
+  enroll?: boolean;
+  /** Allow multiple rows expanded simultaneously. @default true */
+  expandMultiple?: boolean;
+  /** Locale for sorting (defaults to useLocale's selected locale or browser default) */
+  locale?: string;
+  /** Pipeline adapter. @default ClientAdapter */
+  adapter?: DataTableAdapterInterface<T>;
+}
+interface DataTableContext<T extends Record<string, unknown>> {
+  /** Final paginated items for rendering */
+  items: Readonly<Ref<readonly T[]>>;
+  /** Raw unprocessed items */
+  allItems: Readonly<Ref<readonly T[]>>;
+  /** Items after filtering */
+  filteredItems: Readonly<Ref<readonly T[]>>;
+  /** Items after filtering and sorting */
+  sortedItems: Readonly<Ref<readonly T[]>>;
+  /** Column definitions */
+  columns: readonly DataTableColumn<T>[];
+  /** Set the search query */
+  search: (value: string) => void;
+  /** Current search query (readonly) */
+  query: Readonly<ShallowRef<string>>;
+  /** Sort controls */
+  sort: DataTableSort;
+  /** Pagination controls */
+  pagination: PaginationContext;
+  /** Row selection controls */
+  selection: DataTableSelection;
+  /** Row expansion controls */
+  expansion: DataTableExpansion;
+  /** Row grouping controls. When groupBy is not set, `groups` returns an empty array. */
+  grouping: DataTableGrouping<T>;
+  /** Total row count for aria-rowcount */
+  total: Readonly<Ref<number>>;
+  /** Loading state (managed by adapter) */
+  loading: Readonly<Ref<boolean>>;
+  /** Error state (managed by adapter) */
+  error: Readonly<Ref<Error | null>>;
+}
+interface DataTableContextOptions<T extends Record<string, unknown>> extends DataTableOptions<T> {
+  namespace?: string;
+}
+/**
+ * Creates a data table instance with sort controls, selection, and an
+ * adapter-driven data 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
+ *
+ * @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 },
+ *   ],
+ * })
+ *
+ * // 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' }]
+ *
+ * // Paginate
+ * table.pagination.next()
+ *
+ * // Select rows
+ * table.selection.toggle('user-1')
+ * ```
+ */
+declare function createDataTable<T extends Record<string, unknown>>(options: DataTableOptions<T>): DataTableContext<T>;
+/**
+ * Creates a data table context with dependency injection support.
+ *
+ * @param options Data table context options including namespace
+ * @returns A trinity tuple: [useDataTable, provideDataTable, defaultContext]
+ *
+ * @example
+ * ```ts
+ * import { createDataTableContext } from '@vuetify/v0'
+ *
+ * const [useDataTable, provideDataTable, context] = createDataTableContext({
+ *   namespace: 'app:users',
+ *   items: users,
+ *   columns: [
+ *     { key: 'name', title: 'Name', sortable: true },
+ *   ],
+ * })
+ *
+ * // Parent component
+ * provideDataTable()
+ *
+ * // Child component
+ * const table = useDataTable()
+ * ```
+ */
+declare function createDataTableContext<T extends Record<string, unknown>>(_options: DataTableContextOptions<T>): ContextTrinity<DataTableContext<T>>;
+/**
+ * Returns the current data table context from dependency injection.
+ *
+ * @typeParam T - Must be provided explicitly; cannot be inferred from namespace.
+ *   Prefer the `useX` function from {@link createDataTableContext} for type-safe injection.
+ *
+ * @param namespace The namespace for the data table context. @default 'v0:data-table'
+ * @returns The current data table context
+ *
+ * @example
+ * ```vue
+ * <script setup lang="ts">
+ *   import { useDataTable } from '@vuetify/v0'
+ *
+ *   const table = useDataTable<User>()
+ * </script>
+ * ```
+ */
+declare function useDataTable<T extends Record<string, unknown>>(namespace?: string): DataTableContext<T>;
+//#endregion
+export { DataTableGroup as a, DataTableSelection as c, createDataTable as d, createDataTableContext as f, DataTableExpansion as i, DataTableSort as l, DataTableContext as n, DataTableGrouping as o, useDataTable as p, DataTableContextOptions as r, DataTableOptions as s, DataTableColumn as t, SelectStrategy as u };

package/dist/index-BDTbJClL.d.mts

@@ -0,0 +1,11 @@
+//#region src/composables/useStorage/adapters/index.d.ts
+type StorageType = 'localStorage' | 'sessionStorage' | 'memory';
+interface StorageAdapter {
+  getItem: (key: string) => string | null;
+  setItem: (key: string, value: string) => void;
+  removeItem: (key: string) => void;
+  readonly length?: number;
+  key?: (index: number) => string | null;
+}
+//#endregion
+export { StorageType as n, StorageAdapter as t };

package/dist/index-BuOz3Rgm.d.mts

@@ -0,0 +1,32 @@
+import { o as ID } from "./index-BFBN5Zl3.mjs";
+
+//#region src/composables/useFeatures/adapters/generic/index.d.ts
+
+type FeaturesAdapterValue = boolean | {
+  $value?: boolean;
+  $variation?: unknown;
+};
+type FeaturesAdapterFlags = Record<ID, FeaturesAdapterValue>;
+interface FeaturesAdapterInterface {
+  /**
+   * Initialize the adapter and return initial flags.
+   *
+   * @param onUpdate Callback invoked when flags change.
+   * @returns Initial feature flags.
+   *
+   * @remarks Called during plugin setup. Sets up change listeners
+   * and returns the initial flag values.
+   */
+  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;
+}
+//#endregion
+export { FeaturesAdapterValue as i, FeaturesAdapterFlags as n, FeaturesAdapterInterface as r, FeaturesAdapter as t };

package/dist/{index-Bmem4l8m.d.mts → index-Bv1VN_j5.d.mts}

@@ -74,6 +74,6 @@ type HTMLElementName = keyof HTMLElementTagNameMap;
 /**
  * Type for self-closing HTML elements
  */
-type SelfClosingElement = keyof typeof selfClosingTags;
+type SelfClosingElement = (typeof selfClosingTags)[number];
 //#endregion
 export { isSelfClosingTag as a, SUPPORTS_MATCH_MEDIA as c, SUPPORTS_TOUCH as d, __LOGGER_ENABLED__ as f, SelfClosingElement as i, SUPPORTS_MUTATION_OBSERVER as l, HTMLElementName as n, IN_BROWSER as o, version as p, SELF_CLOSING_TAGS as r, SUPPORTS_INTERSECTION_OBSERVER as s, COMMON_ELEMENTS as t, SUPPORTS_OBSERVER as u };