@bendyline/docblocks-react 1.1.2 → 2.1.0

package/src/Export/export-options.ts

@@ -1,99 +0,0 @@
-/**
- * Export option types and localStorage persistence for quick-export.
- */
-
-export type ExportFormat = 'docx' | 'pdf' | 'pptx' | 'md' | 'html';
-
-/** Visual style for HTML export. */
-export type HtmlStyle =
-  /** Render via SquisqPlayer (themed, embeds player bundle). */
-  | 'rendered'
-  /** Plain semantic HTML — small, no JS, no playback. */
-  | 'plain';
-
-/** Packaging for HTML export. */
-export type HtmlBundle =
-  /** Single self-contained .html file (images base64-embedded). */
-  | 'single'
-  /** ZIP containing index.html + asset files. */
-  | 'zip';
-
-export interface ExportOptions {
-  format: ExportFormat;
-  themeId: string;
-  /** Transform style for PPTX — controls how content is segmented and styled. */
-  transformStyle: string;
-  /** Only applies to PDF */
-  pageSize: 'letter' | 'a4';
-  /** HTML rendering style. Only applies to format=html. */
-  htmlStyle: HtmlStyle;
-  /** HTML bundle layout. Only applies to format=html. */
-  htmlBundle: HtmlBundle;
-  /**
-   * Recursive HTML bundle: walk relative `.md` links from the entry
-   * document, render every reachable sibling/child page, and rewrite
-   * cross-doc links from `.md` → `.html`. The output is a ZIP
-   * regardless of `htmlBundle` because multi-doc output needs a
-   * directory tree. Supported for both plain (`markdownDocsToPlainHtmlBundle`)
-   * and rendered (`markdownDocsToHtmlBundle`) HTML styles. Only
-   * meaningful when `format === 'html'`.
-   */
-  includeLinkedDocs: boolean;
-  /**
-   * Rename the entry page from `<basename>.html` to `index.html` so the
-   * export drops straight into a static-site host that expects an
-   * `index.html` landing page. For recursive bundles, cross-doc links
-   * targeting the entry also rewrite to `index.html` so siblings don't
-   * 404. For a single-doc HTML download, this just renames the file.
-   * Only meaningful when `format === 'html'`.
-   */
-  entryAsIndex: boolean;
-}
-
-export const FORMAT_LABELS: Record<ExportFormat, string> = {
-  docx: 'Word Document (.docx)',
-  pdf: 'PDF (.pdf)',
-  pptx: 'PowerPoint (.pptx)',
-  md: 'Markdown (.md)',
-  html: 'HTML (.html)',
-};
-
-export const FORMAT_EXTENSIONS: Record<ExportFormat, string> = {
-  docx: '.docx',
-  pdf: '.pdf',
-  pptx: '.pptx',
-  md: '.md',
-  html: '.html',
-};
-
-const STORAGE_KEY = 'docblocks-export-options';
-
-export const DEFAULT_OPTIONS: ExportOptions = {
-  format: 'pdf',
-  themeId: 'standard',
-  transformStyle: 'documentary',
-  pageSize: 'letter',
-  htmlStyle: 'plain',
-  htmlBundle: 'single',
-  includeLinkedDocs: false,
-  entryAsIndex: false,
-};
-
-export function loadLastExportOptions(): ExportOptions | null {
-  try {
-    const raw = localStorage.getItem(STORAGE_KEY);
-    if (!raw) return null;
-    const parsed = JSON.parse(raw) as Partial<ExportOptions>;
-    return { ...DEFAULT_OPTIONS, ...parsed };
-  } catch {
-    return null;
-  }
-}
-
-export function saveExportOptions(options: ExportOptions): void {
-  try {
-    localStorage.setItem(STORAGE_KEY, JSON.stringify(options));
-  } catch {
-    // Ignore storage errors
-  }
-}

package/src/Export/index.ts

@@ -1,5 +0,0 @@
-export { ExportToolbarControls } from './ExportToolbarControls.js';
-export type { ExportToolbarControlsProps } from './ExportToolbarControls.js';
-export { ExportDialog } from './ExportDialog.js';
-export type { ExportDialogProps } from './ExportDialog.js';
-export type { ExportFormat, ExportOptions } from './export-options.js';

package/src/Export/run-export.ts

@@ -1,349 +0,0 @@
-/**
- * Execute an export using @bendyline/squisq-formats.
- */
-
-import type {
-  MarkdownDocument,
-  MarkdownBlockNode,
-  MarkdownInlineNode,
-} from '@bendyline/squisq/markdown';
-import { parseMarkdown } from '@bendyline/squisq/markdown';
-import type { Doc } from '@bendyline/squisq/schemas';
-import type { ContentContainer } from '@bendyline/squisq/storage';
-import type { ExportOptions, ExportFormat } from './export-options.js';
-import { FORMAT_EXTENSIONS } from './export-options.js';
-
-const MIME_TYPES: Record<ExportFormat, string> = {
-  docx: 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
-  pdf: 'application/pdf',
-  pptx: 'application/vnd.openxmlformats-officedocument.presentationml.presentation',
-  md: 'text/markdown',
-  html: 'text/html',
-};
-
-/** Trigger a browser download for a Blob. */
-function downloadBlob(blob: Blob, filename: string): void {
-  const url = URL.createObjectURL(blob);
-  const a = document.createElement('a');
-  a.href = url;
-  a.download = filename;
-  a.click();
-  URL.revokeObjectURL(url);
-}
-
-/** Derive a filename from the selected file path and export format. */
-function buildFilename(selectedFile: string | null, format: ExportFormat): string {
-  const base = selectedFile ? selectedFile.replace(/^\//, '').replace(/\.[^.]+$/, '') : 'document';
-  return base + FORMAT_EXTENSIONS[format];
-}
-
-/** Run the export and trigger a download. */
-export async function runExport(
-  markdown: string,
-  selectedFile: string | null,
-  options: ExportOptions,
-  mediaContainer?: ContentContainer | null,
-): Promise<void> {
-  const filename = buildFilename(selectedFile, options.format);
-  const themeId = options.themeId !== 'standard' ? options.themeId : undefined;
-
-  if (options.format === 'md') {
-    downloadBlob(new Blob([markdown], { type: MIME_TYPES.md }), filename);
-    return;
-  }
-
-  if (options.format === 'html') {
-    await runHtmlExport(markdown, filename, options, mediaContainer, selectedFile);
-    return;
-  }
-
-  const doc = parseMarkdown(markdown);
-
-  if (options.format === 'docx') {
-    const { markdownDocToDocx } = await import('@bendyline/squisq-formats/docx');
-    const images = mediaContainer ? await resolveImages(doc, mediaContainer) : undefined;
-    const buf = await markdownDocToDocx(doc, { themeId, images });
-    downloadBlob(new Blob([buf], { type: MIME_TYPES.docx }), filename);
-    return;
-  }
-
-  if (options.format === 'pdf') {
-    const { markdownDocToPdf } = await import('@bendyline/squisq-formats/pdf');
-    const buf = await markdownDocToPdf(doc, {
-      themeId,
-      pageSize: options.pageSize,
-    });
-    downloadBlob(new Blob([buf], { type: MIME_TYPES.pdf }), filename);
-    return;
-  }
-
-  if (options.format === 'pptx') {
-    const [{ markdownToDoc }, { applyTransform }, { docToPptx }] = await Promise.all([
-      import('@bendyline/squisq/doc'),
-      import('@bendyline/squisq/transform'),
-      import('@bendyline/squisq-formats/pptx'),
-    ]);
-    // Use the full transform pipeline: markdown -> Doc -> transform -> PPTX
-    const baseDoc = markdownToDoc(doc);
-    const transformed = applyTransform(baseDoc, options.transformStyle);
-    const enrichedDoc = transformed.doc;
-    if (themeId) {
-      enrichedDoc.themeId = themeId;
-    }
-    const buf = await docToPptx(enrichedDoc, { themeId });
-    downloadBlob(new Blob([buf], { type: MIME_TYPES.pptx }), filename);
-    return;
-  }
-}
-
-/** Run the HTML export branch — handles all four htmlStyle × htmlBundle combinations. */
-async function runHtmlExport(
-  markdown: string,
-  htmlFilename: string,
-  options: ExportOptions,
-  mediaContainer?: ContentContainer | null,
-  selectedFile?: string | null,
-): Promise<void> {
-  const baseName = htmlFilename.replace(/\.html$/, '');
-  const zipName = `${baseName}.zip`;
-  // When `entryAsIndex` is on, a single-doc HTML download lands on
-  // disk as `index.html` so it drops straight into a static host. The
-  // recursive ZIP path doesn't care — squisq's bundle helpers handle
-  // the inside-zip rename and the cross-doc link rewrite themselves.
-  const singleHtmlFilename = options.entryAsIndex ? 'index.html' : htmlFilename;
-  const themeId = options.themeId !== 'standard' ? options.themeId : undefined;
-
-  // Recursive HTML bundle: when the user opted in, ask squisq to walk
-  // this doc's relative .md links and emit a ZIP with every reachable
-  // page rendered + cross-doc hrefs rewritten. Two pipelines:
-  //   • Plain  → `markdownDocsToPlainHtmlBundle` (semantic HTML)
-  //   • Rendered → `markdownDocsToHtmlBundle` (SquisqPlayer-rendered,
-  //                shared `squisq-player.js`, Doc-tree link rewrites)
-  // Both consume the workspace container to resolve sibling files —
-  // `mediaContainer` is already scoped to the selected file's parent
-  // dir, which is exactly the bundle's scope root. Falls back to the
-  // single-doc path if either prerequisite is missing rather than
-  // silently skipping the recursion.
-  if (options.includeLinkedDocs && mediaContainer && selectedFile) {
-    const entryPath = basenameForBundle(selectedFile);
-    if (options.htmlStyle === 'rendered') {
-      const [{ markdownDocsToHtmlBundle }, { PLAYER_BUNDLE }] = await Promise.all([
-        import('@bendyline/squisq-formats/html'),
-        import('@bendyline/squisq-react/standalone-source'),
-      ]);
-      const blob = await markdownDocsToHtmlBundle({
-        entryPath,
-        readDocument: (path) => readDocumentFromContainer(mediaContainer, path),
-        readBinary: (path) => mediaContainer.readFile(path),
-        playerScript: PLAYER_BUNDLE,
-        title: baseName,
-        themeId,
-        mode: 'static',
-        entryAsIndex: options.entryAsIndex,
-      });
-      downloadBlob(blob, zipName);
-      return;
-    }
-    const { markdownDocsToPlainHtmlBundle } = await import('@bendyline/squisq-formats/html');
-    const blob = await markdownDocsToPlainHtmlBundle({
-      entryPath,
-      readDocument: (path) => readDocumentFromContainer(mediaContainer, path),
-      readBinary: (path) => mediaContainer.readFile(path),
-      title: baseName,
-      themeId,
-      entryAsIndex: options.entryAsIndex,
-    });
-    downloadBlob(blob, zipName);
-    return;
-  }
-
-  if (options.htmlStyle === 'rendered') {
-    const [{ markdownToDoc }, { docToHtml, docToHtmlZip, collectImagePaths }, { PLAYER_BUNDLE }] =
-      await Promise.all([
-        import('@bendyline/squisq/doc'),
-        import('@bendyline/squisq-formats/html'),
-        import('@bendyline/squisq-react/standalone-source'),
-      ]);
-    const mdDoc = parseMarkdown(markdown);
-    const baseDoc = markdownToDoc(mdDoc);
-    if (themeId) baseDoc.themeId = themeId;
-
-    const images = mediaContainer
-      ? await resolveDocImages(baseDoc, mediaContainer, collectImagePaths)
-      : undefined;
-
-    if (options.htmlBundle === 'zip') {
-      const blob = await docToHtmlZip(baseDoc, {
-        playerScript: PLAYER_BUNDLE,
-        images,
-        mode: 'static',
-        title: baseName,
-      });
-      downloadBlob(blob, zipName);
-      return;
-    }
-
-    const html = docToHtml(baseDoc, {
-      playerScript: PLAYER_BUNDLE,
-      images,
-      mode: 'static',
-      title: baseName,
-    });
-    downloadBlob(new Blob([html], { type: MIME_TYPES.html }), singleHtmlFilename);
-    return;
-  }
-
-  // Plain semantic HTML
-  const mdDoc = parseMarkdown(markdown);
-  const referencedImages = collectMarkdownImageUrls(mdDoc);
-  const localImages = referencedImages.filter((u) => !isExternalUrl(u));
-
-  if (options.htmlBundle === 'zip' && mediaContainer && localImages.length > 0) {
-    const [{ markdownDocToPlainHtml }, { MemoryContentContainer }, { containerToZip }] =
-      await Promise.all([
-        import('@bendyline/squisq-formats/html'),
-        import('@bendyline/squisq/storage'),
-        import('@bendyline/squisq-formats/container'),
-      ]);
-    // Mirror the markdown's relative paths inside the zip so <img src="..."> still resolves.
-    const html = markdownDocToPlainHtml(mdDoc, { title: baseName, themeId });
-    const container = new MemoryContentContainer();
-    await container.writeFile('index.html', new TextEncoder().encode(html));
-    for (const url of localImages) {
-      const data = await mediaContainer.readFile(url);
-      if (!data) continue;
-      const cleanPath = url.replace(/^\/+/, '');
-      await container.writeFile(cleanPath, new Uint8Array(data));
-    }
-    const blob = await containerToZip(container);
-    downloadBlob(blob, zipName);
-    return;
-  }
-
-  const { markdownDocToPlainHtml } = await import('@bendyline/squisq-formats/html');
-  // Single-file plain HTML — embed local images as base64 data URIs.
-  const inlineMap = new Map<string, string>();
-  if (mediaContainer) {
-    for (const url of localImages) {
-      const data = await mediaContainer.readFile(url);
-      if (!data) continue;
-      inlineMap.set(url, arrayBufferToDataUrl(data, url));
-    }
-  }
-  const html = markdownDocToPlainHtml(mdDoc, {
-    title: baseName,
-    images: inlineMap.size > 0 ? inlineMap : undefined,
-    themeId,
-  });
-  downloadBlob(new Blob([html], { type: MIME_TYPES.html }), singleHtmlFilename);
-}
-
-const IMAGE_MIME: Record<string, string> = {
-  png: 'image/png',
-  jpg: 'image/jpeg',
-  jpeg: 'image/jpeg',
-  gif: 'image/gif',
-  webp: 'image/webp',
-  bmp: 'image/bmp',
-  svg: 'image/svg+xml',
-};
-
-function isExternalUrl(url: string): boolean {
-  return (
-    url.startsWith('http://') ||
-    url.startsWith('https://') ||
-    url.startsWith('data:') ||
-    url.startsWith('blob:')
-  );
-}
-
-function arrayBufferToDataUrl(data: ArrayBuffer, url: string): string {
-  const ext = url.slice(url.lastIndexOf('.') + 1).toLowerCase();
-  const mime = IMAGE_MIME[ext] ?? 'application/octet-stream';
-  // btoa requires a binary string; chunk to avoid call-stack issues on large files.
-  const bytes = new Uint8Array(data);
-  let binary = '';
-  const CHUNK = 0x8000;
-  for (let i = 0; i < bytes.length; i += CHUNK) {
-    binary += String.fromCharCode(...bytes.subarray(i, i + CHUNK));
-  }
-  return `data:${mime};base64,${btoa(binary)}`;
-}
-
-/** Walk the markdown AST and collect all image URLs. */
-function collectMarkdownImageUrls(doc: MarkdownDocument): string[] {
-  const urls: string[] = [];
-  function walkBlocks(nodes: MarkdownBlockNode[]): void {
-    for (const node of nodes) {
-      if ('children' in node && Array.isArray(node.children)) {
-        for (const child of node.children as (MarkdownBlockNode | MarkdownInlineNode)[]) {
-          if (child.type === 'image') {
-            urls.push((child as { url: string }).url);
-          } else if ('children' in child && Array.isArray(child.children)) {
-            walkBlocks(child.children as MarkdownBlockNode[]);
-          }
-        }
-      }
-    }
-  }
-  walkBlocks(doc.children);
-  return Array.from(new Set(urls));
-}
-
-/** Resolve image URLs (markdown → docx) to binary data from a ContentContainer. */
-async function resolveImages(
-  doc: MarkdownDocument,
-  container: ContentContainer,
-): Promise<Map<string, { data: ArrayBuffer | Uint8Array; contentType: string }>> {
-  const urls = collectMarkdownImageUrls(doc);
-  const map = new Map<string, { data: ArrayBuffer | Uint8Array; contentType: string }>();
-
-  for (const url of urls) {
-    if (map.has(url)) continue;
-    if (isExternalUrl(url)) continue;
-    const data = await container.readFile(url);
-    if (!data) continue;
-    const ext = url.slice(url.lastIndexOf('.') + 1).toLowerCase();
-    const contentType = IMAGE_MIME[ext] || 'image/png';
-    map.set(url, { data, contentType });
-  }
-
-  return map;
-}
-
-/** Container-relative path for the bundle's entry document. `mediaContainer`
- *  is already scoped to the selected file's parent directory, so the bundle
- *  needs the basename ("docs/home.md" → "home.md"). */
-function basenameForBundle(selectedFile: string): string {
-  const clean = selectedFile.replace(/^\/+/, '');
-  const idx = clean.lastIndexOf('/');
-  return idx === -1 ? clean : clean.slice(idx + 1);
-}
-
-/** Read a UTF-8 text document from a ContentContainer. Returns null when
- *  the file is missing — preserves the bundle's "abort with error" contract
- *  for unreachable .md links. */
-async function readDocumentFromContainer(
-  container: ContentContainer,
-  path: string,
-): Promise<string | null> {
-  const data = await container.readFile(path);
-  if (!data) return null;
-  return new TextDecoder('utf-8').decode(data);
-}
-
-/** Resolve image paths referenced by a squisq Doc to ArrayBuffers for HTML export. */
-async function resolveDocImages(
-  doc: Doc,
-  container: ContentContainer,
-  collectImagePaths: (doc: Doc) => Iterable<string>,
-): Promise<Map<string, ArrayBuffer>> {
-  const paths = collectImagePaths(doc);
-  const map = new Map<string, ArrayBuffer>();
-  for (const path of paths) {
-    const data = await container.readFile(path);
-    if (!data) continue;
-    map.set(path, data);
-  }
-  return map;
-}

package/src/Export/transform-summaries.ts

@@ -1,14 +0,0 @@
-export interface ExportSummaryOption {
-  id: string;
-  name: string;
-  description?: string;
-}
-
-let transformStyleSummariesPromise: Promise<ExportSummaryOption[]> | null = null;
-
-export function loadTransformStyleSummaries(): Promise<ExportSummaryOption[]> {
-  transformStyleSummariesPromise ??= import('@bendyline/squisq/transform').then(
-    ({ getTransformStyleSummaries }) => getTransformStyleSummaries(),
-  );
-  return transformStyleSummariesPromise;
-}