@bendyline/docblocks-react 2.6.2 → 2.7.1

package/dist/chunk-RP3DVNTI.js

@@ -0,0 +1,62 @@
+// src/Export/video-export-doc.ts
+import { parseMarkdown } from "@bendyline/squisq/markdown";
+var DATA_PREVIEW_ROWS = 50;
+var TRANSFORM_KEY = "squisq-transform";
+var LEGACY_TRANSFORM_KEY = "transform-style";
+function persistedTransformStyle(frontmatter, knownIds) {
+  if (!frontmatter) return null;
+  const value = Object.prototype.hasOwnProperty.call(frontmatter, TRANSFORM_KEY) ? frontmatter[TRANSFORM_KEY] : frontmatter[LEGACY_TRANSFORM_KEY];
+  if (typeof value !== "string") return null;
+  const normalized = value.trim().toLowerCase().replace(/\s+/g, "-");
+  const id = normalized === "datadriven" ? "data-driven" : normalized;
+  return knownIds.has(id) ? id : null;
+}
+async function withDataPreviews(doc, container, resolveDataReferences) {
+  try {
+    const { defaultDataReaders } = await import("@bendyline/squisq-formats/data");
+    const resolved = await resolveDataReferences(doc, container, {
+      readers: defaultDataReaders(),
+      maxPreviewRows: DATA_PREVIEW_ROWS
+    });
+    return resolved.doc;
+  } catch {
+    return doc;
+  }
+}
+async function buildVideoExportDoc(markdownSource, options = {}) {
+  const [
+    {
+      buildPreviewDoc,
+      documentTitleFromFileName,
+      markdownToDoc,
+      resolveAudioMapping,
+      resolveDataReferences
+    },
+    { applyTransform, getTransformStyleSummaries }
+  ] = await Promise.all([import("@bendyline/squisq/doc"), import("@bendyline/squisq/transform")]);
+  let doc = markdownToDoc(parseMarkdown(markdownSource));
+  const container = options.workspaceContainer;
+  if (container) {
+    doc = await resolveAudioMapping(doc, container).catch(() => doc);
+    doc = await withDataPreviews(doc, container, resolveDataReferences);
+  }
+  const knownIds = new Set(getTransformStyleSummaries().map((summary) => summary.id));
+  const transformStyle = persistedTransformStyle(doc.frontmatter, knownIds);
+  const contentDoc = transformStyle ? applyTransform(doc, transformStyle).doc : doc;
+  const narrationOwnsTimeline = (contentDoc.documentMedia ?? []).some(
+    (clip) => clip.anchor === "document"
+  );
+  const projected = buildPreviewDoc(contentDoc, {
+    documentTitle: documentTitleFromFileName(options.fileName ?? void 0),
+    interleaveImages: !narrationOwnsTimeline
+  });
+  const invalidPresentation = projected.diagnostics?.find(
+    (diagnostic) => diagnostic.code === "presentation-invalid"
+  );
+  if (invalidPresentation) throw new Error(invalidPresentation.message);
+  return { ...projected, audio: contentDoc.audio };
+}
+
+export {
+  buildVideoExportDoc
+};

package/dist/chunk-SPUPWCSI.js

@@ -0,0 +1,111 @@
+// src/Export/shared-document.ts
+import {
+  SHARED_DOCUMENT_LIMITS,
+  createSharedDocumentUrl
+} from "@bendyline/docblocks/share";
+var PUBLIC_DOCBLOCKS_SHARE_URL = "https://docblocks.com/";
+function resolveSharedDocumentBaseUrl(currentUrl) {
+  try {
+    const current = new URL(currentUrl);
+    if (current.protocol === "http:" || current.protocol === "https:") {
+      current.hash = "";
+      current.searchParams.delete("action");
+      return current.toString();
+    }
+  } catch {
+  }
+  return PUBLIC_DOCBLOCKS_SHARE_URL;
+}
+function sharedDocumentFilename(selectedFile) {
+  const basename = selectedFile?.replace(/\\/gu, "/").split("/").pop() ?? "shared.md";
+  const stem = basename.replace(/\.md$/iu, "").replace(/[^A-Za-z0-9._-]+/gu, "-");
+  const bounded = stem.replace(/^-+|-+$/gu, "").slice(0, 80) || "shared";
+  return `${bounded}.md`;
+}
+async function omitSharedImages(markdown) {
+  const { parseMarkdown, rewriteMarkdownReferences, splitFrontmatterBlock, walkMarkdownTree } = await import("@bendyline/squisq/markdown");
+  const { frontmatter, body } = splitFrontmatterBlock(markdown);
+  const imageReferences = /* @__PURE__ */ new Set();
+  const linkReferences = /* @__PURE__ */ new Set();
+  walkMarkdownTree(parseMarkdown(body, { frontmatter: false }), (node) => {
+    if (node.type === "imageReference") imageReferences.add(node.identifier);
+    if (node.type === "linkReference") linkReferences.add(node.identifier);
+  });
+  let sharedBody = rewriteMarkdownReferences(body, { images: "omit" });
+  let sharedDocument = parseMarkdown(sharedBody, { frontmatter: false });
+  let descriptionContainsImage = false;
+  walkMarkdownTree(sharedDocument, (node) => {
+    if (node.type === "image" || node.type === "imageReference") descriptionContainsImage = true;
+    if (node.type === "imageReference") imageReferences.add(node.identifier);
+    if (node.type === "linkReference") linkReferences.add(node.identifier);
+  });
+  if (descriptionContainsImage) {
+    sharedBody = rewriteMarkdownReferences(sharedBody, { images: "omit" });
+    sharedDocument = parseMarkdown(sharedBody, { frontmatter: false });
+    walkMarkdownTree(sharedDocument, (node) => {
+      if (node.type === "image" || node.type === "imageReference") {
+        throw new Error(
+          "An image description contains image markup that cannot be shared as text."
+        );
+      }
+    });
+  }
+  if (imageReferences.size > 0) {
+    const removals = [];
+    walkMarkdownTree(sharedDocument, (node) => {
+      if (node.type !== "definition" || !imageReferences.has(node.identifier) || linkReferences.has(node.identifier)) {
+        return;
+      }
+      const start = node.position?.start.offset;
+      const end = node.position?.end.offset;
+      if (start === void 0 || end === void 0) {
+        throw new Error("Cannot locate an image reference in the shared document.");
+      }
+      removals.push({ start, end });
+    });
+    for (const { start, end } of removals.sort((a, b) => b.start - a.start)) {
+      sharedBody = sharedBody.slice(0, start) + sharedBody.slice(end);
+    }
+  }
+  return (frontmatter ?? "") + sharedBody;
+}
+async function createSharedDocumentArchive(markdown, selectedFile) {
+  const sharedMarkdown = await omitSharedImages(markdown);
+  const encoded = new TextEncoder().encode(sharedMarkdown);
+  if (encoded.byteLength > SHARED_DOCUMENT_LIMITS.markdownBytes) {
+    throw new Error(
+      `This document is too large for a shared URL (maximum ${SHARED_DOCUMENT_LIMITS.markdownBytes.toLocaleString()} UTF-8 bytes).`
+    );
+  }
+  const [{ MemoryContentContainer }, { containerToZip }] = await Promise.all([
+    import("@bendyline/squisq/storage"),
+    import("@bendyline/squisq-formats/container")
+  ]);
+  const container = new MemoryContentContainer();
+  await container.writeFile(sharedDocumentFilename(selectedFile), encoded, "text/markdown");
+  const blob = await containerToZip(container, { compression: "DEFLATE", compressionLevel: 9 });
+  return new Uint8Array(await blob.arrayBuffer());
+}
+function buildSharedDocumentUrl(baseUrl, archive, mode) {
+  return createSharedDocumentUrl(resolveSharedDocumentBaseUrl(baseUrl), archive, mode);
+}
+function buildSharedDocumentQrUrl(archive, mode) {
+  const url = createSharedDocumentUrl(PUBLIC_DOCBLOCKS_SHARE_URL, archive, mode);
+  if (url.length > SHARED_DOCUMENT_LIMITS.qrUrlCharacters) {
+    throw new Error(
+      "This document is too large for a reliable QR code (maximum " + SHARED_DOCUMENT_LIMITS.qrUrlCharacters.toLocaleString() + " URL characters). Copy the share link instead."
+    );
+  }
+  return url;
+}
+function sharedDocumentQrFilename(selectedFile) {
+  return sharedDocumentFilename(selectedFile).replace(/\.md$/iu, "-qr.png");
+}
+
+export {
+  sharedDocumentFilename,
+  createSharedDocumentArchive,
+  buildSharedDocumentUrl,
+  buildSharedDocumentQrUrl,
+  sharedDocumentQrFilename
+};

package/dist/chunk-TBLZBNQF.js

@@ -0,0 +1,25 @@
+// src/components/HighlightedText.tsx
+import { Fragment } from "react";
+import { Fragment as Fragment2, jsx } from "react/jsx-runtime";
+function HighlightedText({ text, ranges }) {
+  const parts = [];
+  let cursor = 0;
+  for (const [rawStart, rawEnd] of ranges) {
+    const start = Math.max(cursor, Math.min(rawStart, text.length));
+    const end = Math.min(rawEnd, text.length);
+    if (end <= start) continue;
+    if (start > cursor)
+      parts.push(/* @__PURE__ */ jsx(Fragment, { children: text.slice(cursor, start) }, `t${cursor}`));
+    parts.push(
+      /* @__PURE__ */ jsx("mark", { className: "db-search-match", children: text.slice(start, end) }, `m${start}`)
+    );
+    cursor = end;
+  }
+  if (cursor < text.length)
+    parts.push(/* @__PURE__ */ jsx(Fragment, { children: text.slice(cursor) }, `t${cursor}`));
+  return /* @__PURE__ */ jsx(Fragment2, { children: parts });
+}
+
+export {
+  HighlightedText
+};

package/dist/{chunk-M5Y5WO7Z.js → chunk-UG4G7PJ4.js}

@@ -1,6 +1,6 @@
 import {
   FORMAT_EXTENSIONS
-} from "./chunk-EBWYGTN7.js";
+} from "./chunk-X437UAF7.js";
 
 // src/Export/export-filename.ts
 function buildExportFilename(selectedFile, options) {

package/dist/chunk-UONFWKJ7.js

@@ -0,0 +1,22 @@
+// src/Export/host-error.ts
+function hostErrorDetail(caught) {
+  return caught instanceof Error ? caught.message.replace(/^Error invoking remote method '[^']+': Error:\s*/, "").trim() : "";
+}
+
+// src/Export/image-save.ts
+function createImageSaveOutput(adapter) {
+  return async (blob, filename) => {
+    try {
+      const target = await adapter.pickTarget(filename, null);
+      if (!target) return false;
+      return await adapter.saveBlob(blob, filename, target) !== null;
+    } catch (caught) {
+      throw new Error(hostErrorDetail(caught) || `Couldn't save "${filename}".`);
+    }
+  };
+}
+
+export {
+  hostErrorDetail,
+  createImageSaveOutput
+};

package/dist/chunk-VO2JYYQZ.js

@@ -0,0 +1,40 @@
+// src/Speech/useSpeechStatus.ts
+import { useEffect, useState } from "react";
+function useSpeechStatus(speech) {
+  const [status, setStatus] = useState(null);
+  useEffect(() => {
+    let live = true;
+    const unsubscribe = speech.onStatus((next) => {
+      if (live) setStatus(next);
+    });
+    void speech.status().then(
+      (initial) => {
+        if (live) setStatus((current) => current ?? initial);
+      },
+      () => {
+        if (live)
+          setStatus(
+            (current) => current ?? {
+              stt: {
+                state: "unavailable",
+                reason: "Speech status is unavailable. Try opening Settings."
+              },
+              tts: {
+                state: "unavailable",
+                reason: "Speech status is unavailable. Try opening Settings."
+              }
+            }
+          );
+      }
+    );
+    return () => {
+      live = false;
+      unsubscribe();
+    };
+  }, [speech]);
+  return status;
+}
+
+export {
+  useSpeechStatus
+};