@razakalpha/convngx 0.2.4 → 0.2.5

package/fesm2022/razakalpha-convngx.mjs

@@ -0,0 +1,767 @@
+import { BaseConvexClient, ConvexHttpClient } from 'convex/browser';
+import { getFunctionName } from 'convex/server';
+import { InjectionToken, inject, provideEnvironmentInitializer, signal, computed, resource } from '@angular/core';
+import { createAuthClient } from 'better-auth/client';
+import { convexClient, crossDomainClient } from '@convex-dev/better-auth/client/plugins';
+
+/**
+ * Internal helpers for ConvexAngularClient.
+ * NOTE: Pure refactor; functionality unchanged.
+ */
+const AUTH_KEY = 'convex:jwt';
+const AUTH_CH = 'convex-auth';
+/** Decode JWT exp claim (ms). Returns 0 if invalid. */
+function jwtExpMs(jwt) {
+    try {
+        const payload = JSON.parse(atob(jwt.split('.')[1] || ''));
+        return typeof payload?.exp === 'number' ? payload.exp * 1000 : 0;
+    }
+    catch {
+        return 0;
+    }
+}
+/** Canonical JSON stringify for stable de-dupe keys. */
+function stableStringify(input) {
+    const seen = new WeakSet();
+    const norm = (v) => {
+        if (v === null || typeof v !== 'object')
+            return v;
+        if (seen.has(v))
+            return v;
+        seen.add(v);
+        if (Array.isArray(v))
+            return v.map(norm);
+        return Object.keys(v)
+            .sort()
+            .reduce((acc, k) => {
+            acc[k] = norm(v[k]);
+            return acc;
+        }, {});
+    };
+    return JSON.stringify(norm(input));
+}
+/** sessionStorage helpers (some browsers may throw on access) */
+const safeSession = {
+    get: (k) => {
+        try {
+            return typeof sessionStorage !== 'undefined' ? sessionStorage.getItem(k) : null;
+        }
+        catch {
+            return null;
+        }
+    },
+    set: (k, v) => {
+        try {
+            if (typeof sessionStorage !== 'undefined')
+                sessionStorage.setItem(k, v);
+        }
+        catch {
+            /* no-op */
+        }
+    },
+    del: (k) => {
+        try {
+            if (typeof sessionStorage !== 'undefined')
+                sessionStorage.removeItem(k);
+        }
+        catch {
+            /* no-op */
+        }
+    },
+};
+
+/**
+ * ConvexAngularClient
+ * - Wraps Convex BaseConvexClient + ConvexHttpClient
+ * - Integrates Better Auth via pluggable fetcher (setAuth)
+ * - Caches JWT in sessionStorage with BroadcastChannel sync
+ * - Auto-refreshes auth token ahead of expiry with jitter
+ * - Provides:
+ *   - watchQuery: live subscription with localQueryResult + onUpdate
+ *   - query: HTTP one-shot with in-flight de-dupe + 401 retry
+ *   - mutation: supports optimisticUpdate passthrough
+ *   - action: HTTP call with 401 retry
+ * - Does not change any runtime behavior – documentation and structure only.
+ */
+// src/app/convex-angular-client.ts
+/* helpers moved to ./helpers (no behavior change) */
+const bc = typeof BroadcastChannel !== 'undefined'
+    ? new BroadcastChannel(AUTH_CH)
+    : null;
+class ConvexAngularClient {
+    authListeners = new Set();
+    lastSnap;
+    // ==== internals ====
+    emitAuth() {
+        const snap = this.getAuthSnapshot();
+        // de-dupe emissions
+        if (this.lastSnap &&
+            this.lastSnap.isAuthenticated === snap.isAuthenticated &&
+            this.lastSnap.token === snap.token) {
+            return;
+        }
+        this.lastSnap = snap;
+        for (const cb of this.authListeners)
+            cb(snap);
+    }
+    base;
+    http;
+    byToken = new Map();
+    fetchToken;
+    inflightToken;
+    token;
+    refreshTimer;
+    inflightHttp = new Map();
+    authLocked = false;
+    skewMs;
+    constructor(url, opts) {
+        this.skewMs = opts?.authSkewMs ?? 30_000;
+        this.base = new BaseConvexClient(url, (updatedTokens) => {
+            for (const t of updatedTokens) {
+                const e = this.byToken.get(t);
+                if (!e)
+                    continue;
+                for (const cb of e.listeners)
+                    cb();
+            }
+        }, opts);
+        this.http = new ConvexHttpClient(url);
+        // pick up cached token
+        const raw = safeSession.get(AUTH_KEY);
+        if (raw) {
+            try {
+                const t = JSON.parse(raw);
+                if (t?.value && t?.exp && Date.now() < t.exp - this.skewMs) {
+                    this.token = t;
+                    this.http.setAuth(t.value);
+                    this.scheduleRefresh();
+                }
+            }
+            catch { }
+        }
+        // 3) BroadcastChannel: keep as-is (clear only on 'clear', set on 'set')
+        bc?.addEventListener('message', (ev) => {
+            const d = ev.data;
+            if (d?.type === 'set') {
+                if (this.authLocked)
+                    return; // ignore while logging out
+                this.applyToken(d.token?.value ?? null);
+            }
+            else if (d?.type === 'clear') {
+                this.applyToken(null);
+            }
+        });
+        // visibility/network pokes
+        const poke = () => {
+            if (!this.freshTokenInCache())
+                void this.getToken(true);
+        };
+        if (typeof window !== 'undefined') {
+            window.addEventListener('online', poke);
+            document.addEventListener?.('visibilitychange', () => {
+                if (document.visibilityState === 'visible')
+                    poke();
+            });
+        }
+    }
+    setAuth(fetcher) {
+        this.fetchToken = fetcher;
+        this.base.setAuth(async ({ forceRefreshToken }) => (this.authLocked ? null : this.getToken(forceRefreshToken)), () => {
+            // identity changed (connect/reconnect). Do NOT clear token here.
+            // If we're truly logged out, next HTTP/WS use will 401 and we clear then.
+            this.inflightToken = undefined;
+            this.emitAuth(); // soft notify, no flip to false
+        });
+    }
+    /** Optional: call once on app start */
+    async warmAuth() {
+        await this.getToken(true);
+    }
+    freshTokenInCache() {
+        if (!this.token)
+            return null;
+        return Date.now() < this.token.exp - this.skewMs ? this.token.value : null;
+    }
+    // ==== public auth helpers ====
+    onAuth(cb) {
+        cb(this.getAuthSnapshot());
+        this.authListeners.add(cb);
+        return () => this.authListeners.delete(cb);
+    }
+    logoutLocal(lock = true) {
+        if (lock)
+            this.authLocked = true;
+        this.inflightToken = undefined;
+        this.applyToken(null); // this is the ONLY place we hard clear locally
+    }
+    // 5) snapshot uses token presence (not freshness)
+    getAuthSnapshot() {
+        return {
+            isAuthenticated: !!this.token?.value,
+            token: this.token?.value ?? null,
+            exp: this.token?.exp,
+        };
+    }
+    /** Allow re-auth then fetch a fresh token (use after successful sign-in) */
+    async refreshAuth() {
+        this.authLocked = false;
+        await this.getToken(true);
+    }
+    // 4) applyToken: always emit after mutation (you already fixed this)
+    applyToken(token) {
+        if (!token) {
+            this.token = undefined;
+            this.http.clearAuth();
+            safeSession.del(AUTH_KEY);
+            bc?.postMessage({ type: 'clear' });
+            if (this.refreshTimer)
+                window.clearTimeout(this.refreshTimer);
+        }
+        else {
+            if (this.authLocked) {
+                this.emitAuth();
+                return;
+            }
+            const exp = jwtExpMs(token);
+            this.token = { value: token, exp };
+            this.http.setAuth(token);
+            safeSession.set(AUTH_KEY, JSON.stringify(this.token));
+            bc?.postMessage({ type: 'set', token: this.token });
+            this.scheduleRefresh();
+        }
+        this.emitAuth();
+    }
+    scheduleRefresh() {
+        if (!this.token)
+            return;
+        if (this.refreshTimer)
+            window.clearTimeout(this.refreshTimer);
+        const jitter = 2_000 + Math.floor(Math.random() * 2_000);
+        const due = Math.max(0, this.token.exp - this.skewMs - Date.now() - jitter);
+        this.refreshTimer = window.setTimeout(() => {
+            void this.getToken(true);
+        }, due);
+    }
+    async getToken(force) {
+        if (!this.fetchToken || this.authLocked)
+            return null; // 🔒 deny any token
+        const cached = this.freshTokenInCache();
+        if (!force && cached)
+            return cached;
+        if (!this.inflightToken) {
+            this.inflightToken = (async () => {
+                const t = await this.fetchToken({ forceRefreshToken: true });
+                // ignore token if we got locked while waiting
+                if (this.authLocked) {
+                    this.emitAuth(); // ensure listeners see current (likely false)
+                    return null;
+                }
+                this.applyToken(t ?? null);
+                return t ?? null;
+            })().finally(() => setTimeout(() => (this.inflightToken = undefined), 0));
+        }
+        return await this.inflightToken;
+    }
+    async ensureHttpAuth() {
+        await this.getToken(false);
+    }
+    // ——— live query ———
+    watchQuery(q, args) {
+        const name = getFunctionName(q);
+        const valueArgs = (args ?? {});
+        const { queryToken, unsubscribe } = this.base.subscribe(name, valueArgs);
+        const entry = { name, args: valueArgs, listeners: new Set(), unsubscribe };
+        this.byToken.set(queryToken, entry);
+        return {
+            localQueryResult: () => this.base.localQueryResult(name, valueArgs),
+            onUpdate: (cb) => {
+                entry.listeners.add(cb);
+                return () => entry.listeners.delete(cb);
+            },
+            unsubscribe: () => {
+                entry.unsubscribe();
+                this.byToken.delete(queryToken);
+            },
+        };
+    }
+    // ——— mutation ———
+    async mutation(m, args, opts) {
+        const name = getFunctionName(m);
+        return this.base.mutation(name, args, opts?.optimisticUpdate ? { optimisticUpdate: opts.optimisticUpdate } : undefined);
+    }
+    async action(a, args) {
+        await this.ensureHttpAuth();
+        const call = () => this.http.action(a, ...(args ? [args] : []));
+        try {
+            return await call();
+        }
+        catch (e) {
+            const status = e?.status ?? e?.response?.status;
+            if (this.fetchToken && status === 401) {
+                await this.getToken(true);
+                return await call();
+            }
+            throw e;
+        }
+    }
+    async query(q, args) {
+        await this.ensureHttpAuth();
+        const name = getFunctionName(q);
+        const key = name + ':' + (args ? stableStringify(args) : '');
+        if (!this.inflightHttp.has(key)) {
+            this.inflightHttp.set(key, (async () => {
+                try {
+                    return await this.http.query(q, ...(args ? [args] : []));
+                }
+                catch (e) {
+                    const status = e?.status ?? e?.response?.status;
+                    if (this.fetchToken && status === 401) {
+                        await this.getToken(true);
+                        return await this.http.query(q, ...(args ? [args] : []));
+                    }
+                    throw e;
+                }
+                finally {
+                    setTimeout(() => this.inflightHttp.delete(key), 0);
+                }
+            })());
+        }
+        return this.inflightHttp.get(key);
+    }
+}
+
+/**
+* Injection token and helper for accessing the Convex client from DI.
+* Keep this tiny and stable — many helpers rely on it.
+*/
+/** DI token for the configured ConvexAngularClient instance */
+const CONVEX = new InjectionToken('CONVEX');
+/** Convenience helper to inject the Convex client */
+const injectConvex = () => inject(CONVEX);
+
+/**
+ * Un-typed DI token. We don't re-export types; callers who create the client
+ * get full type safety from better-auth directly.
+ */
+const AUTH_CLIENT = new InjectionToken('AUTH_CLIENT');
+/** Provide a configured Better Auth client via DI (default convex+crossDomain plugins) */
+function provideAuthClient(opts) {
+    return {
+        provide: AUTH_CLIENT,
+        useFactory: () => createAuthClient({
+            baseURL: opts.baseURL,
+            plugins: [convexClient(), crossDomainClient()],
+            fetchOptions: { credentials: 'include', ...(opts.fetchOptions ?? {}) },
+        }),
+    };
+}
+
+/**
+ * Convex + Better Auth providers.
+ * - provideConvexBetterAuth: Registers a ConvexAngularClient in DI and wires Better Auth token fetching.
+ * - provideBetterAuthOttBootstrap: Optional environment initializer to handle cross-domain one-time-token.
+ *
+ * No functional changes—cleaned comments and added docs.
+ */
+/**
+ * Registers the Convex client in DI and connects it to Better Auth for JWT retrieval.
+ * Consumers still need to provide the Better Auth HTTP client via provideAuthClient().
+ */
+function provideConvexBetterAuth(opts) {
+    return [
+        {
+            provide: CONVEX,
+            useFactory: () => {
+                const client = new ConvexAngularClient(opts.convexUrl, {
+                    authSkewMs: opts.authSkewMs ?? 45_000,
+                });
+                const auth = inject(AUTH_CLIENT);
+                const fetchAccessToken = async ({ forceRefreshToken }) => {
+                    if (!forceRefreshToken)
+                        return null;
+                    // Retry logic for transient failures (e.g., session not fully propagated)
+                    let lastError;
+                    for (let attempt = 0; attempt < 3; attempt++) {
+                        try {
+                            if (attempt > 0) {
+                                // Wait before retry: 50ms, then 100ms
+                                const delay = attempt * 50;
+                                await new Promise((resolve) => setTimeout(resolve, delay));
+                            }
+                            const { data } = await auth.convex.token();
+                            return data?.token ?? null;
+                        }
+                        catch (err) {
+                            lastError = err;
+                            // Only retry on "Failed to fetch" errors
+                            if (attempt < 2 && err?.message === 'Failed to fetch') {
+                                continue;
+                            }
+                            throw err;
+                        }
+                    }
+                    throw lastError;
+                };
+                client.setAuth(fetchAccessToken);
+                void client.warmAuth();
+                return client;
+            },
+        },
+    ];
+}
+/**
+ * Optional environment initializer to handle OTT (?ott=...) once and upgrade to a cookie session.
+ * Keep separate from main provider for explicit opt-in.
+ */
+function provideBetterAuthOttBootstrap() {
+    return provideEnvironmentInitializer(() => {
+        (async () => {
+            const auth = inject(AUTH_CLIENT);
+            const url = new URL(window.location.href);
+            const ott = url.searchParams.get('ott');
+            if (!ott)
+                return;
+            const result = await auth.crossDomain.oneTimeToken.verify({ token: ott });
+            const session = result?.data?.session;
+            if (session?.token) {
+                await auth.getSession({
+                    fetchOptions: {
+                        credentials: 'include',
+                        headers: { Authorization: `Bearer ${session.token}` },
+                    },
+                });
+                auth.updateSession();
+            }
+            url.searchParams.delete('ott');
+            window.history.replaceState({}, '', url.toString());
+        })();
+    });
+}
+
+// convex-resource.ts
+const DEFAULTS = { keep: 'last' };
+const CONVEX_RESOURCE_OPTIONS = new InjectionToken('CONVEX_RESOURCE_OPTIONS', { factory: () => DEFAULTS });
+function provideConvexResourceOptions(opts) {
+    return { provide: CONVEX_RESOURCE_OPTIONS, useValue: { ...DEFAULTS, ...opts } };
+}
+/** Impl */
+function convexLiveResource(query, a, b) {
+    const convex = injectConvex();
+    const global = inject(CONVEX_RESOURCE_OPTIONS);
+    const keepMode = (typeof a === 'function' ? b : a)?.keep ?? global.keep;
+    const paramsFactory = typeof a === 'function' ? a : undefined;
+    const lastGlobal = signal(undefined, ...(ngDevMode ? [{ debugName: "lastGlobal" }] : []));
+    const argsSig = computed(() => {
+        if (!paramsFactory)
+            return {}; // no-args: always enabled
+        return paramsFactory();
+    }, ...(ngDevMode ? [{ debugName: "argsSig" }] : []));
+    // --- reload tagging ---
+    const reloadStamp = signal(0, ...(ngDevMode ? [{ debugName: "reloadStamp" }] : [])); // increments only when .reload() is called
+    let lastSeenReload = 0; // compared inside stream to detect reload
+    const request = computed(() => ({
+        args: argsSig(),
+        __r: reloadStamp(),
+    }), ...(ngDevMode ? [{ debugName: "request" }] : []));
+    const base = resource({
+        params: request,
+        stream: async ({ params, abortSignal }) => {
+            const s = signal({
+                value: keepMode === 'last' ? lastGlobal() : undefined,
+            }, ...(ngDevMode ? [{ debugName: "s" }] : []));
+            if (!params || !params.args)
+                return s; // gated
+            const isReload = params.__r !== lastSeenReload;
+            lastSeenReload = params.__r;
+            // One-shot fetch: ONLY on reload
+            if (isReload) {
+                convex
+                    .query(query, params.args)
+                    .then((next) => {
+                    if (abortSignal.aborted)
+                        return;
+                    s.set({ value: next });
+                    lastGlobal.set(next);
+                })
+                    .catch((err) => {
+                    if (abortSignal.aborted)
+                        return;
+                    s.set({ error: err });
+                });
+            }
+            // Live subscription (always)
+            const w = convex.watchQuery(query, params.args);
+            try {
+                const local = w.localQueryResult();
+                if (local !== undefined) {
+                    s.set({ value: local });
+                    lastGlobal.set(local);
+                }
+            }
+            catch (err) {
+                s.set({ error: err });
+            }
+            const off = w.onUpdate(() => {
+                try {
+                    const next = w.localQueryResult();
+                    s.set({ value: next });
+                    lastGlobal.set(next);
+                }
+                catch (err) {
+                    s.set({ error: err });
+                }
+            });
+            abortSignal.addEventListener('abort', () => off(), { once: true });
+            return s;
+        },
+    });
+    // Wrap to bump reloadStamp only when user calls reload()
+    const origReload = base.reload.bind(base);
+    const wrapped = {
+        ...base,
+        reload: () => {
+            reloadStamp.set(reloadStamp() + 1);
+            return origReload();
+        },
+    };
+    return wrapped;
+}
+
+/**
+ * Single entry-point provider to wire Convex + Better Auth + resource defaults.
+ * Behavior:
+ * - If opts.authClient is provided, we use it (and verify required plugins).
+ * - Else we create a default Better Auth client using authBaseURL with required plugins.
+ */
+function provideConvexAngular(opts) {
+    const providers = [];
+    if (opts.authClient) {
+        providers.push({
+            provide: AUTH_CLIENT,
+            useFactory: () => {
+                const c = opts.authClient;
+                const hasConvex = typeof c.convex?.token === 'function';
+                const hasCross = typeof c.crossDomain?.oneTimeToken?.verify === 'function';
+                if (!hasConvex || !hasCross) {
+                    throw new Error('Provided AUTH client is missing required plugins: convexClient() and crossDomainClient().');
+                }
+                return c;
+            },
+        });
+    }
+    else {
+        // Default client with known plugin set (convex + crossDomain)
+        providers.push(provideAuthClient({
+            baseURL: opts.authBaseURL,
+        }));
+    }
+    providers.push(...provideConvexBetterAuth({
+        convexUrl: opts.convexUrl,
+        authSkewMs: opts.authSkewMs,
+    }));
+    if (opts.keep) {
+        providers.push(provideConvexResourceOptions({ keep: opts.keep }));
+    }
+    return providers;
+}
+
+// convex-mutation-resource.ts
+/** Single impl */
+function convexMutationResource(mutation, opts) {
+    const convex = injectConvex();
+    const isRunning = signal(false, ...(ngDevMode ? [{ debugName: "isRunning" }] : []));
+    const pending = new Map();
+    const inflight = signal(undefined, ...(ngDevMode ? [{ debugName: "inflight" }] : []));
+    const trigger = signal(undefined, ...(ngDevMode ? [{ debugName: "trigger" }] : []));
+    let seq = 0;
+    const state = resource({
+        params: computed(() => trigger()),
+        stream: async ({ params, abortSignal }) => {
+            const out = signal({
+                value: undefined,
+            }, ...(ngDevMode ? [{ debugName: "out" }] : []));
+            if (!params)
+                return out;
+            const done = () => {
+                // clean out waiter if still present
+                const w = pending.get(params.id);
+                if (w)
+                    pending.delete(params.id);
+            };
+            const runOnce = async () => {
+                let attempt = 0;
+                const retries = opts?.retries ?? 0;
+                const delay = (n) => new Promise((r) => setTimeout(r, opts?.retryDelayMs?.(n) ?? 500 * n));
+                // NB: Convex mutations don’t support abort; we still observe abortSignal to stop emitting.
+                // We *do not* call mutation again on aborted; we just stop updating UI.
+                // If you choose mode: 'replace', older runs get superseded by newer trigger()s.
+                // That’s the main “cancellation” we can mimic here.
+                while (true) {
+                    try {
+                        const res = await convex.mutation(mutation, params.args, {
+                            optimisticUpdate: opts?.optimisticUpdate,
+                        });
+                        if (!abortSignal.aborted) {
+                            out.set({ value: res });
+                            opts?.onSuccess?.(res);
+                            pending.get(params.id)?.resolve(res);
+                        }
+                        done();
+                        return;
+                    }
+                    catch (e) {
+                        const err = e instanceof Error ? e : new Error(String(e));
+                        if (!abortSignal.aborted) {
+                            out.set({ error: err });
+                        }
+                        if (attempt >= retries) {
+                            opts?.onError?.(err);
+                            pending.get(params.id)?.reject(err);
+                            done();
+                            return;
+                        }
+                        attempt++;
+                        await delay(attempt);
+                    }
+                }
+            };
+            isRunning.set(true);
+            try {
+                const p = runOnce();
+                inflight.set(p);
+                await p;
+            }
+            finally {
+                if (!abortSignal.aborted)
+                    isRunning.set(false);
+                if (inflight() && (await inflight()) === undefined)
+                    inflight.set(undefined);
+            }
+            return out;
+        },
+    });
+    const data = computed(() => state.value(), ...(ngDevMode ? [{ debugName: "data" }] : []));
+    const error = computed(() => state.error(), ...(ngDevMode ? [{ debugName: "error" }] : []));
+    const run = (async (args) => {
+        const job = { id: ++seq, args: (args ?? {}) };
+        if (opts?.mode === 'drop' && inflight()) {
+            // return the inflight promise if present (best-effort)
+            return inflight();
+        }
+        if (opts?.mode === 'queue' && inflight()) {
+            await inflight();
+        }
+        const promise = new Promise((resolve, reject) => {
+            pending.set(job.id, { resolve, reject });
+        });
+        // "replace": push new job; older job’s UI will be superseded by the next emission
+        trigger.set(job);
+        return promise;
+    });
+    const reset = () => {
+        // clear UI state; does not affect in-flight promise
+        state.reset?.(); // safe if Angular adds reset later; otherwise ignore
+    };
+    return { run, state, data, error, isRunning: isRunning.asReadonly(), reset };
+}
+
+// convex-action-resource.ts
+/** Single impl */
+function convexActionResource(action, opts) {
+    const convex = injectConvex();
+    const isRunning = signal(false, ...(ngDevMode ? [{ debugName: "isRunning" }] : []));
+    const inflight = signal(undefined, ...(ngDevMode ? [{ debugName: "inflight" }] : []));
+    const pending = new Map();
+    const trigger = signal(undefined, ...(ngDevMode ? [{ debugName: "trigger" }] : []));
+    let seq = 0;
+    const state = resource({
+        params: computed(() => trigger()),
+        stream: async ({ params, abortSignal }) => {
+            const out = signal({
+                value: undefined,
+            }, ...(ngDevMode ? [{ debugName: "out" }] : []));
+            if (!params)
+                return out;
+            const done = () => {
+                const w = pending.get(params.id);
+                if (w)
+                    pending.delete(params.id);
+            };
+            const runOnce = async () => {
+                let attempt = 0;
+                const retries = opts?.retries ?? 0;
+                const delay = (n) => new Promise((r) => setTimeout(r, opts?.retryDelayMs?.(n) ?? 500 * n));
+                while (true) {
+                    try {
+                        const res = await convex.action(action, params.args);
+                        if (!abortSignal.aborted) {
+                            out.set({ value: res });
+                            opts?.onSuccess?.(res);
+                            pending.get(params.id)?.resolve(res);
+                        }
+                        done();
+                        return;
+                    }
+                    catch (e) {
+                        const err = e instanceof Error ? e : new Error(String(e));
+                        if (!abortSignal.aborted)
+                            out.set({ error: err });
+                        if (attempt >= retries) {
+                            opts?.onError?.(err);
+                            pending.get(params.id)?.reject(err);
+                            done();
+                            return;
+                        }
+                        attempt++;
+                        await delay(attempt);
+                    }
+                }
+            };
+            isRunning.set(true);
+            try {
+                const p = runOnce();
+                inflight.set(p);
+                await p;
+            }
+            finally {
+                if (!abortSignal.aborted)
+                    isRunning.set(false);
+                if (inflight() && (await inflight()) === undefined)
+                    inflight.set(undefined);
+            }
+            return out;
+        },
+    });
+    const data = computed(() => state.value(), ...(ngDevMode ? [{ debugName: "data" }] : []));
+    const error = computed(() => state.error(), ...(ngDevMode ? [{ debugName: "error" }] : []));
+    const run = (async (args) => {
+        const job = { id: ++seq, args: (args ?? {}) };
+        if (opts?.mode === 'drop' && inflight()) {
+            return inflight();
+        }
+        if (opts?.mode === 'queue' && inflight()) {
+            await inflight();
+        }
+        const promise = new Promise((resolve, reject) => {
+            pending.set(job.id, { resolve, reject });
+        });
+        trigger.set(job); // "replace" naturally supersedes older emissions
+        return promise;
+    });
+    const reset = () => {
+        state.reset?.();
+    };
+    return { run, state, data, error, isRunning: isRunning.asReadonly(), reset };
+}
+
+/*
+ * Public API Surface of convex-angular
+ */
+// Core client and DI token
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { AUTH_CLIENT, CONVEX, CONVEX_RESOURCE_OPTIONS, ConvexAngularClient, convexActionResource, convexLiveResource, convexMutationResource, injectConvex, provideAuthClient, provideBetterAuthOttBootstrap, provideConvexAngular, provideConvexBetterAuth, provideConvexResourceOptions };
+//# sourceMappingURL=razakalpha-convngx.mjs.map