@docen/docx 0.3.1 → 0.3.2

package/dist/converters/docx.d.mts

@@ -1,2 +1,200 @@
-import { a as generateDOCX, c as parseDOCX, i as compileDocument, l as resolveDocument, n as DocxGenerateOptions, o as generateDOCXStream, r as DocxManager, s as generateDOCXSync, t as DocumentOptions } from "../docx-C5wyjI-0.mjs";
+import { a as JSONContent } from "../core-C9VunJ8o.mjs";
+import { PrepareStep } from "./prepare.mjs";
+import { DocumentOptions, OutputByType, OutputType, PackerOptions, parseDocument } from "@office-open/docx";
+
+//#region src/converters/docx.d.ts
+/**
+ * Manages DOCX serialization (Tiptap JSON ↔ DocumentOptions).
+ *
+ * Each extension provides renderDocx/parseDocx for its own attrs mapping.
+ * DocxManager handles tree walking, child assembly, and dispatching.
+ */
+declare class DocxManager {
+  private numberingConfigs;
+  private orderedInstanceCounter;
+  private resolveStyles;
+  compile(json: JSONContent): DocumentOptions;
+  /** Assemble a SectionOptions from compiled children + optional layout/headers/footers. */
+  private buildSection;
+  /**
+   * Compile resolved header/footer slots (JSONContent[] per slot) back into
+   * SectionChild[] per slot. Returns undefined when no slot has content.
+   */
+  private compileHeaderFooter;
+  /**
+   * Resolve a section's header/footer group (SectionChild[] per slot) into
+   * Tiptap JSON slots. Returns null when no slot has content.
+   */
+  private resolveHeaderFooter;
+  resolve(docOpts: DocumentOptions): JSONContent;
+  private compileSectionChild;
+  private compileParagraphNode;
+  private compileHeadingNode;
+  /** Simple text optimization: merge plain runs into text field */
+  private simplifyParagraph;
+  private compileTableNode;
+  /** Count grid columns from the first table row (summing colspan). */
+  private getTableColumnCount;
+  /**
+   * Compute tblGrid column widths (twips) from first-row cell colwidth attrs.
+   * Returns columnWidths array and the appropriate tableWidth.
+   */
+  private computeColumnWidths;
+  private compileTableCellNode;
+  private compileListFromNode;
+  /**
+   * Register (or reuse) an abstractNum for an ordered list's `start`, and
+   * return a fresh instance so this list counts independently of other lists
+   * that share the same definition.
+   */
+  private registerOrderedNumbering;
+  /**
+   * Prepend an inline checkbox SDT to a task paragraph. The SDT is tagged
+   * "docen-task" so resolve can tell task items apart from ordinary paragraphs
+   * that happen to contain an SDT.
+   */
+  private injectTaskCheckbox;
+  /**
+   * details → block-level group-SDT. The summary paragraph is tagged with a
+   * fixed style so resolve can split it back out; content blocks flatten in
+   * after it. (No native collapse in DOCX — structure round-trips, the view
+   * stays expanded.)
+   */
+  private compileDetailsNode;
+  private compileInlineContent;
+  private compileTextNode;
+  /** Emit a single run for `text` with all inline marks applied. */
+  private compileTextRun;
+  private resolveSectionChild;
+  /** Wrap an opaque SectionChild in a passthrough atom (attrs.data = JSON). */
+  private resolvePassthrough;
+  /**
+   * Resolve a details group-SDT: the summary-style paragraph becomes
+   * detailsSummary, the remaining blocks fold into detailsContent.
+   */
+  private resolveDetailsSdt;
+  private resolveParagraph;
+  /** Look up a paragraph style's NAME from its styleId, via the styles table
+   *  carried on the current resolve(). Returns undefined outside resolve. */
+  private styleNameOf;
+  /** reference → level-0 format/start, for classifying numbering paragraphs. */
+  private buildNumberingLookup;
+  /**
+   * Walk section children, grouping consecutive list paragraphs into nested
+   * Tiptap lists. Non-list children resolve individually. DOCX flattens lists
+   * to a paragraph sequence (depth carried by `level`); this rebuilds the tree.
+   */
+  private resolveSectionChildren;
+  /** Classify a paragraph as a list item, or null if it isn't one. */
+  private detectList;
+  /**
+   * Rebuild nested Tiptap lists from a flat run of list paragraphs. Stack-based:
+   * each frame is an active list at a given depth; the `key` (level:type:
+   * reference) decides whether a paragraph continues the top list, starts a
+   * nested list, or splits off a new sibling list.
+   */
+  private buildListTree;
+  /** Classify a paragraph as a blockquote member by its signature. */
+  private detectBlockquote;
+  /**
+   * Rebuild a blockquote node from a run of signature-carrying paragraphs,
+   * stripping the indent/border signature so child paragraphs render clean.
+   */
+  private buildBlockquote;
+  /**
+   * Resolve a list-item paragraph to a Tiptap paragraph/heading node, stripping
+   * the list marker (bullet/numbering) and the leading task checkbox — those
+   * are expressed at the list/item level, not inside the paragraph.
+   */
+  private resolveListItemParagraph;
+  /** Return a copy of `para` with its leading docen-task checkbox SDT removed. */
+  private stripTaskCheckbox;
+  private resolveCodeBlock;
+  private resolveTable;
+  /**
+   * Resolve a paragraph's inline content. @office-open collapses a plain-text
+   * paragraph (a single run with no properties) to a bare string or a `{ text }`
+   * object with no `children` — recover that text here so it round-trips back to
+   * a text node instead of being dropped.
+   */
+  private resolveInlineContent;
+  private resolveParagraphChildren;
+  private resolveParagraphChild;
+  /** Resolve an inline SDT (mention carrier; other inline SDTs unsupported). */
+  private resolveInlineSdt;
+  private resolveRun;
+  private resolveMarks;
+  private resolveImage;
+  private resolveHyperlink;
+}
+/**
+ * Parse a DOCX file into Tiptap JSON (runtime model).
+ *
+ * Combines @office-open/docx's `parseDocument` (DOCX binary → DocumentOptions)
+ * with `DocxManager.resolve` (DocumentOptions → Tiptap JSON).
+ */
+declare function parseDOCX(data: Parameters<typeof parseDocument>[0]): JSONContent;
+/**
+ * Options for {@link generateDOCX} / {@link generateDOCXStream}.
+ */
+interface DocxGenerateOptions<T extends OutputType = "nodebuffer"> {
+  /**
+   * Pre-compilation steps run on the JSON in place (default: `prepareImages()`).
+   * - `true` / `undefined`: default image pre-fetch (http(s) → embedded data URL)
+   * - `false`: skip preparation
+   * - `PrepareStep[]`: custom steps
+   *
+   * Required for http image URLs — image `renderDocx` drops images without
+   * embedded data (see extensions/image.ts). Mutates the JSON, like `prepareDocument`.
+   */
+  prepare?: boolean | PrepareStep[];
+  /** Packer options; `type` controls the output format (default `"nodebuffer"` → Buffer). */
+  packer?: PackerOptions<T>;
+  /**
+   * Document-level options injected into the compiled `DocumentOptions` — core
+   * properties (`title`/`creator`/`description`/…), `styles`/`externalStyles`,
+   * `background`, `features`, `fonts`, etc. Excludes `sections` (always compiled
+   * from the JSON) and `numbering` (collected from ordered-list nodes).
+   *
+   * `styles`/`externalStyles` here take precedence over any `styles` carried on
+   * `json.attrs.styles` (e.g. from a prior `parseDOCX`); the two are mutually
+   * exclusive, so specifying `externalStyles` drops the compiled `styles`.
+   */
+  document?: Omit<Partial<DocumentOptions>, "sections" | "numbering">;
+}
+/**
+ * Generate a DOCX file from Tiptap JSON (runtime model), asynchronously.
+ *
+ * Pipeline: `prepareDocument` (default: fetch http images, in place) →
+ * `DocxManager.compile` → @office-open/docx's `generateDocument`. `packer.type`
+ * controls the output format (default: `"nodebuffer"` → Buffer). Non-blocking
+ * (fflate Web Workers). With the default `prepare`, the input `json` is mutated
+ * in place (http image URLs become embedded data URLs).
+ */
+declare function generateDOCX<T extends OutputType = "nodebuffer">(json: JSONContent, options?: DocxGenerateOptions<T>): Promise<OutputByType[T]>;
+/**
+ * Generate a DOCX file synchronously — fastest throughput, blocks the event loop.
+ *
+ * Pipeline: `DocxManager.compile` → `generateDocumentSync`. Does **not** run
+ * `prepareDocument` (it is async); call `await prepareDocument(json)` first
+ * when http images need embedding. `options.document` is still applied.
+ */
+declare function generateDOCXSync<T extends OutputType = "nodebuffer">(json: JSONContent, options?: DocxGenerateOptions<T>): OutputByType[T];
+/**
+ * Generate a DOCX file as a `ReadableStream<Uint8Array>` — for large documents
+ * or streaming HTTP responses.
+ *
+ * Pipeline: `prepareDocument` (default: fetch http images, in place) →
+ * `DocxManager.compile` → `generateDocumentStream`. Async due to preparation.
+ */
+declare function generateDOCXStream(json: JSONContent, options?: DocxGenerateOptions): Promise<ReadableStream<Uint8Array>>;
+/**
+ * Convert DocumentOptions (persistence model) to Tiptap JSON (runtime model).
+ */
+declare function resolveDocument(docOpts: DocumentOptions): JSONContent;
+/**
+ * Convert Tiptap JSON (runtime model) to DocumentOptions (persistence model).
+ */
+declare function compileDocument(json: JSONContent): DocumentOptions;
+//#endregion
 export { type DocumentOptions, DocxGenerateOptions, DocxManager, compileDocument, generateDOCX, generateDOCXStream, generateDOCXSync, parseDOCX, resolveDocument };