tempest-react-sdk 0.77.0 → 0.79.0

package/dist/query/offline-persistence.js.map

@@ -1 +1 @@
-{"version":3,"file":"offline-persistence.js","names":[],"sources":["../../src/query/offline-persistence.ts"],"sourcesContent":["import {\n    dehydrate,\n    hydrate,\n    type QueryCacheNotifyEvent,\n    type QueryClient,\n} from \"@tanstack/react-query\";\nimport { createOfflineStore } from \"../offline/create-offline-store\";\nimport { isDevBuild } from \"../utils/dev-mode\";\n\n/**\n * Clears still running, per `databaseName` + `key` slot, across every handle.\n *\n * A handle's `clear()` deletes by key with no ordering against other handles,\n * so a new handle created on login while the previous one is still clearing\n * could `restore()` the previous user's snapshot before the delete lands, or\n * have its first write deleted by it. Every handle's `restore()` and writes\n * wait for the slot's pending clear first; the entry is dropped once settled.\n */\nconst pendingClears = new Map<string, Promise<unknown>>();\n\n/** Options for {@link persistQueryClientOffline}. */\nexport interface OfflineQueryPersistenceOptions {\n    /** The `QueryClient` to snapshot and restore. */\n    queryClient: QueryClient;\n    /** IndexedDB database name for the snapshot. Default `\"TempestQueryCache\"`. */\n    databaseName?: string;\n    /** Row key under which the snapshot is stored. Default `\"tanstack-query\"`. */\n    key?: string;\n    /**\n     * Minimum gap between snapshot writes, in ms — cache churn is coalesced into\n     * one trailing write per window. Default `1000`.\n     */\n    throttleMs?: number;\n}\n\n/** Options for {@link OfflineQueryPersistence.clear}. */\nexport interface OfflineQueryClearOptions {\n    /**\n     * Also clear the in-memory `QueryClient` (`queryClient.clear()`) once\n     * persistence has stopped and the snapshot is deleted — the one-call logout.\n     * Default `false`: the client belongs to the app, which may want to keep\n     * public queries (a catalog, feature flags) across sessions and drop only\n     * the user-scoped keys with `removeQueries`.\n     */\n    resetClient?: boolean;\n}\n\n/** Handle returned by {@link persistQueryClientOffline}. */\nexport interface OfflineQueryPersistence {\n    /**\n     * Load the persisted snapshot into the `QueryClient`. Call once on boot,\n     * before rendering queries, so cached data is available offline. A no-op\n     * once {@link OfflineQueryPersistence.clear} has been called.\n     */\n    restore: () => Promise<void>;\n    /**\n     * Write the current cache snapshot immediately (bypassing the throttle). A\n     * no-op once {@link OfflineQueryPersistence.clear} has been called.\n     */\n    flush: () => Promise<void>;\n    /** Stop persisting and drop the pending write. Idempotent. */\n    unsubscribe: () => void;\n    /**\n     * End the persisted session (e.g. on logout) and delete the snapshot.\n     *\n     * Terminal for this handle: it cancels the pending throttled write, stops\n     * persisting cache changes, waits for any write already in flight and only\n     * then deletes the row — so neither a write pending in the last throttle\n     * window nor cache activity after logout (the next user's first query) can\n     * re-persist the previous user's responses. Afterwards `restore`/`flush`\n     * are no-ops; to persist a new session, call\n     * {@link persistQueryClientOffline} again after login. In a dev build\n     * (`isDevBuild()`), the first `restore`, `flush` or added/updated query on\n     * an ended handle logs one `console.warn` saying so, because a handle kept\n     * at module scope would otherwise stop persisting in silence.\n     *\n     * Ordered against other handles on the same `databaseName` + `key`: until\n     * this clear settles, a new handle's `restore()` and writes wait for it, so\n     * a handle created on login without awaiting the logout neither hydrates\n     * the previous snapshot nor has its first write deleted.\n     *\n     * If the delete rejects, `resetClient` still clears the client and the\n     * rejection reaches the caller.\n     *\n     * The in-memory `QueryClient` is cleared only with `resetClient: true`, and\n     * then only after persistence has stopped, so the reset itself cannot\n     * trigger a write. It is opt-in because the app owns the client and the\n     * shape of its logout: it may keep public queries and drop only the\n     * user-scoped keys with `removeQueries`. Because persistence is already\n     * off, that manual call can come before or after this one.\n     *\n     * Idempotent and safe to call concurrently; every call deletes the row\n     * again.\n     *\n     * @param options - `resetClient` also clears the in-memory `QueryClient`.\n     */\n    clear: (options?: OfflineQueryClearOptions) => Promise<void>;\n}\n\ninterface Snapshot {\n    id: string;\n    state: ReturnType<typeof dehydrate>;\n}\n\n/**\n * Persist a TanStack `QueryClient` cache to IndexedDB (via\n * {@link createOfflineStore}) and restore it on boot — so a reload or a cold\n * offline start shows the last-known data instead of empty screens.\n *\n * Self-contained: uses `dehydrate`/`hydrate` from `@tanstack/react-query`\n * directly, so no `@tanstack/react-query-persist-client` dependency is needed.\n * Writes are throttled and subscribe to the query cache; call `unsubscribe` on\n * teardown. Dexie is a peer dependency of the offline store — install it.\n *\n * @param options - The client plus storage/throttle configuration.\n * @returns A handle with `restore`, `flush`, `clear` and `unsubscribe`.\n *\n * `clear()` is terminal for the handle (see {@link OfflineQueryPersistence.clear}):\n * a logout that only deleted the row used to be undone by the pending write or\n * by the next cache event, restoring the previous user's data on the next boot\n * (#440).\n *\n * @example\n * const persistence = persistQueryClientOffline({ queryClient });\n * await persistence.restore();\n *\n * async function logout(): Promise<void> {\n *     await persistence.clear({ resetClient: true });\n * }\n */\nexport function persistQueryClientOffline(\n    options: OfflineQueryPersistenceOptions,\n): OfflineQueryPersistence {\n    const { queryClient, throttleMs = 1000 } = options;\n    const key = options.key ?? \"tanstack-query\";\n    const databaseName = options.databaseName ?? \"TempestQueryCache\";\n    const store = createOfflineStore<Snapshot, string>({\n        databaseName,\n        version: 1,\n        tableName: \"cache\",\n        indexes: \"&id\",\n        keyPath: \"id\",\n    });\n\n    const slot = `${databaseName}\\u0000${key}`;\n    let ended = false;\n    let warnedEnded = false;\n    let timer: ReturnType<typeof setTimeout> | null = null;\n    const inFlight = new Set<Promise<unknown>>();\n\n    async function afterPendingClear(): Promise<void> {\n        const pending = pendingClears.get(slot);\n        if (pending) await pending;\n    }\n\n    function warnEnded(): void {\n        if (warnedEnded || !isDevBuild()) return;\n        warnedEnded = true;\n        console.warn(\n            \"[tempest-react-sdk] persistQueryClientOffline: handle ended by clear(); \" +\n                \"create a new one after login to keep persisting.\",\n        );\n    }\n\n    async function save(): Promise<void> {\n        if (ended) return;\n        await afterPendingClear();\n        if (ended) return;\n        const write = store.put({ id: key, state: dehydrate(queryClient) });\n        inFlight.add(write);\n        try {\n            await write;\n        } finally {\n            inFlight.delete(write);\n        }\n    }\n\n    function cancelTimer(): void {\n        if (timer) {\n            clearTimeout(timer);\n            timer = null;\n        }\n    }\n\n    function schedule(): void {\n        if (timer || ended) return;\n        timer = setTimeout(() => {\n            timer = null;\n            void save();\n        }, throttleMs);\n    }\n\n    function onCacheEvent(event: QueryCacheNotifyEvent): void {\n        if (!ended) {\n            schedule();\n            return;\n        }\n        if (event.type !== \"added\" && event.type !== \"updated\") return;\n        unsubscribeCache();\n        warnEnded();\n    }\n\n    const unsubscribeCache = queryClient.getQueryCache().subscribe(onCacheEvent);\n\n    async function endSession(resetClient: boolean): Promise<void> {\n        try {\n            await Promise.allSettled([...inFlight]);\n            await store.delete(key);\n        } finally {\n            if (resetClient) queryClient.clear();\n        }\n    }\n\n    return {\n        async restore() {\n            if (ended) {\n                warnEnded();\n                return;\n            }\n            await afterPendingClear();\n            if (ended) return;\n            const snapshot = await store.get(key);\n            if (snapshot && !ended) hydrate(queryClient, snapshot.state);\n        },\n        async flush() {\n            if (ended) {\n                warnEnded();\n                return;\n            }\n            cancelTimer();\n            await save();\n        },\n        unsubscribe() {\n            cancelTimer();\n            unsubscribeCache();\n        },\n        async clear(clearOptions = {}) {\n            ended = true;\n            cancelTimer();\n            const previous = pendingClears.get(slot);\n            const run = endSession(clearOptions.resetClient ?? false);\n            const settled = Promise.allSettled([previous, run]);\n            pendingClears.set(slot, settled);\n            void settled.then(() => {\n                if (pendingClears.get(slot) === settled) pendingClears.delete(slot);\n            });\n            await run;\n        },\n    };\n}\n"],"mappings":";;;;AAkBA,IAAM,oBAAgB,IAAI,IAA8B;AAgHxD,SAAgB,EACZ,GACuB;CACvB,IAAM,EAAE,gBAAa,gBAAa,QAAS,GACrC,IAAM,EAAQ,OAAO,kBACrB,IAAe,EAAQ,gBAAgB,qBACvC,IAAQ,EAAqC;EAC/C;EACA,SAAS;EACT,WAAW;EACX,SAAS;EACT,SAAS;CACb,CAAC,GAEK,IAAO,GAAG,EAAa,QAAQ,KACjC,IAAQ,IACR,IAAc,IACd,IAA8C,MAC5C,oBAAW,IAAI,IAAsB;CAE3C,eAAe,IAAmC;EAC9C,IAAM,IAAU,EAAc,IAAI,CAAI;EACtC,AAAI,KAAS,MAAM;CACvB;CAEA,SAAS,IAAkB;EACnB,MAAgB,EAAW,MAC/B,IAAc,IACd,QAAQ,KACJ,0HAEJ;CACJ;CAEA,eAAe,IAAsB;EAGjC,IAFI,MACJ,MAAM,EAAkB,GACpB,IAAO;EACX,IAAM,IAAQ,EAAM,IAAI;GAAE,IAAI;GAAK,OAAO,EAAU,CAAW;EAAE,CAAC;EAClE,EAAS,IAAI,CAAK;EAClB,IAAI;GACA,MAAM;EACV,UAAU;GACN,EAAS,OAAO,CAAK;EACzB;CACJ;CAEA,SAAS,IAAoB;EACzB,AAEI,OADA,aAAa,CAAK,GACV;CAEhB;CAEA,SAAS,IAAiB;EAClB,KAAS,MACb,IAAQ,iBAAiB;GAErB,AADA,IAAQ,MACR,EAAU;EACd,GAAG,CAAU;CACjB;CAEA,SAAS,EAAa,GAAoC;EACtD,IAAI,CAAC,GAAO;GACR,EAAS;GACT;EACJ;EACI,GAAM,SAAS,WAAW,EAAM,SAAS,eAC7C,EAAiB,GACjB,EAAU;CACd;CAEA,IAAM,IAAmB,EAAY,cAAc,CAAC,CAAC,UAAU,CAAY;CAE3E,eAAe,EAAW,GAAqC;EAC3D,IAAI;GAEA,AADA,MAAM,QAAQ,WAAW,CAAC,GAAG,CAAQ,CAAC,GACtC,MAAM,EAAM,OAAO,CAAG;EAC1B,UAAU;GACN,AAAI,KAAa,EAAY,MAAM;EACvC;CACJ;CAEA,OAAO;EACH,MAAM,UAAU;GACZ,IAAI,GAAO;IACP,EAAU;IACV;GACJ;GAEA,IADA,MAAM,EAAkB,GACpB,GAAO;GACX,IAAM,IAAW,MAAM,EAAM,IAAI,CAAG;GACpC,AAAI,KAAY,CAAC,KAAO,EAAQ,GAAa,EAAS,KAAK;EAC/D;EACA,MAAM,QAAQ;GACV,IAAI,GAAO;IACP,EAAU;IACV;GACJ;GAEA,AADA,EAAY,GACZ,MAAM,EAAK;EACf;EACA,cAAc;GAEV,AADA,EAAY,GACZ,EAAiB;EACrB;EACA,MAAM,MAAM,IAAe,CAAC,GAAG;GAE3B,AADA,IAAQ,IACR,EAAY;GACZ,IAAM,IAAW,EAAc,IAAI,CAAI,GACjC,IAAM,EAAW,EAAa,eAAe,EAAK,GAClD,IAAU,QAAQ,WAAW,CAAC,GAAU,CAAG,CAAC;GAKlD,AAJA,EAAc,IAAI,GAAM,CAAO,GAC/B,EAAa,WAAW;IACpB,AAAI,EAAc,IAAI,CAAI,MAAM,KAAS,EAAc,OAAO,CAAI;GACtE,CAAC,GACD,MAAM;EACV;CACJ;AACJ"}
+{"version":3,"file":"offline-persistence.js","names":["pendingClears","persistQueryClientOffline","options","key","databaseName","store","createOfflineStore","slot","ended","warnedEnded","timer","inFlight","afterPendingClear","pending","warnEnded","isDevBuild","save","write","dehydrate","queryClient","cancelTimer","schedule","throttleMs","onCacheEvent","event","unsubscribeCache","endSession","resetClient","snapshot","hydrate","previous","run","clearOptions","settled"],"sources":["../../src/query/offline-persistence.ts"],"sourcesContent":["import {\n    dehydrate,\n    hydrate,\n    type QueryCacheNotifyEvent,\n    type QueryClient,\n} from \"@tanstack/react-query\";\nimport { createOfflineStore } from \"../offline/create-offline-store\";\nimport { isDevBuild } from \"../utils/dev-mode\";\n\n/**\n * Clears still running, per `databaseName` + `key` slot, across every handle.\n *\n * A handle's `clear()` deletes by key with no ordering against other handles,\n * so a new handle created on login while the previous one is still clearing\n * could `restore()` the previous user's snapshot before the delete lands, or\n * have its first write deleted by it. Every handle's `restore()` and writes\n * wait for the slot's pending clear first; the entry is dropped once settled.\n */\nconst pendingClears = new Map<string, Promise<unknown>>();\n\n/** Options for {@link persistQueryClientOffline}. */\nexport interface OfflineQueryPersistenceOptions {\n    /** The `QueryClient` to snapshot and restore. */\n    queryClient: QueryClient;\n    /** IndexedDB database name for the snapshot. Default `\"TempestQueryCache\"`. */\n    databaseName?: string;\n    /** Row key under which the snapshot is stored. Default `\"tanstack-query\"`. */\n    key?: string;\n    /**\n     * Minimum gap between snapshot writes, in ms — cache churn is coalesced into\n     * one trailing write per window. Default `1000`.\n     */\n    throttleMs?: number;\n}\n\n/** Options for {@link OfflineQueryPersistence.clear}. */\nexport interface OfflineQueryClearOptions {\n    /**\n     * Also clear the in-memory `QueryClient` (`queryClient.clear()`) once\n     * persistence has stopped and the snapshot is deleted — the one-call logout.\n     * Default `false`: the client belongs to the app, which may want to keep\n     * public queries (a catalog, feature flags) across sessions and drop only\n     * the user-scoped keys with `removeQueries`.\n     */\n    resetClient?: boolean;\n}\n\n/** Handle returned by {@link persistQueryClientOffline}. */\nexport interface OfflineQueryPersistence {\n    /**\n     * Load the persisted snapshot into the `QueryClient`. Call once on boot,\n     * before rendering queries, so cached data is available offline. A no-op\n     * once {@link OfflineQueryPersistence.clear} has been called.\n     */\n    restore: () => Promise<void>;\n    /**\n     * Write the current cache snapshot immediately (bypassing the throttle). A\n     * no-op once {@link OfflineQueryPersistence.clear} has been called.\n     */\n    flush: () => Promise<void>;\n    /** Stop persisting and drop the pending write. Idempotent. */\n    unsubscribe: () => void;\n    /**\n     * End the persisted session (e.g. on logout) and delete the snapshot.\n     *\n     * Terminal for this handle: it cancels the pending throttled write, stops\n     * persisting cache changes, waits for any write already in flight and only\n     * then deletes the row — so neither a write pending in the last throttle\n     * window nor cache activity after logout (the next user's first query) can\n     * re-persist the previous user's responses. Afterwards `restore`/`flush`\n     * are no-ops; to persist a new session, call\n     * {@link persistQueryClientOffline} again after login. In a dev build\n     * (`isDevBuild()`), the first `restore`, `flush` or added/updated query on\n     * an ended handle logs one `console.warn` saying so, because a handle kept\n     * at module scope would otherwise stop persisting in silence.\n     *\n     * Ordered against other handles on the same `databaseName` + `key`: until\n     * this clear settles, a new handle's `restore()` and writes wait for it, so\n     * a handle created on login without awaiting the logout neither hydrates\n     * the previous snapshot nor has its first write deleted.\n     *\n     * If the delete rejects, `resetClient` still clears the client and the\n     * rejection reaches the caller.\n     *\n     * The in-memory `QueryClient` is cleared only with `resetClient: true`, and\n     * then only after persistence has stopped, so the reset itself cannot\n     * trigger a write. It is opt-in because the app owns the client and the\n     * shape of its logout: it may keep public queries and drop only the\n     * user-scoped keys with `removeQueries`. Because persistence is already\n     * off, that manual call can come before or after this one.\n     *\n     * Idempotent and safe to call concurrently; every call deletes the row\n     * again.\n     *\n     * @param options - `resetClient` also clears the in-memory `QueryClient`.\n     */\n    clear: (options?: OfflineQueryClearOptions) => Promise<void>;\n}\n\ninterface Snapshot {\n    id: string;\n    state: ReturnType<typeof dehydrate>;\n}\n\n/**\n * Persist a TanStack `QueryClient` cache to IndexedDB (via\n * {@link createOfflineStore}) and restore it on boot — so a reload or a cold\n * offline start shows the last-known data instead of empty screens.\n *\n * Self-contained: uses `dehydrate`/`hydrate` from `@tanstack/react-query`\n * directly, so no `@tanstack/react-query-persist-client` dependency is needed.\n * Writes are throttled and subscribe to the query cache; call `unsubscribe` on\n * teardown. Dexie is a peer dependency of the offline store — install it.\n *\n * @param options - The client plus storage/throttle configuration.\n * @returns A handle with `restore`, `flush`, `clear` and `unsubscribe`.\n *\n * `clear()` is terminal for the handle (see {@link OfflineQueryPersistence.clear}):\n * a logout that only deleted the row used to be undone by the pending write or\n * by the next cache event, restoring the previous user's data on the next boot\n * (#440).\n *\n * @example\n * const persistence = persistQueryClientOffline({ queryClient });\n * await persistence.restore();\n *\n * async function logout(): Promise<void> {\n *     await persistence.clear({ resetClient: true });\n * }\n */\nexport function persistQueryClientOffline(\n    options: OfflineQueryPersistenceOptions,\n): OfflineQueryPersistence {\n    const { queryClient, throttleMs = 1000 } = options;\n    const key = options.key ?? \"tanstack-query\";\n    const databaseName = options.databaseName ?? \"TempestQueryCache\";\n    const store = createOfflineStore<Snapshot, string>({\n        databaseName,\n        version: 1,\n        tableName: \"cache\",\n        indexes: \"&id\",\n        keyPath: \"id\",\n    });\n\n    const slot = `${databaseName}\\u0000${key}`;\n    let ended = false;\n    let warnedEnded = false;\n    let timer: ReturnType<typeof setTimeout> | null = null;\n    const inFlight = new Set<Promise<unknown>>();\n\n    async function afterPendingClear(): Promise<void> {\n        const pending = pendingClears.get(slot);\n        if (pending) await pending;\n    }\n\n    function warnEnded(): void {\n        if (warnedEnded || !isDevBuild()) return;\n        warnedEnded = true;\n        console.warn(\n            \"[tempest-react-sdk] persistQueryClientOffline: handle ended by clear(); \" +\n                \"create a new one after login to keep persisting.\",\n        );\n    }\n\n    async function save(): Promise<void> {\n        if (ended) return;\n        await afterPendingClear();\n        if (ended) return;\n        const write = store.put({ id: key, state: dehydrate(queryClient) });\n        inFlight.add(write);\n        try {\n            await write;\n        } finally {\n            inFlight.delete(write);\n        }\n    }\n\n    function cancelTimer(): void {\n        if (timer) {\n            clearTimeout(timer);\n            timer = null;\n        }\n    }\n\n    function schedule(): void {\n        if (timer || ended) return;\n        timer = setTimeout(() => {\n            timer = null;\n            void save();\n        }, throttleMs);\n    }\n\n    function onCacheEvent(event: QueryCacheNotifyEvent): void {\n        if (!ended) {\n            schedule();\n            return;\n        }\n        if (event.type !== \"added\" && event.type !== \"updated\") return;\n        unsubscribeCache();\n        warnEnded();\n    }\n\n    const unsubscribeCache = queryClient.getQueryCache().subscribe(onCacheEvent);\n\n    async function endSession(resetClient: boolean): Promise<void> {\n        try {\n            await Promise.allSettled([...inFlight]);\n            await store.delete(key);\n        } finally {\n            if (resetClient) queryClient.clear();\n        }\n    }\n\n    return {\n        async restore() {\n            if (ended) {\n                warnEnded();\n                return;\n            }\n            await afterPendingClear();\n            if (ended) return;\n            const snapshot = await store.get(key);\n            if (snapshot && !ended) hydrate(queryClient, snapshot.state);\n        },\n        async flush() {\n            if (ended) {\n                warnEnded();\n                return;\n            }\n            cancelTimer();\n            await save();\n        },\n        unsubscribe() {\n            cancelTimer();\n            unsubscribeCache();\n        },\n        async clear(clearOptions = {}) {\n            ended = true;\n            cancelTimer();\n            const previous = pendingClears.get(slot);\n            const run = endSession(clearOptions.resetClient ?? false);\n            const settled = Promise.allSettled([previous, run]);\n            pendingClears.set(slot, settled);\n            void settled.then(() => {\n                if (pendingClears.get(slot) === settled) pendingClears.delete(slot);\n            });\n            await run;\n        },\n    };\n}\n"],"mappings":";;;;AAkBA,IAAMA,oBAAgB,IAAI,IAA8B;AAgHxD,SAAgBC,EACZ,GACuB;CACvB,IAAM,EAAE,gBAAa,gBAAa,QAASC,GACrCC,IAAMD,EAAQ,OAAO,kBACrBE,IAAeF,EAAQ,gBAAgB,qBACvCG,IAAQC,EAAqC;EAC/C;EACA,SAAS;EACT,WAAW;EACX,SAAS;EACT,SAAS;CACb,CAAC,GAEKC,IAAO,GAAGH,EAAa,QAAQD,KACjCK,IAAQ,IACRC,IAAc,IACdC,IAA8C,MAC5CC,oBAAW,IAAI,IAAsB;CAE3C,eAAeC,IAAmC;EAC9C,IAAMC,IAAUb,EAAc,IAAIO,CAAI;EACtC,AAAIM,KAAS,MAAMA;CACvB;CAEA,SAASC,IAAkB;EACvB,AAAI,MAAgBC,EAAW,MAC/B,IAAc,IACd,QAAQ,KACJ,0HAEJ;CACJ;CAEA,eAAeC,IAAsB;EAGjC,IAFIR,MACJ,MAAMI,EAAkB,GACpBJ,IAAO;EACX,IAAMS,IAAQZ,EAAM,IAAI;GAAE,IAAIF;GAAK,OAAOe,EAAUC,CAAW;EAAE,CAAC;EAClE,EAAS,IAAIF,CAAK;EAClB,IAAI;GACA,MAAMA;EACV,UAAU;GACN,EAAS,OAAOA,CAAK;EACzB;CACJ;CAEA,SAASG,IAAoB;EACzB,AAEIV,OADA,aAAaA,CAAK,GACV;CAEhB;CAEA,SAASW,IAAiB;EACtB,AAAIX,KAASF,MACb,IAAQ,iBAAiB;GAErB,AADA,IAAQ,MACRQ,EAAU;EACd,GAAGM,CAAU;CACjB;CAEA,SAASC,EAAa,GAAoC;EACtD,AAAKf,KAIDgB,EAAM,SAAS,WAAWA,EAAM,SAAS,eAC7CC,EAAiB,GACjBX,EAAU,KALNO,EAAS;CAMjB;CAEA,IAAMI,IAAmBN,EAAY,cAAc,CAAC,CAAC,UAAUI,CAAY;CAE3E,eAAeG,EAAW,GAAqC;EAC3D,IAAI;GAEA,AADA,MAAM,QAAQ,WAAW,CAAC,GAAGf,CAAQ,CAAC,GACtC,MAAMN,EAAM,OAAOF,CAAG;EAC1B,UAAU;GACN,AAAIwB,KAAaR,EAAY,MAAM;EACvC;CACJ;CAEA,OAAO;EACH,MAAM,UAAU;GACZ,IAAIX,GAAO;IACP,EAAU;IACV;GACJ;GAEA,IADA,MAAMI,EAAkB,GACpBJ,GAAO;GACX,IAAMoB,IAAW,MAAMvB,EAAM,IAAIF,CAAG;GACpC,AAAIyB,KAAY,CAACpB,KAAOqB,EAAQV,GAAaS,EAAS,KAAK;EAC/D;EACA,MAAM,QAAQ;GACV,AAAIpB,IACAM,EAAU,KAGdM,EAAY,GACZ,MAAMJ,EAAK;EACf;EACA,cAAc;GAEV,AADAI,EAAY,GACZK,EAAiB;EACrB;EACA,MAAM,MAAM,IAAe,CAAC,GAAG;GAE3B,AADA,IAAQ,IACRL,EAAY;GACZ,IAAMU,IAAW9B,EAAc,IAAIO,CAAI,GACjCwB,IAAML,EAAWM,EAAa,eAAe,EAAK,GAClDC,IAAU,QAAQ,WAAW,CAACH,GAAUC,CAAG,CAAC;GAKlD,AAJA/B,EAAc,IAAIO,GAAM0B,CAAO,GAC/BA,EAAa,WAAW;IACpB,AAAIjC,EAAc,IAAIO,CAAI,MAAM0B,KAASjC,EAAc,OAAOO,CAAI;GACtE,CAAC,GACD,MAAMwB;EACV;CACJ;AACJ"}

package/dist/query/optimistic.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"optimistic.cjs","names":[],"sources":["../../src/query/optimistic.ts"],"sourcesContent":["/**\n * Ready-made `applyOptimistic` builders for {@link useOfflineMutation} over a\n * list-shaped query cache (`TData = T[]`). They cover the two most common\n * optimistic edits — insert-or-update and remove — so callers stop hand-writing\n * the array spread. Both compare records by an id field (`\"id\"` by default) and\n * treat the mutation variables as the record itself.\n */\n\n/**\n * Build an `applyOptimistic` that inserts the item when absent or shallow-merges\n * it into the existing entry (matched by `idField`). New items append to the end.\n *\n * @typeParam T - The list item shape.\n * @param idField - The identity field. Default `\"id\"`.\n * @returns An `(current, item) => T[]` patcher for a list cache.\n *\n * @example\n * useOfflineMutation<Note, Note[], Note>({\n *     sync, queryKey: [\"notes\"],\n *     toEntry: (n) => ({ op: \"update\", recordId: n.id, payload: n }),\n *     applyOptimistic: upsertById(),\n * });\n */\nexport function upsertById<T>(\n    idField: keyof T = \"id\" as keyof T,\n): (current: T[] | undefined, item: T) => T[] {\n    return (current = [], item) => {\n        const index = current.findIndex((entry) => entry[idField] === item[idField]);\n        if (index === -1) return [...current, item];\n        const next = current.slice();\n        next[index] = { ...current[index], ...item };\n        return next;\n    };\n}\n\n/**\n * Build an `applyOptimistic` that removes the entry matching the item's id\n * (by `idField`) from the list. For `delete` mutations, pass variables carrying\n * at least the id field.\n *\n * @typeParam T - The list item shape.\n * @param idField - The identity field. Default `\"id\"`.\n * @returns An `(current, item) => T[]` patcher for a list cache.\n *\n * @example\n * useOfflineMutation<{ id: string }, Note[], Note>({\n *     sync, queryKey: [\"notes\"],\n *     toEntry: ({ id }) => ({ op: \"delete\", recordId: id }),\n *     applyOptimistic: removeById(),\n * });\n */\nexport function removeById<T, V extends Partial<Record<keyof T, unknown>> = T>(\n    idField: keyof T = \"id\" as keyof T,\n): (current: T[] | undefined, item: V) => T[] {\n    return (current = [], item) => {\n        const targetId = (item as Record<keyof T, unknown>)[idField];\n        return current.filter((entry) => entry[idField] !== targetId);\n    };\n}\n"],"mappings":"AAuBA,SAAgB,EACZ,EAAmB,KACuB,CAC1C,OAAQ,EAAU,CAAC,EAAG,IAAS,CAC3B,IAAM,EAAQ,EAAQ,UAAW,GAAU,EAAM,KAAa,EAAK,EAAQ,EAC3E,GAAI,IAAU,GAAI,MAAO,CAAC,GAAG,EAAS,CAAI,EAC1C,IAAM,EAAO,EAAQ,MAAM,EAE3B,MADA,GAAK,GAAS,CAAE,GAAG,EAAQ,GAAQ,GAAG,CAAK,EACpC,CACX,CACJ,CAkBA,SAAgB,EACZ,EAAmB,KACuB,CAC1C,OAAQ,EAAU,CAAC,EAAG,IAAS,CAC3B,IAAM,EAAY,EAAkC,GACpD,OAAO,EAAQ,OAAQ,GAAU,EAAM,KAAa,CAAQ,CAChE,CACJ"}
+{"version":3,"file":"optimistic.cjs","names":["upsertById","index","current","entry","idField","item","next","removeById","targetId"],"sources":["../../src/query/optimistic.ts"],"sourcesContent":["/**\n * Ready-made `applyOptimistic` builders for {@link useOfflineMutation} over a\n * list-shaped query cache (`TData = T[]`). They cover the two most common\n * optimistic edits — insert-or-update and remove — so callers stop hand-writing\n * the array spread. Both compare records by an id field (`\"id\"` by default) and\n * treat the mutation variables as the record itself.\n */\n\n/**\n * Build an `applyOptimistic` that inserts the item when absent or shallow-merges\n * it into the existing entry (matched by `idField`). New items append to the end.\n *\n * @typeParam T - The list item shape.\n * @param idField - The identity field. Default `\"id\"`.\n * @returns An `(current, item) => T[]` patcher for a list cache.\n *\n * @example\n * useOfflineMutation<Note, Note[], Note>({\n *     sync, queryKey: [\"notes\"],\n *     toEntry: (n) => ({ op: \"update\", recordId: n.id, payload: n }),\n *     applyOptimistic: upsertById(),\n * });\n */\nexport function upsertById<T>(\n    idField: keyof T = \"id\" as keyof T,\n): (current: T[] | undefined, item: T) => T[] {\n    return (current = [], item) => {\n        const index = current.findIndex((entry) => entry[idField] === item[idField]);\n        if (index === -1) return [...current, item];\n        const next = current.slice();\n        next[index] = { ...current[index], ...item };\n        return next;\n    };\n}\n\n/**\n * Build an `applyOptimistic` that removes the entry matching the item's id\n * (by `idField`) from the list. For `delete` mutations, pass variables carrying\n * at least the id field.\n *\n * @typeParam T - The list item shape.\n * @param idField - The identity field. Default `\"id\"`.\n * @returns An `(current, item) => T[]` patcher for a list cache.\n *\n * @example\n * useOfflineMutation<{ id: string }, Note[], Note>({\n *     sync, queryKey: [\"notes\"],\n *     toEntry: ({ id }) => ({ op: \"delete\", recordId: id }),\n *     applyOptimistic: removeById(),\n * });\n */\nexport function removeById<T, V extends Partial<Record<keyof T, unknown>> = T>(\n    idField: keyof T = \"id\" as keyof T,\n): (current: T[] | undefined, item: V) => T[] {\n    return (current = [], item) => {\n        const targetId = (item as Record<keyof T, unknown>)[idField];\n        return current.filter((entry) => entry[idField] !== targetId);\n    };\n}\n"],"mappings":"AAuBA,SAAgBA,EACZ,EAAmB,KACuB,CAC1C,OAAQ,EAAU,CAAC,EAAG,IAAS,CAC3B,IAAMC,EAAQC,EAAQ,UAAW,GAAUC,EAAMC,KAAaC,EAAKD,EAAQ,EAC3E,GAAIH,IAAU,GAAI,MAAO,CAAC,GAAGC,EAASG,CAAI,EAC1C,IAAMC,EAAOJ,EAAQ,MAAM,EAE3B,MADA,GAAKD,GAAS,CAAE,GAAGC,EAAQD,GAAQ,GAAGI,CAAK,EACpCC,CACX,CACJ,CAkBA,SAAgBC,EACZ,EAAmB,KACuB,CAC1C,OAAQ,EAAU,CAAC,EAAG,IAAS,CAC3B,IAAMC,EAAYH,EAAkCD,GACpD,OAAOF,EAAQ,OAAQ,GAAUC,EAAMC,KAAaI,CAAQ,CAChE,CACJ,C"}

package/dist/query/optimistic.js.map

@@ -1 +1 @@
-{"version":3,"file":"optimistic.js","names":[],"sources":["../../src/query/optimistic.ts"],"sourcesContent":["/**\n * Ready-made `applyOptimistic` builders for {@link useOfflineMutation} over a\n * list-shaped query cache (`TData = T[]`). They cover the two most common\n * optimistic edits — insert-or-update and remove — so callers stop hand-writing\n * the array spread. Both compare records by an id field (`\"id\"` by default) and\n * treat the mutation variables as the record itself.\n */\n\n/**\n * Build an `applyOptimistic` that inserts the item when absent or shallow-merges\n * it into the existing entry (matched by `idField`). New items append to the end.\n *\n * @typeParam T - The list item shape.\n * @param idField - The identity field. Default `\"id\"`.\n * @returns An `(current, item) => T[]` patcher for a list cache.\n *\n * @example\n * useOfflineMutation<Note, Note[], Note>({\n *     sync, queryKey: [\"notes\"],\n *     toEntry: (n) => ({ op: \"update\", recordId: n.id, payload: n }),\n *     applyOptimistic: upsertById(),\n * });\n */\nexport function upsertById<T>(\n    idField: keyof T = \"id\" as keyof T,\n): (current: T[] | undefined, item: T) => T[] {\n    return (current = [], item) => {\n        const index = current.findIndex((entry) => entry[idField] === item[idField]);\n        if (index === -1) return [...current, item];\n        const next = current.slice();\n        next[index] = { ...current[index], ...item };\n        return next;\n    };\n}\n\n/**\n * Build an `applyOptimistic` that removes the entry matching the item's id\n * (by `idField`) from the list. For `delete` mutations, pass variables carrying\n * at least the id field.\n *\n * @typeParam T - The list item shape.\n * @param idField - The identity field. Default `\"id\"`.\n * @returns An `(current, item) => T[]` patcher for a list cache.\n *\n * @example\n * useOfflineMutation<{ id: string }, Note[], Note>({\n *     sync, queryKey: [\"notes\"],\n *     toEntry: ({ id }) => ({ op: \"delete\", recordId: id }),\n *     applyOptimistic: removeById(),\n * });\n */\nexport function removeById<T, V extends Partial<Record<keyof T, unknown>> = T>(\n    idField: keyof T = \"id\" as keyof T,\n): (current: T[] | undefined, item: V) => T[] {\n    return (current = [], item) => {\n        const targetId = (item as Record<keyof T, unknown>)[idField];\n        return current.filter((entry) => entry[idField] !== targetId);\n    };\n}\n"],"mappings":";AAuBA,SAAgB,EACZ,IAAmB,MACuB;CAC1C,QAAQ,IAAU,CAAC,GAAG,MAAS;EAC3B,IAAM,IAAQ,EAAQ,WAAW,MAAU,EAAM,OAAa,EAAK,EAAQ;EAC3E,IAAI,MAAU,IAAI,OAAO,CAAC,GAAG,GAAS,CAAI;EAC1C,IAAM,IAAO,EAAQ,MAAM;EAE3B,OADA,EAAK,KAAS;GAAE,GAAG,EAAQ;GAAQ,GAAG;EAAK,GACpC;CACX;AACJ;AAkBA,SAAgB,EACZ,IAAmB,MACuB;CAC1C,QAAQ,IAAU,CAAC,GAAG,MAAS;EAC3B,IAAM,IAAY,EAAkC;EACpD,OAAO,EAAQ,QAAQ,MAAU,EAAM,OAAa,CAAQ;CAChE;AACJ"}
+{"version":3,"file":"optimistic.js","names":["upsertById","index","current","entry","idField","item","next","removeById","targetId"],"sources":["../../src/query/optimistic.ts"],"sourcesContent":["/**\n * Ready-made `applyOptimistic` builders for {@link useOfflineMutation} over a\n * list-shaped query cache (`TData = T[]`). They cover the two most common\n * optimistic edits — insert-or-update and remove — so callers stop hand-writing\n * the array spread. Both compare records by an id field (`\"id\"` by default) and\n * treat the mutation variables as the record itself.\n */\n\n/**\n * Build an `applyOptimistic` that inserts the item when absent or shallow-merges\n * it into the existing entry (matched by `idField`). New items append to the end.\n *\n * @typeParam T - The list item shape.\n * @param idField - The identity field. Default `\"id\"`.\n * @returns An `(current, item) => T[]` patcher for a list cache.\n *\n * @example\n * useOfflineMutation<Note, Note[], Note>({\n *     sync, queryKey: [\"notes\"],\n *     toEntry: (n) => ({ op: \"update\", recordId: n.id, payload: n }),\n *     applyOptimistic: upsertById(),\n * });\n */\nexport function upsertById<T>(\n    idField: keyof T = \"id\" as keyof T,\n): (current: T[] | undefined, item: T) => T[] {\n    return (current = [], item) => {\n        const index = current.findIndex((entry) => entry[idField] === item[idField]);\n        if (index === -1) return [...current, item];\n        const next = current.slice();\n        next[index] = { ...current[index], ...item };\n        return next;\n    };\n}\n\n/**\n * Build an `applyOptimistic` that removes the entry matching the item's id\n * (by `idField`) from the list. For `delete` mutations, pass variables carrying\n * at least the id field.\n *\n * @typeParam T - The list item shape.\n * @param idField - The identity field. Default `\"id\"`.\n * @returns An `(current, item) => T[]` patcher for a list cache.\n *\n * @example\n * useOfflineMutation<{ id: string }, Note[], Note>({\n *     sync, queryKey: [\"notes\"],\n *     toEntry: ({ id }) => ({ op: \"delete\", recordId: id }),\n *     applyOptimistic: removeById(),\n * });\n */\nexport function removeById<T, V extends Partial<Record<keyof T, unknown>> = T>(\n    idField: keyof T = \"id\" as keyof T,\n): (current: T[] | undefined, item: V) => T[] {\n    return (current = [], item) => {\n        const targetId = (item as Record<keyof T, unknown>)[idField];\n        return current.filter((entry) => entry[idField] !== targetId);\n    };\n}\n"],"mappings":";AAuBA,SAAgBA,EACZ,IAAmB,MACuB;CAC1C,QAAQ,IAAU,CAAC,GAAG,MAAS;EAC3B,IAAMC,IAAQC,EAAQ,WAAW,MAAUC,EAAMC,OAAaC,EAAKD,EAAQ;EAC3E,IAAIH,MAAU,IAAI,OAAO,CAAC,GAAGC,GAASG,CAAI;EAC1C,IAAMC,IAAOJ,EAAQ,MAAM;EAE3B,OADA,EAAKD,KAAS;GAAE,GAAGC,EAAQD;GAAQ,GAAGI;EAAK,GACpCC;CACX;AACJ;AAkBA,SAAgBC,EACZ,IAAmB,MACuB;CAC1C,QAAQ,IAAU,CAAC,GAAG,MAAS;EAC3B,IAAMC,IAAYH,EAAkCD;EACpD,OAAOF,EAAQ,QAAQ,MAAUC,EAAMC,OAAaI,CAAQ;CAChE;AACJ"}

package/dist/query/pagination.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"pagination.cjs","names":[],"sources":["../../src/query/pagination.ts"],"sourcesContent":["// Contracts mirroring the Tempest FastAPI SDK pagination envelopes, so a\n// React frontend consumes them with no manual mapping.\n//\n// Offset (fastapi-pagination `Page` / BasePaginationSchema):\n//   { items, total, page, size, pages }   (some configs name the size `page_size`)\n// Cursor (CursorPaginationSchema):\n//   { items, next_cursor, has_more, limit }\n\n/** Offset-paginated response envelope (fastapi-pagination `Page[T]`). */\nexport interface OffsetPage<T> {\n    /** The rows for the current page. */\n    items: T[];\n    /** Total number of matching rows across all pages. */\n    total: number;\n    /** Current 1-based page number. */\n    page: number;\n    /** Total number of pages. */\n    pages: number;\n    /** Page size — fastapi-pagination emits `size`. */\n    size?: number;\n    /** Page size — some backends name it `page_size` instead. */\n    page_size?: number;\n}\n\n/** Cursor-paginated response envelope (`CursorPaginationSchema[T]`). */\nexport interface CursorPage<T> {\n    /** The rows for this batch. */\n    items: T[];\n    /** Opaque cursor for the next batch, or null when exhausted. Pass it back verbatim. */\n    next_cursor: string | null;\n    /** Whether another batch exists. */\n    has_more: boolean;\n    /** Batch size used for this query. */\n    limit: number;\n}\n\n/** Offset filter query params (fastapi-pagination / `BasePaginationFilterSchema`). */\nexport interface OffsetParams {\n    page?: number;\n    /** Page size — fastapi-pagination convention. */\n    size?: number;\n    /** Page size — `page_size` convention. */\n    page_size?: number;\n    order_by?: string;\n    ascending?: boolean;\n}\n\n/** Cursor filter query params (`CursorPaginationFilterSchema`). */\nexport interface CursorParams {\n    cursor?: string | null;\n    limit?: number;\n    order_by?: string;\n    ascending?: boolean;\n}\n\n/**\n * Type guard for an {@link OffsetPage} envelope.\n *\n * @param value - The unknown value to test.\n * @returns Whether it carries `items` + `total` + `page` + `pages`.\n */\nexport function isOffsetPage<T = unknown>(value: unknown): value is OffsetPage<T> {\n    if (typeof value !== \"object\" || value === null) return false;\n    const v = value as Record<string, unknown>;\n    return Array.isArray(v.items) && typeof v.total === \"number\" && typeof v.pages === \"number\";\n}\n\n/**\n * Type guard for a {@link CursorPage} envelope.\n *\n * @param value - The unknown value to test.\n * @returns Whether it carries `items` + `has_more` + a `next_cursor` key.\n */\nexport function isCursorPage<T = unknown>(value: unknown): value is CursorPage<T> {\n    if (typeof value !== \"object\" || value === null) return false;\n    const v = value as Record<string, unknown>;\n    return Array.isArray(v.items) && typeof v.has_more === \"boolean\" && \"next_cursor\" in v;\n}\n\n/**\n * Build an empty {@link OffsetPage} — handy as `placeholderData`/`initialData`.\n *\n * @param pageSize - The page size to report (default 20).\n * @returns An empty offset page on page 1.\n */\nexport function emptyOffsetPage<T>(pageSize = 20): OffsetPage<T> {\n    return { items: [], total: 0, page: 1, size: pageSize, pages: 0 };\n}\n"],"mappings":"AA6DA,SAAgB,EAA0B,EAAwC,CAC9E,GAAI,OAAO,GAAU,WAAY,EAAgB,MAAO,GACxD,IAAM,EAAI,EACV,OAAO,MAAM,QAAQ,EAAE,KAAK,GAAK,OAAO,EAAE,OAAU,UAAY,OAAO,EAAE,OAAU,QACvF,CAQA,SAAgB,EAA0B,EAAwC,CAC9E,GAAI,OAAO,GAAU,WAAY,EAAgB,MAAO,GACxD,IAAM,EAAI,EACV,OAAO,MAAM,QAAQ,EAAE,KAAK,GAAK,OAAO,EAAE,UAAa,WAAa,gBAAiB,CACzF,CAQA,SAAgB,EAAmB,EAAW,GAAmB,CAC7D,MAAO,CAAE,MAAO,CAAC,EAAG,MAAO,EAAG,KAAM,EAAG,KAAM,EAAU,MAAO,CAAE,CACpE"}
+{"version":3,"file":"pagination.cjs","names":["isOffsetPage","value","v","isCursorPage","emptyOffsetPage","pageSize"],"sources":["../../src/query/pagination.ts"],"sourcesContent":["// Contracts mirroring the Tempest FastAPI SDK pagination envelopes, so a\n// React frontend consumes them with no manual mapping.\n//\n// Offset (fastapi-pagination `Page` / BasePaginationSchema):\n//   { items, total, page, size, pages }   (some configs name the size `page_size`)\n// Cursor (CursorPaginationSchema):\n//   { items, next_cursor, has_more, limit }\n\n/** Offset-paginated response envelope (fastapi-pagination `Page[T]`). */\nexport interface OffsetPage<T> {\n    /** The rows for the current page. */\n    items: T[];\n    /** Total number of matching rows across all pages. */\n    total: number;\n    /** Current 1-based page number. */\n    page: number;\n    /** Total number of pages. */\n    pages: number;\n    /** Page size — fastapi-pagination emits `size`. */\n    size?: number;\n    /** Page size — some backends name it `page_size` instead. */\n    page_size?: number;\n}\n\n/** Cursor-paginated response envelope (`CursorPaginationSchema[T]`). */\nexport interface CursorPage<T> {\n    /** The rows for this batch. */\n    items: T[];\n    /** Opaque cursor for the next batch, or null when exhausted. Pass it back verbatim. */\n    next_cursor: string | null;\n    /** Whether another batch exists. */\n    has_more: boolean;\n    /** Batch size used for this query. */\n    limit: number;\n}\n\n/** Offset filter query params (fastapi-pagination / `BasePaginationFilterSchema`). */\nexport interface OffsetParams {\n    page?: number;\n    /** Page size — fastapi-pagination convention. */\n    size?: number;\n    /** Page size — `page_size` convention. */\n    page_size?: number;\n    order_by?: string;\n    ascending?: boolean;\n}\n\n/** Cursor filter query params (`CursorPaginationFilterSchema`). */\nexport interface CursorParams {\n    cursor?: string | null;\n    limit?: number;\n    order_by?: string;\n    ascending?: boolean;\n}\n\n/**\n * Type guard for an {@link OffsetPage} envelope.\n *\n * @param value - The unknown value to test.\n * @returns Whether it carries `items` + `total` + `page` + `pages`.\n */\nexport function isOffsetPage<T = unknown>(value: unknown): value is OffsetPage<T> {\n    if (typeof value !== \"object\" || value === null) return false;\n    const v = value as Record<string, unknown>;\n    return Array.isArray(v.items) && typeof v.total === \"number\" && typeof v.pages === \"number\";\n}\n\n/**\n * Type guard for a {@link CursorPage} envelope.\n *\n * @param value - The unknown value to test.\n * @returns Whether it carries `items` + `has_more` + a `next_cursor` key.\n */\nexport function isCursorPage<T = unknown>(value: unknown): value is CursorPage<T> {\n    if (typeof value !== \"object\" || value === null) return false;\n    const v = value as Record<string, unknown>;\n    return Array.isArray(v.items) && typeof v.has_more === \"boolean\" && \"next_cursor\" in v;\n}\n\n/**\n * Build an empty {@link OffsetPage} — handy as `placeholderData`/`initialData`.\n *\n * @param pageSize - The page size to report (default 20).\n * @returns An empty offset page on page 1.\n */\nexport function emptyOffsetPage<T>(pageSize = 20): OffsetPage<T> {\n    return { items: [], total: 0, page: 1, size: pageSize, pages: 0 };\n}\n"],"mappings":"AA6DA,SAAgBA,EAA0B,EAAwC,CAC9E,GAAI,OAAOC,GAAU,WAAYA,EAAgB,MAAO,GACxD,IAAMC,EAAID,EACV,OAAO,MAAM,QAAQC,EAAE,KAAK,GAAK,OAAOA,EAAE,OAAU,UAAY,OAAOA,EAAE,OAAU,QACvF,CAQA,SAAgBC,EAA0B,EAAwC,CAC9E,GAAI,OAAOF,GAAU,WAAYA,EAAgB,MAAO,GACxD,IAAMC,EAAID,EACV,OAAO,MAAM,QAAQC,EAAE,KAAK,GAAK,OAAOA,EAAE,UAAa,WAAa,gBAAiBA,CACzF,CAQA,SAAgBE,EAAmB,EAAW,GAAmB,CAC7D,MAAO,CAAE,MAAO,CAAC,EAAG,MAAO,EAAG,KAAM,EAAG,KAAMC,EAAU,MAAO,CAAE,CACpE,C"}

package/dist/query/pagination.js.map

@@ -1 +1 @@
-{"version":3,"file":"pagination.js","names":[],"sources":["../../src/query/pagination.ts"],"sourcesContent":["// Contracts mirroring the Tempest FastAPI SDK pagination envelopes, so a\n// React frontend consumes them with no manual mapping.\n//\n// Offset (fastapi-pagination `Page` / BasePaginationSchema):\n//   { items, total, page, size, pages }   (some configs name the size `page_size`)\n// Cursor (CursorPaginationSchema):\n//   { items, next_cursor, has_more, limit }\n\n/** Offset-paginated response envelope (fastapi-pagination `Page[T]`). */\nexport interface OffsetPage<T> {\n    /** The rows for the current page. */\n    items: T[];\n    /** Total number of matching rows across all pages. */\n    total: number;\n    /** Current 1-based page number. */\n    page: number;\n    /** Total number of pages. */\n    pages: number;\n    /** Page size — fastapi-pagination emits `size`. */\n    size?: number;\n    /** Page size — some backends name it `page_size` instead. */\n    page_size?: number;\n}\n\n/** Cursor-paginated response envelope (`CursorPaginationSchema[T]`). */\nexport interface CursorPage<T> {\n    /** The rows for this batch. */\n    items: T[];\n    /** Opaque cursor for the next batch, or null when exhausted. Pass it back verbatim. */\n    next_cursor: string | null;\n    /** Whether another batch exists. */\n    has_more: boolean;\n    /** Batch size used for this query. */\n    limit: number;\n}\n\n/** Offset filter query params (fastapi-pagination / `BasePaginationFilterSchema`). */\nexport interface OffsetParams {\n    page?: number;\n    /** Page size — fastapi-pagination convention. */\n    size?: number;\n    /** Page size — `page_size` convention. */\n    page_size?: number;\n    order_by?: string;\n    ascending?: boolean;\n}\n\n/** Cursor filter query params (`CursorPaginationFilterSchema`). */\nexport interface CursorParams {\n    cursor?: string | null;\n    limit?: number;\n    order_by?: string;\n    ascending?: boolean;\n}\n\n/**\n * Type guard for an {@link OffsetPage} envelope.\n *\n * @param value - The unknown value to test.\n * @returns Whether it carries `items` + `total` + `page` + `pages`.\n */\nexport function isOffsetPage<T = unknown>(value: unknown): value is OffsetPage<T> {\n    if (typeof value !== \"object\" || value === null) return false;\n    const v = value as Record<string, unknown>;\n    return Array.isArray(v.items) && typeof v.total === \"number\" && typeof v.pages === \"number\";\n}\n\n/**\n * Type guard for a {@link CursorPage} envelope.\n *\n * @param value - The unknown value to test.\n * @returns Whether it carries `items` + `has_more` + a `next_cursor` key.\n */\nexport function isCursorPage<T = unknown>(value: unknown): value is CursorPage<T> {\n    if (typeof value !== \"object\" || value === null) return false;\n    const v = value as Record<string, unknown>;\n    return Array.isArray(v.items) && typeof v.has_more === \"boolean\" && \"next_cursor\" in v;\n}\n\n/**\n * Build an empty {@link OffsetPage} — handy as `placeholderData`/`initialData`.\n *\n * @param pageSize - The page size to report (default 20).\n * @returns An empty offset page on page 1.\n */\nexport function emptyOffsetPage<T>(pageSize = 20): OffsetPage<T> {\n    return { items: [], total: 0, page: 1, size: pageSize, pages: 0 };\n}\n"],"mappings":";AA6DA,SAAgB,EAA0B,GAAwC;CAC9E,IAAI,OAAO,KAAU,aAAY,GAAgB,OAAO;CACxD,IAAM,IAAI;CACV,OAAO,MAAM,QAAQ,EAAE,KAAK,KAAK,OAAO,EAAE,SAAU,YAAY,OAAO,EAAE,SAAU;AACvF;AAQA,SAAgB,EAA0B,GAAwC;CAC9E,IAAI,OAAO,KAAU,aAAY,GAAgB,OAAO;CACxD,IAAM,IAAI;CACV,OAAO,MAAM,QAAQ,EAAE,KAAK,KAAK,OAAO,EAAE,YAAa,aAAa,iBAAiB;AACzF;AAQA,SAAgB,EAAmB,IAAW,IAAmB;CAC7D,OAAO;EAAE,OAAO,CAAC;EAAG,OAAO;EAAG,MAAM;EAAG,MAAM;EAAU,OAAO;CAAE;AACpE"}
+{"version":3,"file":"pagination.js","names":["isOffsetPage","value","v","isCursorPage","emptyOffsetPage","pageSize"],"sources":["../../src/query/pagination.ts"],"sourcesContent":["// Contracts mirroring the Tempest FastAPI SDK pagination envelopes, so a\n// React frontend consumes them with no manual mapping.\n//\n// Offset (fastapi-pagination `Page` / BasePaginationSchema):\n//   { items, total, page, size, pages }   (some configs name the size `page_size`)\n// Cursor (CursorPaginationSchema):\n//   { items, next_cursor, has_more, limit }\n\n/** Offset-paginated response envelope (fastapi-pagination `Page[T]`). */\nexport interface OffsetPage<T> {\n    /** The rows for the current page. */\n    items: T[];\n    /** Total number of matching rows across all pages. */\n    total: number;\n    /** Current 1-based page number. */\n    page: number;\n    /** Total number of pages. */\n    pages: number;\n    /** Page size — fastapi-pagination emits `size`. */\n    size?: number;\n    /** Page size — some backends name it `page_size` instead. */\n    page_size?: number;\n}\n\n/** Cursor-paginated response envelope (`CursorPaginationSchema[T]`). */\nexport interface CursorPage<T> {\n    /** The rows for this batch. */\n    items: T[];\n    /** Opaque cursor for the next batch, or null when exhausted. Pass it back verbatim. */\n    next_cursor: string | null;\n    /** Whether another batch exists. */\n    has_more: boolean;\n    /** Batch size used for this query. */\n    limit: number;\n}\n\n/** Offset filter query params (fastapi-pagination / `BasePaginationFilterSchema`). */\nexport interface OffsetParams {\n    page?: number;\n    /** Page size — fastapi-pagination convention. */\n    size?: number;\n    /** Page size — `page_size` convention. */\n    page_size?: number;\n    order_by?: string;\n    ascending?: boolean;\n}\n\n/** Cursor filter query params (`CursorPaginationFilterSchema`). */\nexport interface CursorParams {\n    cursor?: string | null;\n    limit?: number;\n    order_by?: string;\n    ascending?: boolean;\n}\n\n/**\n * Type guard for an {@link OffsetPage} envelope.\n *\n * @param value - The unknown value to test.\n * @returns Whether it carries `items` + `total` + `page` + `pages`.\n */\nexport function isOffsetPage<T = unknown>(value: unknown): value is OffsetPage<T> {\n    if (typeof value !== \"object\" || value === null) return false;\n    const v = value as Record<string, unknown>;\n    return Array.isArray(v.items) && typeof v.total === \"number\" && typeof v.pages === \"number\";\n}\n\n/**\n * Type guard for a {@link CursorPage} envelope.\n *\n * @param value - The unknown value to test.\n * @returns Whether it carries `items` + `has_more` + a `next_cursor` key.\n */\nexport function isCursorPage<T = unknown>(value: unknown): value is CursorPage<T> {\n    if (typeof value !== \"object\" || value === null) return false;\n    const v = value as Record<string, unknown>;\n    return Array.isArray(v.items) && typeof v.has_more === \"boolean\" && \"next_cursor\" in v;\n}\n\n/**\n * Build an empty {@link OffsetPage} — handy as `placeholderData`/`initialData`.\n *\n * @param pageSize - The page size to report (default 20).\n * @returns An empty offset page on page 1.\n */\nexport function emptyOffsetPage<T>(pageSize = 20): OffsetPage<T> {\n    return { items: [], total: 0, page: 1, size: pageSize, pages: 0 };\n}\n"],"mappings":";AA6DA,SAAgBA,EAA0B,GAAwC;CAC9E,IAAI,OAAOC,KAAU,aAAYA,GAAgB,OAAO;CACxD,IAAMC,IAAID;CACV,OAAO,MAAM,QAAQC,EAAE,KAAK,KAAK,OAAOA,EAAE,SAAU,YAAY,OAAOA,EAAE,SAAU;AACvF;AAQA,SAAgBC,EAA0B,GAAwC;CAC9E,IAAI,OAAOF,KAAU,aAAYA,GAAgB,OAAO;CACxD,IAAMC,IAAID;CACV,OAAO,MAAM,QAAQC,EAAE,KAAK,KAAK,OAAOA,EAAE,YAAa,aAAa,iBAAiBA;AACzF;AAQA,SAAgBE,EAAmB,IAAW,IAAmB;CAC7D,OAAO;EAAE,OAAO,CAAC;EAAG,OAAO;EAAG,MAAM;EAAG,MAAMC;EAAU,OAAO;CAAE;AACpE"}

package/dist/query/retry-policy.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"retry-policy.cjs","names":[],"sources":["../../src/query/retry-policy.ts"],"sourcesContent":["import { isApiError, isRetriableStatus } from \"../http/errors\";\n\n/** How many times a retriable failure is replayed. */\nconst MAX_RETRIES = 1;\n\n/**\n * Default `retry` for SDK queries: replay transport and server failures, never a\n * deliberate client-side refusal.\n *\n * A flat `retry: 1` replays a 403 on an admin-only listing and a 404 for a record\n * somebody deleted. The server meant both — the second attempt returns the same\n * answer, doubles the network log and holds the spinner on screen for the length\n * of another round trip. A network failure or a 5xx is a different thing: it may\n * well succeed on the next try, so those keep the previous behaviour.\n *\n * The status list is {@link isRetriableStatus}, shared with the client's own\n * policy. It used to be a second copy here, and the copy was missing `425` — so\n * a `425 Too Early` was replayed by `createApiClient({ retry: true })` and not\n * by a query, for the same error in the same app.\n *\n * @example\n * new QueryClient({ defaultOptions: { queries: { retry: shouldRetryQuery } } });\n *\n * @param failureCount - Attempts already made, as react-query counts them.\n * @param error - The rejection value from the query function.\n * @returns Whether react-query should try again.\n */\nexport function shouldRetryQuery(failureCount: number, error: unknown): boolean {\n    if (failureCount >= MAX_RETRIES) return false;\n    if (!isApiError(error)) return true;\n    return isRetriableStatus(error.status);\n}\n"],"mappings":"sCAGA,IAAM,EAAc,EAwBpB,SAAgB,EAAiB,EAAsB,EAAyB,CAG5E,OAFI,GAAgB,EAAoB,GACxC,CAAK,EAAA,WAAW,CAAK,GACd,EAAA,kBAAkB,EAAM,MAAM,CACzC"}
+{"version":3,"file":"retry-policy.cjs","names":["isApiError","isRetriableStatus","require_errors","MAX_RETRIES","shouldRetryQuery","failureCount","error"],"sources":["../../src/query/retry-policy.ts"],"sourcesContent":["import { isApiError, isRetriableStatus } from \"../http/errors\";\n\n/** How many times a retriable failure is replayed. */\nconst MAX_RETRIES = 1;\n\n/**\n * Default `retry` for SDK queries: replay transport and server failures, never a\n * deliberate client-side refusal.\n *\n * A flat `retry: 1` replays a 403 on an admin-only listing and a 404 for a record\n * somebody deleted. The server meant both — the second attempt returns the same\n * answer, doubles the network log and holds the spinner on screen for the length\n * of another round trip. A network failure or a 5xx is a different thing: it may\n * well succeed on the next try, so those keep the previous behaviour.\n *\n * The status list is {@link isRetriableStatus}, shared with the client's own\n * policy. It used to be a second copy here, and the copy was missing `425` — so\n * a `425 Too Early` was replayed by `createApiClient({ retry: true })` and not\n * by a query, for the same error in the same app.\n *\n * @example\n * new QueryClient({ defaultOptions: { queries: { retry: shouldRetryQuery } } });\n *\n * @param failureCount - Attempts already made, as react-query counts them.\n * @param error - The rejection value from the query function.\n * @returns Whether react-query should try again.\n */\nexport function shouldRetryQuery(failureCount: number, error: unknown): boolean {\n    if (failureCount >= MAX_RETRIES) return false;\n    if (!isApiError(error)) return true;\n    return isRetriableStatus(error.status);\n}\n"],"mappings":"A,sCAGA,IAAMG,EAAc,EAwBpB,SAAgBC,EAAiB,EAAsB,EAAyB,CAG5E,OAFIC,GAAgBF,EAAoB,GACxC,CAAKH,EAAAA,WAAWM,CAAK,GACdL,EAAAA,kBAAkBK,EAAM,MAAM,CACzC,C"}

package/dist/query/retry-policy.js.map

@@ -1 +1 @@
-{"version":3,"file":"retry-policy.js","names":[],"sources":["../../src/query/retry-policy.ts"],"sourcesContent":["import { isApiError, isRetriableStatus } from \"../http/errors\";\n\n/** How many times a retriable failure is replayed. */\nconst MAX_RETRIES = 1;\n\n/**\n * Default `retry` for SDK queries: replay transport and server failures, never a\n * deliberate client-side refusal.\n *\n * A flat `retry: 1` replays a 403 on an admin-only listing and a 404 for a record\n * somebody deleted. The server meant both — the second attempt returns the same\n * answer, doubles the network log and holds the spinner on screen for the length\n * of another round trip. A network failure or a 5xx is a different thing: it may\n * well succeed on the next try, so those keep the previous behaviour.\n *\n * The status list is {@link isRetriableStatus}, shared with the client's own\n * policy. It used to be a second copy here, and the copy was missing `425` — so\n * a `425 Too Early` was replayed by `createApiClient({ retry: true })` and not\n * by a query, for the same error in the same app.\n *\n * @example\n * new QueryClient({ defaultOptions: { queries: { retry: shouldRetryQuery } } });\n *\n * @param failureCount - Attempts already made, as react-query counts them.\n * @param error - The rejection value from the query function.\n * @returns Whether react-query should try again.\n */\nexport function shouldRetryQuery(failureCount: number, error: unknown): boolean {\n    if (failureCount >= MAX_RETRIES) return false;\n    if (!isApiError(error)) return true;\n    return isRetriableStatus(error.status);\n}\n"],"mappings":";;AAGA,IAAM,IAAc;AAwBpB,SAAgB,EAAiB,GAAsB,GAAyB;CAG5E,OAFI,KAAgB,IAAoB,KACxC,CAAK,EAAW,CAAK,KACd,EAAkB,EAAM,MAAM;AACzC"}
+{"version":3,"file":"retry-policy.js","names":["MAX_RETRIES","shouldRetryQuery","failureCount","isApiError","error","isRetriableStatus"],"sources":["../../src/query/retry-policy.ts"],"sourcesContent":["import { isApiError, isRetriableStatus } from \"../http/errors\";\n\n/** How many times a retriable failure is replayed. */\nconst MAX_RETRIES = 1;\n\n/**\n * Default `retry` for SDK queries: replay transport and server failures, never a\n * deliberate client-side refusal.\n *\n * A flat `retry: 1` replays a 403 on an admin-only listing and a 404 for a record\n * somebody deleted. The server meant both — the second attempt returns the same\n * answer, doubles the network log and holds the spinner on screen for the length\n * of another round trip. A network failure or a 5xx is a different thing: it may\n * well succeed on the next try, so those keep the previous behaviour.\n *\n * The status list is {@link isRetriableStatus}, shared with the client's own\n * policy. It used to be a second copy here, and the copy was missing `425` — so\n * a `425 Too Early` was replayed by `createApiClient({ retry: true })` and not\n * by a query, for the same error in the same app.\n *\n * @example\n * new QueryClient({ defaultOptions: { queries: { retry: shouldRetryQuery } } });\n *\n * @param failureCount - Attempts already made, as react-query counts them.\n * @param error - The rejection value from the query function.\n * @returns Whether react-query should try again.\n */\nexport function shouldRetryQuery(failureCount: number, error: unknown): boolean {\n    if (failureCount >= MAX_RETRIES) return false;\n    if (!isApiError(error)) return true;\n    return isRetriableStatus(error.status);\n}\n"],"mappings":";;AAGA,IAAMA,IAAc;AAwBpB,SAAgBC,EAAiB,GAAsB,GAAyB;CAG5E,OAFIC,KAAgBF,IAAoB,KACxC,CAAKG,EAAWC,CAAK,KACdC,EAAkBD,EAAM,MAAM;AACzC"}

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

@@ -1 +1 @@
-{"version":3,"file":"use-cursor-query.cjs","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":"uCA0DA,SAAgB,EAAkB,EAA4D,CAC1F,GAAM,CAAE,WAAU,UAAS,QAAQ,GAAI,UAAS,YAAY,GAAO,GAAG,GAAiB,EAEjF,GAAA,EAAQ,EAAA,iBAAA,CAMZ,CACE,GAAG,EACH,SAAU,CAAC,GAAG,EAAU,CAAE,QAAO,UAAS,WAAU,CAAC,EACrD,iBAAkB,KAClB,SAAU,CAAE,eACR,EAAQ,CAAE,OAAQ,EAAW,QAAO,SAAU,EAAS,WAAU,CAAC,EACtE,iBAAmB,GAAU,EAAK,SAAW,EAAK,YAAc,IAAA,EACpE,CAAC,EAEK,EAAQ,EAAM,MAAM,OAAS,CAAC,EAEpC,MAAO,CACH,MAAO,EAAM,QAAS,GAAM,EAAE,KAAK,EACnC,QACA,YAAa,EAAM,YACnB,UAAW,EAAM,UACjB,mBAAoB,EAAM,mBAC1B,MAAO,EAAM,MACb,kBAAqB,KAAK,EAAM,cAAc,EAC9C,YAAe,KAAK,EAAM,QAAQ,CACtC,CACJ"}
+{"version":3,"file":"use-cursor-query.cjs","names":["useInfiniteQuery","_tanstack_react_query","useCursorQuery","queryOptions","options","query","queryKey","queryFn","pageParam","orderBy","last","pages","p"],"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":"A,uCA0DA,SAAgBE,EAAkB,EAA4D,CAC1F,GAAM,CAAE,WAAU,UAAS,QAAQ,GAAI,UAAS,YAAY,GAAO,GAAGC,GAAiBC,EAEjFC,GAAA,EAAQL,EAAAA,iBAAAA,CAMZ,CACE,GAAGG,EACH,SAAU,CAAC,GAAGG,EAAU,CAAE,QAAO,UAAS,WAAU,CAAC,EACrD,iBAAkB,KAClB,SAAU,CAAE,eACRC,EAAQ,CAAE,OAAQC,EAAW,QAAO,SAAUC,EAAS,WAAU,CAAC,EACtE,iBAAmB,GAAUC,EAAK,SAAWA,EAAK,YAAc,IAAA,EACpE,CAAC,EAEKC,EAAQN,EAAM,MAAM,OAAS,CAAC,EAEpC,MAAO,CACH,MAAOM,EAAM,QAAS,GAAMC,EAAE,KAAK,EACnC,QACA,YAAaP,EAAM,YACnB,UAAWA,EAAM,UACjB,mBAAoBA,EAAM,mBAC1B,MAAOA,EAAM,MACb,kBAAqB,KAAKA,EAAM,cAAc,EAC9C,YAAe,KAAKA,EAAM,QAAQ,CACtC,CACJ,C"}

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

@@ -1 +1 @@
-{"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"}
+{"version":3,"file":"use-cursor-query.js","names":["useCursorQuery","queryOptions","options","query","useInfiniteQuery","queryKey","queryFn","pageParam","orderBy","last","pages","p"],"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,SAAgBA,EAAkB,GAA4D;CAC1F,IAAM,EAAE,aAAU,YAAS,WAAQ,IAAI,YAAS,eAAY,IAAO,GAAGC,MAAiBC,GAEjFC,IAAQC,EAMZ;EACE,GAAGH;EACH,UAAU,CAAC,GAAGI,GAAU;GAAE;GAAO;GAAS;EAAU,CAAC;EACrD,kBAAkB;EAClB,UAAU,EAAE,mBACRC,EAAQ;GAAE,QAAQC;GAAW;GAAO,UAAUC;GAAS;EAAU,CAAC;EACtE,mBAAmB,MAAUC,EAAK,WAAWA,EAAK,cAAc,KAAA;CACpE,CAAC,GAEKC,IAAQP,EAAM,MAAM,SAAS,CAAC;CAEpC,OAAO;EACH,OAAOO,EAAM,SAAS,MAAMC,EAAE,KAAK;EACnC;EACA,aAAaR,EAAM;EACnB,WAAWA,EAAM;EACjB,oBAAoBA,EAAM;EAC1B,OAAOA,EAAM;EACb,qBAAqB,KAAKA,EAAM,cAAc;EAC9C,eAAe,KAAKA,EAAM,QAAQ;CACtC;AACJ"}

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

@@ -1 +1 @@
-{"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,EAAS,EAAA,eAAA,CAAe,EAE9B,OAAA,EAAO,EAAA,YAAA,CAA+D,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"}
+{"version":3,"file":"use-offline-mutation.cjs","names":["useQueryClient","useMutation","_tanstack_react_query","useOfflineMutation","options","client","draft","toEntry","variables","id","sync","flush","trigger","queryKey","applyOptimistic","previous","current","context","invalidate"],"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":"A,uCA6EA,SAAgBG,EACZ,EACoE,CACpE,GAAM,CAAE,OAAM,UAAS,WAAU,kBAAiB,QAAQ,GAAM,aAAa,IAAUC,EACjFC,GAAA,EAASL,EAAAA,eAAAA,CAAe,EAE9B,OAAA,EAAOC,EAAAA,YAAAA,CAA+D,CAClE,WAAY,KAAO,IAAc,CAC7B,IAAMK,EAAQC,EAAQC,CAAS,EACzBC,EAAK,MAAMC,EAAK,QAAQJ,EAAM,GAAIA,EAAM,SAAUA,EAAM,OAAO,EACrE,GAAIK,IAAU,GAAO,CACjB,IAAMC,EAAuBD,IAAU,GAAO,iBAAmBA,EACjED,EAAU,MAAME,CAAO,CAC3B,CACA,OAAOH,CACX,EACA,SAAU,KAAO,IAAc,CAC3B,GAAI,CAACI,GAAY,CAACC,EAAiB,MAAO,CAAE,SAAU,IAAA,EAAU,EAChE,MAAMT,EAAO,cAAc,CAAE,UAAS,CAAC,EACvC,IAAMU,EAAWV,EAAO,aAAoBQ,CAAQ,EAEpD,OADAR,EAAO,aAAoBQ,EAAW,GAAYC,EAAgBE,EAASR,CAAS,CAAC,EAC9E,CAAE,UAAS,CACtB,EACA,SAAU,EAAQ,EAAY,IAAY,CAClCK,GAAYI,GAASZ,EAAO,aAAaQ,EAAUI,EAAQ,QAAQ,CAC3E,EACA,cAAiB,CACTC,GAAcL,GAAUR,EAAY,kBAAkB,CAAE,UAAS,CAAC,CAC1E,CACJ,CAAC,CACL,C"}

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

@@ -1 +1 @@
-{"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"}
+{"version":3,"file":"use-offline-mutation.js","names":["useOfflineMutation","options","client","useQueryClient","useMutation","draft","toEntry","variables","id","sync","flush","trigger","queryKey","applyOptimistic","previous","current","context","invalidate"],"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,SAAgBA,EACZ,GACoE;CACpE,IAAM,EAAE,SAAM,YAAS,aAAU,oBAAiB,WAAQ,IAAM,gBAAa,OAAUC,GACjFC,IAASC,EAAe;CAE9B,OAAOC,EAA+D;EAClE,YAAY,OAAO,MAAc;GAC7B,IAAMC,IAAQC,EAAQC,CAAS,GACzBC,IAAK,MAAMC,EAAK,QAAQJ,EAAM,IAAIA,EAAM,UAAUA,EAAM,OAAO;GACrE,IAAIK,MAAU,IAAO;IACjB,IAAMC,IAAuBD,MAAU,KAAO,mBAAmBA;IACjE,EAAU,MAAMC,CAAO;GAC3B;GACA,OAAOH;EACX;EACA,UAAU,OAAO,MAAc;GAC3B,IAAI,CAACI,KAAY,CAACC,GAAiB,OAAO,EAAE,UAAU,KAAA,EAAU;GAChE,MAAMX,EAAO,cAAc,EAAE,YAAS,CAAC;GACvC,IAAMY,IAAWZ,EAAO,aAAoBU,CAAQ;GAEpD,OADAV,EAAO,aAAoBU,IAAW,MAAYC,EAAgBE,GAASR,CAAS,CAAC,GAC9E,EAAE,YAAS;EACtB;EACA,UAAU,GAAQ,GAAY,MAAY;GACtC,AAAIK,KAAYI,KAASd,EAAO,aAAaU,GAAUI,EAAQ,QAAQ;EAC3E;EACA,iBAAiB;GACb,AAAIC,KAAcL,KAAUV,EAAY,kBAAkB,EAAE,YAAS,CAAC;EAC1E;CACJ,CAAC;AACL"}

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

@@ -1 +1 @@
-{"version":3,"file":"use-paginated-query.cjs","names":[],"sources":["../../src/query/use-paginated-query.ts"],"sourcesContent":["import { useCallback, useState } from \"react\";\nimport { hashKey, 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    /**\n     * Base query key — the current page/sort is appended for cache isolation.\n     * Put the applied filters here: when the key changes structurally, the page\n     * goes back to 1 in the same render.\n     */\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; back to 1 on a new `queryKey`). */\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 * A structurally different `queryKey` (compared with TanStack's `hashKey`) is a\n * different result set, so the page returns to 1. The reset is applied during\n * render rather than in an effect: an effect would let one render go out with the\n * new key and the old page, and that render is a request — on page 7 of an\n * unfiltered list, applying a filter used to ask for page 7 of a two-page result\n * and show an empty table (#356).\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 keyHash = hashKey(queryKey);\n    const [paging, setPaging] = useState({ keyHash, page: initialPage });\n    if (paging.keyHash !== keyHash) setPaging({ keyHash, page: 1 });\n    const pageNumber = paging.keyHash === keyHash ? paging.page : 1;\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(\n        (next: number) => setPaging((s) => ({ ...s, page: Math.max(1, next) })),\n        [],\n    );\n    const next = useCallback(\n        () => setPaging((s) => (s.page < pageCount ? { ...s, page: s.page + 1 } : s)),\n        [pageCount],\n    );\n    const prev = useCallback(\n        () => setPaging((s) => (s.page > 1 ? { ...s, page: s.page - 1 } : s)),\n        [],\n    );\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":"0DAmFA,SAAgB,EACZ,EAC0B,CAC1B,GAAM,CACF,WACA,UACA,cAAc,EACd,WAAW,GACX,YAAY,OACZ,UACA,YAAY,GACZ,GAAG,GACH,EAEE,GAAA,EAAU,EAAA,QAAA,CAAQ,CAAQ,EAC1B,CAAC,EAAQ,IAAA,EAAa,EAAA,SAAA,CAAS,CAAE,UAAS,KAAM,CAAY,CAAC,EAC/D,EAAO,UAAY,GAAS,EAAU,CAAE,UAAS,KAAM,CAAE,CAAC,EAC9D,IAAM,EAAa,EAAO,UAAY,EAAU,EAAO,KAAO,EAExD,GAAA,EAAQ,EAAA,SAAA,CAA+B,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,EAAU,EAAA,YAAA,CACX,GAAiB,EAAW,IAAO,CAAE,GAAG,EAAG,KAAM,KAAK,IAAI,EAAG,CAAI,CAAE,EAAE,EACtE,CAAC,CACL,EACM,GAAA,EAAO,EAAA,YAAA,KACH,EAAW,GAAO,EAAE,KAAO,EAAY,CAAE,GAAG,EAAG,KAAM,EAAE,KAAO,CAAE,EAAI,CAAE,EAC5E,CAAC,CAAS,CACd,EACM,GAAA,EAAO,EAAA,YAAA,KACH,EAAW,GAAO,EAAE,KAAO,EAAI,CAAE,GAAG,EAAG,KAAM,EAAE,KAAO,CAAE,EAAI,CAAE,EACpE,CAAC,CACL,EAEA,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"}
+{"version":3,"file":"use-paginated-query.cjs","names":["hashKey","useState","useQuery","keepPreviousData","useCallback","react","_tanstack_react_query","usePaginatedQuery","queryOptions","options","keyHash","queryKey","paging","setPaging","initialPage","pageNumber","query","params","sizeParam","pageSize","orderBy","ascending","queryFn","page","pageCount","hasNext","hasPrev","setPage","s","next","prev"],"sources":["../../src/query/use-paginated-query.ts"],"sourcesContent":["import { useCallback, useState } from \"react\";\nimport { hashKey, 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    /**\n     * Base query key — the current page/sort is appended for cache isolation.\n     * Put the applied filters here: when the key changes structurally, the page\n     * goes back to 1 in the same render.\n     */\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; back to 1 on a new `queryKey`). */\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 * A structurally different `queryKey` (compared with TanStack's `hashKey`) is a\n * different result set, so the page returns to 1. The reset is applied during\n * render rather than in an effect: an effect would let one render go out with the\n * new key and the old page, and that render is a request — on page 7 of an\n * unfiltered list, applying a filter used to ask for page 7 of a two-page result\n * and show an empty table (#356).\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 keyHash = hashKey(queryKey);\n    const [paging, setPaging] = useState({ keyHash, page: initialPage });\n    if (paging.keyHash !== keyHash) setPaging({ keyHash, page: 1 });\n    const pageNumber = paging.keyHash === keyHash ? paging.page : 1;\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(\n        (next: number) => setPaging((s) => ({ ...s, page: Math.max(1, next) })),\n        [],\n    );\n    const next = useCallback(\n        () => setPaging((s) => (s.page < pageCount ? { ...s, page: s.page + 1 } : s)),\n        [pageCount],\n    );\n    const prev = useCallback(\n        () => setPaging((s) => (s.page > 1 ? { ...s, page: s.page - 1 } : s)),\n        [],\n    );\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":"A,0DAmFA,SAAgBO,EACZ,EAC0B,CAC1B,GAAM,CACF,WACA,UACA,cAAc,EACd,WAAW,GACX,YAAY,OACZ,UACA,YAAY,GACZ,GAAGC,GACHC,EAEEC,GAAA,EAAUV,EAAAA,QAAAA,CAAQW,CAAQ,EAC1B,CAACC,EAAQC,IAAA,EAAaZ,EAAAA,SAAAA,CAAS,CAAE,UAAS,KAAMa,CAAY,CAAC,EAC/DF,EAAO,UAAYF,GAASG,EAAU,CAAE,UAAS,KAAM,CAAE,CAAC,EAC9D,IAAME,EAAaH,EAAO,UAAYF,EAAUE,EAAO,KAAO,EAExDI,GAAA,EAAQd,EAAAA,SAAAA,CAA+B,CACzC,GAAGM,EACH,SAAU,CAAC,GAAGG,EAAU,CAAE,KAAMI,EAAY,WAAU,YAAW,UAAS,WAAU,CAAC,EACrF,YAAe,CACX,IAAME,EAAuB,CAAE,KAAMF,GAAaG,GAAYC,CAAS,EAKvE,OAJIC,IACA,EAAO,SAAWA,EAClB,EAAO,UAAYC,GAEhBC,EAAQL,CAAM,CACzB,EACA,gBAAiBd,EAAAA,gBACrB,CAAC,EAEKoB,EAAOP,EAAM,KACbQ,EAAYD,GAAM,OAAS,EAC3BE,EAAUV,EAAaS,EACvBE,EAAUX,EAAa,EAEvBY,GAAA,EAAUvB,EAAAA,YAAAA,CACX,GAAiBS,EAAW,IAAO,CAAE,GAAGe,EAAG,KAAM,KAAK,IAAI,EAAGC,CAAI,CAAE,EAAE,EACtE,CAAC,CACL,EACMA,GAAA,EAAOzB,EAAAA,YAAAA,KACHS,EAAW,GAAOe,EAAE,KAAOJ,EAAY,CAAE,GAAGI,EAAG,KAAMA,EAAE,KAAO,CAAE,EAAIA,CAAE,EAC5E,CAACJ,CAAS,CACd,EACMM,GAAA,EAAO1B,EAAAA,YAAAA,KACHS,EAAW,GAAOe,EAAE,KAAO,EAAI,CAAE,GAAGA,EAAG,KAAMA,EAAE,KAAO,CAAE,EAAIA,CAAE,EACpE,CAAC,CACL,EAEA,MAAO,CACH,OACA,MAAOL,GAAM,OAAS,CAAC,EACvB,aACA,YACA,MAAOA,GAAM,OAAS,EACtB,UACA,UACA,UAAWP,EAAM,UACjB,WAAYA,EAAM,WAClB,MAAOA,EAAM,MACb,UACA,OACA,OACA,YAAe,KAAKA,EAAM,QAAQ,CACtC,CACJ,C"}

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

@@ -1 +1 @@
-{"version":3,"file":"use-paginated-query.js","names":[],"sources":["../../src/query/use-paginated-query.ts"],"sourcesContent":["import { useCallback, useState } from \"react\";\nimport { hashKey, 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    /**\n     * Base query key — the current page/sort is appended for cache isolation.\n     * Put the applied filters here: when the key changes structurally, the page\n     * goes back to 1 in the same render.\n     */\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; back to 1 on a new `queryKey`). */\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 * A structurally different `queryKey` (compared with TanStack's `hashKey`) is a\n * different result set, so the page returns to 1. The reset is applied during\n * render rather than in an effect: an effect would let one render go out with the\n * new key and the old page, and that render is a request — on page 7 of an\n * unfiltered list, applying a filter used to ask for page 7 of a two-page result\n * and show an empty table (#356).\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 keyHash = hashKey(queryKey);\n    const [paging, setPaging] = useState({ keyHash, page: initialPage });\n    if (paging.keyHash !== keyHash) setPaging({ keyHash, page: 1 });\n    const pageNumber = paging.keyHash === keyHash ? paging.page : 1;\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(\n        (next: number) => setPaging((s) => ({ ...s, page: Math.max(1, next) })),\n        [],\n    );\n    const next = useCallback(\n        () => setPaging((s) => (s.page < pageCount ? { ...s, page: s.page + 1 } : s)),\n        [pageCount],\n    );\n    const prev = useCallback(\n        () => setPaging((s) => (s.page > 1 ? { ...s, page: s.page - 1 } : s)),\n        [],\n    );\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":";;;AAmFA,SAAgB,EACZ,GAC0B;CAC1B,IAAM,EACF,aACA,YACA,iBAAc,GACd,cAAW,IACX,eAAY,QACZ,YACA,eAAY,IACZ,GAAG,MACH,GAEE,IAAU,EAAQ,CAAQ,GAC1B,CAAC,GAAQ,KAAa,EAAS;EAAE;EAAS,MAAM;CAAY,CAAC;CACnE,AAAI,EAAO,YAAY,KAAS,EAAU;EAAE;EAAS,MAAM;CAAE,CAAC;CAC9D,IAAM,IAAa,EAAO,YAAY,IAAU,EAAO,OAAO,GAExD,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,GACX,MAAiB,GAAW,OAAO;EAAE,GAAG;EAAG,MAAM,KAAK,IAAI,GAAG,CAAI;CAAE,EAAE,GACtE,CAAC,CACL,GACM,IAAO,QACH,GAAW,MAAO,EAAE,OAAO,IAAY;EAAE,GAAG;EAAG,MAAM,EAAE,OAAO;CAAE,IAAI,CAAE,GAC5E,CAAC,CAAS,CACd,GACM,IAAO,QACH,GAAW,MAAO,EAAE,OAAO,IAAI;EAAE,GAAG;EAAG,MAAM,EAAE,OAAO;CAAE,IAAI,CAAE,GACpE,CAAC,CACL;CAEA,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"}
+{"version":3,"file":"use-paginated-query.js","names":["usePaginatedQuery","queryOptions","options","keyHash","hashKey","queryKey","paging","setPaging","useState","initialPage","pageNumber","query","useQuery","params","sizeParam","pageSize","orderBy","ascending","queryFn","keepPreviousData","page","pageCount","hasNext","hasPrev","setPage","useCallback","s","next","prev"],"sources":["../../src/query/use-paginated-query.ts"],"sourcesContent":["import { useCallback, useState } from \"react\";\nimport { hashKey, 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    /**\n     * Base query key — the current page/sort is appended for cache isolation.\n     * Put the applied filters here: when the key changes structurally, the page\n     * goes back to 1 in the same render.\n     */\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; back to 1 on a new `queryKey`). */\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 * A structurally different `queryKey` (compared with TanStack's `hashKey`) is a\n * different result set, so the page returns to 1. The reset is applied during\n * render rather than in an effect: an effect would let one render go out with the\n * new key and the old page, and that render is a request — on page 7 of an\n * unfiltered list, applying a filter used to ask for page 7 of a two-page result\n * and show an empty table (#356).\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 keyHash = hashKey(queryKey);\n    const [paging, setPaging] = useState({ keyHash, page: initialPage });\n    if (paging.keyHash !== keyHash) setPaging({ keyHash, page: 1 });\n    const pageNumber = paging.keyHash === keyHash ? paging.page : 1;\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(\n        (next: number) => setPaging((s) => ({ ...s, page: Math.max(1, next) })),\n        [],\n    );\n    const next = useCallback(\n        () => setPaging((s) => (s.page < pageCount ? { ...s, page: s.page + 1 } : s)),\n        [pageCount],\n    );\n    const prev = useCallback(\n        () => setPaging((s) => (s.page > 1 ? { ...s, page: s.page - 1 } : s)),\n        [],\n    );\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":";;;AAmFA,SAAgBA,EACZ,GAC0B;CAC1B,IAAM,EACF,aACA,YACA,iBAAc,GACd,cAAW,IACX,eAAY,QACZ,YACA,eAAY,IACZ,GAAGC,MACHC,GAEEC,IAAUC,EAAQC,CAAQ,GAC1B,CAACC,GAAQC,KAAaC,EAAS;EAAE;EAAS,MAAMC;CAAY,CAAC;CACnE,AAAIH,EAAO,YAAYH,KAASI,EAAU;EAAE;EAAS,MAAM;CAAE,CAAC;CAC9D,IAAMG,IAAaJ,EAAO,YAAYH,IAAUG,EAAO,OAAO,GAExDK,IAAQC,EAA+B;EACzC,GAAGX;EACH,UAAU,CAAC,GAAGI,GAAU;GAAE,MAAMK;GAAY;GAAU;GAAW;GAAS;EAAU,CAAC;EACrF,eAAe;GACX,IAAMG,IAAuB;IAAE,MAAMH;KAAaI,IAAYC;GAAS;GAKvE,OAJIC,MACA,EAAO,WAAWA,GAClB,EAAO,YAAYC,IAEhBC,EAAQL,CAAM;EACzB;EACA,iBAAiBM;CACrB,CAAC,GAEKC,IAAOT,EAAM,MACbU,IAAYD,GAAM,SAAS,GAC3BE,IAAUZ,IAAaW,GACvBE,IAAUb,IAAa,GAEvBc,IAAUC,GACX,MAAiBlB,GAAW,OAAO;EAAE,GAAGmB;EAAG,MAAM,KAAK,IAAI,GAAGC,CAAI;CAAE,EAAE,GACtE,CAAC,CACL,GACMA,IAAOF,QACHlB,GAAW,MAAOmB,EAAE,OAAOL,IAAY;EAAE,GAAGK;EAAG,MAAMA,EAAE,OAAO;CAAE,IAAIA,CAAE,GAC5E,CAACL,CAAS,CACd,GACMO,IAAOH,QACHlB,GAAW,MAAOmB,EAAE,OAAO,IAAI;EAAE,GAAGA;EAAG,MAAMA,EAAE,OAAO;CAAE,IAAIA,CAAE,GACpE,CAAC,CACL;CAEA,OAAO;EACH;EACA,OAAON,GAAM,SAAS,CAAC;EACvB;EACA;EACA,OAAOA,GAAM,SAAS;EACtB;EACA;EACA,WAAWT,EAAM;EACjB,YAAYA,EAAM;EAClB,OAAOA,EAAM;EACb;EACA;EACA;EACA,eAAe,KAAKA,EAAM,QAAQ;CACtC;AACJ"}

package/dist/router/AppRouter.cjs.map

@@ -1 +1 @@
-{"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 { RouteGuardResult, 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\n/**\n * Runs one route's `guard` and renders the outcome.\n *\n * The guard is called during this component's render, which is what lets it\n * call hooks — `useCan` returning `{ allowed, isLoading }` maps straight onto\n * the three outcomes. See {@link guardKey} for why each guarded route gets its\n * own instance.\n */\nfunction GuardedElement({\n    guard,\n    guardFallback,\n    redirectTo,\n    children,\n}: {\n    guard: boolean | (() => RouteGuardResult);\n    guardFallback?: ReactNode;\n    redirectTo?: string;\n    children: ReactNode;\n}) {\n    const allowed = typeof guard === \"function\" ? guard() : guard;\n    return (\n        <RouteGuard when={allowed} fallback={guardFallback} redirectTo={redirectTo}>\n            {children}\n        </RouteGuard>\n    );\n}\n\nconst guardKeys = new WeakMap<TempestRouteObject, string>();\nlet guardKeySeq = 0;\n\n/**\n * A key unique to each route object, so React remounts `GuardedElement` when\n * the matched route changes instead of reusing the instance.\n *\n * Load-bearing once guards may call hooks. React Router renders the matched\n * route's element at the same position in the tree, so without a differing key\n * React reconciles two different routes onto the same `GuardedElement`\n * instance and the previous route's guard state survives into the next one's —\n * a guard reading `useState(\"from-a\")` still reads `\"from-a\"` after navigating\n * to a route whose guard initialises it to `\"from-b\"`. Path is not enough on\n * its own: two routes in different branches can share one.\n */\nfunction guardKey(route: TempestRouteObject): string {\n    let key = guardKeys.get(route);\n    if (!key) {\n        key = `guard-${++guardKeySeq}`;\n        guardKeys.set(route, key);\n    }\n    return key;\n}\n\nfunction toRouteElements(routes: TempestRouteObject[], fallback: ReactNode): 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\n                    key={guardKey(route)}\n                    guard={route.guard}\n                    guardFallback={route.guardFallback ?? fallback}\n                    redirectTo={route.redirectTo}\n                >\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, fallback) : 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    /**\n     * Suspense fallback shown while a `lazy` route chunk loads, and the default\n     * for a route whose `guard` answers `\"pending\"` — one spinner covers both\n     * kinds of \"not ready yet\". A route overrides it with its own\n     * `guardFallback`.\n     */\n    fallback?: ReactNode;\n}\n\n/**\n * Render a full React Router (v7 or v8, declarative mode) from a\n * {@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, fallback), [routes, fallback]);\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,CAUA,SAAS,EAAe,CACpB,QACA,gBACA,aACA,YAMD,CACC,IAAM,EAAU,OAAO,GAAU,WAAa,EAAM,EAAI,EACxD,OACI,EAAA,EAAA,IAAA,CAAC,EAAA,WAAD,CAAY,KAAM,EAAS,SAAU,EAA2B,aAC3D,UACO,CAAA,CAEpB,CAEA,IAAM,EAAY,IAAI,QAClB,EAAc,EAclB,SAAS,EAAS,EAAmC,CACjD,IAAI,EAAM,EAAU,IAAI,CAAK,EAK7B,OAJK,IACD,EAAM,SAAS,EAAE,IACjB,EAAU,IAAI,EAAO,CAAG,GAErB,CACX,CAEA,SAAS,EAAgB,EAA8B,EAAgC,CACnF,OAAO,EAAO,KAAK,EAAO,IAAM,CAC5B,IAAI,EAAqB,EAAM,QAC/B,GAAI,EAAM,KAAM,CACZ,IAAM,EAAgB,EAAY,CAAK,EACvC,GAAU,EAAA,EAAA,IAAA,CAAC,EAAD,CAAgB,CAAA,CAC9B,CAkBA,OAjBI,EAAM,QAAU,IAAA,KAChB,GACI,EAAA,EAAA,IAAA,CAAC,EAAD,CAEI,MAAO,EAAM,MACb,cAAe,EAAM,eAAiB,EACtC,WAAY,EAAM,WAEjB,SAAA,CACW,EANP,EAAS,CAAK,CAMP,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,cAEpB,SAAA,EAAM,SAAW,EAAgB,EAAM,SAAU,CAAQ,EAAI,IAC3D,EANE,EAAM,MAAQ,SAAS,GAMzB,CAEf,CAAC,CACL,CAEA,IAAM,EAAoD,CACtD,QAAS,EAAA,cACT,KAAM,EAAA,WACN,OAAQ,EAAA,YACZ,EA8BA,SAAgB,EAAU,CACtB,SACA,SAAS,UACT,WACA,iBACA,WAAW,MACI,CACf,IAAM,GAAA,EAAO,EAAA,QAAA,KAAc,EAAgB,EAAQ,CAAQ,EAAG,CAAC,EAAQ,CAAQ,CAAC,EAC1E,EAAS,EAAQ,GAGvB,OACI,EAAA,EAAA,IAAA,CAAC,EAAD,CAAQ,GAHQ,IAAW,SAAW,CAAE,WAAU,gBAAe,EAAI,CAAE,UAAS,EAI5E,UAAA,EAAA,EAAA,IAAA,CAAC,EAAA,SAAD,CAAoB,WAChB,UAAA,EAAA,EAAA,IAAA,CAAC,EAAA,OAAD,CAAA,SAAS,CAAa,CAAA,CAChB,CAAA,CACN,CAAA,CAEhB"}
+{"version":3,"file":"AppRouter.cjs","names":["lazyWithRetry","RouteGuard","Route","BrowserRouter","HashRouter","MemoryRouter","useMemo","Suspense","Routes","require_lazy_with_retry","require_RouteGuard","react","react_jsx_runtime","react_router","defineRoutes","routes","lazyCache","resolveLazy","comp","route","GuardedElement","allowed","guard","guardFallback","guardKeys","guardKeySeq","guardKey","key","toRouteElements","element","LazyComponent","fallback","i","ROUTERS","AppRouter","tree","Router","router"],"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 { RouteGuardResult, 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\n/**\n * Runs one route's `guard` and renders the outcome.\n *\n * The guard is called during this component's render, which is what lets it\n * call hooks — `useCan` returning `{ allowed, isLoading }` maps straight onto\n * the three outcomes. See {@link guardKey} for why each guarded route gets its\n * own instance.\n */\nfunction GuardedElement({\n    guard,\n    guardFallback,\n    redirectTo,\n    children,\n}: {\n    guard: boolean | (() => RouteGuardResult);\n    guardFallback?: ReactNode;\n    redirectTo?: string;\n    children: ReactNode;\n}) {\n    const allowed = typeof guard === \"function\" ? guard() : guard;\n    return (\n        <RouteGuard when={allowed} fallback={guardFallback} redirectTo={redirectTo}>\n            {children}\n        </RouteGuard>\n    );\n}\n\nconst guardKeys = new WeakMap<TempestRouteObject, string>();\nlet guardKeySeq = 0;\n\n/**\n * A key unique to each route object, so React remounts `GuardedElement` when\n * the matched route changes instead of reusing the instance.\n *\n * Load-bearing once guards may call hooks. React Router renders the matched\n * route's element at the same position in the tree, so without a differing key\n * React reconciles two different routes onto the same `GuardedElement`\n * instance and the previous route's guard state survives into the next one's —\n * a guard reading `useState(\"from-a\")` still reads `\"from-a\"` after navigating\n * to a route whose guard initialises it to `\"from-b\"`. Path is not enough on\n * its own: two routes in different branches can share one.\n */\nfunction guardKey(route: TempestRouteObject): string {\n    let key = guardKeys.get(route);\n    if (!key) {\n        key = `guard-${++guardKeySeq}`;\n        guardKeys.set(route, key);\n    }\n    return key;\n}\n\nfunction toRouteElements(routes: TempestRouteObject[], fallback: ReactNode): 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\n                    key={guardKey(route)}\n                    guard={route.guard}\n                    guardFallback={route.guardFallback ?? fallback}\n                    redirectTo={route.redirectTo}\n                >\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, fallback) : 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    /**\n     * Suspense fallback shown while a `lazy` route chunk loads, and the default\n     * for a route whose `guard` answers `\"pending\"` — one spinner covers both\n     * kinds of \"not ready yet\". A route overrides it with its own\n     * `guardFallback`.\n     */\n    fallback?: ReactNode;\n}\n\n/**\n * Render a full React Router (v7 or v8, declarative mode) from a\n * {@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, fallback), [routes, fallback]);\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":"A,6JAoBA,SAAgBc,EAAa,EAAoD,CAC7E,OAAOC,CACX,CAEA,IAAMC,EAAY,IAAI,QAEtB,SAASC,EAAY,EAAmD,CACpE,IAAIC,EAAOF,EAAU,IAAIG,CAAK,EAK9B,OAJKD,IACD,EAAOlB,EAAAA,cAAcmB,EAAM,IAAK,EAChCH,EAAU,IAAIG,EAAOD,CAAI,GAEtBA,CACX,CAUA,SAASE,EAAe,CACpB,QACA,gBACA,aACA,YAMD,CACC,IAAMC,EAAU,OAAOC,GAAU,WAAaA,EAAM,EAAIA,EACxD,OACI,EAAAV,EAAA,IAAA,CAACX,EAAAA,WAAD,CAAY,KAAMoB,EAAS,SAAUE,EAA2B,aAC3D,UACO,CAAA,CAEpB,CAEA,IAAMC,EAAY,IAAI,QAClBC,EAAc,EAclB,SAASC,EAAS,EAAmC,CACjD,IAAIC,EAAMH,EAAU,IAAIL,CAAK,EAK7B,OAJKQ,IACD,EAAM,SAAS,EAAEF,IACjBD,EAAU,IAAIL,EAAOQ,CAAG,GAErBA,CACX,CAEA,SAASC,EAAgB,EAA8B,EAAgC,CACnF,OAAOb,EAAO,KAAK,EAAO,IAAM,CAC5B,IAAIc,EAAqBV,EAAM,QAC/B,GAAIA,EAAM,KAAM,CACZ,IAAMW,EAAgBb,EAAYE,CAAK,EACvC,GAAU,EAAAP,EAAA,IAAA,CAACkB,EAAD,CAAgB,CAAA,CAC9B,CAkBA,OAjBIX,EAAM,QAAU,IAAA,KAChB,GACI,EAAAP,EAAA,IAAA,CAACQ,EAAD,CAEI,MAAOD,EAAM,MACb,cAAeA,EAAM,eAAiBY,EACtC,WAAYZ,EAAM,WAEjB,SAAAU,CACW,EANPH,EAASP,CAAK,CAMP,GAIpBA,EAAM,OACC,EAAAP,EAAA,IAAA,CAACV,EAAAA,MAAD,CAA0B,MAAA,GAAe,SAAU,EAAvC,SAAS8B,GAA8B,GAI1D,EAAApB,EAAA,IAAA,CAACV,EAAAA,MAAD,CAEI,KAAMiB,EAAM,KACH,UACT,cAAeA,EAAM,cAEpB,SAAAA,EAAM,SAAWS,EAAgBT,EAAM,SAAUY,CAAQ,EAAI,IAC3D,EANEZ,EAAM,MAAQ,SAASa,GAMzB,CAEf,CAAC,CACL,CAEA,IAAMC,EAAoD,CACtD,QAAS9B,EAAAA,cACT,KAAMC,EAAAA,WACN,OAAQC,EAAAA,YACZ,EA8BA,SAAgB6B,EAAU,CACtB,SACA,SAAS,UACT,WACA,iBACA,WAAW,MACI,CACf,IAAMC,GAAA,EAAO7B,EAAAA,QAAAA,KAAcsB,EAAgBb,EAAQgB,CAAQ,EAAG,CAAChB,EAAQgB,CAAQ,CAAC,EAC1EK,EAASH,EAAQI,GAGvB,OACI,EAAAzB,EAAA,IAAA,CAACwB,EAAD,CAAQ,GAHQC,IAAW,SAAW,CAAE,WAAU,gBAAe,EAAI,CAAE,UAAS,EAI5E,UAAA,EAAAzB,EAAA,IAAA,CAACL,EAAAA,SAAD,CAAoB,WAChB,UAAA,EAAAK,EAAA,IAAA,CAACJ,EAAAA,OAAD,CAAA,SAAS2B,CAAa,CAAA,CAChB,CAAA,CACN,CAAA,CAEhB,C"}

package/dist/router/AppRouter.js.map

@@ -1 +1 @@
-{"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 { RouteGuardResult, 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\n/**\n * Runs one route's `guard` and renders the outcome.\n *\n * The guard is called during this component's render, which is what lets it\n * call hooks — `useCan` returning `{ allowed, isLoading }` maps straight onto\n * the three outcomes. See {@link guardKey} for why each guarded route gets its\n * own instance.\n */\nfunction GuardedElement({\n    guard,\n    guardFallback,\n    redirectTo,\n    children,\n}: {\n    guard: boolean | (() => RouteGuardResult);\n    guardFallback?: ReactNode;\n    redirectTo?: string;\n    children: ReactNode;\n}) {\n    const allowed = typeof guard === \"function\" ? guard() : guard;\n    return (\n        <RouteGuard when={allowed} fallback={guardFallback} redirectTo={redirectTo}>\n            {children}\n        </RouteGuard>\n    );\n}\n\nconst guardKeys = new WeakMap<TempestRouteObject, string>();\nlet guardKeySeq = 0;\n\n/**\n * A key unique to each route object, so React remounts `GuardedElement` when\n * the matched route changes instead of reusing the instance.\n *\n * Load-bearing once guards may call hooks. React Router renders the matched\n * route's element at the same position in the tree, so without a differing key\n * React reconciles two different routes onto the same `GuardedElement`\n * instance and the previous route's guard state survives into the next one's —\n * a guard reading `useState(\"from-a\")` still reads `\"from-a\"` after navigating\n * to a route whose guard initialises it to `\"from-b\"`. Path is not enough on\n * its own: two routes in different branches can share one.\n */\nfunction guardKey(route: TempestRouteObject): string {\n    let key = guardKeys.get(route);\n    if (!key) {\n        key = `guard-${++guardKeySeq}`;\n        guardKeys.set(route, key);\n    }\n    return key;\n}\n\nfunction toRouteElements(routes: TempestRouteObject[], fallback: ReactNode): 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\n                    key={guardKey(route)}\n                    guard={route.guard}\n                    guardFallback={route.guardFallback ?? fallback}\n                    redirectTo={route.redirectTo}\n                >\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, fallback) : 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    /**\n     * Suspense fallback shown while a `lazy` route chunk loads, and the default\n     * for a route whose `guard` answers `\"pending\"` — one spinner covers both\n     * kinds of \"not ready yet\". A route overrides it with its own\n     * `guardFallback`.\n     */\n    fallback?: ReactNode;\n}\n\n/**\n * Render a full React Router (v7 or v8, declarative mode) from a\n * {@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, fallback), [routes, fallback]);\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;AAUA,SAAS,EAAe,EACpB,UACA,kBACA,eACA,eAMD;CACC,IAAM,IAAU,OAAO,KAAU,aAAa,EAAM,IAAI;CACxD,OACI,kBAAC,GAAD;EAAY,MAAM;EAAS,UAAU;EAA2B;EAC3D;CACO,CAAA;AAEpB;AAEA,IAAM,oBAAY,IAAI,QAAoC,GACtD,IAAc;AAclB,SAAS,EAAS,GAAmC;CACjD,IAAI,IAAM,EAAU,IAAI,CAAK;CAK7B,OAJK,MACD,IAAM,SAAS,EAAE,KACjB,EAAU,IAAI,GAAO,CAAG,IAErB;AACX;AAEA,SAAS,EAAgB,GAA8B,GAAgC;CACnF,OAAO,EAAO,KAAK,GAAO,MAAM;EAC5B,IAAI,IAAqB,EAAM;EAC/B,IAAI,EAAM,MAAM;GACZ,IAAM,IAAgB,EAAY,CAAK;GACvC,IAAU,kBAAC,GAAD,CAAgB,CAAA;EAC9B;EAkBA,OAjBI,EAAM,UAAU,KAAA,MAChB,IACI,kBAAC,GAAD;GAEI,OAAO,EAAM;GACb,eAAe,EAAM,iBAAiB;GACtC,YAAY,EAAM;GAEjB,UAAA;EACW,GANP,EAAS,CAAK,CAMP,IAIpB,EAAM,QACC,kBAAC,GAAD;GAA0B,OAAA;GAAe;EAAU,GAAvC,SAAS,GAA8B,IAI1D,kBAAC,GAAD;GAEI,MAAM,EAAM;GACH;GACT,eAAe,EAAM;GAEpB,UAAA,EAAM,WAAW,EAAgB,EAAM,UAAU,CAAQ,IAAI;EAC3D,GANE,EAAM,QAAQ,SAAS,GAMzB;CAEf,CAAC;AACL;AAEA,IAAM,IAAoD;CACtD,SAAS;CACT,MAAM;CACN,QAAQ;AACZ;AA8BA,SAAgB,EAAU,EACtB,WACA,YAAS,WACT,aACA,mBACA,cAAW,QACI;CACf,IAAM,IAAO,QAAc,EAAgB,GAAQ,CAAQ,GAAG,CAAC,GAAQ,CAAQ,CAAC,GAC1E,IAAS,EAAQ;CAGvB,OACI,kBAAC,GAAD;EAAQ,GAHQ,MAAW,WAAW;GAAE;GAAU;EAAe,IAAI,EAAE,YAAS;EAI5E,UAAA,kBAAC,GAAD;GAAoB;GAChB,UAAA,kBAAC,GAAD,EAAA,UAAS,EAAa,CAAA;EAChB,CAAA;CACN,CAAA;AAEhB"}
+{"version":3,"file":"AppRouter.js","names":["defineRoutes","routes","lazyCache","resolveLazy","comp","route","lazyWithRetry","GuardedElement","allowed","guard","RouteGuard","guardFallback","guardKeys","guardKeySeq","guardKey","key","toRouteElements","element","LazyComponent","fallback","Route","i","ROUTERS","BrowserRouter","HashRouter","MemoryRouter","AppRouter","tree","useMemo","Router","router","Suspense","Routes"],"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 { RouteGuardResult, 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\n/**\n * Runs one route's `guard` and renders the outcome.\n *\n * The guard is called during this component's render, which is what lets it\n * call hooks — `useCan` returning `{ allowed, isLoading }` maps straight onto\n * the three outcomes. See {@link guardKey} for why each guarded route gets its\n * own instance.\n */\nfunction GuardedElement({\n    guard,\n    guardFallback,\n    redirectTo,\n    children,\n}: {\n    guard: boolean | (() => RouteGuardResult);\n    guardFallback?: ReactNode;\n    redirectTo?: string;\n    children: ReactNode;\n}) {\n    const allowed = typeof guard === \"function\" ? guard() : guard;\n    return (\n        <RouteGuard when={allowed} fallback={guardFallback} redirectTo={redirectTo}>\n            {children}\n        </RouteGuard>\n    );\n}\n\nconst guardKeys = new WeakMap<TempestRouteObject, string>();\nlet guardKeySeq = 0;\n\n/**\n * A key unique to each route object, so React remounts `GuardedElement` when\n * the matched route changes instead of reusing the instance.\n *\n * Load-bearing once guards may call hooks. React Router renders the matched\n * route's element at the same position in the tree, so without a differing key\n * React reconciles two different routes onto the same `GuardedElement`\n * instance and the previous route's guard state survives into the next one's —\n * a guard reading `useState(\"from-a\")` still reads `\"from-a\"` after navigating\n * to a route whose guard initialises it to `\"from-b\"`. Path is not enough on\n * its own: two routes in different branches can share one.\n */\nfunction guardKey(route: TempestRouteObject): string {\n    let key = guardKeys.get(route);\n    if (!key) {\n        key = `guard-${++guardKeySeq}`;\n        guardKeys.set(route, key);\n    }\n    return key;\n}\n\nfunction toRouteElements(routes: TempestRouteObject[], fallback: ReactNode): 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\n                    key={guardKey(route)}\n                    guard={route.guard}\n                    guardFallback={route.guardFallback ?? fallback}\n                    redirectTo={route.redirectTo}\n                >\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, fallback) : 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    /**\n     * Suspense fallback shown while a `lazy` route chunk loads, and the default\n     * for a route whose `guard` answers `\"pending\"` — one spinner covers both\n     * kinds of \"not ready yet\". A route overrides it with its own\n     * `guardFallback`.\n     */\n    fallback?: ReactNode;\n}\n\n/**\n * Render a full React Router (v7 or v8, declarative mode) from a\n * {@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, fallback), [routes, fallback]);\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,SAAgBA,EAAa,GAAoD;CAC7E,OAAOC;AACX;AAEA,IAAMC,oBAAY,IAAI,QAAoD;AAE1E,SAASC,EAAY,GAAmD;CACpE,IAAIC,IAAOF,EAAU,IAAIG,CAAK;CAK9B,OAJKD,MACD,IAAOE,EAAcD,EAAM,IAAK,GAChCH,EAAU,IAAIG,GAAOD,CAAI,IAEtBA;AACX;AAUA,SAASG,EAAe,EACpB,UACA,kBACA,eACA,eAMD;CACC,IAAMC,IAAU,OAAOC,KAAU,aAAaA,EAAM,IAAIA;CACxD,OACI,kBAACC,GAAD;EAAY,MAAMF;EAAS,UAAUG;EAA2B;EAC3D;CACO,CAAA;AAEpB;AAEA,IAAMC,oBAAY,IAAI,QAAoC,GACtDC,IAAc;AAclB,SAASC,EAAS,GAAmC;CACjD,IAAIC,IAAMH,EAAU,IAAIP,CAAK;CAK7B,OAJKU,MACD,IAAM,SAAS,EAAEF,KACjBD,EAAU,IAAIP,GAAOU,CAAG,IAErBA;AACX;AAEA,SAASC,EAAgB,GAA8B,GAAgC;CACnF,OAAOf,EAAO,KAAK,GAAO,MAAM;EAC5B,IAAIgB,IAAqBZ,EAAM;EAC/B,IAAIA,EAAM,MAAM;GACZ,IAAMa,IAAgBf,EAAYE,CAAK;GACvC,IAAU,kBAACa,GAAD,CAAgB,CAAA;EAC9B;EAkBA,OAjBIb,EAAM,UAAU,KAAA,MAChB,IACI,kBAACE,GAAD;GAEI,OAAOF,EAAM;GACb,eAAeA,EAAM,iBAAiBc;GACtC,YAAYd,EAAM;GAEjB,UAAAY;EACW,GANPH,EAAST,CAAK,CAMP,IAIpBA,EAAM,QACC,kBAACe,GAAD;GAA0B,OAAA;GAAe;EAAU,GAAvC,SAASC,GAA8B,IAI1D,kBAACD,GAAD;GAEI,MAAMf,EAAM;GACH;GACT,eAAeA,EAAM;GAEpB,UAAAA,EAAM,WAAWW,EAAgBX,EAAM,UAAUc,CAAQ,IAAI;EAC3D,GANEd,EAAM,QAAQ,SAASgB,GAMzB;CAEf,CAAC;AACL;AAEA,IAAMC,IAAoD;CACtD,SAASC;CACT,MAAMC;CACN,QAAQC;AACZ;AA8BA,SAAgBC,EAAU,EACtB,WACA,YAAS,WACT,aACA,mBACA,cAAW,QACI;CACf,IAAMC,IAAOC,QAAcZ,EAAgBf,GAAQkB,CAAQ,GAAG,CAAClB,GAAQkB,CAAQ,CAAC,GAC1EU,IAASP,EAAQQ;CAGvB,OACI,kBAACD,GAAD;EAAQ,GAHQC,MAAW,WAAW;GAAE;GAAU;EAAe,IAAI,EAAE,YAAS;EAI5E,UAAA,kBAACC,GAAD;GAAoB;GAChB,UAAA,kBAACC,GAAD,EAAA,UAASL,EAAa,CAAA;EAChB,CAAA;CACN,CAAA;AAEhB"}

package/dist/router/RouteGuard.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"RouteGuard.cjs","names":[],"sources":["../../src/router/RouteGuard.tsx"],"sourcesContent":["import type { ReactNode } from \"react\";\nimport { Navigate } from \"react-router\";\nimport type { RouteGuardResult } from \"./types\";\n\nexport interface RouteGuardProps {\n    /**\n     * Whether access is allowed — typically\n     * `useAuthStore((s) => s.isAuthenticated)`.\n     *\n     * `\"pending\"` is the third answer, for a permission that has not resolved\n     * yet: it holds the decision and renders {@link fallback} instead of\n     * choosing between two wrong moves — redirecting someone who does have\n     * access, or showing the screen to someone who does not.\n     */\n    when: RouteGuardResult;\n    /**\n     * Rendered while `when` is `\"pending\"`. Defaults to nothing, which is a\n     * blank screen — pass the same spinner the rest of the app uses.\n     */\n    fallback?: ReactNode;\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 `true`, redirects when it is `false`, and holds on\n * `\"pending\"`. Pairs naturally with `createAuthStore` for protected areas, and\n * with `useCan` for permissions that resolve over the network.\n *\n * @example\n * <RouteGuard when={useAuthStore((s) => s.isAuthenticated)} redirectTo=\"/login\">\n *     <Outlet />\n * </RouteGuard>\n *\n * @example\n * const { allowed, isLoading } = useCan({ action: \"read\", resource: \"finance\" });\n *\n * <RouteGuard when={isLoading ? \"pending\" : allowed} fallback={<Spinner />}>\n *     <Outlet />\n * </RouteGuard>\n */\nexport function RouteGuard({\n    when,\n    fallback = null,\n    redirectTo = \"/\",\n    replace = true,\n    children,\n}: RouteGuardProps) {\n    if (when === \"pending\") return <>{fallback}</>;\n    return <>{when ? children : <Navigate to={redirectTo} replace={replace} />}</>;\n}\n"],"mappings":"6DA8CA,SAAgB,EAAW,CACvB,OACA,WAAW,KACX,aAAa,IACb,UAAU,GACV,YACgB,CAEhB,OADI,IAAS,WAAkB,EAAA,EAAA,IAAA,CAAA,EAAA,SAAA,CAAA,SAAG,CAAW,CAAA,GACtC,EAAA,EAAA,IAAA,CAAA,EAAA,SAAA,CAAA,SAAG,EAAO,GAAW,EAAA,EAAA,IAAA,CAAC,EAAA,SAAD,CAAU,GAAI,EAAqB,SAAU,CAAA,CAAI,CAAA,CACjF"}
+{"version":3,"file":"RouteGuard.cjs","names":["_Fragment","Navigate","react_jsx_runtime","react_router","RouteGuard","when","fallback","children","redirectTo"],"sources":["../../src/router/RouteGuard.tsx"],"sourcesContent":["import type { ReactNode } from \"react\";\nimport { Navigate } from \"react-router\";\nimport type { RouteGuardResult } from \"./types\";\n\nexport interface RouteGuardProps {\n    /**\n     * Whether access is allowed — typically\n     * `useAuthStore((s) => s.isAuthenticated)`.\n     *\n     * `\"pending\"` is the third answer, for a permission that has not resolved\n     * yet: it holds the decision and renders {@link fallback} instead of\n     * choosing between two wrong moves — redirecting someone who does have\n     * access, or showing the screen to someone who does not.\n     */\n    when: RouteGuardResult;\n    /**\n     * Rendered while `when` is `\"pending\"`. Defaults to nothing, which is a\n     * blank screen — pass the same spinner the rest of the app uses.\n     */\n    fallback?: ReactNode;\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 `true`, redirects when it is `false`, and holds on\n * `\"pending\"`. Pairs naturally with `createAuthStore` for protected areas, and\n * with `useCan` for permissions that resolve over the network.\n *\n * @example\n * <RouteGuard when={useAuthStore((s) => s.isAuthenticated)} redirectTo=\"/login\">\n *     <Outlet />\n * </RouteGuard>\n *\n * @example\n * const { allowed, isLoading } = useCan({ action: \"read\", resource: \"finance\" });\n *\n * <RouteGuard when={isLoading ? \"pending\" : allowed} fallback={<Spinner />}>\n *     <Outlet />\n * </RouteGuard>\n */\nexport function RouteGuard({\n    when,\n    fallback = null,\n    redirectTo = \"/\",\n    replace = true,\n    children,\n}: RouteGuardProps) {\n    if (when === \"pending\") return <>{fallback}</>;\n    return <>{when ? children : <Navigate to={redirectTo} replace={replace} />}</>;\n}\n"],"mappings":"A,6DA8CA,SAAgBI,EAAW,CACvB,OACA,WAAW,KACX,aAAa,IACb,UAAU,GACV,YACgB,CAEhB,OADIC,IAAS,WAAkB,EAAAH,EAAA,IAAA,CAAAF,EAAAA,SAAA,CAAA,SAAGM,CAAW,CAAA,GACtC,EAAAJ,EAAA,IAAA,CAAAF,EAAAA,SAAA,CAAA,SAAGK,EAAOE,GAAW,EAAAL,EAAA,IAAA,CAACD,EAAAA,SAAD,CAAU,GAAIO,EAAqB,SAAU,CAAA,CAAI,CAAA,CACjF,C"}

package/dist/router/RouteGuard.js.map

@@ -1 +1 @@
-{"version":3,"file":"RouteGuard.js","names":[],"sources":["../../src/router/RouteGuard.tsx"],"sourcesContent":["import type { ReactNode } from \"react\";\nimport { Navigate } from \"react-router\";\nimport type { RouteGuardResult } from \"./types\";\n\nexport interface RouteGuardProps {\n    /**\n     * Whether access is allowed — typically\n     * `useAuthStore((s) => s.isAuthenticated)`.\n     *\n     * `\"pending\"` is the third answer, for a permission that has not resolved\n     * yet: it holds the decision and renders {@link fallback} instead of\n     * choosing between two wrong moves — redirecting someone who does have\n     * access, or showing the screen to someone who does not.\n     */\n    when: RouteGuardResult;\n    /**\n     * Rendered while `when` is `\"pending\"`. Defaults to nothing, which is a\n     * blank screen — pass the same spinner the rest of the app uses.\n     */\n    fallback?: ReactNode;\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 `true`, redirects when it is `false`, and holds on\n * `\"pending\"`. Pairs naturally with `createAuthStore` for protected areas, and\n * with `useCan` for permissions that resolve over the network.\n *\n * @example\n * <RouteGuard when={useAuthStore((s) => s.isAuthenticated)} redirectTo=\"/login\">\n *     <Outlet />\n * </RouteGuard>\n *\n * @example\n * const { allowed, isLoading } = useCan({ action: \"read\", resource: \"finance\" });\n *\n * <RouteGuard when={isLoading ? \"pending\" : allowed} fallback={<Spinner />}>\n *     <Outlet />\n * </RouteGuard>\n */\nexport function RouteGuard({\n    when,\n    fallback = null,\n    redirectTo = \"/\",\n    replace = true,\n    children,\n}: RouteGuardProps) {\n    if (when === \"pending\") return <>{fallback}</>;\n    return <>{when ? children : <Navigate to={redirectTo} replace={replace} />}</>;\n}\n"],"mappings":";;;AA8CA,SAAgB,EAAW,EACvB,SACA,cAAW,MACX,gBAAa,KACb,aAAU,IACV,eACgB;CAEhB,OADI,MAAS,YAAkB,kBAAA,GAAA,EAAA,UAAG,EAAW,CAAA,IACtC,kBAAA,GAAA,EAAA,UAAG,IAAO,IAAW,kBAAC,GAAD;EAAU,IAAI;EAAqB;CAAU,CAAA,EAAI,CAAA;AACjF"}
+{"version":3,"file":"RouteGuard.js","names":["_Fragment","RouteGuard","when","Fragment","fallback","children","Navigate","redirectTo"],"sources":["../../src/router/RouteGuard.tsx"],"sourcesContent":["import type { ReactNode } from \"react\";\nimport { Navigate } from \"react-router\";\nimport type { RouteGuardResult } from \"./types\";\n\nexport interface RouteGuardProps {\n    /**\n     * Whether access is allowed — typically\n     * `useAuthStore((s) => s.isAuthenticated)`.\n     *\n     * `\"pending\"` is the third answer, for a permission that has not resolved\n     * yet: it holds the decision and renders {@link fallback} instead of\n     * choosing between two wrong moves — redirecting someone who does have\n     * access, or showing the screen to someone who does not.\n     */\n    when: RouteGuardResult;\n    /**\n     * Rendered while `when` is `\"pending\"`. Defaults to nothing, which is a\n     * blank screen — pass the same spinner the rest of the app uses.\n     */\n    fallback?: ReactNode;\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 `true`, redirects when it is `false`, and holds on\n * `\"pending\"`. Pairs naturally with `createAuthStore` for protected areas, and\n * with `useCan` for permissions that resolve over the network.\n *\n * @example\n * <RouteGuard when={useAuthStore((s) => s.isAuthenticated)} redirectTo=\"/login\">\n *     <Outlet />\n * </RouteGuard>\n *\n * @example\n * const { allowed, isLoading } = useCan({ action: \"read\", resource: \"finance\" });\n *\n * <RouteGuard when={isLoading ? \"pending\" : allowed} fallback={<Spinner />}>\n *     <Outlet />\n * </RouteGuard>\n */\nexport function RouteGuard({\n    when,\n    fallback = null,\n    redirectTo = \"/\",\n    replace = true,\n    children,\n}: RouteGuardProps) {\n    if (when === \"pending\") return <>{fallback}</>;\n    return <>{when ? children : <Navigate to={redirectTo} replace={replace} />}</>;\n}\n"],"mappings":";;;AA8CA,SAAgBC,EAAW,EACvB,SACA,cAAW,MACX,gBAAa,KACb,aAAU,IACV,eACgB;CAEhB,OADIC,MAAS,YAAkB,kBAAAF,GAAA,EAAA,UAAGI,EAAW,CAAA,IACtC,kBAAAJ,GAAA,EAAA,UAAGE,IAAOG,IAAW,kBAACC,GAAD;EAAU,IAAIC;EAAqB;CAAU,CAAA,EAAI,CAAA;AACjF"}

package/dist/router/index.js

@@ -1,4 +1,4 @@
 import { RouteGuard as e } from "./RouteGuard.js";
 import { AppRouter as t, defineRoutes as n } from "./AppRouter.js";
-import { BrowserRouter as r, HashRouter as i, Link as a, MemoryRouter as o, NavLink as s, Navigate as c, Outlet as l, Route as u, Routes as d, redirect as f, useLocation as p, useMatch as m, useNavigate as h, useParams as g, useRouteError as _, useSearchParams as v } from "react-router";
-export { t as AppRouter, r as BrowserRouter, i as HashRouter, a as Link, o as MemoryRouter, s as NavLink, c as Navigate, l as Outlet, u as Route, e as RouteGuard, d as Routes, n as defineRoutes, f as redirect, p as useLocation, m as useMatch, h as useNavigate, g as useParams, _ as useRouteError, v as useSearchParams };
+import { Await as r, BrowserRouter as i, Form as a, HashRouter as o, IDLE_BLOCKER as s, IDLE_FETCHER as c, IDLE_NAVIGATION as l, Link as u, MemoryRouter as d, NavLink as f, Navigate as p, NavigationType as m, Outlet as h, Route as g, Router as _, RouterProvider as v, Routes as y, ScrollRestoration as b, createBrowserRouter as x, createHashRouter as S, createMemoryRouter as C, createPath as w, createRoutesFromChildren as T, createRoutesFromElements as E, createSearchParams as D, data as O, generatePath as k, isRouteErrorResponse as A, matchPath as j, matchRoutes as M, parsePath as N, redirect as P, redirectDocument as F, renderMatches as I, replace as L, resolvePath as R, useActionData as z, useAsyncError as B, useAsyncValue as V, useBeforeUnload as H, useBlocker as U, useFetcher as W, useFetchers as G, useFormAction as K, useHref as q, useInRouterContext as J, useLinkClickHandler as Y, useLoaderData as X, useLocation as Z, useMatch as Q, useMatches as $, useNavigate as ee, useNavigation as te, useNavigationType as ne, useOutlet as re, useOutletContext as ie, useParams as ae, useResolvedPath as oe, useRevalidator as se, useRouteError as ce, useRouteLoaderData as le, useRoutes as ue, useSearchParams as de, useSubmit as fe, useViewTransitionState as pe } from "react-router";
+export { t as AppRouter, r as Await, i as BrowserRouter, o as HashRouter, s as IDLE_BLOCKER, c as IDLE_FETCHER, l as IDLE_NAVIGATION, u as Link, d as MemoryRouter, f as NavLink, p as Navigate, m as NavigationType, h as Outlet, g as Route, e as RouteGuard, _ as Router, a as RouterForm, v as RouterProvider, y as Routes, b as ScrollRestoration, x as createBrowserRouter, S as createHashRouter, C as createMemoryRouter, w as createPath, T as createRoutesFromChildren, E as createRoutesFromElements, D as createSearchParams, O as data, n as defineRoutes, k as generatePath, A as isRouteErrorResponse, j as matchPath, M as matchRoutes, N as parsePath, P as redirect, F as redirectDocument, I as renderMatches, L as replace, R as resolvePath, z as useActionData, B as useAsyncError, V as useAsyncValue, H as useBeforeUnload, U as useBlocker, W as useFetcher, G as useFetchers, K as useFormAction, q as useHref, J as useInRouterContext, Y as useLinkClickHandler, X as useLoaderData, Z as useLocation, Q as useMatch, $ as useMatches, ee as useNavigate, te as useNavigation, ne as useNavigationType, re as useOutlet, ie as useOutletContext, ae as useParams, oe as useResolvedPath, se as useRevalidator, ce as useRouteError, le as useRouteLoaderData, ue as useRoutes, de as useSearchParams, fe as useSubmit, pe as useViewTransitionState };

package/dist/share/share-or-download.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"share-or-download.cjs","names":[],"sources":["../../src/share/share-or-download.ts"],"sourcesContent":["import { share } from \"./share\";\n\n/** Options for {@link shareOrDownloadBlob}. */\nexport interface ShareOrDownloadOptions {\n    /** Title passed to the Web Share dialog. Defaults to the file name. */\n    title?: string;\n}\n\n/**\n * Try the Web Share API with the given `Blob` as a file; fall back to a\n * download anchor when the browser cannot share files (desktop Firefox, older\n * iOS Safari, etc.).\n *\n * A companion to {@link share} for the common \"export a generated artifact\"\n * flow: on mobile it opens the native share sheet, and everywhere else it\n * triggers a plain download. Returns early when the user shares or cancels the\n * dialog; otherwise it downloads.\n *\n * @param blob - The binary payload to share or download.\n * @param fileName - The file name presented to the user.\n * @param options - Optional `title` for the share dialog.\n * @returns A promise that resolves once the share or download completes.\n *\n * @example\n * const zip = new Blob([bytes], { type: \"application/zip\" });\n * await shareOrDownloadBlob(zip, \"export.zip\");\n */\nexport async function shareOrDownloadBlob(\n    blob: Blob,\n    fileName: string,\n    options: ShareOrDownloadOptions = {},\n): Promise<void> {\n    const file = new File([blob], fileName, { type: blob.type });\n    const result = await share({ title: options.title ?? fileName, files: [file] });\n    if (result.shared || result.cancelled) return;\n\n    const url = URL.createObjectURL(blob);\n    const anchor = document.createElement(\"a\");\n    anchor.href = url;\n    anchor.download = fileName;\n    document.body.appendChild(anchor);\n    anchor.click();\n    anchor.remove();\n    URL.revokeObjectURL(url);\n}\n"],"mappings":"+BA2BA,eAAsB,EAClB,EACA,EACA,EAAkC,CAAC,EACtB,CACb,IAAM,EAAO,IAAI,KAAK,CAAC,CAAI,EAAG,EAAU,CAAE,KAAM,EAAK,IAAK,CAAC,EACrD,EAAS,MAAM,EAAA,MAAM,CAAE,MAAO,EAAQ,OAAS,EAAU,MAAO,CAAC,CAAI,CAAE,CAAC,EAC9E,GAAI,EAAO,QAAU,EAAO,UAAW,OAEvC,IAAM,EAAM,IAAI,gBAAgB,CAAI,EAC9B,EAAS,SAAS,cAAc,GAAG,EACzC,EAAO,KAAO,EACd,EAAO,SAAW,EAClB,SAAS,KAAK,YAAY,CAAM,EAChC,EAAO,MAAM,EACb,EAAO,OAAO,EACd,IAAI,gBAAgB,CAAG,CAC3B"}
+{"version":3,"file":"share-or-download.cjs","names":["share","require_share","shareOrDownloadBlob","file","blob","fileName","result","options","url","anchor"],"sources":["../../src/share/share-or-download.ts"],"sourcesContent":["import { share } from \"./share\";\n\n/** Options for {@link shareOrDownloadBlob}. */\nexport interface ShareOrDownloadOptions {\n    /** Title passed to the Web Share dialog. Defaults to the file name. */\n    title?: string;\n}\n\n/**\n * Try the Web Share API with the given `Blob` as a file; fall back to a\n * download anchor when the browser cannot share files (desktop Firefox, older\n * iOS Safari, etc.).\n *\n * A companion to {@link share} for the common \"export a generated artifact\"\n * flow: on mobile it opens the native share sheet, and everywhere else it\n * triggers a plain download. Returns early when the user shares or cancels the\n * dialog; otherwise it downloads.\n *\n * @param blob - The binary payload to share or download.\n * @param fileName - The file name presented to the user.\n * @param options - Optional `title` for the share dialog.\n * @returns A promise that resolves once the share or download completes.\n *\n * @example\n * const zip = new Blob([bytes], { type: \"application/zip\" });\n * await shareOrDownloadBlob(zip, \"export.zip\");\n */\nexport async function shareOrDownloadBlob(\n    blob: Blob,\n    fileName: string,\n    options: ShareOrDownloadOptions = {},\n): Promise<void> {\n    const file = new File([blob], fileName, { type: blob.type });\n    const result = await share({ title: options.title ?? fileName, files: [file] });\n    if (result.shared || result.cancelled) return;\n\n    const url = URL.createObjectURL(blob);\n    const anchor = document.createElement(\"a\");\n    anchor.href = url;\n    anchor.download = fileName;\n    document.body.appendChild(anchor);\n    anchor.click();\n    anchor.remove();\n    URL.revokeObjectURL(url);\n}\n"],"mappings":"A,+BA2BA,eAAsBE,EAClB,EACA,EACA,EAAkC,CAAC,EACtB,CACb,IAAMC,EAAO,IAAI,KAAK,CAACC,CAAI,EAAGC,EAAU,CAAE,KAAMD,EAAK,IAAK,CAAC,EACrDE,EAAS,MAAMN,EAAAA,MAAM,CAAE,MAAOO,EAAQ,OAASF,EAAU,MAAO,CAACF,CAAI,CAAE,CAAC,EAC9E,GAAIG,EAAO,QAAUA,EAAO,UAAW,OAEvC,IAAME,EAAM,IAAI,gBAAgBJ,CAAI,EAC9BK,EAAS,SAAS,cAAc,GAAG,EACzC,EAAO,KAAOD,EACd,EAAO,SAAWH,EAClB,SAAS,KAAK,YAAYI,CAAM,EAChCA,EAAO,MAAM,EACbA,EAAO,OAAO,EACd,IAAI,gBAAgBD,CAAG,CAC3B,C"}

package/dist/share/share-or-download.js.map

@@ -1 +1 @@
-{"version":3,"file":"share-or-download.js","names":[],"sources":["../../src/share/share-or-download.ts"],"sourcesContent":["import { share } from \"./share\";\n\n/** Options for {@link shareOrDownloadBlob}. */\nexport interface ShareOrDownloadOptions {\n    /** Title passed to the Web Share dialog. Defaults to the file name. */\n    title?: string;\n}\n\n/**\n * Try the Web Share API with the given `Blob` as a file; fall back to a\n * download anchor when the browser cannot share files (desktop Firefox, older\n * iOS Safari, etc.).\n *\n * A companion to {@link share} for the common \"export a generated artifact\"\n * flow: on mobile it opens the native share sheet, and everywhere else it\n * triggers a plain download. Returns early when the user shares or cancels the\n * dialog; otherwise it downloads.\n *\n * @param blob - The binary payload to share or download.\n * @param fileName - The file name presented to the user.\n * @param options - Optional `title` for the share dialog.\n * @returns A promise that resolves once the share or download completes.\n *\n * @example\n * const zip = new Blob([bytes], { type: \"application/zip\" });\n * await shareOrDownloadBlob(zip, \"export.zip\");\n */\nexport async function shareOrDownloadBlob(\n    blob: Blob,\n    fileName: string,\n    options: ShareOrDownloadOptions = {},\n): Promise<void> {\n    const file = new File([blob], fileName, { type: blob.type });\n    const result = await share({ title: options.title ?? fileName, files: [file] });\n    if (result.shared || result.cancelled) return;\n\n    const url = URL.createObjectURL(blob);\n    const anchor = document.createElement(\"a\");\n    anchor.href = url;\n    anchor.download = fileName;\n    document.body.appendChild(anchor);\n    anchor.click();\n    anchor.remove();\n    URL.revokeObjectURL(url);\n}\n"],"mappings":";;AA2BA,eAAsB,EAClB,GACA,GACA,IAAkC,CAAC,GACtB;CACb,IAAM,IAAO,IAAI,KAAK,CAAC,CAAI,GAAG,GAAU,EAAE,MAAM,EAAK,KAAK,CAAC,GACrD,IAAS,MAAM,EAAM;EAAE,OAAO,EAAQ,SAAS;EAAU,OAAO,CAAC,CAAI;CAAE,CAAC;CAC9E,IAAI,EAAO,UAAU,EAAO,WAAW;CAEvC,IAAM,IAAM,IAAI,gBAAgB,CAAI,GAC9B,IAAS,SAAS,cAAc,GAAG;CAMzC,AALA,EAAO,OAAO,GACd,EAAO,WAAW,GAClB,SAAS,KAAK,YAAY,CAAM,GAChC,EAAO,MAAM,GACb,EAAO,OAAO,GACd,IAAI,gBAAgB,CAAG;AAC3B"}
+{"version":3,"file":"share-or-download.js","names":["shareOrDownloadBlob","file","blob","fileName","result","share","options","url","anchor"],"sources":["../../src/share/share-or-download.ts"],"sourcesContent":["import { share } from \"./share\";\n\n/** Options for {@link shareOrDownloadBlob}. */\nexport interface ShareOrDownloadOptions {\n    /** Title passed to the Web Share dialog. Defaults to the file name. */\n    title?: string;\n}\n\n/**\n * Try the Web Share API with the given `Blob` as a file; fall back to a\n * download anchor when the browser cannot share files (desktop Firefox, older\n * iOS Safari, etc.).\n *\n * A companion to {@link share} for the common \"export a generated artifact\"\n * flow: on mobile it opens the native share sheet, and everywhere else it\n * triggers a plain download. Returns early when the user shares or cancels the\n * dialog; otherwise it downloads.\n *\n * @param blob - The binary payload to share or download.\n * @param fileName - The file name presented to the user.\n * @param options - Optional `title` for the share dialog.\n * @returns A promise that resolves once the share or download completes.\n *\n * @example\n * const zip = new Blob([bytes], { type: \"application/zip\" });\n * await shareOrDownloadBlob(zip, \"export.zip\");\n */\nexport async function shareOrDownloadBlob(\n    blob: Blob,\n    fileName: string,\n    options: ShareOrDownloadOptions = {},\n): Promise<void> {\n    const file = new File([blob], fileName, { type: blob.type });\n    const result = await share({ title: options.title ?? fileName, files: [file] });\n    if (result.shared || result.cancelled) return;\n\n    const url = URL.createObjectURL(blob);\n    const anchor = document.createElement(\"a\");\n    anchor.href = url;\n    anchor.download = fileName;\n    document.body.appendChild(anchor);\n    anchor.click();\n    anchor.remove();\n    URL.revokeObjectURL(url);\n}\n"],"mappings":";;AA2BA,eAAsBA,EAClB,GACA,GACA,IAAkC,CAAC,GACtB;CACb,IAAMC,IAAO,IAAI,KAAK,CAACC,CAAI,GAAGC,GAAU,EAAE,MAAMD,EAAK,KAAK,CAAC,GACrDE,IAAS,MAAMC,EAAM;EAAE,OAAOC,EAAQ,SAASH;EAAU,OAAO,CAACF,CAAI;CAAE,CAAC;CAC9E,IAAIG,EAAO,UAAUA,EAAO,WAAW;CAEvC,IAAMG,IAAM,IAAI,gBAAgBL,CAAI,GAC9BM,IAAS,SAAS,cAAc,GAAG;CAMzC,AALA,EAAO,OAAOD,GACd,EAAO,WAAWJ,GAClB,SAAS,KAAK,YAAYK,CAAM,GAChCA,EAAO,MAAM,GACbA,EAAO,OAAO,GACd,IAAI,gBAAgBD,CAAG;AAC3B"}

package/dist/share/share.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"share.cjs","names":[],"sources":["../../src/share/share.ts"],"sourcesContent":["export interface SharePayload {\n    title?: string;\n    text?: string;\n    url?: string;\n    /** Files to share (supported only on a subset of browsers). */\n    files?: File[];\n}\n\nexport interface ShareResult {\n    /** True when `navigator.share` resolved successfully. */\n    shared: boolean;\n    /** True when the platform did not support the requested payload. */\n    unsupported: boolean;\n    /** True when the user cancelled the share dialog. */\n    cancelled: boolean;\n    error?: unknown;\n}\n\n/**\n * Wrap the Web Share API with a uniform result object. Falls through to\n * `unsupported: true` when the browser lacks `navigator.share`, leaving the\n * caller free to render a custom fallback (copy-link, social buttons).\n */\nexport async function share(payload: SharePayload): Promise<ShareResult> {\n    if (typeof navigator === \"undefined\" || !(\"share\" in navigator)) {\n        return { shared: false, unsupported: true, cancelled: false };\n    }\n    if (payload.files && !navigator.canShare?.({ files: payload.files })) {\n        return { shared: false, unsupported: true, cancelled: false };\n    }\n    try {\n        await navigator.share(payload);\n        return { shared: true, unsupported: false, cancelled: false };\n    } catch (error) {\n        if (error instanceof DOMException && error.name === \"AbortError\") {\n            return { shared: false, unsupported: false, cancelled: true };\n        }\n        return { shared: false, unsupported: false, cancelled: false, error };\n    }\n}\n\n/** True when the Web Share API is available in this environment. */\nexport function isShareSupported(): boolean {\n    return typeof navigator !== \"undefined\" && \"share\" in navigator;\n}\n"],"mappings":"AAuBA,eAAsB,EAAM,EAA6C,CAIrE,GAHI,OAAO,UAAc,KAAe,EAAE,UAAW,YAGjD,EAAQ,OAAS,CAAC,UAAU,WAAW,CAAE,MAAO,EAAQ,KAAM,CAAC,EAC/D,MAAO,CAAE,OAAQ,GAAO,YAAa,GAAM,UAAW,EAAM,EAEhE,GAAI,CAEA,OADA,MAAM,UAAU,MAAM,CAAO,EACtB,CAAE,OAAQ,GAAM,YAAa,GAAO,UAAW,EAAM,CAChE,OAAS,EAAO,CAIZ,OAHI,aAAiB,cAAgB,EAAM,OAAS,aACzC,CAAE,OAAQ,GAAO,YAAa,GAAO,UAAW,EAAK,EAEzD,CAAE,OAAQ,GAAO,YAAa,GAAO,UAAW,GAAO,OAAM,CACxE,CACJ,CAGA,SAAgB,GAA4B,CACxC,OAAO,OAAO,UAAc,KAAe,UAAW,SAC1D"}
+{"version":3,"file":"share.cjs","names":["share","payload","error","isShareSupported"],"sources":["../../src/share/share.ts"],"sourcesContent":["export interface SharePayload {\n    title?: string;\n    text?: string;\n    url?: string;\n    /** Files to share (supported only on a subset of browsers). */\n    files?: File[];\n}\n\nexport interface ShareResult {\n    /** True when `navigator.share` resolved successfully. */\n    shared: boolean;\n    /** True when the platform did not support the requested payload. */\n    unsupported: boolean;\n    /** True when the user cancelled the share dialog. */\n    cancelled: boolean;\n    error?: unknown;\n}\n\n/**\n * Wrap the Web Share API with a uniform result object. Falls through to\n * `unsupported: true` when the browser lacks `navigator.share`, leaving the\n * caller free to render a custom fallback (copy-link, social buttons).\n */\nexport async function share(payload: SharePayload): Promise<ShareResult> {\n    if (typeof navigator === \"undefined\" || !(\"share\" in navigator)) {\n        return { shared: false, unsupported: true, cancelled: false };\n    }\n    if (payload.files && !navigator.canShare?.({ files: payload.files })) {\n        return { shared: false, unsupported: true, cancelled: false };\n    }\n    try {\n        await navigator.share(payload);\n        return { shared: true, unsupported: false, cancelled: false };\n    } catch (error) {\n        if (error instanceof DOMException && error.name === \"AbortError\") {\n            return { shared: false, unsupported: false, cancelled: true };\n        }\n        return { shared: false, unsupported: false, cancelled: false, error };\n    }\n}\n\n/** True when the Web Share API is available in this environment. */\nexport function isShareSupported(): boolean {\n    return typeof navigator !== \"undefined\" && \"share\" in navigator;\n}\n"],"mappings":"AAuBA,eAAsBA,EAAM,EAA6C,CAIrE,GAHI,OAAO,UAAc,KAAe,EAAE,UAAW,YAGjDC,EAAQ,OAAS,CAAC,UAAU,WAAW,CAAE,MAAOA,EAAQ,KAAM,CAAC,EAC/D,MAAO,CAAE,OAAQ,GAAO,YAAa,GAAM,UAAW,EAAM,EAEhE,GAAI,CAEA,OADA,MAAM,UAAU,MAAMA,CAAO,EACtB,CAAE,OAAQ,GAAM,YAAa,GAAO,UAAW,EAAM,CAChE,OAASC,EAAO,CAIZ,OAHIA,aAAiB,cAAgBA,EAAM,OAAS,aACzC,CAAE,OAAQ,GAAO,YAAa,GAAO,UAAW,EAAK,EAEzD,CAAE,OAAQ,GAAO,YAAa,GAAO,UAAW,GAAO,OAAM,CACxE,CACJ,CAGA,SAAgBC,GAA4B,CACxC,OAAO,OAAO,UAAc,KAAe,UAAW,SAC1D,C"}