@p10node/office-engine 0.0.0 → 0.1.1

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

@@ -0,0 +1,325 @@
+/** All lengths in points unless stated otherwise. */
+export interface RunStyle {
+    b?: boolean;
+    i?: boolean;
+    /** underline kind ('single', 'double', …) or 'none' */
+    u?: string;
+    strike?: boolean;
+    dstrike?: boolean;
+    color?: string;
+    sz?: number;
+    font?: string;
+    hl?: string;
+    shd?: string;
+    va?: 'sup' | 'sub';
+    caps?: boolean;
+    smallCaps?: boolean;
+    vanish?: boolean;
+    spacing?: number;
+}
+export interface Border {
+    w: number;
+    style: string;
+    color: string;
+}
+export interface ParaStyle {
+    align?: 'left' | 'center' | 'right' | 'justify';
+    indL?: number;
+    indR?: number;
+    /** positive: first line indent; negative: hanging */
+    indFirst?: number;
+    before?: number;
+    after?: number;
+    line?: number;
+    lineRule?: 'auto' | 'exact' | 'atLeast';
+    shd?: string;
+    bTop?: Border;
+    bBottom?: Border;
+    bLeft?: Border;
+    bRight?: Border;
+    keepNext?: boolean;
+    pageBreakBefore?: boolean;
+    outline?: number;
+    contextual?: boolean;
+}
+/** [paragraph id, run ordinal] of the source run in the original XML */
+export type SrcRef = [number, number];
+/** Direct formatting changed by the user (written back as explicit run properties). */
+export interface RunSet {
+    b?: boolean;
+    i?: boolean;
+    u?: string;
+    strike?: boolean;
+    color?: string | null;
+    sz?: number;
+    /** raw font name */
+    font?: string;
+    hl?: string | null;
+    va?: 'sup' | 'sub' | null;
+}
+/**
+ * Inline content. Tabs and line breaks are carried as '\t' / '\n' inside text.
+ * Everything that isn't 'text' counts as one character when editing.
+ */
+export type Inline = {
+    t: 'text';
+    text: string;
+    s: RunStyle;
+    href?: string;
+    lk?: string;
+    src?: SrcRef;
+    d?: RunSet;
+} | {
+    t: 'img';
+    target: string;
+    w: number;
+    h: number;
+    alt?: string;
+    href?: string;
+    src?: SrcRef;
+    rid?: string;
+    resized?: boolean;
+    /** alt text changed by the user */
+    altSet?: boolean;
+    /** picture replaced (rid points to the new image part) */
+    repl?: boolean;
+} | {
+    t: 'field';
+    kind: 'PAGE' | 'NUMPAGES';
+    s: RunStyle;
+    src?: SrcRef;
+} | {
+    t: 'box';
+    w: number;
+    h: number;
+    blocks: Block[];
+    fill?: string;
+    border?: string;
+    src?: SrcRef;
+} | {
+    t: 'shape';
+    w: number;
+    h: number;
+    label?: string;
+    src?: SrcRef;
+} | {
+    t: 'ref';
+    text: string;
+    s: RunStyle;
+    src?: SrcRef;
+};
+export interface ListMarker {
+    text: string;
+    s: RunStyle;
+    /** marker followed by tab (default) */
+    tab: boolean;
+}
+export interface Paragraph {
+    t: 'p';
+    ps: ParaStyle;
+    runs: Inline[];
+    marker?: ListMarker;
+    /** font size of the paragraph mark, for empty paragraph height */
+    markSz?: number;
+    markFont?: string;
+    /** explicit page break before this paragraph (from w:br type=page or pageBreakBefore) */
+    pb?: boolean;
+    /** paragraph id (editable paragraphs only); split parts share it */
+    pid?: number;
+    /** read-only (inside fields spanning paragraphs, text boxes, nested tables…) */
+    ro?: boolean;
+    /** paragraph style id */
+    sid?: string;
+    /** list kind + level when numbered */
+    lst?: 'bullet' | 'number';
+    ilvl?: number;
+    /** template paragraph (original pid) */
+    from?: number;
+    /** original paragraphs whose bookmarks/comments this one carries */
+    orig?: number[];
+    /** paragraph-level changes */
+    pd?: ParaDirty;
+    /** changed since load */
+    edited?: boolean;
+    /** keeps the template's section break */
+    keepSect?: boolean;
+    /** render version (bumped to force DOM rebuild after IME composition) */
+    ver?: number;
+    /** formatting for text typed into this (empty) paragraph */
+    caret?: Inline;
+}
+export interface ParaDirty {
+    style?: string;
+    align?: 'left' | 'center' | 'right' | 'justify';
+    list?: 'bullet' | 'number' | 'none';
+    ilvl?: number;
+    indL?: number;
+    /** line spacing multiple (1, 1.15, 1.5, 2…) */
+    line?: number;
+    /** spacing before / after in pt */
+    before?: number;
+    after?: number;
+    pageBreak?: boolean;
+}
+export type SpecRun = {
+    text: string;
+    src?: SrcRef;
+    set?: RunSet;
+    lk?: string;
+} | {
+    obj: 'copy';
+    src: SrcRef;
+    size?: [number, number];
+    alt?: string;
+    rid?: string;
+} | {
+    obj: 'image';
+    rid: string;
+    w: number;
+    h: number;
+    name?: string;
+    alt?: string;
+} | {
+    obj: 'field';
+    kind: 'PAGE' | 'NUMPAGES';
+    set?: RunSet;
+};
+export interface ParaSpec {
+    pid: number;
+    from: number;
+    orig?: number[];
+    pd?: ParaDirty;
+    /** page-break separated parts */
+    parts: SpecRun[][];
+    pristine?: boolean;
+    keepSect?: boolean;
+}
+export interface CellSpec {
+    src?: [number, number];
+    colSpan: number;
+    rowSpan: number;
+    paras: ParaSpec[];
+    shd?: string;
+}
+export interface TableSpec {
+    tid: number;
+    item?: number;
+    cols: number[];
+    rows: {
+        src?: number;
+        cells: CellSpec[];
+    }[];
+}
+export interface TableOp {
+    tid: number;
+    item?: number;
+    /** paragraph the (new) table follows */
+    anchor?: number;
+    /** null deletes the table */
+    spec: TableSpec | null;
+}
+export interface EditOp {
+    anchor: number;
+    list: ParaSpec[];
+    remove?: number[];
+    /** return re-converted blocks (needed after style/list changes) */
+    want?: boolean;
+}
+export interface EditResult {
+    blocks: Record<number, Block[]>;
+    markers: Record<number, {
+        text: string;
+        s: RunStyle;
+        tab: boolean;
+        lst?: 'bullet' | 'number';
+    } | null>;
+}
+/** built-in paragraph styles the picker always offers (created on first use when missing) */
+export type CanonStyle = 'normal' | 'title' | 'subtitle' | 'h1' | 'h2' | 'h3' | 'h4' | 'h5' | 'h6';
+export interface StyleInfo {
+    id: string;
+    name: string;
+    next?: string;
+    canon?: CanonStyle;
+    /** heading level 0-8 (outline) */
+    outline?: number;
+    /** run look of the style, for the style picker */
+    preview?: {
+        b?: boolean;
+        i?: boolean;
+        color?: string;
+        sz?: number;
+        font?: string;
+    };
+}
+export interface CellBorders {
+    t?: string;
+    r?: string;
+    b?: string;
+    l?: string;
+}
+export interface TableCell {
+    blocks: Block[];
+    /** [row, tc] index in the original table XML (template for cell properties) */
+    src?: [number, number];
+    colSpan: number;
+    rowSpan: number;
+    w?: number;
+    shd?: string;
+    vAlign?: 'top' | 'middle' | 'bottom';
+    borders: CellBorders;
+    pad: [number, number, number, number];
+}
+export interface TableRow {
+    cells: TableCell[];
+    /** original row index */
+    src?: number;
+    h?: number;
+    exact?: boolean;
+    header?: boolean;
+}
+export interface Table {
+    t: 'tbl';
+    /** body item index of an original top-level table */
+    item?: number;
+    /** set once the table is regenerated by the editor (new or structurally changed) */
+    tid?: number;
+    cols: number[];
+    rows: TableRow[];
+    align?: 'left' | 'center' | 'right';
+    indL?: number;
+    w?: number;
+}
+export interface PageSetup {
+    w: number;
+    h: number;
+    mt: number;
+    mr: number;
+    mb: number;
+    ml: number;
+    header: number;
+    footer: number;
+}
+export interface SectionBreak {
+    t: 'sect';
+    page: PageSetup;
+    /** 'nextPage' | 'continuous' | 'evenPage' | 'oddPage' */
+    kind: string;
+}
+export type Block = Paragraph | Table | SectionBreak;
+export interface DocxMeta {
+    page: PageSetup;
+    /** quick paragraph styles for the style picker */
+    styles?: StyleInfo[];
+    header?: Block[];
+    footer?: Block[];
+    firstHeader?: Block[];
+    firstFooter?: Block[];
+    titlePg?: boolean;
+    /** body default font (CSS) and size */
+    font?: string;
+    sz?: number;
+    /** final page setup known (end of document reached) */
+    final?: boolean;
+}
+export declare const DEFAULT_PAGE: PageSetup;

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

@@ -0,0 +1,35 @@
+import { type RChild, type RNode } from '../raw';
+import type { DocxDocument, GenRun } from './parser';
+import type { CanonStyle, EditOp, EditResult, ParaSpec, StyleInfo, TableOp, TableSpec } from './types';
+export declare const DOCX_MIME = "application/vnd.openxmlformats-officedocument.wordprocessingml.document";
+interface ParaLoc {
+    node: RNode;
+    list: RChild[];
+    index: number;
+}
+/** Paragraphs of a body item in the same preorder the converter uses. */
+export declare function collectParasRaw(nodes: RChild[]): ParaLoc[];
+export declare function collectRunsRaw(p: RNode): RNode[];
+export declare function origPara(doc: DocxDocument, pid: number): RNode | undefined;
+/** Id of a built-in paragraph style (Title, Heading 1…), added to styles.xml when the document lacks it. */
+export declare function ensureStyle(doc: DocxDocument, kind: CanonStyle): Promise<{
+    id: string;
+    styles: StyleInfo[];
+}>;
+export declare function genParagraph(doc: DocxDocument, spec: ParaSpec): Promise<{
+    xml: string;
+    map: GenRun[];
+}>;
+export declare function applyEdit(doc: DocxDocument, op: EditOp): Promise<EditResult>;
+/** Adds an image part to the document; returns its relationship id and part path. */
+export declare function addImage(doc: DocxDocument, bytes: Uint8Array, ext: string): Promise<{
+    rid: string;
+    path: string;
+}>;
+/** External hyperlink relationship; returns the run link key ('r:rIdN'). */
+export declare function addLink(doc: DocxDocument, url: string): Promise<string>;
+/** Regenerates a whole table from the editor model, reusing original row/cell properties. */
+export declare function genTable(doc: DocxDocument, spec: TableSpec): Promise<string>;
+export declare function applyTable(doc: DocxDocument, op: TableOp): Promise<void>;
+export declare function saveDocx(doc: DocxDocument): Promise<Blob>;
+export {};

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

@@ -0,0 +1 @@
+export declare function cssFont(name: string | undefined): string | undefined;

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

@@ -0,0 +1,15 @@
+import './default-worker';
+export * from './source';
+export { ZipArchive } from './zip';
+export { SaxParser, TreeBuilder, parseXml, parseXmlStream, type XEl, type SaxHandler } from './xml';
+export { OpcPackage, type DocKind } from './opc';
+export { DocxDocument } from './docx/parser';
+export type * from './docx/types';
+export { XlsxWorkbook, colName, colIndex } from './xlsx/workbook';
+export { formatValue, formatGeneral, serialToDate } from './xlsx/numfmt';
+export type * from './xlsx/types';
+export { PptxPresentation } from './pptx/parser';
+export type * from './pptx/types';
+export { Engine } from './worker/engine';
+export { DocumentClient, setDefaultWorker, type OpenOptions } from './worker/client';
+export type { Events, Methods, OpenResult } from './worker/protocol';

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

@@ -0,0 +1,56 @@
+import { ZipArchive } from './zip';
+import { type PartData } from './zipwrite';
+import { type XEl } from './xml';
+export type DocKind = 'docx' | 'xlsx' | 'pptx';
+export interface Rel {
+    id: string;
+    type: string;
+    target: string;
+    external: boolean;
+}
+export type Rels = Map<string, Rel>;
+export declare function mimeOf(path: string): string;
+/** Browser-renderable image? (EMF/WMF/TIFF are not.) */
+export declare function isWebImage(path: string): boolean;
+export declare function dirOf(part: string): string;
+export declare function resolvePath(baseDir: string, target: string): string;
+/** Inverse of resolvePath: target of `abs` relative to directory `fromDir`. */
+export declare function relativeTarget(fromDir: string, abs: string): string;
+export declare function relsPathFor(part: string): string;
+export declare class OpcPackage {
+    readonly zip: ZipArchive;
+    private relsCache;
+    private xmlCache;
+    private contentTypes?;
+    /** edited parts: normalized path → { path, data } (data null = deleted) */
+    private changes;
+    constructor(zip: ZipArchive);
+    has(path: string): boolean;
+    get dirty(): boolean;
+    /** Current text of a part (edited version if any). */
+    text(path: string): Promise<string>;
+    /** Decompressed stream of the current version of a part (edited parts included). */
+    stream(path: string, onRaw?: (consumed: number, total: number) => void): Promise<ReadableStream<Uint8Array>>;
+    setPart(path: string, data: PartData | null): void;
+    /** Builds the edited package; unchanged entries are copied without recompression. */
+    save(type: string): Promise<Blob>;
+    /** Adds a relationship from `part` to `target` (absolute part path); returns its id. */
+    addRel(part: string, type: string, target: string, external?: boolean): Promise<string>;
+    removeRelsTo(part: string, target: string): Promise<void>;
+    /** Ensures a <Default Extension=…> entry exists (for new media types). */
+    ensureDefaultType(ext: string, contentType: string): Promise<void>;
+    /** Free part name like `word/media/image7.png`. */
+    freeName(dir: string, base: string, ext: string): string;
+    setContentType(partName: string, contentType: string | null): Promise<void>;
+    /** Parsed XML part (cached). Missing parts resolve to undefined. */
+    xml(path: string, cache?: boolean): Promise<XEl | undefined>;
+    rels(part: string): Promise<Rels>;
+    contentType(path: string): Promise<string | undefined>;
+    blob(path: string): Promise<Blob>;
+    mainPart(): Promise<{
+        path: string;
+        kind: DocKind;
+    }>;
+}
+export declare function relOfType(rels: Rels, suffix: string): Rel | undefined;
+export declare function relsOfType(rels: Rels, suffix: string): Rel[];

package/dist/types/core/pptx/edit.d.ts

@@ -0,0 +1,10 @@
+import type { PptxPresentation } from './parser';
+import type { PresentationMeta, ShapeOp, SlideModel, SlideOp } from './types';
+/** undoes / redoes the last shape edit; returns the slide index and its new model */
+export declare function undoShapes(pres: PptxPresentation, redo?: boolean): Promise<{
+    index: number;
+    model: SlideModel;
+} | null>;
+export declare function addSlideImage(pres: PptxPresentation, index: number, bytes: Uint8Array, ext: string): Promise<string>;
+export declare function shapeOps(pres: PptxPresentation, index: number, ops: ShapeOp[]): Promise<SlideModel>;
+export declare function slideOp(pres: PptxPresentation, op: SlideOp): Promise<PresentationMeta>;

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

@@ -0,0 +1,52 @@
+import { OpcPackage } from '../opc';
+import { type XEl } from '../xml';
+import type { PParaSpec, PresentationMeta, SlideModel } from './types';
+export declare const PPTX_MIME = "application/vnd.openxmlformats-officedocument.presentationml.presentation";
+interface GenPara {
+    k?: number;
+    runs: ([number, number] | undefined)[];
+}
+export declare class PptxPresentation {
+    readonly pkg: OpcPackage;
+    readonly mainPath: string;
+    private defaultTextStyle;
+    private masters;
+    private layouts;
+    private tableStyles?;
+    readonly meta: PresentationMeta;
+    private constructor();
+    static open(pkg: OpcPackage, mainPath: string): Promise<PptxPresentation>;
+    private part;
+    private master;
+    private layout;
+    private getTableStyles;
+    slide(index: number): Promise<SlideModel>;
+    get defaults(): XEl | undefined;
+    private genMaps;
+    /** structural edits (shapes, slides) */
+    touched: boolean;
+    /** shape edits (slide XML before / after) for undo; text edits drop the entries of their slide */
+    undoStack: {
+        path: string;
+        before: string;
+        after: string;
+    }[];
+    redoStack: {
+        path: string;
+        before: string;
+        after: string;
+    }[];
+    private originals;
+    private lateShapes;
+    /**
+     * Takes the slide XML that text edits use as template (their run references point into it).
+     * Done lazily on the first text edit; collaboration takes it up front so every client uses the same.
+     */
+    keepOriginal(path: string): Promise<void>;
+    genMap(path: string, sid: number): GenPara[] | undefined;
+    get dirty(): boolean;
+    /** Rewrites the paragraphs of shape `sid` on slide `index` and returns the re-rendered slide. */
+    setText(index: number, sid: number, paras: PParaSpec[]): Promise<SlideModel>;
+    save(): Promise<Blob>;
+}
+export {};