@p10node/office-engine 0.0.0 → 0.1.1

package/dist/types/collab/xlsx-ops.d.ts

@@ -0,0 +1,72 @@
+/** XLSX collaboration operations (shared by the main-thread adapter and the worker) + their transforms. */
+import type { CellInput, FindOptions, FmtPatch, Range, SheetOp } from '../core/xlsx/types';
+/** sheets are addressed by part path: indexes move when sheets are added / reordered */
+export type PBookOp = {
+    op: 'add';
+    name?: string;
+    after?: string;
+} | {
+    op: 'rename';
+    path: string;
+    name: string;
+} | {
+    op: 'delete';
+    path: string;
+} | {
+    op: 'move';
+    path: string;
+    to: number;
+};
+export type XOp = {
+    t: 'set';
+    id: string;
+    sheet: string;
+    cells: CellInput[];
+} | {
+    t: 'fmt';
+    id: string;
+    sheet: string;
+    range: Range;
+    patch: FmtPatch;
+} | {
+    t: 'sheet';
+    id: string;
+    sheet: string;
+    op: SheetOp;
+} | {
+    t: 'replace';
+    id: string;
+    sheet: string;
+    query: string;
+    by: string;
+    opts?: FindOptions;
+    at?: {
+        r: number;
+        c: number;
+    };
+} | {
+    t: 'book';
+    id: string;
+    op: PBookOp;
+}
+/** sets the cells changed by op `target` back to their state before (`prev`) or after (`next`) it */
+ | {
+    t: 'revert';
+    id: string;
+    target: string;
+    which: 'prev' | 'next';
+};
+export declare const STRUCTURAL: Set<"colWidth" | "deleteCols" | "deleteRows" | "fill" | "freeze" | "gridlines" | "hideCols" | "hideRows" | "insertCols" | "insertRows" | "merge" | "rowHeight" | "sort" | "unmerge">;
+export declare const isStructural: (o: XOp) => boolean;
+/** index after `n` items were inserted (n > 0) or deleted (n < 0) at `at`; null when deleted */
+export declare function shiftIdx(x: number, at: number, n: number): number | null;
+/** inclusive span [a, b] after an insert / delete; null when entirely deleted */
+export declare function shiftSpan(a: number, b: number, at: number, n: number): [number, number] | null;
+/** `op` adjusted to apply after `prior` (deterministic) */
+export declare function transformX(op: XOp, prior: XOp): XOp | null;
+export declare function footprint(op: XOp): {
+    sheet: string;
+    range: Range;
+} | null;
+/** whether remote ops interact with pending local ones (→ rebase) */
+export declare function conflictsX(pending: XOp[], remote: XOp[]): boolean;

package/dist/types/collab/xlsx-worker.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Worker side of XLSX collaboration: runs operations on the XlsxEditor without its undo
+ * history, keeping one exact record per applied operation (for rebasing and shared undo).
+ */
+import type { XlsxEditor } from '../core/xlsx/editor';
+import type { SheetProgress, XlsxEditResult } from '../core/xlsx/types';
+import type { XlsxWorkbook } from '../core/xlsx/workbook';
+import { type XOp } from './xlsx-ops';
+export declare class XlsxCollabWorker {
+    private ed;
+    private wb;
+    private emit;
+    private recs;
+    /** op id → record of its latest application */
+    private byOp;
+    private seq;
+    constructor(ed: XlsxEditor, wb: XlsxWorkbook, emit: (p: SheetProgress) => void);
+    private index;
+    private sheet;
+    /** forgets the records of a sheet (null: all), whose cell keys / indexes changed under them */
+    private dropSheet;
+    apply(op: XOp): Promise<{
+        res: XlsxEditResult | null;
+        rec: number | null;
+    }>;
+    private run;
+    /** exactly undoes an applied operation (rebase) */
+    revert(id: number): Promise<XlsxEditResult | null>;
+}

package/dist/types/collab/xlsx.d.ts

@@ -0,0 +1,51 @@
+/**
+ * XLSX collaboration (main thread): turns the view's worker calls into shared operations.
+ * Cell edits, formatting, layout, fill / sort / replace are applied optimistically; inserting /
+ * deleting rows or columns and sheet-list changes wait for the hub's order. Undo / redo only
+ * touch the local user's own operations (shared as `revert` operations).
+ */
+import type { DocumentClient } from '../core/worker/client';
+import type { Methods } from '../core/worker/protocol';
+import type { Range } from '../core/xlsx/types';
+import type { Adapter, ApplyResult } from './session';
+import { type XOp } from './xlsx-ops';
+export interface XlsxPresence {
+    k: 'xlsx';
+    /** sheet part path */
+    sheet: string;
+    /** selected range and active cell */
+    range: Range;
+    ar: number;
+    ac: number;
+}
+/** what XlsxView publishes about the local selection */
+export interface XlsxLocalSel {
+    sheet: number;
+    range: Range;
+    ar: number;
+    ac: number;
+}
+export declare class XlsxCollab implements Adapter<XOp> {
+    private client;
+    submit?: (op: XOp) => Promise<unknown>;
+    nextId?: () => string;
+    onPresence?: (p: XlsxPresence) => void;
+    private undoStack;
+    private redoStack;
+    private offLocal;
+    constructor(client: DocumentClient);
+    dispose(): void;
+    private get meta();
+    private path;
+    private id;
+    captures(method: keyof Methods): boolean;
+    intercept(method: keyof Methods, args: unknown[]): Promise<unknown> | undefined;
+    private pbook;
+    private local;
+    private history;
+    transform(op: XOp, prior: XOp): XOp | null;
+    conflicts(pending: XOp[], remote: XOp[]): boolean;
+    pessimistic(op: XOp): boolean;
+    apply(op: XOp, kind: 'local' | 'replay' | 'remote'): Promise<ApplyResult>;
+    revert(undo: unknown): Promise<void>;
+}

package/dist/types/core/color.d.ts

@@ -0,0 +1,25 @@
+import { type XEl } from './xml';
+import type { Theme } from './theme';
+export type RGB = [number, number, number];
+export declare function hexToRgb(hex: string): RGB;
+export declare function rgbToHex([r, g, b]: RGB): string;
+export declare function rgbToHsl([r, g, b]: RGB): [number, number, number];
+export declare function hslToRgb([h, s, l]: [number, number, number]): RGB;
+/** Excel/Word style tint (-1..1) applied in HSL luminance. */
+export declare function applyTint(hex: string, tint: number): string;
+export interface ColorCtx {
+    theme?: Theme;
+    /** pptx clrMap: bg1→lt1 … */
+    clrMap?: Record<string, string>;
+    /** Placeholder color for style matrix references. */
+    phClr?: string;
+}
+export declare const COLOR_TAGS: Set<string>;
+/** Resolves a DrawingML color element (srgbClr, schemeClr, …) to a CSS color. */
+export declare function drawingColor(el: XEl, ctx: ColorCtx): string | undefined;
+/** First color child of a fill-ish element (solidFill, fgClr, …). */
+export declare function colorOf(parent: XEl | undefined, ctx: ColorCtx): string | undefined;
+export declare const INDEXED: string[];
+/** SpreadsheetML <color rgb|theme|indexed tint>. */
+export declare function sheetColor(el: XEl | undefined, theme: Theme | undefined, indexed?: string[]): string | undefined;
+export declare function customIndexed(stylesRoot: XEl | undefined): string[];

package/dist/types/core/convert.d.ts

@@ -0,0 +1,29 @@
+import type { RunSet } from './docx/types';
+/** Separator of a delimited text file: tab, semicolon (European CSV) or comma. */
+export declare function detectSeparator(text: string): string;
+/** RFC 4180 parser (quoted fields, escaped quotes, CRLF / LF, newlines inside quotes). */
+export declare function parseCsv(text: string, sep?: string): string[][];
+/**
+ * Builds a one-sheet workbook from rows of text.
+ * `decimalComma`: "12,5" is a number (semicolon-separated files from comma-decimal locales).
+ */
+export declare function rowsToXlsx(rows: string[][], sheetName?: string, decimalComma?: boolean): Promise<Blob>;
+export interface ImportRun {
+    text: string;
+    set?: RunSet;
+    href?: string;
+}
+export interface ImportPara {
+    runs: ImportRun[];
+    /** heading level 1-6 */
+    heading?: number;
+    list?: 'bullet' | 'number';
+}
+/** One paragraph per line. */
+export declare function textToParas(text: string): ImportPara[];
+/** Small CommonMark subset → HTML: headings, paragraphs, lists, quotes, code blocks, rules, tables. */
+export declare function markdownToHtml(md: string): string;
+/** Builds a document (Letter, 1" margins, Calibri 11) from paragraphs of formatted runs. */
+export declare function parasToDocx(paras: ImportPara[]): Promise<Blob>;
+/** One empty title slide, 16:9, Office theme; layouts: title, title and content, blank. */
+export declare function blankPptx(): Promise<Blob>;

package/dist/types/core/default-worker.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/core/docx/numbering.d.ts

@@ -0,0 +1,33 @@
+import type { Theme } from '../theme';
+import { type XEl } from '../xml';
+import type { ParaStyle, RunStyle } from './types';
+export interface Level {
+    start: number;
+    fmt: string;
+    text: string;
+    ps: ParaStyle;
+    rs: RunStyle;
+    isLgl: boolean;
+    suff: string;
+    restart?: number;
+}
+export declare function formatNumber(n: number, fmt: string): string;
+export declare class Numbering {
+    private abstracts;
+    private nums;
+    private counters;
+    constructor(root: XEl | undefined, theme: Theme);
+    reset(): void;
+    /** First list instance whose level 0 is a bullet / a number, without overrides. */
+    findList(kind: 'bullet' | 'number'): string | undefined;
+    ids(): {
+        abstract: number;
+        num: number;
+    };
+    level(numId: string, ilvl: number): Level | undefined;
+    /** Advances the counter for (numId, ilvl) and returns the marker text. */
+    next(numId: string, ilvl: number): {
+        text: string;
+        level: Level;
+    } | undefined;
+}

package/dist/types/core/docx/parser.d.ts

@@ -0,0 +1,126 @@
+import { OpcPackage, type Rels } from '../opc';
+import { type Theme } from '../theme';
+import { type XEl } from '../xml';
+import { Numbering } from './numbering';
+import { StyleSheet, type NumPr } from './styles';
+import type { Block, DocxMeta, ListMarker, PageSetup, ParaStyle, RunSet, RunStyle, SrcRef, Table } from './types';
+export type Layer = {
+    ps: ParaStyle;
+    rs: RunStyle;
+};
+export interface ParaRecord {
+    layer?: Layer;
+    num?: NumPr;
+    ro: boolean;
+    sid: string;
+    lst?: 'bullet' | 'number';
+    marker?: ListMarker;
+}
+/** run ordinal → original source (reconversion of generated XML) */
+export interface GenRun {
+    src?: SrcRef;
+    d?: RunSet;
+}
+export interface ConvHooks {
+    /** registers an editable paragraph; returns its id */
+    para?(el: XEl, rec: ParaRecord): number | undefined;
+    forced?: {
+        pid: number;
+        root: XEl;
+        map: GenRun[];
+        layer?: Layer;
+        marker?: ListMarker;
+        rec?: ParaRecord;
+    };
+    /** body item currently being converted (tables remember it) */
+    item?: () => number;
+}
+export declare function pageSetup(sectPr: XEl | undefined): PageSetup;
+/** Runs of a paragraph in preorder (the ordinal is the run's identity for write-back). */
+export declare function collectRuns(p: XEl): Map<XEl, number>;
+/** Paragraphs of a body item (root included) in preorder. */
+export declare function collectParas(roots: XEl[], into?: Map<XEl, number>): Map<XEl, number>;
+export declare function markerOf(numbering: Numbering, num: NumPr, markRs: RunStyle): {
+    marker: ListMarker;
+    lst: 'bullet' | 'number';
+} | undefined;
+export declare class Converter {
+    private styles;
+    private numbering;
+    private theme;
+    private rels;
+    private hooks;
+    private fields;
+    private tableLayer?;
+    private boxDepth;
+    private tableDepth;
+    private cur?;
+    constructor(styles: StyleSheet, numbering: Numbering, theme: Theme, rels: Rels, hooks?: ConvHooks);
+    blocks(el: XEl, out: Block[]): void;
+    paragraph(el: XEl, out: Block[]): void;
+    /** source reference + user formatting of a run element */
+    private srcOf;
+    private inlines;
+    private run;
+    private target;
+    private boxBlocks;
+    private drawing;
+    private vml;
+    table(el: XEl): Table;
+    private tableInner;
+}
+export interface DocxStreamCallbacks {
+    onBlocks(blocks: Block[]): void;
+    onMeta(meta: DocxMeta): void;
+    onProgress?(loaded: number, total: number): void;
+    signal?: AbortSignal;
+    /** Hold blocks until this much time passed so small docs render in one go (ms). */
+    initialHoldMs?: number;
+}
+export interface PInfo extends ParaRecord {
+    item: number;
+    ord: number;
+}
+export declare class DocxDocument {
+    readonly pkg: OpcPackage;
+    readonly mainPath: string;
+    rels: Rels;
+    readonly styles: StyleSheet;
+    numbering: Numbering;
+    readonly theme: Theme;
+    /** raw XML of each body child (exact source) */
+    items: string[];
+    prefix: string;
+    suffix: string;
+    info: Map<number, PInfo>;
+    /** where each original paragraph lives in the source (never changes) */
+    origLoc: Map<number, {
+        item: number;
+        ord: number;
+    }>;
+    /** original paragraph id per (item, ord) */
+    ordPid: Map<string, number>;
+    itemParas: Map<number, number[]>;
+    /** (item:ord) → paragraph ids now standing in for that original paragraph */
+    groups: Map<string, number[]>;
+    genXml: Map<number, string>;
+    /** whole body items replaced by the editor (regenerated tables; '' = deleted) */
+    itemXml: Map<number, string>;
+    private nextPid;
+    private captured;
+    private edited;
+    private constructor();
+    static open(pkg: OpcPackage, mainPath: string): Promise<DocxDocument>;
+    get dirty(): boolean;
+    markEdited(): void;
+    private headerFooter;
+    stream(cb: DocxStreamCallbacks): Promise<void>;
+    get ready(): boolean;
+    /** Re-converts generated paragraph XML into blocks (styles, list levels resolved by the engine). */
+    reconvert(pid: number, xml: string, map: GenRun[], layer: Layer | undefined, marker?: ListMarker): {
+        blocks: Block[];
+        rec: ParaRecord;
+    };
+    /** Recomputes list markers in document order; returns changed ones. */
+    recomputeMarkers(): Map<number, PInfo>;
+}

package/dist/types/core/docx/spec.d.ts

@@ -0,0 +1,4 @@
+import type { Inline, Paragraph, ParaSpec, SpecRun } from './types';
+export declare function inlineSpec(x: Inline): SpecRun;
+/** Write-back spec for a paragraph (all page-break parts sharing one pid). */
+export declare function paraSpec(parts: Paragraph[]): ParaSpec;

package/dist/types/core/docx/styles.d.ts

@@ -0,0 +1,63 @@
+import type { Theme } from '../theme';
+import { type XEl } from '../xml';
+import type { Border, CanonStyle, ParaStyle, RunStyle, StyleInfo } from './types';
+export declare const HIGHLIGHT: Record<string, string>;
+export declare const hexColor: (v: string | undefined) => string | undefined;
+export declare function shading(el: XEl | undefined): string | undefined;
+export declare function border(el: XEl | undefined): Border | undefined | null;
+export declare const borderCss: (b: Border | null | undefined) => string | undefined;
+export declare function readRPr(rPr: XEl | undefined, theme: Theme): RunStyle;
+export interface NumPr {
+    numId: string;
+    ilvl: number;
+}
+export interface PPrResult {
+    ps: ParaStyle;
+    styleId?: string;
+    numPr?: NumPr;
+    sectPr?: XEl;
+}
+export declare function readPPr(pPr: XEl | undefined): PPrResult;
+export declare const merge: <T extends object>(...parts: (T | undefined)[]) => T;
+export interface ResolvedParaStyle {
+    ps: ParaStyle;
+    rs: RunStyle;
+    numPr?: NumPr;
+}
+export interface CondFormat {
+    rs: RunStyle;
+    shd?: string;
+}
+export interface ResolvedTableStyle {
+    ps: ParaStyle;
+    rs: RunStyle;
+    borders: Record<string, Border | null | undefined>;
+    cellMar: Partial<Record<'top' | 'left' | 'bottom' | 'right', number>>;
+    shd?: string;
+    cond: Record<string, CondFormat>;
+}
+export declare class StyleSheet {
+    private theme;
+    private defs;
+    private paraCache;
+    private charCache;
+    private tblCache;
+    defaultPara?: string;
+    defaultTable?: string;
+    docRs: RunStyle;
+    docPs: ParaStyle;
+    constructor(root: XEl | undefined, theme: Theme);
+    /** registers a style element added to styles.xml */
+    add(s: XEl): void;
+    /** ids of the built-in paragraph styles present in the document (matched by name, any locale id) */
+    canonical(): Partial<Record<CanonStyle, string>>;
+    has(id: string): boolean;
+    /** Paragraph styles offered in the style picker (Normal, Title, Heading 1…). */
+    quickStyles(): StyleInfo[];
+    private chain;
+    para(id: string | undefined): ResolvedParaStyle;
+    char(id: string | undefined): RunStyle;
+    table(id: string | undefined): ResolvedTableStyle;
+}
+export declare function readTableBorders(el: XEl | undefined): Record<string, Border | null | undefined>;
+export declare function readMargins(el: XEl | undefined): Partial<Record<'top' | 'left' | 'bottom' | 'right', number>>;