@joinskips/brand 9.0.0-develop.148 → 9.0.0-develop.149

package/chat/chat/generated/skips-app/types.gen.js

@@ -0,0 +1,2 @@
+// This file is auto-generated by @hey-api/openapi-ts
+export {};

package/chat/chat/index.d.ts

@@ -0,0 +1,3 @@
+export { SkipsChat, type SkipsChatProps, type SkipsChatWelcome, type SkipsChatWords } from './SkipsChat.tsx';
+export type { SkipsChatMember, SkipsChatOptions } from './useSkipsChat.ts';
+export * from './connection.ts';

package/chat/chat/index.js

@@ -0,0 +1,2 @@
+export { SkipsChat } from "./SkipsChat.js";
+export * from "./connection.js";

package/chat/chat/platform.d.ts

@@ -0,0 +1,4 @@
+import type { Socket } from '../helpers/index.ts';
+import type { SessionStore } from './session.ts';
+export declare function platformSocket(url: string): Socket;
+export declare function platformStore(): SessionStore;

package/chat/chat/platform.js

@@ -0,0 +1,46 @@
+// The platform's WebSocket behind the small shape the live feed expects (openCable). Browsers and phones both have
+// one.
+export function platformSocket(url) {
+    const socket = new WebSocket(url);
+    const adapter = {
+        send: (data) => {
+            socket.send(data);
+        },
+        close: () => {
+            socket.close();
+        },
+        onopen: null,
+        onmessage: null,
+        onclose: null,
+        onerror: null,
+    };
+    socket.onerror = (event) => {
+        adapter.onerror?.(event);
+    };
+    socket.onopen = (event) => {
+        adapter.onopen?.(event);
+    };
+    socket.onmessage = (event) => {
+        adapter.onmessage?.({ data: event.data });
+    };
+    socket.onclose = (event) => {
+        adapter.onclose?.(event);
+    };
+    return adapter;
+}
+// The tab's sessionStorage on the web, which ends a visitor's chat with its tab. A phone has none, so there the
+// chat keeps it for as long as the app runs.
+export function platformStore() {
+    if (typeof sessionStorage !== 'undefined')
+        return sessionStorage;
+    const kept = new Map();
+    return {
+        getItem: (key) => kept.get(key) ?? null,
+        setItem: (key, value) => {
+            kept.set(key, value);
+        },
+        removeItem: (key) => {
+            kept.delete(key);
+        },
+    };
+}

package/chat/chat/session.d.ts

@@ -0,0 +1,19 @@
+import { type ContactSession, type Conversation } from './client.ts';
+export interface ChatSession {
+    contact: ContactSession;
+    conversation: Conversation;
+}
+export interface SessionStore {
+    getItem(key: string): string | null;
+    setItem(key: string, value: string): void;
+    removeItem(key: string): void;
+}
+export declare function sessionKey(inboxIdentifier: string): string;
+export declare const SESSION_IDLE_MS: number;
+export declare function loadSession(store: SessionStore, inboxIdentifier: string, now: number): ChatSession | null;
+export declare function sessionEndsAt(store: SessionStore, inboxIdentifier: string, now: number): number | null;
+export declare function saveSession(store: SessionStore, inboxIdentifier: string, session: ChatSession, now: number): void;
+export declare function clearSession(store: SessionStore, inboxIdentifier: string): void;
+export declare function readKey(inboxIdentifier: string): string;
+export declare function loadReadThrough(store: SessionStore, inboxIdentifier: string): number;
+export declare function saveReadThrough(store: SessionStore, inboxIdentifier: string, id: number): void;

package/chat/chat/session.js

@@ -0,0 +1,95 @@
+// What the browser keeps so a refresh returns to the same conversation: the contact
+// and the conversation, under one key per inbox. The store is injected (sessionStorage
+// on the web, so a chat ends with its tab), a chat left idle too long is forgotten, and
+// anything unreadable counts as no session. The code a visitor was emailed is never kept.
+import { isInbox, isRecord } from "./client.js";
+export function sessionKey(inboxIdentifier) {
+    return `skips-chat:${inboxIdentifier}`;
+}
+function isSession(value) {
+    return (isRecord(value) &&
+        isRecord(value.contact) &&
+        typeof value.contact.sourceId === 'string' &&
+        typeof value.contact.pubsubToken === 'string' &&
+        (value.contact.inboxIdentifier === undefined || isInbox(value.contact.inboxIdentifier)) &&
+        isRecord(value.conversation) &&
+        typeof value.conversation.id === 'number');
+}
+// How long a chat stays signed in after it was last used. A visitor who comes back later
+// than this is asked for a new code.
+export const SESSION_IDLE_MS = 30 * 60 * 1000;
+function isKept(value) {
+    return isRecord(value) && typeof value.usedAt === 'number' && isSession(value);
+}
+// The session this store holds with when it was last used, if that was within the idle limit. One
+// left idle longer, or left by a version that kept no time with it, is removed so that what opens a
+// conversation does not stay behind.
+function loadKept(store, inboxIdentifier, now) {
+    try {
+        const key = sessionKey(inboxIdentifier);
+        const raw = store.getItem(key);
+        if (raw === null)
+            return null;
+        const parsed = JSON.parse(raw);
+        if (isKept(parsed) && now - parsed.usedAt <= SESSION_IDLE_MS)
+            return parsed;
+        clearSession(store, inboxIdentifier);
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
+export function loadSession(store, inboxIdentifier, now) {
+    const kept = loadKept(store, inboxIdentifier, now);
+    return kept && { contact: kept.contact, conversation: kept.conversation };
+}
+// When the stored session's idle limit runs out, or null when there is no session to run out.
+export function sessionEndsAt(store, inboxIdentifier, now) {
+    const kept = loadKept(store, inboxIdentifier, now);
+    return kept && kept.usedAt + SESSION_IDLE_MS;
+}
+// Keeps the session as used at `now`. Saving it again starts its idle limit again.
+export function saveSession(store, inboxIdentifier, session, now) {
+    try {
+        const kept = { ...session, usedAt: now };
+        store.setItem(sessionKey(inboxIdentifier), JSON.stringify(kept));
+    }
+    catch {
+        // Storage can be blocked; the conversation then lasts one page view.
+    }
+}
+export function clearSession(store, inboxIdentifier) {
+    try {
+        store.removeItem(sessionKey(inboxIdentifier));
+        store.removeItem(readKey(inboxIdentifier));
+    }
+    catch {
+        // Nothing to clear if it could not be stored.
+    }
+}
+export function readKey(inboxIdentifier) {
+    return `skips-chat-read:${inboxIdentifier}`;
+}
+// The newest message the visitor has had on their screen, by the Skips App's id (they only grow). The
+// header's chat button counts the replies after it as unread, on this page or the next one.
+export function loadReadThrough(store, inboxIdentifier) {
+    try {
+        const stored = Number(store.getItem(readKey(inboxIdentifier)));
+        return Number.isSafeInteger(stored) ? stored : 0;
+    }
+    catch {
+        return 0;
+    }
+}
+// Only ever moves forward: an older list arriving late does not make a reply unread again.
+export function saveReadThrough(store, inboxIdentifier, id) {
+    if (id <= loadReadThrough(store, inboxIdentifier))
+        return;
+    try {
+        store.setItem(readKey(inboxIdentifier), String(id));
+    }
+    catch {
+        // Storage can be blocked; the count then starts from the first reply of the next page.
+    }
+}

package/chat/chat/useSkipsChat.d.ts

@@ -0,0 +1,78 @@
+import { type ChatMessage, type ChoiceItem, type PickedFile, type Socket, type Thread, type ThreadMessage } from '../helpers/index.ts';
+import type { SkipsTyping } from '../hooks/index.ts';
+import { type ContactSession } from './client.ts';
+import { type SessionStore } from './session.ts';
+export type ChatStatus = 'starting' | 'ready' | 'unreachable';
+export interface SkipsChatOptions {
+    baseUrl: string;
+    inboxIdentifier: string;
+    careTeamName: string;
+    pageAddress?: string | undefined;
+    fetchFn?: typeof fetch | undefined;
+    createSocket?: ((url: string) => Socket) | undefined;
+    store?: SessionStore | undefined;
+    now?: (() => number) | undefined;
+    opening?: string | undefined;
+    verifyUrl?: string | undefined;
+    idleMs?: number | undefined;
+    onSignedOut?: (() => void) | undefined;
+    member?: SkipsChatMember | undefined;
+}
+export interface SkipsChatMember {
+    contact: ContactSession;
+    conversationId: number | null;
+    onStarted?: ((conversationId: number) => void) | undefined;
+    onSent?: ((conversationId: number, message: ChatMessage) => void) | undefined;
+}
+interface WelcomeBase {
+    line: string;
+    unreachable: boolean;
+}
+interface WelcomeAsking extends WelcomeBase {
+    step: 'choosing' | 'email';
+    email?: string | undefined;
+}
+export interface WelcomeCode extends WelcomeBase {
+    step: 'code';
+    email: string;
+    noMatch: boolean;
+    ranOut: boolean;
+    codes: number;
+}
+export interface WelcomeName extends WelcomeBase {
+    step: 'name';
+    email: string;
+    code: string;
+    codes: number;
+}
+interface WelcomeThrough extends WelcomeBase {
+    step: 'through';
+    email: string;
+    named: boolean;
+    signedIn: boolean;
+    lineId: number;
+}
+export type Welcome = WelcomeAsking | WelcomeCode | WelcomeName | WelcomeThrough;
+export interface ChatState {
+    thread: Thread;
+    status: ChatStatus;
+    send: (text: string, picked?: PickedFile | null) => Promise<void>;
+    retry: (failed: ThreadMessage) => Promise<void>;
+    tryAgain: () => void;
+    reconnecting: boolean;
+    loadOlder: () => Promise<void>;
+    typed: (text: string) => void;
+    stillHere: () => void;
+    welcome: Welcome | null;
+    continueHere: (line: string) => void;
+    sendCode: (email: string) => Promise<void>;
+    checkCode: (step: WelcomeCode, code: string) => Promise<void>;
+    giveName: (step: WelcomeName, name: string) => Promise<void>;
+    changeEmail: (step: WelcomeCode | WelcomeName) => void;
+    skipsTyping: SkipsTyping;
+    choose: (question: ThreadMessage, answer: ChoiceItem) => Promise<void>;
+    choosing: string | null;
+    choiceFailed: number | null;
+}
+export declare function useSkipsChat({ baseUrl, inboxIdentifier, careTeamName, pageAddress, fetchFn, createSocket, store: givenStore, opening, verifyUrl, idleMs, ...changing }: SkipsChatOptions): ChatState;
+export {};