oasis-editor 0.0.100 → 0.0.101

package/dist/core/editorState.d.ts

@@ -1,6 +1,6 @@
 import { EditorAsset, EditorBlockNode, EditorDocument, EditorFootnote, EditorPageSettings, EditorParagraphNode, EditorSection, EditorState, EditorTableCellNode, EditorTableNode, EditorTableRowNode, EditorTextRun, EditorTextStyle, EditorTextBoxData, EditorImageRunData, EditorNamedStyle } from './model.js';
 
-export type EditorNodeKind = "document" | "paragraph" | "run" | "table" | "table-row" | "table-cell" | "footnote" | "bookmark" | "comment";
+export type EditorNodeKind = "document" | "paragraph" | "run" | "table" | "table-row" | "table-cell" | "footnote" | "bookmark" | "comment" | "sdt";
 /**
  * Single authority for editor node IDs. Stateless and globally unique, so two
  * editors mounted on the same page never share a sequence. The `kind` prefix is

package/dist/core/model/index.d.ts

@@ -8,7 +8,7 @@
  */
 export type { EditorUnderlineStyle, EditorLigatures, EditorNumberSpacing, EditorNumberForm, EditorTextLanguage, EditorBorderStyle, EditorEmphasisMark, EditorTabStop, EditorParagraphListStyle, EditorImageCrop, EditorImageFillMode, EditorImageFloatingPosition, EditorImageFloatingLayout, EditorImageRunData, EditorWrapPolygonPoint, EditorFieldData, EditorFieldChar, EditorFootnoteReferenceData, EditorEndnoteReferenceData, EditorRevision, EditorRevisionMetadata, EditorStructuralRevision, EditorPropertyRevision, EditorAsset, EditorFootnoteNumberFormat, EditorFootnoteRestart, EditorDocxWidthValue, EditorTableLayout, EditorTableRowHeightRule, EditorGradientStop, EditorTextFill, EditorTextOutline, EditorTextShadow, EditorGlow, EditorReflection, } from './types/primitives.js';
 export type { EditorTextStyle, EditorParagraphStyle, EditorTableStyle, EditorTableFloatingLayout, EditorTableConditionalFormat, EditorConditionalRowStyle, EditorTableConditionalType, EditorTableConditionalFlags, EditorTableCellStyle, EditorNamedStyle, } from './types/styles.js';
-export type { EditorRunBase, EditorTextRun, EditorTextBoxShape, EditorTextBoxBody, EditorTextBoxData, EditorDropCap, EditorParagraphNode, EditorTableCellNode, EditorTableRowStyle, EditorTableRowNode, EditorTableNode, EditorBlockNode, } from './types/nodes.js';
+export type { EditorRunBase, EditorTextRun, EditorTextBoxShape, EditorTextBoxBody, EditorTextBoxData, EditorDropCap, EditorSdtBlockWrapper, EditorParagraphNode, EditorTableCellNode, EditorTableRowStyle, EditorTableRowNode, EditorTableNode, EditorBlockNode, } from './types/nodes.js';
 export type { RunKind, RunOfKind, RunVisitor } from './runKind.js';
 export { getRunKind, isInlineObjectRun, visitRun, getRunImage, getRunTextBox, getRunField, getRunFieldChar, getRunFieldInstruction, getRunFootnoteReference, getRunEndnoteReference, getRunSym, } from './runKind.js';
 export type { EditorFootnote } from './types/documentFootnotes.js';

package/dist/core/model/types/nodes.d.ts

@@ -144,6 +144,21 @@ export interface EditorDropCap {
     /** Cap run style: fontSize (`w:sz`), font, color, baselineShift (`w:position`). */
     style?: EditorTextStyle;
 }
+/**
+ * A block-level structured document tag (`w:sdt`, a content control) enclosing
+ * one or more blocks, preserved for round-trip. Its content is unwrapped into the
+ * normal block flow (so it still renders and edits); this carries the wrapper's
+ * properties verbatim so export can re-wrap. `groupId` ties together the
+ * consecutive blocks that came from the same `w:sdt`; the array on a block lists
+ * its enclosing wrappers outermost-first (nested content controls).
+ */
+export interface EditorSdtBlockWrapper {
+    groupId: string;
+    /** Raw `<w:sdtPr>…</w:sdtPr>` XML, or empty when the tag had no properties. */
+    sdtPrXml: string;
+    /** Raw `<w:sdtEndPr>…</w:sdtEndPr>` XML, when present. */
+    sdtEndPrXml?: string;
+}
 export interface EditorParagraphNode {
     id: string;
     type: "paragraph";
@@ -152,6 +167,8 @@ export interface EditorParagraphNode {
     list?: EditorParagraphListStyle;
     /** Drop cap that body text in this paragraph wraps around, when present. */
     dropCap?: EditorDropCap;
+    /** Enclosing block-level `w:sdt` content controls, preserved for round-trip. */
+    sdtWrappers?: EditorSdtBlockWrapper[];
 }
 export interface EditorTableCellNode {
     id: string;
@@ -220,5 +237,7 @@ export interface EditorTableNode {
     style?: EditorTableStyle;
     /** Preservation-only `w:tblGridChange` XML. */
     gridRevision?: EditorPropertyRevision<number[]>;
+    /** Enclosing block-level `w:sdt` content controls, preserved for round-trip. */
+    sdtWrappers?: EditorSdtBlockWrapper[];
 }
 export type EditorBlockNode = EditorParagraphNode | EditorTableNode;

package/dist/export/docx/text/blocksXml.d.ts

@@ -1,6 +1,12 @@
 import { EditorBlockNode, EditorNamedStyle, EditorParagraphNode, EditorParagraphStyle } from '../../../core/model.js';
 import { DocContext } from '../docxTypes.js';
 
+/**
+ * Serialize a block run, re-wrapping any block-level `w:sdt` content controls
+ * preserved on import. Consecutive blocks sharing an outermost wrapper `groupId`
+ * are coalesced back into one `<w:sdt>` envelope; the wrapper is stripped before
+ * recursing so nested content controls re-wrap from the inside out.
+ */
 export declare function serializeBlocksXml(blocks: EditorBlockNode[], context: DocContext, styles: Record<string, EditorNamedStyle> | undefined): string;
 export declare function serializeParagraphXml(paragraph: EditorParagraphNode, context: DocContext, styles: Record<string, EditorNamedStyle> | undefined, overrides?: {
     align?: EditorParagraphStyle["align"];

package/dist/export/pdf/OasisPdfWriter.d.ts

@@ -1,4 +1,4 @@
-import { OasisPdfFontResource, OasisPdfImageOptions, OasisPdfImageResource, OasisPdfLineOptions, OasisPdfPageSize, OasisPdfPathOptions, OasisPdfRectOptions, OasisPdfTextOptions } from './writer/pdfTypes.js';
+import { OasisPdfAxialGradient, OasisPdfFontResource, OasisPdfImageOptions, OasisPdfImageResource, OasisPdfLineOptions, OasisPdfPageSize, OasisPdfPathOptions, OasisPdfRectOptions, OasisPdfTextOptions } from './writer/pdfTypes.js';
 
 export type { OasisPdfPageSize, OasisPdfPage, OasisPdfRectOptions, OasisPdfLineOptions, OasisPdfPathSegment, OasisPdfPathOptions, OasisPdfTextOptions, OasisPdfImageResource, OasisPdfImageOptions, OasisPdfFontResource, OasisPdfBase14FontResource, OasisPdfUnicodeFontResource, } from './writer/pdfTypes.js';
 export declare class OasisPdfWriter {
@@ -6,6 +6,7 @@ export declare class OasisPdfWriter {
     private readonly streams;
     private readonly fonts;
     private readonly images;
+    private readonly shadings;
     constructor(fontResources?: OasisPdfFontResource[]);
     registerFontResource(resource: OasisPdfFontResource): void;
     addPage(size: OasisPdfPageSize): number;
@@ -18,6 +19,12 @@ export declare class OasisPdfWriter {
     rotateAbout(pageIndex: number, centerX: number, centerY: number, degrees: number): void;
     clipRect(pageIndex: number, x: number, y: number, width: number, height: number): void;
     drawText(pageIndex: number, options: OasisPdfTextOptions): void;
+    /**
+     * Registers an axial (linear) gradient on a page for use as a glyph fill, and
+     * returns its shading resource name to pass as `gradientShadingName` on a
+     * subsequent `drawText`. Coordinates are in the writer's top-left point space.
+     */
+    registerAxialGradient(pageIndex: number, gradient: OasisPdfAxialGradient): string | null;
     registerImageResource(resource: Omit<OasisPdfImageResource, "resourceName"> & {
         resourceName?: string;
     }): string;

package/dist/export/pdf/writer/PdfContentStream.d.ts

@@ -1,12 +1,20 @@
-import { OasisPdfImageOptions, OasisPdfLineOptions, OasisPdfPage, OasisPdfPathOptions, OasisPdfRectOptions, OasisPdfTextOptions } from './pdfTypes.js';
+import { OasisPdfAxialGradient, OasisPdfImageOptions, OasisPdfLineOptions, OasisPdfPage, OasisPdfPathOptions, OasisPdfRectOptions, OasisPdfTextOptions } from './pdfTypes.js';
 import { PdfFontTable } from './PdfFontTable.js';
 import { PdfImageTable } from './PdfImageTable.js';
+import { PdfShadingTable } from './PdfShadingTable.js';
 
 export declare class PdfContentStream {
     readonly page: OasisPdfPage;
     private readonly fonts;
     private readonly images;
-    constructor(page: OasisPdfPage, fonts: PdfFontTable, images: PdfImageTable);
+    private readonly shadings;
+    constructor(page: OasisPdfPage, fonts: PdfFontTable, images: PdfImageTable, shadings: PdfShadingTable);
+    /**
+     * Registers an axial gradient for use as a glyph fill on this page. Coordinates
+     * come in the writer's top-left point space and are flipped to PDF bottom-left
+     * space here; the returned name is referenced via `OasisPdfTextOptions`.
+     */
+    registerAxialGradient(gradient: OasisPdfAxialGradient): string;
     drawRect(options: OasisPdfRectOptions): void;
     drawLine(options: OasisPdfLineOptions): void;
     drawPath(options: OasisPdfPathOptions): void;
@@ -15,6 +23,15 @@ export declare class PdfContentStream {
     rotateAbout(centerX: number, centerY: number, degrees: number): void;
     clipRect(x: number, y: number, width: number, height: number): void;
     drawText(options: OasisPdfTextOptions): void;
+    private textSetupCommands;
     private emitTextBlock;
+    /**
+     * Fills glyphs with an axial gradient: the text is drawn in clip render mode
+     * (`7 Tr`) so the glyph outlines become the clip path, then the shading is
+     * painted through them with `sh`. The whole sequence is isolated in a
+     * `q … Q` pair so the clip does not leak. Outline/stroke is not combined with
+     * gradient fill (the gradient supersedes it).
+     */
+    private emitGradientTextBlock;
     drawImage(options: OasisPdfImageOptions): void;
 }

package/dist/export/pdf/writer/PdfDocumentSerializer.d.ts

@@ -1,5 +1,6 @@
 import { OasisPdfPage } from './pdfTypes.js';
 import { PdfFontTable } from './PdfFontTable.js';
 import { PdfImageTable } from './PdfImageTable.js';
+import { PdfShadingTable } from './PdfShadingTable.js';
 
-export declare function serializePdfDocument(pages: OasisPdfPage[], fonts: PdfFontTable, images: PdfImageTable): Uint8Array;
+export declare function serializePdfDocument(pages: OasisPdfPage[], fonts: PdfFontTable, images: PdfImageTable, shadings: PdfShadingTable): Uint8Array;

package/dist/export/pdf/writer/PdfShadingTable.d.ts

@@ -0,0 +1,22 @@
+import { AddPdfObject } from './pdfTypes.js';
+
+/** A gradient already resolved to PDF bottom-left-origin point coordinates. */
+export interface PdfAxialShadingSpec {
+    x0: number;
+    y0: number;
+    x1: number;
+    y1: number;
+    /** Stops sorted by offset, each `{ offset: 0–1, color: hex }`. */
+    stops: Array<{
+        offset: number;
+        color: string;
+    }>;
+}
+export declare class PdfShadingTable {
+    private readonly shadings;
+    /** Registers a gradient (PDF space) and returns its `/Shading` resource name. */
+    register(spec: PdfAxialShadingSpec): string;
+    /** Emits each gradient's Function + Shading objects, keyed by resource name. */
+    buildShadingObjects(addObject: AddPdfObject): Map<string, number>;
+    private addShadingObject;
+}

package/dist/export/pdf/writer/pdfPrimitives.d.ts

@@ -6,6 +6,7 @@ export declare function formatNumber(value: number): string;
 export declare function byteLength(value: string): number;
 export declare function bytesToHex(bytes: Uint8Array): string;
 export declare function toHex16(value: number): string;
+export declare function colorToRgb(color: string | undefined, fallback: [number, number, number]): [number, number, number];
 export declare function colorCommand(color: string | undefined, operator: "rg" | "RG", fallback: [number, number, number]): string;
 export declare function resolveFontName(options: Pick<OasisPdfTextOptions, "bold" | "italic" | "fontResourceName">): string;
 export declare function fontResourceObjectBody(resource: OasisPdfFontResource): string;

package/dist/export/pdf/writer/pdfTypes.d.ts

@@ -12,6 +12,24 @@ export interface OasisPdfPage {
     height: number;
     commands: string[];
     imageResourceNames: Set<string>;
+    shadingResourceNames: Set<string>;
+}
+/** One color stop of an axial gradient. `offset` is 0–1; `color` is a hex string. */
+export interface OasisPdfGradientStop {
+    offset: number;
+    color: string;
+}
+/**
+ * An axial (linear) gradient fill, in the writer's top-left-origin point space.
+ * `(x0,y0)→(x1,y1)` is the gradient axis; the content stream flips y to PDF space
+ * and the shading extends its end colors beyond the axis.
+ */
+export interface OasisPdfAxialGradient {
+    x0: number;
+    y0: number;
+    x1: number;
+    y1: number;
+    stops: OasisPdfGradientStop[];
 }
 export interface OasisPdfRectOptions {
     x: number;
@@ -78,6 +96,12 @@ export interface OasisPdfTextOptions {
      * Unicode font (e.g. `["liga", "onum", "ss01"]`). Ignored by base-14 fonts.
      */
     fontFeatures?: readonly string[];
+    /**
+     * Resource name of an axial-gradient shading (from `registerAxialGradient`).
+     * When set, the glyphs are used as a clip path and the gradient is painted
+     * through them (`w14:textFill` gradient), so `color`/`renderMode` are ignored.
+     */
+    gradientShadingName?: string;
 }
 export interface OasisPdfImageResource {
     resourceName: string;

package/dist/import/docx/nestedBlocks.d.ts

@@ -6,6 +6,20 @@ import { DocxImportTheme } from './theme.js';
 import { NumberingMaps } from './numbering.js';
 import { ParseNestedBlocks } from './runs/types.js';
 
+/**
+ * Parse a single block-level child element (`w:p`, `w:tbl`, or a `w:sdt` content
+ * control) into editor blocks. Unknown elements yield no blocks. Shared by the
+ * text-box body walker, the document-body walker, and nested `w:sdtContent`.
+ */
+export declare function parseBlockLevelChild(element: XmlElement, numberingMaps: NumberingMaps, zip: JSZip, relsMap: Map<string, string>, assets: AssetRegistry, theme: DocxImportTheme, parseNestedBlocks: ParseNestedBlocks): Promise<EditorBlockNode[]>;
+/**
+ * Parse a block-level structured document tag (`w:sdt`) into its content blocks,
+ * preserving the `w:sdtPr`/`w:sdtEndPr` wrapper on each produced block so export
+ * can re-wrap it (see {@link EditorSdtBlockWrapper}). The content is unwrapped so
+ * it renders and edits like any other block; nested `w:sdt` recurses, prepending
+ * outer wrappers ahead of inner ones.
+ */
+export declare function parseSdtBlockNode(sdtElement: XmlElement, numberingMaps: NumberingMaps, zip: JSZip, relsMap: Map<string, string>, assets: AssetRegistry, theme: DocxImportTheme, parseNestedBlocks: ParseNestedBlocks): Promise<EditorBlockNode[]>;
 /**
  * Build a `ParseNestedBlocks` callback bound to an import context. The paragraph
  * and table parsers receive this so a text-box run can recurse into block-level

package/dist/{index-BuxYvaSC.js → index-BPpHyg6q.js}

@@ -2519,7 +2519,7 @@ function OasisEditorAppLazy(props = {}) {
     onCleanup(() => {
       cancelled = true;
     });
-    import("./OasisEditorApp-CRjXmvyC.js").then((m) => {
+    import("./OasisEditorApp-B421ezvO.js").then((m) => {
       cancelled = true;
       setProgress(1);
       setTimeout(() => setApp(() => m.OasisEditorApp), 180);
@@ -36504,6 +36504,86 @@ async function parseTableNode(tableNode, numberingMaps, zip, relsMap, assets, th
   }
   return table;
 }
+async function parseBlockLevelChild(element, numberingMaps, zip, relsMap, assets, theme, parseNestedBlocks) {
+  if (element.namespaceURI !== WORD_NS) {
+    return [];
+  }
+  if (element.localName === "p") {
+    const parsed = await parseParagraphNodes(
+      element,
+      numberingMaps,
+      zip,
+      relsMap,
+      assets,
+      theme,
+      parseNestedBlocks
+    );
+    return parsed.paragraphs;
+  }
+  if (element.localName === "tbl") {
+    return [
+      await parseTableNode(
+        element,
+        numberingMaps,
+        zip,
+        relsMap,
+        assets,
+        theme,
+        parseNestedBlocks
+      )
+    ];
+  }
+  if (element.localName === "sdt") {
+    return parseSdtBlockNode(
+      element,
+      numberingMaps,
+      zip,
+      relsMap,
+      assets,
+      theme,
+      parseNestedBlocks
+    );
+  }
+  return [];
+}
+async function parseSdtBlockNode(sdtElement, numberingMaps, zip, relsMap, assets, theme, parseNestedBlocks) {
+  const sdtPr = getFirstChildByTagNameNS(sdtElement, WORD_NS, "sdtPr");
+  const sdtEndPr = getFirstChildByTagNameNS(sdtElement, WORD_NS, "sdtEndPr");
+  const wrapper = {
+    groupId: createEditorNodeId("sdt"),
+    sdtPrXml: sdtPr ? new XMLSerializer().serializeToString(sdtPr) : "",
+    ...sdtEndPr ? { sdtEndPrXml: new XMLSerializer().serializeToString(sdtEndPr) } : {}
+  };
+  const sdtContent = getFirstChildByTagNameNS(
+    sdtElement,
+    WORD_NS,
+    "sdtContent"
+  );
+  const blocks = [];
+  if (sdtContent) {
+    for (let index = 0; index < sdtContent.childNodes.length; index += 1) {
+      const node = sdtContent.childNodes[index];
+      if ((node == null ? void 0 : node.nodeType) !== node.ELEMENT_NODE) {
+        continue;
+      }
+      blocks.push(
+        ...await parseBlockLevelChild(
+          node,
+          numberingMaps,
+          zip,
+          relsMap,
+          assets,
+          theme,
+          parseNestedBlocks
+        )
+      );
+    }
+  }
+  for (const block of blocks) {
+    block.sdtWrappers = [wrapper, ...block.sdtWrappers ?? []];
+  }
+  return blocks;
+}
 function createNestedBlockParser(numberingMaps, zip, relsMap, assets, theme) {
   return (container) => parseTxbxContentBlocks(
     container,
@@ -36528,36 +36608,17 @@ async function parseTxbxContentBlocks(container, numberingMaps, zip, relsMap, as
     if ((node == null ? void 0 : node.nodeType) !== node.ELEMENT_NODE) {
       continue;
     }
-    const element = node;
-    if (element.namespaceURI !== WORD_NS) {
-      continue;
-    }
-    if (element.localName === "p") {
-      const parsed = await parseParagraphNodes(
-        element,
+    blocks.push(
+      ...await parseBlockLevelChild(
+        node,
         numberingMaps,
         zip,
         relsMap,
         assets,
         theme,
         parseNestedBlocks
-      );
-      for (const paragraph of parsed.paragraphs) {
-        blocks.push(paragraph);
-      }
-    } else if (element.localName === "tbl") {
-      blocks.push(
-        await parseTableNode(
-          element,
-          numberingMaps,
-          zip,
-          relsMap,
-          assets,
-          theme,
-          parseNestedBlocks
-        )
-      );
-    }
+      )
+    );
   }
   return blocks;
 }
@@ -37117,6 +37178,19 @@ async function importDocxToEditorDocument(buffer, options = {}) {
         )
       );
       reportBodyProgress();
+    } else if (element.localName === "sdt") {
+      for (const block of await parseSdtBlockNode(
+        element,
+        numberingMaps,
+        zip,
+        relsMap,
+        assets,
+        theme,
+        parseNestedBlocks
+      )) {
+        appendBodyBlock(block);
+      }
+      reportBodyProgress();
     }
     await yieldToEventLoop(50, completedBodyWorkItems);
   }
@@ -37500,7 +37574,7 @@ function importDocxInWorker(buffer, options = {}) {
     const worker = new Worker(
       new URL(
         /* @vite-ignore */
-        "" + new URL("assets/importDocxWorker-BulqJDJj.js", import.meta.url).href,
+        "" + new URL("assets/importDocxWorker-DkjxuxwM.js", import.meta.url).href,
         import.meta.url
       ),
       {

package/dist/oasis-editor.js

@@ -1,4 +1,4 @@
-import { O, c8, c9, ca, cb, cc, a8, cd, Q, bT, ce, cf, cg, N, ch, bR, ci, cj, ck, cl, cm, c3, cn, co, cp, cq, cr, cs, ct, cu, cv, cw, cx, cy, ad, cz, c2, cA, ca as ca2, cf as cf2, ch as ch2, cq as cq2, cs as cs2, cx as cx2, cB, bV, bQ, cC, cD, cE, bS, cF, cG, bU } from "./index-BuxYvaSC.js";
+import { O, c8, c9, ca, cb, cc, a8, cd, Q, bT, ce, cf, cg, N, ch, bR, ci, cj, ck, cl, cm, c3, cn, co, cp, cq, cr, cs, ct, cu, cv, cw, cx, cy, ad, cz, c2, cA, ca as ca2, cf as cf2, ch as ch2, cq as cq2, cs as cs2, cx as cx2, cB, bV, bQ, cC, cD, cE, bS, cF, cG, bU } from "./index-BPpHyg6q.js";
 export {
   O as BalloonShell,
   c8 as Button,