passline-ai 2.0.0 → 2.1.3

package/README.md

@@ -1,6 +1,40 @@
-# Passline
+# passline-ai
 
-React chat widget for the Passline website chatbot API.
+React chat widget for [Passline](https://passline.ai). Drop it into a React or Next.js app with an embed token.
+
+**Requirements:** Node.js 18+, React 18+, a secure context (`https` or `localhost`) so Web Crypto can run.
+
+```bash
+npm install passline-ai
+```
+
+```tsx
+import { PasslineChat } from "passline-ai";
+
+<PasslineChat token="YOUR_EMBED_TOKEN" />;
+```
+
+That is the full installer setup.
+
+---
+
+## Contents
+
+- [Install](#install)
+- [Quick start](#quick-start)
+- [Exports](#exports)
+- [`PasslineChat`](#passlinechat)
+- [Theme](#theme)
+- [Labels](#labels)
+- [Render props](#render-props)
+- [Session persistence](#session-persistence)
+- [`usePasslineChat`](#usepasslinechat)
+- [`usePasslineSession`](#usepasslinesession)
+- [Types](#types)
+- [Next.js](#nextjs)
+- [Behavior](#behavior)
+
+---
 
 ## Install
 
@@ -8,32 +42,509 @@ React chat widget for the Passline website chatbot API.
 npm install passline-ai
 ```
 
-Peer dependencies: `react` and `react-dom` >= 18.
+Peer dependencies:
+
+| Package     | Version    |
+| ----------- | ---------- |
+| `react`     | `>=18.0.0` |
+| `react-dom` | `>=18.0.0` |
+
+Styles ship inside the bundle. Do not import a separate CSS file.
+
+---
 
-## Usage
+## Quick start
+
+### React
 
 ```tsx
 import { PasslineChat } from "passline-ai";
 
 export function App() {
-  return (
-    <PasslineChat
-      token={process.env.NEXT_PUBLIC_PASSLINE_TOKEN!}
-      origin="https://api.passline.ai"
+  return <PasslineChat token="YOUR_EMBED_TOKEN" />;
+}
+```
+
+### Themed widget
+
+```tsx
+<PasslineChat
+  token="YOUR_EMBED_TOKEN"
+  locale="en"
+  autoOpen
+  theme={{
+    primaryColor: "#0f766e",
+    buttonSize: "large",
+    panelWidth: "400px",
+  }}
+  labels={{
+    typeMessage: "Ask anything…",
+    send: "Send",
+  }}
+  onMessageSend={(text) => console.log("sent", text)}
+  onError={(error) => console.error(error)}
+/>
+```
+
+---
+
+## Exports
+
+Everything below is available from `"passline-ai"`:
+
+| Export                         | Kind      | Description                                   |
+| ------------------------------ | --------- | --------------------------------------------- |
+| `PasslineChat`                 | component | Floating chat button + panel                  |
+| `usePasslineChat`              | hook      | Widget state, open/close, send, new chat      |
+| `usePasslineSession`           | hook      | Session create/restore, messages, persistence |
+| `DEFAULT_PASSLINE_CHAT_LABELS` | constant  | Default chrome strings                        |
+| `mergePasslineChatLabels`      | function  | Merge partial labels onto the defaults        |
+| `PasslineChatProps`            | type      | Props for `PasslineChat`                      |
+| `PasslineTheme`                | type      | Theme tokens                                  |
+| `PasslineChatLabels`           | type      | Label keys                                    |
+| `PasslineMessage`              | type      | One chat message                              |
+| `PasslineSession`              | type      | Active session + branding                     |
+
+---
+
+## `PasslineChat`
+
+Floating launcher (bottom-right) that opens a dialog panel. Branding (assistant name, company name, logo) comes from the session API after the first successful connect.
+
+```tsx
+import { PasslineChat } from "passline-ai";
+
+<PasslineChat token="YOUR_EMBED_TOKEN" />;
+```
+
+### Props
+
+| Prop                | Type                                 | Default     | Description                                                                                    |
+| ------------------- | ------------------------------------ | ----------- | ---------------------------------------------------------------------------------------------- |
+| `token`             | `string`                             | required    | Embed token from the Passline dashboard.                                                       |
+| `locale`            | `string`                             | —           | BCP 47 tag sent when creating a session (`en`, `nb`, `fr`). Also namespaces persisted storage. |
+| `labels`            | `Partial<PasslineChatLabels>`        | defaults    | Overrides for widget chrome. Conversation copy comes from the API.                             |
+| `theme`             | `PasslineTheme`                      | defaults    | Colors, sizes, fonts, and optional class names.                                                |
+| `className`         | `string`                             | `""`        | Extra class on the wrapper.                                                                    |
+| `buttonClassName`   | `string`                             | `""`        | Extra class on the launcher button.                                                            |
+| `panelClassName`    | `string`                             | `""`        | Extra class on the dialog panel.                                                               |
+| `autoOpen`          | `boolean`                            | `false`     | Open the panel on mount.                                                                       |
+| `persistSession`    | `boolean`                            | `true`      | Store the session in `localStorage`.                                                           |
+| `maxSessionAge`     | `number`                             | `604800000` | Max age of a stored session in ms (7 days).                                                    |
+| `maxStoredMessages` | `number`                             | `200`       | Max messages kept in `localStorage`.                                                           |
+| `renderButton`      | `(props) => ReactNode`               | built-in    | Replace the launcher.                                                                          |
+| `renderHeader`      | `(props) => ReactNode`               | built-in    | Replace the panel header.                                                                      |
+| `renderMessage`     | `(props) => ReactNode`               | built-in    | Replace each bubble.                                                                           |
+| `renderInput`       | `(props) => ReactNode`               | built-in    | Replace the composer.                                                                          |
+| `onOpen`            | `() => void`                         | —           | Fires when the panel opens (not on first mount if closed).                                     |
+| `onClose`           | `() => void`                         | —           | Fires when the panel closes.                                                                   |
+| `onMessageSend`     | `(message: string) => void`          | —           | Fires with the user text before the request.                                                   |
+| `onMessageReceive`  | `(message: PasslineMessage) => void` | —           | Fires with the assistant reply.                                                                |
+| `onError`           | `(error: Error) => void`             | —           | Network, session, or send failures.                                                            |
+| `onSessionStart`    | `(session: PasslineSession) => void` | —           | Fires once per new `sessionId`.                                                                |
+| `onNewChat`         | `() => void`                         | —           | Fires after the header “new chat” action.                                                      |
+
+---
+
+## Theme
+
+Pass a partial `theme` object. Unset keys use the defaults below.
+
+```tsx
+<PasslineChat
+  token="YOUR_EMBED_TOKEN"
+  theme={{
+    primaryColor: "#4f46e5",
+    buttonSize: "small",
+    panelClassName: "my-chat-panel",
+  }}
+/>
+```
+
+### Tokens
+
+| Token                      | Type                             | Default                             |
+| -------------------------- | -------------------------------- | ----------------------------------- |
+| `primaryColor`             | `string`                         | `#0f766e`                           |
+| `primaryHoverColor`        | `string`                         | `#0d9488`                           |
+| `backgroundColor`          | `string`                         | `#f8fafc`                           |
+| `textColor`                | `string`                         | `#0f172a`                           |
+| `userBubbleColor`          | `string`                         | `#0f766e`                           |
+| `userBubbleTextColor`      | `string`                         | `#ffffff`                           |
+| `assistantBubbleColor`     | `string`                         | `#ffffff`                           |
+| `assistantBubbleTextColor` | `string`                         | `#1e293b`                           |
+| `borderRadius`             | `string \| number`               | `16px`                              |
+| `borderWidth`              | `string \| number`               | `1px`                               |
+| `borderColor`              | `string`                         | `#e2e8f0`                           |
+| `buttonSize`               | `"small" \| "medium" \| "large"` | `medium` (`44px` / `56px` / `64px`) |
+| `buttonBorderRadius`       | `string \| number`               | `999px`                             |
+| `buttonBackgroundColor`    | `string`                         | `#0f766e`                           |
+| `buttonHoverColor`         | `string`                         | `#0d9488`                           |
+| `buttonIconColor`          | `string`                         | `#ffffff`                           |
+| `panelWidth`               | `string \| number`               | `380px`                             |
+| `panelHeight`              | `string \| number`               | `560px`                             |
+| `panelShadow`              | `string`                         | `0 12px 40px rgba(0,0,0,.22)`       |
+| `fontFamily`               | `string`                         | system UI stack                     |
+| `fontSize`                 | `string`                         | `14px`                              |
+| `spacing`                  | `string \| number`               | `12px`                              |
+| `padding`                  | `string \| number`               | `12px`                              |
+| `className`                | `string`                         | `""`                                |
+| `buttonClassName`          | `string`                         | `""`                                |
+| `panelClassName`           | `string`                         | `""`                                |
+| `headerClassName`          | `string`                         | `""`                                |
+| `messagesClassName`        | `string`                         | `""`                                |
+| `inputClassName`           | `string`                         | `""`                                |
+
+`className`, `buttonClassName`, and `panelClassName` on the component are also applied (in addition to the theme class names).
+
+The launcher uses the organization logo when the session provides `logoUrl`. If the image fails, it falls back to the chat icon. The header falls back to initials from the company or assistant name.
+
+---
+
+## Labels
+
+Chrome strings only. The greeting and assistant replies come from the API.
+
+```tsx
+import {
+  PasslineChat,
+  DEFAULT_PASSLINE_CHAT_LABELS,
+  mergePasslineChatLabels,
+} from "passline-ai";
+
+<PasslineChat
+  token="YOUR_EMBED_TOKEN"
+  labels={{
+    assistant: "Support",
+    typeMessage: "Type a message…",
+    send: "Send",
+  }}
+/>;
+```
+
+`mergePasslineChatLabels(partial)` returns a full `PasslineChatLabels` object (`{ ...DEFAULT_PASSLINE_CHAT_LABELS, ...partial }`).
+
+| Key                | Default                | Where it appears                                |
+| ------------------ | ---------------------- | ----------------------------------------------- |
+| `assistant`        | `Assistant`            | Header title fallback, avatar initials fallback |
+| `offline`          | `Offline`              | Subtitle, input placeholder when offline        |
+| `unavailable`      | `Unavailable`          | Subtitle / placeholder when the session failed  |
+| `connecting`       | `Connecting…`          | Subtitle, placeholder, empty-state              |
+| `online`           | `Online`               | Subtitle when connected with no company name    |
+| `typeMessage`      | `Type a message…`      | Input placeholder when ready                    |
+| `send`             | `Send`                 | Send button                                     |
+| `openChat`         | `Open chat`            | Launcher `aria-label` when closed               |
+| `closeChat`        | `Close chat`           | Launcher `aria-label` when open                 |
+| `newChat`          | `Start new chat`       | Header button `aria-label`                      |
+| `newChatTitle`     | `Start new chat`       | Header button `title`                           |
+| `typing`           | `Assistant is typing…` | Shown while a reply is in flight                |
+| `panelAriaLabel`   | `Passline chat`        | Dialog `aria-label`                             |
+| `organizationLogo` | `Organization logo`    | Logo `alt` fallback                             |
+| `defaultGreeting`  | `Hi! How can I help?`  | Used only if the API greeting is empty          |
+
+---
+
+## Render props
+
+Use these to replace a slice of the built-in UI. Session and send logic stay the same.
+
+### `renderButton`
+
+```tsx
+renderButton={({ onClick, isOpen, className }) => (
+  <button type="button" className={className} onClick={onClick}>
+    {isOpen ? "Close" : "Chat"}
+  </button>
+)}
+```
+
+| Field       | Type         | Description      |
+| ----------- | ------------ | ---------------- |
+| `onClick`   | `() => void` | Toggle the panel |
+| `isOpen`    | `boolean`    | Panel visibility |
+| `className` | `string`     | Reserved (empty) |
+
+### `renderHeader`
+
+```tsx
+renderHeader={({ title, subtitle, avatar, onNewChat }) => (
+  <header>
+    <strong>{title}</strong>
+    <span>{subtitle}</span>
+    <span>{avatar}</span>
+    <button type="button" onClick={onNewChat}>
+      New
+    </button>
+  </header>
+)}
+```
+
+| Field       | Type         | Description                                                  |
+| ----------- | ------------ | ------------------------------------------------------------ |
+| `title`     | `string`     | Assistant name (or label fallback)                           |
+| `subtitle`  | `string`     | Company name, or online / connecting / offline / unavailable |
+| `avatar`    | `string`     | Initials derived from branding                               |
+| `onNewChat` | `() => void` | Clears storage and starts a new session                      |
+
+### `renderMessage`
+
+```tsx
+renderMessage={({ message, className }) => (
+  <div className={className} data-role={message.role}>
+    {message.content}
+  </div>
+)}
+```
+
+| Field       | Type              | Description                         |
+| ----------- | ----------------- | ----------------------------------- |
+| `message`   | `PasslineMessage` | `role` is `"user"` or `"assistant"` |
+| `className` | `string`          | Reserved (empty)                    |
+
+### `renderInput`
+
+```tsx
+renderInput={({ value, onChange, onSend, disabled, placeholder, className }) => (
+  <form
+    className={className}
+    onSubmit={(event) => {
+      event.preventDefault();
+      onSend();
+    }}
+  >
+    <input
+      value={value}
+      placeholder={placeholder}
+      disabled={disabled}
+      onChange={(event) => onChange(event.target.value)}
     />
-  );
+    <button type="submit" disabled={disabled}>
+      Send
+    </button>
+  </form>
+)}
+```
+
+| Field         | Type                      | Description                                                      |
+| ------------- | ------------------------- | ---------------------------------------------------------------- |
+| `value`       | `string`                  | Draft text                                                       |
+| `onChange`    | `(value: string) => void` | Update draft                                                     |
+| `onSend`      | `() => void`              | Send the current draft                                           |
+| `disabled`    | `boolean`                 | True while loading, offline, sending, or before a session exists |
+| `placeholder` | `string`                  | Status-aware placeholder                                         |
+| `className`   | `string`                  | Reserved (empty)                                                 |
+
+The default input sends on Enter (Shift+Enter is ignored; it is a single-line field).
+
+---
+
+## Session persistence
+
+When `persistSession` is `true` (default), the widget writes to `localStorage`:
+
+| Key                              | When            |
+| -------------------------------- | --------------- |
+| `passline:chat:{token}`          | No `locale`     |
+| `passline:chat:{token}:{locale}` | `locale` is set |
+
+Stored fields: `sessionId`, `assistantName`, `companyName`, `logoUrl`, `messages`, `updatedAt`.
+
+- Entries older than `maxSessionAge` are discarded.
+- Only the last `maxStoredMessages` messages are kept.
+- Quota / private-mode failures are ignored; the session stays in memory.
+- `newChat` clears the stored entry and creates a new session.
+- An expired or invalid server session is cleared and recreated. The last user message is not retried automatically.
+
+Set `persistSession={false}` for a fresh session every page load.
+
+---
+
+## `usePasslineChat`
+
+Headless hook used by `PasslineChat`. Use it to build a custom shell.
+
+```tsx
+import { usePasslineChat } from "passline-ai";
+
+const {
+  isOpen,
+  setIsOpen,
+  toggleOpen,
+  isSending,
+  isLoading,
+  offline,
+  messages,
+  session,
+  error,
+  sendMessage,
+  newChat,
+} = usePasslineChat(token, {
+  locale: "en",
+  defaultGreeting: "Hi! How can I help?",
+  persistSession: true,
+  maxSessionAge: 7 * 24 * 60 * 60 * 1000,
+  maxStoredMessages: 200,
+  autoOpen: false,
+  onMessageSend: (text) => {},
+  onMessageReceive: (message) => {},
+  onError: (error) => {},
+  onSessionStart: (session) => {},
+});
+```
+
+A session is created (or restored) when the panel is open and the client is online.
+
+### Options
+
+| Option              | Type                                 | Default               |
+| ------------------- | ------------------------------------ | --------------------- |
+| `locale`            | `string`                             | —                     |
+| `defaultGreeting`   | `string`                             | `Hi! How can I help?` |
+| `persistSession`    | `boolean`                            | `true`                |
+| `maxSessionAge`     | `number`                             | 7 days in ms          |
+| `maxStoredMessages` | `number`                             | `200`                 |
+| `autoOpen`          | `boolean`                            | `false`               |
+| `onMessageSend`     | `(message: string) => void`          | —                     |
+| `onMessageReceive`  | `(message: PasslineMessage) => void` | —                     |
+| `onError`           | `(error: Error) => void`             | —                     |
+| `onSessionStart`    | `(session: PasslineSession) => void` | —                     |
+
+### Return value
+
+| Field         | Type                                 | Description                      |
+| ------------- | ------------------------------------ | -------------------------------- |
+| `isOpen`      | `boolean`                            | Panel open state                 |
+| `setIsOpen`   | `(open: boolean) => void`            | Set open state                   |
+| `toggleOpen`  | `() => void`                         | Toggle open state                |
+| `isSending`   | `boolean`                            | Reply request in flight          |
+| `isLoading`   | `boolean`                            | Session create/restore in flight |
+| `offline`     | `boolean`                            | Gateway unreachable              |
+| `messages`    | `PasslineMessage[]`                  | Current thread                   |
+| `session`     | `PasslineSession \| null`            | Branding + `sessionId`           |
+| `error`       | `string \| null`                     | Last error message               |
+| `sendMessage` | `(content: string) => Promise<void>` | Send user text                   |
+| `newChat`     | `() => Promise<void>`                | Reset and start a new session    |
+
+`sendMessage` no-ops when the text is empty, a send is already in flight, a session is loading, or the client is offline.
+
+---
+
+## `usePasslineSession`
+
+Lower-level session hook. Prefer `usePasslineChat` unless you need `createSession` / `ensureSession` / `clearStoredSession` directly.
+
+```tsx
+import { usePasslineSession } from "passline-ai";
+
+const {
+  session,
+  messages,
+  isLoading,
+  offline,
+  error,
+  sendMessage,
+  newChat,
+  createSession,
+  ensureSession,
+  clearStoredSession,
+} = usePasslineSession(
+  token,
+  persistSession, // default true
+  maxSessionAge, // default 7 days
+  maxStoredMessages, // default 200
+  locale, // optional
+  defaultGreeting, // default "Hi! How can I help?"
+);
+```
+
+### Return value
+
+| Field                | Type                                               | Description                                   |
+| -------------------- | -------------------------------------------------- | --------------------------------------------- |
+| `session`            | `PasslineSession \| null`                          | Active session                                |
+| `messages`           | `PasslineMessage[]`                                | `session.messages` or `[]`                    |
+| `isLoading`          | `boolean`                                          | Session request in flight                     |
+| `offline`            | `boolean`                                          | Gateway unreachable                           |
+| `error`              | `string \| null`                                   | Last error                                    |
+| `sendMessage`        | `(content: string) => Promise<PasslineMessage>`    | Appends user + assistant messages             |
+| `newChat`            | `() => Promise<PasslineSession>`                   | Clear storage and create a session            |
+| `createSession`      | `(forceNew?: boolean) => Promise<PasslineSession>` | Restore cache, or create (`true` skips cache) |
+| `ensureSession`      | `() => Promise<PasslineSession \| null>`           | Return current session or create one          |
+| `clearStoredSession` | `() => void`                                       | Remove the `localStorage` entry               |
+
+Changing `token` or `locale` resets in-memory state and reloads the matching cache key.
+
+---
+
+## Types
+
+```ts
+interface PasslineMessage {
+  id?: string;
+  role: "user" | "assistant";
+  content: string;
+  timestamp?: number;
+}
+
+interface PasslineSession {
+  sessionId: string;
+  assistantName: string;
+  companyName: string | null;
+  logoUrl: string | null;
+  greeting?: string;
+  messages: PasslineMessage[];
+}
+```
+
+`PasslineChatProps`, `PasslineTheme`, and `PasslineChatLabels` match the tables above.
+
+---
+
+## Next.js
+
+Mark the host as a client component. The widget uses hooks, `window`, and `localStorage`.
+
+### App Router
+
+```tsx
+"use client";
+
+import { PasslineChat } from "passline-ai";
+
+export function SupportChat() {
+  return <PasslineChat token={process.env.NEXT_PUBLIC_PASSLINE_TOKEN!} />;
 }
 ```
 
-`origin` should be the API host that serves `POST /api/chatbot/session`. Styles ship inside the bundle.
+### Pages Router
+
+```tsx
+import { PasslineChat } from "passline-ai";
+
+export default function Page() {
+  return <PasslineChat token={process.env.NEXT_PUBLIC_PASSLINE_TOKEN!} />;
+}
+```
+
+Do not call the widget from a Server Component without a client boundary.
+
+---
+
+## Behavior
+
+| Topic          | Detail                                                                                 |
+| -------------- | -------------------------------------------------------------------------------------- |
+| Token          | Required. Issued in the Passline dashboard.                                            |
+| Branding       | `assistantName`, `companyName`, and `logoUrl` arrive with the session.                 |
+| Greeting       | API greeting is the first assistant message. `labels.defaultGreeting` is the fallback. |
+| Input lock     | Disabled while loading, offline, sending, or before `sessionId` exists.                |
+| Offline        | Fetch / 5xx failures mark the widget offline and lock the input.                       |
+| New chat       | Header control clears storage and opens a new session.                                 |
+| Locale         | Sent on session create; also splits the storage key.                                   |
+| Secure context | Required (`https` or `localhost`) for the Web Crypto handshake.                        |
 
-## Scripts
+---
 
-| Command                       | Purpose                             |
-| ----------------------------- | ----------------------------------- |
-| `npm run build`               | Produce `dist/` for npm             |
-| `npm run pack:check`          | Show what `npm publish` will upload |
-| `npm run dev`                 | Local demo at http://127.0.0.1:5173 |
-| `npm publish --access public` | Publish `passline-ai`               |
+## License
 
-Copy `.env.example` to `.env` for the demo. Publishing a GitHub Release on `main` runs `.github/workflows/publish.yml` when `NPM_TOKEN` is set.
+MIT

package/dist/api/passlineApi.d.ts

@@ -21,11 +21,18 @@ export declare function isOfflineError(err: unknown): boolean;
 export declare function isSessionInvalidError(err: unknown): boolean;
 export declare class PasslineApi {
     private token;
-    private origin;
-    constructor(token: string, origin?: string);
-    private getHeaders;
+    private channel;
+    private handshake;
+    constructor(token: string);
+    private gatewayUrl;
+    private postJson;
+    private throwIfFailed;
+    private ensureChannel;
+    private openChannel;
     private request;
-    createSession(): Promise<ChatbotSessionResponse>;
+    createSession(options?: {
+        locale?: string;
+    }): Promise<ChatbotSessionResponse>;
     sendMessage(sessionId: string, message: string): Promise<ChatbotMessageResponse>;
 }
 export declare function toPasslineSession(response: ChatbotSessionResponse, messages?: PasslineSession["messages"]): PasslineSession;

package/dist/component/labels.d.ts

@@ -0,0 +1,19 @@
+export interface PasslineChatLabels {
+    assistant: string;
+    offline: string;
+    unavailable: string;
+    connecting: string;
+    online: string;
+    typeMessage: string;
+    send: string;
+    openChat: string;
+    closeChat: string;
+    newChat: string;
+    newChatTitle: string;
+    typing: string;
+    panelAriaLabel: string;
+    organizationLogo: string;
+    defaultGreeting: string;
+}
+export declare const DEFAULT_PASSLINE_CHAT_LABELS: PasslineChatLabels;
+export declare function mergePasslineChatLabels(labels?: Partial<PasslineChatLabels>): PasslineChatLabels;

package/dist/component/types.d.ts

@@ -1,4 +1,5 @@
 import type { ReactNode } from "react";
+import type { PasslineChatLabels } from "./labels";
 export interface PasslineMessage {
     id?: string;
     role: "user" | "assistant";
@@ -46,7 +47,10 @@ export interface PasslineTheme {
 }
 export interface PasslineChatProps {
     token: string;
-    origin?: string;
+    /** BCP 47 language tag sent when creating a session (e.g. `en`, `nb`, `fr`). */
+    locale?: string;
+    /** Overrides for widget chrome strings. Conversation copy comes from the API. */
+    labels?: Partial<PasslineChatLabels>;
     theme?: PasslineTheme;
     className?: string;
     buttonClassName?: string;

package/dist/crypto/envelope.d.ts

@@ -0,0 +1,40 @@
+export declare const PROXY_PATH = "/api/p";
+/** Public widget gateway. This is the only host the npm package calls. */
+export declare const PASSLINE_GATEWAY = "https://api.passline.ai";
+export type HandshakeRequest = {
+    v: 1;
+    op: "h";
+    c: string;
+};
+export type HandshakeResponse = {
+    v: 1;
+    s: string;
+    t: string;
+};
+export type RpcRequest = {
+    v: 1;
+    op: "x";
+    t: string;
+    i: string;
+    c: string;
+};
+export type RpcResponse = {
+    v: 1;
+    i: string;
+    c: string;
+};
+export declare function utf8(value: string): Uint8Array<ArrayBuffer>;
+export declare function b64encode(data: ArrayBuffer | Uint8Array): string;
+export declare function b64decode(value: string): Uint8Array<ArrayBuffer>;
+export declare function generateEcdhPair(): Promise<CryptoKeyPair>;
+export declare function exportPublicKey(key: CryptoKey): Promise<string>;
+export declare function importPublicKey(spki: string): Promise<CryptoKey>;
+export declare function sharedAesKey(privateKey: CryptoKey, publicKey: CryptoKey): Promise<CryptoKey>;
+export declare function encryptJson(key: CryptoKey, payload: unknown): Promise<{
+    i: string;
+    c: string;
+}>;
+export declare function decryptJson<T>(key: CryptoKey, i: string, c: string): Promise<T>;
+export declare function sealTicket(secret: string, sharedBits: ArrayBuffer, ttlMs?: number): Promise<string>;
+export declare function openTicket(secret: string, ticket: string): Promise<CryptoKey>;
+export declare function ecdhBits(privateKey: CryptoKey, publicKey: CryptoKey): Promise<ArrayBuffer>;

package/dist/hooks/usePasslineClient.d.ts

@@ -1,6 +1,7 @@
 import { PasslineMessage, PasslineSession } from "../component/types";
 export declare function usePasslineChat(token: string, options?: {
-    origin?: string;
+    locale?: string;
+    defaultGreeting?: string;
     persistSession?: boolean;
     maxSessionAge?: number;
     maxStoredMessages?: number;