@constructor-io/constructorio-ui-asa 1.7.1 → 1.8.0

package/lib/cjs/hooks/persistence/useChatPersistence.js

@@ -0,0 +1,485 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const react_1 = require("react");
+const chatThreads_1 = require("../../utils/chatThreads");
+const chatSession_1 = require("../../utils/chatSession");
+const useIsMounted_1 = tslib_1.__importDefault(require("../useIsMounted"));
+const useLatest_1 = tslib_1.__importDefault(require("../useLatest"));
+const useWriteQueue_1 = tslib_1.__importDefault(require("./useWriteQueue"));
+const useThreadList_1 = tslib_1.__importDefault(require("./useThreadList"));
+const useForeignStream_1 = tslib_1.__importDefault(require("./useForeignStream"));
+const backgroundTurns_1 = require("./backgroundTurns");
+const hasUnsavedWork = (session) => session.isStreaming || session.dirty || session.orphanIds.length > 0;
+/** Restores, saves and syncs the conversation with `store`; inert when `store` is undefined. */
+function useChatPersistence(params) {
+    const { store, scope, index, session, initialThreadId, messages, setMessages, isStreaming, setIsStreaming, turnRef, cancelStream, } = params;
+    if (store)
+        (0, chatThreads_1.getTabId)();
+    const [isHydrating, setIsHydrating] = (0, react_1.useState)(Boolean(store));
+    const [activeThreadId, setActiveThreadId] = (0, react_1.useState)(null);
+    const storeRef = (0, useLatest_1.default)(store);
+    const messagesRef = (0, useLatest_1.default)(messages);
+    const mountedRef = (0, useIsMounted_1.default)();
+    const { enqueue: enqueueWrite, reset: resetWrites } = (0, useWriteQueue_1.default)();
+    // Async writes not yet committed; the page may go away before a queued one gets its lock.
+    const pendingWritesRef = (0, react_1.useRef)(0);
+    // Another tab changed the thread while this one streamed; looked at again once the turn is saved.
+    const missedSyncRef = (0, react_1.useRef)(false);
+    const { threads, setThreads, refreshThreads, invalidate: invalidateThreads, } = (0, useThreadList_1.default)(storeRef);
+    const { foreignInFlight, setForeignInFlight, watch: watchForeign, stop: stopForeign, clearTimer: clearForeignTimer, } = (0, useForeignStream_1.default)(session);
+    // Reset during render so the previous store's conversation never paints under the new one.
+    // A login keeps the guest conversation on screen instead and moves it into the shopper's store.
+    const [rendered, setRendered] = (0, react_1.useState)({ store, scope, index });
+    const carryOverFromRef = (0, react_1.useRef)(undefined);
+    // Every guest thread moves into the shopper's store on login, so none is left for the next guest.
+    const migrateFromRef = (0, react_1.useRef)(undefined);
+    const settleIntoRef = (0, react_1.useRef)(undefined);
+    if (rendered.store !== store) {
+        const login = rendered.store &&
+            store &&
+            rendered.index === index &&
+            rendered.scope === 'guest' &&
+            scope === 'user';
+        const carryOver = login && messages.length > 0;
+        setRendered({ store, scope, index });
+        setThreads([]);
+        if (login)
+            migrateFromRef.current = rendered.store;
+        if (carryOver) {
+            carryOverFromRef.current = rendered.store;
+        }
+        else {
+            // An unfinished turn still belongs to the previous store; the effect below writes it there.
+            if (rendered.store && messages.length > 0 && hasUnsavedWork(session)) {
+                settleIntoRef.current = { store: rendered.store, messages };
+            }
+            setMessages([]);
+            setActiveThreadId(null);
+            setForeignInFlight(false);
+            setIsStreaming(false);
+            setIsHydrating(Boolean(store));
+        }
+    }
+    /** Puts a stored conversation on screen and makes it the one this tab continues. */
+    const showStoredChat = (0, react_1.useCallback)((chat) => {
+        (0, chatSession_1.adoptStoredChat)(session, chat);
+        setActiveThreadId(chat.threadId);
+        const remainingMs = (0, chatThreads_1.foreignStreamRemainingMs)(chat);
+        if (remainingMs === 0) {
+            stopForeign();
+            setMessages((0, chatThreads_1.normalizeHydratedMessages)(chat.messages));
+            // Write the settled snapshot back so the list stops reporting it in flight.
+            if ((0, chatThreads_1.isInFlight)(chat.messages))
+                session.dirty = true;
+            return;
+        }
+        setMessages(chat.messages);
+        watchForeign(remainingMs, () => {
+            if (!mountedRef.current || session.storageThreadId !== chat.threadId)
+                return;
+            if (session.isStreaming)
+                return;
+            session.dirty = true;
+            setMessages((prev) => (0, chatThreads_1.normalizeHydratedMessages)(prev));
+        });
+    }, [session, stopForeign, watchForeign, setMessages, mountedRef]);
+    /** Writes the conversation as it is now; `settle` finishes an in-flight answer, `sync` skips awaiting. */
+    const persistNow = (0, react_1.useCallback)((mode) => {
+        const { current } = storeRef;
+        if (!current || messagesRef.current.length === 0)
+            return undefined;
+        const toSave = (mode === null || mode === void 0 ? void 0 : mode.settle)
+            ? (0, chatThreads_1.normalizeHydratedMessages)(messagesRef.current)
+            : messagesRef.current;
+        const { snapshot, staleIds } = (0, chatSession_1.prepareSnapshot)(session, toSave);
+        if ((mode === null || mode === void 0 ? void 0 : mode.sync) && current.saveThreadSync) {
+            current.saveThreadSync(snapshot, staleIds);
+            return undefined;
+        }
+        if (mountedRef.current)
+            setActiveThreadId(snapshot.threadId);
+        pendingWritesRef.current += 1;
+        return enqueueWrite(() => tslib_1.__awaiter(this, void 0, void 0, function* () {
+            const { saved, leftover } = yield (0, chatThreads_1.saveThreadAndRetireStale)(current, snapshot, staleIds).finally(() => {
+                pendingWritesRef.current -= 1;
+            });
+            // Leftovers of a conversation the user has since left stay stored: they may be its only copy.
+            const sameConversation = storeRef.current === current && session.storageThreadId === snapshot.threadId;
+            if (!sameConversation)
+                return;
+            if (leftover.length > 0) {
+                session.orphanIds = Array.from(new Set([...session.orphanIds, ...leftover]));
+            }
+            // Not stored and no newer snapshot on its way: pagehide or the next save must write it.
+            if (!saved && session.lastSyncedAt === snapshot.updatedAt)
+                session.dirty = true;
+        }));
+    }, [session, storeRef, messagesRef, enqueueWrite, mountedRef]);
+    const onStreamStart = (0, react_1.useCallback)(() => {
+        var _a;
+        (_a = persistNow()) === null || _a === void 0 ? void 0 : _a.then(refreshThreads);
+    }, [persistNow, refreshThreads]);
+    /** Where this tab's answer goes while its conversation is on screen. */
+    const screenOwner = (0, react_1.useCallback)((turn) => ({
+        setMessages,
+        onStart: (threadId) => {
+            if (threadId)
+                session.serverThreadId = threadId;
+            onStreamStart();
+        },
+        onDone: () => {
+            // A turn cancelled by a reset, or handed to the background, is accounted for elsewhere.
+            if (turnRef.current !== turn)
+                return;
+            turnRef.current = null;
+            session.dirty = true;
+            session.isStreaming = false;
+            setIsStreaming(false);
+        },
+    }), [session, setMessages, onStreamStart, turnRef, setIsStreaming]);
+    /** Lets this tab's answer finish in the background, so leaving its conversation does not stop it. */
+    const detachTurn = (0, react_1.useCallback)(() => {
+        const turn = turnRef.current;
+        const { current } = storeRef;
+        const shown = messagesRef.current;
+        if (!turn || !current || !session.isStreaming)
+            return false;
+        if (!shown.some((m) => m.id === turn.assistantId))
+            return false;
+        turnRef.current = null;
+        (0, backgroundTurns_1.continueInBackground)(turn, {
+            store: current,
+            session: (0, chatSession_1.forkSession)(session),
+            messages: shown.map((m) => (m.id === turn.assistantId ? turn.assistant : m)),
+            after: enqueueWrite(() => tslib_1.__awaiter(this, void 0, void 0, function* () { })),
+        });
+        session.isStreaming = false;
+        return true;
+    }, [session, storeRef, messagesRef, turnRef, enqueueWrite]);
+    /** Shows a conversation whose answer went on in the background; an unfinished one streams on here. */
+    const showBackgroundTurn = (0, react_1.useCallback)((bg) => {
+        stopForeign();
+        (0, chatSession_1.adoptSession)(session, bg.session, bg.messages);
+        enqueueWrite(() => bg.writes);
+        setActiveThreadId(session.storageThreadId);
+        setMessages(bg.messages);
+        if (!bg.streaming) {
+            if (!bg.saved)
+                session.dirty = true;
+            return;
+        }
+        turnRef.current = bg.turn;
+        session.isStreaming = true;
+        setIsStreaming(true);
+    }, [session, stopForeign, enqueueWrite, setMessages, turnRef, setIsStreaming]);
+    const settleAndPersist = (0, react_1.useCallback)(() => {
+        if (hasUnsavedWork(session))
+            return persistNow({ settle: true });
+        return undefined;
+    }, [session, persistNow]);
+    /** Write the settled conversation without awaiting anything: the page is going away. */
+    const flushBeforeUnload = (0, react_1.useCallback)(() => {
+        var _a;
+        if (!hasUnsavedWork(session) && pendingWritesRef.current === 0)
+            return;
+        if ((_a = storeRef.current) === null || _a === void 0 ? void 0 : _a.saveThreadSync)
+            session.dirty = false;
+        persistNow({ settle: true, sync: true });
+    }, [session, storeRef, persistNow]);
+    /** Forget the conversation on screen; returns every id it is stored under. */
+    const forgetConversation = (0, react_1.useCallback)(() => {
+        stopForeign();
+        cancelStream();
+        const { orphanIds } = session;
+        const storedId = (0, chatSession_1.resetConversation)(session);
+        session.interacted = true;
+        setActiveThreadId(null);
+        setMessages([]);
+        setIsStreaming(false);
+        return storedId ? [storedId, ...orphanIds] : orphanIds;
+    }, [session, stopForeign, cancelStream, setMessages, setIsStreaming]);
+    // Restore on mount, and again from scratch whenever the store changes. Compared by store, not
+    // by a first-run flag, so StrictMode re-running the mount effect is not taken for a switch.
+    const effectStoreRef = (0, react_1.useRef)(null);
+    (0, react_1.useEffect)(() => {
+        var _a, _b;
+        const previous = effectStoreRef.current;
+        effectStoreRef.current = { store };
+        const carryOverFrom = carryOverFromRef.current;
+        carryOverFromRef.current = undefined;
+        const migrateFrom = migrateFromRef.current;
+        migrateFromRef.current = undefined;
+        // Behind the guest store's pending writes, so none of them can recreate a moved record.
+        const migrate = (onScreen) => migrateFrom && store
+            ? enqueueWrite(() => (0, backgroundTurns_1.moveBackgroundTurns)(migrateFrom, store)
+                .then(() => (0, chatThreads_1.moveThreads)(migrateFrom, store, onScreen))
+                .catch(() => { }))
+            : undefined;
+        if (carryOverFrom && store && migrateFrom) {
+            // A login mid-conversation: the guest conversation continues as the shopper's own.
+            stopForeign();
+            invalidateThreads();
+            const onScreen = {
+                threadIds: [session.storageThreadId, ...session.orphanIds].filter((id) => id !== null),
+                firstMessageId: (_a = messagesRef.current[0]) === null || _a === void 0 ? void 0 : _a.id,
+            };
+            const guestWritesDone = enqueueWrite(() => tslib_1.__awaiter(this, void 0, void 0, function* () { }));
+            resetWrites();
+            session.orphanIds = [];
+            session.lastSyncedAt = 0;
+            session.loadRequest += 1;
+            session.interacted = true;
+            // Saved into the shopper's store first: the guest copies are deleted only once it is there.
+            session.dirty = session.isStreaming;
+            const saved = persistNow();
+            Promise.all([guestWritesDone, saved, (0, backgroundTurns_1.moveBackgroundTurns)(migrateFrom, store)])
+                .then(() => (0, chatThreads_1.moveThreads)(migrateFrom, store, onScreen))
+                .catch(() => { })
+                .then(refreshThreads);
+            setIsHydrating(false);
+            return undefined;
+        }
+        if (previous && previous.store !== store) {
+            // The store changed (e.g. a logout): start over instead of saving the old conversation into it.
+            clearForeignTimer();
+            cancelStream();
+            const settleInto = settleIntoRef.current;
+            settleIntoRef.current = undefined;
+            if (settleInto) {
+                const { snapshot, staleIds } = (0, chatSession_1.prepareSnapshot)(session, (0, chatThreads_1.normalizeHydratedMessages)(settleInto.messages));
+                const { store: left } = settleInto;
+                // Written at once when the store can: a logout often navigates away before a queued write runs.
+                if (left.saveThreadSync) {
+                    try {
+                        left.saveThreadSync(snapshot, staleIds);
+                    }
+                    catch (_c) {
+                        /* ignore */
+                    }
+                }
+                else {
+                    enqueueWrite(() => (0, chatThreads_1.saveThreadAndRetireStale)(left, snapshot, staleIds).then(() => { }));
+                }
+            }
+            (_b = migrate()) === null || _b === void 0 ? void 0 : _b.then(refreshThreads);
+            (0, chatSession_1.resetConversation)(session);
+            session.interacted = false;
+            invalidateThreads();
+            resetWrites();
+        }
+        if (!store) {
+            setIsHydrating(false);
+            return undefined;
+        }
+        setIsHydrating(true);
+        let cancelled = false;
+        (() => tslib_1.__awaiter(this, void 0, void 0, function* () {
+            var _d;
+            try {
+                const summaries = yield store.listThreads();
+                if (cancelled)
+                    return;
+                if (session.interacted) {
+                    refreshThreads();
+                    return;
+                }
+                setThreads(summaries);
+                const targetId = initialThreadId !== null && initialThreadId !== void 0 ? initialThreadId : (_d = summaries[0]) === null || _d === void 0 ? void 0 : _d.threadId;
+                const live = targetId ? (0, backgroundTurns_1.resumeBackgroundTurn)(store, targetId, screenOwner) : null;
+                if (live) {
+                    showBackgroundTurn(live);
+                    return;
+                }
+                const chat = targetId ? yield store.getThread(targetId) : null;
+                if (cancelled || session.interacted)
+                    return;
+                if (!chat) {
+                    if (targetId && (0, chatThreads_1.isLocalThreadId)(targetId))
+                        session.serverThreadId = null;
+                    return;
+                }
+                showStoredChat(chat);
+            }
+            catch (_e) {
+                /* storage unavailable: start empty */
+            }
+            finally {
+                if (!cancelled)
+                    setIsHydrating(false);
+            }
+        }))();
+        return () => {
+            cancelled = true;
+            clearForeignTimer();
+        };
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [store]);
+    // Leaving the page or unmounting mid-answer keeps the turn, settled.
+    (0, react_1.useEffect)(() => {
+        if (!store || typeof window === 'undefined')
+            return undefined;
+        window.addEventListener('pagehide', flushBeforeUnload);
+        return () => window.removeEventListener('pagehide', flushBeforeUnload);
+    }, [store, flushBeforeUnload]);
+    (0, react_1.useEffect)(() => () => {
+        if (!detachTurn())
+            settleAndPersist();
+    }, [detachTurn, settleAndPersist]);
+    (0, react_1.useEffect)(() => (0, backgroundTurns_1.subscribeBackgroundTurns)(refreshThreads), [refreshThreads]);
+    // Follow changes another tab made to the list or to the thread on screen.
+    const syncFromStore = (0, react_1.useCallback)(() => tslib_1.__awaiter(this, void 0, void 0, function* () {
+        var _a;
+        const { current } = storeRef;
+        if (!current)
+            return;
+        refreshThreads();
+        const activeId = session.storageThreadId;
+        if (!activeId)
+            return;
+        const stillActive = () => mountedRef.current && session.storageThreadId === activeId;
+        try {
+            const chat = yield current.getThread(activeId);
+            if (!stillActive())
+                return;
+            if (!chat) {
+                const rekeyed = (0, chatThreads_1.isLocalThreadId)(activeId)
+                    ? yield (0, chatThreads_1.findRekeyedThread)(current, (_a = messagesRef.current[0]) === null || _a === void 0 ? void 0 : _a.id)
+                    : null;
+                if (!stillActive())
+                    return;
+                if (rekeyed) {
+                    showStoredChat(rekeyed);
+                    return;
+                }
+                // Evicted or expired, not deleted: keep it; writing back here would ping-pong with the other tab.
+                const deleted = current.isThreadDeleted ? yield current.isThreadDeleted(activeId) : true;
+                if (!stillActive())
+                    return;
+                if (deleted)
+                    forgetConversation();
+                else
+                    session.dirty = true;
+                return;
+            }
+            // Unsaved local work first; the save's completion looks at the store again.
+            if (session.isStreaming || session.dirty || pendingWritesRef.current > 0) {
+                missedSyncRef.current = true;
+                return;
+            }
+            if (chat.updatedAt > session.lastSyncedAt) {
+                showStoredChat(chat);
+                return;
+            }
+            // Turns another tab merged in while this one streamed: add them, and store the full view.
+            const shown = new Set(messagesRef.current.map((m) => m.id));
+            if (chat.messages.some((m) => !shown.has(m.id) && !(0, chatSession_1.isOwnMessage)(session, m.id))) {
+                session.dirty = true;
+                setMessages((prev) => (0, chatThreads_1.mergeMessages)(chat.messages, prev));
+            }
+        }
+        catch (_b) {
+            /* ignore */
+        }
+    }), [
+        session,
+        storeRef,
+        messagesRef,
+        refreshThreads,
+        showStoredChat,
+        forgetConversation,
+        mountedRef,
+        setMessages,
+    ]);
+    // Save once a turn has settled.
+    (0, react_1.useEffect)(() => {
+        var _a;
+        if (!storeRef.current || messages.length === 0)
+            return;
+        if (isStreaming || !session.dirty)
+            return;
+        session.dirty = false;
+        (_a = persistNow()) === null || _a === void 0 ? void 0 : _a.then(() => {
+            if (!missedSyncRef.current) {
+                refreshThreads();
+                return;
+            }
+            missedSyncRef.current = false;
+            syncFromStore();
+        });
+    }, [messages, isStreaming, session, storeRef, persistNow, refreshThreads, syncFromStore]);
+    (0, react_1.useEffect)(() => {
+        if (!(store === null || store === void 0 ? void 0 : store.subscribe))
+            return undefined;
+        return store.subscribe(() => {
+            syncFromStore();
+        });
+    }, [store, syncFromStore]);
+    /** The user is sending a message: nothing still loading may land on top of it. */
+    const beginTurn = (0, react_1.useCallback)(() => {
+        session.interacted = true;
+        session.loadRequest += 1;
+        setIsHydrating(false);
+    }, [session]);
+    const clearHistory = (0, react_1.useCallback)(() => {
+        const storedIds = forgetConversation();
+        const { current } = storeRef;
+        if (storedIds.length === 0 || !current)
+            return;
+        // Queued behind pending saves so one of them cannot recreate the deleted thread.
+        enqueueWrite(() => Promise.all(storedIds.map((id) => current.deleteThread(id).catch(() => { }))).then(() => { })).then(refreshThreads);
+    }, [forgetConversation, storeRef, enqueueWrite, refreshThreads]);
+    const leaveConversation = (0, react_1.useCallback)(() => {
+        var _a;
+        if (!detachTurn())
+            (_a = settleAndPersist()) === null || _a === void 0 ? void 0 : _a.then(refreshThreads);
+        forgetConversation();
+    }, [detachTurn, settleAndPersist, refreshThreads, forgetConversation]);
+    const newThread = leaveConversation;
+    const switchThread = (0, react_1.useCallback)((threadId) => tslib_1.__awaiter(this, void 0, void 0, function* () {
+        const { current } = storeRef;
+        if (!current || threadId === session.storageThreadId)
+            return;
+        leaveConversation();
+        const live = (0, backgroundTurns_1.resumeBackgroundTurn)(current, threadId, screenOwner);
+        if (live) {
+            showBackgroundTurn(live);
+            return;
+        }
+        const request = session.loadRequest;
+        const stillWanted = () => mountedRef.current && request === session.loadRequest;
+        setIsHydrating(true);
+        try {
+            const chat = yield current.getThread(threadId);
+            if (stillWanted() && chat)
+                showStoredChat(chat);
+        }
+        catch (_c) {
+            /* keep the empty conversation */
+        }
+        finally {
+            if (stillWanted())
+                setIsHydrating(false);
+        }
+    }), [
+        session,
+        storeRef,
+        leaveConversation,
+        screenOwner,
+        showBackgroundTurn,
+        showStoredChat,
+        mountedRef,
+    ]);
+    return {
+        isHydrating,
+        threads,
+        activeThreadId,
+        foreignInFlight,
+        beginTurn,
+        screenOwner,
+        clearHistory,
+        newThread,
+        switchThread,
+    };
+}
+exports.default = useChatPersistence;

package/lib/cjs/hooks/persistence/useForeignStream.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const react_1 = require("react");
+/** An answer streaming in another tab: blocks sending and settles after the grace period. */
+function useForeignStream(session) {
+    const [foreignInFlight, setForeignInFlight] = (0, react_1.useState)(false);
+    const timerRef = (0, react_1.useRef)(null);
+    const setForeign = (0, react_1.useCallback)((value) => {
+        session.foreignInFlight = value;
+        setForeignInFlight(value);
+    }, [session]);
+    const clearTimer = (0, react_1.useCallback)(() => {
+        if (timerRef.current)
+            clearTimeout(timerRef.current);
+        timerRef.current = null;
+    }, []);
+    /** Show the thread as streaming elsewhere, then run `onExpire` unless cleared before. */
+    const watch = (0, react_1.useCallback)((remainingMs, onExpire) => {
+        clearTimer();
+        setForeign(true);
+        timerRef.current = setTimeout(() => {
+            timerRef.current = null;
+            setForeign(false);
+            onExpire();
+        }, remainingMs);
+    }, [clearTimer, setForeign]);
+    const stop = (0, react_1.useCallback)(() => {
+        clearTimer();
+        setForeign(false);
+    }, [clearTimer, setForeign]);
+    (0, react_1.useEffect)(() => clearTimer, [clearTimer]);
+    return { foreignInFlight, setForeignInFlight, watch, stop, clearTimer };
+}
+exports.default = useForeignStream;

package/lib/cjs/hooks/persistence/useThreadList.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const react_1 = require("react");
+const useIsMounted_1 = tslib_1.__importDefault(require("../useIsMounted"));
+/** Whether two thread lists describe the same state, so an unchanged re-read can be dropped. */
+function sameThreads(a, b) {
+    return (a.length === b.length &&
+        a.every((t, i) => {
+            const other = b[i];
+            return (t.threadId === other.threadId &&
+                t.updatedAt === other.updatedAt &&
+                t.createdAt === other.createdAt &&
+                t.inFlight === other.inFlight &&
+                t.title === other.title);
+        }));
+}
+/** The stored thread list, re-read on demand; only the latest read may land. */
+function useThreadList(storeRef) {
+    const [threads, setThreads] = (0, react_1.useState)([]);
+    const requestRef = (0, react_1.useRef)(0);
+    const mountedRef = (0, useIsMounted_1.default)();
+    /** Drop the result of any read still in flight. */
+    const invalidate = (0, react_1.useCallback)(() => {
+        requestRef.current += 1;
+    }, []);
+    const refreshThreads = (0, react_1.useCallback)(() => tslib_1.__awaiter(this, void 0, void 0, function* () {
+        const store = storeRef.current;
+        if (!store)
+            return;
+        requestRef.current += 1;
+        const request = requestRef.current;
+        try {
+            const list = yield store.listThreads();
+            if (!mountedRef.current || request !== requestRef.current)
+                return;
+            setThreads((prev) => (sameThreads(prev, list) ? prev : list));
+        }
+        catch (_a) {
+            /* ignore */
+        }
+    }), [storeRef, mountedRef]);
+    return { threads, setThreads, refreshThreads, invalidate };
+}
+exports.default = useThreadList;

package/lib/cjs/hooks/persistence/useWriteQueue.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const react_1 = require("react");
+/** Runs storage writes one after another, in the order they were issued. */
+function useWriteQueue() {
+    const chainRef = (0, react_1.useRef)(Promise.resolve());
+    const enqueue = (0, react_1.useCallback)((run) => {
+        chainRef.current = chainRef.current.then(run, run);
+        return chainRef.current;
+    }, []);
+    /** Forget pending writes, so a slow one cannot delay writes into a different store. */
+    const reset = (0, react_1.useCallback)(() => {
+        chainRef.current = Promise.resolve();
+    }, []);
+    return { enqueue, reset };
+}
+exports.default = useWriteQueue;