bitsnap-react 1.18.0 → 1.19.0

package/dist/widgets-BT2LN2Nq.d.mts

@@ -0,0 +1,547 @@
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import { L as LocaleTables } from './texts-9kfgClsA.mjs';
+
+/**
+ * Buyer side of the Bitsnap chat service (`bitsnap-messaging`): the shapes
+ * the library works with. The wire is snake_case JSON; `client.ts` maps it to
+ * these camelCase types. Times are ISO 8601 strings, `null` when absent.
+ */
+/** Default base URL of the chat service. */
+declare const DEFAULT_CHAT_API_URL = "https://chat.bitsnap.pl";
+/** Default NATS WebSocket URL, used when the realtime token lists no server. */
+declare const DEFAULT_CHAT_REALTIME_URL = "wss://bitsnap-nats-queue-production.up.railway.app";
+/** One paid order that gives a pack thread creator replies. */
+type ChatPack = {
+    orderId: string;
+    productId?: string;
+    replies: number;
+    used: number;
+    left: number;
+    expiresAt: string | null;
+    expired: boolean;
+};
+/** A stored message, or the pending answer of a send. */
+type ChatMessage = {
+    id: string;
+    threadId: string;
+    authorEmail: string;
+    body: string;
+    attachmentKey?: string;
+    attachmentKind?: string;
+    createdAt: string;
+    pinned: boolean;
+    /** Soft deleted: the body is empty. */
+    deleted: boolean;
+    /** A message of the service, such as the creator's away notice. */
+    system: boolean;
+    /** `"pending"` in the answer of a send: queued, not stored yet. */
+    status?: "pending";
+};
+/** The state of a conversation for the caller (`ThreadView` on the wire). */
+type ChatThreadSummary = {
+    id: string;
+    kind: "pack" | "channel";
+    channelId?: string;
+    /** For a buyer, the creator's e-mail (pack) or the channel name. */
+    title: string;
+    lastMessage?: ChatMessage;
+    unread: number;
+    repliesTotal: number;
+    repliesUsed: number;
+    repliesLeft: number;
+    expiresAt: string | null;
+    /** The caller cannot write: every pack has expired. */
+    composerLocked: boolean;
+    productId?: string;
+    /** The creator's promise in hours ("odpowiedź w ciągu 48 h"), 0 for none. */
+    responseHours: number;
+    packs: ChatPack[];
+    muted: boolean;
+};
+/** A channel the caller may read. */
+type ChatChannelSummary = {
+    id: string;
+    name: string;
+    topic: string;
+    welcome: string;
+    whoCanPost: "creator" | "members";
+    productId: string;
+    /** `creator`, `member` or `muted`. */
+    role: string;
+    memberCount: number;
+    createdAt: string;
+    blockLinks: boolean;
+    blockMedia: boolean;
+    cooldownSeconds: number;
+};
+/** A pack the buyer holds and has not opened a thread for yet. */
+type ChatPackEntitlement = {
+    productId: string;
+    name: string;
+    repliesLeftHint: number;
+    expiresAt: string | null;
+};
+/** A community product the buyer holds; `channelId` once a channel is bound. */
+type ChatChannelEntitlement = {
+    productId: string;
+    channelId?: string;
+};
+/** `GET /v1/me`: the buyer's chat in one project. */
+type ChatMe = {
+    email: string;
+    threads: ChatThreadSummary[];
+    entitlements: {
+        packs: ChatPackEntitlement[];
+        channels: ChatChannelEntitlement[];
+    };
+    channels: ChatChannelSummary[];
+};
+/** One page of history, newest first as the service answers it. */
+type ChatMessagePage = {
+    messages: ChatMessage[];
+    hasMore: boolean;
+};
+/** The thread part of a send answer. */
+type ChatThreadState = Pick<ChatThreadSummary, "id" | "kind" | "repliesTotal" | "repliesUsed" | "repliesLeft" | "expiresAt" | "composerLocked" | "responseHours">;
+/** `POST /v1/threads/{id}/messages` answers 202 with the queued message. */
+type ChatSendResult = {
+    message: ChatMessage;
+    thread: ChatThreadState;
+};
+type ChatReportReason = "spam" | "abuse" | "illegal" | "other";
+/** `POST /v1/realtime/token`. */
+type ChatRealtimeToken = {
+    jwt: string;
+    expiresAt: string;
+    servers: string[];
+    subjects: string[];
+    truncated: boolean;
+};
+/** Live events on the thread or channel subject. */
+type ChatRealtimeEvent = {
+    type: "message.created";
+    message: ChatMessage;
+} | {
+    type: "message.rejected";
+    id: string;
+    reason: string;
+} | {
+    type: "message.deleted";
+    id: string;
+} | {
+    type: "message.pinned";
+    id: string;
+} | {
+    type: "message.unpinned";
+    id: string;
+};
+/** How a conversation hears about new messages. */
+type ChatLiveMode = "connecting" | "live" | "polling" | "off";
+
+/**
+ * An error answer of the chat service (`{"error":"<code>"}`), or `network`
+ * (status 0) when the request did not get an answer.
+ *
+ * Codes the buyer UI handles: `unauthorized` (401), `plan_required`,
+ * `locked`, `muted`, `blocked`, `forbidden`, `read_only` (403), `not_found`
+ * (404), `moderation_link`, `moderation_banned_word`, `moderation_media`
+ * (422), `cooldown` (429, with `retryAfter`), `unavailable` (503),
+ * `invalid_project` (400).
+ */
+declare class ChatError extends Error {
+    readonly code: string;
+    readonly status: number;
+    /** `cooldown`: seconds to wait before the next post. */
+    readonly retryAfter?: number;
+    /** Extra fields of the answer (`locked`: `product_id`, `price_cents`, `welcome`). */
+    readonly data: Record<string, unknown>;
+    constructor(code: string, status: number, data?: Record<string, unknown>);
+}
+type ChatClientOptions = {
+    /** Project id sent as `X-Bitsnap-Project`. */
+    projectId: string;
+    /** Bearer credential: the panel session token or a `bcht_` buyer token. */
+    token: string;
+    /** Base URL of the chat service. Defaults to `https://chat.bitsnap.pl`. */
+    baseUrl?: string;
+    /** Replaces `fetch` (tests, server rendering). */
+    fetch?: typeof fetch;
+};
+/** The buyer calls of the chat service HTTP API. */
+type ChatClient = {
+    readonly baseUrl: string;
+    readonly projectId: string;
+    me(): Promise<ChatMe>;
+    /** Opens or returns the pack thread of a service product. */
+    openThread(productId: string): Promise<ChatThreadSummary>;
+    /** Newest first; `before` is a message id. */
+    messages(threadId: string, options?: {
+        before?: string;
+        limit?: number;
+    }): Promise<ChatMessagePage>;
+    /** Queues a message. The service answers 202 with `status: "pending"`. */
+    send(threadId: string, input: {
+        body: string;
+        clientId?: string;
+    }): Promise<ChatSendResult>;
+    deleteMessage(threadId: string, messageId: string): Promise<void>;
+    mute(threadId: string, muted: boolean): Promise<void>;
+    report(input: {
+        threadId: string;
+        messageId?: string;
+        reason: ChatReportReason;
+        note?: string;
+    }): Promise<void>;
+    markRead(threadId: string, messageId: string): Promise<void>;
+    /**
+     * A NATS token for every conversation the caller may read. The answer is
+     * kept until a minute and a half before it expires (the service mints one
+     * per caller every 10 s); `fresh` asks for a new one.
+     */
+    realtimeToken(options?: {
+        fresh?: boolean;
+    }): Promise<ChatRealtimeToken>;
+};
+declare function createChatClient(options: ChatClientOptions): ChatClient;
+/** Parses one live event of the thread or channel subject. */
+declare function parseRealtimeEvent(raw: unknown): ChatRealtimeEvent | null;
+
+/** The part of `@nats-io/nats-core` the chat uses. */
+type NatsModule = {
+    wsconnect(options: {
+        servers: string[];
+        authenticator: unknown;
+        name?: string;
+        reconnect?: boolean;
+        maxReconnectAttempts?: number;
+    }): Promise<NatsConnectionLike>;
+    jwtAuthenticator(jwt: () => string): unknown;
+};
+type NatsConnectionLike = {
+    subscribe(subject: string, options: {
+        callback: (error: Error | null, msg: {
+            data: Uint8Array;
+        }) => void;
+    }): {
+        unsubscribe(): void;
+    };
+    closed(): Promise<void | Error>;
+    close(): Promise<void>;
+};
+type LiveOptions = {
+    client: ChatClient;
+    /** `thread` for a pack thread, `channel` for a channel. */
+    kind: "thread" | "channel";
+    /** Thread id (a channel thread has the channel's id). */
+    id: string;
+    onEvent: (event: ChatRealtimeEvent) => void;
+    onMode: (mode: ChatLiveMode) => void;
+    /** Loads the newest page: the fallback, and the catch-up after a connect. */
+    poll: () => Promise<void>;
+    /** Polling interval while the socket is down. Default 8 s. */
+    pollIntervalMs?: number;
+    /** Delay before the socket is tried again after a failure. Default 60 s. */
+    retryMs?: number;
+    /** Overrides the WebSocket servers of the realtime token. */
+    realtimeUrl?: string;
+    /** Replaces the NATS loader (tests). */
+    loadNats?: () => Promise<NatsModule>;
+};
+/**
+ * Listens to one conversation: a realtime token from the chat service, then
+ * a subscribe-only NATS WebSocket on the conversation's subject. When any
+ * step fails (no WebSocket, token refused, subject not granted, socket
+ * closed) it polls the newest page instead and tries the socket again later.
+ * Returns the stop function.
+ */
+declare function startLive(options: LiveOptions): () => void;
+
+/**
+ * Every string of the chat (panel "Wiadomości", `ChatThread`, `Channel`).
+ * Pass a partial object through the `texts` prop to override any of them,
+ * whatever the locale. Placeholders like `{count}` stay in overrides.
+ *
+ * Counts use three forms (`One`, `Few`, `Many`) for Polish; English uses
+ * `One` and `Many`.
+ */
+type ChatTexts = {
+    inboxHeading: string;
+    inboxIntro: string;
+    inboxEmpty: string;
+    inboxError: string;
+    loading: string;
+    retry: string;
+    back: string;
+    selectConversation: string;
+    kindChat: string;
+    kindChannel: string;
+    startSection: string;
+    startChat: string;
+    openChannel: string;
+    channelNotReady: string;
+    chatFallbackTitle: string;
+    channelFallbackTitle: string;
+    /** Placeholder `{count}`. */
+    repliesLeftOne: string;
+    repliesLeftFew: string;
+    repliesLeftMany: string;
+    noRepliesLeft: string;
+    /** Placeholder `{date}`. */
+    expiresOn: string;
+    /** Placeholder `{date}`. */
+    expiredOn: string;
+    /** Placeholder `{hours}`. */
+    responseHours: string;
+    /** Placeholder `{count}`. */
+    unread: string;
+    /** Placeholder `{count}`. */
+    members: string;
+    mutedBadge: string;
+    noMessagesYet: string;
+    emptyThread: string;
+    emptyChannel: string;
+    privacyNote: string;
+    loadOlder: string;
+    you: string;
+    creator: string;
+    systemLabel: string;
+    pinned: string;
+    deletedPlaceholder: string;
+    attachment: string;
+    composerLabel: string;
+    composerPlaceholder: string;
+    send: string;
+    composerExpired: string;
+    composerCreatorOnly: string;
+    composerMuted: string;
+    composerReadOnly: string;
+    lockRepliesTitle: string;
+    lockRepliesBody: string;
+    lockExpiredTitle: string;
+    lockExpiredBody: string;
+    lockThreadTitle: string;
+    lockThreadBody: string;
+    lockChannelTitle: string;
+    lockChannelBody: string;
+    buyPack: string;
+    buyAccess: string;
+    buying: string;
+    buyError: string;
+    pending: string;
+    notConfirmed: string;
+    rejectedLink: string;
+    rejectedBannedWord: string;
+    rejectedMedia: string;
+    /** Placeholder `{seconds}`. */
+    rejectedCooldown: string;
+    rejectedBlocked: string;
+    rejectedMuted: string;
+    rejectedReadOnly: string;
+    rejectedPackEmpty: string;
+    rejectedForbidden: string;
+    rejectedGeneric: string;
+    failedNetwork: string;
+    editMessage: string;
+    retrySend: string;
+    dismiss: string;
+    messageActions: string;
+    deleteMessage: string;
+    deleteConfirm: string;
+    reportMessage: string;
+    conversationActions: string;
+    muteThread: string;
+    unmuteThread: string;
+    muteError: string;
+    reportConversation: string;
+    reportTitle: string;
+    reportConversationTitle: string;
+    reportReason: string;
+    reasonSpam: string;
+    reasonAbuse: string;
+    reasonIllegal: string;
+    reasonOther: string;
+    reportNote: string;
+    reportSend: string;
+    reportCancel: string;
+    reportSent: string;
+    reportError: string;
+    liveLabel: string;
+    pollingLabel: string;
+    errorNoToken: string;
+    errorUnauthorized: string;
+    errorPlan: string;
+    errorNotFound: string;
+    errorUnavailable: string;
+    errorGeneric: string;
+};
+declare const CHAT_TEXT_TABLES: LocaleTables<keyof ChatTexts>;
+/** Chat strings for a locale (default: the library locale), with overrides. */
+declare function getChatTexts(overrides?: Partial<ChatTexts>, locale?: string): ChatTexts;
+
+/** What to open: a pack thread (by product or id) or a channel. */
+type ConversationTarget = {
+    kind: "thread";
+    threadId?: string;
+    productId?: string;
+} | {
+    kind: "channel";
+    channelId: string;
+    productId?: string;
+};
+/** The client-side state of a message the service has not stored. */
+type LocalMessageState = {
+    state: "pending" | "unconfirmed" | "rejected" | "failed";
+    /** Error code or live reject reason. */
+    reason?: string;
+    retryAfter?: number;
+    /** An earlier send of this message may have been queued: retries keep its id. */
+    keepId?: boolean;
+};
+type ConversationMessage = ChatMessage & {
+    local?: LocalMessageState;
+};
+/**
+ * Why the buyer sees the lock: `replies` (no creator replies left, writing
+ * still works), `expired` (every pack expired), `no-pack` (no thread and no
+ * pack for the product), `no-access` (a paid channel without a grant).
+ */
+type ConversationLock = {
+    reason: "replies" | "expired" | "no-pack" | "no-access";
+    productId?: string;
+    priceCents?: number;
+    welcome?: string;
+};
+type ConversationState = {
+    status: "loading" | "ready" | "locked" | "error";
+    error?: ChatError;
+    threadId?: string;
+    /** The caller's e-mail, lowercased. */
+    me?: string;
+    thread?: ChatThreadSummary;
+    channel?: ChatChannelSummary;
+    lock?: ConversationLock;
+    /** Oldest first. */
+    messages: ConversationMessage[];
+    hasMore: boolean;
+    loadingOlder: boolean;
+    live: ChatLiveMode;
+};
+type ConversationActions = {
+    send(body: string): Promise<void>;
+    /** Sends a failed or refused message again. */
+    retry(id: string): Promise<void>;
+    /** Removes a message that was not stored. */
+    discard(id: string): void;
+    deleteMessage(id: string): Promise<void>;
+    report(input: {
+        messageId?: string;
+        reason: ChatReportReason;
+        note?: string;
+    }): Promise<void>;
+    setMuted(muted: boolean): Promise<void>;
+    loadOlder(): Promise<void>;
+    reload(): void;
+};
+type UseConversationOptions = {
+    /**
+     * `undefined` when there is no credential (the state is an error), `null`
+     * while the credential is still being looked up (the state stays loading).
+     */
+    client: ChatClient | null | undefined;
+    target: ConversationTarget;
+    pollIntervalMs?: number;
+    realtimeUrl?: string;
+    loadNats?: () => Promise<NatsModule>;
+    /** A pending send counts as unconfirmed after this long. Default 45 s. */
+    confirmTimeoutMs?: number;
+};
+/**
+ * State and actions of one conversation: resolves the thread (opening a pack
+ * thread when the buyer holds a pack and has none yet), loads the newest
+ * page, listens live (or polls) and sends optimistically.
+ */
+declare function useConversation(options: UseConversationOptions): ConversationState & ConversationActions;
+
+/** What the lock's buy action gets. */
+type ChatBuyRequest = {
+    /** The product (or variant) to sell: `buyProductId`, else the locked product. */
+    productId: string;
+    /** `replies`, `expired`, `no-pack` or `no-access`. */
+    reason: ConversationLock["reason"];
+    /** Known for a locked channel (from the chat service). */
+    priceCents?: number;
+};
+/** Props shared by `ChatThread` and `Channel`. */
+type ChatWidgetBaseProps = {
+    /**
+     * Public Bitsnap project id of the shop. The cart uses it, the panel
+     * session is looked up with it, and it is the `X-Bitsnap-Project` of the
+     * chat service unless `chatProjectID` is given.
+     */
+    projectID: string;
+    /** Project id for the chat service, when it differs from `projectID`. */
+    chatProjectID?: string;
+    /**
+     * Bearer for the chat service: a `bcht_` buyer token from your server
+     * (`POST /api/v1/chat/buyer-token`). Defaults to the customer panel session
+     * of this browser (after `PanelLogin`).
+     */
+    token?: string;
+    /** Chat service base URL. Defaults to `https://chat.bitsnap.pl`. */
+    apiUrl?: string;
+    /** NATS WebSocket URL overriding the one of the realtime token. */
+    realtimeUrl?: string;
+    /** Bitsnap host of the panel session (`setHost`), when not the default. */
+    host?: string;
+    /** Polling interval in ms while the live connection is down. Default 8000. */
+    pollIntervalMs?: number;
+    /** Language of the default texts; defaults to the library locale. */
+    locale?: string;
+    /** Text overrides, whatever the locale. */
+    texts?: Partial<ChatTexts>;
+    /** Heading of the conversation. */
+    title?: string;
+    /** Shows a back button in the header. */
+    onBack?: () => void;
+    /**
+     * The lock's "Kup pakiet" / "Kup dostęp". Default: add the product to the
+     * page cart and open it (mount `BitsnapCheckout` on the page). Throw to
+     * show the error line.
+     */
+    onBuy?: (request: ChatBuyRequest) => Promise<void> | void;
+    /** The product or variant the buy action sells (e.g. the pack variant). */
+    buyProductId?: string;
+    className?: string;
+    /** A ready client (tests, custom transport). Replaces token and URLs. */
+    client?: ChatClient;
+    /** @internal Replaces the NATS loader (tests). */
+    loadNats?: () => Promise<NatsModule>;
+};
+type ChatThreadProps = ChatWidgetBaseProps & {
+    /** The service product of the pack: opens its thread, creating it if needed. */
+    productId?: string;
+    /** An existing thread. Give this or `productId`. */
+    threadId?: string;
+};
+type ChannelProps = ChatWidgetBaseProps & {
+    /** The channel (its id is also the id of its conversation). */
+    channelId: string;
+    /** The community product sold by the lock; defaults to the channel's own. */
+    productId?: string;
+};
+/**
+ * A buyer's pack thread for one service product: history, live updates,
+ * sending with pending and refused states, report and mute, and the lock
+ * with "Kup pakiet" when the replies are used up or the pack expired.
+ * Load `bitsnap-react/dist/index.css` once.
+ */
+declare function ChatThread(props: ChatThreadProps): react_jsx_runtime.JSX.Element;
+/**
+ * A community channel: messages, live updates, posting when the channel
+ * allows it (with the channel's moderation refusals shown on the message),
+ * report, and the lock with "Kup dostęp" for a buyer without a grant.
+ * Load `bitsnap-react/dist/index.css` once.
+ */
+declare function Channel(props: ChannelProps): react_jsx_runtime.JSX.Element;
+
+export { type ChatPackEntitlement as A, type ChatRealtimeEvent as B, type ChatTexts as C, DEFAULT_CHAT_API_URL as D, type ChatRealtimeToken as E, type ChatReportReason as F, type ChatSendResult as G, type ChatThreadState as H, type ChatThreadSummary as I, type LiveOptions as L, type UseConversationOptions as U, Channel as a, ChatThread as b, type ChannelProps as c, type ChatBuyRequest as d, type ChatThreadProps as e, type ChatWidgetBaseProps as f, ChatError as g, createChatClient as h, type ChatClient as i, type ChatClientOptions as j, type ConversationLock as k, type ConversationMessage as l, type ConversationTarget as m, CHAT_TEXT_TABLES as n, getChatTexts as o, parseRealtimeEvent as p, DEFAULT_CHAT_REALTIME_URL as q, type ChatChannelEntitlement as r, startLive as s, type ChatChannelSummary as t, useConversation as u, type ChatLiveMode as v, type ChatMe as w, type ChatMessage as x, type ChatMessagePage as y, type ChatPack as z };