@pixerate/editor 0.25.0 → 0.26.1

package/dist/{controller-BIJiNoVs.d.ts → controller-CxXGOEmy.d.ts}

@@ -654,6 +654,11 @@ interface FormulaNameDefinition {
     /** A key identifying the name (for cycle detection), e.g. `Data!RATE`. Defaults to the name. */
     key?: string;
 }
+/** Hints for `EvaluationContext.resolveRange`. */
+interface RangeResolveOptions {
+    /** The values are only aggregated by a function that ignores blank cells. */
+    skipBlanks?: boolean;
+}
 interface EvaluationContext {
     /**
      * Value of a cell. `sheet` is set for sheet-qualified references
@@ -665,8 +670,11 @@ interface EvaluationContext {
      * Values of a rectangular range, column by column (all rows of the first
      * column, then the next column). Lookup functions rely on this order.
      * `sheet` as in `resolveCell`; return an error code for a missing sheet.
+     * `options.skipBlanks` is a hint that the caller ignores blank cells
+     * (SUM, COUNT, AVERAGE, …): a resolver may then leave them out, so sparse
+     * ranges cost no array slots. Returning every value is always correct.
      */
-    resolveRange?: (startCol: string, startRow: number, endCol: string, endRow: number, sheet?: string) => any[] | string;
+    resolveRange?: (startCol: string, startRow: number, endCol: string, endRow: number, sheet?: string, options?: RangeResolveOptions) => any[] | string;
     resolveProperty?: (property: string) => any;
     /**
      * The spilled array anchored at a cell, for `A1#` references: its shape and
@@ -760,6 +768,10 @@ declare class FormulaEvaluator {
     private evaluateRange;
     private callFunction;
     private finishCall;
+    /**
+     * Arguments evaluated on first use. With `skipBlanks` (the function ignores
+     * blank cells), range arguments may come back without their blanks.
+     */
     private lazyArguments;
     /**
      * Applies a scalar function element by element when it receives arrays
@@ -843,19 +855,107 @@ declare function extractNameDependencies(node: ASTNode): NameDep[];
  */
 declare const columnDependencyKey: (col: string) => string;
 declare function extractCellDependencies(node: ASTNode): CellDep[];
+/**
+ * A reference a formula reads, without expanding ranges: a single cell or
+ * a rectangle (`A1:B9`; a whole column `A:A` runs to `WHOLE_COLUMN_END_ROW`).
+ * Columns are letters, rows are 1-based; ranges are normalised (start ≤ end).
+ */
+type ReferenceDep = ({
+    kind: 'cell';
+    col: string;
+    row: number;
+} & Pick<CellDep, 'sheet' | 'sheetEnd'>) | ({
+    kind: 'range';
+    startCol: string;
+    startRow: number;
+    endCol: string;
+    endRow: number;
+} & Pick<CellDep, 'sheet' | 'sheetEnd'>);
+/**
+ * The cells and ranges a formula reads, ranges kept whole (unlike
+ * `extractCellDependencies`, which lists every cell of a range). `A1#`
+ * depends on its anchor `A1`.
+ */
+declare function extractReferenceDependencies(node: ASTNode): ReferenceDep[];
+/**
+ * Dependency key of a rectangle (`A1:B9`, or `SHEET!A1:B9` with a sheet
+ * prefix), for `DependencyGraph.setCellDependencies`. The graph stores it as
+ * one range, however many cells it covers.
+ */
+declare function rangeDependencyKey(startCol: string, startRow: number, endCol: string, endRow: number, sheetPrefix?: string): string;
+interface IntervalEntry<T> {
+    r0: number;
+    r1: number;
+    id: string;
+    payload: T;
+}
+/**
+ * Row intervals `[r0, r1]` with payloads, answering "which intervals overlap
+ * rows `a..b`?" in O(log n + k). Entries are sorted by start, with an
+ * implicit segment tree of the largest end below each node, so a query only
+ * descends into subtrees holding a match. Removals mark entries dead;
+ * insertions wait in a small pending set. Both are merged in (on the next
+ * query) once either grows, so mutations cost O(log n) amortised.
+ */
+declare class IntervalIndex<T> {
+    private items;
+    private dead;
+    private deadCount;
+    private maxEnd;
+    private leaves;
+    private position;
+    private pending;
+    /** Live entries. */
+    get size(): number;
+    /** Adds (or revives) the entry `id`. An id always names the same interval. */
+    insert(r0: number, r1: number, id: string, payload: T): void;
+    remove(id: string): void;
+    /** Merges pending insertions and drops dead entries when there are enough of them. */
+    private settle;
+    /** Calls `fn` for every live interval overlapping rows `a..b` (`r0 <= b && r1 >= a`). */
+    query(a: number, b: number, fn: (payload: T, entry: IntervalEntry<T>) => void): void;
+    private walk;
+}
+/** Sizes of the dependency index (see `DependencyGraph.getIndexStats`). */
+interface DependencyIndexStats {
+    /** Cells with registered dependencies (formulas). */
+    formulas: number;
+    /** Single-cell edges (formula → cell it reads). */
+    cellEdges: number;
+    /** Range entries: one per range (per column for ranges up to 64 columns wide), however many cells it covers. */
+    rangeEntries: number;
+    /** Formulas that use a volatile function. */
+    volatile: number;
+}
 declare class DependencyGraph {
-    private dependencies;
-    private dependents;
+    private nodes;
+    private cellDependents;
+    private rangeIndex;
+    private volatile;
     private spillDependencies;
     private spillDependents;
     private spillEdges;
-    /**
-     * Sets the cells `cellKey` depends on directly (keys such as `B2`, or a
-     * column key from `columnDependencyKey`), replacing its previous
-     * dependencies. Used by spreadsheets whose keys carry more than A1 text
-     * (e.g. sheet-qualified keys); `setCellFormula` derives them from a formula.
+    private blockingEdges;
+    private parsed;
+    private parse;
+    private sheetIndex;
+    private removeNode;
+    /**
+     * Sets what `cellKey` depends on directly, replacing its previous
+     * dependencies. Keys are single cells (`B2`), rectangles (`A1:B9`) or
+     * whole columns (`A:`, see `columnDependencyKey`), each optionally
+     * sheet-qualified (`SHEET!A1:A9`). Ranges are stored whole in an interval
+     * index, never expanded cell by cell. `setCellFormula` derives the keys
+     * from a formula.
      */
     setCellDependencies(cellKey: string, dependencyKeys: Iterable<string>): void;
+    /**
+     * Marks `cellKey` as volatile (its formula uses NOW, RAND, …): it is
+     * recalculated by every plan made with `includeVolatile`, whatever changed.
+     */
+    setVolatile(cellKey: string, volatile: boolean): void;
+    /** Cells whose formulas are volatile. */
+    getVolatileKeys(): string[];
     setCellFormula(cellKey: string, formulaStr: string | null): void;
     /** Removes every registered formula and dependency. */
     clear(): void;
@@ -867,12 +967,34 @@ declare class DependencyGraph {
      * the anchor's edges.
      */
     setSpillEdges(anchorKey: string, spilledKeys: Iterable<string>, blockingKeys?: Iterable<string>): void;
+    /**
+     * Drops the edge from a spilled cell to the anchor whose values it holds,
+     * for a cell that just got input of its own: its value no longer comes
+     * from the anchor (which recalculates and becomes `#SPILL!`), and the
+     * stale edge could otherwise close a false cycle with the cell's new
+     * formula before the anchor is evaluated again.
+     */
+    detachSpilledCell(cellKey: string): void;
     /** The spilled cells registered for `anchorKey` by `setSpillEdges`. */
     getSpilledKeys(anchorKey: string): string[];
-    /** Formula dependencies plus dynamic-array (spill) dependencies of a cell. */
+    /**
+     * What a cell depends on directly: single cells, ranges (as registered,
+     * e.g. `A1:A9` or `A:`, not expanded) and dynamic-array (spill) edges.
+     */
     getDependencies(cellKey: string): string[];
-    /** Cells depending on `cellKey`, through formulas or spills. */
+    /**
+     * Whether the formula in `formulaKey` reads `cellKey` directly: as a cell,
+     * inside one of its ranges, or through a spill edge.
+     */
+    dependsOn(formulaKey: string, cellKey: string): boolean;
+    /**
+     * Formulas (and spilled cells) reading `cellKey` directly, through formulas
+     * or spills. Found in O(log n + k) through the range index.
+     */
     getDependents(cellKey: string): string[];
+    private collectDependents;
+    /** Sizes of the index: ranges count once (per column), not once per cell. */
+    getIndexStats(): DependencyIndexStats;
     /**
      * Detects if there is a cycle containing cellKey.
      */
@@ -886,13 +1008,19 @@ declare class DependencyGraph {
     };
     /**
      * Plans a recalculation over `cellKeys` (and, with `includeDependents`, every
-     * cell that transitively depends on them). Returns the keys in evaluation
+     * cell that transitively depends on them; with `includeVolatile`, every
+     * volatile formula and its dependents too). Returns the keys in evaluation
      * order (dependencies first) and the set of keys that are part of a cycle,
      * which must be marked `#CYCLE!` instead of evaluated. Every member of a
      * cycle is reported, not just the cell that closed it.
+     *
+     * Only the planned cells are ordered: a range a formula reads becomes one
+     * node whose edges are the planned cells inside it (found by binary
+     * search), so a range shared by many formulas is resolved once.
      */
     getEvaluationPlan(cellKeys: Iterable<string>, options?: {
         includeDependents?: boolean;
+        includeVolatile?: boolean;
     }): {
         order: string[];
         cyclic: Set<string>;
@@ -1234,6 +1362,15 @@ interface SpreadsheetControllerOptions {
      */
     maxHistoryBytes?: number;
 }
+/** Work done by a recalculation (see `SpreadsheetController.getRecalculationStats`). */
+interface SpreadsheetRecalculationStats {
+    /** Formulas evaluated. */
+    evaluated: number;
+    /** Cells in the evaluation plans: formulas, their dependents and spilled cells. */
+    planned: number;
+    /** Evaluation passes (another pass runs when spill ranges change). */
+    passes: number;
+}
 /** A defined name as listed by `getNames()`. */
 interface SpreadsheetNameInfo extends SpreadsheetDefinedName {
     /** Name of the sheet a sheet-scoped name belongs to; unset for workbook scope. */
@@ -1273,6 +1410,9 @@ declare class SpreadsheetController {
     private evaluatingRowIndex;
     private evaluatingCell;
     private spillChanges;
+    private recalcStats;
+    private astCache;
+    private rangeCache;
     /** The active sheet's document (the sheet the editor shows). */
     get document(): SpreadsheetDocument;
     set document(doc: SpreadsheetDocument);
@@ -1358,7 +1498,17 @@ declare class SpreadsheetController {
     private recomputeRowIndices;
     getColumn(colIdOrKey: string): SpreadsheetColumn | undefined;
     getRow(rowIdOrIndex: string | number): SpreadsheetRow | undefined;
+    /** The row with this id on the current sheet (constant time, see `PositionCache`). */
+    private findRow;
+    /** The column with this id on the current sheet. */
+    private findColumn;
+    /** The column whose key is `key` (`A`, `B`, …): keys follow column positions. */
+    private columnByKey;
     getCell(rowId: string, colId: string): CellData;
+    /** `getCell` for a row and column already looked up. */
+    private cellOf;
+    /** A cell with no value of its own: derived (bound, column formula, blank), keeping an explicit number format. */
+    private finishCell;
     /** Value of a cell with no stored data: bound record value, column formula, or blank. */
     private getDerivedCell;
     setCellValue(rowId: string, colId: string, raw: string): void;
@@ -1375,7 +1525,26 @@ declare class SpreadsheetController {
      * span) and, through defined names, the cells those names refer to.
      */
     private registerFormula;
-    /** Adds the qualified keys `ast` depends on, with unqualified references on `home`. */
+    /**
+     * Spill edges made stale by new input in `cellKey`: the edges of the array
+     * it anchored (its new formula re-spills when evaluated; spill changes
+     * are recalculated in a further pass) and, when it now holds input, its
+     * edge to the anchor whose values it held. Left in place they can close
+     * false cycles with the new formulas before the anchors are evaluated.
+     */
+    private dropStaleSpillEdges;
+    /**
+     * The parsed formula, shared by dependency registration and evaluation (so
+     * a load parses each formula once). ASTs are never mutated.
+     */
+    private parseCached;
+    /**
+     * Adds the qualified keys `ast` depends on, with unqualified references on
+     * `home`: cells, and ranges kept whole (`SHEETID!A1:A50000`), which the
+     * graph indexes as intervals instead of one key per cell. Sets
+     * `volatile.found` when a volatile function (NOW, RAND, …) is used,
+     * directly or through a defined name.
+     */
     private collectDependencies;
     /**
      * Recalculates `keys` (and, with `includeDependents`, their dependents) in
@@ -1385,12 +1554,31 @@ declare class SpreadsheetController {
      * another pass, until nothing changes.
      */
     private recalculateKeys;
+    /**
+     * Recalculates cells of the current sheet whose stored input changed (their
+     * formulas already registered), with their dependents, in one plan.
+     */
+    private recalculateWrittenCells;
+    /**
+     * Work done by the last recalculation (an edit, paste, import, load or
+     * full recalculation): formulas evaluated, cells planned (formulas, their
+     * dependents and spilled cells) and passes (more than one when spill
+     * ranges changed). Deterministic, unlike timings: use it to check that an
+     * edit only recalculates what depends on it.
+     */
+    getRecalculationStats(): SpreadsheetRecalculationStats;
     /**
      * Rebuilds the dependency graph from scratch and recalculates every formula
      * in dependency order.
      */
     recalculateAll(): void;
     private runEvaluationPlan;
+    /**
+     * Drops cached ranges of `sheetId` that cover column `col` (whose cell was
+     * just evaluated), or all of the sheet's when `col` is null (spilled
+     * values moved or changed).
+     */
+    private invalidateRangeCache;
     private locateCellKey;
     private markCycle;
     private evalSingleCellByKey;
@@ -1415,6 +1603,11 @@ declare class SpreadsheetController {
     /** Whether `range` overlaps a spilled array (its anchor or spilled cells). */
     private intersectsSpill;
     private resolveCellByCoord;
+    /**
+     * Values of a range, column by column. With `skipBlanks` (functions that
+     * ignore blank cells: SUM, COUNT, AVERAGE, …) blank cells are left out, so
+     * a sparse column costs one lookup per row and no array slot.
+     */
     private resolveRangeByCoords;
     private resolveCurrentRowProperty;
     selectCell(row: number, col: number, extendSelection?: boolean): void;
@@ -1735,6 +1928,9 @@ declare class SpreadsheetController {
         sheet?: string;
     }): FormulaEvaluationResult;
     private recordSnapshot;
+    /** Records the stored state of one cell, for undoing a single-cell edit. */
+    private recordCellSnapshot;
+    private cellHistory;
     private recordWorkbookSnapshot;
     private pushUndo;
     /** Drops the oldest snapshots beyond `maxHistoryBytes`, always keeping the newest. */
@@ -1839,4 +2035,4 @@ declare class SpreadsheetController {
     isInvalidDataCircled(row: number, col: number): boolean;
 }
 
-export { type GroupSummary as $, type ASTNode as A, type BinaryOpNode as B, type CellCoordinate as C, DEFAULT_COLUMN_WIDTH as D, type DataValidationResult as E, type DataValidationRule as F, type DataValidationSheet as G, type DataValidationType as H, DependencyGraph as I, type EvaluationContext as J, FORMULA_ERRORS as K, type FilterOperator as L, type FilterRule as M, type FormulaDiagnostic as N, type FormulaErrorCode as O, type FormulaEvaluationResult as P, FormulaEvaluator as Q, type FormulaNameDefinition as R, SpreadsheetController as S, FormulaParser as T, type FormulaRange as U, type FormulaReferenceFilter as V, type FormulaReferenceInfo as W, type FormulaToken as X, type FormulaTokenType as Y, type FunctionCallNode as Z, type GroupAggregate as _, type CellData as a, getTableSections as a$, type InvokeNode as a0, type LiteralNode as a1, MAX_FORMULA_ARRAY_SIZE as a2, type MissingNode as a3, type NameDep as a4, type NameNode as a5, type NewConditionalFormatRule as a6, type NewDataValidationRule as a7, type NewFilterRule as a8, type ParsedSpreadsheetClipboard as a9, type SpreadsheetRowSection as aA, type SpreadsheetSheetInfo as aB, type SpreadsheetSpill as aC, type SpreadsheetTableSettings as aD, type SpreadsheetValidationAction as aE, type SpreadsheetValidationPrompt as aF, type SpreadsheetViewColumn as aG, type SpreadsheetViewModel as aH, type SpreadsheetViewRow as aI, type SpreadsheetWorkbook as aJ, type StructuralChange as aK, type UnaryOpNode as aL, WHOLE_COLUMN_END_ROW as aM, buildSpreadsheetView as aN, colNameToIndex as aO, columnDependencyKey as aP, compareNumbers as aQ, compareValues as aR, computeRowGroups as aS, createSpreadsheetClipboardData as aT, deleteSheetInFormula as aU, describeFormulaError as aV, extractCellDependencies as aW, extractNameDependencies as aX, formatSheetPrefix as aY, formulaIdentifiers as aZ, getRowSection as a_, type PropertyRefNode as aa, type RangeNode as ab, type RowType as ac, SPREADSHEET_CLIPBOARD_MIME as ad, type SheetQualifier as ae, type SortDirection as af, type SortKey as ag, type SpillRefNode as ah, type SpreadsheetCellSpan as ai, type SpreadsheetClipboardCell as aj, type SpreadsheetClipboardData as ak, type SpreadsheetClipboardPayload as al, type SpreadsheetClipboardSource as am, type SpreadsheetColumn as an, type SpreadsheetCommitResult as ao, type SpreadsheetControllerOptions as ap, type SpreadsheetDataSource as aq, type SpreadsheetDataSourceField as ar, type SpreadsheetDefinedName as as, type SpreadsheetDocument as at, type SpreadsheetFilterState as au, type SpreadsheetGrouping as av, type SpreadsheetNameInfo as aw, type SpreadsheetNameScope as ax, type SpreadsheetRow as ay, type SpreadsheetRowGroup as az, type CellDep as b, indexToColName as b0, isFormulaError as b1, mapFormulaReferences as b2, numberToText as b3, offsetFormulaReferences as b4, parseCellReference as b5, parseFormula as b6, parseHtmlTable as b7, parseRange as b8, quoteSheetName as b9, readSpreadsheetClipboard as ba, rebaseClipboardRows as bb, remapFormulaReferences as bc, renameNameInFormula as bd, renameSheetInFormula as be, rowPassesFilters as bf, serializeHtmlTable as bg, sheetNameNeedsQuotes as bh, shiftFormulaReferences as bi, sortCompareValues as bj, tokenizeFormula as bk, type CellFormat as c, type CellPosition as d, type CellRange as e, type CellRefNode as f, type CellValueReader as g, type ColumnBinding as h, type ColumnType as i, type ConditionalCellFormat as j, type ConditionalFormatCondition as k, type ConditionalFormatIconSet as l, type ConditionalFormatOperator as m, type ConditionalFormatOverlay as n, type ConditionalFormatRule as o, type ConditionalFormatSheet as p, type ConditionalFormatStyle as q, type ConditionalFormatTimePeriod as r, type ConditionalFormatType as s, type ConditionalFormatValue as t, type CsvExportOptions as u, type CsvImportOptions as v, DEFAULT_ROW_HEIGHT as w, DataSourceBinder as x, type DataValidationErrorStyle as y, type DataValidationOperator as z };
+export { type GroupAggregate as $, type ASTNode as A, type BinaryOpNode as B, type CellCoordinate as C, DEFAULT_COLUMN_WIDTH as D, type DataValidationResult as E, type DataValidationRule as F, type DataValidationSheet as G, type DataValidationType as H, DependencyGraph as I, type DependencyIndexStats as J, type EvaluationContext as K, FORMULA_ERRORS as L, type FilterOperator as M, type FilterRule as N, type FormulaDiagnostic as O, type FormulaErrorCode as P, type FormulaEvaluationResult as Q, FormulaEvaluator as R, SpreadsheetController as S, type FormulaNameDefinition as T, FormulaParser as U, type FormulaRange as V, type FormulaReferenceFilter as W, type FormulaReferenceInfo as X, type FormulaToken as Y, type FormulaTokenType as Z, type FunctionCallNode as _, type CellData as a, extractCellDependencies as a$, type GroupSummary as a0, IntervalIndex as a1, type InvokeNode as a2, type LiteralNode as a3, MAX_FORMULA_ARRAY_SIZE as a4, type MissingNode as a5, type NameDep as a6, type NameNode as a7, type NewConditionalFormatRule as a8, type NewDataValidationRule as a9, type SpreadsheetNameInfo as aA, type SpreadsheetNameScope as aB, type SpreadsheetRecalculationStats as aC, type SpreadsheetRow as aD, type SpreadsheetRowGroup as aE, type SpreadsheetRowSection as aF, type SpreadsheetSheetInfo as aG, type SpreadsheetSpill as aH, type SpreadsheetTableSettings as aI, type SpreadsheetValidationAction as aJ, type SpreadsheetValidationPrompt as aK, type SpreadsheetViewColumn as aL, type SpreadsheetViewModel as aM, type SpreadsheetViewRow as aN, type SpreadsheetWorkbook as aO, type StructuralChange as aP, type UnaryOpNode as aQ, WHOLE_COLUMN_END_ROW as aR, buildSpreadsheetView as aS, colNameToIndex as aT, columnDependencyKey as aU, compareNumbers as aV, compareValues as aW, computeRowGroups as aX, createSpreadsheetClipboardData as aY, deleteSheetInFormula as aZ, describeFormulaError as a_, type NewFilterRule as aa, type ParsedSpreadsheetClipboard as ab, type PropertyRefNode as ac, type RangeNode as ad, type RangeResolveOptions as ae, type ReferenceDep as af, type RowType as ag, SPREADSHEET_CLIPBOARD_MIME as ah, type SheetQualifier as ai, type SortDirection as aj, type SortKey as ak, type SpillRefNode as al, type SpreadsheetCellSpan as am, type SpreadsheetClipboardCell as an, type SpreadsheetClipboardData as ao, type SpreadsheetClipboardPayload as ap, type SpreadsheetClipboardSource as aq, type SpreadsheetColumn as ar, type SpreadsheetCommitResult as as, type SpreadsheetControllerOptions as at, type SpreadsheetDataSource as au, type SpreadsheetDataSourceField as av, type SpreadsheetDefinedName as aw, type SpreadsheetDocument as ax, type SpreadsheetFilterState as ay, type SpreadsheetGrouping as az, type CellDep as b, extractNameDependencies as b0, extractReferenceDependencies as b1, formatSheetPrefix as b2, formulaIdentifiers as b3, getRowSection as b4, getTableSections as b5, indexToColName as b6, isFormulaError as b7, mapFormulaReferences as b8, numberToText as b9, offsetFormulaReferences as ba, parseCellReference as bb, parseFormula as bc, parseHtmlTable as bd, parseRange as be, quoteSheetName as bf, rangeDependencyKey as bg, readSpreadsheetClipboard as bh, rebaseClipboardRows as bi, remapFormulaReferences as bj, renameNameInFormula as bk, renameSheetInFormula as bl, rowPassesFilters as bm, serializeHtmlTable as bn, sheetNameNeedsQuotes as bo, shiftFormulaReferences as bp, sortCompareValues as bq, tokenizeFormula as br, type CellFormat as c, type CellPosition as d, type CellRange as e, type CellRefNode as f, type CellValueReader as g, type ColumnBinding as h, type ColumnType as i, type ConditionalCellFormat as j, type ConditionalFormatCondition as k, type ConditionalFormatIconSet as l, type ConditionalFormatOperator as m, type ConditionalFormatOverlay as n, type ConditionalFormatRule as o, type ConditionalFormatSheet as p, type ConditionalFormatStyle as q, type ConditionalFormatTimePeriod as r, type ConditionalFormatType as s, type ConditionalFormatValue as t, type CsvExportOptions as u, type CsvImportOptions as v, DEFAULT_ROW_HEIGHT as w, DataSourceBinder as x, type DataValidationErrorStyle as y, type DataValidationOperator as z };

package/dist/export/index.cjs

@@ -0,0 +1,36 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+var _chunkTXXNBDQXcjs = require('../chunk-TXXNBDQX.cjs');
+require('../chunk-3CC7OPUQ.cjs');
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.DOCX_ANONYMOUS_AUTHOR = _chunkTXXNBDQXcjs.DOCX_ANONYMOUS_AUTHOR; exports.DOCX_EXPORT_MIME_TYPE = _chunkTXXNBDQXcjs.DOCX_EXPORT_MIME_TYPE; exports.DocxExportController = _chunkTXXNBDQXcjs.DocxExportController; exports.XmlWriter = _chunkTXXNBDQXcjs.XmlWriter; exports.createDocxExportController = _chunkTXXNBDQXcjs.createDocxExportController; exports.createDocxParts = _chunkTXXNBDQXcjs.createDocxParts; exports.deflateRaw = _chunkTXXNBDQXcjs.deflateRaw; exports.docxFileName = _chunkTXXNBDQXcjs.docxFileName; exports.downloadBlob = _chunkTXXNBDQXcjs.downloadBlob; exports.escapeXmlAttr = _chunkTXXNBDQXcjs.escapeXmlAttr; exports.escapeXmlText = _chunkTXXNBDQXcjs.escapeXmlText; exports.exportDocx = _chunkTXXNBDQXcjs.exportDocx; exports.exportDocxBlob = _chunkTXXNBDQXcjs.exportDocxBlob; exports.stripInvalidXmlChars = _chunkTXXNBDQXcjs.stripInvalidXmlChars; exports.writeZip = _chunkTXXNBDQXcjs.writeZip;
+//# sourceMappingURL=index.cjs.map

package/dist/export/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["/home/runner/work/editor/editor/packages/core/dist/export/index.cjs"],"names":[],"mappings":"AAAA;AACE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACF,yDAA8B;AAC9B,iCAA8B;AAC9B;AACE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACF,g5BAAC","file":"/home/runner/work/editor/editor/packages/core/dist/export/index.cjs"}

package/dist/export/index.d.cts

@@ -0,0 +1,243 @@
+import { S as SerializedComments, f as CommentThread, R as ReviewAuthor } from '../comment-store-BEMgVlAA.cjs';
+import { e as StyleRegistry, f as StyleRegistryJSON, c as StyleDefinition } from '../registry-CED5C0lA.cjs';
+
+/**
+ * Dependency-free DOCX (WordprocessingML) export of TipTap documents.
+ *
+ * Takes an editor (anything with `getJSON()`) or its JSON and writes a
+ * minimal, valid package: `[Content_Types].xml`, `_rels/.rels`,
+ * `word/document.xml` (+ relationships), `styles.xml` (from the paragraph
+ * style registry, with `basedOn` / `next` / `link`), `numbering.xml` (one
+ * `w:num` per list), `settings.xml`, `comments.xml` +
+ * `commentsExtended.xml` (replies and resolved state) + `people.xml` (author
+ * ids), `docProps/core.xml` and `docProps/app.xml`, plus embedded images.
+ *
+ * Tracked insertions, deletions, moves (`w:moveFrom` / `w:moveTo` with
+ * named move ranges), formatting changes (`w:rPrChange`) and block changes
+ * (`w:pPrChange`, paragraph-mark `w:ins` / `w:del`) keep their authors and
+ * dates. Anything that cannot be written is listed in the returned report.
+ */
+declare const DOCX_EXPORT_MIME_TYPE = "application/vnd.openxmlformats-officedocument.wordprocessingml.document";
+/** A ProseMirror / TipTap JSON node (`editor.getJSON()`). */
+interface DocxJSONNode {
+    type?: string;
+    attrs?: Record<string, any>;
+    content?: DocxJSONNode[];
+    marks?: DocxJSONMark[];
+    text?: string;
+}
+interface DocxJSONMark {
+    type: string;
+    attrs?: Record<string, any>;
+}
+/** Anything with `getJSON()`, e.g. a TipTap `Editor`. Its comment store and style registry are used by default. */
+interface DocxExportEditorLike {
+    getJSON(): DocxJSONNode;
+    storage?: unknown;
+}
+/** A comment store (`CommentStore`), its `toJSON()` output, or a thread list. */
+type DocxCommentSource = {
+    toJSON(): SerializedComments;
+} | {
+    getSnapshot(): {
+        threads: readonly CommentThread[];
+    };
+} | SerializedComments | readonly CommentThread[];
+interface DocxExportOptions {
+    /**
+     * Paragraph and character styles written to `styles.xml`. Defaults to the
+     * editor's registry (`ParagraphStyles` extension), else the built-in styles.
+     */
+    styles?: StyleRegistry | StyleRegistryJSON | readonly StyleDefinition[];
+    /** Comment threads. Defaults to the editor's comment store (`Comments` extension). */
+    comments?: DocxCommentSource | null;
+    /**
+     * The document's author (`dc:creator`) and the author of tracked changes
+     * and comments that name none.
+     */
+    author?: string | ReviewAuthor;
+    /**
+     * `"strip-authors"` writes every comment, reply and tracked change as
+     * "Author" (initials "A"), leaves out `people.xml`, the creator and last
+     * modified by, and sets `w:removePersonalInformation` so Word keeps doing
+     * so. Default `"keep"`.
+     */
+    privacy?: "keep" | "strip-authors";
+    /** `dc:title` of the document. */
+    title?: string;
+    /**
+     * Images with `http(s)` URLs: `"skip"` (default, reported) or `"link"`
+     * (an external relationship Word may load when the file is opened).
+     */
+    remoteImages?: "skip" | "link";
+    /** Time written as created / modified (default: now). */
+    now?: () => Date;
+    /** ZIP compression (default `"auto"`: deflate when `CompressionStream` exists). */
+    compression?: "auto" | "store";
+}
+type DocxExportIssueKind = "node" | "mark" | "image" | "link" | "comment" | "style";
+/** Something the export left out or simplified, counted per kind, name and reason. */
+interface DocxExportIssue {
+    kind: DocxExportIssueKind;
+    /** Node / mark type, style id, image or link URL (truncated), or comment thread id. */
+    name: string;
+    reason: string;
+    count: number;
+}
+interface DocxExportReport {
+    /** Content that was dropped or simplified. Empty when everything was written. */
+    dropped: DocxExportIssue[];
+    /** Counts of what was written. */
+    written: {
+        paragraphs: number;
+        tables: number;
+        images: number;
+        comments: number;
+        replies: number;
+        trackedChanges: number;
+    };
+}
+interface DocxExportResult {
+    /** The `.docx` file. */
+    data: Uint8Array;
+    report: DocxExportReport;
+}
+interface DocxPackagePart {
+    name: string;
+    data: Uint8Array | string;
+}
+/** Name written for every author with `privacy: "strip-authors"` (as Word does). */
+declare const DOCX_ANONYMOUS_AUTHOR = "Author";
+/**
+ * Builds the package parts of a DOCX file without zipping them (synchronous;
+ * useful for inspection and tests). See {@link exportDocx}.
+ */
+declare function createDocxParts(input: DocxExportEditorLike | DocxJSONNode, options?: DocxExportOptions): {
+    parts: DocxPackagePart[];
+    report: DocxExportReport;
+};
+/**
+ * Exports an editor (or its JSON) as a Word document. Resolves with the file
+ * bytes and a report of what was dropped. Never fetches anything: remote
+ * images are skipped (or linked with `remoteImages: "link"`).
+ */
+declare function exportDocx(input: DocxExportEditorLike | DocxJSONNode, options?: DocxExportOptions): Promise<DocxExportResult>;
+/** Like {@link exportDocx}, but resolves with a `Blob` of type {@link DOCX_EXPORT_MIME_TYPE}. */
+declare function exportDocxBlob(input: DocxExportEditorLike | DocxJSONNode, options?: DocxExportOptions): Promise<{
+    blob: Blob;
+    report: DocxExportReport;
+}>;
+
+/**
+ * Saves a `Blob` as a file through a temporary `<a download>` link. Does
+ * nothing (returns `false`) without a DOM.
+ */
+declare function downloadBlob(blob: Blob, fileName: string): boolean;
+/** `name.docx`, with characters that are invalid in file names replaced. */
+declare function docxFileName(name: string | undefined): string;
+interface DocxExportState {
+    isExporting: boolean;
+    /** Last export error (cleared when a new export starts). */
+    error: Error | null;
+    /** Report of the most recent successful export. */
+    lastReport: DocxExportReport | null;
+}
+interface DocxExportControllerOptions extends DocxExportOptions {
+    /** Download file name (default: `title`, else `document`, plus `.docx`). */
+    fileName?: string;
+    /** Called after each successful export with its report. */
+    onExport?: (report: DocxExportReport, blob: Blob) => void;
+    /** Called when an export fails (the error is also kept in the state). */
+    onError?: (error: Error) => void;
+}
+/**
+ * Framework-agnostic state for an "Export to Word" button: tracks
+ * `isExporting` / `error` / `lastReport` and downloads the `.docx` of the
+ * editor returned by `getSource`. React's `useDocxExport` and Svelte's
+ * `createDocxExport` wrap it.
+ */
+declare class DocxExportController {
+    private readonly getSource;
+    private options;
+    private state;
+    private readonly listeners;
+    private pending;
+    constructor(getSource: () => DocxExportEditorLike | DocxJSONNode | null | undefined, options?: DocxExportControllerOptions);
+    setOptions(options: DocxExportControllerOptions): void;
+    getState: () => DocxExportState;
+    subscribe: (listener: (state: DocxExportState) => void) => (() => void);
+    private setState;
+    /** Builds the `.docx` without downloading it. Resolves with `null` when there is no editor or it fails. */
+    exportBlob(): Promise<{
+        blob: Blob;
+        report: DocxExportReport;
+    } | null>;
+    /** Exports and downloads the document. Resolves with the report, or `null`. */
+    download(fileName?: string): Promise<DocxExportReport | null>;
+}
+declare function createDocxExportController(getSource: () => DocxExportEditorLike | DocxJSONNode | null | undefined, options?: DocxExportControllerOptions): DocxExportController;
+
+/**
+ * Minimal, dependency-free ZIP writer (the counterpart of `readZip`), used by
+ * the DOCX export. Entries are deflated with the platform
+ * `CompressionStream("deflate-raw")` when it exists (modern browsers,
+ * Node ≥ 18) and stored otherwise, or when deflating does not make them
+ * smaller. Names are written as UTF-8 (flag bit 11). No ZIP64: archives are
+ * limited to 65 535 entries and 4 GiB.
+ */
+interface ZipWriteEntry {
+    /** Entry path with `/` separators; must be relative and free of `..`. */
+    name: string;
+    /** Strings are encoded as UTF-8. */
+    data: Uint8Array | string;
+}
+interface ZipWriteOptions {
+    /**
+     * `"auto"` (default) deflates when `CompressionStream` is available,
+     * `"store"` never compresses.
+     */
+    compression?: "auto" | "store";
+    /**
+     * Modification time written for every entry (default 1980-01-01, the DOS
+     * epoch, so the output is deterministic).
+     */
+    modified?: Date;
+}
+/** Raw deflate with `CompressionStream`, or `null` when it is unavailable. */
+declare function deflateRaw(data: Uint8Array): Promise<Uint8Array | null>;
+/** Writes a ZIP archive. Throws on unsafe or duplicate names and oversized archives. */
+declare function writeZip(entries: readonly ZipWriteEntry[], options?: ZipWriteOptions): Promise<Uint8Array>;
+
+/** Removes characters that are not allowed in XML 1.0 documents. */
+declare function stripInvalidXmlChars(value: string): string;
+/** Escapes text for XML element content (`&`, `<`, `>`), dropping invalid characters. */
+declare function escapeXmlText(value: string): string;
+/**
+ * Escapes a value for a double- or single-quoted XML attribute. White space
+ * other than spaces is written as character references, because attribute
+ * value normalisation would otherwise turn tabs and newlines into spaces.
+ */
+declare function escapeXmlAttr(value: string): string;
+type XmlAttrs = Record<string, string | number | undefined | null | false>;
+/**
+ * A small string-building XML writer; every attribute value and text node is
+ * escaped. Element names are trusted (always literals in this codebase).
+ */
+declare class XmlWriter {
+    private parts;
+    /** `declaration: false` writes a fragment (e.g. one paragraph). */
+    constructor(declaration?: boolean);
+    open(name: string, values?: XmlAttrs): this;
+    empty(name: string, values?: XmlAttrs): this;
+    close(name: string): this;
+    text(value: string): this;
+    /** `<name attrs>text</name>`. */
+    leaf(name: string, values: XmlAttrs | undefined, text: string): this;
+    /** `<name w:val="value"/>`. */
+    val(name: string, value: string | number): this;
+    /** Appends markup produced by another writer. */
+    raw(markup: string): this;
+    toString(): string;
+}
+
+export { DOCX_ANONYMOUS_AUTHOR, DOCX_EXPORT_MIME_TYPE, type DocxCommentSource, DocxExportController, type DocxExportControllerOptions, type DocxExportEditorLike, type DocxExportIssue, type DocxExportIssueKind, type DocxExportOptions, type DocxExportReport, type DocxExportResult, type DocxExportState, type DocxJSONMark, type DocxJSONNode, type DocxPackagePart, type XmlAttrs, XmlWriter, type ZipWriteEntry, type ZipWriteOptions, createDocxExportController, createDocxParts, deflateRaw, docxFileName, downloadBlob, escapeXmlAttr, escapeXmlText, exportDocx, exportDocxBlob, stripInvalidXmlChars, writeZip };