@constructor-io/constructorio-ui-asa 1.7.2 → 1.9.0

package/lib/cjs/utils/chatSession.js

@@ -0,0 +1,98 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.prepareSnapshot = exports.adoptSession = exports.forkSession = exports.adoptStoredChat = exports.isOwnMessage = exports.nextMessageId = exports.resetConversation = exports.createChatSession = void 0;
+const chatThreads_1 = require("./chatThreads");
+const productNormalizer_1 = require("./productNormalizer");
+function createChatSession(initialThreadId, normalizeItem = productNormalizer_1.normalizeItemToProduct) {
+    return {
+        normalizeItem,
+        serverThreadId: initialThreadId && !(0, chatThreads_1.isLocalThreadId)(initialThreadId) ? initialThreadId : null,
+        storageThreadId: null,
+        orphanIds: [],
+        createdAt: null,
+        lastSyncedAt: 0,
+        dirty: false,
+        interacted: false,
+        loadRequest: 0,
+        isStreaming: false,
+        foreignInFlight: false,
+        idCounter: 0,
+        idSuffix: (0, chatThreads_1.randomId)().slice(0, 6),
+    };
+}
+exports.createChatSession = createChatSession;
+/** Forget the current conversation. Returns the id it was stored under, if any. */
+function resetConversation(session) {
+    const storedId = session.storageThreadId;
+    session.serverThreadId = null;
+    session.storageThreadId = null;
+    session.orphanIds = [];
+    session.createdAt = null;
+    session.lastSyncedAt = 0;
+    session.dirty = false;
+    session.loadRequest += 1;
+    session.isStreaming = false;
+    session.foreignInFlight = false;
+    return storedId;
+}
+exports.resetConversation = resetConversation;
+function nextMessageId(session) {
+    session.idCounter += 1;
+    return `msg-${session.idCounter}-${Date.now()}-${session.idSuffix}`;
+}
+exports.nextMessageId = nextMessageId;
+/** Whether `messageId` was minted by this session rather than by another tab. */
+function isOwnMessage(session, messageId) {
+    return messageId.endsWith(`-${session.idSuffix}`);
+}
+exports.isOwnMessage = isOwnMessage;
+/** Makes a stored conversation the one this session continues. */
+function adoptStoredChat(session, chat) {
+    session.storageThreadId = chat.threadId;
+    session.createdAt = chat.createdAt;
+    session.serverThreadId = (0, chatThreads_1.isLocalThreadId)(chat.threadId) ? null : chat.threadId;
+    session.idCounter = (0, chatThreads_1.nextMessageCounter)(chat.messages);
+    session.lastSyncedAt = chat.updatedAt;
+}
+exports.adoptStoredChat = adoptStoredChat;
+/** A copy that keeps the conversation `session` holds while `session` itself moves on. */
+function forkSession(session) {
+    return Object.assign(Object.assign({}, session), { orphanIds: [...session.orphanIds] });
+}
+exports.forkSession = forkSession;
+/** Makes `session` continue the conversation `from` kept, showing `messages`. */
+function adoptSession(session, from, messages) {
+    session.serverThreadId = from.serverThreadId;
+    session.storageThreadId = from.storageThreadId;
+    session.orphanIds = [...from.orphanIds];
+    session.createdAt = from.createdAt;
+    session.lastSyncedAt = from.lastSyncedAt;
+    session.idCounter = (0, chatThreads_1.nextMessageCounter)(messages);
+}
+exports.adoptSession = adoptSession;
+/** Builds the record to write and moves the session onto its key; `staleIds` are the records to retire once stored. */
+function prepareSnapshot(session, messages, now = Date.now()) {
+    var _a, _b, _c;
+    const previousId = session.storageThreadId;
+    const threadId = (_b = (_a = session.serverThreadId) !== null && _a !== void 0 ? _a : previousId) !== null && _b !== void 0 ? _b : (0, chatThreads_1.createLocalThreadId)();
+    const staleIds = [previousId !== threadId ? previousId : null, ...session.orphanIds].filter((id) => id !== null && id !== threadId);
+    // Strictly increasing so other tabs read a same-millisecond save as newer.
+    const updatedAt = Math.max(now, session.lastSyncedAt + 1);
+    const createdAt = (_c = session.createdAt) !== null && _c !== void 0 ? _c : updatedAt;
+    session.storageThreadId = threadId;
+    session.orphanIds = [];
+    session.createdAt = createdAt;
+    session.lastSyncedAt = updatedAt;
+    return {
+        staleIds: Array.from(new Set(staleIds)),
+        snapshot: {
+            version: chatThreads_1.PERSISTED_CHAT_VERSION,
+            threadId,
+            messages: (0, chatThreads_1.compactMessages)(messages, session.normalizeItem),
+            createdAt,
+            updatedAt,
+            owner: (0, chatThreads_1.getTabId)(),
+        },
+    };
+}
+exports.prepareSnapshot = prepareSnapshot;

package/lib/cjs/utils/chatThreads.js

@@ -0,0 +1,248 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.moveThreads = exports.foreignStreamRemainingMs = exports.isThreadStreaming = exports.findRekeyedThread = exports.saveThreadAndRetireStale = exports.mergeMessages = exports.compactMessages = exports.normalizeHydratedMessages = exports.isInFlight = exports.nextMessageCounter = exports.getThreadTitle = exports.isLocalThreadId = exports.getTabId = exports.createLocalThreadId = exports.randomId = exports.IN_FLIGHT_GRACE_MS = exports.DEFAULT_PERSISTENCE_TTL_MS = exports.DEFAULT_PERSISTENCE_KEY = exports.PERSISTED_CHAT_VERSION = void 0;
+const tslib_1 = require("tslib");
+/** Stored record format; records with another version are ignored on read. */
+exports.PERSISTED_CHAT_VERSION = 1;
+/** Prefix of the `localStorage` key; the api key, domain and user id are appended to it. */
+exports.DEFAULT_PERSISTENCE_KEY = 'cio-asa:chat';
+/** One week, matching how long the agent itself remembers a thread. */
+exports.DEFAULT_PERSISTENCE_TTL_MS = 7 * 24 * 60 * 60 * 1000;
+/** How long a stored answer written by another tab is still shown as "typing" before it is settled. */
+exports.IN_FLIGHT_GRACE_MS = 60 * 1000;
+/** Marks client-side thread ids, used before the server has assigned one. Never sent to the agent. */
+const LOCAL_THREAD_PREFIX = 'local-';
+/** Thread titles are the first question, cut to this many characters. */
+const TITLE_MAX_LENGTH = 80;
+let fallbackCounter = 0;
+/** Random token for the ids that must not collide between tabs: threads, tabs and messages. */
+function randomId() {
+    if (typeof crypto !== 'undefined') {
+        if (typeof crypto.randomUUID === 'function')
+            return crypto.randomUUID();
+        if (typeof crypto.getRandomValues === 'function') {
+            const bytes = crypto.getRandomValues(new Uint8Array(16));
+            return Array.from(bytes, (b) => b.toString(16).padStart(2, '0')).join('');
+        }
+    }
+    fallbackCounter += 1;
+    return `${Date.now().toString(36)}-${fallbackCounter.toString(36)}`;
+}
+exports.randomId = randomId;
+/** Client-side thread id for a conversation the server has not named yet. */
+function createLocalThreadId() {
+    return `${LOCAL_THREAD_PREFIX}${randomId()}`;
+}
+exports.createLocalThreadId = createLocalThreadId;
+const TAB_ID_KEY = 'cio-asa:tab';
+let tabId;
+/** Whether this page load is a reload, as opposed to a new, duplicated or restored tab. */
+function isReload() {
+    try {
+        const [entry] = performance.getEntriesByType('navigation');
+        return (entry === null || entry === void 0 ? void 0 : entry.type) === 'reload';
+    }
+    catch (_a) {
+        return false;
+    }
+}
+/**
+ * Per-tab id: survives a reload, differs between tabs, `undefined` on the server. A duplicated tab
+ * copies `sessionStorage`, so the id is read back on a reload only, and is kept there only while
+ * the page is hidden.
+ */
+function getTabId() {
+    if (tabId)
+        return tabId;
+    if (typeof window === 'undefined')
+        return undefined;
+    const id = randomId();
+    tabId = id;
+    try {
+        const { sessionStorage } = window;
+        tabId = (isReload() && sessionStorage.getItem(TAB_ID_KEY)) || id;
+        sessionStorage.removeItem(TAB_ID_KEY);
+        const claimed = tabId;
+        window.addEventListener('pagehide', () => {
+            try {
+                sessionStorage.setItem(TAB_ID_KEY, claimed);
+            }
+            catch (_a) {
+                /* ignore */
+            }
+        });
+        window.addEventListener('pageshow', (event) => {
+            if (!event.persisted)
+                return;
+            try {
+                sessionStorage.removeItem(TAB_ID_KEY);
+            }
+            catch (_a) {
+                /* ignore */
+            }
+        });
+    }
+    catch (_a) {
+        /* sessionStorage blocked: the id lasts for this page only */
+    }
+    return tabId;
+}
+exports.getTabId = getTabId;
+/** Whether `threadId` was made by `createLocalThreadId` rather than by the server. */
+function isLocalThreadId(threadId) {
+    return typeof threadId === 'string' && threadId.startsWith(LOCAL_THREAD_PREFIX);
+}
+exports.isLocalThreadId = isLocalThreadId;
+/** Title for a thread list: the first user message, truncated with an ellipsis. */
+function getThreadTitle(messages) {
+    var _a, _b;
+    const first = (_b = (_a = messages.find((m) => m.role === 'user')) === null || _a === void 0 ? void 0 : _a.text) !== null && _b !== void 0 ? _b : '';
+    return first.length > TITLE_MAX_LENGTH ? `${first.slice(0, TITLE_MAX_LENGTH - 1)}…` : first;
+}
+exports.getThreadTitle = getThreadTitle;
+/** Counter to continue message ids from after a restore, so new ids never collide with restored ones. */
+function nextMessageCounter(messages) {
+    return messages.reduce((max, m) => {
+        const match = /^msg-(\d+)-/.exec(m.id);
+        return match ? Math.max(max, Number(match[1])) : max;
+    }, messages.length);
+}
+exports.nextMessageCounter = nextMessageCounter;
+/** Whether the latest answer in `messages` has not finished streaming. */
+function isInFlight(messages) {
+    const last = messages[messages.length - 1];
+    return (last === null || last === void 0 ? void 0 : last.status) === 'loading' || (last === null || last === void 0 ? void 0 : last.status) === 'streaming';
+}
+exports.isInFlight = isInFlight;
+/** Settles answers stored mid-stream: `done` when they have content, an interrupted `error` otherwise. */
+function normalizeHydratedMessages(messages) {
+    return messages.map((m) => {
+        var _a;
+        if (m.status !== 'loading' && m.status !== 'streaming')
+            return m;
+        const hasContent = Boolean(m.text) || Boolean((_a = m.groups) === null || _a === void 0 ? void 0 : _a.length) || Boolean(m.refinement);
+        return hasContent ? Object.assign(Object.assign({}, m), { status: 'done' }) : Object.assign(Object.assign({}, m), { status: 'error', interrupted: true });
+    });
+}
+exports.normalizeHydratedMessages = normalizeHydratedMessages;
+/** Messages as stored: raw items replaced by the cards `normalize` makes; a restored group keeps its cards. */
+function compactMessages(messages, normalize) {
+    return messages.map((m) => {
+        var _a;
+        return ((_a = m.groups) === null || _a === void 0 ? void 0 : _a.length)
+            ? Object.assign(Object.assign({}, m), { groups: m.groups.map((g) => {
+                    var _a;
+                    return (Object.assign(Object.assign({}, g), { searchResults: [], products: (_a = g.products) !== null && _a !== void 0 ? _a : g.searchResults.map(normalize) }));
+                }) }) : m;
+    });
+}
+exports.compactMessages = compactMessages;
+const isUnsettled = (m) => m.status === 'loading' || m.status === 'streaming';
+/**
+ * Both lists in stored order; a shared message takes the incoming version unless `preferStored`.
+ * A settled incoming version still replaces a stored one mid-stream: it is the later one by definition.
+ */
+function mergeMessages(stored, incoming, preferStored = false) {
+    const incomingById = new Map(incoming.map((m) => [m.id, m]));
+    const storedIds = new Set(stored.map((m) => m.id));
+    return [
+        ...stored.map((m) => {
+            const update = incomingById.get(m.id);
+            if (!update)
+                return m;
+            if (!preferStored)
+                return update;
+            return isUnsettled(m) && !isUnsettled(update) ? update : m;
+        }),
+        ...incoming.filter((m) => !storedIds.has(m.id)),
+    ];
+}
+exports.mergeMessages = mergeMessages;
+/**
+ * Saves `snapshot`, then deletes `staleIds` once the new record is read back. Stores may fail
+ * without throwing, so both steps are checked by reading: `saved` is whether the snapshot landed,
+ * `leftover` the stale ids still stored.
+ */
+function saveThreadAndRetireStale(store, snapshot, staleIds) {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        try {
+            yield store.saveThread(snapshot);
+        }
+        catch (_a) {
+            return { saved: false, leftover: staleIds };
+        }
+        const persisted = yield store.getThread(snapshot.threadId).catch(() => null);
+        if (!persisted || persisted.updatedAt < snapshot.updatedAt) {
+            return { saved: false, leftover: staleIds };
+        }
+        const retired = yield Promise.all(staleIds.map((id) => tslib_1.__awaiter(this, void 0, void 0, function* () {
+            yield store.deleteThread(id).catch(() => { });
+            return (yield store.getThread(id).catch(() => null)) === null;
+        })));
+        return { saved: true, leftover: staleIds.filter((_, i) => !retired[i]) };
+    });
+}
+exports.saveThreadAndRetireStale = saveThreadAndRetireStale;
+/** Finds the server-keyed record another tab re-keyed a local thread into, by its first message. */
+function findRekeyedThread(store, firstMessageId) {
+    var _a;
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        if (!firstMessageId)
+            return null;
+        const list = yield store.listThreads();
+        const candidates = list.filter((t) => !isLocalThreadId(t.threadId));
+        const loaded = yield Promise.all(candidates.map((t) => store.getThread(t.threadId)));
+        return (_a = loaded.find((c) => { var _a; return ((_a = c === null || c === void 0 ? void 0 : c.messages[0]) === null || _a === void 0 ? void 0 : _a.id) === firstMessageId; })) !== null && _a !== void 0 ? _a : null;
+    });
+}
+exports.findRekeyedThread = findRekeyedThread;
+/** Whether a stored thread still reads as streaming: this tab's own always, another tab's only within the grace. */
+function isThreadStreaming(chat, now = Date.now()) {
+    if (!isInFlight(chat.messages))
+        return false;
+    if (chat.owner !== undefined && chat.owner === getTabId())
+        return true;
+    return now - chat.updatedAt < exports.IN_FLIGHT_GRACE_MS;
+}
+exports.isThreadStreaming = isThreadStreaming;
+/** Ms left to show a stored answer as streaming in another tab; `0` when it should be settled. */
+function foreignStreamRemainingMs(chat, now = Date.now()) {
+    if (!isInFlight(chat.messages))
+        return 0;
+    if (chat.owner !== undefined && chat.owner === getTabId())
+        return 0;
+    return Math.max(0, exports.IN_FLIGHT_GRACE_MS - (now - chat.updatedAt));
+}
+exports.foreignStreamRemainingMs = foreignStreamRemainingMs;
+/**
+ * Moves every thread of `from` into `to`; copies of the chat on screen are not copied, its owner
+ * saves it. A source record is deleted only once `to` holds it after every copy was made, so one
+ * copy evicting another, or a save that did not land, leaves the source in place.
+ */
+function moveThreads(from, to, onScreen = {}) {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        const { threadIds = [], firstMessageId } = onScreen;
+        const summaries = yield from.listThreads();
+        const chats = (yield Promise.all(summaries.map((t) => from.getThread(t.threadId)))).filter((chat) => chat !== null);
+        const isShown = (chat) => {
+            var _a;
+            return threadIds.includes(chat.threadId) ||
+                (firstMessageId !== undefined && ((_a = chat.messages[0]) === null || _a === void 0 ? void 0 : _a.id) === firstMessageId);
+        };
+        const toCopy = chats.filter((chat) => !isShown(chat));
+        yield Promise.all(toCopy.map((chat) => to.saveThread(chat)));
+        const targetList = yield to.listThreads();
+        const target = new Map((yield Promise.all(targetList.map((t) => to.getThread(t.threadId))))
+            .filter((chat) => chat !== null)
+            .map((chat) => [chat.threadId, chat]));
+        const shownSaved = Array.from(target.values()).some(isShown);
+        const moved = chats.filter((chat) => {
+            if (isShown(chat))
+                return shownSaved;
+            const copy = target.get(chat.threadId);
+            return copy !== undefined && copy.updatedAt >= chat.updatedAt;
+        });
+        yield Promise.all(moved.map((chat) => from.deleteThread(chat.threadId)));
+    });
+}
+exports.moveThreads = moveThreads;

package/lib/cjs/utils/clientOptions.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readClientOptions = void 0;
+/** `options` is private in the client's typings; read it here only, so a client bump fails a test, not storage keys. */
+function readClientOptions(client) {
+    const { options } = (client !== null && client !== void 0 ? client : {});
+    if (!options || typeof options !== 'object')
+        return undefined;
+    return options;
+}
+exports.readClientOptions = readClientOptions;