Base UI

node_modules/vue-router/dist/experimental/index.d.ts

@@ -0,0 +1,7 @@
+/*!
+ * vue-router v5.1.0
+ * (c) 2026 Eduardo San Martin Morote
+ * @license MIT
+ */
+import { $n as defineParamParserRaw, An as MatchMiss, Bn as EXPERIMENTAL_RouterOptions, Cn as ParamParserTypeOf, Dn as PathParamNamesForFilePath, En as ParamParsers_Native, Fn as EXPERIMENTAL_RouteRecordRaw, Gn as createFixedResolver, Hn as EXPERIMENTAL_Router_Base, In as EXPERIMENTAL_RouteRecord_Base, Jn as ExtractParamParserType, Kn as MatcherPatternQuery, Ln as EXPERIMENTAL_RouteRecord_Group, Mn as EXPERIMENTAL_RouteRecordNormalized, Nn as EXPERIMENTAL_RouteRecordNormalized_Group, On as _mergeRouteRecord, Pn as EXPERIMENTAL_RouteRecordNormalized_Matchable, Qn as defineParamParser, Rn as EXPERIMENTAL_RouteRecord_Matchable, Sn as ParamParserType, Tn as ParamParsers, Un as experimental_createRouter, Vn as EXPERIMENTAL_RouterOptions_Base, Wn as normalizeRouteRecord, Xn as PARAM_PARSER_INT, Yn as normalizeParamParser, Zn as PARAM_PARSER_BOOL, _ as getCurrentContext, _n as defineBasicLoader, a as DefineLoaderFn, ar as MatcherPatternPath, b as withLoaderContext, bn as DefinePageQueryParamOptions, c as UseDataLoaderResult, cn as NavigationResult, cr as MatcherPatternPathStatic, d as DataLoaderPluginOptions, dn as DefineDataLoaderOptions, f as NavigationResult$1, fn as DefineDataLoaderOptions_DefinedData, fr as ParamParser, gn as UseDataLoaderBasic_LaxData, h as useIsDataLoading, hn as UseDataLoaderBasic_DefinedData, i as DefineDataLoaderOptionsBase_LaxData, ir as MatcherPatternHash, jn as miss, kn as definePage, l as toLazyValue, ln as DataLoaderBasicEntry, lr as MatcherQueryParams, m as reroute, mn as UseDataLoaderBasic, n as DataLoaderEntryBase, nr as MatcherParamsFormatted, o as UseDataLoader, or as MatcherPatternPathDynamic, p as SetupLoaderGuardOptions, pn as DefineDataLoaderOptions_LaxData, qn as MatcherPatternQueryParam, r as DefineDataLoaderOptionsBase_DefinedData, rr as MatcherPattern, s as UseDataLoaderInternals, sr as MatcherPatternPathDynamic_ParamOptions, t as DataLoaderContextBase, tr as EmptyParams, u as DataLoaderPlugin, un as DataLoaderContext, ur as MatcherQueryParamsValue, v as setCurrentContext, vn as ErrorDefault, wn as ParamParserType_Native, xn as DefinePageQueryParamOptionsAny, y as trackRoute, yn as DefinePage, zn as EXPERIMENTAL_Router } from "../index-BQLwgiyK.js";
+export { type DataLoaderBasicEntry, type DataLoaderContext, type DataLoaderContextBase, type DataLoaderEntryBase, DataLoaderPlugin, type DataLoaderPluginOptions, type DefineDataLoaderOptions, type DefineDataLoaderOptionsBase_DefinedData, type DefineDataLoaderOptionsBase_LaxData, type DefineDataLoaderOptions_DefinedData, type DefineDataLoaderOptions_LaxData, type DefineLoaderFn, type DefinePage, type DefinePageQueryParamOptions, type EXPERIMENTAL_RouteRecordNormalized, type EXPERIMENTAL_RouteRecordNormalized_Group, type EXPERIMENTAL_RouteRecordNormalized_Matchable, type EXPERIMENTAL_RouteRecordRaw, type EXPERIMENTAL_RouteRecord_Base, type EXPERIMENTAL_RouteRecord_Group, type EXPERIMENTAL_RouteRecord_Matchable, type EXPERIMENTAL_Router, type EXPERIMENTAL_RouterOptions, type EXPERIMENTAL_RouterOptions_Base, type EXPERIMENTAL_Router_Base, type EmptyParams, type ErrorDefault, type MatcherParamsFormatted, type MatcherPattern, type MatcherPatternHash, type MatcherPatternPath, MatcherPatternPathDynamic, type MatcherPatternPathDynamic_ParamOptions, MatcherPatternPathStatic, type MatcherPatternQuery, MatcherPatternQueryParam, type MatcherQueryParams, type MatcherQueryParamsValue, NavigationResult, PARAM_PARSER_BOOL, PARAM_PARSER_INT, type ParamParser, type ParamParserType, type ParamParserTypeOf, type ParamParserType_Native, type SetupLoaderGuardOptions, type UseDataLoader, type UseDataLoaderBasic, type UseDataLoaderBasic_DefinedData, type UseDataLoaderBasic_LaxData, type UseDataLoaderInternals, type UseDataLoaderResult, type DefinePageQueryParamOptionsAny as _DefinePageQueryParamOptionsAny, type ExtractParamParserType as _ExtractParamParserType, MatchMiss as _MatchMiss, NavigationResult$1 as _NavigationResult, type ParamParsers as _ParamParsers, type ParamParsers_Native as _ParamParsers_Native, type PathParamNamesForFilePath as _PathParamNamesForFilePath, _mergeRouteRecord, normalizeParamParser as _normalizeParamParser, createFixedResolver, defineBasicLoader, definePage, defineParamParser, defineParamParserRaw, experimental_createRouter, getCurrentContext, miss, normalizeRouteRecord, reroute, setCurrentContext, toLazyValue, trackRoute, useIsDataLoading, withLoaderContext };

node_modules/vue-router/dist/experimental/pinia-colada.d.ts

@@ -0,0 +1,152 @@
+/*!
+ * vue-router v5.1.0
+ * (c) 2026 Eduardo San Martin Morote
+ * @license MIT
+ */
+import { It as RouteMap, a as DefineLoaderFn, c as UseDataLoaderResult, f as NavigationResult, g as _PromiseMerged, i as DefineDataLoaderOptionsBase_LaxData, mr as LocationQuery, n as DataLoaderEntryBase, o as UseDataLoader, pt as RouteLocationNormalizedLoaded, r as DefineDataLoaderOptionsBase_DefinedData, t as DataLoaderContextBase, vn as ErrorDefault } from "../index-BQLwgiyK.js";
+import { ShallowRef } from "vue";
+import { EntryKey, UseQueryOptions, UseQueryReturn } from "@pinia/colada";
+
+//#region src/experimental/data-loaders/defineColadaLoader.d.ts
+/**
+ * Creates a Pinia Colada data loader with `data` is always defined.
+ *
+ * @param name - name of the route to have typed routes
+ * @param options - options to configure the data loader
+ */
+declare function defineColadaLoader<Name extends keyof RouteMap, Data>(name: Name, options: DefineDataColadaLoaderOptions_DefinedData<Name, Data>): UseDataLoaderColada_DefinedData<Data>;
+/**
+ * Creates a Pinia Colada data loader with `data` is possibly `undefined`.
+ *
+ * @param name - name of the route to have typed routes
+ * @param options - options to configure the data loader
+ */
+declare function defineColadaLoader<Name extends keyof RouteMap, Data>(name: Name, options: DefineDataColadaLoaderOptions_LaxData<Name, Data>): UseDataLoaderColada_LaxData<Data>;
+/**
+ * Creates a Pinia Colada data loader with `data` is always defined.
+ * @param options - options to configure the data loader
+ */
+declare function defineColadaLoader<Data>(options: DefineDataColadaLoaderOptions_DefinedData<keyof RouteMap, Data>): UseDataLoaderColada_DefinedData<Data>;
+/**
+ * Creates a Pinia Colada data loader with `data` is possibly `undefined`.
+ * @param options - options to configure the data loader
+ */
+declare function defineColadaLoader<Data>(options: DefineDataColadaLoaderOptions_LaxData<keyof RouteMap, Data>): UseDataLoaderColada_LaxData<Data>;
+/**
+ * Base type with docs for the options of `defineColadaLoader`.
+ * @internal
+ */
+interface _DefineDataColadaLoaderOptions_Common<Name extends keyof RouteMap, Data> extends Omit<UseQueryOptions<Data, ErrorDefault, Data>, 'query' | 'key'> {
+  /**
+   * Key associated with the data and passed to pinia colada
+   * @param to - Route to load the data
+   */
+  key: EntryKey | ((to: RouteLocationNormalizedLoaded<Name>) => EntryKey);
+  /**
+   * Function that returns a promise with the data.
+   */
+  query: DefineLoaderFn<Data, DataColadaLoaderContext, RouteLocationNormalizedLoaded<Name>>;
+}
+/**
+ * Options for `defineColadaLoader` when the data is possibly `undefined`.
+ */
+interface DefineDataColadaLoaderOptions_LaxData<Name extends keyof RouteMap, Data> extends _DefineDataColadaLoaderOptions_Common<Name, Data>, DefineDataLoaderOptionsBase_LaxData {}
+/**
+ * Options for `defineColadaLoader` when the data is always defined.
+ */
+interface DefineDataColadaLoaderOptions_DefinedData<Name extends keyof RouteMap, Data> extends _DefineDataColadaLoaderOptions_Common<Name, Data>, DefineDataLoaderOptionsBase_DefinedData {}
+/**
+ * @deprecated Use {@link `DefineDataColadaLoaderOptions_LaxData`} instead.
+ */
+type DefineDataColadaLoaderOptions<Name extends keyof RouteMap, Data> = DefineDataColadaLoaderOptions_LaxData<Name, Data>;
+/**
+ * @internal
+ */
+interface DataColadaLoaderContext extends DataLoaderContextBase {}
+interface UseDataLoaderColadaResult<TData, TError = ErrorDefault, TDataInitial extends TData | undefined = TData | undefined> extends UseDataLoaderResult<TData | TDataInitial, ErrorDefault>, Pick<UseQueryReturn<TData, TError, TDataInitial>, 'isPending' | 'status' | 'asyncStatus' | 'state'> {
+  /**
+   * Equivalent to `useQuery().refetch()`. Refetches the data no matter if its stale or not.
+   * @see reload - It also calls `refetch()` but returns an empty promise
+   */
+  refetch: (to?: RouteLocationNormalizedLoaded) => ReturnType<UseQueryReturn<TData, TError, TDataInitial>['refetch']>;
+  /**
+   * Equivalent to `useQuery().refresh()`. Refetches the data **only** if it's stale.
+   */
+  refresh: (to?: RouteLocationNormalizedLoaded) => ReturnType<UseQueryReturn<TData, TError, TDataInitial>['refetch']>;
+}
+/**
+ * Data Loader composable returned by `defineColadaLoader()`.
+ */
+interface UseDataLoaderColada_LaxData<Data> extends UseDataLoader<Data | undefined, ErrorDefault> {
+  /**
+   * Data Loader composable returned by `defineColadaLoader()`.
+   *
+   * @example
+   * Returns the Data loader data, isLoading, error etc. Meant to be used in `setup()` or `<script setup>` **without `await`**:
+   * ```vue
+   * <script setup>
+   * const { data, isLoading, error } = useUserData()
+   * </script>
+   * ```
+   *
+   * @example
+   * It also returns a promise of the data when used in nested loaders. Note this `data` is **not a ref**. This is not meant to be used in `setup()` or `<script setup>`.
+   * ```ts
+   * export const useUserConnections = defineLoader(async () => {
+   *   const user = await useUserData()
+   *   return fetchUserConnections(user.id)
+   * })
+   * ```
+   */
+  (): _PromiseMerged<Exclude<Data, NavigationResult | undefined>, UseDataLoaderColadaResult<Exclude<Data, NavigationResult> | undefined>>;
+}
+/**
+ * Data Loader composable returned by `defineColadaLoader()`.
+ */
+interface UseDataLoaderColada_DefinedData<TData> extends UseDataLoader<TData, ErrorDefault> {
+  /**
+   * Data Loader composable returned by `defineColadaLoader()`.
+   *
+   * @example
+   * Returns the Data loader data, isLoading, error etc. Meant to be used in `setup()` or `<script setup>` **without `await`**:
+   * ```vue
+   * <script setup>
+   * const { data, isLoading, error } = useUserData()
+   * </script>
+   * ```
+   *
+   * @example
+   * It also returns a promise of the data when used in nested loaders. Note this `data` is **not a ref**. This is not meant to be used in `setup()` or `<script setup>`.
+   * ```ts
+   * export const useUserConnections = defineLoader(async () => {
+   *   const user = await useUserData()
+   *   return fetchUserConnections(user.id)
+   * })
+   * ```
+   */
+  (): _PromiseMerged<Exclude<TData, NavigationResult | undefined>, UseDataLoaderColadaResult<Exclude<TData, NavigationResult>, ErrorDefault, Exclude<TData, NavigationResult>>>;
+}
+interface DataLoaderColadaEntry<TData, TError = unknown, TDataInitial extends TData | undefined = TData | undefined> extends DataLoaderEntryBase<TData, TError, TDataInitial> {
+  /**
+   * Reactive route passed to pinia colada so it automatically refetch
+   */
+  route: ShallowRef<RouteLocationNormalizedLoaded>;
+  /**
+   * Tracked routes to know when the data should be refreshed. Key is the key of the query.
+   */
+  tracked: Map<string, TrackedRoute>;
+  /**
+   * Extended options for pinia colada
+   */
+  ext: UseQueryReturn<TData, TError, TDataInitial> | null;
+}
+interface TrackedRoute {
+  ready: boolean;
+  params: Partial<LocationQuery>;
+  query: Partial<LocationQuery>;
+  hash: {
+    v: string | null;
+  };
+}
+//#endregion
+export { type DataColadaLoaderContext, type DataLoaderColadaEntry, type DefineDataColadaLoaderOptions, type DefineDataColadaLoaderOptions_DefinedData, type DefineDataColadaLoaderOptions_LaxData, type UseDataLoaderColadaResult, type UseDataLoaderColada_DefinedData, type UseDataLoaderColada_LaxData, type _DefineDataColadaLoaderOptions_Common, defineColadaLoader };

node_modules/vue-router/dist/experimental/pinia-colada.js

@@ -0,0 +1,232 @@
+/*!
+* vue-router v5.1.0
+* (c) 2026 Eduardo San Martin Morote
+* @license MIT
+*/
+import { n as useRouter, t as useRoute } from "../useApi-s_02lHjl.js";
+import { a as assign, b as toLazyValue, c as setCurrentContext, d as ABORT_CONTROLLER_KEY, f as APP_KEY, g as LOADER_ENTRIES_KEY, h as IS_USE_DATA_LOADER_KEY, l as trackRoute, m as IS_SSR_KEY, n as NavigationResult, o as getCurrentContext, p as DATA_LOADERS_EFFECT_SCOPE_KEY, s as isSubsetOf, v as PENDING_LOCATION_KEY, y as STAGED_NO_VALUE } from "../navigation-guard-B8OQKdL7.js";
+import { shallowRef, watch } from "vue";
+import { defineQuery, useQuery, useQueryCache } from "@pinia/colada";
+//#region src/experimental/data-loaders/defineColadaLoader.ts
+function defineColadaLoader(nameOrOptions, _options) {
+	_options = _options || nameOrOptions;
+	const loader = _options.query;
+	const options = {
+		...DEFAULT_DEFINE_LOADER_OPTIONS,
+		..._options,
+		commit: _options?.commit || "after-load"
+	};
+	let isInitial = true;
+	const useDefinedQuery = defineQuery(() => {
+		const router = useRouter();
+		const entry = router[LOADER_ENTRIES_KEY].get(loader);
+		return useQuery({
+			...options,
+			query: () => {
+				const route = entry.route.value;
+				const [trackedRoute, params, query, hash] = trackRoute(route);
+				entry.tracked.set(joinKeys(serializeQueryKey(options.key, trackedRoute)), {
+					ready: false,
+					params,
+					query,
+					hash
+				});
+				return router[APP_KEY].runWithContext(() => loader(trackedRoute, { signal: route.meta[ABORT_CONTROLLER_KEY]?.signal }));
+			},
+			key: () => toValueWithParameters(options.key, entry.route.value)
+		});
+	});
+	function load(to, router, from, parent, reload) {
+		const entries = router[LOADER_ENTRIES_KEY];
+		const isSSR = router[IS_SSR_KEY];
+		const key = serializeQueryKey(options.key, to);
+		if (!entries.has(loader)) {
+			const route = shallowRef(to);
+			entries.set(loader, {
+				data: shallowRef(),
+				isLoading: shallowRef(false),
+				error: shallowRef(null),
+				to,
+				options,
+				children: /* @__PURE__ */ new Set(),
+				resetPending() {
+					this.pendingTo = null;
+					this.pendingLoad = null;
+					this.isLoading.value = false;
+				},
+				staged: STAGED_NO_VALUE,
+				stagedError: null,
+				commit,
+				tracked: /* @__PURE__ */ new Map(),
+				ext: null,
+				route,
+				pendingTo: null,
+				pendingLoad: null
+			});
+		}
+		const entry = entries.get(loader);
+		if (entry.pendingTo === to && entry.pendingLoad) return entry.pendingLoad;
+		const currentContext = getCurrentContext();
+		if (process.env.NODE_ENV !== "production") {
+			if (parent !== currentContext[0]) console.warn(`❌👶 "${key}" has a different parent than the current context. This shouldn't be happening. Please report a bug with a reproduction to https://github.com/vuejs/router/`);
+		}
+		setCurrentContext([
+			entry,
+			router,
+			to
+		]);
+		if (!entry.ext) {
+			entry.ext = useDefinedQuery();
+			useQueryCache().get(toValueWithParameters(options.key, to))?.deps.delete(router[DATA_LOADERS_EFFECT_SCOPE_KEY]);
+			reload = false;
+		}
+		const { isLoading, data, error, ext } = entry;
+		if (isInitial) {
+			isInitial = false;
+			if (ext.data.value !== void 0) {
+				data.value = ext.data.value;
+				setCurrentContext(currentContext);
+				return entry.pendingLoad = Promise.resolve();
+			}
+		}
+		if (entry.route.value !== to) {
+			const tracked = entry.tracked.get(joinKeys(key));
+			reload = !tracked || hasRouteChanged(to, tracked);
+		}
+		entry.route.value = entry.pendingTo = to;
+		isLoading.value = true;
+		entry.staged = STAGED_NO_VALUE;
+		entry.stagedError = error.value;
+		const currentLoad = ext[reload ? "refetch" : "refresh"]().then(() => {
+			if (entry.pendingLoad === currentLoad) {
+				const newError = ext.error.value;
+				if (newError) {
+					if (newError instanceof NavigationResult) {
+						entry.pendingTo = null;
+						throw newError;
+					}
+					entry.stagedError = newError;
+					if (!toLazyValue(options.lazy, to, from) || isSSR) throw newError;
+				} else {
+					const newData = ext.data.value;
+					if (newData instanceof NavigationResult) {
+						if (process.env.NODE_ENV !== "production") console.warn("[vue-router]: Returning a NavigationResult is deprecated. Use reroute() instead, which throws internally.");
+						entry.pendingTo = null;
+						throw newData;
+					} else {
+						entry.staged = newData;
+						entry.stagedError = null;
+					}
+				}
+			}
+		}).finally(() => {
+			setCurrentContext(currentContext);
+			if (entry.pendingLoad === currentLoad) {
+				isLoading.value = false;
+				if (options.commit === "immediate" || !router[PENDING_LOCATION_KEY]) entry.commit(to);
+			}
+		});
+		setCurrentContext(currentContext);
+		entry.pendingLoad = currentLoad;
+		return currentLoad;
+	}
+	function commit(to) {
+		const key = serializeQueryKey(options.key, to);
+		if (this.pendingTo === to) {
+			if (process.env.NODE_ENV !== "production") {
+				if (this.staged === STAGED_NO_VALUE && this.stagedError === null) console.warn(`Loader "${key}"'s "commit()" was called but there is no staged data.`);
+			}
+			if (this.staged !== STAGED_NO_VALUE) {
+				this.data.value = this.staged;
+				if (process.env.NODE_ENV !== "production" && !this.tracked.has(joinKeys(key))) {
+					console.warn(`A query was defined with the same key as the loader "[${key.join(", ")}]". If the "key" is meant to be the same, you should directly use the data loader instead. If not, change the key of the "useQuery()".\nSee https://pinia-colada.esm.dev/#TODO`);
+					return;
+				}
+				this.tracked.get(joinKeys(key)).ready = true;
+			}
+			this.error.value = this.stagedError;
+			this.staged = STAGED_NO_VALUE;
+			this.stagedError = this.error.value;
+			this.to = to;
+			this.pendingTo = null;
+			for (const childEntry of this.children) childEntry.commit(to);
+		}
+	}
+	const useDataLoader = () => {
+		const currentContext = getCurrentContext();
+		const [parentEntry, _router, _route] = currentContext;
+		const router = _router || useRouter();
+		const route = _route || useRoute();
+		const app = router[APP_KEY];
+		const entries = router[LOADER_ENTRIES_KEY];
+		let entry = entries.get(loader);
+		if (!entry || parentEntry && entry.pendingTo !== route || !entry.pendingLoad) app.runWithContext(() => load(route, router, void 0, parentEntry, true));
+		entry = entries.get(loader);
+		if (parentEntry) {
+			if (parentEntry !== entry) parentEntry.children.add(entry);
+		}
+		const { data, error, isLoading } = entry;
+		const ext = useDefinedQuery();
+		useQueryCache().get(toValueWithParameters(options.key, route))?.deps.delete(router[DATA_LOADERS_EFFECT_SCOPE_KEY]);
+		watch(ext.data, (newData) => {
+			if (!router[PENDING_LOCATION_KEY]) data.value = newData;
+		});
+		watch(ext.isLoading, (isFetching) => {
+			if (!router[PENDING_LOCATION_KEY]) isLoading.value = isFetching;
+		});
+		watch(ext.error, (newError) => {
+			if (!router[PENDING_LOCATION_KEY]) error.value = newError;
+		});
+		const useDataLoaderResult = {
+			data,
+			error,
+			isLoading,
+			reload: (to = router.currentRoute.value) => app.runWithContext(() => load(to, router, void 0, void 0, true)).then(() => entry.commit(to)),
+			refetch: (to = router.currentRoute.value) => app.runWithContext(() => load(to, router, void 0, void 0, true)).then(() => (entry.commit(to), entry.ext.state.value)),
+			refresh: (to = router.currentRoute.value) => app.runWithContext(() => load(to, router)).then(() => (entry.commit(to), entry.ext.state.value)),
+			status: ext.status,
+			asyncStatus: ext.asyncStatus,
+			state: ext.state,
+			isPending: ext.isPending
+		};
+		const promise = entry.pendingLoad.then(() => entry.staged === STAGED_NO_VALUE ? ext.data.value : entry.staged).catch((e) => parentEntry ? Promise.reject(e) : null).finally(() => setCurrentContext(currentContext));
+		setCurrentContext(currentContext);
+		return assign(promise, useDataLoaderResult);
+	};
+	useDataLoader[IS_USE_DATA_LOADER_KEY] = true;
+	useDataLoader._ = {
+		load,
+		options,
+		getEntry(router) {
+			return router[LOADER_ENTRIES_KEY].get(loader);
+		}
+	};
+	return useDataLoader;
+}
+const joinKeys = (keys) => keys.join("|");
+function hasRouteChanged(to, tracked) {
+	return !tracked.ready || !isSubsetOf(tracked.params, to.params) || !isSubsetOf(tracked.query, to.query) || tracked.hash.v != null && tracked.hash.v !== to.hash;
+}
+const DEFAULT_DEFINE_LOADER_OPTIONS = {
+	lazy: false,
+	server: true,
+	commit: "after-load"
+};
+const toValueWithParameters = (optionValue, arg) => {
+	return typeof optionValue === "function" ? optionValue(arg) : optionValue;
+};
+/**
+* Transform the key to a string array so it can be used as a key in caches.
+*
+* @param key - key to transform
+* @param to - route to use
+*/
+function serializeQueryKey(keyOption, to) {
+	const key = toValueWithParameters(keyOption, to);
+	return (Array.isArray(key) ? key : [key]).map(stringifyFlatObject);
+}
+function stringifyFlatObject(obj) {
+	return obj && typeof obj === "object" ? JSON.stringify(obj, Object.keys(obj).sort()) : String(obj);
+}
+//#endregion
+export { defineColadaLoader };