@green-on-grey/ui-kit 0.0.0-stage → 0.1.1

package/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/README.md

@@ -1,3 +1,76 @@
-# Temporary Holding Version
+# ui-kit
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+`@green-on-grey/ui-kit` — the UI kit of the Nabu and Hammurapi products: design tokens, styles,
+React components, icons, the chat and the sign-in screen. The look is the one of Nabu.
+
+Specification: `hammurapi-specs/specs/NAB/CMN/FTR.NAB.CMN-0005/`.
+Showcase: <https://greenongrey.github.io/ui-kit/> (every release also lives in `/vX.Y.Z/`).
+
+## Use in a product
+
+```sh
+npm install --save-exact @green-on-grey/ui-kit
+```
+
+```ts
+// main.tsx — the styles of the kit come before the styles of the product
+import "@green-on-grey/ui-kit/styles.css";
+import "./styles.css";
+
+// i18n — the strings of the components live in the namespace `uikit`
+import { resources as kit } from "@green-on-grey/ui-kit/locales";
+const resources = { en: { translation: en, uikit: kit.en }, ru: { translation: ru, uikit: kit.ru } /* … */ };
+```
+
+```tsx
+import { Avatar, Icon, Modal, ToastProvider, TopBar, useToast } from "@green-on-grey/ui-kit";
+import { Chat, ChatLayout, ConversationList } from "@green-on-grey/ui-kit/chat";
+import { LoginScreen } from "@green-on-grey/ui-kit/login";
+```
+
+| Entry | What |
+|---|---|
+| `@green-on-grey/ui-kit` | Components, icons, hooks |
+| `@green-on-grey/ui-kit/chat` | The chat and its view types. It never talks to a server: the product adapts its API to the types |
+| `@green-on-grey/ui-kit/login` | The sign-in screen |
+| `@green-on-grey/ui-kit/locales` | Strings in en, ru, de, es, zh |
+| `@green-on-grey/ui-kit/styles.css` | All the styles in one file; works without React |
+| `@green-on-grey/ui-kit/tokens.css` | Tokens and themes only |
+| `ui-kit-check` | Fails when a stylesheet of the product redefines the kit |
+
+`index.html` of a product links the fonts and applies the saved theme before the first paint:
+
+```html
+<link rel="preconnect" href="https://fonts.googleapis.com" />
+<link rel="preconnect" href="https://fonts.gstatic.com" crossorigin />
+<link href="https://fonts.googleapis.com/css2?family=Onest:wght@400;500;600;700&family=JetBrains+Mono:wght@400;500&display=swap" rel="stylesheet" />
+<script>
+  try { var t = localStorage.getItem("<product>-theme"); if (t && t !== "system") document.documentElement.setAttribute("data-theme", t); } catch (e) {}
+</script>
+```
+
+A product does not redefine classes and tokens of the kit; `npm run lint` of a product runs
+`ui-kit-check src/styles.css`.
+
+## Develop
+
+```sh
+npm ci
+npm run dev             # the showcase on http://localhost:5180, built from src/
+npm test                # vitest
+npm run test:e2e        # Playwright on the showcase: behaviour and snapshots
+npm run lint            # oxlint + tsc
+npm run build           # dist/: ESM, types, styles.css, tokens.css, manifest.json
+```
+
+To try a change in a product before a release, start the product with `UI_KIT_SRC=../ui-kit`.
+
+## Release
+
+1. Raise `version` in `package.json` and describe the release in `CHANGELOG.md` (`## X.Y.Z`).
+   A visible change of the look is at least a minor.
+2. Tag `vX.Y.Z` and push the tag: CI publishes the package to npm (trusted publishing) and the
+   showcase to GitHub Pages.
+
+Snapshots of the showcase are compared with zero tolerance; their baselines are made by the
+`update-snapshots` workflow, never on a developer machine.

package/bin/ui-kit-check.d.mts

@@ -0,0 +1,6 @@
+export interface Manifest { version: string; classes: string[]; roots: string[]; tokens: string[] }
+export interface Violation { line: number; selector: string; rule: 1 | 2 | 3; text: string }
+export function classesOf(selector: string): string[];
+export function compounds(selector: string): string[];
+export function target(selector: string): string;
+export function check(css: string, manifest: Manifest, from?: string): Violation[];

package/bin/ui-kit-check.mjs

@@ -0,0 +1,130 @@
+#!/usr/bin/env node
+// ui-kit-check: a product does not redefine the kit (FTR.NAB.CMN-0005 R23, tech §3.6).
+//   ui-kit-check src/styles.css [more files]
+// A violation is
+//   1. a declaration of a token of the kit;
+//   2. a rule whose target — the rightmost compound of the selector — is an element
+//      of the kit: it has a root class of the kit (one the kit styles on its own:
+//      .btn, .chip, .t) and no class of the product. Names of parts and states
+//      (.on, .hd, .lab) under a class of the product are the product's own;
+//   3. a rule whose selector has no class of the product at all: only tags, only
+//      classes of the kit or both.
+// There are no exceptions and no disabling comments: another look means a class
+// of the product or a change of the kit.
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { parse } from "postcss";
+
+export const classesOf = (selector) => [...selector.matchAll(/\.(-?[A-Za-z_][\w-]*)/g)].map((m) => m[1]);
+
+/** The compounds of a selector, left to right. Brackets and parentheses are kept
+ * whole: attribute values and arguments of :is() may hold spaces and combinators. */
+export function compounds(selector) {
+  const out = [];
+  let depth = 0;
+  let cur = "";
+  for (const ch of selector.trim()) {
+    if (ch === "(" || ch === "[") depth++;
+    if (ch === ")" || ch === "]") depth--;
+    if (depth === 0 && /[\s>+~]/.test(ch)) {
+      if (cur) out.push(cur);
+      cur = "";
+    } else cur += ch;
+  }
+  if (cur) out.push(cur);
+  return out;
+}
+
+/** The rightmost compound of a selector: what the rule styles. */
+export const target = (selector) => compounds(selector).at(-1) ?? "";
+
+/** A compound without the arguments of its functions: `.a:not(.b)` → `.a:not()`. */
+const outer = (compound) => {
+  let prev;
+  do { prev = compound; compound = compound.replace(/\([^()]*\)/g, "()"); } while (compound !== prev);
+  return compound;
+};
+
+/** Classes a compound may match through :is() and :where(): `:is(.btn, .chip)` → btn, chip. */
+function alternatives(compound) {
+  const out = [];
+  for (const m of compound.matchAll(/:(?:is|where|matches)\(/g)) {
+    let depth = 1;
+    let i = m.index + m[0].length;
+    const from = i;
+    for (; i < compound.length && depth > 0; i++) depth += compound[i] === "(" ? 1 : compound[i] === ")" ? -1 : 0;
+    // of every alternative only its own target counts
+    for (const alt of compound.slice(from, i - 1).split(",")) out.push(...classesOf(outer(target(alt))));
+  }
+  return out;
+}
+
+/** The selectors of a rule with the selectors of the rules it is nested in. */
+function resolved(rule) {
+  let list = rule.selectors;
+  for (let p = rule.parent; p; p = p.parent) {
+    if (p.type !== "rule") continue;
+    list = p.selectors.flatMap((ps) => list.map((s) => (s.includes("&") ? s.replaceAll("&", ps) : `${ps} ${s}`)));
+  }
+  return list;
+}
+
+/** Root classes of a stylesheet: those it styles on their own, as the single
+ * class of the first compound of a selector. */
+export function rootsOf(ast) {
+  const roots = new Set();
+  ast.walkRules((r) => {
+    for (const selector of r.selectors) {
+      const first = classesOf(compounds(selector)[0] ?? "");
+      if (first.length === 1) roots.add(first[0]);
+    }
+  });
+  return roots;
+}
+
+/** Violations of one stylesheet: `{ line, selector, rule, text }`. */
+export function check(css, manifest, from = "styles.css") {
+  const kit = new Set(manifest.classes);
+  const roots = new Set(manifest.roots);
+  const tokens = new Set(manifest.tokens);
+  const out = [];
+  const ast = parse(css, { from });
+  ast.walkDecls(/^--/, (d) => {
+    if (tokens.has(d.prop)) out.push({ line: d.source.start.line, selector: d.parent.selector ?? "", rule: 1, text: `the token ${d.prop} of the kit is redefined` });
+  });
+  ast.walkRules((r) => {
+    if (r.parent.type === "atrule" && r.parent.name.endsWith("keyframes")) return;
+    if (!r.nodes.some((n) => n.type === "decl" && !n.prop.startsWith("--"))) return;
+    for (const selector of resolved(r)) {
+      const own = (list) => list.some((c) => !kit.has(c));
+      const all = classesOf(selector);
+      // the classes the target has for certain, and those it may have through :is() / :where()
+      const sure = classesOf(outer(target(selector)));
+      const hit = [...sure, ...alternatives(target(selector))].filter((c) => roots.has(c));
+      if (!own(all)) out.push({ line: r.source.start.line, selector, rule: 3, text: "the selector has no class of the product" });
+      else if (hit.length > 0 && !own(sure)) out.push({ line: r.source.start.line, selector, rule: 2, text: `the rule restyles ${hit.map((c) => "." + c).join(", ")} of the kit` });
+    }
+  });
+  return out.toSorted((a, b) => a.line - b.line);
+}
+
+function main(argv) {
+  const files = argv.filter((a) => !a.startsWith("--"));
+  if (files.length === 0) {
+    console.error("usage: ui-kit-check <stylesheet> [more stylesheets]");
+    return 2;
+  }
+  const manifest = JSON.parse(fs.readFileSync(path.resolve(import.meta.dirname, "../dist/manifest.json"), "utf8"));
+  let bad = 0;
+  for (const file of files) {
+    for (const v of check(fs.readFileSync(file, "utf8"), manifest, file)) {
+      console.error(`${file}:${v.line}  ${v.selector}  — ${v.text} (rule ${v.rule})`);
+      bad++;
+    }
+  }
+  if (bad) console.error(`\nui-kit-check: ${bad} redefinition(s) of @green-on-grey/ui-kit ${manifest.version}. Use a class of the product or change the kit.`);
+  return bad ? 1 : 0;
+}
+
+if (process.argv[1] && fs.realpathSync(process.argv[1]) === fileURLToPath(import.meta.url)) process.exit(main(process.argv.slice(2)));

package/dist/chat/Chat.d.ts

@@ -0,0 +1,5 @@
+import type { ChatProps } from "./types";
+/** The conversation: the messages and the composer (FTR.NAB.CMN-0005 R11–R13,
+ * design §6). The behaviour is the one of the chat of Nabu. A control exists
+ * only when the product gave its handler: no `onCancel` — no cancel button. */
+export declare function Chat(props: ChatProps): import("react").JSX.Element;

package/dist/chat/ConversationList.d.ts

@@ -0,0 +1,19 @@
+import { type ReactNode } from "react";
+import type { ConversationListProps } from "./types";
+/** The conversations of the user: the main one, the topics, the archive (design
+ * §6.2). In a wide place the list stands left of the messages; on a phone and in
+ * a narrow place it lies over them while open and closes by a pick, a tap
+ * beside it or Escape. */
+export declare function ConversationList({ conversations, currentId, open, onPick, onClose, onCreate }: ConversationListProps): import("react").JSX.Element;
+/** The place of a chat: the list of conversations, the conversation and what the
+ * product puts beside them. `narrow` is for a side panel: the list lies over the
+ * messages as on a phone, whatever the width of the window. */
+export declare function ChatLayout({ narrow, children }: {
+    narrow?: boolean;
+    children: ReactNode;
+}): import("react").JSX.Element;
+/** The dialog of a new topic: one field, Enter creates. */
+export declare function NewTopicModal({ onClose, onCreate }: {
+    onClose: () => void;
+    onCreate: (title: string) => Promise<void>;
+}): import("react").JSX.Element;

package/dist/chat/MessageView.d.ts

@@ -0,0 +1,11 @@
+import type { ChatMessage, ChatStep } from "./types";
+/** The time of a caption: hours and minutes in the language of the interface. */
+export declare function markTime(iso: string, language: string): string;
+/** More than three steps are folded to the last two (design §6.4). */
+export declare function visibleSteps(steps: ChatStep[], open: boolean): ChatStep[];
+/** One message of the conversation (design §6.4). */
+export declare function MessageView({ m, busy, onRetry }: {
+    m: ChatMessage;
+    busy: boolean;
+    onRetry?: () => void;
+}): import("react").JSX.Element;

package/dist/chat/index.d.ts

@@ -0,0 +1,4 @@
+export { Chat } from "./Chat";
+export { ChatLayout, ConversationList, NewTopicModal } from "./ConversationList";
+export { useRecorder } from "./useRecorder";
+export type { ChatAttachment, ChatConfirmation, ChatConversation, ChatMark, ChatMessage, ChatProps, ChatStep, ChatUpload, ChatWait, ConversationListProps, } from "./types";

package/dist/chat/types.d.ts

@@ -0,0 +1,104 @@
+import type { ReactNode } from "react";
+import type { IconName } from "../components/Icon";
+export interface ChatConversation {
+    id: string;
+    group: "main" | "topic" | "archive";
+    title: string;
+    /** The time of the last message, already worded by the product. */
+    when?: string;
+    unread?: number;
+    icon?: IconName;
+}
+/** A file the user has attached to the message being written. */
+export interface ChatUpload {
+    id: string;
+    fileName: string;
+}
+export interface ChatAttachment extends ChatUpload {
+    href: string;
+}
+export interface ChatStep {
+    id: string;
+    text: string;
+    title?: string;
+    status: "running" | "done" | "error";
+}
+/** The caption over a message: the channel it came from or the context of the product. */
+export interface ChatMark {
+    icon: IconName;
+    text: string;
+}
+export type ChatWait = {
+    state: "starting";
+} | {
+    state: "queued";
+    position: number;
+};
+export interface ChatMessage {
+    id: string;
+    /** `note` is a line of the system without a bubble: the outcome of a confirmation, a cancelled turn. */
+    role: "user" | "assistant" | "note";
+    text: string;
+    /** ISO time. */
+    createdAt: string;
+    status: "pending" | "streaming" | "done" | "failed";
+    mark?: ChatMark;
+    attachments?: ChatAttachment[];
+    steps?: ChatStep[];
+    wait?: ChatWait;
+    error?: {
+        text: string;
+        transient: boolean;
+    };
+    /** The content of the product inside the message: a mail card, a digest. */
+    content?: ReactNode;
+}
+export interface ChatConfirmation {
+    id: string;
+    summary: string;
+    preview?: string;
+}
+/** Give the chat a `key` of the conversation: its composer and its scroll belong to one conversation. */
+export interface ChatProps {
+    agentName: string;
+    messages: ChatMessage[];
+    /** The header of the conversation: the agent, the model, the menus of the product. */
+    header?: ReactNode;
+    /** The second line of the empty conversation. */
+    emptyHint?: ReactNode;
+    loading?: boolean;
+    historyError?: ReactNode;
+    hasOlder?: boolean;
+    loadingOlder?: boolean;
+    /** A turn is being sent or answered: sending and retrying wait. */
+    busy?: boolean;
+    /** Shown instead of the composer: why one cannot write here and what to do. */
+    readOnly?: ReactNode;
+    confirmations?: ChatConfirmation[];
+    /** Over the composer: the modes of the chat of Hammurapi. */
+    aboveComposer?: ReactNode;
+    upload?: {
+        maxBytes: number;
+        accept?: string;
+    };
+    /** Resolves when the message is accepted (the composer is cleared); rejects to keep the text. */
+    onSend(text: string, attachmentIds: string[], voice: boolean): Promise<void>;
+    onLoadOlder?(): void;
+    onRetry?(messageId: string): void;
+    onCancel?(): void;
+    onConfirm?(id: string, approve: boolean): void;
+    /** `null`: the upload failed and the product has told the user. */
+    onUpload?(file: File): Promise<ChatUpload | null>;
+    /** The text of a recording; `null`: it failed and the product has told the user. */
+    onTranscribe?(recording: Blob): Promise<string | null>;
+}
+export interface ConversationListProps {
+    conversations: ChatConversation[];
+    currentId?: string;
+    /** In a narrow place and on a phone the list lies over the messages while open. */
+    open: boolean;
+    onPick(id: string): void;
+    onClose(): void;
+    /** Rejects with an Error whose message is shown in the dialog. */
+    onCreate?(title: string): Promise<void>;
+}

package/dist/chat/useRecorder.d.ts

@@ -0,0 +1,9 @@
+/** Push-to-talk recording with MediaRecorder. */
+export declare function useRecorder(): {
+    supported: boolean;
+    recording: boolean;
+    seconds: string;
+    error: boolean;
+    start: () => Promise<void>;
+    stop: () => Promise<Blob | null>;
+};