@arbidocs/react 0.5.111 → 0.5.112

package/dist/documents/related-documents.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/documents/related-documents.ts"],
+  "sourcesContent": ["/**\n * The documents related to each document of a workspace. It computes a map of related documents for each document in the workspace.\n * Relationships include:\n * - Email family: parent/child via parent_ext_id (an attachment and its email, a message and its\n *   mailbox archive). Versions are NOT relations: they live inside their document.\n * - Made from: derivations (a crop's source image, a redline's inputs, a redacted copy's original,\n *   a production's documents) from `derived_from`, with the source version when it is not the\n *   current one; and the other way round, the copies made from a document\n * - Exact duplicates (same content_hash / fingerprint)\n * - Near-duplicates (from similarity API)\n *\n * Returns a stable Map<docExtId, RelatedDocs> recomputed only when\n * the documents array or similarity data changes.\n */\n\nimport { useMemo, useRef } from 'react'\nimport type { WorkspaceDocument } from './documents-cache'\nimport { SIMILARITY_THRESHOLD, useSimilarDocuments } from './documents-data'\n\nexport interface RelatedDocs<D extends WorkspaceDocument = WorkspaceDocument> {\n  /** The email / mailbox archive this document was extracted from. */\n  parent?: D\n  /** Attachments: documents extracted from this one. */\n  children: D[]\n  /** Documents this one was made from (crop, redline, redacted copy); not the previous version. */\n  madeFrom: D[]\n  /** Documents made from this one (a redacted or annotated copy, a production, a crop). */\n  copies: D[]\n  /** How each made-from / copy document is related, by its id (a `derived_from` role). */\n  roles: Record<string, string>\n  /**\n   * The version of a made-from document this one was made from, by its id \u2014 only when that is\n   * not the source's current version (the copy was made from an older version).\n   */\n  versions?: Record<string, number>\n  duplicates: D[]\n  similar: Array<{ doc: D; similarity: number }>\n}\n\nexport type RelatedDocsMap<D extends WorkspaceDocument = WorkspaceDocument> = Map<\n  string,\n  RelatedDocs<D>\n>\n\n/** Count total related documents for a given entry */\nexport function getRelatedTotal(related: RelatedDocs<WorkspaceDocument>): number {\n  return (\n    (related.parent ? 1 : 0) +\n    related.children.length +\n    related.madeFrom.length +\n    related.copies.length +\n    related.duplicates.length +\n    related.similar.length\n  )\n}\n\n/** Build human-readable count labels per relationship type */\nexport function getRelatedLabels(related: RelatedDocs<WorkspaceDocument>): string[] {\n  const parts: string[] = []\n  if (related.parent) parts.push('1 parent')\n  if (related.children.length > 0) {\n    const n = related.children.length\n    parts.push(`${n} ${n === 1 ? 'attachment' : 'attachments'}`)\n  }\n  if (related.madeFrom.length > 0) parts.push(`made from ${related.madeFrom.length}`)\n  if (related.copies.length > 0) {\n    const n = related.copies.length\n    parts.push(`${n} ${n === 1 ? 'copy' : 'copies'}`)\n  }\n  if (related.duplicates.length > 0) {\n    const n = related.duplicates.length\n    parts.push(`${n} ${n === 1 ? 'duplicate' : 'duplicates'}`)\n  }\n  if (related.similar.length > 0) {\n    const n = related.similar.length\n    parts.push(`${n} similar`)\n  }\n  return parts\n}\n\n/**\n * Computes related documents map from workspace documents and similarity API.\n * Call this in a component that has access to the documents array.\n */\nexport function useRelatedDocuments<D extends WorkspaceDocument>(\n  documents: D[]\n): RelatedDocsMap<D> {\n  const { data: similarData } = useSimilarDocuments()\n\n  // Structural fingerprint \u2014 only recompute when fields that affect relationships change.\n  // Metadata-only changes (title rename, tag toggle, status update) produce the same\n  // fingerprint and skip the expensive map rebuild.\n  const structuralKey = useMemo(() => {\n    const parts: string[] = []\n    for (const doc of documents) {\n      parts.push(doc.external_id)\n      parts.push(doc.parent_ext_id || '')\n      parts.push(doc.content_hash || '')\n      parts.push(String(doc.current_version ?? 1))\n      for (const source of doc.derived_from ?? [])\n        parts.push(source.doc_ext_id, source.role, String(source.version ?? ''))\n    }\n    return parts.join('|')\n  }, [documents])\n\n  const prevKeyRef = useRef(structuralKey)\n  const prevMapRef = useRef<RelatedDocsMap<D>>(new Map())\n  // Also track documents ref so we rebuild map with fresh Doc objects when structure changes\n  const prevDocsRef = useRef(documents)\n  const prevSimilarRef = useRef(similarData)\n\n  return useMemo(() => {\n    // If nothing that affects relationships has changed, reuse the previous result.\n    // Must also check similarData \u2014 it arrives async after the initial build.\n    if (\n      prevKeyRef.current === structuralKey &&\n      prevSimilarRef.current === similarData &&\n      prevMapRef.current.size > 0 &&\n      prevDocsRef.current === documents\n    ) {\n      return prevMapRef.current\n    }\n    prevKeyRef.current = structuralKey\n    prevDocsRef.current = documents\n    prevSimilarRef.current = similarData\n    const map = new Map<string, RelatedDocs<D>>()\n\n    const getOrCreate = (docId: string): RelatedDocs<D> => {\n      let entry = map.get(docId)\n      if (!entry) {\n        entry = { children: [], madeFrom: [], copies: [], roles: {}, duplicates: [], similar: [] }\n        map.set(docId, entry)\n      }\n      return entry\n    }\n\n    // Index documents by ID for O(1) lookups\n    const docById = new Map<string, D>()\n    for (const doc of documents) {\n      docById.set(doc.external_id, doc)\n    }\n\n    // Build content_hash index for exact duplicate detection\n    const byHash = new Map<string, D[]>()\n    for (const doc of documents) {\n      if (doc.content_hash) {\n        const list = byHash.get(doc.content_hash) || []\n        list.push(doc)\n        byHash.set(doc.content_hash, list)\n      }\n    }\n\n    // Parent/child relationships\n    for (const doc of documents) {\n      if (doc.parent_ext_id) {\n        const parent = docById.get(doc.parent_ext_id)\n        if (parent) {\n          getOrCreate(doc.external_id).parent = parent\n          getOrCreate(parent.external_id).children.push(doc)\n        }\n      }\n    }\n\n    // Made from / copies \u2014 derivations of separate documents (versions live inside a document).\n    for (const doc of documents) {\n      for (const source of doc.derived_from ?? []) {\n        const from = docById.get(source.doc_ext_id)\n        if (!from) continue\n        const made = getOrCreate(doc.external_id)\n        made.madeFrom.push(from)\n        made.roles[from.external_id] = source.role\n        if (source.version && source.version !== (from.current_version ?? 1)) {\n          made.versions = { ...made.versions, [from.external_id]: source.version }\n        }\n        const original = getOrCreate(from.external_id)\n        original.copies.push(doc)\n        original.roles[doc.external_id] = source.role\n      }\n    }\n\n    // Exact duplicates \u2014 same content_hash, excluding self\n    for (const [, docs] of byHash) {\n      if (docs.length > 1) {\n        for (const doc of docs) {\n          getOrCreate(doc.external_id).duplicates = docs.filter(\n            (d) => d.external_id !== doc.external_id\n          )\n        }\n      }\n    }\n\n    // Near-duplicates from similarity API\n    // Only include pairs with SIMILARITY_THRESHOLD \u2264 similarity < 1.0\n    // (1.0 exact matches are already in duplicates above)\n    if (similarData?.pairs) {\n      for (const pair of similarData.pairs) {\n        if (pair.similarity < SIMILARITY_THRESHOLD || pair.similarity >= 1.0) continue\n        const docA = docById.get(pair.doc_a.external_id)\n        const docB = docById.get(pair.doc_b.external_id)\n        if (docA && docB) {\n          getOrCreate(docA.external_id).similar.push({\n            doc: docB,\n            similarity: pair.similarity,\n          })\n          getOrCreate(docB.external_id).similar.push({\n            doc: docA,\n            similarity: pair.similarity,\n          })\n        }\n      }\n    }\n\n    prevMapRef.current = map\n    return map\n  }, [documents, similarData, structuralKey])\n}\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/documents/support.js

@@ -0,0 +1,29 @@
+import { useArbiWsStore } from "../websocket/store.js";
+import { useArbiHost } from "../host/config.js";
+const NO_SUPPORT = {};
+function useDocumentsSupport() {
+  return useArbiHost().documents ?? NO_SUPPORT;
+}
+function useProcessingTasks() {
+  return useArbiWsStore((state) => state.tasks);
+}
+function useProcessingTask(docId) {
+  return useArbiWsStore((state) => state.tasks[docId]);
+}
+const NO_ACTIONS = {};
+function useDocumentHostActions() {
+  const { useHostActions } = useDocumentsSupport();
+  return useHostActions?.() ?? NO_ACTIONS;
+}
+function useOpenViewerDocumentId() {
+  const { useOpenViewerDocumentId: useHostViewing } = useDocumentsSupport();
+  return useHostViewing?.() ?? null;
+}
+export {
+  useDocumentHostActions,
+  useDocumentsSupport,
+  useOpenViewerDocumentId,
+  useProcessingTask,
+  useProcessingTasks
+};
+//# sourceMappingURL=support.js.map

package/dist/documents/support.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/documents/support.tsx"],
+  "sourcesContent": ["/**\n * What a host adds to the document hooks and the document kits, opt in (the host configuration's\n * `documents`): the live processing state it keeps (from its own live connection), what happens on\n * its side when documents are deleted or queued for processing, how it uploads (workspace key, zip\n * archives), and what it does with documents beyond the package (its workflows, chat, mail, offline\n * copies, viewer). Without it the hooks work on their own, and the kits offer less, never something\n * that does nothing.\n */\n\nimport type { components } from '@arbidocs/client'\nimport type { ZipExtractor } from './upload-files'\nimport type { WorkspaceDocument } from './documents-cache'\nimport type { ReactNode } from 'react'\nimport { useArbiWsStore } from '../websocket/store'\nimport { useArbiHost } from '../host/config'\n\n/** Something the host can start on documents or a folder (a workflow, a skill). */\nexport interface DocumentStartItem {\n  id: string\n  title: string\n  run: () => void\n}\n\n/** What the host does with documents beyond the package. Each absent one is not offered. */\nexport interface DocumentHostActions {\n  /** What can be started on one file. */\n  startItemsForFile?: (document: WorkspaceDocument) => DocumentStartItem[]\n  /** What can be started on everything in a folder. */\n  startItemsForFolder?: (folderPath: string) => DocumentStartItem[]\n  /** Start a chat about one document. */\n  openDocumentChat?: (docId: string) => void\n  /** Start a chat about several documents. */\n  openDocumentsChat?: (docIds: string[]) => void\n  /**\n   * Hand a document to the host's mail composer as an attachment (offered while mail is on): its\n   * current version, or an earlier one (`version`, 1-based).\n   */\n  emailDocument?: (\n    document: WorkspaceDocument,\n    options?: { version?: number | null }\n  ) => Promise<void>\n  /** Show how to raise the plan's limits (an upload was refused for them). */\n  openUpgrade?: () => void\n  /** Show the AI budget a document's processing ran into, and what can be done. */\n  openQuota?: (quota: { spend: number; budget: number; projectExtId: string | null }) => void\n  /** Open a person (yourself: your settings; someone else: a direct message). */\n  openUser?: (userId: string) => void\n  /** Open a document beside another, to compare them. */\n  compareDocuments?: (docId: string, otherDocId: string) => void\n  /** Open the fields manager (labels or AI fields), on its form for a new one with `create`. */\n  openFieldsManager?: (kind?: 'label' | 'annotation', options?: { create?: boolean }) => void\n}\n\n/** A person as the document kits show them (who made a document, a field, a value). */\nexport type DocumentPerson = components['schemas']['UserResponse']\n\n/** A document's live processing, as the host follows it (a `task_update` and what it adds). */\nexport interface ProcessingTask {\n  doc_ext_id: string\n  status: string\n  progress?: number | null\n  workspace_ext_id?: string | null\n  file_name?: string | null\n  failed_stage?: string | null\n  /** The event's order (`task_update.seq`; see `processing-order`). None on one set here. */\n  seq?: number | null\n}\n\nexport interface DocumentsSupport {\n  /**\n   * The workspace's raw key, for the direct upload (encrypted here, sent straight to storage) that\n   * the user's settings can turn on. Throws when the key is not held here (a public workspace, a\n   * temporary grant): the upload then goes through the server. Absent: always through the server.\n   */\n  resolveWorkspaceKey?: (workspaceId: string) => Promise<Uint8Array>\n  /** Opens a zip archive into its files (e.g. off the main thread). Default: on the main thread. */\n  extractZip?: ZipExtractor\n  /** The host's actions on documents, as a hook (a kit reads it once per view). */\n  useHostActions?: () => DocumentHostActions\n  /**\n   * Called once documents are kept on this device (`useKeepDocumentsOffline`), while still online:\n   * e.g. to load the viewer's code so a pinned document opens offline too.\n   */\n  onKeptOffline?: () => void | Promise<void>\n  /** The document open in the host's viewer while it is open (null when closed), as a hook. */\n  useOpenViewerDocumentId?: () => string | null\n  /**\n   * How the host shows a person (its presence, its card): by a document, a field, a thread's\n   * entry or a message. `tooltip`: whether hovering shows their card; `variant`: their face alone\n   * (`icon`, small, the default) or their face and name (`pill`). Absent: the kits' own avatar.\n   */\n  renderUser?: (\n    user: DocumentPerson,\n    options: { tooltip: boolean; variant?: 'icon' | 'pill' }\n  ) => ReactNode\n}\n\nconst NO_SUPPORT: DocumentsSupport = {}\n\n/** The host's document support (the host configuration's `documents`; empty without one). */\nexport function useDocumentsSupport(): DocumentsSupport {\n  return useArbiHost().documents ?? NO_SUPPORT\n}\n\n/** Every document's live processing (the shared WebSocket store's). */\nexport function useProcessingTasks(): Readonly<Record<string, ProcessingTask>> {\n  return useArbiWsStore((state) => state.tasks)\n}\n\n/** One document's live processing: re-renders only when that document's changes. */\nexport function useProcessingTask(docId: string): ProcessingTask | undefined {\n  return useArbiWsStore((state) => state.tasks[docId])\n}\n\nconst NO_ACTIONS: DocumentHostActions = {}\n\n/** The host's actions on documents (none without host support). */\nexport function useDocumentHostActions(): DocumentHostActions {\n  const { useHostActions } = useDocumentsSupport()\n  return useHostActions?.() ?? NO_ACTIONS\n}\n\n/** The document open in the host's viewer, while it is open (none without host support). */\nexport function useOpenViewerDocumentId(): string | null {\n  const { useOpenViewerDocumentId: useHostViewing } = useDocumentsSupport()\n  return useHostViewing?.() ?? null\n}\n"],
+  "mappings": "AAaA,SAAS,sBAAsB;AAC/B,SAAS,mBAAmB;AAmF5B,MAAM,aAA+B,CAAC;AAG/B,SAAS,sBAAwC;AACtD,SAAO,YAAY,EAAE,aAAa;AACpC;AAGO,SAAS,qBAA+D;AAC7E,SAAO,eAAe,CAAC,UAAU,MAAM,KAAK;AAC9C;AAGO,SAAS,kBAAkB,OAA2C;AAC3E,SAAO,eAAe,CAAC,UAAU,MAAM,MAAM,KAAK,CAAC;AACrD;AAEA,MAAM,aAAkC,CAAC;AAGlC,SAAS,yBAA8C;AAC5D,QAAM,EAAE,eAAe,IAAI,oBAAoB;AAC/C,SAAO,iBAAiB,KAAK;AAC/B;AAGO,SAAS,0BAAyC;AACvD,QAAM,EAAE,yBAAyB,eAAe,IAAI,oBAAoB;AACxE,SAAO,iBAAiB,KAAK;AAC/B;",
+  "names": []
+}

package/dist/documents/upload-files.js

@@ -0,0 +1,169 @@
+import { documents } from "@arbidocs/sdk/browser";
+const { SUPPORTED_EXTENSIONS, mimeFromName, sanitizeFolderPath } = documents;
+const UPLOAD_ACCEPT = ".pdf,.txt,.md,.html,.doc,.docx,.rtf,.ppt,.pptx,.xls,.xlsx,.jpg,.jpeg,.png,.gif,.bmp,.tiff,.tif,.webp,.mp4,.mpeg,.mpg,.webm,.mov,.avi,.mkv,.mp3,.wav,.m4a,.aac,.ogg,.flac,.eml,.msg,.mbox,.pst,.ost,.zip,application/pdf,text/plain,text/markdown,text/html,application/msword,application/vnd.openxmlformats-officedocument.wordprocessingml.document,application/rtf,application/vnd.ms-powerpoint,application/vnd.openxmlformats-officedocument.presentationml.presentation,application/vnd.ms-excel,application/vnd.openxmlformats-officedocument.spreadsheetml.sheet,image/jpeg,image/png,image/gif,image/bmp,image/tiff,image/webp,video/mp4,video/mpeg,video/webm,video/quicktime,video/x-msvideo,video/x-matroska,audio/mpeg,audio/wav,audio/mp4,audio/aac,audio/ogg,audio/flac,message/rfc822,application/vnd.ms-outlook,application/mbox,application/zip,application/x-zip-compressed";
+const UPLOAD_MAX_FILE_SIZE = 2 * 1024 * 1024 * 1024;
+const SUPPORTED_TYPES = /* @__PURE__ */ new Set([
+  "application/pdf",
+  "text/plain",
+  "text/markdown",
+  "text/html",
+  "application/msword",
+  "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+  "application/rtf",
+  "application/vnd.ms-powerpoint",
+  "application/vnd.openxmlformats-officedocument.presentationml.presentation",
+  "application/vnd.ms-excel",
+  "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+  "image/jpeg",
+  "image/png",
+  "image/gif",
+  "image/bmp",
+  "image/tiff",
+  "image/webp",
+  "video/mp4",
+  "video/mpeg",
+  "video/webm",
+  "video/quicktime",
+  "video/x-msvideo",
+  "video/x-matroska",
+  "audio/mpeg",
+  "audio/wav",
+  "audio/mp4",
+  "audio/aac",
+  "audio/ogg",
+  "audio/flac",
+  "message/rfc822",
+  "application/vnd.ms-outlook",
+  "application/mbox"
+]);
+function extensionOf(name) {
+  const dot = name.lastIndexOf(".");
+  return dot === -1 ? "" : name.slice(dot).toLowerCase();
+}
+function withRelativePath(file, relativePath) {
+  const copy = new File([file], file.name, { type: file.type, lastModified: file.lastModified });
+  Object.defineProperty(copy, "webkitRelativePath", { value: relativePath, writable: false });
+  return copy;
+}
+function isZipFile(file) {
+  return file.name.toLowerCase().endsWith(".zip") || file.type === "application/zip" || file.type === "application/x-zip-compressed";
+}
+const extractZipFile = async (zip, maxFileSize) => {
+  const { unzip } = await import("unzipit");
+  const { entries } = await unzip(await zip.arrayBuffer());
+  const names = Object.keys(entries).filter((name) => !entries[name].isDirectory);
+  const roots = new Set(names.map((name) => name.split("/")[0]));
+  const hasSingleRoot = roots.size === 1 && names.every((name) => name.includes("/"));
+  const base = zip.name.replace(/\.zip$/i, "");
+  const extractedFiles = [];
+  const skippedLargeFiles = [];
+  for (const name of names) {
+    const entry = entries[name];
+    if (!SUPPORTED_EXTENSIONS.has(extensionOf(name))) continue;
+    const fileName = name.split("/").pop() ?? name;
+    if (entry.size > maxFileSize) {
+      skippedLargeFiles.push(fileName);
+      continue;
+    }
+    const file = new File([await entry.arrayBuffer()], fileName, {
+      type: mimeFromName(fileName) ?? "application/octet-stream",
+      lastModified: entry.lastModDate?.getTime() ?? Date.now()
+    });
+    extractedFiles.push(withRelativePath(file, hasSingleRoot ? name : `${base}/${name}`));
+  }
+  return { extractedFiles, skippedLargeFiles };
+};
+async function prepareUploadFiles(chosen, options = {}) {
+  const maxFileSize = options.maxFileSize ?? UPLOAD_MAX_FILE_SIZE;
+  const extractZip = options.extractZip ?? extractZipFile;
+  const accepted = [];
+  const refused = [];
+  const zips = [];
+  for (const file of Array.from(chosen)) {
+    if (isZipFile(file)) {
+      zips.push(file);
+      continue;
+    }
+    const extension = extensionOf(file.name);
+    if (file.size === 0) refused.push({ name: file.name, reason: "empty" });
+    else if (file.size > maxFileSize) refused.push({ name: file.name, reason: "too_large" });
+    else if (!extension) refused.push({ name: file.name, reason: "no_extension" });
+    else if (!SUPPORTED_TYPES.has(file.type) && !SUPPORTED_EXTENSIONS.has(extension))
+      refused.push({ name: file.name, reason: "unsupported" });
+    else accepted.push(file);
+  }
+  for (const zip of zips) {
+    try {
+      const { extractedFiles, skippedLargeFiles } = await extractZip(zip, maxFileSize);
+      for (const name of skippedLargeFiles)
+        refused.push({ name: `${name} (from ${zip.name})`, reason: "too_large" });
+      if (extractedFiles.length === 0 && skippedLargeFiles.length === 0)
+        refused.push({ name: zip.name, reason: "empty_zip" });
+      accepted.push(...extractedFiles);
+    } catch {
+      refused.push({ name: zip.name, reason: "zip_error" });
+    }
+  }
+  accepted.sort(
+    (a, b) => (a.webkitRelativePath || a.name).toLowerCase().localeCompare((b.webkitRelativePath || b.name).toLowerCase())
+  );
+  return { accepted, refused };
+}
+function readDirectory(directory, path, into) {
+  return new Promise((resolve) => {
+    const reader = directory.createReader();
+    const readBatch = () => reader.readEntries(async (entries) => {
+      if (entries.length === 0) return resolve();
+      await Promise.all(
+        entries.map(
+          (entry) => entry.isFile ? new Promise(
+            (done) => entry.file(
+              (file) => {
+                into.push(withRelativePath(file, `${path}/${file.name}`));
+                done();
+              },
+              () => done()
+            )
+          ) : entry.isDirectory ? readDirectory(entry, `${path}/${entry.name}`, into) : Promise.resolve()
+        )
+      );
+      readBatch();
+    });
+    readBatch();
+  });
+}
+async function filesFromDrop(transfer) {
+  const items = Array.from(transfer.items ?? []);
+  if (items.length === 0) return Array.from(transfer.files ?? []);
+  const files = [];
+  const folders = [];
+  for (const item of items) {
+    if (item.kind !== "file") continue;
+    const entry = item.webkitGetAsEntry?.();
+    if (entry?.isDirectory) {
+      folders.push(readDirectory(entry, entry.name, files));
+    } else {
+      const file = item.getAsFile();
+      if (file) files.push(file);
+    }
+  }
+  await Promise.all(folders);
+  return files;
+}
+function uploadFolderOf(file, base) {
+  const relative = file.webkitRelativePath;
+  const slash = relative ? relative.lastIndexOf("/") : -1;
+  const own = slash > 0 ? relative.slice(0, slash) : "";
+  return sanitizeFolderPath([base, own].filter(Boolean).join("/")) || null;
+}
+export {
+  UPLOAD_ACCEPT,
+  UPLOAD_MAX_FILE_SIZE,
+  extractZipFile,
+  filesFromDrop,
+  isZipFile,
+  prepareUploadFiles,
+  uploadFolderOf,
+  withRelativePath
+};
+//# sourceMappingURL=upload-files.js.map

package/dist/documents/upload-files.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/documents/upload-files.ts"],
+  "sourcesContent": ["/**\n * Choosing files to upload: what the picker accepts, which files are refused and why, folders\n * dropped whole (each file keeps its path below the dropped folder), zip archives opened into\n * their files, and the folder a file goes to.\n */\n\nimport { documents } from '@arbidocs/sdk/browser'\n\nconst { SUPPORTED_EXTENSIONS, mimeFromName, sanitizeFolderPath } = documents\n\n/** The file picker's `accept`: every type an upload takes, zip archives included. */\nexport const UPLOAD_ACCEPT =\n  '.pdf,.txt,.md,.html,.doc,.docx,.rtf,.ppt,.pptx,.xls,.xlsx,.jpg,.jpeg,.png,.gif,.bmp,.tiff,.tif,.webp,.mp4,.mpeg,.mpg,.webm,.mov,.avi,.mkv,.mp3,.wav,.m4a,.aac,.ogg,.flac,.eml,.msg,.mbox,.pst,.ost,.zip,application/pdf,text/plain,text/markdown,text/html,application/msword,application/vnd.openxmlformats-officedocument.wordprocessingml.document,application/rtf,application/vnd.ms-powerpoint,application/vnd.openxmlformats-officedocument.presentationml.presentation,application/vnd.ms-excel,application/vnd.openxmlformats-officedocument.spreadsheetml.sheet,image/jpeg,image/png,image/gif,image/bmp,image/tiff,image/webp,video/mp4,video/mpeg,video/webm,video/quicktime,video/x-msvideo,video/x-matroska,audio/mpeg,audio/wav,audio/mp4,audio/aac,audio/ogg,audio/flac,message/rfc822,application/vnd.ms-outlook,application/mbox,application/zip,application/x-zip-compressed'\n\n/** The largest file a browser upload takes. */\nexport const UPLOAD_MAX_FILE_SIZE = 2 * 1024 * 1024 * 1024\n\nconst SUPPORTED_TYPES = new Set([\n  'application/pdf',\n  'text/plain',\n  'text/markdown',\n  'text/html',\n  'application/msword',\n  'application/vnd.openxmlformats-officedocument.wordprocessingml.document',\n  'application/rtf',\n  'application/vnd.ms-powerpoint',\n  'application/vnd.openxmlformats-officedocument.presentationml.presentation',\n  'application/vnd.ms-excel',\n  'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',\n  'image/jpeg',\n  'image/png',\n  'image/gif',\n  'image/bmp',\n  'image/tiff',\n  'image/webp',\n  'video/mp4',\n  'video/mpeg',\n  'video/webm',\n  'video/quicktime',\n  'video/x-msvideo',\n  'video/x-matroska',\n  'audio/mpeg',\n  'audio/wav',\n  'audio/mp4',\n  'audio/aac',\n  'audio/ogg',\n  'audio/flac',\n  'message/rfc822',\n  'application/vnd.ms-outlook',\n  'application/mbox',\n])\n\n/** Why a chosen file is not uploaded. */\nexport type UploadRefusal =\n  'empty' | 'too_large' | 'no_extension' | 'unsupported' | 'empty_zip' | 'zip_error'\n\nexport interface RefusedUploadFile {\n  name: string\n  reason: UploadRefusal\n}\n\n/** A zip archive's files, and the names of those too large to take. */\nexport interface ExtractedZip {\n  extractedFiles: File[]\n  skippedLargeFiles: string[]\n}\n\n/** Opens a zip archive into its files (each with its path in `webkitRelativePath`). */\nexport type ZipExtractor = (zip: File, maxFileSize: number) => Promise<ExtractedZip>\n\nfunction extensionOf(name: string): string {\n  const dot = name.lastIndexOf('.')\n  return dot === -1 ? '' : name.slice(dot).toLowerCase()\n}\n\n/** A file with its path below a dropped or picked folder (as the browser's folder picker sets). */\nexport function withRelativePath(file: File, relativePath: string): File {\n  const copy = new File([file], file.name, { type: file.type, lastModified: file.lastModified })\n  Object.defineProperty(copy, 'webkitRelativePath', { value: relativePath, writable: false })\n  return copy\n}\n\nexport function isZipFile(file: Pick<File, 'name' | 'type'>): boolean {\n  return (\n    file.name.toLowerCase().endsWith('.zip') ||\n    file.type === 'application/zip' ||\n    file.type === 'application/x-zip-compressed'\n  )\n}\n\n/**\n * Open a zip archive into the files an upload takes. An archive whose files all sit in one folder\n * keeps that folder; otherwise they go under a folder named after the archive.\n */\nexport const extractZipFile: ZipExtractor = async (zip, maxFileSize) => {\n  const { unzip } = await import('unzipit')\n  const { entries } = await unzip(await zip.arrayBuffer())\n  const names = Object.keys(entries).filter((name) => !entries[name].isDirectory)\n  const roots = new Set(names.map((name) => name.split('/')[0]))\n  const hasSingleRoot = roots.size === 1 && names.every((name) => name.includes('/'))\n  const base = zip.name.replace(/\\.zip$/i, '')\n\n  const extractedFiles: File[] = []\n  const skippedLargeFiles: string[] = []\n  for (const name of names) {\n    const entry = entries[name]\n    if (!SUPPORTED_EXTENSIONS.has(extensionOf(name))) continue\n    const fileName = name.split('/').pop() ?? name\n    if (entry.size > maxFileSize) {\n      skippedLargeFiles.push(fileName)\n      continue\n    }\n    const file = new File([await entry.arrayBuffer()], fileName, {\n      type: mimeFromName(fileName) ?? 'application/octet-stream',\n      lastModified: entry.lastModDate?.getTime() ?? Date.now(),\n    })\n    extractedFiles.push(withRelativePath(file, hasSingleRoot ? name : `${base}/${name}`))\n  }\n  return { extractedFiles, skippedLargeFiles }\n}\n\n/**\n * The chosen files an upload takes (zip archives opened into theirs), sorted by path, and those it\n * refuses with why.\n */\nexport async function prepareUploadFiles(\n  chosen: ArrayLike<File>,\n  options: { maxFileSize?: number; extractZip?: ZipExtractor } = {}\n): Promise<{ accepted: File[]; refused: RefusedUploadFile[] }> {\n  const maxFileSize = options.maxFileSize ?? UPLOAD_MAX_FILE_SIZE\n  const extractZip = options.extractZip ?? extractZipFile\n  const accepted: File[] = []\n  const refused: RefusedUploadFile[] = []\n  const zips: File[] = []\n\n  for (const file of Array.from(chosen)) {\n    if (isZipFile(file)) {\n      // An archive has no size limit: its files are checked one by one.\n      zips.push(file)\n      continue\n    }\n    const extension = extensionOf(file.name)\n    if (file.size === 0) refused.push({ name: file.name, reason: 'empty' })\n    else if (file.size > maxFileSize) refused.push({ name: file.name, reason: 'too_large' })\n    else if (!extension) refused.push({ name: file.name, reason: 'no_extension' })\n    else if (!SUPPORTED_TYPES.has(file.type) && !SUPPORTED_EXTENSIONS.has(extension))\n      refused.push({ name: file.name, reason: 'unsupported' })\n    else accepted.push(file)\n  }\n\n  for (const zip of zips) {\n    try {\n      const { extractedFiles, skippedLargeFiles } = await extractZip(zip, maxFileSize)\n      for (const name of skippedLargeFiles)\n        refused.push({ name: `${name} (from ${zip.name})`, reason: 'too_large' })\n      if (extractedFiles.length === 0 && skippedLargeFiles.length === 0)\n        refused.push({ name: zip.name, reason: 'empty_zip' })\n      accepted.push(...extractedFiles)\n    } catch {\n      refused.push({ name: zip.name, reason: 'zip_error' })\n    }\n  }\n\n  // Sorted by path, for a predictable (e-discovery) order.\n  accepted.sort((a, b) =>\n    (a.webkitRelativePath || a.name)\n      .toLowerCase()\n      .localeCompare((b.webkitRelativePath || b.name).toLowerCase())\n  )\n  return { accepted, refused }\n}\n\nfunction readDirectory(directory: FileSystemDirectoryEntry, path: string, into: File[]) {\n  return new Promise<void>((resolve) => {\n    const reader = directory.createReader()\n    const readBatch = () =>\n      reader.readEntries(async (entries) => {\n        if (entries.length === 0) return resolve()\n        await Promise.all(\n          entries.map((entry) =>\n            entry.isFile\n              ? new Promise<void>((done) =>\n                  (entry as FileSystemFileEntry).file(\n                    (file) => {\n                      into.push(withRelativePath(file, `${path}/${file.name}`))\n                      done()\n                    },\n                    () => done()\n                  )\n                )\n              : entry.isDirectory\n                ? readDirectory(entry as FileSystemDirectoryEntry, `${path}/${entry.name}`, into)\n                : Promise.resolve()\n          )\n        )\n        // A directory reader hands entries over in batches: read until it returns none.\n        readBatch()\n      })\n    readBatch()\n  })\n}\n\n/** The files of a drop: dropped folders are read whole, each file keeping its path. */\nexport async function filesFromDrop(transfer: DataTransfer): Promise<File[]> {\n  const items = Array.from(transfer.items ?? [])\n  if (items.length === 0) return Array.from(transfer.files ?? [])\n  const files: File[] = []\n  const folders: Promise<void>[] = []\n  for (const item of items) {\n    if (item.kind !== 'file') continue\n    const entry = item.webkitGetAsEntry?.()\n    if (entry?.isDirectory) {\n      folders.push(readDirectory(entry as FileSystemDirectoryEntry, entry.name, files))\n    } else {\n      const file = item.getAsFile()\n      if (file) files.push(file)\n    }\n  }\n  await Promise.all(folders)\n  return files\n}\n\n/**\n * The folder a file goes to: `base` (where the upload was started), then the folders the file sat\n * in below what was dropped or picked. Null at the workspace root.\n */\nexport function uploadFolderOf(file: File, base?: string | null): string | null {\n  const relative = file.webkitRelativePath\n  const slash = relative ? relative.lastIndexOf('/') : -1\n  const own = slash > 0 ? relative.slice(0, slash) : ''\n  return sanitizeFolderPath([base, own].filter(Boolean).join('/')) || null\n}\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/documents/useAudioRecorder.js

@@ -0,0 +1,315 @@
+import { useCallback, useEffect, useRef, useState } from "react";
+import { classifyMediaError } from "./media-error.js";
+import {
+  createChunkedRecorder,
+  pickRecorderMimeType
+} from "./chunked-recorder.js";
+import {
+  DEFAULT_SEGMENTER_CONFIG,
+  flushSegmenter,
+  INITIAL_SEGMENTER_STATE,
+  levelFromRms,
+  stepSegmenter
+} from "./audio-segmenter.js";
+const LEVEL_UPDATE_INTERVAL_MS = 50;
+function pickSegmentMimeType() {
+  if (MediaRecorder.isTypeSupported("audio/webm;codecs=opus")) return "audio/webm;codecs=opus";
+  return MediaRecorder.isTypeSupported("audio/webm") ? "audio/webm" : "audio/mp4";
+}
+function useAudioRecorder(options = {}) {
+  const optionsRef = useRef(options);
+  optionsRef.current = options;
+  const [state, setState] = useState("idle");
+  const [level, setLevel] = useState(0);
+  const [elapsedMs, setElapsedMs] = useState(0);
+  const [blob, setBlob] = useState(null);
+  const [mimeType, setMimeType] = useState(null);
+  const [error, setError] = useState(null);
+  const mediaRecorderRef = useRef(null);
+  const chunksRef = useRef([]);
+  const streamRef = useRef(null);
+  const ownsStreamRef = useRef(false);
+  const stateRef = useRef("idle");
+  stateRef.current = state;
+  const segmentStartRef = useRef(0);
+  const accumulatedMsRef = useRef(0);
+  const audioContextRef = useRef(null);
+  const analyserRef = useRef(null);
+  const levelRafRef = useRef(null);
+  const levelIntervalRef = useRef(null);
+  const segmentingRef = useRef(false);
+  const segmenterStateRef = useRef(INITIAL_SEGMENTER_STATE);
+  const openSegmentRef = useRef(null);
+  const segmentMimeTypeRef = useRef(null);
+  const chunkedRef = useRef(null);
+  const segmenterConfig = useCallback(
+    () => ({ ...DEFAULT_SEGMENTER_CONFIG, ...optionsRef.current.segmenter }),
+    []
+  );
+  const beginSegment = useCallback(() => {
+    const stream = streamRef.current;
+    const mt = segmentMimeTypeRef.current;
+    if (!stream || !mt) return;
+    const recorder = new MediaRecorder(stream, { mimeType: mt });
+    const chunks = [];
+    recorder.ondataavailable = (e) => {
+      if (e.data.size > 0) chunks.push(e.data);
+    };
+    recorder.start();
+    openSegmentRef.current = { recorder, chunks, startedAt: Date.now() };
+  }, []);
+  const endSegment = useCallback((keep, voiceMs) => {
+    const open = openSegmentRef.current;
+    openSegmentRef.current = null;
+    if (!open) return;
+    const { recorder, chunks, startedAt } = open;
+    const durationMs = Date.now() - startedAt;
+    recorder.onstop = () => {
+      const onSegment = optionsRef.current.onSegment;
+      if (!keep || !chunks.length || !onSegment) return;
+      const type = recorder.mimeType || segmentMimeTypeRef.current || "audio/webm";
+      onSegment({
+        blob: new Blob(chunks, { type }),
+        mimeType: type,
+        startedAt,
+        durationMs,
+        voiceMs
+      });
+    };
+    if (recorder.state !== "inactive") recorder.stop();
+  }, []);
+  const applySegmenterEvents = useCallback(
+    (events) => {
+      for (const event of events) {
+        if (event.type === "start") beginSegment();
+        else endSegment(event.keep, event.voiceMs);
+      }
+    },
+    [beginSegment, endSegment]
+  );
+  const flushOpenSegment = useCallback(() => {
+    if (!segmentingRef.current) return;
+    const flushed = flushSegmenter(segmenterStateRef.current, performance.now(), segmenterConfig());
+    segmenterStateRef.current = flushed.state;
+    applySegmenterEvents(flushed.events);
+    endSegment(false, 0);
+  }, [segmenterConfig, applySegmenterEvents, endSegment]);
+  const stopMeter = useCallback(() => {
+    if (levelRafRef.current !== null) cancelAnimationFrame(levelRafRef.current);
+    levelRafRef.current = null;
+    if (levelIntervalRef.current !== null) clearInterval(levelIntervalRef.current);
+    levelIntervalRef.current = null;
+    analyserRef.current = null;
+    void audioContextRef.current?.close().catch(() => {
+    });
+    audioContextRef.current = null;
+  }, []);
+  const startMeter = useCallback(
+    (stream) => {
+      const audioContext = new AudioContext();
+      const source = audioContext.createMediaStreamSource(stream);
+      const analyser = audioContext.createAnalyser();
+      analyser.fftSize = 256;
+      source.connect(analyser);
+      audioContextRef.current = audioContext;
+      analyserRef.current = analyser;
+      const data = new Uint8Array(analyser.frequencyBinCount);
+      const segmenting = segmentingRef.current;
+      let lastUpdate = 0;
+      const tick = (t) => {
+        const active = analyserRef.current;
+        if (!active) return;
+        if (t - lastUpdate >= LEVEL_UPDATE_INTERVAL_MS) {
+          lastUpdate = t;
+          active.getByteTimeDomainData(data);
+          let sumSquares = 0;
+          for (let i = 0; i < data.length; i++) {
+            const centered = (data[i] - 128) / 128;
+            sumSquares += centered * centered;
+          }
+          const rms = Math.sqrt(sumSquares / data.length);
+          const nextLevel = levelFromRms(rms);
+          setLevel(nextLevel);
+          setElapsedMs(accumulatedMsRef.current + (t - segmentStartRef.current));
+          if (segmenting) {
+            const step = stepSegmenter(segmenterStateRef.current, nextLevel, t, segmenterConfig());
+            segmenterStateRef.current = step.state;
+            applySegmenterEvents(step.events);
+          }
+        }
+        if (!segmenting) levelRafRef.current = requestAnimationFrame(tick);
+      };
+      if (segmenting) {
+        levelIntervalRef.current = setInterval(
+          () => tick(performance.now()),
+          LEVEL_UPDATE_INTERVAL_MS
+        );
+      } else {
+        levelRafRef.current = requestAnimationFrame(tick);
+      }
+    },
+    [segmenterConfig, applySegmenterEvents]
+  );
+  const stopTracks = useCallback(() => {
+    if (ownsStreamRef.current) streamRef.current?.getTracks().forEach((t) => t.stop());
+    streamRef.current = null;
+    ownsStreamRef.current = false;
+  }, []);
+  useEffect(
+    () => () => {
+      void chunkedRef.current?.stop();
+      chunkedRef.current = null;
+      flushOpenSegment();
+      endSegment(false, 0);
+      segmentingRef.current = false;
+      segmenterStateRef.current = INITIAL_SEGMENTER_STATE;
+      stopTracks();
+      stopMeter();
+    },
+    [flushOpenSegment, endSegment, stopTracks, stopMeter]
+  );
+  useEffect(() => {
+    const onPageHide = () => flushOpenSegment();
+    window.addEventListener("pagehide", onPageHide);
+    return () => window.removeEventListener("pagehide", onPageHide);
+  }, [flushOpenSegment]);
+  const start = useCallback(async () => {
+    if (stateRef.current === "recording" || stateRef.current === "paused") return;
+    setError(null);
+    try {
+      const { track, onSegment } = optionsRef.current;
+      const stream = track ? new MediaStream([track]) : await navigator.mediaDevices.getUserMedia({ audio: true });
+      streamRef.current = stream;
+      ownsStreamRef.current = !track;
+      const { chunkMs } = optionsRef.current;
+      if (onSegment && chunkMs) {
+        const mt2 = optionsRef.current.mimeType ?? pickRecorderMimeType("audio");
+        const chunked = createChunkedRecorder({
+          stream,
+          mimeType: mt2,
+          chunkMs,
+          audioBitsPerSecond: optionsRef.current.audioBitsPerSecond,
+          onChunk: (chunk) => optionsRef.current.onSegment?.({
+            blob: chunk.blob,
+            mimeType: chunk.mimeType,
+            startedAt: chunk.startedAt,
+            durationMs: chunk.durationMs,
+            voiceMs: chunk.durationMs,
+            index: chunk.index
+          }),
+          onError: (err) => setError(classifyMediaError(err, "microphone"))
+        });
+        chunkedRef.current = chunked;
+        segmentingRef.current = false;
+        setMimeType(mt2);
+        setBlob(null);
+        accumulatedMsRef.current = 0;
+        segmentStartRef.current = performance.now();
+        chunked.start();
+        stateRef.current = "recording";
+        setState("recording");
+        return;
+      }
+      if (onSegment) {
+        const mt2 = pickSegmentMimeType();
+        segmentMimeTypeRef.current = mt2;
+        segmentingRef.current = true;
+        segmenterStateRef.current = INITIAL_SEGMENTER_STATE;
+        setMimeType(mt2);
+        setBlob(null);
+        accumulatedMsRef.current = 0;
+        segmentStartRef.current = performance.now();
+        stateRef.current = "recording";
+        setState("recording");
+        startMeter(stream);
+        return;
+      }
+      segmentingRef.current = false;
+      const mt = MediaRecorder.isTypeSupported("audio/webm") ? "audio/webm" : "audio/mp4";
+      const recorder = new MediaRecorder(stream, { mimeType: mt });
+      chunksRef.current = [];
+      recorder.ondataavailable = (e) => {
+        if (e.data.size > 0) chunksRef.current.push(e.data);
+      };
+      mediaRecorderRef.current = recorder;
+      setMimeType(mt);
+      setBlob(null);
+      accumulatedMsRef.current = 0;
+      segmentStartRef.current = performance.now();
+      recorder.start();
+      setState("recording");
+      startMeter(stream);
+    } catch (err) {
+      segmentingRef.current = false;
+      stopTracks();
+      setError(classifyMediaError(err, "microphone"));
+    }
+  }, [startMeter, stopTracks]);
+  const pause = useCallback(() => {
+    if (segmentingRef.current || chunkedRef.current) return;
+    const recorder = mediaRecorderRef.current;
+    if (!recorder || recorder.state !== "recording") return;
+    recorder.pause();
+    accumulatedMsRef.current += performance.now() - segmentStartRef.current;
+    stopMeter();
+    setLevel(0);
+    setState("paused");
+  }, [stopMeter]);
+  const resume = useCallback(() => {
+    if (segmentingRef.current || chunkedRef.current) return;
+    const recorder = mediaRecorderRef.current;
+    if (!recorder || recorder.state !== "paused") return;
+    recorder.resume();
+    segmentStartRef.current = performance.now();
+    setState("recording");
+    if (streamRef.current) startMeter(streamRef.current);
+  }, [startMeter]);
+  const stop = useCallback(() => {
+    const chunked = chunkedRef.current;
+    if (chunked) {
+      chunkedRef.current = null;
+      void chunked.stop();
+      setElapsedMs(accumulatedMsRef.current + (performance.now() - segmentStartRef.current));
+      stopTracks();
+      stateRef.current = "stopped";
+      setState("stopped");
+      return;
+    }
+    if (segmentingRef.current) {
+      flushOpenSegment();
+      segmentingRef.current = false;
+      stopMeter();
+      stopTracks();
+      setLevel(0);
+      stateRef.current = "stopped";
+      setState("stopped");
+      return;
+    }
+    const recorder = mediaRecorderRef.current;
+    if (!recorder || recorder.state === "inactive") return;
+    const finalElapsed = recorder.state === "paused" ? accumulatedMsRef.current : accumulatedMsRef.current + (performance.now() - segmentStartRef.current);
+    stopMeter();
+    recorder.onstop = () => {
+      stopTracks();
+      const finalBlob = chunksRef.current.length ? new Blob(chunksRef.current, { type: recorder.mimeType }) : null;
+      setBlob(finalBlob);
+      setElapsedMs(finalElapsed);
+      setLevel(0);
+      setState("stopped");
+    };
+    recorder.stop();
+  }, [stopMeter, stopTracks, flushOpenSegment]);
+  const reset = useCallback(() => {
+    setState("idle");
+    setBlob(null);
+    setElapsedMs(0);
+    setLevel(0);
+    setMimeType(null);
+    setError(null);
+  }, []);
+  return { state, level, elapsedMs, blob, mimeType, error, start, pause, resume, stop, reset };
+}
+export {
+  useAudioRecorder
+};
+//# sourceMappingURL=useAudioRecorder.js.map