@pastweb/vue 2.0.0

package/dist/api/hooks/index.js

@@ -0,0 +1,13 @@
+import { reuseMutation, reuseQuery } from "./reuseQuery/reuseQuery.js";
+import "./reuseQuery/index.js";
+import { useInfiniteQuery } from "./useInfiniteQuery/useInfiniteQuery.js";
+import "./useInfiniteQuery/index.js";
+import { useApiQueryCache } from "./useApiQueryCache/useApiQueryCache.js";
+import "./useApiQueryCache/index.js";
+import { useMutation } from "./useMutation/useMutation.js";
+import "./useMutation/index.js";
+import { useQueries } from "./useQueries/useQueries.js";
+import "./useQueries/index.js";
+import { useQuery } from "./useQuery/useQuery.js";
+import "./useQuery/index.js";
+export { reuseMutation, reuseQuery, useApiQueryCache, useInfiniteQuery, useMutation, useQueries, useQuery };

package/dist/api/hooks/reuseQuery/index.cjs

@@ -0,0 +1,4 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_api_hooks_reuseQuery_reuseQuery = require("./reuseQuery.cjs");
+exports.reuseMutation = require_api_hooks_reuseQuery_reuseQuery.reuseMutation;
+exports.reuseQuery = require_api_hooks_reuseQuery_reuseQuery.reuseQuery;

package/dist/api/hooks/reuseQuery/index.d.cts

@@ -0,0 +1,2 @@
+import { reuseMutation, reuseQuery } from "./reuseQuery.cjs";
+export { reuseMutation, reuseQuery };

package/dist/api/hooks/reuseQuery/index.d.ts

@@ -0,0 +1,2 @@
+import { reuseMutation, reuseQuery } from "./reuseQuery.js";
+export { reuseMutation, reuseQuery };

package/dist/api/hooks/reuseQuery/index.js

@@ -0,0 +1,2 @@
+import { reuseMutation, reuseQuery } from "./reuseQuery.js";
+export { reuseMutation, reuseQuery };

package/dist/api/hooks/reuseQuery/reuseQuery.cjs

@@ -0,0 +1,44 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_api_hooks_utils_useReactiveRender = require("../utils/useReactiveRender.cjs");
+require("../utils/index.cjs");
+//#region src/api/hooks/reuseQuery/reuseQuery.ts
+/**
+* Reuses a tools reactive query-like state inside Vue rendering.
+*
+* `createState` is called when the composable runs. The returned tools
+* reactive object is wrapped by {@link useReactiveRender}, so Vue components
+* that read its fields update when those fields change.
+*
+* Use this helper to build custom Vue composables from the framework-agnostic
+* `@pastweb/tools` query primitives without reimplementing their state
+* machines.
+*
+* @typeParam TState - Reactive state object returned by a tools hook.
+* @param createState - Factory that creates the tools reactive state.
+* @returns The same state shape, bridged into Vue rendering.
+*
+* @example
+* ```ts
+* import { useQuery as createToolsQuery } from '@pastweb/tools';
+* import { reuseQuery } from '@pastweb/vue';
+*
+* export function useUsers(agent: Agent) {
+*   return reuseQuery(() => createToolsQuery({
+*     fn: () => agent.get('/api/users', { queryKey: ['users'] }),
+*   }));
+* }
+* ```
+*/
+function reuseQuery(createState) {
+	return require_api_hooks_utils_useReactiveRender.useReactiveRender(createState);
+}
+/**
+* Semantic alias for {@link reuseQuery} when the reused state represents a
+* mutation rather than a query.
+*/
+const reuseMutation = reuseQuery;
+//#endregion
+exports.reuseMutation = reuseMutation;
+exports.reuseQuery = reuseQuery;
+
+//# sourceMappingURL=reuseQuery.cjs.map

package/dist/api/hooks/reuseQuery/reuseQuery.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"reuseQuery.cjs","names":["useReactiveRender"],"sources":["../../../../src/api/hooks/reuseQuery/reuseQuery.ts"],"sourcesContent":["import { useReactiveRender } from '../utils';\n\n/**\n * Reuses a tools reactive query-like state inside Vue rendering.\n *\n * `createState` is called when the composable runs. The returned tools\n * reactive object is wrapped by {@link useReactiveRender}, so Vue components\n * that read its fields update when those fields change.\n *\n * Use this helper to build custom Vue composables from the framework-agnostic\n * `@pastweb/tools` query primitives without reimplementing their state\n * machines.\n *\n * @typeParam TState - Reactive state object returned by a tools hook.\n * @param createState - Factory that creates the tools reactive state.\n * @returns The same state shape, bridged into Vue rendering.\n *\n * @example\n * ```ts\n * import { useQuery as createToolsQuery } from '@pastweb/tools';\n * import { reuseQuery } from '@pastweb/vue';\n *\n * export function useUsers(agent: Agent) {\n *   return reuseQuery(() => createToolsQuery({\n *     fn: () => agent.get('/api/users', { queryKey: ['users'] }),\n *   }));\n * }\n * ```\n */\nexport function reuseQuery<TState extends Record<PropertyKey, any>>(createState: () => TState): TState {\n  return useReactiveRender(createState);\n}\n\n/**\n * Semantic alias for {@link reuseQuery} when the reused state represents a\n * mutation rather than a query.\n */\nexport const reuseMutation = reuseQuery;\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6BA,SAAgB,WAAoD,aAAmC;CACrG,OAAOA,0CAAAA,kBAAkB,WAAW;AACtC;;;;;AAMA,MAAa,gBAAgB"}

package/dist/api/hooks/reuseQuery/reuseQuery.d.cts

@@ -0,0 +1,37 @@
+//#region src/api/hooks/reuseQuery/reuseQuery.d.ts
+/**
+ * Reuses a tools reactive query-like state inside Vue rendering.
+ *
+ * `createState` is called when the composable runs. The returned tools
+ * reactive object is wrapped by {@link useReactiveRender}, so Vue components
+ * that read its fields update when those fields change.
+ *
+ * Use this helper to build custom Vue composables from the framework-agnostic
+ * `@pastweb/tools` query primitives without reimplementing their state
+ * machines.
+ *
+ * @typeParam TState - Reactive state object returned by a tools hook.
+ * @param createState - Factory that creates the tools reactive state.
+ * @returns The same state shape, bridged into Vue rendering.
+ *
+ * @example
+ * ```ts
+ * import { useQuery as createToolsQuery } from '@pastweb/tools';
+ * import { reuseQuery } from '@pastweb/vue';
+ *
+ * export function useUsers(agent: Agent) {
+ *   return reuseQuery(() => createToolsQuery({
+ *     fn: () => agent.get('/api/users', { queryKey: ['users'] }),
+ *   }));
+ * }
+ * ```
+ */
+declare function reuseQuery<TState extends Record<PropertyKey, any>>(createState: () => TState): TState;
+/**
+ * Semantic alias for {@link reuseQuery} when the reused state represents a
+ * mutation rather than a query.
+ */
+declare const reuseMutation: typeof reuseQuery;
+//#endregion
+export { reuseMutation, reuseQuery };
+//# sourceMappingURL=reuseQuery.d.cts.map

package/dist/api/hooks/reuseQuery/reuseQuery.d.ts

@@ -0,0 +1,37 @@
+//#region src/api/hooks/reuseQuery/reuseQuery.d.ts
+/**
+ * Reuses a tools reactive query-like state inside Vue rendering.
+ *
+ * `createState` is called when the composable runs. The returned tools
+ * reactive object is wrapped by {@link useReactiveRender}, so Vue components
+ * that read its fields update when those fields change.
+ *
+ * Use this helper to build custom Vue composables from the framework-agnostic
+ * `@pastweb/tools` query primitives without reimplementing their state
+ * machines.
+ *
+ * @typeParam TState - Reactive state object returned by a tools hook.
+ * @param createState - Factory that creates the tools reactive state.
+ * @returns The same state shape, bridged into Vue rendering.
+ *
+ * @example
+ * ```ts
+ * import { useQuery as createToolsQuery } from '@pastweb/tools';
+ * import { reuseQuery } from '@pastweb/vue';
+ *
+ * export function useUsers(agent: Agent) {
+ *   return reuseQuery(() => createToolsQuery({
+ *     fn: () => agent.get('/api/users', { queryKey: ['users'] }),
+ *   }));
+ * }
+ * ```
+ */
+declare function reuseQuery<TState extends Record<PropertyKey, any>>(createState: () => TState): TState;
+/**
+ * Semantic alias for {@link reuseQuery} when the reused state represents a
+ * mutation rather than a query.
+ */
+declare const reuseMutation: typeof reuseQuery;
+//#endregion
+export { reuseMutation, reuseQuery };
+//# sourceMappingURL=reuseQuery.d.ts.map

package/dist/api/hooks/reuseQuery/reuseQuery.js

@@ -0,0 +1,42 @@
+import { useReactiveRender } from "../utils/useReactiveRender.js";
+import "../utils/index.js";
+//#region src/api/hooks/reuseQuery/reuseQuery.ts
+/**
+* Reuses a tools reactive query-like state inside Vue rendering.
+*
+* `createState` is called when the composable runs. The returned tools
+* reactive object is wrapped by {@link useReactiveRender}, so Vue components
+* that read its fields update when those fields change.
+*
+* Use this helper to build custom Vue composables from the framework-agnostic
+* `@pastweb/tools` query primitives without reimplementing their state
+* machines.
+*
+* @typeParam TState - Reactive state object returned by a tools hook.
+* @param createState - Factory that creates the tools reactive state.
+* @returns The same state shape, bridged into Vue rendering.
+*
+* @example
+* ```ts
+* import { useQuery as createToolsQuery } from '@pastweb/tools';
+* import { reuseQuery } from '@pastweb/vue';
+*
+* export function useUsers(agent: Agent) {
+*   return reuseQuery(() => createToolsQuery({
+*     fn: () => agent.get('/api/users', { queryKey: ['users'] }),
+*   }));
+* }
+* ```
+*/
+function reuseQuery(createState) {
+	return useReactiveRender(createState);
+}
+/**
+* Semantic alias for {@link reuseQuery} when the reused state represents a
+* mutation rather than a query.
+*/
+const reuseMutation = reuseQuery;
+//#endregion
+export { reuseMutation, reuseQuery };
+
+//# sourceMappingURL=reuseQuery.js.map

package/dist/api/hooks/reuseQuery/reuseQuery.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"reuseQuery.js","names":[],"sources":["../../../../src/api/hooks/reuseQuery/reuseQuery.ts"],"sourcesContent":["import { useReactiveRender } from '../utils';\n\n/**\n * Reuses a tools reactive query-like state inside Vue rendering.\n *\n * `createState` is called when the composable runs. The returned tools\n * reactive object is wrapped by {@link useReactiveRender}, so Vue components\n * that read its fields update when those fields change.\n *\n * Use this helper to build custom Vue composables from the framework-agnostic\n * `@pastweb/tools` query primitives without reimplementing their state\n * machines.\n *\n * @typeParam TState - Reactive state object returned by a tools hook.\n * @param createState - Factory that creates the tools reactive state.\n * @returns The same state shape, bridged into Vue rendering.\n *\n * @example\n * ```ts\n * import { useQuery as createToolsQuery } from '@pastweb/tools';\n * import { reuseQuery } from '@pastweb/vue';\n *\n * export function useUsers(agent: Agent) {\n *   return reuseQuery(() => createToolsQuery({\n *     fn: () => agent.get('/api/users', { queryKey: ['users'] }),\n *   }));\n * }\n * ```\n */\nexport function reuseQuery<TState extends Record<PropertyKey, any>>(createState: () => TState): TState {\n  return useReactiveRender(createState);\n}\n\n/**\n * Semantic alias for {@link reuseQuery} when the reused state represents a\n * mutation rather than a query.\n */\nexport const reuseMutation = reuseQuery;\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6BA,SAAgB,WAAoD,aAAmC;CACrG,OAAO,kBAAkB,WAAW;AACtC;;;;;AAMA,MAAa,gBAAgB"}

package/dist/api/hooks/useApiQueryCache/index.cjs

@@ -0,0 +1,3 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_api_hooks_useApiQueryCache_useApiQueryCache = require("./useApiQueryCache.cjs");
+exports.useApiQueryCache = require_api_hooks_useApiQueryCache_useApiQueryCache.useApiQueryCache;

package/dist/api/hooks/useApiQueryCache/index.d.cts

@@ -0,0 +1,2 @@
+import { useApiQueryCache } from "./useApiQueryCache.cjs";
+export { useApiQueryCache };

package/dist/api/hooks/useApiQueryCache/index.d.ts

@@ -0,0 +1,2 @@
+import { useApiQueryCache } from "./useApiQueryCache.js";
+export { useApiQueryCache };

package/dist/api/hooks/useApiQueryCache/index.js

@@ -0,0 +1,2 @@
+import { useApiQueryCache } from "./useApiQueryCache.js";
+export { useApiQueryCache };

package/dist/api/hooks/useApiQueryCache/useApiQueryCache.cjs

@@ -0,0 +1,31 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_getContext_getContext = require("../../../getContext/getContext.cjs");
+require("../../../getContext/index.cjs");
+let _pastweb_tools_api_createQueryCache_constants = require("@pastweb/tools/api/createQueryCache/constants");
+//#region src/api/hooks/useApiQueryCache/useApiQueryCache.ts
+/**
+* Returns the active tools `QueryCache` from Vue dependency injection.
+*
+* The cache is provided by installing the plugin returned from
+* {@link installApiCache}. This keeps cache ownership in `@pastweb/tools`
+* while exposing Vue-friendly access for composables and components.
+*
+* @returns The active tools `QueryCache`.
+* @throws When no query cache has been provided in the current app tree.
+*
+* @example
+* ```ts
+* import { useApiQueryCache } from '@pastweb/vue';
+*
+* const queryCache = useApiQueryCache();
+* ```
+*/
+function useApiQueryCache() {
+	const queryCache = require_getContext_getContext.getContext(_pastweb_tools_api_createQueryCache_constants.QUERY_CACHE_CONTEXT_KEY);
+	if (!queryCache) throw new Error("useApiQueryCache error: queryCache must be installed via installApiCache.");
+	return queryCache;
+}
+//#endregion
+exports.useApiQueryCache = useApiQueryCache;
+
+//# sourceMappingURL=useApiQueryCache.cjs.map

package/dist/api/hooks/useApiQueryCache/useApiQueryCache.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"useApiQueryCache.cjs","names":["getContext","QUERY_CACHE_CONTEXT_KEY"],"sources":["../../../../src/api/hooks/useApiQueryCache/useApiQueryCache.ts"],"sourcesContent":["import { QUERY_CACHE_CONTEXT_KEY } from '@pastweb/tools/api/createQueryCache/constants';\nimport type { QueryCache } from '@pastweb/tools/api/createQueryCache/types';\nimport { getContext } from '../../../getContext';\n\n/**\n * Returns the active tools `QueryCache` from Vue dependency injection.\n *\n * The cache is provided by installing the plugin returned from\n * {@link installApiCache}. This keeps cache ownership in `@pastweb/tools`\n * while exposing Vue-friendly access for composables and components.\n *\n * @returns The active tools `QueryCache`.\n * @throws When no query cache has been provided in the current app tree.\n *\n * @example\n * ```ts\n * import { useApiQueryCache } from '@pastweb/vue';\n *\n * const queryCache = useApiQueryCache();\n * ```\n */\nexport function useApiQueryCache(): QueryCache {\n  const queryCache = getContext<QueryCache | undefined>(QUERY_CACHE_CONTEXT_KEY);\n\n  if (!queryCache) {\n    throw new Error(\n      'useApiQueryCache error: queryCache must be installed via installApiCache.'\n    );\n  }\n\n  return queryCache;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;AAqBA,SAAgB,mBAA+B;CAC7C,MAAM,aAAaA,8BAAAA,WAAmCC,8CAAAA,uBAAuB;CAE7E,IAAI,CAAC,YACH,MAAM,IAAI,MACR,2EACF;CAGF,OAAO;AACT"}

package/dist/api/hooks/useApiQueryCache/useApiQueryCache.d.cts

@@ -0,0 +1,24 @@
+import { QueryCache } from "@pastweb/tools/api/createQueryCache/types";
+
+//#region src/api/hooks/useApiQueryCache/useApiQueryCache.d.ts
+/**
+ * Returns the active tools `QueryCache` from Vue dependency injection.
+ *
+ * The cache is provided by installing the plugin returned from
+ * {@link installApiCache}. This keeps cache ownership in `@pastweb/tools`
+ * while exposing Vue-friendly access for composables and components.
+ *
+ * @returns The active tools `QueryCache`.
+ * @throws When no query cache has been provided in the current app tree.
+ *
+ * @example
+ * ```ts
+ * import { useApiQueryCache } from '@pastweb/vue';
+ *
+ * const queryCache = useApiQueryCache();
+ * ```
+ */
+declare function useApiQueryCache(): QueryCache;
+//#endregion
+export { useApiQueryCache };
+//# sourceMappingURL=useApiQueryCache.d.cts.map

package/dist/api/hooks/useApiQueryCache/useApiQueryCache.d.ts

@@ -0,0 +1,24 @@
+import { QueryCache } from "@pastweb/tools/api/createQueryCache/types";
+
+//#region src/api/hooks/useApiQueryCache/useApiQueryCache.d.ts
+/**
+ * Returns the active tools `QueryCache` from Vue dependency injection.
+ *
+ * The cache is provided by installing the plugin returned from
+ * {@link installApiCache}. This keeps cache ownership in `@pastweb/tools`
+ * while exposing Vue-friendly access for composables and components.
+ *
+ * @returns The active tools `QueryCache`.
+ * @throws When no query cache has been provided in the current app tree.
+ *
+ * @example
+ * ```ts
+ * import { useApiQueryCache } from '@pastweb/vue';
+ *
+ * const queryCache = useApiQueryCache();
+ * ```
+ */
+declare function useApiQueryCache(): QueryCache;
+//#endregion
+export { useApiQueryCache };
+//# sourceMappingURL=useApiQueryCache.d.ts.map

package/dist/api/hooks/useApiQueryCache/useApiQueryCache.js

@@ -0,0 +1,30 @@
+import { getContext } from "../../../getContext/getContext.js";
+import "../../../getContext/index.js";
+import { QUERY_CACHE_CONTEXT_KEY } from "@pastweb/tools/api/createQueryCache/constants";
+//#region src/api/hooks/useApiQueryCache/useApiQueryCache.ts
+/**
+* Returns the active tools `QueryCache` from Vue dependency injection.
+*
+* The cache is provided by installing the plugin returned from
+* {@link installApiCache}. This keeps cache ownership in `@pastweb/tools`
+* while exposing Vue-friendly access for composables and components.
+*
+* @returns The active tools `QueryCache`.
+* @throws When no query cache has been provided in the current app tree.
+*
+* @example
+* ```ts
+* import { useApiQueryCache } from '@pastweb/vue';
+*
+* const queryCache = useApiQueryCache();
+* ```
+*/
+function useApiQueryCache() {
+	const queryCache = getContext(QUERY_CACHE_CONTEXT_KEY);
+	if (!queryCache) throw new Error("useApiQueryCache error: queryCache must be installed via installApiCache.");
+	return queryCache;
+}
+//#endregion
+export { useApiQueryCache };
+
+//# sourceMappingURL=useApiQueryCache.js.map

package/dist/api/hooks/useApiQueryCache/useApiQueryCache.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useApiQueryCache.js","names":[],"sources":["../../../../src/api/hooks/useApiQueryCache/useApiQueryCache.ts"],"sourcesContent":["import { QUERY_CACHE_CONTEXT_KEY } from '@pastweb/tools/api/createQueryCache/constants';\nimport type { QueryCache } from '@pastweb/tools/api/createQueryCache/types';\nimport { getContext } from '../../../getContext';\n\n/**\n * Returns the active tools `QueryCache` from Vue dependency injection.\n *\n * The cache is provided by installing the plugin returned from\n * {@link installApiCache}. This keeps cache ownership in `@pastweb/tools`\n * while exposing Vue-friendly access for composables and components.\n *\n * @returns The active tools `QueryCache`.\n * @throws When no query cache has been provided in the current app tree.\n *\n * @example\n * ```ts\n * import { useApiQueryCache } from '@pastweb/vue';\n *\n * const queryCache = useApiQueryCache();\n * ```\n */\nexport function useApiQueryCache(): QueryCache {\n  const queryCache = getContext<QueryCache | undefined>(QUERY_CACHE_CONTEXT_KEY);\n\n  if (!queryCache) {\n    throw new Error(\n      'useApiQueryCache error: queryCache must be installed via installApiCache.'\n    );\n  }\n\n  return queryCache;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;AAqBA,SAAgB,mBAA+B;CAC7C,MAAM,aAAa,WAAmC,uBAAuB;CAE7E,IAAI,CAAC,YACH,MAAM,IAAI,MACR,2EACF;CAGF,OAAO;AACT"}

package/dist/api/hooks/useInfiniteQuery/index.cjs

@@ -0,0 +1,3 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_api_hooks_useInfiniteQuery_useInfiniteQuery = require("./useInfiniteQuery.cjs");
+exports.useInfiniteQuery = require_api_hooks_useInfiniteQuery_useInfiniteQuery.useInfiniteQuery;

package/dist/api/hooks/useInfiniteQuery/index.d.cts

@@ -0,0 +1,3 @@
+import { useInfiniteQuery } from "./useInfiniteQuery.cjs";
+import { InfiniteQueryConfig, InfiniteQueryInfo, InfiniteQueryInitialData } from "@pastweb/tools";
+export { type InfiniteQueryConfig, type InfiniteQueryInfo, type InfiniteQueryInitialData, useInfiniteQuery };

package/dist/api/hooks/useInfiniteQuery/index.d.ts

@@ -0,0 +1,3 @@
+import { useInfiniteQuery } from "./useInfiniteQuery.js";
+import { InfiniteQueryConfig, InfiniteQueryInfo, InfiniteQueryInitialData } from "@pastweb/tools";
+export { type InfiniteQueryConfig, type InfiniteQueryInfo, type InfiniteQueryInitialData, useInfiniteQuery };

package/dist/api/hooks/useInfiniteQuery/index.js

@@ -0,0 +1,2 @@
+import { useInfiniteQuery } from "./useInfiniteQuery.js";
+export { useInfiniteQuery };

package/dist/api/hooks/useInfiniteQuery/useInfiniteQuery.cjs

@@ -0,0 +1,34 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_api_hooks_reuseQuery_reuseQuery = require("../reuseQuery/reuseQuery.cjs");
+require("../reuseQuery/index.cjs");
+let _pastweb_tools_api_hooks_useInfiniteQuery = require("@pastweb/tools/api/hooks/useInfiniteQuery");
+//#region src/api/hooks/useInfiniteQuery/useInfiniteQuery.ts
+/**
+* Vue wrapper for `@pastweb/tools` `useInfiniteQuery`.
+*
+* The core infinite query owns page ordering, fetch status, retry behavior, and
+* cache interaction. This composable bridges that reactive state into Vue
+* rendering so templates update when query fields change.
+*
+* @typeParam TPage - Data shape for each fetched page.
+* @typeParam TPageParam - Page parameter shape.
+* @param config - Infinite query configuration passed to the tools hook.
+* @returns Reactive infinite query information.
+*
+* @example
+* ```ts
+* const posts = useInfiniteQuery({
+*   initialPageParam: 1,
+*   fn: page => agent.get(`/api/posts?page=${page}`, {
+*     queryKey: ['posts', page],
+*   }),
+* });
+* ```
+*/
+function useInfiniteQuery(config) {
+	return require_api_hooks_reuseQuery_reuseQuery.reuseQuery(() => (0, _pastweb_tools_api_hooks_useInfiniteQuery.useInfiniteQuery)(config));
+}
+//#endregion
+exports.useInfiniteQuery = useInfiniteQuery;
+
+//# sourceMappingURL=useInfiniteQuery.cjs.map

package/dist/api/hooks/useInfiniteQuery/useInfiniteQuery.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"useInfiniteQuery.cjs","names":["reuseQuery"],"sources":["../../../../src/api/hooks/useInfiniteQuery/useInfiniteQuery.ts"],"sourcesContent":["import { useInfiniteQuery as createToolsInfiniteQuery } from '@pastweb/tools/api/hooks/useInfiniteQuery';\nimport { reuseQuery } from '../reuseQuery';\nimport type {\n  InfiniteQueryConfig,\n  InfiniteQueryInfo,\n} from '@pastweb/tools/api/hooks/useInfiniteQuery/types';\n\n/**\n * Vue wrapper for `@pastweb/tools` `useInfiniteQuery`.\n *\n * The core infinite query owns page ordering, fetch status, retry behavior, and\n * cache interaction. This composable bridges that reactive state into Vue\n * rendering so templates update when query fields change.\n *\n * @typeParam TPage - Data shape for each fetched page.\n * @typeParam TPageParam - Page parameter shape.\n * @param config - Infinite query configuration passed to the tools hook.\n * @returns Reactive infinite query information.\n *\n * @example\n * ```ts\n * const posts = useInfiniteQuery({\n *   initialPageParam: 1,\n *   fn: page => agent.get(`/api/posts?page=${page}`, {\n *     queryKey: ['posts', page],\n *   }),\n * });\n * ```\n */\nexport function useInfiniteQuery<TPage, TPageParam = unknown>(\n  config: InfiniteQueryConfig<TPage, TPageParam>,\n): InfiniteQueryInfo<TPage, TPageParam> {\n  return reuseQuery(() => createToolsInfiniteQuery(config));\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;AA6BA,SAAgB,iBACd,QACsC;CACtC,OAAOA,wCAAAA,kBAAAA,GAAAA,0CAAAA,iBAAAA,CAA0C,MAAM,CAAC;AAC1D"}

package/dist/api/hooks/useInfiniteQuery/useInfiniteQuery.d.cts

@@ -0,0 +1,29 @@
+import { InfiniteQueryConfig, InfiniteQueryInfo } from "@pastweb/tools/api/hooks/useInfiniteQuery/types";
+
+//#region src/api/hooks/useInfiniteQuery/useInfiniteQuery.d.ts
+/**
+ * Vue wrapper for `@pastweb/tools` `useInfiniteQuery`.
+ *
+ * The core infinite query owns page ordering, fetch status, retry behavior, and
+ * cache interaction. This composable bridges that reactive state into Vue
+ * rendering so templates update when query fields change.
+ *
+ * @typeParam TPage - Data shape for each fetched page.
+ * @typeParam TPageParam - Page parameter shape.
+ * @param config - Infinite query configuration passed to the tools hook.
+ * @returns Reactive infinite query information.
+ *
+ * @example
+ * ```ts
+ * const posts = useInfiniteQuery({
+ *   initialPageParam: 1,
+ *   fn: page => agent.get(`/api/posts?page=${page}`, {
+ *     queryKey: ['posts', page],
+ *   }),
+ * });
+ * ```
+ */
+declare function useInfiniteQuery<TPage, TPageParam = unknown>(config: InfiniteQueryConfig<TPage, TPageParam>): InfiniteQueryInfo<TPage, TPageParam>;
+//#endregion
+export { useInfiniteQuery };
+//# sourceMappingURL=useInfiniteQuery.d.cts.map

package/dist/api/hooks/useInfiniteQuery/useInfiniteQuery.d.ts

@@ -0,0 +1,29 @@
+import { InfiniteQueryConfig, InfiniteQueryInfo } from "@pastweb/tools/api/hooks/useInfiniteQuery/types";
+
+//#region src/api/hooks/useInfiniteQuery/useInfiniteQuery.d.ts
+/**
+ * Vue wrapper for `@pastweb/tools` `useInfiniteQuery`.
+ *
+ * The core infinite query owns page ordering, fetch status, retry behavior, and
+ * cache interaction. This composable bridges that reactive state into Vue
+ * rendering so templates update when query fields change.
+ *
+ * @typeParam TPage - Data shape for each fetched page.
+ * @typeParam TPageParam - Page parameter shape.
+ * @param config - Infinite query configuration passed to the tools hook.
+ * @returns Reactive infinite query information.
+ *
+ * @example
+ * ```ts
+ * const posts = useInfiniteQuery({
+ *   initialPageParam: 1,
+ *   fn: page => agent.get(`/api/posts?page=${page}`, {
+ *     queryKey: ['posts', page],
+ *   }),
+ * });
+ * ```
+ */
+declare function useInfiniteQuery<TPage, TPageParam = unknown>(config: InfiniteQueryConfig<TPage, TPageParam>): InfiniteQueryInfo<TPage, TPageParam>;
+//#endregion
+export { useInfiniteQuery };
+//# sourceMappingURL=useInfiniteQuery.d.ts.map

package/dist/api/hooks/useInfiniteQuery/useInfiniteQuery.js

@@ -0,0 +1,33 @@
+import { reuseQuery } from "../reuseQuery/reuseQuery.js";
+import "../reuseQuery/index.js";
+import { useInfiniteQuery as useInfiniteQuery$1 } from "@pastweb/tools/api/hooks/useInfiniteQuery";
+//#region src/api/hooks/useInfiniteQuery/useInfiniteQuery.ts
+/**
+* Vue wrapper for `@pastweb/tools` `useInfiniteQuery`.
+*
+* The core infinite query owns page ordering, fetch status, retry behavior, and
+* cache interaction. This composable bridges that reactive state into Vue
+* rendering so templates update when query fields change.
+*
+* @typeParam TPage - Data shape for each fetched page.
+* @typeParam TPageParam - Page parameter shape.
+* @param config - Infinite query configuration passed to the tools hook.
+* @returns Reactive infinite query information.
+*
+* @example
+* ```ts
+* const posts = useInfiniteQuery({
+*   initialPageParam: 1,
+*   fn: page => agent.get(`/api/posts?page=${page}`, {
+*     queryKey: ['posts', page],
+*   }),
+* });
+* ```
+*/
+function useInfiniteQuery(config) {
+	return reuseQuery(() => useInfiniteQuery$1(config));
+}
+//#endregion
+export { useInfiniteQuery };
+
+//# sourceMappingURL=useInfiniteQuery.js.map

package/dist/api/hooks/useInfiniteQuery/useInfiniteQuery.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useInfiniteQuery.js","names":["createToolsInfiniteQuery"],"sources":["../../../../src/api/hooks/useInfiniteQuery/useInfiniteQuery.ts"],"sourcesContent":["import { useInfiniteQuery as createToolsInfiniteQuery } from '@pastweb/tools/api/hooks/useInfiniteQuery';\nimport { reuseQuery } from '../reuseQuery';\nimport type {\n  InfiniteQueryConfig,\n  InfiniteQueryInfo,\n} from '@pastweb/tools/api/hooks/useInfiniteQuery/types';\n\n/**\n * Vue wrapper for `@pastweb/tools` `useInfiniteQuery`.\n *\n * The core infinite query owns page ordering, fetch status, retry behavior, and\n * cache interaction. This composable bridges that reactive state into Vue\n * rendering so templates update when query fields change.\n *\n * @typeParam TPage - Data shape for each fetched page.\n * @typeParam TPageParam - Page parameter shape.\n * @param config - Infinite query configuration passed to the tools hook.\n * @returns Reactive infinite query information.\n *\n * @example\n * ```ts\n * const posts = useInfiniteQuery({\n *   initialPageParam: 1,\n *   fn: page => agent.get(`/api/posts?page=${page}`, {\n *     queryKey: ['posts', page],\n *   }),\n * });\n * ```\n */\nexport function useInfiniteQuery<TPage, TPageParam = unknown>(\n  config: InfiniteQueryConfig<TPage, TPageParam>,\n): InfiniteQueryInfo<TPage, TPageParam> {\n  return reuseQuery(() => createToolsInfiniteQuery(config));\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;AA6BA,SAAgB,iBACd,QACsC;CACtC,OAAO,iBAAiBA,mBAAyB,MAAM,CAAC;AAC1D"}

package/dist/api/hooks/useMutation/index.cjs

@@ -0,0 +1,3 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_api_hooks_useMutation_useMutation = require("./useMutation.cjs");
+exports.useMutation = require_api_hooks_useMutation_useMutation.useMutation;

package/dist/api/hooks/useMutation/index.d.cts

@@ -0,0 +1,3 @@
+import { useMutation } from "./useMutation.cjs";
+import { MutationConfig, MutationInfo } from "@pastweb/tools";
+export { type MutationConfig, type MutationInfo, useMutation };

package/dist/api/hooks/useMutation/index.d.ts

@@ -0,0 +1,3 @@
+import { useMutation } from "./useMutation.js";
+import { MutationConfig, MutationInfo } from "@pastweb/tools";
+export { type MutationConfig, type MutationInfo, useMutation };

package/dist/api/hooks/useMutation/index.js

@@ -0,0 +1,2 @@
+import { useMutation } from "./useMutation.js";
+export { useMutation };

package/dist/api/hooks/useMutation/useMutation.cjs

@@ -0,0 +1,30 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_api_hooks_reuseQuery_reuseQuery = require("../reuseQuery/reuseQuery.cjs");
+require("../reuseQuery/index.cjs");
+let _pastweb_tools_api_hooks_useMutation = require("@pastweb/tools/api/hooks/useMutation");
+//#region src/api/hooks/useMutation/useMutation.ts
+/**
+* Vue wrapper for `@pastweb/tools` `useMutation`.
+*
+* The mutation object is created by tools and bridged into Vue rendering. Use it
+* for POST/PUT/PATCH/DELETE style actions, cache invalidation callbacks, and
+* mutation lifecycle state.
+*
+* @typeParam T - Mutation result data shape.
+* @param config - Mutation configuration passed to the tools hook.
+* @returns Reactive mutation information.
+*
+* @example
+* ```ts
+* const saveUser = useMutation({
+*   fn: payload => agent.post('/api/users', payload),
+* });
+* ```
+*/
+function useMutation(config) {
+	return require_api_hooks_reuseQuery_reuseQuery.reuseMutation(() => (0, _pastweb_tools_api_hooks_useMutation.useMutation)(config));
+}
+//#endregion
+exports.useMutation = useMutation;
+
+//# sourceMappingURL=useMutation.cjs.map

package/dist/api/hooks/useMutation/useMutation.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"useMutation.cjs","names":["reuseMutation"],"sources":["../../../../src/api/hooks/useMutation/useMutation.ts"],"sourcesContent":["import { useMutation as createToolsMutation } from '@pastweb/tools/api/hooks/useMutation';\nimport { reuseMutation } from '../reuseQuery';\nimport type { MutationConfig, MutationInfo } from '@pastweb/tools/api/hooks/useMutation/types';\n\n/**\n * Vue wrapper for `@pastweb/tools` `useMutation`.\n *\n * The mutation object is created by tools and bridged into Vue rendering. Use it\n * for POST/PUT/PATCH/DELETE style actions, cache invalidation callbacks, and\n * mutation lifecycle state.\n *\n * @typeParam T - Mutation result data shape.\n * @param config - Mutation configuration passed to the tools hook.\n * @returns Reactive mutation information.\n *\n * @example\n * ```ts\n * const saveUser = useMutation({\n *   fn: payload => agent.post('/api/users', payload),\n * });\n * ```\n */\nexport function useMutation<T>(config: MutationConfig<T>): MutationInfo<T> {\n  return reuseMutation(() => createToolsMutation(config));\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;AAsBA,SAAgB,YAAe,QAA4C;CACzE,OAAOA,wCAAAA,qBAAAA,GAAAA,qCAAAA,YAAAA,CAAwC,MAAM,CAAC;AACxD"}

package/dist/api/hooks/useMutation/useMutation.d.cts

@@ -0,0 +1,25 @@
+import { MutationConfig, MutationInfo } from "@pastweb/tools/api/hooks/useMutation/types";
+
+//#region src/api/hooks/useMutation/useMutation.d.ts
+/**
+ * Vue wrapper for `@pastweb/tools` `useMutation`.
+ *
+ * The mutation object is created by tools and bridged into Vue rendering. Use it
+ * for POST/PUT/PATCH/DELETE style actions, cache invalidation callbacks, and
+ * mutation lifecycle state.
+ *
+ * @typeParam T - Mutation result data shape.
+ * @param config - Mutation configuration passed to the tools hook.
+ * @returns Reactive mutation information.
+ *
+ * @example
+ * ```ts
+ * const saveUser = useMutation({
+ *   fn: payload => agent.post('/api/users', payload),
+ * });
+ * ```
+ */
+declare function useMutation<T>(config: MutationConfig<T>): MutationInfo<T>;
+//#endregion
+export { useMutation };
+//# sourceMappingURL=useMutation.d.cts.map

package/dist/api/hooks/useMutation/useMutation.d.ts

@@ -0,0 +1,25 @@
+import { MutationConfig, MutationInfo } from "@pastweb/tools/api/hooks/useMutation/types";
+
+//#region src/api/hooks/useMutation/useMutation.d.ts
+/**
+ * Vue wrapper for `@pastweb/tools` `useMutation`.
+ *
+ * The mutation object is created by tools and bridged into Vue rendering. Use it
+ * for POST/PUT/PATCH/DELETE style actions, cache invalidation callbacks, and
+ * mutation lifecycle state.
+ *
+ * @typeParam T - Mutation result data shape.
+ * @param config - Mutation configuration passed to the tools hook.
+ * @returns Reactive mutation information.
+ *
+ * @example
+ * ```ts
+ * const saveUser = useMutation({
+ *   fn: payload => agent.post('/api/users', payload),
+ * });
+ * ```
+ */
+declare function useMutation<T>(config: MutationConfig<T>): MutationInfo<T>;
+//#endregion
+export { useMutation };
+//# sourceMappingURL=useMutation.d.ts.map