@doany-ai/inbox 0.0.0-stage → 0.1.0

package/dist/storage.js

@@ -0,0 +1,86 @@
+export function memoryStorage() {
+    const values = new Map();
+    return {
+        get: (key) => values.get(key) ?? null,
+        set: (key, value) => void values.set(key, value),
+        remove: (key) => void values.delete(key),
+    };
+}
+/** The browser's localStorage when it can be used, else memory for this page. */
+export function defaultStorage() {
+    let store;
+    try {
+        store = globalThis.localStorage;
+    }
+    catch {
+        store = undefined; // blocked (private mode, a sandboxed frame)
+    }
+    if (!store)
+        return memoryStorage();
+    const web = store;
+    const fallback = memoryStorage();
+    return {
+        get(key) {
+            try {
+                return web.getItem(key) ?? fallback.get(key);
+            }
+            catch {
+                return fallback.get(key);
+            }
+        },
+        set(key, value) {
+            try {
+                web.setItem(key, value);
+            }
+            catch {
+                fallback.set(key, value);
+            }
+        },
+        remove(key) {
+            fallback.remove(key);
+            try {
+                web.removeItem(key);
+            }
+            catch {
+                // Nothing to remove without storage.
+            }
+        },
+    };
+}
+/** The visitor hid the privacy line: kept for the browser session. */
+export const PRIVACY_DISMISSED_KEY = "doany_inbox_privacy_dismissed";
+const sessionFallback = memoryStorage();
+function sessionStore() {
+    try {
+        return globalThis.sessionStorage;
+    }
+    catch {
+        return undefined; // blocked (private mode, a sandboxed frame)
+    }
+}
+/** A mark kept for the browser session; for this page only where the session's storage cannot be used. */
+export function sessionMark(key) {
+    try {
+        if (sessionStore()?.getItem(key) != null)
+            return true;
+    }
+    catch {
+        // The page's own copy below.
+    }
+    return sessionFallback.get(key) != null;
+}
+export function setSessionMark(key) {
+    try {
+        const store = sessionStore();
+        if (store) {
+            store.setItem(key, "1");
+            return;
+        }
+    }
+    catch {
+        // Kept for this page only.
+    }
+    sessionFallback.set(key, "1");
+}
+/** The newest team message shown with the panel open. Message ids are unique, so one key serves every chat. */
+export const READ_KEY = "doany_inbox_read";

package/dist/types.d.ts

@@ -0,0 +1,189 @@
+import type { DoanyClientLike } from "@doany-ai/app-core";
+/** What the site's chat button reads (`GET /apps/{app_id}/inbox/config`). A disabled config carries only `enabled`. */
+export interface InboxConfig {
+    enabled: boolean;
+    project_id?: string;
+    /** The button's words, set by the business (default `Ask us`). */
+    label?: string;
+    corner?: "right" | "left" | (string & {});
+    /** Path prefixes where the button is not offered. */
+    hidden_paths?: string[];
+    business?: {
+        name: string;
+    };
+    receptionist?: {
+        /** The AI receptionist's name (default `Annie`). */
+        name: string;
+        /** The business's own greeting, or null for the package's `greeting` label. */
+        greeting: string | null;
+    };
+    paths?: InboxPaths;
+    /** Up to four questions offered before the first message. Present only while the AI receptionist answers (`paths.ask`). */
+    suggested_questions?: InboxSuggestedQuestion[];
+    availability?: InboxAvailability;
+    /** The site's live hostnames: the only hosts a message's text links to. */
+    link_hosts?: string[];
+    /** Show "Powered by DoAny". */
+    branding?: boolean;
+}
+/**
+ * A question the chat offers before the first message: the business's own
+ * words (`text`), or a code the platform built from what the business has,
+ * which shows a label (`inboxSuggestedQuestionLabelKeys`).
+ */
+export type InboxSuggestedQuestion = {
+    text: string;
+    code?: undefined;
+} | {
+    code: "prices" | "book" | "hours" | "address" | (string & {});
+    text?: undefined;
+};
+export interface InboxPaths {
+    /** The AI receptionist answers. */
+    ask: boolean;
+    /** Something is bookable online; the row also needs the site's `bookHref`. */
+    book: boolean;
+    /** The business's phone, or null. */
+    call: string | null;
+    /** The business's contact email: shown only at a limit, never as a row. */
+    email: string | null;
+    /** Send a message to the team. */
+    message: boolean;
+}
+export interface InboxAvailability {
+    open: boolean;
+    /** When it next opens, in the business's own offset (`2026-11-16T09:00:00-05:00`). */
+    back_at: string | null;
+    /** The business's away notice, shown whenever it is set. */
+    away_notice: string | null;
+    /**
+     * How many minutes the team usually takes to answer (5, 15, 30, 60, 120,
+     * 240, 480 or 1440), or null until it has answered enough chats within its
+     * open hours. Shown as "Usually replies within" while the business is open.
+     */
+    replies_within: number | null;
+}
+export interface InboxMe {
+    /** The chat belongs to the signed-in account: its email is not shown. */
+    signed_in: boolean;
+}
+/** One line of the chat, as the client's browser may see it. */
+export interface InboxMessage {
+    id: string;
+    author: "client" | "receptionist" | "team" | "system" | (string & {});
+    /** The team member's first name, or the receptionist's name. */
+    author_name: string | null;
+    kind: "text" | "event" | "offer" | (string & {});
+    /** Plain text. Null for an event. */
+    text: string | null;
+    /** For an event, `code` names it; each code maps to a label (`inboxEventLabelKeys`). */
+    payload: ({
+        code?: string;
+    } & Record<string, unknown>) | null;
+    occurred_at: string;
+}
+export interface InboxContact {
+    email: string;
+    name?: string;
+    /** E.164. */
+    phone?: string;
+}
+/** The first message of a chat. The SDK makes the token, the message id and the key, and keeps them with the body until the platform decides. */
+export interface InboxStartParams {
+    text: string;
+    /** Required unless a verified site account is signed in. */
+    contact?: InboxContact;
+    /** `person`: the Send a message row. The AI does not answer. */
+    intent?: "ask" | "person";
+    pagePath?: string;
+    language?: string;
+    capabilities?: string[];
+}
+export interface InboxStartReceipt {
+    me: InboxMe;
+    message: InboxMessage;
+    reply_pending: boolean;
+}
+/** A first message whose answer is still owed: the SDK resends it unchanged. */
+export interface InboxPendingStart {
+    text: string;
+    intent: "ask" | "person";
+    contact: InboxContact | null;
+}
+export interface InboxThreadPage {
+    messages: InboxMessage[];
+    /** Read after this next time. Opaque. */
+    next_cursor: string | null;
+    reply_pending: boolean;
+    paused: boolean;
+    /** The button was turned off: the thread stays readable, nothing can be sent. */
+    off: boolean;
+    me: InboxMe;
+    /** The cursor given could not be used: this page reads from the start. */
+    restarted?: boolean;
+}
+export interface InboxSendParams {
+    text: string;
+    /** The same id again retries a send whose answer was lost: the chat keeps one copy. */
+    clientMessageId?: string;
+    capabilities?: string[];
+}
+export interface InboxSendReceipt {
+    message: InboxMessage;
+    reply_pending: boolean;
+}
+/** The part of the SDK client this package calls. A real SDK client satisfies `InboxClient`. */
+export interface InboxClient extends DoanyClientLike {
+    inbox: {
+        config(): Promise<InboxConfig>;
+        /** The chat this browser holds, or null. No request. */
+        current(): {
+            email: string | null;
+        } | null;
+        /** A first message still owed, or null. No request. */
+        pendingStart(): InboxPendingStart | null;
+        /** The first message; with no params, the one still owed. */
+        start(params?: InboxStartParams): Promise<InboxStartReceipt>;
+        messages(params?: {
+            cursor?: string | null;
+        }): Promise<InboxThreadPage>;
+        send(params: InboxSendParams): Promise<InboxSendReceipt>;
+        person(params?: {
+            text?: string;
+        }): Promise<void>;
+        seen(throughCursor: string): Promise<void>;
+        resume(linkToken: string): Promise<{
+            me: InboxMe;
+        }>;
+        /** Reports a booking made from an offer in this chat. */
+        bookings(params: {
+            registrationId: string;
+            accessToken: string;
+        }): Promise<void>;
+        newMessageId(): string;
+        /** Forgets this browser's chat and a first message still owed. No request. */
+        forget(): void;
+    };
+}
+/** What an offer card hands to `renderBooking`: the service, its option, and the day the receptionist named. */
+export interface InboxBookingOffer {
+    service_setting_id: string;
+    catalog_item_variant_id: string;
+    /** A day in `timezone`, `YYYY-MM-DD`. */
+    date: string;
+    timezone: string;
+}
+/** A booking the site's flow made, as `BookingFlow`'s `onBooked` gives it (`@doany-ai/calendar`'s `BookingResult`). */
+export interface InboxBooked {
+    /** `status` `pending_payment`: held until it is paid, not booked yet. */
+    registration?: {
+        id: string;
+        status?: string;
+    } | null;
+    access_token?: string | null;
+}
+/** The second argument of `renderBooking`. */
+export interface InboxBookingHooks {
+    /** Pass to the flow's `onBooked`: the chat and the business's Inbox then show the booking. */
+    onBooked(result: InboxBooked): void;
+}

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -1,6 +1,63 @@
 {
   "name": "@doany-ai/inbox",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.0",
+  "description": "The chat button on a Doany site: a visitor asks, books or reaches a person, and the business answers from its Inbox. A hook with no DOM and a default widget",
+  "type": "module",
+  "sideEffects": false,
+  "files": [
+    "dist"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./core": {
+      "types": "./dist/core.d.ts",
+      "import": "./dist/core.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "scripts": {
+    "build": "rm -rf dist && tsc -p tsconfig.build.json",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "test": "vitest run",
+    "prepublishOnly": "npm run build"
+  },
+  "peerDependencies": {
+    "@doany-ai/app-core": "^0.2.3",
+    "@doany-ai/sdk": "^0.5.14 || ^0.6.0",
+    "@tanstack/react-query": "^5.0.0",
+    "react": "^18.2.0 || ^19.0.0",
+    "react-dom": "^18.2.0 || ^19.0.0",
+    "react-router-dom": "^6.4.0 || ^7.0.0"
+  },
+  "peerDependenciesMeta": {
+    "@doany-ai/sdk": {
+      "optional": true
+    },
+    "react-router-dom": {
+      "optional": true
+    }
+  },
+  "dependencies": {
+    "lucide-react": "^0.475.0"
+  },
+  "devDependencies": {
+    "@doany-ai/app-core": "file:../doany-app-core",
+    "@doany-ai/sdk": "file:../doany-sdk",
+    "@tanstack/react-query": "^5.84.1",
+    "@testing-library/jest-dom": "^6.6.3",
+    "@testing-library/react": "^16.2.0",
+    "@types/node": "^22.20.4",
+    "@types/react": "^18.2.66",
+    "@types/react-dom": "^18.2.22",
+    "jsdom": "^26.0.0",
+    "react": "^18.2.0",
+    "react-dom": "^18.2.0",
+    "react-router-dom": "^6.26.0",
+    "typescript": "^5.8.2",
+    "vitest": "^3.0.0"
+  },
+  "license": "MIT"
+}