@chatlychat/sdk-js 0.0.0-stage → 0.1.0

package/dist/live.js

@@ -0,0 +1,158 @@
+/**
+ * How many message ids a subscription remembers.
+ *
+ * Unbounded, a long-lived tab on a busy conversation keeps every id it has
+ * ever seen. The cap is far above any realistic poll window, and the oldest
+ * are dropped first — a message older than the last thousand cannot appear as
+ * "new" in a later poll of the most recent page.
+ */
+const MAX_REMEMBERED = 1_000;
+/**
+ * The messages in `batch` that `seen` has not yet been told about, oldest
+ * first, with `seen` updated.
+ *
+ * Ordered by `createdAt` rather than by the order the server returned: a list
+ * endpoint is free to answer newest-first, and a consumer appending in
+ * receive order would render the conversation upside down.
+ *
+ * Deliberately NOT the widget's `mergePolled`. That one reconciles optimistic
+ * `local-*` rows against their server copies, which only matters to a UI that
+ * renders a message before the server has one. A headless consumer owns that
+ * decision themselves; all they need from us is "what is new".
+ */
+export function newMessagesSince(seen, batch) {
+    const fresh = [];
+    for (const message of batch) {
+        const id = message?.id;
+        if (typeof id !== 'string' || id.length === 0) {
+            // A row we cannot key is a row we would emit again on every poll.
+            continue;
+        }
+        if (seen.has(id)) {
+            continue;
+        }
+        seen.add(id);
+        fresh.push(message);
+    }
+    fresh.sort((a, b) => String(a.createdAt).localeCompare(String(b.createdAt)));
+    if (seen.size > MAX_REMEMBERED) {
+        // Insertion-ordered, so the first entries are the oldest.
+        const excess = seen.size - MAX_REMEMBERED;
+        let dropped = 0;
+        for (const id of seen) {
+            if (dropped >= excess) {
+                break;
+            }
+            seen.delete(id);
+            dropped += 1;
+        }
+    }
+    return fresh;
+}
+/**
+ * How long a "typing" indicator survives without another `typing.start`.
+ *
+ * ── Why the SDK owns this timeout and not the consumer ──────────────────
+ *
+ * `typing.stop` is best-effort. The dashboard emits one after 5s of idle
+ * keystrokes and on send, and its hook emits one on unmount — but an agent
+ * who closes the laptop mid-sentence, loses their network, or whose tab is
+ * killed sends nothing at all. A consumer rendering the raw start/stop pair
+ * gets an indicator that says "Sarah is typing…" forever, which is the exact
+ * shape of bug this codebase keeps finding: it appears to work.
+ *
+ * Leaving it to the consumer means every consumer writes this same timer, and
+ * the ones who do not ship the stuck indicator. 3,500ms is the widget's own
+ * window (`use-conversation-realtime.tsx`), so a custom UI built on the SDK
+ * behaves like the widget rather than subtly differently.
+ */
+export const TYPING_STOP_AFTER_MS = 3_500;
+/**
+ * Turn a stream of `typing.start` / `typing.stop` events into the single
+ * boolean a UI actually renders.
+ *
+ * Edge-triggered: `onChange` fires only when the answer changes, so a
+ * keystroke every 300ms does not re-render the consumer's component ten times
+ * a second. Exported for its own test — the timer behaviour is the part worth
+ * pinning, and it is invisible from the outside.
+ */
+export function createTypingTracker(opts) {
+    const stopAfterMs = opts.stopAfterMs ?? TYPING_STOP_AFTER_MS;
+    let timer = null;
+    let active = null;
+    const clear = () => {
+        if (timer !== null) {
+            clearTimeout(timer);
+            timer = null;
+        }
+    };
+    const settle = (actor, isTyping) => {
+        if (isTyping === (active !== null)) {
+            return;
+        }
+        active = isTyping ? actor : null;
+        opts.onChange({ ...actor, isTyping });
+    };
+    return {
+        start(actor) {
+            settle(actor, true);
+            clear();
+            timer = setTimeout(() => {
+                timer = null;
+                settle(actor, false);
+            }, stopAfterMs);
+        },
+        stop(actor) {
+            clear();
+            // The ACTIVE actor is preferred over the one passed in, so the
+            // `isTyping: false` signal names whoever the consumer was told about —
+            // not an empty placeholder from a `message.created` envelope.
+            const subject = active ?? actor;
+            if (subject === undefined || subject === null) {
+                return;
+            }
+            settle(subject, false);
+        },
+        dispose() {
+            // No `onChange` on dispose: the subscription is going away and the
+            // consumer is tearing their UI down with it. Firing a last event into a
+            // component that has unmounted is how a wrapper earns a React warning.
+            clear();
+            active = null;
+        },
+    };
+}
+/**
+ * The actor a `typing.*` envelope is about, or null if it is not one we show.
+ *
+ * Two exclusions, both load-bearing:
+ *
+ *  - `kind: 'viewing'`. The agent dashboard publishes room presence and
+ *    collaborative-cursor frames AS `typing.start` (see `viewing.cursor` in
+ *    `apps/realtime/src/gateway.ts`), ~10 per second while an agent moves
+ *    their mouse. Rendering those as typing would make the indicator flicker
+ *    whenever an agent so much as looked at the conversation.
+ *  - anything that is not an agent or a bot. The gateway's visitor allowlist
+ *    already forwards only agent typing, so this is the second of two checks
+ *    rather than the only one — but a visitor must never be shown their OWN
+ *    typing as the agent's, and the day the allowlist widens is not the day
+ *    to discover that.
+ */
+export function typingActorOf(payload) {
+    if (typeof payload !== 'object' || payload === null) {
+        return null;
+    }
+    const p = payload;
+    if (p.kind === 'viewing') {
+        return null;
+    }
+    if (p.actorType !== 'agent' && p.actorType !== 'bot') {
+        return null;
+    }
+    return {
+        actorType: p.actorType,
+        actorId: typeof p.actorId === 'string' ? p.actorId : '',
+        ...(typeof p.displayName === 'string' ? { displayName: p.displayName } : {}),
+    };
+}
+//# sourceMappingURL=live.js.map

package/dist/live.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"live.js","sourceRoot":"","sources":["../src/live.ts"],"names":[],"mappings":"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"}

package/dist/types.d.ts

@@ -0,0 +1,142 @@
+/**
+ * Public types for the headless SDK.
+ *
+ * Declared here rather than imported from `@livechat/shared`: this bundle
+ * ships to a customer's website and importing from the shared package drags
+ * zod in with it — measured at ~11KB gzipped when it happened to the widget.
+ * The shapes are the API's response bodies, which are a published contract.
+ */
+/** One message as the visitor endpoints return it. */
+export interface HeadlessMessage {
+    readonly id: string;
+    readonly body: string;
+    readonly authorType: 'contact' | 'agent' | 'bot' | 'system';
+    readonly createdAt: string;
+    /** Rich blocks, when the message carries them. Opaque here — render or ignore. */
+    readonly blocks?: unknown;
+    /** A Tier 2/3 interactive step. Mutually exclusive with `blocks`. */
+    readonly canvas?: unknown;
+    readonly attachments?: ReadonlyArray<{
+        readonly id: string;
+        readonly filename: string;
+        readonly mimeType: string;
+        readonly url: string;
+    }>;
+}
+/** One thread in the visitor's own list. */
+export interface HeadlessConversation {
+    readonly id: string;
+    readonly status?: string;
+    readonly lastMessageAt?: string;
+    readonly subject?: string | null;
+}
+/**
+ * "The agent is typing", as the consumer should render it.
+ *
+ * `isTyping` rather than two callbacks, because a UI holds one boolean and
+ * the two-callback shape makes the consumer own the state machine — including
+ * the part they cannot know about (see `TYPING_STOP_AFTER_MS`).
+ */
+export interface TypingSignal {
+    /** Show the indicator, or hide it. */
+    readonly isTyping: boolean;
+    /**
+     * Who. `'agent'` in every case the server currently forwards — a visitor
+     * never receives their own typing, and agent-presence cursors are filtered
+     * out on both sides.
+     */
+    readonly actorType: 'agent' | 'bot';
+    readonly actorId: string;
+    /** The agent's display name, when the dashboard sent one. */
+    readonly displayName?: string;
+}
+/** What `subscribe()` reports. */
+export interface SubscribeHandlers {
+    /** A message the consumer has not been given before. */
+    readonly onMessage?: (message: HeadlessMessage) => void;
+    /**
+     * The agent started or stopped typing.
+     *
+     * **PUSH ONLY.** Typing is a socket event with no HTTP route, so a polling
+     * consumer never receives this — not rarely, never. There is nothing to
+     * poll and nothing to warn about at subscribe time either, because a
+     * consumer who passes `onTyping` without `io` has asked for something the
+     * transport cannot carry: `subscribe` says so once, in the console, rather
+     * than leaving them to wonder why an agent who is visibly typing in the
+     * dashboard produces nothing. (A 6-second poll would be a useless indicator
+     * even if a route existed — the dashboard stops sending after 5s of idle
+     * keystrokes, so a poll could easily see neither edge.)
+     *
+     * Called with `isTyping: false` either when the agent's `typing.stop`
+     * arrives OR after `TYPING_STOP_AFTER_MS` with no further start — see that
+     * constant for why the timeout is not the consumer's problem to solve.
+     */
+    readonly onTyping?: (signal: TypingSignal) => void;
+    /**
+     * A poll or socket failed. Called rather than thrown: `subscribe` is
+     * long-lived, and a rejected promise nobody is awaiting becomes an
+     * unhandled rejection on the customer's page.
+     */
+    readonly onError?: (error: unknown) => void;
+}
+export interface SubscribeOptions {
+    /** Poll interval. Ignored when `io` is supplied. Floored at 2s. */
+    readonly intervalMs?: number;
+    /**
+     * Your own `socket.io-client` factory, for push instead of polling:
+     *
+     *   import { io } from 'socket.io-client';
+     *   chatly.subscribe(id, handlers, { io });
+     *
+     * The SDK does not depend on it, so a consumer who does not want the bytes
+     * does not ship them.
+     */
+    readonly io?: SocketIoFactory;
+}
+/** The shape of `socket.io-client`'s default export that the SDK uses. */
+export type SocketIoFactory = (url: string, opts: Record<string, unknown>) => {
+    on: (event: string, handler: (payload: unknown) => void) => void;
+    emit: (event: string, payload: unknown) => void;
+    disconnect: () => void;
+};
+/**
+ * What `subscribe()` returns.
+ *
+ * Callable, so `const stop = subscribe(...); stop()` keeps working — it was
+ * documented and shipped as a plain unsubscribe function, and changing that
+ * shape hours later would break the first consumers for no gain. The extras
+ * hang off it.
+ *
+ * ── Why RECEIVING typing is not here ────────────────────────────────────
+ *
+ * A typing indicator needs both directions, and they land in different
+ * places. SENDING is an imperative call the consumer makes at a moment of
+ * their choosing (a keystroke), so it has to hang off the handle — there is
+ * nowhere else to put it. RECEIVING is an event, and every other event this
+ * SDK reports arrives through `SubscribeHandlers` (`onMessage`, `onError`).
+ *
+ * The three alternatives were:
+ *
+ *  1. **`onTyping` in the handlers.** Chosen. Zero change to the return
+ *     type, so no existing caller can break, and it is the shape a consumer
+ *     already knows from `onMessage`.
+ *  2. **An emitter on the handle** (`sub.onTyping(fn)`). A second
+ *     subscription idiom in one SDK, with its own unsubscribe to get wrong,
+ *     for one event.
+ *  3. **Returning an object instead of a function.** The breaking change the
+ *     note above rejects, and it buys nothing: `setTyping` already proved the
+ *     callable-plus-properties shape carries whatever we need.
+ */
+export type Subscription = (() => void) & {
+    /**
+     * Tell the agent this visitor is typing.
+     *
+     * Only the PUSH path can carry this: typing is a socket event
+     * (`apps/realtime/src/gateway.ts` listens for `typing.start`) and there is
+     * no HTTP route for it. On the polling path it warns once rather than
+     * silently doing nothing — a no-op that looks like it worked is how an
+     * integrator spends an hour on their own code.
+     */
+    setTyping: (isTyping: boolean) => void;
+};
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,sDAAsD;AACtD,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,UAAU,EAAE,SAAS,GAAG,OAAO,GAAG,KAAK,GAAG,QAAQ,CAAC;IAC5D,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,kFAAkF;IAClF,QAAQ,CAAC,MAAM,CAAC,EAAE,OAAO,CAAC;IAC1B,qEAAqE;IACrE,QAAQ,CAAC,MAAM,CAAC,EAAE,OAAO,CAAC;IAC1B,QAAQ,CAAC,WAAW,CAAC,EAAE,aAAa,CAAC;QACnC,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;QACpB,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;QAC1B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;QAC1B,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;KACtB,CAAC,CAAC;CACJ;AAED,4CAA4C;AAC5C,MAAM,WAAW,oBAAoB;IACnC,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,aAAa,CAAC,EAAE,MAAM,CAAC;IAChC,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CAClC;AAED;;;;;;GAMG;AACH,MAAM,WAAW,YAAY;IAC3B,sCAAsC;IACtC,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAC;IAC3B;;;;OAIG;IACH,QAAQ,CAAC,SAAS,EAAE,OAAO,GAAG,KAAK,CAAC;IACpC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,6DAA6D;IAC7D,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;CAC/B;AAED,kCAAkC;AAClC,MAAM,WAAW,iBAAiB;IAChC,wDAAwD;IACxD,QAAQ,CAAC,SAAS,CAAC,EAAE,CAAC,OAAO,EAAE,eAAe,KAAK,IAAI,CAAC;IACxD;;;;;;;;;;;;;;;;OAgBG;IACH,QAAQ,CAAC,QAAQ,CAAC,EAAE,CAAC,MAAM,EAAE,YAAY,KAAK,IAAI,CAAC;IACnD;;;;OAIG;IACH,QAAQ,CAAC,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,IAAI,CAAC;CAC7C;AAED,MAAM,WAAW,gBAAgB;IAC/B,mEAAmE;IACnE,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;IAC7B;;;;;;;;OAQG;IACH,QAAQ,CAAC,EAAE,CAAC,EAAE,eAAe,CAAC;CAC/B;AAED,0EAA0E;AAC1E,MAAM,MAAM,eAAe,GAAG,CAC5B,GAAG,EAAE,MAAM,EACX,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAC1B;IACH,EAAE,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,CAAC,OAAO,EAAE,OAAO,KAAK,IAAI,KAAK,IAAI,CAAC;IACjE,IAAI,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,KAAK,IAAI,CAAC;IAChD,UAAU,EAAE,MAAM,IAAI,CAAC;CACxB,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,MAAM,MAAM,YAAY,GAAG,CAAC,MAAM,IAAI,CAAC,GAAG;IACxC;;;;;;;;OAQG;IACH,SAAS,EAAE,CAAC,QAAQ,EAAE,OAAO,KAAK,IAAI,CAAC;CACxC,CAAC"}

package/dist/types.js

@@ -0,0 +1,10 @@
+/**
+ * Public types for the headless SDK.
+ *
+ * Declared here rather than imported from `@livechat/shared`: this bundle
+ * ships to a customer's website and importing from the shared package drags
+ * zod in with it — measured at ~11KB gzipped when it happened to the widget.
+ * The shapes are the API's response bodies, which are a published contract.
+ */
+export {};
+//# sourceMappingURL=types.js.map

package/dist/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG"}

package/package.json

@@ -1,6 +1,62 @@
 {
   "name": "@chatlychat/sdk-js",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.0",
+  "description": "Browser SDK for the LiveChat platform — identify visitors, fire events, control the widget.",
+  "license": "MIT",
+  "homepage": "https://github.com/livechat/platform/tree/main/packages/sdk-js",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/livechat/platform.git",
+    "directory": "packages/sdk-js"
+  },
+  "bugs": "https://github.com/livechat/platform/issues",
+  "keywords": [
+    "livechat",
+    "chat",
+    "messaging",
+    "support",
+    "widget",
+    "sdk"
+  ],
+  "author": "LiveChat Platform Engineering",
+  "type": "module",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "!dist/**/*.spec.*",
+    "README.md",
+    "LICENSE",
+    "CHANGELOG.md"
+  ],
+  "sideEffects": false,
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "prepublishOnly": "pnpm build",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "lint": "eslint src --max-warnings=0",
+    "test": "vitest run"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/",
+    "provenance": true
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "devDependencies": {
+    "@livechat/config": "workspace:*",
+    "jsdom": "^30.0.1",
+    "typescript": "catalog:",
+    "vitest": "catalog:"
+  }
+}