@bendyline/squisq-formats 2.0.1 → 2.2.0

package/src/shared/fidelity.ts

@@ -1,130 +0,0 @@
-/**
- * Shared Markdown fidelity reporting for exporters that intentionally support
- * only a subset of the core Markdown AST. Keeping the capability profiles in
- * one exhaustive table prevents each exporter from silently drifting as the
- * core AST grows.
- */
-
-import type {
-  MarkdownBlockNode,
-  MarkdownDocument,
-  MarkdownInlineNode,
-} from '@bendyline/squisq/markdown';
-
-type ContentNodeType = MarkdownBlockNode['type'] | MarkdownInlineNode['type'];
-export type MarkdownExportProfile = 'docx' | 'pdf' | 'pptx' | 'epub';
-
-/**
- * Exhaustive by construction: adding a Markdown node type in core makes this
- * package fail typechecking until its export fidelity is considered here.
- */
-const CONTENT_NODE_TYPES: Record<ContentNodeType, true> = {
-  heading: true,
-  paragraph: true,
-  blockquote: true,
-  list: true,
-  code: true,
-  thematicBreak: true,
-  table: true,
-  htmlBlock: true,
-  math: true,
-  definition: true,
-  footnoteDefinition: true,
-  containerDirective: true,
-  leafDirective: true,
-  definitionList: true,
-  text: true,
-  emphasis: true,
-  strong: true,
-  delete: true,
-  inlineCode: true,
-  link: true,
-  image: true,
-  break: true,
-  htmlInline: true,
-  inlineMath: true,
-  footnoteReference: true,
-  linkReference: true,
-  imageReference: true,
-  textDirective: true,
-  mention: true,
-  inlineIcon: true,
-};
-
-const COMMON_SUPPORTED: readonly ContentNodeType[] = [
-  'heading',
-  'paragraph',
-  'blockquote',
-  'list',
-  'code',
-  'thematicBreak',
-  'table',
-  'htmlBlock',
-  'math',
-  'text',
-  'emphasis',
-  'strong',
-  'delete',
-  'inlineCode',
-  'link',
-  'image',
-  'break',
-  'htmlInline',
-  'inlineMath',
-];
-
-const PROFILE_SUPPORT: Record<MarkdownExportProfile, ReadonlySet<ContentNodeType>> = {
-  docx: new Set([...COMMON_SUPPORTED, 'footnoteDefinition', 'footnoteReference']),
-  pdf: new Set([...COMMON_SUPPORTED, 'footnoteDefinition', 'footnoteReference']),
-  pptx: new Set(COMMON_SUPPORTED),
-  epub: new Set(COMMON_SUPPORTED),
-};
-
-const PROFILE_LABELS: Record<MarkdownExportProfile, string> = {
-  docx: 'DOCX',
-  pdf: 'PDF',
-  pptx: 'PPTX',
-  epub: 'EPUB',
-};
-
-interface AstLikeNode {
-  type?: string;
-  children?: unknown;
-}
-
-/** Return a user-facing warning when an exporter will omit Markdown nodes. */
-export function markdownFidelityWarnings(
-  document: MarkdownDocument,
-  profile: MarkdownExportProfile,
-): string[] {
-  const supported = PROFILE_SUPPORT[profile];
-  const omitted = new Map<ContentNodeType, number>();
-
-  const visit = (candidate: unknown): void => {
-    if (!candidate || typeof candidate !== 'object') return;
-    const node = candidate as AstLikeNode;
-    const type = node.type as ContentNodeType | undefined;
-
-    if (type && Object.prototype.hasOwnProperty.call(CONTENT_NODE_TYPES, type)) {
-      if (!supported.has(type)) {
-        // The exporter drops this whole subtree, so report the highest-fidelity
-        // boundary once instead of inflating the count with its descendants.
-        omitted.set(type, (omitted.get(type) ?? 0) + 1);
-        return;
-      }
-    }
-
-    if (Array.isArray(node.children)) {
-      for (const child of node.children) visit(child);
-    }
-  };
-
-  for (const child of document.children) visit(child);
-  if (omitted.size === 0) return [];
-
-  const total = [...omitted.values()].reduce((sum, count) => sum + count, 0);
-  const details = [...omitted].map(([type, count]) => `${type} (${count})`).join(', ');
-  return [
-    `${PROFILE_LABELS[profile]} export omitted ${total} unsupported Markdown node(s): ${details}.`,
-  ];
-}

package/src/shared/images.ts

@@ -1,44 +0,0 @@
-/**
- * Shared extension → MIME-type mapping for embedded media.
- *
- * Previously triplicated with subtle drift: the docx and pptx importers each
- * carried a byte-identical dotted-key map (png/jpg/.../emf/wmf), while the html
- * exporter's `inferMimeType` used no-dot keys and a different key set (added
- * audio/video/ico/avif, omitted tiff/emf/wmf). This module is the single union
- * of all of them, so a newly-supported type only has to be added once.
- */
-
-/** Union of every extension→MIME entry the format modules need. */
-const EXT_TO_MIME: Record<string, string> = {
-  // Raster / vector images
-  png: 'image/png',
-  jpg: 'image/jpeg',
-  jpeg: 'image/jpeg',
-  gif: 'image/gif',
-  webp: 'image/webp',
-  bmp: 'image/bmp',
-  svg: 'image/svg+xml',
-  tiff: 'image/tiff',
-  tif: 'image/tiff',
-  ico: 'image/x-icon',
-  avif: 'image/avif',
-  // Office vector formats (docx/pptx embedded metafiles)
-  emf: 'image/emf',
-  wmf: 'image/wmf',
-  // Audio / video (html export inlines these as data URIs)
-  mp3: 'audio/mpeg',
-  wav: 'audio/wav',
-  ogg: 'audio/ogg',
-  mp4: 'video/mp4',
-  webm: 'video/webm',
-};
-
-/**
- * Map a file extension to its MIME type. Tolerates a leading dot and any
- * casing (`.PNG`, `png`, `.png` all resolve). Returns
- * `application/octet-stream` for unknown extensions.
- */
-export function extToMime(ext: string): string {
-  const key = ext.replace(/^\./, '').toLowerCase();
-  return EXT_TO_MIME[key] ?? 'application/octet-stream';
-}

package/src/shared/inlineRuns.ts

@@ -1,99 +0,0 @@
-/**
- * Shared inline walker for the "run-based" exporters.
- *
- * DOCX (`<w:r>`) and PPTX (`<a:r>`) both render inline markdown by threading an
- * active character-format object DOWN through nested nodes (strong → bold,
- * emphasis → italic, …) and emitting flat styled runs at the leaves — as
- * opposed to the HTML exporters, which WRAP children in tags, or the PDF
- * exporter, which accumulates positioned spans. That control flow is identical
- * between DOCX and PPTX; only the leaf serialization differs.
- *
- * This module owns the traversal once. Each exporter supplies the handful of
- * leaf handlers (`run`, `link`, `image`, `lineBreak`, optional `footnoteRef`)
- * via {@link InlineRunHandlers}. Because the handler interface is typed, adding
- * a new inline node type here forces both exporters to be considered — there's
- * no longer a per-exporter `default:` that can silently drift.
- */
-
-import type {
-  MarkdownInlineNode,
-  MarkdownLink,
-  MarkdownImage,
-  MarkdownFootnoteReference,
-} from '@bendyline/squisq/markdown';
-import { stripHtmlTags } from './text.js';
-
-/** Active character formatting threaded down through nested inline nodes. */
-export interface InlineRunFormat {
-  bold?: boolean;
-  italic?: boolean;
-  strike?: boolean;
-  code?: boolean;
-  /** Explicit run color (hex without `#`); only some exporters use this. */
-  color?: string;
-}
-
-/**
- * Per-format leaf handlers. The walker handles the shared format-threading
- * control flow; these turn the leaves into the target dialect's markup.
- */
-export interface InlineRunHandlers {
-  /** Emit a styled text run for `text`, given the active format. */
-  run(text: string, format: InlineRunFormat): string;
-  /** Emit a hyperlink (the handler manages its own child rendering). */
-  link(node: MarkdownLink, format: InlineRunFormat): string;
-  /** Emit an inline image. */
-  image(node: MarkdownImage, format: InlineRunFormat): string;
-  /** Emit a hard line break. */
-  lineBreak(): string;
-  /** Emit a footnote reference. Omit to drop footnote refs (PPTX). */
-  footnoteRef?(node: MarkdownFootnoteReference): string;
-}
-
-/** Walk a list of inline nodes, concatenating each rendered run. */
-export function inlineNodesToRuns(
-  nodes: MarkdownInlineNode[],
-  handlers: InlineRunHandlers,
-  format: InlineRunFormat = {},
-): string {
-  let out = '';
-  for (const node of nodes) {
-    out += inlineNodeToRuns(node, handlers, format);
-  }
-  return out;
-}
-
-/** Render a single inline node under the active format. */
-export function inlineNodeToRuns(
-  node: MarkdownInlineNode,
-  handlers: InlineRunHandlers,
-  format: InlineRunFormat,
-): string {
-  switch (node.type) {
-    case 'text':
-      return handlers.run(node.value, format);
-    case 'strong':
-      return inlineNodesToRuns(node.children, handlers, { ...format, bold: true });
-    case 'emphasis':
-      return inlineNodesToRuns(node.children, handlers, { ...format, italic: true });
-    case 'delete':
-      return inlineNodesToRuns(node.children, handlers, { ...format, strike: true });
-    case 'inlineCode':
-      return handlers.run(node.value, { ...format, code: true });
-    case 'inlineMath':
-      return handlers.run(node.value, { ...format, code: true });
-    case 'htmlInline':
-      return handlers.run(stripHtmlTags(node.rawHtml), format);
-    case 'link':
-      return handlers.link(node, format);
-    case 'image':
-      return handlers.image(node, format);
-    case 'break':
-      return handlers.lineBreak();
-    case 'footnoteReference':
-      return handlers.footnoteRef ? handlers.footnoteRef(node) : '';
-    default:
-      // linkReference, imageReference, textDirective, inlineIcon, … — skip.
-      return '';
-  }
-}

package/src/shared/text.ts

@@ -1,41 +0,0 @@
-/**
- * Shared plain-text helpers used by every format exporter.
- *
- * These were previously copy-pasted into the docx / pptx / epub exporters with
- * subtle drift (e.g. some handled `inlineMath`, some handled `break`). Keeping a
- * single implementation here means a fix or a newly-supported inline node type
- * only has to be added in one place.
- */
-
-import type { MarkdownInlineNode } from '@bendyline/squisq/markdown';
-
-/** Strip HTML tags from a string, keeping only the text content. */
-export function stripHtmlTags(html: string): string {
-  return html.replace(/<[^>]*>/g, '');
-}
-
-/** Flatten a single inline node to its plain-text content. */
-export function inlineToPlainText(node: MarkdownInlineNode): string {
-  switch (node.type) {
-    case 'text':
-    case 'inlineCode':
-    case 'inlineMath':
-      return node.value;
-    case 'emphasis':
-    case 'strong':
-    case 'delete':
-    case 'link':
-      return extractPlainText(node.children);
-    case 'image':
-      return node.alt ?? '';
-    case 'break':
-      return ' ';
-    default:
-      return '';
-  }
-}
-
-/** Flatten an array of inline nodes to their concatenated plain-text content. */
-export function extractPlainText(nodes: MarkdownInlineNode[]): string {
-  return nodes.map(inlineToPlainText).join('');
-}

package/src/shared/zipEntryCount.ts

@@ -1,151 +0,0 @@
-/** Narrow EOCD preflight for rejecting record-count bombs before JSZip allocation. */
-
-import { throwIfZipAborted } from './zipLimits.js';
-
-const END_OF_CENTRAL_DIRECTORY = 0x06054b50;
-const ZIP64_END_OF_CENTRAL_DIRECTORY = 0x06064b50;
-const ZIP64_END_LOCATOR = 0x07064b50;
-const UINT16_MAX = 0xffff;
-const MIN_EOCD_BYTES = 22;
-const MAX_ZIP_COMMENT_BYTES = 0xffff;
-
-export type ZipInput = ArrayBuffer | Uint8Array | Blob;
-
-/** Materialize Blob input once when possible so preflight bytes feed JSZip too. */
-export async function prepareZipInput(
-  data: ZipInput,
-  signal?: AbortSignal,
-): Promise<{ input: ZipInput; bytes?: Uint8Array }> {
-  throwIfZipAborted(signal);
-  if (ArrayBuffer.isView(data)) {
-    const bytes = new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
-    return { input: bytes, bytes };
-  }
-  if (!isBlobLike(data)) {
-    const bytes = new Uint8Array(data);
-    return { input: bytes, bytes };
-  }
-
-  const bytes = await readBlobBytes(data, signal);
-  throwIfZipAborted(signal);
-  return bytes ? { input: bytes, bytes } : { input: data };
-}
-
-/**
- * Read the declared total central-directory record count when unambiguous.
- * Returns undefined for absent, trailing, malformed, or unsupported metadata;
- * JSZip remains authoritative in those cases.
- */
-export function declaredZipEntryCount(bytes: Uint8Array): number | undefined {
-  const eocdOffset = findEocd(bytes);
-  if (eocdOffset === undefined) return undefined;
-  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
-  const count = view.getUint16(eocdOffset + 10, true);
-  if (count !== UINT16_MAX) return count;
-  return readZip64EntryCount(view, eocdOffset);
-}
-
-function findEocd(bytes: Uint8Array): number | undefined {
-  if (bytes.byteLength < MIN_EOCD_BYTES) return undefined;
-  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
-  const earliest = Math.max(0, bytes.byteLength - MIN_EOCD_BYTES - MAX_ZIP_COMMENT_BYTES);
-  for (let offset = bytes.byteLength - MIN_EOCD_BYTES; offset >= earliest; offset--) {
-    if (view.getUint32(offset, true) !== END_OF_CENTRAL_DIRECTORY) continue;
-    const commentLength = view.getUint16(offset + 20, true);
-    if (offset + MIN_EOCD_BYTES + commentLength === bytes.byteLength) return offset;
-  }
-  return undefined;
-}
-
-function readZip64EntryCount(view: DataView, eocdOffset: number): number | undefined {
-  const locatorOffset = eocdOffset - 20;
-  if (locatorOffset < 0 || view.getUint32(locatorOffset, true) !== ZIP64_END_LOCATOR) {
-    return undefined;
-  }
-  const recordOffset = readSafeUint64(view, locatorOffset + 8);
-  if (
-    recordOffset === undefined ||
-    recordOffset < 0 ||
-    recordOffset + 40 > view.byteLength ||
-    view.getUint32(recordOffset, true) !== ZIP64_END_OF_CENTRAL_DIRECTORY
-  ) {
-    return undefined;
-  }
-  return readSafeUint64(view, recordOffset + 32);
-}
-
-function readSafeUint64(view: DataView, offset: number): number | undefined {
-  if (offset < 0 || offset + 8 > view.byteLength) return undefined;
-  const low = view.getUint32(offset, true);
-  const high = view.getUint32(offset + 4, true);
-  const value = high * 0x1_0000_0000 + low;
-  return Number.isSafeInteger(value) ? value : undefined;
-}
-
-function isBlobLike(data: ZipInput): data is Blob {
-  const candidate = data as Blob;
-  return typeof candidate.size === 'number' && typeof candidate.slice === 'function';
-}
-
-async function readBlobBytes(blob: Blob, signal?: AbortSignal): Promise<Uint8Array | undefined> {
-  const arrayBuffer = (blob as Blob & { arrayBuffer?: () => Promise<ArrayBuffer> }).arrayBuffer;
-  if (typeof arrayBuffer === 'function') {
-    return new Uint8Array(await raceWithAbort(arrayBuffer.call(blob), signal));
-  }
-  if (typeof FileReader === 'undefined') return undefined;
-  return new Promise((resolve, reject) => {
-    const reader = new FileReader();
-    let settled = false;
-    const cleanup = (): void => signal?.removeEventListener('abort', handleAbort);
-    const finish = (work: () => void): void => {
-      if (settled) return;
-      settled = true;
-      cleanup();
-      work();
-    };
-    const handleAbort = (): void => {
-      if (settled) return;
-      const reason = signal?.reason ?? new Error('ZIP operation was cancelled');
-      // Mark the promise settled before FileReader.abort(): browsers are
-      // allowed to dispatch `abort` synchronously and re-enter this handler.
-      finish(() => reject(reason));
-      try {
-        reader.abort();
-      } catch {
-        // Preserve the caller's reason if a platform reader is already done.
-      }
-    };
-    reader.onload = () => finish(() => resolve(new Uint8Array(reader.result as ArrayBuffer)));
-    reader.onerror = () =>
-      finish(() => reject(reader.error ?? new Error('Could not read ZIP blob.')));
-    reader.onabort = handleAbort;
-    signal?.addEventListener('abort', handleAbort, { once: true });
-    if (signal?.aborted) {
-      handleAbort();
-      return;
-    }
-    reader.readAsArrayBuffer(blob);
-  });
-}
-
-function raceWithAbort<T>(work: Promise<T>, signal?: AbortSignal): Promise<T> {
-  throwIfZipAborted(signal);
-  if (!signal) return work;
-  return new Promise<T>((resolve, reject) => {
-    let settled = false;
-    const finish = (complete: () => void): void => {
-      if (settled) return;
-      settled = true;
-      signal.removeEventListener('abort', handleAbort);
-      complete();
-    };
-    const handleAbort = (): void =>
-      finish(() => reject(signal.reason ?? new Error('ZIP operation was cancelled')));
-    signal.addEventListener('abort', handleAbort, { once: true });
-    if (signal.aborted) handleAbort();
-    work.then(
-      (value) => finish(() => resolve(value)),
-      (error: unknown) => finish(() => reject(error)),
-    );
-  });
-}