tempest-react-sdk 0.23.0 → 0.24.0

package/dist/query/use-cursor-query.js.map

@@ -1 +1 @@
-{"version":3,"file":"use-cursor-query.js","sources":["../../src/query/use-cursor-query.ts"],"sourcesContent":["import { useInfiniteQuery } from \"@tanstack/react-query\";\nimport type { InfiniteData, QueryKey, UseInfiniteQueryOptions } from \"@tanstack/react-query\";\n\nimport type { CursorPage, CursorParams } from \"./pagination\";\n\nexport interface UseCursorQueryOptions<T> extends Omit<\n    UseInfiniteQueryOptions<\n        CursorPage<T>,\n        Error,\n        InfiniteData<CursorPage<T>, string | null>,\n        QueryKey,\n        string | null\n    >,\n    \"queryKey\" | \"queryFn\" | \"initialPageParam\" | \"getNextPageParam\"\n> {\n    /** Base query key — `limit`/sort is appended for cache isolation. */\n    queryKey: QueryKey;\n    /** Fetcher receiving the cursor params; return the backend envelope. */\n    queryFn: (params: CursorParams) => Promise<CursorPage<T>> | CursorPage<T>;\n    /** Batch size sent as `limit`. Default: 20. */\n    limit?: number;\n    /** Initial `order_by`. */\n    orderBy?: string;\n    /** Initial `ascending`. Default: false. */\n    ascending?: boolean;\n}\n\nexport interface UseCursorQueryResult<T> {\n    /** All rows fetched so far, flattened across batches. */\n    items: T[];\n    /** The raw batches, in fetch order. */\n    pages: CursorPage<T>[];\n    hasNextPage: boolean;\n    isLoading: boolean;\n    isFetchingNextPage: boolean;\n    error: Error | null;\n    /** Fetch the next batch (no-op when exhausted). */\n    fetchNextPage: () => void;\n    /** Refetch from the first batch. */\n    refetch: () => void;\n}\n\n/**\n * Cursor-pagination hook over TanStack Query's `useInfiniteQuery` for the\n * Tempest `CursorPaginationSchema` envelope\n * (`{ items, next_cursor, has_more, limit }`).\n *\n * The opaque `next_cursor` is fed straight back as the next page param; the\n * loop stops when `has_more` is false (or `next_cursor` is null).\n *\n * @example\n * const feed = useCursorQuery<Post>({\n *     queryKey: [\"feed\"],\n *     limit: 30,\n *     queryFn: (params) => postsService.listPosts(params),\n * });\n * // feed.items, feed.fetchNextPage(), feed.hasNextPage\n */\nexport function useCursorQuery<T>(options: UseCursorQueryOptions<T>): UseCursorQueryResult<T> {\n    const { queryKey, queryFn, limit = 20, orderBy, ascending = false, ...queryOptions } = options;\n\n    const query = useInfiniteQuery<\n        CursorPage<T>,\n        Error,\n        InfiniteData<CursorPage<T>, string | null>,\n        QueryKey,\n        string | null\n    >({\n        ...queryOptions,\n        queryKey: [...queryKey, { limit, orderBy, ascending }],\n        initialPageParam: null,\n        queryFn: ({ pageParam }) =>\n            queryFn({ cursor: pageParam, limit, order_by: orderBy, ascending }),\n        getNextPageParam: (last) => (last.has_more ? last.next_cursor : undefined),\n    });\n\n    const pages = query.data?.pages ?? [];\n\n    return {\n        items: pages.flatMap((p) => p.items),\n        pages,\n        hasNextPage: query.hasNextPage,\n        isLoading: query.isLoading,\n        isFetchingNextPage: query.isFetchingNextPage,\n        error: query.error,\n        fetchNextPage: () => void query.fetchNextPage(),\n        refetch: () => void query.refetch(),\n    };\n}\n"],"names":["useCursorQuery","options","queryKey","queryFn","limit","orderBy","ascending","queryOptions","query","useInfiniteQuery","pageParam","last","pages","p"],"mappings":";AA0DO,SAASA,EAAkBC,GAA4D;AAC1F,QAAM,EAAE,UAAAC,GAAU,SAAAC,GAAS,OAAAC,IAAQ,IAAI,SAAAC,GAAS,WAAAC,IAAY,IAAO,GAAGC,EAAA,IAAiBN,GAEjFO,IAAQC,EAMZ;AAAA,IACE,GAAGF;AAAA,IACH,UAAU,CAAC,GAAGL,GAAU,EAAE,OAAAE,GAAO,SAAAC,GAAS,WAAAC,GAAW;AAAA,IACrD,kBAAkB;AAAA,IAClB,SAAS,CAAC,EAAE,WAAAI,EAAA,MACRP,EAAQ,EAAE,QAAQO,GAAW,OAAAN,GAAO,UAAUC,GAAS,WAAAC,GAAW;AAAA,IACtE,kBAAkB,CAACK,MAAUA,EAAK,WAAWA,EAAK,cAAc;AAAA,EAAA,CACnE,GAEKC,IAAQJ,EAAM,MAAM,SAAS,CAAA;AAEnC,SAAO;AAAA,IACH,OAAOI,EAAM,QAAQ,CAACC,MAAMA,EAAE,KAAK;AAAA,IACnC,OAAAD;AAAA,IACA,aAAaJ,EAAM;AAAA,IACnB,WAAWA,EAAM;AAAA,IACjB,oBAAoBA,EAAM;AAAA,IAC1B,OAAOA,EAAM;AAAA,IACb,eAAe,MAAA;AAAM,MAAKA,EAAM,cAAA;AAAA;AAAA,IAChC,SAAS,MAAA;AAAM,MAAKA,EAAM,QAAA;AAAA;AAAA,EAAQ;AAE1C;"}
+{"version":3,"file":"use-cursor-query.js","names":[],"sources":["../../src/query/use-cursor-query.ts"],"sourcesContent":["import { useInfiniteQuery } from \"@tanstack/react-query\";\nimport type { InfiniteData, QueryKey, UseInfiniteQueryOptions } from \"@tanstack/react-query\";\n\nimport type { CursorPage, CursorParams } from \"./pagination\";\n\nexport interface UseCursorQueryOptions<T> extends Omit<\n    UseInfiniteQueryOptions<\n        CursorPage<T>,\n        Error,\n        InfiniteData<CursorPage<T>, string | null>,\n        QueryKey,\n        string | null\n    >,\n    \"queryKey\" | \"queryFn\" | \"initialPageParam\" | \"getNextPageParam\"\n> {\n    /** Base query key — `limit`/sort is appended for cache isolation. */\n    queryKey: QueryKey;\n    /** Fetcher receiving the cursor params; return the backend envelope. */\n    queryFn: (params: CursorParams) => Promise<CursorPage<T>> | CursorPage<T>;\n    /** Batch size sent as `limit`. Default: 20. */\n    limit?: number;\n    /** Initial `order_by`. */\n    orderBy?: string;\n    /** Initial `ascending`. Default: false. */\n    ascending?: boolean;\n}\n\nexport interface UseCursorQueryResult<T> {\n    /** All rows fetched so far, flattened across batches. */\n    items: T[];\n    /** The raw batches, in fetch order. */\n    pages: CursorPage<T>[];\n    hasNextPage: boolean;\n    isLoading: boolean;\n    isFetchingNextPage: boolean;\n    error: Error | null;\n    /** Fetch the next batch (no-op when exhausted). */\n    fetchNextPage: () => void;\n    /** Refetch from the first batch. */\n    refetch: () => void;\n}\n\n/**\n * Cursor-pagination hook over TanStack Query's `useInfiniteQuery` for the\n * Tempest `CursorPaginationSchema` envelope\n * (`{ items, next_cursor, has_more, limit }`).\n *\n * The opaque `next_cursor` is fed straight back as the next page param; the\n * loop stops when `has_more` is false (or `next_cursor` is null).\n *\n * @example\n * const feed = useCursorQuery<Post>({\n *     queryKey: [\"feed\"],\n *     limit: 30,\n *     queryFn: (params) => postsService.listPosts(params),\n * });\n * // feed.items, feed.fetchNextPage(), feed.hasNextPage\n */\nexport function useCursorQuery<T>(options: UseCursorQueryOptions<T>): UseCursorQueryResult<T> {\n    const { queryKey, queryFn, limit = 20, orderBy, ascending = false, ...queryOptions } = options;\n\n    const query = useInfiniteQuery<\n        CursorPage<T>,\n        Error,\n        InfiniteData<CursorPage<T>, string | null>,\n        QueryKey,\n        string | null\n    >({\n        ...queryOptions,\n        queryKey: [...queryKey, { limit, orderBy, ascending }],\n        initialPageParam: null,\n        queryFn: ({ pageParam }) =>\n            queryFn({ cursor: pageParam, limit, order_by: orderBy, ascending }),\n        getNextPageParam: (last) => (last.has_more ? last.next_cursor : undefined),\n    });\n\n    const pages = query.data?.pages ?? [];\n\n    return {\n        items: pages.flatMap((p) => p.items),\n        pages,\n        hasNextPage: query.hasNextPage,\n        isLoading: query.isLoading,\n        isFetchingNextPage: query.isFetchingNextPage,\n        error: query.error,\n        fetchNextPage: () => void query.fetchNextPage(),\n        refetch: () => void query.refetch(),\n    };\n}\n"],"mappings":";;AA0DA,SAAgB,EAAkB,GAA4D;CAC1F,IAAM,EAAE,aAAU,YAAS,WAAQ,IAAI,YAAS,eAAY,IAAO,GAAG,MAAiB,GAEjF,IAAQ,EAMZ;EACE,GAAG;EACH,UAAU,CAAC,GAAG,GAAU;GAAE;GAAO;GAAS;EAAU,CAAC;EACrD,kBAAkB;EAClB,UAAU,EAAE,mBACR,EAAQ;GAAE,QAAQ;GAAW;GAAO,UAAU;GAAS;EAAU,CAAC;EACtE,mBAAmB,MAAU,EAAK,WAAW,EAAK,cAAc,KAAA;CACpE,CAAC,GAEK,IAAQ,EAAM,MAAM,SAAS,CAAC;CAEpC,OAAO;EACH,OAAO,EAAM,SAAS,MAAM,EAAE,KAAK;EACnC;EACA,aAAa,EAAM;EACnB,WAAW,EAAM;EACjB,oBAAoB,EAAM;EAC1B,OAAO,EAAM;EACb,qBAAqB,KAAK,EAAM,cAAc;EAC9C,eAAe,KAAK,EAAM,QAAQ;CACtC;AACJ"}

package/dist/query/use-offline-mutation.cjs

@@ -1,2 +1,2 @@
-"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const s=require("@tanstack/react-query");function d(c){const{sync:n,toEntry:l,queryKey:e,applyOptimistic:o,flush:a=!0,invalidate:f=!1}=c,i=s.useQueryClient();return s.useMutation({mutationFn:async u=>{const t=l(u),r=await n.enqueue(t.op,t.recordId,t.payload);if(a!==!1){const y=a===!0?"after-mutation":a;n.flush(y)}return r},onMutate:async u=>{if(!e||!o)return{previous:void 0};await i.cancelQueries({queryKey:e});const t=i.getQueryData(e);return i.setQueryData(e,r=>o(r,u)),{previous:t}},onError:(u,t,r)=>{e&&r&&i.setQueryData(e,r.previous)},onSettled:()=>{f&&e&&i.invalidateQueries({queryKey:e})}})}exports.useOfflineMutation=d;
-//# sourceMappingURL=use-offline-mutation.cjs.map
+let e=require("@tanstack/react-query");function t(t){let{sync:n,toEntry:r,queryKey:i,applyOptimistic:a,flush:o=!0,invalidate:s=!1}=t,c=(0,e.useQueryClient)();return(0,e.useMutation)({mutationFn:async e=>{let t=r(e),i=await n.enqueue(t.op,t.recordId,t.payload);if(o!==!1){let e=o===!0?`after-mutation`:o;n.flush(e)}return i},onMutate:async e=>{if(!i||!a)return{previous:void 0};await c.cancelQueries({queryKey:i});let t=c.getQueryData(i);return c.setQueryData(i,t=>a(t,e)),{previous:t}},onError:(e,t,n)=>{i&&n&&c.setQueryData(i,n.previous)},onSettled:()=>{s&&i&&c.invalidateQueries({queryKey:i})}})}exports.useOfflineMutation=t;
+//# sourceMappingURL=use-offline-mutation.cjs.map

package/dist/query/use-offline-mutation.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"use-offline-mutation.cjs","sources":["../../src/query/use-offline-mutation.ts"],"sourcesContent":["import { useMutation, useQueryClient } from \"@tanstack/react-query\";\nimport type { QueryKey, UseMutationResult } from \"@tanstack/react-query\";\nimport type { OfflineSync, OutboxOp, SyncTrigger } from \"../offline\";\n\n/** The outbox entry a mutation's variables map to. */\nexport interface OutboxDraft<TPayload> {\n    /** The mutation kind. */\n    op: OutboxOp;\n    /** Primary key of the affected record. */\n    recordId: string;\n    /** Record snapshot for `create`/`update` (omit for `delete`). */\n    payload?: TPayload;\n}\n\n/**\n * Configuration for {@link useOfflineMutation}.\n *\n * @typeParam TVariables - The `mutate(variables)` input shape.\n * @typeParam TData - The cached query data optimistically patched.\n * @typeParam TPayload - Record snapshot carried by outbox entries.\n */\nexport interface UseOfflineMutationOptions<TVariables, TData, TPayload> {\n    /** The engine the mutation enqueues into. */\n    sync: OfflineSync<TPayload>;\n    /** Map `mutate` variables into an outbox entry. */\n    toEntry: (variables: TVariables) => OutboxDraft<TPayload>;\n    /**\n     * Query key to optimistically patch and (optionally) invalidate. Omit to\n     * only enqueue without touching the React Query cache.\n     */\n    queryKey?: QueryKey;\n    /**\n     * Produce the next cached value from the current one and the variables.\n     * Runs in `onMutate`; the previous value is restored automatically if the\n     * enqueue throws. Requires `queryKey`.\n     */\n    applyOptimistic?: (current: TData | undefined, variables: TVariables) => TData;\n    /**\n     * Trigger a flush after enqueueing. `true` (default) uses\n     * `\"after-mutation\"`; pass a custom {@link SyncTrigger} string, or `false`\n     * to leave flushing to the caller / auto-flush hooks.\n     */\n    flush?: boolean | SyncTrigger;\n    /** Invalidate `queryKey` in `onSettled` so a later read refetches. Default `false`. */\n    invalidate?: boolean;\n}\n\ninterface MutationContext<TData> {\n    previous: TData | undefined;\n}\n\n/**\n * Optimistic mutation that writes to an {@link OfflineSync} outbox instead of\n * hitting the network directly, bridging the sync engine and TanStack Query.\n *\n * On `mutate` it enqueues the entry, optimistically patches the given query\n * cache key and kicks a flush; if the enqueue itself throws, the cache is\n * rolled back to its previous value. Server delivery happens later inside the\n * engine's flush loop, so the UI updates instantly and survives reloads and\n * offline periods.\n *\n * @typeParam TVariables - The `mutate(variables)` input shape.\n * @typeParam TData - The cached query data optimistically patched.\n * @typeParam TPayload - Record snapshot carried by outbox entries.\n * @param options - Engine, variables→entry mapping and cache wiring.\n * @returns The TanStack {@link UseMutationResult}; the mutation resolves to the\n *   generated outbox entry id.\n *\n * @example\n * const addNote = useOfflineMutation({\n *     sync: notesSync,\n *     queryKey: [\"notes\"],\n *     toEntry: (note: Note) => ({ op: \"create\", recordId: note.id, payload: note }),\n *     applyOptimistic: (current: Note[] = [], note) => [...current, note],\n * });\n * addNote.mutate(newNote);\n */\nexport function useOfflineMutation<TVariables, TData = unknown, TPayload = unknown>(\n    options: UseOfflineMutationOptions<TVariables, TData, TPayload>,\n): UseMutationResult<string, Error, TVariables, MutationContext<TData>> {\n    const { sync, toEntry, queryKey, applyOptimistic, flush = true, invalidate = false } = options;\n    const client = useQueryClient();\n\n    return useMutation<string, Error, TVariables, MutationContext<TData>>({\n        mutationFn: async (variables) => {\n            const draft = toEntry(variables);\n            const id = await sync.enqueue(draft.op, draft.recordId, draft.payload);\n            if (flush !== false) {\n                const trigger: SyncTrigger = flush === true ? \"after-mutation\" : flush;\n                void sync.flush(trigger);\n            }\n            return id;\n        },\n        onMutate: async (variables) => {\n            if (!queryKey || !applyOptimistic) return { previous: undefined };\n            await client.cancelQueries({ queryKey });\n            const previous = client.getQueryData<TData>(queryKey);\n            client.setQueryData<TData>(queryKey, (current) => applyOptimistic(current, variables));\n            return { previous };\n        },\n        onError: (_error, _variables, context) => {\n            if (queryKey && context) client.setQueryData(queryKey, context.previous);\n        },\n        onSettled: () => {\n            if (invalidate && queryKey) void client.invalidateQueries({ queryKey });\n        },\n    });\n}\n"],"names":["useOfflineMutation","options","sync","toEntry","queryKey","applyOptimistic","flush","invalidate","client","useQueryClient","useMutation","variables","draft","id","trigger","previous","current","_error","_variables","context"],"mappings":"yHA6EO,SAASA,EACZC,EACoE,CACpE,KAAM,CAAE,KAAAC,EAAM,QAAAC,EAAS,SAAAC,EAAU,gBAAAC,EAAiB,MAAAC,EAAQ,GAAM,WAAAC,EAAa,EAAA,EAAUN,EACjFO,EAASC,EAAAA,eAAA,EAEf,OAAOC,cAA+D,CAClE,WAAY,MAAOC,GAAc,CAC7B,MAAMC,EAAQT,EAAQQ,CAAS,EACzBE,EAAK,MAAMX,EAAK,QAAQU,EAAM,GAAIA,EAAM,SAAUA,EAAM,OAAO,EACrE,GAAIN,IAAU,GAAO,CACjB,MAAMQ,EAAuBR,IAAU,GAAO,iBAAmBA,EAC5DJ,EAAK,MAAMY,CAAO,CAC3B,CACA,OAAOD,CACX,EACA,SAAU,MAAOF,GAAc,CAC3B,GAAI,CAACP,GAAY,CAACC,EAAiB,MAAO,CAAE,SAAU,MAAA,EACtD,MAAMG,EAAO,cAAc,CAAE,SAAAJ,EAAU,EACvC,MAAMW,EAAWP,EAAO,aAAoBJ,CAAQ,EACpD,OAAAI,EAAO,aAAoBJ,EAAWY,GAAYX,EAAgBW,EAASL,CAAS,CAAC,EAC9E,CAAE,SAAAI,CAAA,CACb,EACA,QAAS,CAACE,EAAQC,EAAYC,IAAY,CAClCf,GAAYe,GAASX,EAAO,aAAaJ,EAAUe,EAAQ,QAAQ,CAC3E,EACA,UAAW,IAAM,CACTZ,GAAcH,GAAeI,EAAO,kBAAkB,CAAE,SAAAJ,EAAU,CAC1E,CAAA,CACH,CACL"}
+{"version":3,"file":"use-offline-mutation.cjs","names":[],"sources":["../../src/query/use-offline-mutation.ts"],"sourcesContent":["import { useMutation, useQueryClient } from \"@tanstack/react-query\";\nimport type { QueryKey, UseMutationResult } from \"@tanstack/react-query\";\nimport type { OfflineSync, OutboxOp, SyncTrigger } from \"../offline\";\n\n/** The outbox entry a mutation's variables map to. */\nexport interface OutboxDraft<TPayload> {\n    /** The mutation kind. */\n    op: OutboxOp;\n    /** Primary key of the affected record. */\n    recordId: string;\n    /** Record snapshot for `create`/`update` (omit for `delete`). */\n    payload?: TPayload;\n}\n\n/**\n * Configuration for {@link useOfflineMutation}.\n *\n * @typeParam TVariables - The `mutate(variables)` input shape.\n * @typeParam TData - The cached query data optimistically patched.\n * @typeParam TPayload - Record snapshot carried by outbox entries.\n */\nexport interface UseOfflineMutationOptions<TVariables, TData, TPayload> {\n    /** The engine the mutation enqueues into. */\n    sync: OfflineSync<TPayload>;\n    /** Map `mutate` variables into an outbox entry. */\n    toEntry: (variables: TVariables) => OutboxDraft<TPayload>;\n    /**\n     * Query key to optimistically patch and (optionally) invalidate. Omit to\n     * only enqueue without touching the React Query cache.\n     */\n    queryKey?: QueryKey;\n    /**\n     * Produce the next cached value from the current one and the variables.\n     * Runs in `onMutate`; the previous value is restored automatically if the\n     * enqueue throws. Requires `queryKey`.\n     */\n    applyOptimistic?: (current: TData | undefined, variables: TVariables) => TData;\n    /**\n     * Trigger a flush after enqueueing. `true` (default) uses\n     * `\"after-mutation\"`; pass a custom {@link SyncTrigger} string, or `false`\n     * to leave flushing to the caller / auto-flush hooks.\n     */\n    flush?: boolean | SyncTrigger;\n    /** Invalidate `queryKey` in `onSettled` so a later read refetches. Default `false`. */\n    invalidate?: boolean;\n}\n\ninterface MutationContext<TData> {\n    previous: TData | undefined;\n}\n\n/**\n * Optimistic mutation that writes to an {@link OfflineSync} outbox instead of\n * hitting the network directly, bridging the sync engine and TanStack Query.\n *\n * On `mutate` it enqueues the entry, optimistically patches the given query\n * cache key and kicks a flush; if the enqueue itself throws, the cache is\n * rolled back to its previous value. Server delivery happens later inside the\n * engine's flush loop, so the UI updates instantly and survives reloads and\n * offline periods.\n *\n * @typeParam TVariables - The `mutate(variables)` input shape.\n * @typeParam TData - The cached query data optimistically patched.\n * @typeParam TPayload - Record snapshot carried by outbox entries.\n * @param options - Engine, variables→entry mapping and cache wiring.\n * @returns The TanStack {@link UseMutationResult}; the mutation resolves to the\n *   generated outbox entry id.\n *\n * @example\n * const addNote = useOfflineMutation({\n *     sync: notesSync,\n *     queryKey: [\"notes\"],\n *     toEntry: (note: Note) => ({ op: \"create\", recordId: note.id, payload: note }),\n *     applyOptimistic: (current: Note[] = [], note) => [...current, note],\n * });\n * addNote.mutate(newNote);\n */\nexport function useOfflineMutation<TVariables, TData = unknown, TPayload = unknown>(\n    options: UseOfflineMutationOptions<TVariables, TData, TPayload>,\n): UseMutationResult<string, Error, TVariables, MutationContext<TData>> {\n    const { sync, toEntry, queryKey, applyOptimistic, flush = true, invalidate = false } = options;\n    const client = useQueryClient();\n\n    return useMutation<string, Error, TVariables, MutationContext<TData>>({\n        mutationFn: async (variables) => {\n            const draft = toEntry(variables);\n            const id = await sync.enqueue(draft.op, draft.recordId, draft.payload);\n            if (flush !== false) {\n                const trigger: SyncTrigger = flush === true ? \"after-mutation\" : flush;\n                void sync.flush(trigger);\n            }\n            return id;\n        },\n        onMutate: async (variables) => {\n            if (!queryKey || !applyOptimistic) return { previous: undefined };\n            await client.cancelQueries({ queryKey });\n            const previous = client.getQueryData<TData>(queryKey);\n            client.setQueryData<TData>(queryKey, (current) => applyOptimistic(current, variables));\n            return { previous };\n        },\n        onError: (_error, _variables, context) => {\n            if (queryKey && context) client.setQueryData(queryKey, context.previous);\n        },\n        onSettled: () => {\n            if (invalidate && queryKey) void client.invalidateQueries({ queryKey });\n        },\n    });\n}\n"],"mappings":"uCA6EA,SAAgB,EACZ,EACoE,CACpE,GAAM,CAAE,OAAM,UAAS,WAAU,kBAAiB,QAAQ,GAAM,aAAa,IAAU,EACjF,GAAA,EAAA,EAAA,eAAA,CAAwB,EAE9B,OAAA,EAAA,EAAA,YAAA,CAAsE,CAClE,WAAY,KAAO,IAAc,CAC7B,IAAM,EAAQ,EAAQ,CAAS,EACzB,EAAK,MAAM,EAAK,QAAQ,EAAM,GAAI,EAAM,SAAU,EAAM,OAAO,EACrE,GAAI,IAAU,GAAO,CACjB,IAAM,EAAuB,IAAU,GAAO,iBAAmB,EACjE,EAAU,MAAM,CAAO,CAC3B,CACA,OAAO,CACX,EACA,SAAU,KAAO,IAAc,CAC3B,GAAI,CAAC,GAAY,CAAC,EAAiB,MAAO,CAAE,SAAU,IAAA,EAAU,EAChE,MAAM,EAAO,cAAc,CAAE,UAAS,CAAC,EACvC,IAAM,EAAW,EAAO,aAAoB,CAAQ,EAEpD,OADA,EAAO,aAAoB,EAAW,GAAY,EAAgB,EAAS,CAAS,CAAC,EAC9E,CAAE,UAAS,CACtB,EACA,SAAU,EAAQ,EAAY,IAAY,CAClC,GAAY,GAAS,EAAO,aAAa,EAAU,EAAQ,QAAQ,CAC3E,EACA,cAAiB,CACT,GAAc,GAAU,EAAY,kBAAkB,CAAE,UAAS,CAAC,CAC1E,CACJ,CAAC,CACL"}

package/dist/query/use-offline-mutation.js

@@ -1,30 +1,31 @@
-import { useQueryClient as y, useMutation as d } from "@tanstack/react-query";
-function v(s) {
-  const { sync: u, toEntry: c, queryKey: e, applyOptimistic: o, flush: n = !0, invalidate: f = !1 } = s, i = y();
-  return d({
-    mutationFn: async (a) => {
-      const t = c(a), r = await u.enqueue(t.op, t.recordId, t.payload);
-      if (n !== !1) {
-        const l = n === !0 ? "after-mutation" : n;
-        u.flush(l);
-      }
-      return r;
-    },
-    onMutate: async (a) => {
-      if (!e || !o) return { previous: void 0 };
-      await i.cancelQueries({ queryKey: e });
-      const t = i.getQueryData(e);
-      return i.setQueryData(e, (r) => o(r, a)), { previous: t };
-    },
-    onError: (a, t, r) => {
-      e && r && i.setQueryData(e, r.previous);
-    },
-    onSettled: () => {
-      f && e && i.invalidateQueries({ queryKey: e });
-    }
-  });
+import { useMutation as e, useQueryClient as t } from "@tanstack/react-query";
+//#region src/query/use-offline-mutation.ts
+function n(n) {
+	let { sync: r, toEntry: i, queryKey: a, applyOptimistic: o, flush: s = !0, invalidate: c = !1 } = n, l = t();
+	return e({
+		mutationFn: async (e) => {
+			let t = i(e), n = await r.enqueue(t.op, t.recordId, t.payload);
+			if (s !== !1) {
+				let e = s === !0 ? "after-mutation" : s;
+				r.flush(e);
+			}
+			return n;
+		},
+		onMutate: async (e) => {
+			if (!a || !o) return { previous: void 0 };
+			await l.cancelQueries({ queryKey: a });
+			let t = l.getQueryData(a);
+			return l.setQueryData(a, (t) => o(t, e)), { previous: t };
+		},
+		onError: (e, t, n) => {
+			a && n && l.setQueryData(a, n.previous);
+		},
+		onSettled: () => {
+			c && a && l.invalidateQueries({ queryKey: a });
+		}
+	});
 }
-export {
-  v as useOfflineMutation
-};
-//# sourceMappingURL=use-offline-mutation.js.map
+//#endregion
+export { n as useOfflineMutation };
+
+//# sourceMappingURL=use-offline-mutation.js.map

package/dist/query/use-offline-mutation.js.map

@@ -1 +1 @@
-{"version":3,"file":"use-offline-mutation.js","sources":["../../src/query/use-offline-mutation.ts"],"sourcesContent":["import { useMutation, useQueryClient } from \"@tanstack/react-query\";\nimport type { QueryKey, UseMutationResult } from \"@tanstack/react-query\";\nimport type { OfflineSync, OutboxOp, SyncTrigger } from \"../offline\";\n\n/** The outbox entry a mutation's variables map to. */\nexport interface OutboxDraft<TPayload> {\n    /** The mutation kind. */\n    op: OutboxOp;\n    /** Primary key of the affected record. */\n    recordId: string;\n    /** Record snapshot for `create`/`update` (omit for `delete`). */\n    payload?: TPayload;\n}\n\n/**\n * Configuration for {@link useOfflineMutation}.\n *\n * @typeParam TVariables - The `mutate(variables)` input shape.\n * @typeParam TData - The cached query data optimistically patched.\n * @typeParam TPayload - Record snapshot carried by outbox entries.\n */\nexport interface UseOfflineMutationOptions<TVariables, TData, TPayload> {\n    /** The engine the mutation enqueues into. */\n    sync: OfflineSync<TPayload>;\n    /** Map `mutate` variables into an outbox entry. */\n    toEntry: (variables: TVariables) => OutboxDraft<TPayload>;\n    /**\n     * Query key to optimistically patch and (optionally) invalidate. Omit to\n     * only enqueue without touching the React Query cache.\n     */\n    queryKey?: QueryKey;\n    /**\n     * Produce the next cached value from the current one and the variables.\n     * Runs in `onMutate`; the previous value is restored automatically if the\n     * enqueue throws. Requires `queryKey`.\n     */\n    applyOptimistic?: (current: TData | undefined, variables: TVariables) => TData;\n    /**\n     * Trigger a flush after enqueueing. `true` (default) uses\n     * `\"after-mutation\"`; pass a custom {@link SyncTrigger} string, or `false`\n     * to leave flushing to the caller / auto-flush hooks.\n     */\n    flush?: boolean | SyncTrigger;\n    /** Invalidate `queryKey` in `onSettled` so a later read refetches. Default `false`. */\n    invalidate?: boolean;\n}\n\ninterface MutationContext<TData> {\n    previous: TData | undefined;\n}\n\n/**\n * Optimistic mutation that writes to an {@link OfflineSync} outbox instead of\n * hitting the network directly, bridging the sync engine and TanStack Query.\n *\n * On `mutate` it enqueues the entry, optimistically patches the given query\n * cache key and kicks a flush; if the enqueue itself throws, the cache is\n * rolled back to its previous value. Server delivery happens later inside the\n * engine's flush loop, so the UI updates instantly and survives reloads and\n * offline periods.\n *\n * @typeParam TVariables - The `mutate(variables)` input shape.\n * @typeParam TData - The cached query data optimistically patched.\n * @typeParam TPayload - Record snapshot carried by outbox entries.\n * @param options - Engine, variables→entry mapping and cache wiring.\n * @returns The TanStack {@link UseMutationResult}; the mutation resolves to the\n *   generated outbox entry id.\n *\n * @example\n * const addNote = useOfflineMutation({\n *     sync: notesSync,\n *     queryKey: [\"notes\"],\n *     toEntry: (note: Note) => ({ op: \"create\", recordId: note.id, payload: note }),\n *     applyOptimistic: (current: Note[] = [], note) => [...current, note],\n * });\n * addNote.mutate(newNote);\n */\nexport function useOfflineMutation<TVariables, TData = unknown, TPayload = unknown>(\n    options: UseOfflineMutationOptions<TVariables, TData, TPayload>,\n): UseMutationResult<string, Error, TVariables, MutationContext<TData>> {\n    const { sync, toEntry, queryKey, applyOptimistic, flush = true, invalidate = false } = options;\n    const client = useQueryClient();\n\n    return useMutation<string, Error, TVariables, MutationContext<TData>>({\n        mutationFn: async (variables) => {\n            const draft = toEntry(variables);\n            const id = await sync.enqueue(draft.op, draft.recordId, draft.payload);\n            if (flush !== false) {\n                const trigger: SyncTrigger = flush === true ? \"after-mutation\" : flush;\n                void sync.flush(trigger);\n            }\n            return id;\n        },\n        onMutate: async (variables) => {\n            if (!queryKey || !applyOptimistic) return { previous: undefined };\n            await client.cancelQueries({ queryKey });\n            const previous = client.getQueryData<TData>(queryKey);\n            client.setQueryData<TData>(queryKey, (current) => applyOptimistic(current, variables));\n            return { previous };\n        },\n        onError: (_error, _variables, context) => {\n            if (queryKey && context) client.setQueryData(queryKey, context.previous);\n        },\n        onSettled: () => {\n            if (invalidate && queryKey) void client.invalidateQueries({ queryKey });\n        },\n    });\n}\n"],"names":["useOfflineMutation","options","sync","toEntry","queryKey","applyOptimistic","flush","invalidate","client","useQueryClient","useMutation","variables","draft","id","trigger","previous","current","_error","_variables","context"],"mappings":";AA6EO,SAASA,EACZC,GACoE;AACpE,QAAM,EAAE,MAAAC,GAAM,SAAAC,GAAS,UAAAC,GAAU,iBAAAC,GAAiB,OAAAC,IAAQ,IAAM,YAAAC,IAAa,GAAA,IAAUN,GACjFO,IAASC,EAAA;AAEf,SAAOC,EAA+D;AAAA,IAClE,YAAY,OAAOC,MAAc;AAC7B,YAAMC,IAAQT,EAAQQ,CAAS,GACzBE,IAAK,MAAMX,EAAK,QAAQU,EAAM,IAAIA,EAAM,UAAUA,EAAM,OAAO;AACrE,UAAIN,MAAU,IAAO;AACjB,cAAMQ,IAAuBR,MAAU,KAAO,mBAAmBA;AACjE,QAAKJ,EAAK,MAAMY,CAAO;AAAA,MAC3B;AACA,aAAOD;AAAA,IACX;AAAA,IACA,UAAU,OAAOF,MAAc;AAC3B,UAAI,CAACP,KAAY,CAACC,EAAiB,QAAO,EAAE,UAAU,OAAA;AACtD,YAAMG,EAAO,cAAc,EAAE,UAAAJ,GAAU;AACvC,YAAMW,IAAWP,EAAO,aAAoBJ,CAAQ;AACpD,aAAAI,EAAO,aAAoBJ,GAAU,CAACY,MAAYX,EAAgBW,GAASL,CAAS,CAAC,GAC9E,EAAE,UAAAI,EAAA;AAAA,IACb;AAAA,IACA,SAAS,CAACE,GAAQC,GAAYC,MAAY;AACtC,MAAIf,KAAYe,KAASX,EAAO,aAAaJ,GAAUe,EAAQ,QAAQ;AAAA,IAC3E;AAAA,IACA,WAAW,MAAM;AACb,MAAIZ,KAAcH,KAAeI,EAAO,kBAAkB,EAAE,UAAAJ,GAAU;AAAA,IAC1E;AAAA,EAAA,CACH;AACL;"}
+{"version":3,"file":"use-offline-mutation.js","names":[],"sources":["../../src/query/use-offline-mutation.ts"],"sourcesContent":["import { useMutation, useQueryClient } from \"@tanstack/react-query\";\nimport type { QueryKey, UseMutationResult } from \"@tanstack/react-query\";\nimport type { OfflineSync, OutboxOp, SyncTrigger } from \"../offline\";\n\n/** The outbox entry a mutation's variables map to. */\nexport interface OutboxDraft<TPayload> {\n    /** The mutation kind. */\n    op: OutboxOp;\n    /** Primary key of the affected record. */\n    recordId: string;\n    /** Record snapshot for `create`/`update` (omit for `delete`). */\n    payload?: TPayload;\n}\n\n/**\n * Configuration for {@link useOfflineMutation}.\n *\n * @typeParam TVariables - The `mutate(variables)` input shape.\n * @typeParam TData - The cached query data optimistically patched.\n * @typeParam TPayload - Record snapshot carried by outbox entries.\n */\nexport interface UseOfflineMutationOptions<TVariables, TData, TPayload> {\n    /** The engine the mutation enqueues into. */\n    sync: OfflineSync<TPayload>;\n    /** Map `mutate` variables into an outbox entry. */\n    toEntry: (variables: TVariables) => OutboxDraft<TPayload>;\n    /**\n     * Query key to optimistically patch and (optionally) invalidate. Omit to\n     * only enqueue without touching the React Query cache.\n     */\n    queryKey?: QueryKey;\n    /**\n     * Produce the next cached value from the current one and the variables.\n     * Runs in `onMutate`; the previous value is restored automatically if the\n     * enqueue throws. Requires `queryKey`.\n     */\n    applyOptimistic?: (current: TData | undefined, variables: TVariables) => TData;\n    /**\n     * Trigger a flush after enqueueing. `true` (default) uses\n     * `\"after-mutation\"`; pass a custom {@link SyncTrigger} string, or `false`\n     * to leave flushing to the caller / auto-flush hooks.\n     */\n    flush?: boolean | SyncTrigger;\n    /** Invalidate `queryKey` in `onSettled` so a later read refetches. Default `false`. */\n    invalidate?: boolean;\n}\n\ninterface MutationContext<TData> {\n    previous: TData | undefined;\n}\n\n/**\n * Optimistic mutation that writes to an {@link OfflineSync} outbox instead of\n * hitting the network directly, bridging the sync engine and TanStack Query.\n *\n * On `mutate` it enqueues the entry, optimistically patches the given query\n * cache key and kicks a flush; if the enqueue itself throws, the cache is\n * rolled back to its previous value. Server delivery happens later inside the\n * engine's flush loop, so the UI updates instantly and survives reloads and\n * offline periods.\n *\n * @typeParam TVariables - The `mutate(variables)` input shape.\n * @typeParam TData - The cached query data optimistically patched.\n * @typeParam TPayload - Record snapshot carried by outbox entries.\n * @param options - Engine, variables→entry mapping and cache wiring.\n * @returns The TanStack {@link UseMutationResult}; the mutation resolves to the\n *   generated outbox entry id.\n *\n * @example\n * const addNote = useOfflineMutation({\n *     sync: notesSync,\n *     queryKey: [\"notes\"],\n *     toEntry: (note: Note) => ({ op: \"create\", recordId: note.id, payload: note }),\n *     applyOptimistic: (current: Note[] = [], note) => [...current, note],\n * });\n * addNote.mutate(newNote);\n */\nexport function useOfflineMutation<TVariables, TData = unknown, TPayload = unknown>(\n    options: UseOfflineMutationOptions<TVariables, TData, TPayload>,\n): UseMutationResult<string, Error, TVariables, MutationContext<TData>> {\n    const { sync, toEntry, queryKey, applyOptimistic, flush = true, invalidate = false } = options;\n    const client = useQueryClient();\n\n    return useMutation<string, Error, TVariables, MutationContext<TData>>({\n        mutationFn: async (variables) => {\n            const draft = toEntry(variables);\n            const id = await sync.enqueue(draft.op, draft.recordId, draft.payload);\n            if (flush !== false) {\n                const trigger: SyncTrigger = flush === true ? \"after-mutation\" : flush;\n                void sync.flush(trigger);\n            }\n            return id;\n        },\n        onMutate: async (variables) => {\n            if (!queryKey || !applyOptimistic) return { previous: undefined };\n            await client.cancelQueries({ queryKey });\n            const previous = client.getQueryData<TData>(queryKey);\n            client.setQueryData<TData>(queryKey, (current) => applyOptimistic(current, variables));\n            return { previous };\n        },\n        onError: (_error, _variables, context) => {\n            if (queryKey && context) client.setQueryData(queryKey, context.previous);\n        },\n        onSettled: () => {\n            if (invalidate && queryKey) void client.invalidateQueries({ queryKey });\n        },\n    });\n}\n"],"mappings":";;AA6EA,SAAgB,EACZ,GACoE;CACpE,IAAM,EAAE,SAAM,YAAS,aAAU,oBAAiB,WAAQ,IAAM,gBAAa,OAAU,GACjF,IAAS,EAAe;CAE9B,OAAO,EAA+D;EAClE,YAAY,OAAO,MAAc;GAC7B,IAAM,IAAQ,EAAQ,CAAS,GACzB,IAAK,MAAM,EAAK,QAAQ,EAAM,IAAI,EAAM,UAAU,EAAM,OAAO;GACrE,IAAI,MAAU,IAAO;IACjB,IAAM,IAAuB,MAAU,KAAO,mBAAmB;IACjE,EAAU,MAAM,CAAO;GAC3B;GACA,OAAO;EACX;EACA,UAAU,OAAO,MAAc;GAC3B,IAAI,CAAC,KAAY,CAAC,GAAiB,OAAO,EAAE,UAAU,KAAA,EAAU;GAChE,MAAM,EAAO,cAAc,EAAE,YAAS,CAAC;GACvC,IAAM,IAAW,EAAO,aAAoB,CAAQ;GAEpD,OADA,EAAO,aAAoB,IAAW,MAAY,EAAgB,GAAS,CAAS,CAAC,GAC9E,EAAE,YAAS;EACtB;EACA,UAAU,GAAQ,GAAY,MAAY;GACtC,AAAI,KAAY,KAAS,EAAO,aAAa,GAAU,EAAQ,QAAQ;EAC3E;EACA,iBAAiB;GACb,AAAI,KAAc,KAAU,EAAY,kBAAkB,EAAE,YAAS,CAAC;EAC1E;CACJ,CAAC;AACL"}

package/dist/query/use-paginated-query.cjs

@@ -1,2 +1,2 @@
-"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const n=require("react"),y=require("@tanstack/react-query");function k(l){const{queryKey:d,queryFn:p,initialPage:P=1,pageSize:u=20,sizeParam:c="size",orderBy:o,ascending:g=!1,...b}=l,[t,i]=n.useState(P),a=y.useQuery({...b,queryKey:[...d,{page:t,pageSize:u,sizeParam:c,orderBy:o,ascending:g}],queryFn:()=>{const e={page:t,[c]:u};return o&&(e.order_by=o,e.ascending=g),p(e)},placeholderData:y.keepPreviousData}),r=a.data,s=r?.pages??0,h=t<s,m=t>1,q=n.useCallback(e=>i(Math.max(1,e)),[]),f=n.useCallback(()=>i(e=>e<s?e+1:e),[s]),v=n.useCallback(()=>i(e=>e>1?e-1:e),[]);return{page:r,items:r?.items??[],pageNumber:t,pageCount:s,total:r?.total??0,hasNext:h,hasPrev:m,isLoading:a.isLoading,isFetching:a.isFetching,error:a.error,setPage:q,next:f,prev:v,refetch:()=>{a.refetch()}}}exports.usePaginatedQuery=k;
-//# sourceMappingURL=use-paginated-query.cjs.map
+let e=require("react"),t=require("@tanstack/react-query");function n(n){let{queryKey:r,queryFn:i,initialPage:a=1,pageSize:o=20,sizeParam:s=`size`,orderBy:c,ascending:l=!1,...u}=n,[d,f]=(0,e.useState)(a),p=(0,t.useQuery)({...u,queryKey:[...r,{page:d,pageSize:o,sizeParam:s,orderBy:c,ascending:l}],queryFn:()=>{let e={page:d,[s]:o};return c&&(e.order_by=c,e.ascending=l),i(e)},placeholderData:t.keepPreviousData}),m=p.data,h=m?.pages??0,g=d<h,_=d>1,v=(0,e.useCallback)(e=>f(Math.max(1,e)),[]),y=(0,e.useCallback)(()=>f(e=>e<h?e+1:e),[h]),b=(0,e.useCallback)(()=>f(e=>e>1?e-1:e),[]);return{page:m,items:m?.items??[],pageNumber:d,pageCount:h,total:m?.total??0,hasNext:g,hasPrev:_,isLoading:p.isLoading,isFetching:p.isFetching,error:p.error,setPage:v,next:y,prev:b,refetch:()=>void p.refetch()}}exports.usePaginatedQuery=n;
+//# sourceMappingURL=use-paginated-query.cjs.map

package/dist/query/use-paginated-query.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"use-paginated-query.cjs","sources":["../../src/query/use-paginated-query.ts"],"sourcesContent":["import { useCallback, useState } from \"react\";\nimport { keepPreviousData, useQuery } from \"@tanstack/react-query\";\nimport type { QueryKey, UseQueryOptions } from \"@tanstack/react-query\";\n\nimport type { OffsetPage, OffsetParams } from \"./pagination\";\n\nexport interface UsePaginatedQueryOptions<T> extends Omit<\n    UseQueryOptions<OffsetPage<T>, Error, OffsetPage<T>, QueryKey>,\n    \"queryKey\" | \"queryFn\"\n> {\n    /** Base query key — the current page/sort is appended for cache isolation. */\n    queryKey: QueryKey;\n    /** Fetcher receiving the offset params; return the backend envelope. */\n    queryFn: (params: OffsetParams) => Promise<OffsetPage<T>> | OffsetPage<T>;\n    /** Initial 1-based page. Default: 1. */\n    initialPage?: number;\n    /** Page size. Default: 20. */\n    pageSize?: number;\n    /**\n     * Query-param name for the page size. fastapi-pagination uses `\"size\"`\n     * (default); SDK `BasePaginationFilterSchema` configs may use `\"page_size\"`.\n     */\n    sizeParam?: \"size\" | \"page_size\";\n    /** Initial `order_by` (only sent when set). */\n    orderBy?: string;\n    /** Initial `ascending` (only sent when `orderBy` is set). Default: false. */\n    ascending?: boolean;\n}\n\nexport interface UsePaginatedQueryResult<T> {\n    /** The current page envelope, or undefined while the first load is pending. */\n    page: OffsetPage<T> | undefined;\n    /** The rows of the current page (empty array while pending). */\n    items: T[];\n    /** Current 1-based page number (controlled by the hook). */\n    pageNumber: number;\n    /** Total page count from the last successful response. */\n    pageCount: number;\n    /** Total row count from the last successful response. */\n    total: number;\n    hasNext: boolean;\n    hasPrev: boolean;\n    isLoading: boolean;\n    isFetching: boolean;\n    error: Error | null;\n    /** Jump to a specific 1-based page (clamped to >= 1). */\n    setPage: (page: number) => void;\n    /** Go to the next page when available. */\n    next: () => void;\n    /** Go to the previous page when available. */\n    prev: () => void;\n    /** Refetch the current page. */\n    refetch: () => void;\n}\n\n/**\n * Offset-pagination hook over TanStack Query for the fastapi-pagination /\n * Tempest envelope (`{ items, total, page, size, pages }`).\n *\n * It owns the page state, sends `page` + the size param (`size` by default,\n * or `page_size` via `sizeParam`) plus optional `order_by`/`ascending` to your\n * fetcher, keeps the previous page visible while the next loads, and derives\n * `hasNext`/`hasPrev`/`pageCount`.\n *\n * @example\n * const users = usePaginatedQuery<User>({\n *     queryKey: [\"users\"],\n *     pageSize: 25,\n *     queryFn: (params) => usersService.listUsers(params),\n * });\n * // users.items, users.next(), users.hasNext, users.pageCount\n */\nexport function usePaginatedQuery<T>(\n    options: UsePaginatedQueryOptions<T>,\n): UsePaginatedQueryResult<T> {\n    const {\n        queryKey,\n        queryFn,\n        initialPage = 1,\n        pageSize = 20,\n        sizeParam = \"size\",\n        orderBy,\n        ascending = false,\n        ...queryOptions\n    } = options;\n\n    const [pageNumber, setPageNumber] = useState(initialPage);\n\n    const query = useQuery<OffsetPage<T>, Error>({\n        ...queryOptions,\n        queryKey: [...queryKey, { page: pageNumber, pageSize, sizeParam, orderBy, ascending }],\n        queryFn: () => {\n            const params: OffsetParams = { page: pageNumber, [sizeParam]: pageSize };\n            if (orderBy) {\n                params.order_by = orderBy;\n                params.ascending = ascending;\n            }\n            return queryFn(params);\n        },\n        placeholderData: keepPreviousData,\n    });\n\n    const page = query.data;\n    const pageCount = page?.pages ?? 0;\n    const hasNext = pageNumber < pageCount;\n    const hasPrev = pageNumber > 1;\n\n    const setPage = useCallback((next: number) => setPageNumber(Math.max(1, next)), []);\n    const next = useCallback(() => setPageNumber((p) => (p < pageCount ? p + 1 : p)), [pageCount]);\n    const prev = useCallback(() => setPageNumber((p) => (p > 1 ? p - 1 : p)), []);\n\n    return {\n        page,\n        items: page?.items ?? [],\n        pageNumber,\n        pageCount,\n        total: page?.total ?? 0,\n        hasNext,\n        hasPrev,\n        isLoading: query.isLoading,\n        isFetching: query.isFetching,\n        error: query.error,\n        setPage,\n        next,\n        prev,\n        refetch: () => void query.refetch(),\n    };\n}\n"],"names":["usePaginatedQuery","options","queryKey","queryFn","initialPage","pageSize","sizeParam","orderBy","ascending","queryOptions","pageNumber","setPageNumber","useState","query","useQuery","params","keepPreviousData","page","pageCount","hasNext","hasPrev","setPage","useCallback","next","p","prev"],"mappings":"4IAwEO,SAASA,EACZC,EAC0B,CAC1B,KAAM,CACF,SAAAC,EACA,QAAAC,EACA,YAAAC,EAAc,EACd,SAAAC,EAAW,GACX,UAAAC,EAAY,OACZ,QAAAC,EACA,UAAAC,EAAY,GACZ,GAAGC,CAAA,EACHR,EAEE,CAACS,EAAYC,CAAa,EAAIC,EAAAA,SAASR,CAAW,EAElDS,EAAQC,EAAAA,SAA+B,CACzC,GAAGL,EACH,SAAU,CAAC,GAAGP,EAAU,CAAE,KAAMQ,EAAY,SAAAL,EAAU,UAAAC,EAAW,QAAAC,EAAS,UAAAC,EAAW,EACrF,QAAS,IAAM,CACX,MAAMO,EAAuB,CAAE,KAAML,EAAY,CAACJ,CAAS,EAAGD,CAAA,EAC9D,OAAIE,IACAQ,EAAO,SAAWR,EAClBQ,EAAO,UAAYP,GAEhBL,EAAQY,CAAM,CACzB,EACA,gBAAiBC,EAAAA,gBAAA,CACpB,EAEKC,EAAOJ,EAAM,KACbK,EAAYD,GAAM,OAAS,EAC3BE,EAAUT,EAAaQ,EACvBE,EAAUV,EAAa,EAEvBW,EAAUC,EAAAA,YAAaC,GAAiBZ,EAAc,KAAK,IAAI,EAAGY,CAAI,CAAC,EAAG,CAAA,CAAE,EAC5EA,EAAOD,EAAAA,YAAY,IAAMX,EAAea,GAAOA,EAAIN,EAAYM,EAAI,EAAIA,CAAE,EAAG,CAACN,CAAS,CAAC,EACvFO,EAAOH,EAAAA,YAAY,IAAMX,EAAea,GAAOA,EAAI,EAAIA,EAAI,EAAIA,CAAE,EAAG,CAAA,CAAE,EAE5E,MAAO,CACH,KAAAP,EACA,MAAOA,GAAM,OAAS,CAAA,EACtB,WAAAP,EACA,UAAAQ,EACA,MAAOD,GAAM,OAAS,EACtB,QAAAE,EACA,QAAAC,EACA,UAAWP,EAAM,UACjB,WAAYA,EAAM,WAClB,MAAOA,EAAM,MACb,QAAAQ,EACA,KAAAE,EACA,KAAAE,EACA,QAAS,IAAA,CAAWZ,EAAM,QAAA,EAAQ,CAE1C"}
+{"version":3,"file":"use-paginated-query.cjs","names":[],"sources":["../../src/query/use-paginated-query.ts"],"sourcesContent":["import { useCallback, useState } from \"react\";\nimport { keepPreviousData, useQuery } from \"@tanstack/react-query\";\nimport type { QueryKey, UseQueryOptions } from \"@tanstack/react-query\";\n\nimport type { OffsetPage, OffsetParams } from \"./pagination\";\n\nexport interface UsePaginatedQueryOptions<T> extends Omit<\n    UseQueryOptions<OffsetPage<T>, Error, OffsetPage<T>, QueryKey>,\n    \"queryKey\" | \"queryFn\"\n> {\n    /** Base query key — the current page/sort is appended for cache isolation. */\n    queryKey: QueryKey;\n    /** Fetcher receiving the offset params; return the backend envelope. */\n    queryFn: (params: OffsetParams) => Promise<OffsetPage<T>> | OffsetPage<T>;\n    /** Initial 1-based page. Default: 1. */\n    initialPage?: number;\n    /** Page size. Default: 20. */\n    pageSize?: number;\n    /**\n     * Query-param name for the page size. fastapi-pagination uses `\"size\"`\n     * (default); SDK `BasePaginationFilterSchema` configs may use `\"page_size\"`.\n     */\n    sizeParam?: \"size\" | \"page_size\";\n    /** Initial `order_by` (only sent when set). */\n    orderBy?: string;\n    /** Initial `ascending` (only sent when `orderBy` is set). Default: false. */\n    ascending?: boolean;\n}\n\nexport interface UsePaginatedQueryResult<T> {\n    /** The current page envelope, or undefined while the first load is pending. */\n    page: OffsetPage<T> | undefined;\n    /** The rows of the current page (empty array while pending). */\n    items: T[];\n    /** Current 1-based page number (controlled by the hook). */\n    pageNumber: number;\n    /** Total page count from the last successful response. */\n    pageCount: number;\n    /** Total row count from the last successful response. */\n    total: number;\n    hasNext: boolean;\n    hasPrev: boolean;\n    isLoading: boolean;\n    isFetching: boolean;\n    error: Error | null;\n    /** Jump to a specific 1-based page (clamped to >= 1). */\n    setPage: (page: number) => void;\n    /** Go to the next page when available. */\n    next: () => void;\n    /** Go to the previous page when available. */\n    prev: () => void;\n    /** Refetch the current page. */\n    refetch: () => void;\n}\n\n/**\n * Offset-pagination hook over TanStack Query for the fastapi-pagination /\n * Tempest envelope (`{ items, total, page, size, pages }`).\n *\n * It owns the page state, sends `page` + the size param (`size` by default,\n * or `page_size` via `sizeParam`) plus optional `order_by`/`ascending` to your\n * fetcher, keeps the previous page visible while the next loads, and derives\n * `hasNext`/`hasPrev`/`pageCount`.\n *\n * @example\n * const users = usePaginatedQuery<User>({\n *     queryKey: [\"users\"],\n *     pageSize: 25,\n *     queryFn: (params) => usersService.listUsers(params),\n * });\n * // users.items, users.next(), users.hasNext, users.pageCount\n */\nexport function usePaginatedQuery<T>(\n    options: UsePaginatedQueryOptions<T>,\n): UsePaginatedQueryResult<T> {\n    const {\n        queryKey,\n        queryFn,\n        initialPage = 1,\n        pageSize = 20,\n        sizeParam = \"size\",\n        orderBy,\n        ascending = false,\n        ...queryOptions\n    } = options;\n\n    const [pageNumber, setPageNumber] = useState(initialPage);\n\n    const query = useQuery<OffsetPage<T>, Error>({\n        ...queryOptions,\n        queryKey: [...queryKey, { page: pageNumber, pageSize, sizeParam, orderBy, ascending }],\n        queryFn: () => {\n            const params: OffsetParams = { page: pageNumber, [sizeParam]: pageSize };\n            if (orderBy) {\n                params.order_by = orderBy;\n                params.ascending = ascending;\n            }\n            return queryFn(params);\n        },\n        placeholderData: keepPreviousData,\n    });\n\n    const page = query.data;\n    const pageCount = page?.pages ?? 0;\n    const hasNext = pageNumber < pageCount;\n    const hasPrev = pageNumber > 1;\n\n    const setPage = useCallback((next: number) => setPageNumber(Math.max(1, next)), []);\n    const next = useCallback(() => setPageNumber((p) => (p < pageCount ? p + 1 : p)), [pageCount]);\n    const prev = useCallback(() => setPageNumber((p) => (p > 1 ? p - 1 : p)), []);\n\n    return {\n        page,\n        items: page?.items ?? [],\n        pageNumber,\n        pageCount,\n        total: page?.total ?? 0,\n        hasNext,\n        hasPrev,\n        isLoading: query.isLoading,\n        isFetching: query.isFetching,\n        error: query.error,\n        setPage,\n        next,\n        prev,\n        refetch: () => void query.refetch(),\n    };\n}\n"],"mappings":"0DAwEA,SAAgB,EACZ,EAC0B,CAC1B,GAAM,CACF,WACA,UACA,cAAc,EACd,WAAW,GACX,YAAY,OACZ,UACA,YAAY,GACZ,GAAG,GACH,EAEE,CAAC,EAAY,IAAA,EAAA,EAAA,SAAA,CAA0B,CAAW,EAElD,GAAA,EAAA,EAAA,SAAA,CAAuC,CACzC,GAAG,EACH,SAAU,CAAC,GAAG,EAAU,CAAE,KAAM,EAAY,WAAU,YAAW,UAAS,WAAU,CAAC,EACrF,YAAe,CACX,IAAM,EAAuB,CAAE,KAAM,GAAa,GAAY,CAAS,EAKvE,OAJI,IACA,EAAO,SAAW,EAClB,EAAO,UAAY,GAEhB,EAAQ,CAAM,CACzB,EACA,gBAAiB,EAAA,gBACrB,CAAC,EAEK,EAAO,EAAM,KACb,EAAY,GAAM,OAAS,EAC3B,EAAU,EAAa,EACvB,EAAU,EAAa,EAEvB,GAAA,EAAA,EAAA,YAAA,CAAuB,GAAiB,EAAc,KAAK,IAAI,EAAG,CAAI,CAAC,EAAG,CAAC,CAAC,EAC5E,GAAA,EAAA,EAAA,YAAA,KAAyB,EAAe,GAAO,EAAI,EAAY,EAAI,EAAI,CAAE,EAAG,CAAC,CAAS,CAAC,EACvF,GAAA,EAAA,EAAA,YAAA,KAAyB,EAAe,GAAO,EAAI,EAAI,EAAI,EAAI,CAAE,EAAG,CAAC,CAAC,EAE5E,MAAO,CACH,OACA,MAAO,GAAM,OAAS,CAAC,EACvB,aACA,YACA,MAAO,GAAM,OAAS,EACtB,UACA,UACA,UAAW,EAAM,UACjB,WAAY,EAAM,WAClB,MAAO,EAAM,MACb,UACA,OACA,OACA,YAAe,KAAK,EAAM,QAAQ,CACtC,CACJ"}

package/dist/query/use-paginated-query.js

@@ -1,44 +1,43 @@
-import { useState as v, useCallback as i } from "react";
-import { useQuery as x, keepPreviousData as F } from "@tanstack/react-query";
-function k(y) {
-  const {
-    queryKey: m,
-    queryFn: p,
-    initialPage: d = 1,
-    pageSize: c = 20,
-    sizeParam: u = "size",
-    orderBy: n,
-    ascending: g = !1,
-    ...h
-  } = y, [t, o] = v(d), a = x({
-    ...h,
-    queryKey: [...m, { page: t, pageSize: c, sizeParam: u, orderBy: n, ascending: g }],
-    queryFn: () => {
-      const e = { page: t, [u]: c };
-      return n && (e.order_by = n, e.ascending = g), p(e);
-    },
-    placeholderData: F
-  }), r = a.data, s = r?.pages ?? 0, l = t < s, f = t > 1, P = i((e) => o(Math.max(1, e)), []), q = i(() => o((e) => e < s ? e + 1 : e), [s]), b = i(() => o((e) => e > 1 ? e - 1 : e), []);
-  return {
-    page: r,
-    items: r?.items ?? [],
-    pageNumber: t,
-    pageCount: s,
-    total: r?.total ?? 0,
-    hasNext: l,
-    hasPrev: f,
-    isLoading: a.isLoading,
-    isFetching: a.isFetching,
-    error: a.error,
-    setPage: P,
-    next: q,
-    prev: b,
-    refetch: () => {
-      a.refetch();
-    }
-  };
+import { useCallback as e, useState as t } from "react";
+import { keepPreviousData as n, useQuery as r } from "@tanstack/react-query";
+//#region src/query/use-paginated-query.ts
+function i(i) {
+	let { queryKey: a, queryFn: o, initialPage: s = 1, pageSize: c = 20, sizeParam: l = "size", orderBy: u, ascending: d = !1, ...f } = i, [p, m] = t(s), h = r({
+		...f,
+		queryKey: [...a, {
+			page: p,
+			pageSize: c,
+			sizeParam: l,
+			orderBy: u,
+			ascending: d
+		}],
+		queryFn: () => {
+			let e = {
+				page: p,
+				[l]: c
+			};
+			return u && (e.order_by = u, e.ascending = d), o(e);
+		},
+		placeholderData: n
+	}), g = h.data, _ = g?.pages ?? 0, v = p < _, y = p > 1, b = e((e) => m(Math.max(1, e)), []), x = e(() => m((e) => e < _ ? e + 1 : e), [_]), S = e(() => m((e) => e > 1 ? e - 1 : e), []);
+	return {
+		page: g,
+		items: g?.items ?? [],
+		pageNumber: p,
+		pageCount: _,
+		total: g?.total ?? 0,
+		hasNext: v,
+		hasPrev: y,
+		isLoading: h.isLoading,
+		isFetching: h.isFetching,
+		error: h.error,
+		setPage: b,
+		next: x,
+		prev: S,
+		refetch: () => void h.refetch()
+	};
 }
-export {
-  k as usePaginatedQuery
-};
-//# sourceMappingURL=use-paginated-query.js.map
+//#endregion
+export { i as usePaginatedQuery };
+
+//# sourceMappingURL=use-paginated-query.js.map

package/dist/query/use-paginated-query.js.map

@@ -1 +1 @@
-{"version":3,"file":"use-paginated-query.js","sources":["../../src/query/use-paginated-query.ts"],"sourcesContent":["import { useCallback, useState } from \"react\";\nimport { keepPreviousData, useQuery } from \"@tanstack/react-query\";\nimport type { QueryKey, UseQueryOptions } from \"@tanstack/react-query\";\n\nimport type { OffsetPage, OffsetParams } from \"./pagination\";\n\nexport interface UsePaginatedQueryOptions<T> extends Omit<\n    UseQueryOptions<OffsetPage<T>, Error, OffsetPage<T>, QueryKey>,\n    \"queryKey\" | \"queryFn\"\n> {\n    /** Base query key — the current page/sort is appended for cache isolation. */\n    queryKey: QueryKey;\n    /** Fetcher receiving the offset params; return the backend envelope. */\n    queryFn: (params: OffsetParams) => Promise<OffsetPage<T>> | OffsetPage<T>;\n    /** Initial 1-based page. Default: 1. */\n    initialPage?: number;\n    /** Page size. Default: 20. */\n    pageSize?: number;\n    /**\n     * Query-param name for the page size. fastapi-pagination uses `\"size\"`\n     * (default); SDK `BasePaginationFilterSchema` configs may use `\"page_size\"`.\n     */\n    sizeParam?: \"size\" | \"page_size\";\n    /** Initial `order_by` (only sent when set). */\n    orderBy?: string;\n    /** Initial `ascending` (only sent when `orderBy` is set). Default: false. */\n    ascending?: boolean;\n}\n\nexport interface UsePaginatedQueryResult<T> {\n    /** The current page envelope, or undefined while the first load is pending. */\n    page: OffsetPage<T> | undefined;\n    /** The rows of the current page (empty array while pending). */\n    items: T[];\n    /** Current 1-based page number (controlled by the hook). */\n    pageNumber: number;\n    /** Total page count from the last successful response. */\n    pageCount: number;\n    /** Total row count from the last successful response. */\n    total: number;\n    hasNext: boolean;\n    hasPrev: boolean;\n    isLoading: boolean;\n    isFetching: boolean;\n    error: Error | null;\n    /** Jump to a specific 1-based page (clamped to >= 1). */\n    setPage: (page: number) => void;\n    /** Go to the next page when available. */\n    next: () => void;\n    /** Go to the previous page when available. */\n    prev: () => void;\n    /** Refetch the current page. */\n    refetch: () => void;\n}\n\n/**\n * Offset-pagination hook over TanStack Query for the fastapi-pagination /\n * Tempest envelope (`{ items, total, page, size, pages }`).\n *\n * It owns the page state, sends `page` + the size param (`size` by default,\n * or `page_size` via `sizeParam`) plus optional `order_by`/`ascending` to your\n * fetcher, keeps the previous page visible while the next loads, and derives\n * `hasNext`/`hasPrev`/`pageCount`.\n *\n * @example\n * const users = usePaginatedQuery<User>({\n *     queryKey: [\"users\"],\n *     pageSize: 25,\n *     queryFn: (params) => usersService.listUsers(params),\n * });\n * // users.items, users.next(), users.hasNext, users.pageCount\n */\nexport function usePaginatedQuery<T>(\n    options: UsePaginatedQueryOptions<T>,\n): UsePaginatedQueryResult<T> {\n    const {\n        queryKey,\n        queryFn,\n        initialPage = 1,\n        pageSize = 20,\n        sizeParam = \"size\",\n        orderBy,\n        ascending = false,\n        ...queryOptions\n    } = options;\n\n    const [pageNumber, setPageNumber] = useState(initialPage);\n\n    const query = useQuery<OffsetPage<T>, Error>({\n        ...queryOptions,\n        queryKey: [...queryKey, { page: pageNumber, pageSize, sizeParam, orderBy, ascending }],\n        queryFn: () => {\n            const params: OffsetParams = { page: pageNumber, [sizeParam]: pageSize };\n            if (orderBy) {\n                params.order_by = orderBy;\n                params.ascending = ascending;\n            }\n            return queryFn(params);\n        },\n        placeholderData: keepPreviousData,\n    });\n\n    const page = query.data;\n    const pageCount = page?.pages ?? 0;\n    const hasNext = pageNumber < pageCount;\n    const hasPrev = pageNumber > 1;\n\n    const setPage = useCallback((next: number) => setPageNumber(Math.max(1, next)), []);\n    const next = useCallback(() => setPageNumber((p) => (p < pageCount ? p + 1 : p)), [pageCount]);\n    const prev = useCallback(() => setPageNumber((p) => (p > 1 ? p - 1 : p)), []);\n\n    return {\n        page,\n        items: page?.items ?? [],\n        pageNumber,\n        pageCount,\n        total: page?.total ?? 0,\n        hasNext,\n        hasPrev,\n        isLoading: query.isLoading,\n        isFetching: query.isFetching,\n        error: query.error,\n        setPage,\n        next,\n        prev,\n        refetch: () => void query.refetch(),\n    };\n}\n"],"names":["usePaginatedQuery","options","queryKey","queryFn","initialPage","pageSize","sizeParam","orderBy","ascending","queryOptions","pageNumber","setPageNumber","useState","query","useQuery","params","keepPreviousData","page","pageCount","hasNext","hasPrev","setPage","useCallback","next","p","prev"],"mappings":";;AAwEO,SAASA,EACZC,GAC0B;AAC1B,QAAM;AAAA,IACF,UAAAC;AAAA,IACA,SAAAC;AAAA,IACA,aAAAC,IAAc;AAAA,IACd,UAAAC,IAAW;AAAA,IACX,WAAAC,IAAY;AAAA,IACZ,SAAAC;AAAA,IACA,WAAAC,IAAY;AAAA,IACZ,GAAGC;AAAA,EAAA,IACHR,GAEE,CAACS,GAAYC,CAAa,IAAIC,EAASR,CAAW,GAElDS,IAAQC,EAA+B;AAAA,IACzC,GAAGL;AAAA,IACH,UAAU,CAAC,GAAGP,GAAU,EAAE,MAAMQ,GAAY,UAAAL,GAAU,WAAAC,GAAW,SAAAC,GAAS,WAAAC,GAAW;AAAA,IACrF,SAAS,MAAM;AACX,YAAMO,IAAuB,EAAE,MAAML,GAAY,CAACJ,CAAS,GAAGD,EAAA;AAC9D,aAAIE,MACAQ,EAAO,WAAWR,GAClBQ,EAAO,YAAYP,IAEhBL,EAAQY,CAAM;AAAA,IACzB;AAAA,IACA,iBAAiBC;AAAA,EAAA,CACpB,GAEKC,IAAOJ,EAAM,MACbK,IAAYD,GAAM,SAAS,GAC3BE,IAAUT,IAAaQ,GACvBE,IAAUV,IAAa,GAEvBW,IAAUC,EAAY,CAACC,MAAiBZ,EAAc,KAAK,IAAI,GAAGY,CAAI,CAAC,GAAG,CAAA,CAAE,GAC5EA,IAAOD,EAAY,MAAMX,EAAc,CAACa,MAAOA,IAAIN,IAAYM,IAAI,IAAIA,CAAE,GAAG,CAACN,CAAS,CAAC,GACvFO,IAAOH,EAAY,MAAMX,EAAc,CAACa,MAAOA,IAAI,IAAIA,IAAI,IAAIA,CAAE,GAAG,CAAA,CAAE;AAE5E,SAAO;AAAA,IACH,MAAAP;AAAA,IACA,OAAOA,GAAM,SAAS,CAAA;AAAA,IACtB,YAAAP;AAAA,IACA,WAAAQ;AAAA,IACA,OAAOD,GAAM,SAAS;AAAA,IACtB,SAAAE;AAAA,IACA,SAAAC;AAAA,IACA,WAAWP,EAAM;AAAA,IACjB,YAAYA,EAAM;AAAA,IAClB,OAAOA,EAAM;AAAA,IACb,SAAAQ;AAAA,IACA,MAAAE;AAAA,IACA,MAAAE;AAAA,IACA,SAAS,MAAA;AAAM,MAAKZ,EAAM,QAAA;AAAA;AAAA,EAAQ;AAE1C;"}
+{"version":3,"file":"use-paginated-query.js","names":[],"sources":["../../src/query/use-paginated-query.ts"],"sourcesContent":["import { useCallback, useState } from \"react\";\nimport { keepPreviousData, useQuery } from \"@tanstack/react-query\";\nimport type { QueryKey, UseQueryOptions } from \"@tanstack/react-query\";\n\nimport type { OffsetPage, OffsetParams } from \"./pagination\";\n\nexport interface UsePaginatedQueryOptions<T> extends Omit<\n    UseQueryOptions<OffsetPage<T>, Error, OffsetPage<T>, QueryKey>,\n    \"queryKey\" | \"queryFn\"\n> {\n    /** Base query key — the current page/sort is appended for cache isolation. */\n    queryKey: QueryKey;\n    /** Fetcher receiving the offset params; return the backend envelope. */\n    queryFn: (params: OffsetParams) => Promise<OffsetPage<T>> | OffsetPage<T>;\n    /** Initial 1-based page. Default: 1. */\n    initialPage?: number;\n    /** Page size. Default: 20. */\n    pageSize?: number;\n    /**\n     * Query-param name for the page size. fastapi-pagination uses `\"size\"`\n     * (default); SDK `BasePaginationFilterSchema` configs may use `\"page_size\"`.\n     */\n    sizeParam?: \"size\" | \"page_size\";\n    /** Initial `order_by` (only sent when set). */\n    orderBy?: string;\n    /** Initial `ascending` (only sent when `orderBy` is set). Default: false. */\n    ascending?: boolean;\n}\n\nexport interface UsePaginatedQueryResult<T> {\n    /** The current page envelope, or undefined while the first load is pending. */\n    page: OffsetPage<T> | undefined;\n    /** The rows of the current page (empty array while pending). */\n    items: T[];\n    /** Current 1-based page number (controlled by the hook). */\n    pageNumber: number;\n    /** Total page count from the last successful response. */\n    pageCount: number;\n    /** Total row count from the last successful response. */\n    total: number;\n    hasNext: boolean;\n    hasPrev: boolean;\n    isLoading: boolean;\n    isFetching: boolean;\n    error: Error | null;\n    /** Jump to a specific 1-based page (clamped to >= 1). */\n    setPage: (page: number) => void;\n    /** Go to the next page when available. */\n    next: () => void;\n    /** Go to the previous page when available. */\n    prev: () => void;\n    /** Refetch the current page. */\n    refetch: () => void;\n}\n\n/**\n * Offset-pagination hook over TanStack Query for the fastapi-pagination /\n * Tempest envelope (`{ items, total, page, size, pages }`).\n *\n * It owns the page state, sends `page` + the size param (`size` by default,\n * or `page_size` via `sizeParam`) plus optional `order_by`/`ascending` to your\n * fetcher, keeps the previous page visible while the next loads, and derives\n * `hasNext`/`hasPrev`/`pageCount`.\n *\n * @example\n * const users = usePaginatedQuery<User>({\n *     queryKey: [\"users\"],\n *     pageSize: 25,\n *     queryFn: (params) => usersService.listUsers(params),\n * });\n * // users.items, users.next(), users.hasNext, users.pageCount\n */\nexport function usePaginatedQuery<T>(\n    options: UsePaginatedQueryOptions<T>,\n): UsePaginatedQueryResult<T> {\n    const {\n        queryKey,\n        queryFn,\n        initialPage = 1,\n        pageSize = 20,\n        sizeParam = \"size\",\n        orderBy,\n        ascending = false,\n        ...queryOptions\n    } = options;\n\n    const [pageNumber, setPageNumber] = useState(initialPage);\n\n    const query = useQuery<OffsetPage<T>, Error>({\n        ...queryOptions,\n        queryKey: [...queryKey, { page: pageNumber, pageSize, sizeParam, orderBy, ascending }],\n        queryFn: () => {\n            const params: OffsetParams = { page: pageNumber, [sizeParam]: pageSize };\n            if (orderBy) {\n                params.order_by = orderBy;\n                params.ascending = ascending;\n            }\n            return queryFn(params);\n        },\n        placeholderData: keepPreviousData,\n    });\n\n    const page = query.data;\n    const pageCount = page?.pages ?? 0;\n    const hasNext = pageNumber < pageCount;\n    const hasPrev = pageNumber > 1;\n\n    const setPage = useCallback((next: number) => setPageNumber(Math.max(1, next)), []);\n    const next = useCallback(() => setPageNumber((p) => (p < pageCount ? p + 1 : p)), [pageCount]);\n    const prev = useCallback(() => setPageNumber((p) => (p > 1 ? p - 1 : p)), []);\n\n    return {\n        page,\n        items: page?.items ?? [],\n        pageNumber,\n        pageCount,\n        total: page?.total ?? 0,\n        hasNext,\n        hasPrev,\n        isLoading: query.isLoading,\n        isFetching: query.isFetching,\n        error: query.error,\n        setPage,\n        next,\n        prev,\n        refetch: () => void query.refetch(),\n    };\n}\n"],"mappings":";;;AAwEA,SAAgB,EACZ,GAC0B;CAC1B,IAAM,EACF,aACA,YACA,iBAAc,GACd,cAAW,IACX,eAAY,QACZ,YACA,eAAY,IACZ,GAAG,MACH,GAEE,CAAC,GAAY,KAAiB,EAAS,CAAW,GAElD,IAAQ,EAA+B;EACzC,GAAG;EACH,UAAU,CAAC,GAAG,GAAU;GAAE,MAAM;GAAY;GAAU;GAAW;GAAS;EAAU,CAAC;EACrF,eAAe;GACX,IAAM,IAAuB;IAAE,MAAM;KAAa,IAAY;GAAS;GAKvE,OAJI,MACA,EAAO,WAAW,GAClB,EAAO,YAAY,IAEhB,EAAQ,CAAM;EACzB;EACA,iBAAiB;CACrB,CAAC,GAEK,IAAO,EAAM,MACb,IAAY,GAAM,SAAS,GAC3B,IAAU,IAAa,GACvB,IAAU,IAAa,GAEvB,IAAU,GAAa,MAAiB,EAAc,KAAK,IAAI,GAAG,CAAI,CAAC,GAAG,CAAC,CAAC,GAC5E,IAAO,QAAkB,GAAe,MAAO,IAAI,IAAY,IAAI,IAAI,CAAE,GAAG,CAAC,CAAS,CAAC,GACvF,IAAO,QAAkB,GAAe,MAAO,IAAI,IAAI,IAAI,IAAI,CAAE,GAAG,CAAC,CAAC;CAE5E,OAAO;EACH;EACA,OAAO,GAAM,SAAS,CAAC;EACvB;EACA;EACA,OAAO,GAAM,SAAS;EACtB;EACA;EACA,WAAW,EAAM;EACjB,YAAY,EAAM;EAClB,OAAO,EAAM;EACb;EACA;EACA;EACA,eAAe,KAAK,EAAM,QAAQ;CACtC;AACJ"}

package/dist/router/AppRouter.cjs

@@ -1,2 +1,2 @@
-"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const r=require("react/jsx-runtime"),c=require("react"),s=require("react-router-dom"),h=require("../auth/lazy-with-retry.cjs"),m=require("./RouteGuard.cjs");function p(t){return t}const u=new WeakMap;function y(t){let e=u.get(t);return e||(e=h.lazyWithRetry(t.lazy),u.set(t,e)),e}function f({guard:t,redirectTo:e,children:o}){const n=typeof t=="function"?t():t;return r.jsx(m.RouteGuard,{when:n,redirectTo:e,children:o})}function l(t){return t.map((e,o)=>{let n=e.element;if(e.lazy){const i=y(e);n=r.jsx(i,{})}return e.guard!==void 0&&(n=r.jsx(f,{guard:e.guard,redirectTo:e.redirectTo,children:n})),e.index?r.jsx(s.Route,{index:!0,element:n},`index-${o}`):r.jsx(s.Route,{path:e.path,element:n,caseSensitive:e.caseSensitive,children:e.children?l(e.children):null},e.path??`route-${o}`)})}const x={browser:s.BrowserRouter,hash:s.HashRouter,memory:s.MemoryRouter};function j({routes:t,router:e="browser",basename:o,initialEntries:n,fallback:i=null}){const a=c.useMemo(()=>l(t),[t]),d=x[e],R=e==="memory"?{basename:o,initialEntries:n}:{basename:o};return r.jsx(d,{...R,children:r.jsx(c.Suspense,{fallback:i,children:r.jsx(s.Routes,{children:a})})})}exports.AppRouter=j;exports.defineRoutes=p;
-//# sourceMappingURL=AppRouter.cjs.map
+const e=require("../auth/lazy-with-retry.cjs"),t=require("./RouteGuard.cjs");let n=require("react"),r=require("react/jsx-runtime"),i=require("react-router");function a(e){return e}var o=new WeakMap;function s(t){let n=o.get(t);return n||(n=e.lazyWithRetry(t.lazy),o.set(t,n)),n}function c({guard:e,redirectTo:n,children:i}){return(0,r.jsx)(t.RouteGuard,{when:typeof e==`function`?e():e,redirectTo:n,children:i})}function l(e){return e.map((e,t)=>{let n=e.element;return e.lazy&&(n=(0,r.jsx)(s(e),{})),e.guard!==void 0&&(n=(0,r.jsx)(c,{guard:e.guard,redirectTo:e.redirectTo,children:n})),e.index?(0,r.jsx)(i.Route,{index:!0,element:n},`index-${t}`):(0,r.jsx)(i.Route,{path:e.path,element:n,caseSensitive:e.caseSensitive,children:e.children?l(e.children):null},e.path??`route-${t}`)})}var u={browser:i.BrowserRouter,hash:i.HashRouter,memory:i.MemoryRouter};function d({routes:e,router:t=`browser`,basename:a,initialEntries:o,fallback:s=null}){let c=(0,n.useMemo)(()=>l(e),[e]),d=u[t];return(0,r.jsx)(d,{...t===`memory`?{basename:a,initialEntries:o}:{basename:a},children:(0,r.jsx)(n.Suspense,{fallback:s,children:(0,r.jsx)(i.Routes,{children:c})})})}exports.AppRouter=d,exports.defineRoutes=a;
+//# sourceMappingURL=AppRouter.cjs.map

package/dist/router/AppRouter.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"AppRouter.cjs","sources":["../../src/router/AppRouter.tsx"],"sourcesContent":["import { Suspense, useMemo } from \"react\";\nimport type { ComponentType, ReactNode } from \"react\";\nimport { BrowserRouter, HashRouter, MemoryRouter, Routes, Route } from \"react-router-dom\";\nimport { lazyWithRetry } from \"../auth/lazy-with-retry\";\nimport { RouteGuard } from \"./RouteGuard\";\nimport type { RouterKind, TempestRouteObject } from \"./types\";\n\n/**\n * Identity helper that types a declarative route tree. Use it so editors give\n * autocomplete and type-checking on every node; the array is returned as-is.\n *\n * @example\n * export const routes = defineRoutes([\n *     { path: \"/\", element: <Layout />, children: [\n *         { index: true, lazy: () => import(\"./pages/Home\") },\n *         { path: \"settings\", lazy: () => import(\"./pages/Settings\"),\n *           guard: () => useAuth.getState().isAuthenticated, redirectTo: \"/login\" },\n *     ] },\n * ]);\n */\nexport function defineRoutes(routes: TempestRouteObject[]): TempestRouteObject[] {\n    return routes;\n}\n\nconst lazyCache = new WeakMap<TempestRouteObject, ComponentType<unknown>>();\n\nfunction resolveLazy(route: TempestRouteObject): ComponentType<unknown> {\n    let comp = lazyCache.get(route);\n    if (!comp) {\n        comp = lazyWithRetry(route.lazy!);\n        lazyCache.set(route, comp);\n    }\n    return comp;\n}\n\nfunction GuardedElement({\n    guard,\n    redirectTo,\n    children,\n}: {\n    guard: boolean | (() => boolean);\n    redirectTo?: string;\n    children: ReactNode;\n}) {\n    const allowed = typeof guard === \"function\" ? guard() : guard;\n    return (\n        <RouteGuard when={allowed} redirectTo={redirectTo}>\n            {children}\n        </RouteGuard>\n    );\n}\n\nfunction toRouteElements(routes: TempestRouteObject[]): ReactNode {\n    return routes.map((route, i) => {\n        let element: ReactNode = route.element;\n        if (route.lazy) {\n            const LazyComponent = resolveLazy(route);\n            element = <LazyComponent />;\n        }\n        if (route.guard !== undefined) {\n            element = (\n                <GuardedElement guard={route.guard} redirectTo={route.redirectTo}>\n                    {element}\n                </GuardedElement>\n            );\n        }\n\n        if (route.index) {\n            return <Route key={`index-${i}`} index element={element} />;\n        }\n\n        return (\n            <Route\n                key={route.path ?? `route-${i}`}\n                path={route.path}\n                element={element}\n                caseSensitive={route.caseSensitive}\n            >\n                {route.children ? toRouteElements(route.children) : null}\n            </Route>\n        );\n    });\n}\n\nconst ROUTERS: Record<RouterKind, typeof BrowserRouter> = {\n    browser: BrowserRouter,\n    hash: HashRouter,\n    memory: MemoryRouter,\n};\n\nexport interface AppRouterProps {\n    /** Declarative route tree, ideally built with {@link defineRoutes}. */\n    routes: TempestRouteObject[];\n    /** History strategy (default: `\"browser\"`). */\n    router?: RouterKind;\n    /** App-wide base path forwarded to the underlying router. */\n    basename?: string;\n    /** Initial URLs for the `\"memory\"` router (tests / non-DOM hosts). */\n    initialEntries?: string[];\n    /** Suspense fallback shown while a `lazy` route chunk loads. */\n    fallback?: ReactNode;\n}\n\n/**\n * Render a full React Router (v7, declarative mode) from a {@link defineRoutes}\n * tree: picks the history strategy, wraps everything in a `<Suspense>` boundary\n * for `lazy` routes, and applies per-route `guard` redirects. This is the\n * single entry point apps mount at their root.\n *\n * @example\n * <AppRouter routes={routes} fallback={<Spinner />} />\n */\nexport function AppRouter({\n    routes,\n    router = \"browser\",\n    basename,\n    initialEntries,\n    fallback = null,\n}: AppRouterProps) {\n    const tree = useMemo(() => toRouteElements(routes), [routes]);\n    const Router = ROUTERS[router];\n    const routerProps = router === \"memory\" ? { basename, initialEntries } : { basename };\n\n    return (\n        <Router {...routerProps}>\n            <Suspense fallback={fallback}>\n                <Routes>{tree}</Routes>\n            </Suspense>\n        </Router>\n    );\n}\n"],"names":["defineRoutes","routes","lazyCache","resolveLazy","route","comp","lazyWithRetry","GuardedElement","guard","redirectTo","children","allowed","jsx","RouteGuard","toRouteElements","i","element","LazyComponent","Route","ROUTERS","BrowserRouter","HashRouter","MemoryRouter","AppRouter","router","basename","initialEntries","fallback","tree","useMemo","Router","routerProps","Suspense","Routes"],"mappings":"6OAoBO,SAASA,EAAaC,EAAoD,CAC7E,OAAOA,CACX,CAEA,MAAMC,MAAgB,QAEtB,SAASC,EAAYC,EAAmD,CACpE,IAAIC,EAAOH,EAAU,IAAIE,CAAK,EAC9B,OAAKC,IACDA,EAAOC,EAAAA,cAAcF,EAAM,IAAK,EAChCF,EAAU,IAAIE,EAAOC,CAAI,GAEtBA,CACX,CAEA,SAASE,EAAe,CACpB,MAAAC,EACA,WAAAC,EACA,SAAAC,CACJ,EAIG,CACC,MAAMC,EAAU,OAAOH,GAAU,WAAaA,IAAUA,EACxD,OACII,EAAAA,IAACC,EAAAA,WAAA,CAAW,KAAMF,EAAS,WAAAF,EACtB,SAAAC,EACL,CAER,CAEA,SAASI,EAAgBb,EAAyC,CAC9D,OAAOA,EAAO,IAAI,CAACG,EAAOW,IAAM,CAC5B,IAAIC,EAAqBZ,EAAM,QAC/B,GAAIA,EAAM,KAAM,CACZ,MAAMa,EAAgBd,EAAYC,CAAK,EACvCY,QAAWC,EAAA,EAAc,CAC7B,CASA,OARIb,EAAM,QAAU,SAChBY,EACIJ,EAAAA,IAACL,GAAe,MAAOH,EAAM,MAAO,WAAYA,EAAM,WACjD,SAAAY,CAAA,CACL,GAIJZ,EAAM,YACEc,QAAA,CAAyB,MAAK,GAAC,QAAAF,CAAA,EAApB,SAASD,CAAC,EAA4B,EAIzDH,EAAAA,IAACM,EAAAA,MAAA,CAEG,KAAMd,EAAM,KACZ,QAAAY,EACA,cAAeZ,EAAM,cAEpB,SAAAA,EAAM,SAAWU,EAAgBV,EAAM,QAAQ,EAAI,IAAA,EAL/CA,EAAM,MAAQ,SAASW,CAAC,EAAA,CAQzC,CAAC,CACL,CAEA,MAAMI,EAAoD,CACtD,QAASC,EAAAA,cACT,KAAMC,EAAAA,WACN,OAAQC,EAAAA,YACZ,EAwBO,SAASC,EAAU,CACtB,OAAAtB,EACA,OAAAuB,EAAS,UACT,SAAAC,EACA,eAAAC,EACA,SAAAC,EAAW,IACf,EAAmB,CACf,MAAMC,EAAOC,EAAAA,QAAQ,IAAMf,EAAgBb,CAAM,EAAG,CAACA,CAAM,CAAC,EACtD6B,EAASX,EAAQK,CAAM,EACvBO,EAAcP,IAAW,SAAW,CAAE,SAAAC,EAAU,eAAAC,CAAA,EAAmB,CAAE,SAAAD,CAAA,EAE3E,OACIb,EAAAA,IAACkB,EAAA,CAAQ,GAAGC,EACR,SAAAnB,EAAAA,IAACoB,WAAA,CAAS,SAAAL,EACN,SAAAf,EAAAA,IAACqB,SAAA,CAAQ,SAAAL,CAAA,CAAK,CAAA,CAClB,EACJ,CAER"}
+{"version":3,"file":"AppRouter.cjs","names":[],"sources":["../../src/router/AppRouter.tsx"],"sourcesContent":["import { Suspense, useMemo } from \"react\";\nimport type { ComponentType, ReactNode } from \"react\";\nimport { BrowserRouter, HashRouter, MemoryRouter, Routes, Route } from \"react-router\";\nimport { lazyWithRetry } from \"../auth/lazy-with-retry\";\nimport { RouteGuard } from \"./RouteGuard\";\nimport type { RouterKind, TempestRouteObject } from \"./types\";\n\n/**\n * Identity helper that types a declarative route tree. Use it so editors give\n * autocomplete and type-checking on every node; the array is returned as-is.\n *\n * @example\n * export const routes = defineRoutes([\n *     { path: \"/\", element: <Layout />, children: [\n *         { index: true, lazy: () => import(\"./pages/Home\") },\n *         { path: \"settings\", lazy: () => import(\"./pages/Settings\"),\n *           guard: () => useAuth.getState().isAuthenticated, redirectTo: \"/login\" },\n *     ] },\n * ]);\n */\nexport function defineRoutes(routes: TempestRouteObject[]): TempestRouteObject[] {\n    return routes;\n}\n\nconst lazyCache = new WeakMap<TempestRouteObject, ComponentType<unknown>>();\n\nfunction resolveLazy(route: TempestRouteObject): ComponentType<unknown> {\n    let comp = lazyCache.get(route);\n    if (!comp) {\n        comp = lazyWithRetry(route.lazy!);\n        lazyCache.set(route, comp);\n    }\n    return comp;\n}\n\nfunction GuardedElement({\n    guard,\n    redirectTo,\n    children,\n}: {\n    guard: boolean | (() => boolean);\n    redirectTo?: string;\n    children: ReactNode;\n}) {\n    const allowed = typeof guard === \"function\" ? guard() : guard;\n    return (\n        <RouteGuard when={allowed} redirectTo={redirectTo}>\n            {children}\n        </RouteGuard>\n    );\n}\n\nfunction toRouteElements(routes: TempestRouteObject[]): ReactNode {\n    return routes.map((route, i) => {\n        let element: ReactNode = route.element;\n        if (route.lazy) {\n            const LazyComponent = resolveLazy(route);\n            element = <LazyComponent />;\n        }\n        if (route.guard !== undefined) {\n            element = (\n                <GuardedElement guard={route.guard} redirectTo={route.redirectTo}>\n                    {element}\n                </GuardedElement>\n            );\n        }\n\n        if (route.index) {\n            return <Route key={`index-${i}`} index element={element} />;\n        }\n\n        return (\n            <Route\n                key={route.path ?? `route-${i}`}\n                path={route.path}\n                element={element}\n                caseSensitive={route.caseSensitive}\n            >\n                {route.children ? toRouteElements(route.children) : null}\n            </Route>\n        );\n    });\n}\n\nconst ROUTERS: Record<RouterKind, typeof BrowserRouter> = {\n    browser: BrowserRouter,\n    hash: HashRouter,\n    memory: MemoryRouter,\n};\n\nexport interface AppRouterProps {\n    /** Declarative route tree, ideally built with {@link defineRoutes}. */\n    routes: TempestRouteObject[];\n    /** History strategy (default: `\"browser\"`). */\n    router?: RouterKind;\n    /** App-wide base path forwarded to the underlying router. */\n    basename?: string;\n    /** Initial URLs for the `\"memory\"` router (tests / non-DOM hosts). */\n    initialEntries?: string[];\n    /** Suspense fallback shown while a `lazy` route chunk loads. */\n    fallback?: ReactNode;\n}\n\n/**\n * Render a full React Router (v7, declarative mode) from a {@link defineRoutes}\n * tree: picks the history strategy, wraps everything in a `<Suspense>` boundary\n * for `lazy` routes, and applies per-route `guard` redirects. This is the\n * single entry point apps mount at their root.\n *\n * @example\n * <AppRouter routes={routes} fallback={<Spinner />} />\n */\nexport function AppRouter({\n    routes,\n    router = \"browser\",\n    basename,\n    initialEntries,\n    fallback = null,\n}: AppRouterProps) {\n    const tree = useMemo(() => toRouteElements(routes), [routes]);\n    const Router = ROUTERS[router];\n    const routerProps = router === \"memory\" ? { basename, initialEntries } : { basename };\n\n    return (\n        <Router {...routerProps}>\n            <Suspense fallback={fallback}>\n                <Routes>{tree}</Routes>\n            </Suspense>\n        </Router>\n    );\n}\n"],"mappings":"6JAoBA,SAAgB,EAAa,EAAoD,CAC7E,OAAO,CACX,CAEA,IAAM,EAAY,IAAI,QAEtB,SAAS,EAAY,EAAmD,CACpE,IAAI,EAAO,EAAU,IAAI,CAAK,EAK9B,OAJK,IACD,EAAO,EAAA,cAAc,EAAM,IAAK,EAChC,EAAU,IAAI,EAAO,CAAI,GAEtB,CACX,CAEA,SAAS,EAAe,CACpB,QACA,aACA,YAKD,CAEC,OACI,EAAA,EAAA,IAAA,CAAC,EAAA,WAAD,CAAY,KAFA,OAAO,GAAU,WAAa,EAAM,EAAI,EAEb,aAClC,UACO,CAAA,CAEpB,CAEA,SAAS,EAAgB,EAAyC,CAC9D,OAAO,EAAO,KAAK,EAAO,IAAM,CAC5B,IAAI,EAAqB,EAAM,QAiB/B,OAhBI,EAAM,OAEN,GAAU,EAAA,EAAA,IAAA,CADY,EAAY,CACvB,EAAD,CAAgB,CAAA,GAE1B,EAAM,QAAU,IAAA,KAChB,GACI,EAAA,EAAA,IAAA,CAAC,EAAD,CAAgB,MAAO,EAAM,MAAO,WAAY,EAAM,oBACjD,CACW,CAAA,GAIpB,EAAM,OACC,EAAA,EAAA,IAAA,CAAC,EAAA,MAAD,CAA0B,MAAA,GAAe,SAAU,EAAvC,SAAS,GAA8B,GAI1D,EAAA,EAAA,IAAA,CAAC,EAAA,MAAD,CAEI,KAAM,EAAM,KACH,UACT,cAAe,EAAM,uBAEpB,EAAM,SAAW,EAAgB,EAAM,QAAQ,EAAI,IACjD,EANE,EAAM,MAAQ,SAAS,GAMzB,CAEf,CAAC,CACL,CAEA,IAAM,EAAoD,CACtD,QAAS,EAAA,cACT,KAAM,EAAA,WACN,OAAQ,EAAA,YACZ,EAwBA,SAAgB,EAAU,CACtB,SACA,SAAS,UACT,WACA,iBACA,WAAW,MACI,CACf,IAAM,GAAA,EAAA,EAAA,QAAA,KAAqB,EAAgB,CAAM,EAAG,CAAC,CAAM,CAAC,EACtD,EAAS,EAAQ,GAGvB,OACI,EAAA,EAAA,IAAA,CAAC,EAAD,CAAQ,GAHQ,IAAW,SAAW,CAAE,WAAU,gBAAe,EAAI,CAAE,UAAS,YAI5E,EAAA,EAAA,IAAA,CAAC,EAAA,SAAD,CAAoB,qBAChB,EAAA,EAAA,IAAA,CAAC,EAAA,OAAD,CAAA,SAAS,CAAa,CAAA,CAChB,CAAA,CACN,CAAA,CAEhB"}

package/dist/router/AppRouter.js

@@ -1,60 +1,61 @@
-import { jsx as t } from "react/jsx-runtime";
-import { useMemo as d, Suspense as p } from "react";
-import { MemoryRouter as u, HashRouter as f, BrowserRouter as h, Routes as R, Route as c } from "react-router-dom";
-import { lazyWithRetry as y } from "../auth/lazy-with-retry.js";
-import { RouteGuard as w } from "./RouteGuard.js";
-function G(n) {
-  return n;
+import { lazyWithRetry as e } from "../auth/lazy-with-retry.js";
+import { RouteGuard as t } from "./RouteGuard.js";
+import { Suspense as n, useMemo as r } from "react";
+import { jsx as i } from "react/jsx-runtime";
+import { BrowserRouter as a, HashRouter as o, MemoryRouter as s, Route as c, Routes as l } from "react-router";
+//#region src/router/AppRouter.tsx
+function u(e) {
+	return e;
 }
-const s = /* @__PURE__ */ new WeakMap();
-function z(n) {
-  let e = s.get(n);
-  return e || (e = y(n.lazy), s.set(n, e)), e;
+var d = /* @__PURE__ */ new WeakMap();
+function f(t) {
+	let n = d.get(t);
+	return n || (n = e(t.lazy), d.set(t, n)), n;
 }
-function x({
-  guard: n,
-  redirectTo: e,
-  children: o
-}) {
-  const r = typeof n == "function" ? n() : n;
-  return /* @__PURE__ */ t(w, { when: r, redirectTo: e, children: o });
+function p({ guard: e, redirectTo: n, children: r }) {
+	return /* @__PURE__ */ i(t, {
+		when: typeof e == "function" ? e() : e,
+		redirectTo: n,
+		children: r
+	});
 }
-function l(n) {
-  return n.map((e, o) => {
-    let r = e.element;
-    if (e.lazy) {
-      const i = z(e);
-      r = /* @__PURE__ */ t(i, {});
-    }
-    return e.guard !== void 0 && (r = /* @__PURE__ */ t(x, { guard: e.guard, redirectTo: e.redirectTo, children: r })), e.index ? /* @__PURE__ */ t(c, { index: !0, element: r }, `index-${o}`) : /* @__PURE__ */ t(
-      c,
-      {
-        path: e.path,
-        element: r,
-        caseSensitive: e.caseSensitive,
-        children: e.children ? l(e.children) : null
-      },
-      e.path ?? `route-${o}`
-    );
-  });
+function m(e) {
+	return e.map((e, t) => {
+		let n = e.element;
+		return e.lazy && (n = /* @__PURE__ */ i(f(e), {})), e.guard !== void 0 && (n = /* @__PURE__ */ i(p, {
+			guard: e.guard,
+			redirectTo: e.redirectTo,
+			children: n
+		})), e.index ? /* @__PURE__ */ i(c, {
+			index: !0,
+			element: n
+		}, `index-${t}`) : /* @__PURE__ */ i(c, {
+			path: e.path,
+			element: n,
+			caseSensitive: e.caseSensitive,
+			children: e.children ? m(e.children) : null
+		}, e.path ?? `route-${t}`);
+	});
 }
-const v = {
-  browser: h,
-  hash: f,
-  memory: u
+var h = {
+	browser: a,
+	hash: o,
+	memory: s
 };
-function L({
-  routes: n,
-  router: e = "browser",
-  basename: o,
-  initialEntries: r,
-  fallback: i = null
-}) {
-  const m = d(() => l(n), [n]), a = v[e];
-  return /* @__PURE__ */ t(a, { ...e === "memory" ? { basename: o, initialEntries: r } : { basename: o }, children: /* @__PURE__ */ t(p, { fallback: i, children: /* @__PURE__ */ t(R, { children: m }) }) });
+function g({ routes: e, router: t = "browser", basename: a, initialEntries: o, fallback: s = null }) {
+	let c = r(() => m(e), [e]), u = h[t];
+	return /* @__PURE__ */ i(u, {
+		...t === "memory" ? {
+			basename: a,
+			initialEntries: o
+		} : { basename: a },
+		children: /* @__PURE__ */ i(n, {
+			fallback: s,
+			children: /* @__PURE__ */ i(l, { children: c })
+		})
+	});
 }
-export {
-  L as AppRouter,
-  G as defineRoutes
-};
-//# sourceMappingURL=AppRouter.js.map
+//#endregion
+export { g as AppRouter, u as defineRoutes };
+
+//# sourceMappingURL=AppRouter.js.map

package/dist/router/AppRouter.js.map

@@ -1 +1 @@
-{"version":3,"file":"AppRouter.js","sources":["../../src/router/AppRouter.tsx"],"sourcesContent":["import { Suspense, useMemo } from \"react\";\nimport type { ComponentType, ReactNode } from \"react\";\nimport { BrowserRouter, HashRouter, MemoryRouter, Routes, Route } from \"react-router-dom\";\nimport { lazyWithRetry } from \"../auth/lazy-with-retry\";\nimport { RouteGuard } from \"./RouteGuard\";\nimport type { RouterKind, TempestRouteObject } from \"./types\";\n\n/**\n * Identity helper that types a declarative route tree. Use it so editors give\n * autocomplete and type-checking on every node; the array is returned as-is.\n *\n * @example\n * export const routes = defineRoutes([\n *     { path: \"/\", element: <Layout />, children: [\n *         { index: true, lazy: () => import(\"./pages/Home\") },\n *         { path: \"settings\", lazy: () => import(\"./pages/Settings\"),\n *           guard: () => useAuth.getState().isAuthenticated, redirectTo: \"/login\" },\n *     ] },\n * ]);\n */\nexport function defineRoutes(routes: TempestRouteObject[]): TempestRouteObject[] {\n    return routes;\n}\n\nconst lazyCache = new WeakMap<TempestRouteObject, ComponentType<unknown>>();\n\nfunction resolveLazy(route: TempestRouteObject): ComponentType<unknown> {\n    let comp = lazyCache.get(route);\n    if (!comp) {\n        comp = lazyWithRetry(route.lazy!);\n        lazyCache.set(route, comp);\n    }\n    return comp;\n}\n\nfunction GuardedElement({\n    guard,\n    redirectTo,\n    children,\n}: {\n    guard: boolean | (() => boolean);\n    redirectTo?: string;\n    children: ReactNode;\n}) {\n    const allowed = typeof guard === \"function\" ? guard() : guard;\n    return (\n        <RouteGuard when={allowed} redirectTo={redirectTo}>\n            {children}\n        </RouteGuard>\n    );\n}\n\nfunction toRouteElements(routes: TempestRouteObject[]): ReactNode {\n    return routes.map((route, i) => {\n        let element: ReactNode = route.element;\n        if (route.lazy) {\n            const LazyComponent = resolveLazy(route);\n            element = <LazyComponent />;\n        }\n        if (route.guard !== undefined) {\n            element = (\n                <GuardedElement guard={route.guard} redirectTo={route.redirectTo}>\n                    {element}\n                </GuardedElement>\n            );\n        }\n\n        if (route.index) {\n            return <Route key={`index-${i}`} index element={element} />;\n        }\n\n        return (\n            <Route\n                key={route.path ?? `route-${i}`}\n                path={route.path}\n                element={element}\n                caseSensitive={route.caseSensitive}\n            >\n                {route.children ? toRouteElements(route.children) : null}\n            </Route>\n        );\n    });\n}\n\nconst ROUTERS: Record<RouterKind, typeof BrowserRouter> = {\n    browser: BrowserRouter,\n    hash: HashRouter,\n    memory: MemoryRouter,\n};\n\nexport interface AppRouterProps {\n    /** Declarative route tree, ideally built with {@link defineRoutes}. */\n    routes: TempestRouteObject[];\n    /** History strategy (default: `\"browser\"`). */\n    router?: RouterKind;\n    /** App-wide base path forwarded to the underlying router. */\n    basename?: string;\n    /** Initial URLs for the `\"memory\"` router (tests / non-DOM hosts). */\n    initialEntries?: string[];\n    /** Suspense fallback shown while a `lazy` route chunk loads. */\n    fallback?: ReactNode;\n}\n\n/**\n * Render a full React Router (v7, declarative mode) from a {@link defineRoutes}\n * tree: picks the history strategy, wraps everything in a `<Suspense>` boundary\n * for `lazy` routes, and applies per-route `guard` redirects. This is the\n * single entry point apps mount at their root.\n *\n * @example\n * <AppRouter routes={routes} fallback={<Spinner />} />\n */\nexport function AppRouter({\n    routes,\n    router = \"browser\",\n    basename,\n    initialEntries,\n    fallback = null,\n}: AppRouterProps) {\n    const tree = useMemo(() => toRouteElements(routes), [routes]);\n    const Router = ROUTERS[router];\n    const routerProps = router === \"memory\" ? { basename, initialEntries } : { basename };\n\n    return (\n        <Router {...routerProps}>\n            <Suspense fallback={fallback}>\n                <Routes>{tree}</Routes>\n            </Suspense>\n        </Router>\n    );\n}\n"],"names":["defineRoutes","routes","lazyCache","resolveLazy","route","comp","lazyWithRetry","GuardedElement","guard","redirectTo","children","allowed","jsx","RouteGuard","toRouteElements","i","element","LazyComponent","Route","ROUTERS","BrowserRouter","HashRouter","MemoryRouter","AppRouter","router","basename","initialEntries","fallback","tree","useMemo","Router","Suspense","Routes"],"mappings":";;;;;AAoBO,SAASA,EAAaC,GAAoD;AAC7E,SAAOA;AACX;AAEA,MAAMC,wBAAgB,QAAA;AAEtB,SAASC,EAAYC,GAAmD;AACpE,MAAIC,IAAOH,EAAU,IAAIE,CAAK;AAC9B,SAAKC,MACDA,IAAOC,EAAcF,EAAM,IAAK,GAChCF,EAAU,IAAIE,GAAOC,CAAI,IAEtBA;AACX;AAEA,SAASE,EAAe;AAAA,EACpB,OAAAC;AAAA,EACA,YAAAC;AAAA,EACA,UAAAC;AACJ,GAIG;AACC,QAAMC,IAAU,OAAOH,KAAU,aAAaA,MAAUA;AACxD,SACI,gBAAAI,EAACC,GAAA,EAAW,MAAMF,GAAS,YAAAF,GACtB,UAAAC,GACL;AAER;AAEA,SAASI,EAAgBb,GAAyC;AAC9D,SAAOA,EAAO,IAAI,CAACG,GAAOW,MAAM;AAC5B,QAAIC,IAAqBZ,EAAM;AAC/B,QAAIA,EAAM,MAAM;AACZ,YAAMa,IAAgBd,EAAYC,CAAK;AACvC,MAAAY,sBAAWC,GAAA,EAAc;AAAA,IAC7B;AASA,WARIb,EAAM,UAAU,WAChBY,IACI,gBAAAJ,EAACL,KAAe,OAAOH,EAAM,OAAO,YAAYA,EAAM,YACjD,UAAAY,EAAA,CACL,IAIJZ,EAAM,0BACEc,GAAA,EAAyB,OAAK,IAAC,SAAAF,EAAA,GAApB,SAASD,CAAC,EAA4B,IAIzD,gBAAAH;AAAA,MAACM;AAAA,MAAA;AAAA,QAEG,MAAMd,EAAM;AAAA,QACZ,SAAAY;AAAA,QACA,eAAeZ,EAAM;AAAA,QAEpB,UAAAA,EAAM,WAAWU,EAAgBV,EAAM,QAAQ,IAAI;AAAA,MAAA;AAAA,MAL/CA,EAAM,QAAQ,SAASW,CAAC;AAAA,IAAA;AAAA,EAQzC,CAAC;AACL;AAEA,MAAMI,IAAoD;AAAA,EACtD,SAASC;AAAA,EACT,MAAMC;AAAA,EACN,QAAQC;AACZ;AAwBO,SAASC,EAAU;AAAA,EACtB,QAAAtB;AAAA,EACA,QAAAuB,IAAS;AAAA,EACT,UAAAC;AAAA,EACA,gBAAAC;AAAA,EACA,UAAAC,IAAW;AACf,GAAmB;AACf,QAAMC,IAAOC,EAAQ,MAAMf,EAAgBb,CAAM,GAAG,CAACA,CAAM,CAAC,GACtD6B,IAASX,EAAQK,CAAM;AAG7B,SACI,gBAAAZ,EAACkB,GAAA,EAAQ,GAHON,MAAW,WAAW,EAAE,UAAAC,GAAU,gBAAAC,EAAA,IAAmB,EAAE,UAAAD,EAAA,GAInE,UAAA,gBAAAb,EAACmB,GAAA,EAAS,UAAAJ,GACN,UAAA,gBAAAf,EAACoB,GAAA,EAAQ,UAAAJ,EAAA,CAAK,EAAA,CAClB,GACJ;AAER;"}
+{"version":3,"file":"AppRouter.js","names":[],"sources":["../../src/router/AppRouter.tsx"],"sourcesContent":["import { Suspense, useMemo } from \"react\";\nimport type { ComponentType, ReactNode } from \"react\";\nimport { BrowserRouter, HashRouter, MemoryRouter, Routes, Route } from \"react-router\";\nimport { lazyWithRetry } from \"../auth/lazy-with-retry\";\nimport { RouteGuard } from \"./RouteGuard\";\nimport type { RouterKind, TempestRouteObject } from \"./types\";\n\n/**\n * Identity helper that types a declarative route tree. Use it so editors give\n * autocomplete and type-checking on every node; the array is returned as-is.\n *\n * @example\n * export const routes = defineRoutes([\n *     { path: \"/\", element: <Layout />, children: [\n *         { index: true, lazy: () => import(\"./pages/Home\") },\n *         { path: \"settings\", lazy: () => import(\"./pages/Settings\"),\n *           guard: () => useAuth.getState().isAuthenticated, redirectTo: \"/login\" },\n *     ] },\n * ]);\n */\nexport function defineRoutes(routes: TempestRouteObject[]): TempestRouteObject[] {\n    return routes;\n}\n\nconst lazyCache = new WeakMap<TempestRouteObject, ComponentType<unknown>>();\n\nfunction resolveLazy(route: TempestRouteObject): ComponentType<unknown> {\n    let comp = lazyCache.get(route);\n    if (!comp) {\n        comp = lazyWithRetry(route.lazy!);\n        lazyCache.set(route, comp);\n    }\n    return comp;\n}\n\nfunction GuardedElement({\n    guard,\n    redirectTo,\n    children,\n}: {\n    guard: boolean | (() => boolean);\n    redirectTo?: string;\n    children: ReactNode;\n}) {\n    const allowed = typeof guard === \"function\" ? guard() : guard;\n    return (\n        <RouteGuard when={allowed} redirectTo={redirectTo}>\n            {children}\n        </RouteGuard>\n    );\n}\n\nfunction toRouteElements(routes: TempestRouteObject[]): ReactNode {\n    return routes.map((route, i) => {\n        let element: ReactNode = route.element;\n        if (route.lazy) {\n            const LazyComponent = resolveLazy(route);\n            element = <LazyComponent />;\n        }\n        if (route.guard !== undefined) {\n            element = (\n                <GuardedElement guard={route.guard} redirectTo={route.redirectTo}>\n                    {element}\n                </GuardedElement>\n            );\n        }\n\n        if (route.index) {\n            return <Route key={`index-${i}`} index element={element} />;\n        }\n\n        return (\n            <Route\n                key={route.path ?? `route-${i}`}\n                path={route.path}\n                element={element}\n                caseSensitive={route.caseSensitive}\n            >\n                {route.children ? toRouteElements(route.children) : null}\n            </Route>\n        );\n    });\n}\n\nconst ROUTERS: Record<RouterKind, typeof BrowserRouter> = {\n    browser: BrowserRouter,\n    hash: HashRouter,\n    memory: MemoryRouter,\n};\n\nexport interface AppRouterProps {\n    /** Declarative route tree, ideally built with {@link defineRoutes}. */\n    routes: TempestRouteObject[];\n    /** History strategy (default: `\"browser\"`). */\n    router?: RouterKind;\n    /** App-wide base path forwarded to the underlying router. */\n    basename?: string;\n    /** Initial URLs for the `\"memory\"` router (tests / non-DOM hosts). */\n    initialEntries?: string[];\n    /** Suspense fallback shown while a `lazy` route chunk loads. */\n    fallback?: ReactNode;\n}\n\n/**\n * Render a full React Router (v7, declarative mode) from a {@link defineRoutes}\n * tree: picks the history strategy, wraps everything in a `<Suspense>` boundary\n * for `lazy` routes, and applies per-route `guard` redirects. This is the\n * single entry point apps mount at their root.\n *\n * @example\n * <AppRouter routes={routes} fallback={<Spinner />} />\n */\nexport function AppRouter({\n    routes,\n    router = \"browser\",\n    basename,\n    initialEntries,\n    fallback = null,\n}: AppRouterProps) {\n    const tree = useMemo(() => toRouteElements(routes), [routes]);\n    const Router = ROUTERS[router];\n    const routerProps = router === \"memory\" ? { basename, initialEntries } : { basename };\n\n    return (\n        <Router {...routerProps}>\n            <Suspense fallback={fallback}>\n                <Routes>{tree}</Routes>\n            </Suspense>\n        </Router>\n    );\n}\n"],"mappings":";;;;;;AAoBA,SAAgB,EAAa,GAAoD;CAC7E,OAAO;AACX;AAEA,IAAM,oBAAY,IAAI,QAAoD;AAE1E,SAAS,EAAY,GAAmD;CACpE,IAAI,IAAO,EAAU,IAAI,CAAK;CAK9B,OAJK,MACD,IAAO,EAAc,EAAM,IAAK,GAChC,EAAU,IAAI,GAAO,CAAI,IAEtB;AACX;AAEA,SAAS,EAAe,EACpB,UACA,eACA,eAKD;CAEC,OACI,kBAAC,GAAD;EAAY,MAFA,OAAO,KAAU,aAAa,EAAM,IAAI;EAEb;EAClC;CACO,CAAA;AAEpB;AAEA,SAAS,EAAgB,GAAyC;CAC9D,OAAO,EAAO,KAAK,GAAO,MAAM;EAC5B,IAAI,IAAqB,EAAM;EAiB/B,OAhBI,EAAM,SAEN,IAAU,kBADY,EAAY,CACvB,GAAD,CAAgB,CAAA,IAE1B,EAAM,UAAU,KAAA,MAChB,IACI,kBAAC,GAAD;GAAgB,OAAO,EAAM;GAAO,YAAY,EAAM;aACjD;EACW,CAAA,IAIpB,EAAM,QACC,kBAAC,GAAD;GAA0B,OAAA;GAAe;EAAU,GAAvC,SAAS,GAA8B,IAI1D,kBAAC,GAAD;GAEI,MAAM,EAAM;GACH;GACT,eAAe,EAAM;aAEpB,EAAM,WAAW,EAAgB,EAAM,QAAQ,IAAI;EACjD,GANE,EAAM,QAAQ,SAAS,GAMzB;CAEf,CAAC;AACL;AAEA,IAAM,IAAoD;CACtD,SAAS;CACT,MAAM;CACN,QAAQ;AACZ;AAwBA,SAAgB,EAAU,EACtB,WACA,YAAS,WACT,aACA,mBACA,cAAW,QACI;CACf,IAAM,IAAO,QAAc,EAAgB,CAAM,GAAG,CAAC,CAAM,CAAC,GACtD,IAAS,EAAQ;CAGvB,OACI,kBAAC,GAAD;EAAQ,GAHQ,MAAW,WAAW;GAAE;GAAU;EAAe,IAAI,EAAE,YAAS;YAI5E,kBAAC,GAAD;GAAoB;aAChB,kBAAC,GAAD,EAAA,UAAS,EAAa,CAAA;EAChB,CAAA;CACN,CAAA;AAEhB"}

package/dist/router/RouteGuard.cjs

@@ -1,2 +1,2 @@
-"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const e=require("react/jsx-runtime"),n=require("react-router-dom");function i({when:t,redirectTo:r="/",replace:u=!0,children:o}){return e.jsx(e.Fragment,{children:t?o:e.jsx(n.Navigate,{to:r,replace:u})})}exports.RouteGuard=i;
-//# sourceMappingURL=RouteGuard.cjs.map
+let e=require("react/jsx-runtime"),t=require("react-router");function n({when:n,redirectTo:r=`/`,replace:i=!0,children:a}){return(0,e.jsx)(e.Fragment,{children:n?a:(0,e.jsx)(t.Navigate,{to:r,replace:i})})}exports.RouteGuard=n;
+//# sourceMappingURL=RouteGuard.cjs.map

package/dist/router/RouteGuard.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"RouteGuard.cjs","sources":["../../src/router/RouteGuard.tsx"],"sourcesContent":["import type { ReactNode } from \"react\";\nimport { Navigate } from \"react-router-dom\";\n\nexport interface RouteGuardProps {\n    /**\n     * Whether access is allowed. Pass a boolean or anything truthy/falsy —\n     * typically `useAuthStore((s) => s.isAuthenticated)`.\n     */\n    when: boolean;\n    /** Where to redirect when `when` is falsy (default: `\"/\"`). */\n    redirectTo?: string;\n    /** Replace history entry on redirect instead of pushing (default: true). */\n    replace?: boolean;\n    /** Protected content, usually `<Outlet />` for a guarded layout route. */\n    children: ReactNode;\n}\n\n/**\n * Declarative route guard built on React Router's `<Navigate>`. Renders its\n * children when `when` is truthy, otherwise redirects. Pairs naturally with\n * `createAuthStore` for protected areas.\n *\n * @example\n * <RouteGuard when={useAuthStore((s) => s.isAuthenticated)} redirectTo=\"/login\">\n *     <Outlet />\n * </RouteGuard>\n */\nexport function RouteGuard({ when, redirectTo = \"/\", replace = true, children }: RouteGuardProps) {\n    return <>{when ? children : <Navigate to={redirectTo} replace={replace} />}</>;\n}\n"],"names":["RouteGuard","when","redirectTo","replace","children","jsx","Fragment","Navigate"],"mappings":"mJA2BO,SAASA,EAAW,CAAE,KAAAC,EAAM,WAAAC,EAAa,IAAK,QAAAC,EAAU,GAAM,SAAAC,GAA6B,CAC9F,OAAOC,EAAAA,IAAAC,EAAAA,SAAA,CAAG,WAAOF,EAAWC,MAACE,EAAAA,UAAS,GAAIL,EAAY,QAAAC,EAAkB,CAAA,CAAG,CAC/E"}
+{"version":3,"file":"RouteGuard.cjs","names":[],"sources":["../../src/router/RouteGuard.tsx"],"sourcesContent":["import type { ReactNode } from \"react\";\nimport { Navigate } from \"react-router\";\n\nexport interface RouteGuardProps {\n    /**\n     * Whether access is allowed. Pass a boolean or anything truthy/falsy —\n     * typically `useAuthStore((s) => s.isAuthenticated)`.\n     */\n    when: boolean;\n    /** Where to redirect when `when` is falsy (default: `\"/\"`). */\n    redirectTo?: string;\n    /** Replace history entry on redirect instead of pushing (default: true). */\n    replace?: boolean;\n    /** Protected content, usually `<Outlet />` for a guarded layout route. */\n    children: ReactNode;\n}\n\n/**\n * Declarative route guard built on React Router's `<Navigate>`. Renders its\n * children when `when` is truthy, otherwise redirects. Pairs naturally with\n * `createAuthStore` for protected areas.\n *\n * @example\n * <RouteGuard when={useAuthStore((s) => s.isAuthenticated)} redirectTo=\"/login\">\n *     <Outlet />\n * </RouteGuard>\n */\nexport function RouteGuard({ when, redirectTo = \"/\", replace = true, children }: RouteGuardProps) {\n    return <>{when ? children : <Navigate to={redirectTo} replace={replace} />}</>;\n}\n"],"mappings":"6DA2BA,SAAgB,EAAW,CAAE,OAAM,aAAa,IAAK,UAAU,GAAM,YAA6B,CAC9F,OAAO,EAAA,EAAA,IAAA,CAAA,EAAA,SAAA,CAAA,SAAG,EAAO,GAAW,EAAA,EAAA,IAAA,CAAC,EAAA,SAAD,CAAU,GAAI,EAAqB,SAAU,CAAA,CAAI,CAAA,CACjF"}