@vuetify/v0 0.1.6 → 0.1.8

package/dist/index-CeNfBYuo.d.mts

@@ -0,0 +1,46 @@
+import { App } from "vue";
+
+//#region src/composables/createTrinity/index.d.ts
+type ContextTrinity<Z = unknown> = readonly [() => Z, (context?: Z, app?: App) => Z, Z];
+/**
+ * Creates a new trinity for a context composable and its provider.
+ *
+ * @param useContext The function that retrieves/uses the context (typically named `useContext`).
+ * @param provideContext The function that provides the context to descendants.
+ * @param context The default context instance to use when no custom context is provided.
+ * @template Z The type of the context.
+ * @returns A readonly tuple containing: [useContext function, provideContext wrapper function, default context instance].
+ *
+ * @remarks The trinity pattern is a foundational pattern used throughout the codebase for creating reusable context systems. It provides three related elements:
+ *
+ * 1. A function to retrieve/use the context
+ * 2. A function to provide the context (with default value support)
+ * 3. The default context instance
+ *
+ * The returned tuple is readonly (using `as const`) to ensure proper type inference.
+ *
+ * @see https://0.vuetifyjs.com/composables/foundation/create-trinity#create-trinity
+ *
+ * @example
+ * ```ts
+ * interface MyContext {
+ *   foo: string
+ *   bar: number
+ * }
+ *
+ * export function createMyFeature<E extends MyContext = MyContext>() {
+ *   const [useContext, _provideContext] = createContext<E>('my-context')
+ *
+ *   const context = { foo: 'hello', bar: 42 }
+ *
+ *   function provideContext (_context: E = context, app?: App): E {
+ *     return _provideContext(_context, app)
+ *   }
+ *
+ *   return createTrinity<E>(useContext, provideContext, context)
+ * }
+ * ```
+ */
+declare function createTrinity<Z = unknown>(useContext: () => Z, provideContext: (_context?: Z, app?: App) => Z, context: Z): ContextTrinity<Z>;
+//#endregion
+export { createTrinity as n, ContextTrinity as t };

package/dist/{index-DIK84tM4.d.mts → index-CmCMrlt3.d.mts}

@@ -1,9 +1,9 @@
-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-CLs-OrSN.mjs";
+import { o as ID } from "./index-Dor6eAEc.mjs";
+import { t as ContextTrinity } from "./index-CeNfBYuo.mjs";
+import { a as SortDirection, l as PaginationOptions, o as SortEntry, r as DataTableAdapterInterface, s as PaginationContext, y as FilterOptions } from "./adapter-DIx4Rntl.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';