nuxt-ui-tools 0.1.3 → 1.0.1

package/dist/runtime/i18n/types.d.ts

@@ -8,6 +8,10 @@ export interface UiToolsTableMessages {
     footer: {
         rowsSelected: string;
         rowsPerPage: string;
+        perPage: string;
+        range: string;
+        rangeEmpty: string;
+        pageOf: string;
         page: string;
         pageSizeOption: string;
         previousPage: string;
@@ -17,6 +21,10 @@ export interface UiToolsTableMessages {
     };
     controls: {
         addFilter: string;
+        resetFilters: string;
+        columnsCount: string;
+        close: string;
+        loadingMore: string;
         searchFilters: string;
         noMatchingFilters: string;
         view: string;
@@ -25,6 +33,19 @@ export interface UiToolsTableMessages {
         resetColumns: string;
         sort: string;
         loadMore: string;
+        clearSelection: string;
+    };
+    selectionBar: {
+        selection: string;
+        allResults: string;
+        more: string;
+        clear: string;
+    };
+    summaries: {
+        total: string;
+        page: string;
+        filtered: string;
+        selection: string;
     };
     columnsMenu: {
         sortAsc: string;
@@ -36,10 +57,24 @@ export interface UiToolsTableMessages {
         hideColumn: string;
     };
     filters: {
+        editor: {
+            clear: string;
+        };
+        sheet: {
+            done: string;
+            back: string;
+            sortBy: string;
+            order: string;
+        };
         panel: {
             trigger: string;
             clearAll: string;
             apply: string;
+            done: string;
+            reset: string;
+            results: string;
+            matching: string;
+            matchMode: string;
         };
         options: {
             empty: string;
@@ -73,6 +108,9 @@ export interface UiToolsTableMessages {
         empty: {
             title: string;
             description: string;
+            filteredTitle: string;
+            filteredDescription: string;
+            reset: string;
         };
         gridError: {
             title: string;
@@ -234,15 +272,59 @@ export interface UiToolsFormMessages {
         cancelButton: string;
         resetButton: string;
     };
+    states: {
+        contextError: {
+            title: string;
+            description: string;
+            action: string;
+        };
+    };
+    validation: {
+        required: string;
+        dateMin: string;
+        dateMax: string;
+    };
     fields: {
         text: {
             defaultPlaceholder: string;
+            clear: string;
+        };
+        description: {
+            more: string;
+            close: string;
+        };
+        file: {
+            drop: string;
+            replace: string;
+            remove: string;
+            add: string;
+        };
+        array: {
+            addItem: string;
+            removeItem: string;
+            dragItem: string;
+            editItem: string;
+            confirmDelete: string;
+            empty: string;
+            item: string;
+            expand: string;
+            collapse: string;
+            unique: string;
+        };
+        password: {
+            show: string;
+            hide: string;
+            requirements: string;
         };
         options: {
             refresh: string;
             create: string;
             creating: string;
             createNamed: string;
+            loadMore: string;
+            loadingMore: string;
+            retry: string;
+            loadError: string;
         };
         hierarchy: {
             search: string;
@@ -256,6 +338,7 @@ export interface UiToolsFormMessages {
             start: string;
             end: string;
             clear: string;
+            confirm: string;
         };
         time: {
             format: string;
@@ -275,6 +358,7 @@ export interface UiToolsFormMessages {
         phone: {
             country: string;
             number: string;
+            clear: string;
         };
     };
 }

package/dist/runtime/i18n/use-locale.d.ts

@@ -1,4 +1,4 @@
-import { type InjectionKey, type Ref } from 'vue';
+import type { InjectionKey, Ref } from 'vue';
 import type { Locale, Messages } from './types.js';
 export declare const uiToolsLocaleContextInjectionKey: InjectionKey<Ref<Locale<Messages> | undefined>>;
 export declare function useUiToolsLocaleRef(localeOverrides?: Ref<Locale<Messages> | undefined>): import("vue").ComputedRef<Locale<Messages>>;

package/dist/runtime/i18n/use-locale.js

@@ -1,16 +1,18 @@
 import { useLocale as useNuxtUiLocale } from "@nuxt/ui/composables/useLocale";
-import { computed, inject, provide } from "vue";
+import { computed, getCurrentInstance, inject, provide } from "vue";
 import { fr } from "./locales/index.js";
 import en from "./locales/en.js";
 import { buildUiToolsLocaleContext } from "./utils.js";
 export const uiToolsLocaleContextInjectionKey = Symbol.for("nuxt-ui-tools.locale-context");
+let fallbackLocale = null;
 export function useUiToolsLocaleRef(localeOverrides) {
-  const nuxtUiLocale = useNuxtUiLocale();
-  const injectedLocale = inject(uiToolsLocaleContextInjectionKey, void 0);
+  const instance = getCurrentInstance();
+  const nuxtUiLocale = instance ? useNuxtUiLocale() : null;
+  const injectedLocale = instance ? inject(uiToolsLocaleContextInjectionKey, null) : fallbackLocale;
   return computed(
     () => localeOverrides?.value ?? injectedLocale?.value ?? resolveUiToolsLocale({
-      code: nuxtUiLocale.code.value,
-      dir: nuxtUiLocale.dir.value
+      code: nuxtUiLocale?.code.value,
+      dir: nuxtUiLocale?.dir.value
     })
   );
 }
@@ -19,6 +21,7 @@ export function useUiToolsLocale(localeOverrides) {
   return buildUiToolsLocaleContext(computed(() => locale.value || en));
 }
 export function provideUiToolsLocale(locale) {
+  fallbackLocale = locale;
   provide(uiToolsLocaleContextInjectionKey, locale);
 }
 const uiToolsLocales = [en, fr];
@@ -33,5 +36,5 @@ function resolveUiToolsLocale(params) {
   };
 }
 function normalizeLocaleCode(value) {
-  return String(value ?? en.code).replace(/-/g, "_").toLowerCase();
+  return String(value ?? en.code).replaceAll("-", "_").toLowerCase();
 }

package/dist/runtime/i18n/utils.d.ts

@@ -1,4 +1,4 @@
-import { type MaybeRef, type Ref } from 'vue';
+import type { MaybeRef, Ref } from 'vue';
 import type { UiToolsDirection, UiToolsLocale } from '#ui-tools/i18n/types';
 export type UiToolsTranslatorOption = Record<string, string | number>;
 export type UiToolsTranslator = (path: string, option?: UiToolsTranslatorOption) => string;

package/dist/runtime/i18n/utils.js

@@ -1,9 +1,12 @@
 import { computed, unref } from "vue";
 import { getObjectProperty } from "#ui-tools/shared/utils/object";
+import { isString } from "#ui-tools/shared/utils/predicate";
 export function translateUiToolsMessage(path, option, locale) {
   const message = getObjectProperty(locale.messages, path);
-  if (typeof message !== "string") return path;
-  return message.replace(/\{(\w+)\}/g, (_, key) => `${option?.[key] ?? `{${key}}`}`);
+  if (!isString(message)) {
+    return path;
+  }
+  return message.replaceAll(/\{(\w+)\}/gu, (_, key) => `${option?.[key] ?? `{${key}}`}`);
 }
 export function buildUiToolsTranslator(locale) {
   return (path, option) => translateUiToolsMessage(path, option, unref(locale));
@@ -11,10 +14,10 @@ export function buildUiToolsTranslator(locale) {
 export function buildUiToolsLocaleContext(locale) {
   const localeRef = computed(() => unref(locale));
   return {
-    locale: localeRef,
-    lang: computed(() => unref(locale).name),
-    dir: computed(() => unref(locale).dir),
     code: computed(() => unref(locale).code),
+    dir: computed(() => unref(locale).dir),
+    lang: computed(() => unref(locale).name),
+    locale: localeRef,
     t: buildUiToolsTranslator(locale)
   };
 }

package/dist/runtime/query-prefetch/index.d.ts

@@ -0,0 +1,2 @@
+export * from './types/index.js';
+export * from './utils/index.js';

package/dist/runtime/query-prefetch/index.js

@@ -0,0 +1,2 @@
+export * from "./types/index.js";
+export * from "./utils/index.js";

package/dist/runtime/query-prefetch/plugins/link-prefetch.client.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("#app/nuxt").Plugin<Record<never, never>> & import("#app/nuxt").ObjectPlugin<Record<never, never>>;
+export default _default;

package/dist/runtime/query-prefetch/plugins/link-prefetch.client.js

@@ -0,0 +1,8 @@
+import { defineNuxtPlugin } from "#app";
+import { prefetchPage } from "../utils/prefetch-page.js";
+export default defineNuxtPlugin({
+  name: "nuxt-ui-tools:query-prefetch",
+  setup(nuxtApp) {
+    nuxtApp.hook("link:prefetch", (to) => nuxtApp.runWithContext(() => prefetchPage(to)));
+  }
+});

package/dist/runtime/query-prefetch/types/index.d.ts

@@ -0,0 +1,2 @@
+export * from './plan.js';
+export * from './page.js';

package/dist/runtime/query-prefetch/types/index.js

@@ -0,0 +1,2 @@
+export * from "./plan.js";
+export * from "./page.js";

package/dist/runtime/query-prefetch/types/page.d.ts

@@ -0,0 +1,55 @@
+import type { QueryClient } from '@tanstack/vue-query';
+import type { RouteLocationResolvedGeneric, RouteMap, RouteMapGeneric, RouteParamsGeneric } from 'vue-router';
+import type { QueryPrefetchEntry } from './plan.js';
+type RouteMapNames = Extract<keyof RouteMap, string>;
+/**
+ * Route names usable with `defineQueryPrefetch(...)`.
+ *
+ * Falls back to plain `string` when `experimental.typedPages` is disabled, so
+ * the macro stays usable in apps without typed routes.
+ */
+export type QueryPrefetchRouteName = [RouteMap] extends [RouteMapGeneric] ? string : RouteMapNames;
+type QueryPrefetchRouteParams<TRouteName extends QueryPrefetchRouteName> = [RouteMap] extends [
+    RouteMapGeneric
+] ? RouteParamsGeneric : TRouteName extends keyof RouteMap ? RouteMap[TRouteName]['params'] : RouteParamsGeneric;
+export type QueryPrefetchRuntimeRoute = Pick<RouteLocationResolvedGeneric, 'fullPath' | 'hash' | 'name' | 'params' | 'path' | 'query'>;
+/**
+ * The destination route exposed to a prefetch resolver, with `params` narrowed
+ * from the route name when typed pages are enabled.
+ */
+export type QueryPrefetchRoute<TRouteName extends QueryPrefetchRouteName> = Omit<QueryPrefetchRuntimeRoute, 'params'> & {
+    params: QueryPrefetchRouteParams<TRouteName>;
+};
+/**
+ * What a page-level prefetch resolver may return: a single query, a staged
+ * plan, or a mixed array of both (array entries run in parallel).
+ */
+export type QueryPrefetchOptions = QueryPrefetchEntry | readonly QueryPrefetchEntry[];
+export interface QueryPrefetchRuntimeContext {
+    queryClient: QueryClient;
+    route: QueryPrefetchRuntimeRoute;
+}
+export interface QueryPrefetchResolveContext<TRouteName extends QueryPrefetchRouteName> {
+    queryClient: QueryClient;
+    route: QueryPrefetchRoute<TRouteName>;
+}
+/**
+ * A page's declared data requirements, stored on `route.meta.queryPrefetch` by
+ * the `defineQueryPrefetch(...)` macro and executed on link prefetch or through
+ * `prefetchPage(...)`.
+ */
+export interface QueryPrefetchDefinition {
+    resolve: (context: QueryPrefetchRuntimeContext) => QueryPrefetchOptions;
+    routeName: QueryPrefetchRouteName;
+}
+declare module 'vue-router' {
+    interface RouteMeta {
+        queryPrefetch?: QueryPrefetchDefinition;
+    }
+}
+declare module 'nuxt/app' {
+    interface PageMeta {
+        queryPrefetch?: QueryPrefetchDefinition;
+    }
+}
+export {};

package/dist/runtime/query-prefetch/types/plan.d.ts

@@ -0,0 +1,55 @@
+import type { InferDataFromTag, QueryKey, UseQueryOptions } from '@tanstack/vue-query';
+import type { GenericObject, MaybePromise } from '#ui-tools/shared/types/utils';
+/**
+ * Minimal query shape accepted by the prefetch executor.
+ *
+ * Deliberately duck-typed so any `queryOptions(...)` output or hand-written
+ * definition works without forcing TanStack generics on consumers. Entries with
+ * `enabled: false` are skipped, and a `select` transform is applied to the
+ * fetched data before it is exposed to later stages.
+ */
+export interface QueryPrefetchOption {
+    queryKey: QueryKey;
+}
+export type QueryPrefetchEntry = QueryPrefetchOption | QueryPrefetchPlan;
+export type QueryPrefetchQueries = Readonly<Record<string, QueryPrefetchOption>>;
+/** Values accumulated by staged prefetch resolvers after query data is decoded. */
+export type QueryPrefetchContext = GenericObject;
+type QueryPrefetchFunctionResult<Value> = Value extends (...args: never[]) => infer Result ? Result : Value extends {
+    value: infer Inner;
+} ? QueryPrefetchFunctionResult<Inner> : never;
+type QueryPrefetchResult<Option> = Option extends {
+    value: infer Inner;
+} ? QueryPrefetchResult<Inner> : Option extends {
+    select?: infer Select;
+} ? [QueryPrefetchFunctionResult<NonNullable<Select>>] extends [never] ? QueryPrefetchDataResult<Option> : QueryPrefetchFunctionResult<NonNullable<Select>> : QueryPrefetchDataResult<Option>;
+type QueryPrefetchDataResult<Option> = Option extends {
+    queryKey: infer Key;
+} ? Key extends QueryKey ? unknown extends InferDataFromTag<unknown, Key> ? Option extends {
+    queryFn?: infer QueryFn;
+} ? Awaited<QueryPrefetchFunctionResult<NonNullable<QueryFn>>> : unknown : InferDataFromTag<unknown, Key> : unknown : Option extends UseQueryOptions<infer _QueryFnData, infer _Error, infer Data, infer _QD, infer _QK> ? Data : unknown;
+type QueryPrefetchStageResults<Queries extends QueryPrefetchQueries> = {
+    [Key in keyof Queries]: QueryPrefetchResult<Queries[Key]>;
+};
+export interface QueryPrefetchStage {
+    resolve(context: Readonly<QueryPrefetchContext>): MaybePromise<QueryPrefetchQueries>;
+}
+/**
+ * An immutable, chainable staged prefetch plan.
+ *
+ * Each `.stage(...)` accepts either a static map of query options or a function
+ * receiving the accumulated context of all previous stages. The context type
+ * accumulates the `select`-ed data types of every stage, so dependent stages
+ * stay fully typed:
+ *
+ * ```ts
+ * defineQueryPrefetchPlan()
+ *   .stage({ item: itemQuery })
+ *   .stage(({ item }) => ({ details: detailsQuery(item.id) }))
+ * ```
+ */
+export interface QueryPrefetchPlan<Context extends object = object> {
+    kind: 'query-prefetch-plan';
+    stage: <const Queries extends QueryPrefetchQueries>(queries: Queries | ((context: Readonly<Context>) => MaybePromise<Queries>)) => QueryPrefetchPlan<Context & QueryPrefetchStageResults<Queries>>;
+}
+export {};

package/dist/runtime/query-prefetch/utils/index.d.ts

@@ -0,0 +1,3 @@
+export * from './plan.js';
+export * from './page.js';
+export * from './prefetch-page.js';

package/dist/runtime/query-prefetch/utils/index.js

@@ -0,0 +1,3 @@
+export * from "./plan.js";
+export * from "./page.js";
+export * from "./prefetch-page.js";

package/dist/runtime/query-prefetch/utils/page.d.ts

@@ -0,0 +1,24 @@
+import type { QueryPrefetchDefinition, QueryPrefetchOptions, QueryPrefetchResolveContext, QueryPrefetchRouteName, QueryPrefetchRuntimeContext } from '../types/page.js';
+/**
+ * Declares the data a page needs, for use as a page macro:
+ *
+ * ```ts
+ * defineQueryPrefetch('items', ({ route }) => prefetchTable({ route, schema: itemsSchema() }))
+ * ```
+ *
+ * A build-time transform moves the call into `definePageMeta({ queryPrefetch })`,
+ * so any resolved route carries its own data requirements. The definition is
+ * executed when Nuxt links prefetch the route (`link:prefetch`) or when
+ * `prefetchPage(...)` is called manually (hover menus, buttons, middleware).
+ *
+ * Route names and `route.params` are typed when `experimental.typedPages` is
+ * enabled; otherwise any string route name is accepted.
+ */
+export declare function defineQueryPrefetch<const TRouteName extends QueryPrefetchRouteName, const TOptions extends QueryPrefetchOptions>(routeName: TRouteName, resolve: (context: QueryPrefetchResolveContext<TRouteName>) => TOptions): QueryPrefetchDefinition;
+/**
+ * Executes a page's prefetch definition: plain query options are prefetched in
+ * parallel, staged plans run through `executeQueryPrefetchPlan(...)`. Returns
+ * the resolved data per entry (plans contribute their first stage's first
+ * result), unwrapping single-element arrays.
+ */
+export declare function executeQueryPrefetch(definition: QueryPrefetchDefinition, context: QueryPrefetchRuntimeContext): Promise<any[] | never[]>;

package/dist/runtime/query-prefetch/utils/page.js

@@ -0,0 +1,63 @@
+import { hasProperty, isFunction, isObject } from "#ui-tools/shared/utils/predicate";
+import { executeQueryPrefetchPlan, isQueryPrefetchPlan } from "./plan.js";
+export function defineQueryPrefetch(routeName, resolve) {
+  return {
+    resolve: (context) => resolve({
+      queryClient: context.queryClient,
+      route: narrowQueryPrefetchRoute(context.route, routeName)
+    }),
+    routeName
+  };
+}
+export function executeQueryPrefetch(definition, context) {
+  return Promise.resolve().then(() => definition.resolve(context)).then((resolved) => {
+    const entries = isQueryPrefetchEntry(resolved) ? [resolved] : resolved;
+    return Promise.all(
+      entries.map((entry) => {
+        if (!isQueryPrefetchPlan(entry)) {
+          return executeQueryOptions([entry], context.queryClient);
+        }
+        return executeQueryPrefetchPlan(entry, {
+          queryClient: context.queryClient
+        }).then((stageContext) => Object.values(stageContext)[0]);
+      })
+    );
+  }).then(
+    (results) => results.map((result) => Array.isArray(result) && result.length === 1 ? result[0] : result)
+  ).catch(() => []);
+}
+function executeQueryOptions(queries, queryClient) {
+  return Promise.all(
+    queries.map(async (query) => {
+      if (hasProperty(query, "enabled") && query.enabled === false) {
+        return;
+      }
+      try {
+        await queryClient.ensureQueryData({ ...query, revalidateIfStale: true });
+        const data = queryClient.getQueryData(query.queryKey);
+        const select = hasProperty(query, "select") ? query.select : void 0;
+        return data !== void 0 && isQueryPrefetchSelector(select) ? select(data) : data;
+      } catch {
+        return;
+      }
+    })
+  );
+}
+function isQueryPrefetchEntry(value) {
+  if (Array.isArray(value)) {
+    return false;
+  }
+  return isQueryPrefetchPlan(value) || "queryKey" in value;
+}
+function isQueryPrefetchSelector(value) {
+  return isFunction(value);
+}
+function narrowQueryPrefetchRoute(route, routeName) {
+  if (isQueryPrefetchRoute(route, routeName)) {
+    return route;
+  }
+  throw new Error(`Unable to resolve typed query-prefetch route ${String(routeName)}`);
+}
+function isQueryPrefetchRoute(route, _routeName) {
+  return isObject(route.params);
+}

package/dist/runtime/query-prefetch/utils/plan.d.ts

@@ -0,0 +1,29 @@
+import type { QueryClient } from '@tanstack/vue-query';
+import type { QueryPrefetchEntry, QueryPrefetchOption, QueryPrefetchPlan } from '../types/plan.js';
+type QueryPrefetchCandidate = QueryPrefetchEntry | readonly QueryPrefetchEntry[];
+/**
+ * Starts a staged query prefetch plan.
+ *
+ * Stages run sequentially and queries within a stage run in parallel. Each
+ * stage callback receives the accumulated (selected) results of all previous
+ * stages, keyed by the record keys used when declaring them.
+ *
+ * Execute a plan with `executeQueryPrefetchPlan(...)`, return it from a
+ * `defineQueryPrefetch(...)` resolver, or build one from a table schema with
+ * `prefetchTable(...)`.
+ */
+export declare function defineQueryPrefetchPlan(): QueryPrefetchPlan<{}>;
+/**
+ * Executes a staged prefetch plan against a TanStack query client.
+ *
+ * Uses `ensureQueryData({ revalidateIfStale: true })` so warm, fresh cache
+ * entries are reused as-is. Errors are swallowed and the partially accumulated
+ * context is returned: prefetch is opportunistic and must never break
+ * navigation — the destination page's own queries remain the correctness path.
+ */
+export declare function executeQueryPrefetchPlan(plan: QueryPrefetchPlan, { queryClient }: {
+    queryClient: QueryClient;
+}): Promise<import("#ui-tools/shared/types/utils").GenericObject>;
+export declare function isQueryPrefetchPlan(value: QueryPrefetchCandidate): value is QueryPrefetchPlan;
+export declare function isQueryPrefetchOption(value: QueryPrefetchCandidate): value is QueryPrefetchOption;
+export {};

package/dist/runtime/query-prefetch/utils/plan.js

@@ -0,0 +1,67 @@
+import { hasProperty, isFunction } from "#ui-tools/shared/utils/predicate";
+const queryPrefetchStages = /* @__PURE__ */ new WeakMap();
+function createQueryPrefetchPlan(stages) {
+  const plan = {
+    kind: "query-prefetch-plan",
+    stage(queries) {
+      const stage = {
+        resolve(context) {
+          return isQueryPrefetchResolver(queries) ? queries(context) : queries;
+        }
+      };
+      return createQueryPrefetchPlan([...stages, stage]);
+    }
+  };
+  queryPrefetchStages.set(plan, stages);
+  return plan;
+}
+export function defineQueryPrefetchPlan() {
+  return createQueryPrefetchPlan([]);
+}
+export async function executeQueryPrefetchPlan(plan, { queryClient }) {
+  const context = {};
+  try {
+    for (const stage of queryPrefetchStages.get(plan) ?? []) {
+      const queries = await stage.resolve(context);
+      const entries = Object.entries(queries);
+      const results = await Promise.all(
+        entries.map(([, query]) => executeQuery(query, queryClient))
+      );
+      Object.assign(
+        context,
+        Object.fromEntries(entries.map(([key], index) => [key, results[index]]))
+      );
+    }
+  } catch {
+    return context;
+  }
+  return context;
+}
+export function isQueryPrefetchPlan(value) {
+  if (Array.isArray(value)) {
+    return false;
+  }
+  return hasProperty(value, "kind") && value.kind === "query-prefetch-plan";
+}
+export function isQueryPrefetchOption(value) {
+  if (Array.isArray(value)) {
+    return false;
+  }
+  return hasProperty(value, "queryKey") && Array.isArray(value.queryKey);
+}
+function executeQuery(query, queryClient) {
+  if (hasProperty(query, "enabled") && query.enabled === false) {
+    return Promise.resolve();
+  }
+  return queryClient.ensureQueryData({ ...query, revalidateIfStale: true }).then((data) => {
+    const select = hasProperty(query, "select") ? query.select : void 0;
+    return isQueryPrefetchSelector(select) ? select(data) : data;
+  }).catch(() => {
+  });
+}
+function isQueryPrefetchSelector(value) {
+  return isFunction(value);
+}
+function isQueryPrefetchResolver(value) {
+  return isFunction(value);
+}

package/dist/runtime/query-prefetch/utils/prefetch-page.d.ts

@@ -0,0 +1,17 @@
+import type { RouteLocationRaw } from 'vue-router';
+/**
+ * Prefetches a route's declared data (`route.meta.queryPrefetch`) and its lazy
+ * components without navigating.
+ *
+ * Wired automatically to Nuxt's `link:prefetch` hook by the module, so plain
+ * `<NuxtLink>` prefetch strategies trigger it. Call it manually for non-link
+ * interactions such as hover menus:
+ *
+ * ```ts
+ * onMouseenter: () => prefetchPage('/items')
+ * ```
+ *
+ * In-flight prefetches are deduped per destination `fullPath`, cross-origin
+ * URLs are ignored, and normal query staleness rules own any later refetch.
+ */
+export declare function prefetchPage(to: RouteLocationRaw): Promise<void>;

package/dist/runtime/query-prefetch/utils/prefetch-page.js

@@ -0,0 +1,57 @@
+import { useQueryClient } from "@tanstack/vue-query";
+import { preloadRouteComponents, useNuxtApp, useRouter } from "nuxt/app";
+import { isString } from "#ui-tools/shared/utils/predicate";
+import { executeQueryPrefetch } from "./page.js";
+const pendingPagePrefetches = /* @__PURE__ */ new WeakMap();
+export function prefetchPage(to) {
+  const nuxtApp = useNuxtApp();
+  const router = useRouter();
+  const route = resolvePrefetchRoute(to, router);
+  if (!route?.matched.length) {
+    return Promise.resolve();
+  }
+  let pendingPages = pendingPagePrefetches.get(nuxtApp);
+  if (!pendingPages) {
+    pendingPages = /* @__PURE__ */ new Map();
+    pendingPagePrefetches.set(nuxtApp, pendingPages);
+  }
+  const pending = pendingPages.get(route.fullPath);
+  if (pending) {
+    return pending;
+  }
+  const definition = route.meta.queryPrefetch;
+  const prefetch = Promise.allSettled([
+    Promise.resolve().then(() => {
+      if (import.meta.client) {
+        return preloadRouteComponents(route.fullPath, router);
+      }
+    }),
+    definition ? Promise.resolve().then(
+      () => nuxtApp.runWithContext(
+        () => executeQueryPrefetch(definition, {
+          queryClient: resolvePrefetchQueryClient(),
+          route
+        })
+      )
+    ) : Promise.resolve()
+  ]).then(() => {
+  });
+  pendingPages.set(route.fullPath, prefetch);
+  return prefetch.finally(() => {
+    pendingPages.delete(route.fullPath);
+  });
+}
+function resolvePrefetchRoute(to, router) {
+  if (import.meta.server || !isString(to)) {
+    return router.resolve(to);
+  }
+  const target = new URL(to, window.location.href);
+  if (target.origin !== window.location.origin) {
+    return null;
+  }
+  return router.resolve(`${target.pathname}${target.search}${target.hash}`);
+}
+function resolvePrefetchQueryClient() {
+  const nuxtApp = useNuxtApp();
+  return nuxtApp.vueApp.runWithContext(() => useQueryClient());
+}