@p10node/office-engine 0.0.0-stage → 0.1.0

package/dist/types/react/docx/DocxEditor.d.ts

@@ -0,0 +1,172 @@
+import type { Block, CanonStyle, Paragraph, ParaDirty, ParaStyle, RunSet, RunStyle, StyleInfo } from '../../core/docx/types';
+import type { DocumentClient } from '../../core/worker/client';
+import { RichInput, type ReplaceOpts, type RichHost } from '../edit/input';
+import { type RRun, type Sel } from '../edit/rich';
+export interface DocState {
+    blocks: Block[];
+    heights: WeakMap<Block, number>;
+    dirty: Set<Block>;
+    /** leading blocks measured at least once */
+    frontier: number;
+}
+export interface FormatState {
+    b: boolean;
+    i: boolean;
+    u: boolean;
+    strike: boolean;
+    color?: string;
+    hl?: string;
+    sz?: number;
+    font?: string;
+    align?: string;
+    style?: string;
+    lst?: 'bullet' | 'number';
+    line?: number;
+    va?: 'sup' | 'sub';
+    link?: string;
+    /** caret inside a table cell */
+    inTable: boolean;
+    /** a single image is selected */
+    img?: {
+        w: number;
+        h: number;
+        alt?: string;
+        target: string;
+        pa: string;
+        o: number;
+    };
+    canUndo: boolean;
+    canRedo: boolean;
+}
+/** a model change: contiguous paragraphs replaced, or top-level blocks replaced */
+export type DocxCommit = {
+    kind: 'paras';
+    before: Paragraph[];
+    next: Paragraph[];
+} | {
+    kind: 'blocks';
+    bi: number;
+    before: Block[];
+    next: Block[];
+};
+export declare class DocxEditor implements RichHost<Paragraph> {
+    private client;
+    private st;
+    private changed;
+    readonly input: RichInput;
+    pendingSel: Sel | null;
+    styles: StyleInfo[];
+    private history;
+    private future;
+    private pend;
+    /** next id for new paragraphs / tables (a collaboration session gives each client its own range) */
+    nextPid: number;
+    private inflight;
+    onState?: (s: FormatState | null) => void;
+    /** image selection changed (overlay with resize handles) */
+    onImage?: (img: FormatState['img'] | null) => void;
+    /** style list changed (a built-in style was added to the document) */
+    onStyles?: (styles: StyleInfo[]) => void;
+    shortcut?: (e: KeyboardEvent) => boolean;
+    onDirty?: () => void;
+    /** paint format: run formatting copied from the caret, applied to the next selection */
+    painter: RunSet | null;
+    onPainter?: (on: boolean) => void;
+    /** every model change, after it was mirrored to the worker (collaboration hook) */
+    onCommit?: (c: DocxCommit) => void;
+    constructor(client: DocumentClient, st: DocState, changed: () => void);
+    private container;
+    para(pa: string): Paragraph | undefined;
+    span(a: string, b: string): string[] | null;
+    prev(pa: string): string | undefined;
+    next(pa: string): string | undefined;
+    cmp(a: string, b: string): number;
+    withRuns(p: Paragraph, runs: RRun[]): Paragraph;
+    private origOf;
+    defaultRun(p: Paragraph): Partial<RRun> | undefined;
+    split(p: Paragraph, left: RRun[], right: RRun[], atEnd: boolean): [Paragraph, Paragraph];
+    join(a: Paragraph, b: Paragraph, runs: RRun[]): Paragraph;
+    private splice;
+    replace(pas: string[], next: Paragraph[], sel: Sel, opts?: ReplaceOpts & {
+        history?: boolean;
+        want?: boolean;
+    }): void;
+    /** contiguous blocks sharing `pid` around index `near` */
+    private partsOf;
+    private commit;
+    get busy(): boolean;
+    private locate;
+    private put;
+    private applyResult;
+    /** current address of the first block of `list` (paragraphs by pid, tables by identity), `empty` for an empty list; undefined when gone */
+    private whereNow;
+    /** table undo / redo: paragraphs still in place keep their current text (edited since, maybe by collaborators) */
+    private keepCurrent;
+    undo(): void;
+    redo(): void;
+    get canUndo(): boolean;
+    get canRedo(): boolean;
+    pendingStyle(): Partial<RRun> | undefined;
+    clearPending(): void;
+    private selectedParas;
+    format(s: Partial<RunStyle>, d: RunSet, opts?: {
+        want?: boolean;
+    }): void;
+    toggle(key: 'b' | 'i' | 'u' | 'strike'): void;
+    setFont(name: string): void;
+    setSize(sz: number): void;
+    setColor(c: string | null): void;
+    setHighlight(c: string | null): void;
+    clearFormat(): void;
+    setPara(patch: ParaDirty, optimistic?: Partial<ParaStyle>, sel?: Sel | null): void;
+    toggleList(kind: 'bullet' | 'number'): void;
+    indent(dir: 1 | -1, sel?: Sel | null): void;
+    tab(sel: Sel, shift: boolean): boolean;
+    backspaceAtStart(pa: string, p: Paragraph): boolean;
+    /** content width (pt) of the page, for sizing new tables / images */
+    contentW: number;
+    /** document default font (CSS) / size, shown when a run inherits them */
+    defaultFont?: string;
+    defaultSz?: number;
+    private prevParaPid;
+    private tableSpec;
+    private commitTable;
+    private send;
+    /** Replaces top-level blocks (table insert/delete/restructure) with history + write-back. */
+    replaceBlocks(bi: number, count: number, next: Block[], sel: Sel | null, history?: boolean): void;
+    private emptyPara;
+    insertTable(rowsN: number, colsN: number): void;
+    /** Structural table edit at the caret's cell. */
+    tableOp(kind: 'rowAbove' | 'rowBelow' | 'colLeft' | 'colRight' | 'delRow' | 'delCol' | 'delTable'): void;
+    insertImages(files: Blob[], at?: Sel): Promise<void>;
+    setLink(url: string | null): Promise<void>;
+    /** applies `fn` to the text runs inside the selection */
+    private patchRuns;
+    insertPageBreak(): void;
+    /** scales the selected image (factor) or fits it to the page width */
+    resizeImage(f: number | 'fit'): void;
+    private patchObjects;
+    pasteRich(sel: Sel, data: DataTransfer): boolean;
+    /** applies a built-in style (Title, Heading 1…), creating it in the document when missing */
+    applyCanon(kind: CanonStyle): Promise<void>;
+    /** selects the inline object at (pa, o) */
+    selectObject(pa: string, o: number): void;
+    private imageSel;
+    private patchImage;
+    /** exact size in pt */
+    setImageSize(w: number, h: number): void;
+    /** natural pixel size of the picture → pt, limited to the text width */
+    imageOriginal(nw: number, nh: number): void;
+    setAltText(alt: string): void;
+    replaceImage(file: Blob): Promise<void>;
+    /** deletes the selection (or the selected object) */
+    deleteSelection(): void;
+    insertText(text: string): void;
+    /** copies the caret's character formatting; the next selection receives it */
+    copyFormat(): void;
+    /** applies the copied formatting to the current selection (after the mouse is released) */
+    applyPainter(): boolean;
+    state(sel?: Sel | null): FormatState | null;
+    private emitState;
+    onSelection(sel: Sel | null): void;
+}

package/dist/types/react/docx/DocxToolbar.d.ts

@@ -0,0 +1,18 @@
+import type { StyleInfo } from '../../core/docx/types';
+import type { DocxEditor } from './DocxEditor';
+export interface ImageActions {
+    original: () => void;
+    replace: () => void;
+    alt: () => void;
+    download: () => void;
+}
+export declare function DocxToolbar(props: {
+    editor: DocxEditor;
+    styles: StyleInfo[];
+    onFind: () => void;
+    outline: boolean;
+    onOutline: () => void;
+    painter: boolean;
+    onLink: () => void;
+    image: ImageActions;
+}): import("react").JSX.Element;

package/dist/types/react/docx/DocxView.d.ts

@@ -0,0 +1,8 @@
+import type { DocumentClient } from '../../core/worker/client';
+import { type Zoom } from '../common/ZoomControl';
+export interface DocxViewProps {
+    client: DocumentClient;
+    onStatus?: (s: string) => void;
+    initialZoom?: Zoom;
+}
+export declare function DocxView({ client, onStatus, initialZoom }: DocxViewProps): import("react").JSX.Element;

package/dist/types/react/docx/FindBar.d.ts

@@ -0,0 +1,22 @@
+import { type ReactNode } from 'react';
+export interface Match {
+    pa: string;
+    a: number;
+    b: number;
+    bi: number;
+}
+export declare function FindBar(props: {
+    query: string;
+    index: number;
+    count: number;
+    editable: boolean;
+    onQuery: (q: string) => void;
+    onNav: (d: 1 | -1) => void;
+    onClose: () => void;
+    onReplace: (text: string, all: boolean) => void;
+    placeholder?: string;
+    /** extra controls (match case…) under the search row */
+    options?: ReactNode;
+    /** open with the replace row visible */
+    replace?: boolean;
+}): import("react").JSX.Element;

package/dist/types/react/docx/html.d.ts

@@ -0,0 +1,8 @@
+import type { Inline } from '../../core/docx/types';
+export interface PastedPara {
+    runs: Inline[];
+    heading?: number;
+    list?: 'bullet' | 'number';
+}
+/** Converts clipboard HTML (Word, Google Docs, web pages) into paragraphs of formatted runs. */
+export declare function htmlToParas(html: string): PastedPara[];

package/dist/types/react/docx/render.d.ts

@@ -0,0 +1,24 @@
+import { type CSSProperties } from 'react';
+import type { Block, RunStyle } from '../../core/docx/types';
+import type { DocumentClient } from '../../core/worker/client';
+export interface RenderCtx {
+    client: DocumentClient;
+    /** 0-based page index, -1 while measuring */
+    page: number;
+    pages: number;
+    measuring: boolean;
+    editable: boolean;
+}
+export declare function runCss(s: RunStyle | undefined): CSSProperties;
+/** contextual spacing flags: 'b' drop space before, 'a' drop space after */
+export type Spacing = '' | 'b' | 'a' | 'ba';
+export declare function contextual(p: Block | undefined, prev: Block | undefined, next: Block | undefined): Spacing;
+export interface BlockViewProps {
+    block: Block;
+    ctx: RenderCtx;
+    /** editable address (top-level: block index; table: block index used as prefix) */
+    pa?: string;
+    sp?: Spacing;
+    nested?: boolean;
+}
+export declare const BlockView: import("react").MemoExoticComponent<({ block, ctx, pa, sp, nested }: BlockViewProps) => import("react").JSX.Element>;

package/dist/types/react/docx/tables.d.ts

@@ -0,0 +1,20 @@
+import type { Paragraph, Table, TableCell } from '../../core/docx/types';
+export interface GridCell {
+    ri: number;
+    ci: number;
+    g: number;
+    cell: TableCell;
+}
+/** Grid positions of every cell (row spans occupy following rows). */
+export declare function gridOf(t: Table): {
+    cells: GridCell[];
+    nCols: number;
+    at: (ri: number, g: number) => GridCell | undefined;
+};
+export type NewPara = (template: TableCell) => Paragraph;
+export declare function insertRow(t: Table, ri: number, below: boolean, mk: NewPara): Table;
+export declare function deleteRow(t: Table, ri: number): Table | null;
+export declare function insertCol(t: Table, g0: number, right: boolean, mk: NewPara): Table;
+export declare function deleteCol(t: Table, g: number): Table | null;
+/** New table model (rows × cols) with simple single borders. */
+export declare function newTable(rowsN: number, colsN: number, width: number, mk: () => Paragraph): Table;

package/dist/types/react/edit/Toolbar.d.ts

@@ -0,0 +1,130 @@
+import { type CSSProperties, type ReactNode, type RefObject } from 'react';
+export declare function Icon({ name, size }: {
+    name: string;
+    size?: number;
+}): import("react").JSX.Element;
+/** closes a popup on outside mousedown (shadow-DOM safe: uses the composed path) */
+export declare function useDismiss(ref: RefObject<HTMLElement | null>, open: boolean, close: () => void): void;
+export declare function Btn(props: {
+    icon?: string;
+    label?: ReactNode;
+    title: string;
+    active?: boolean;
+    disabled?: boolean;
+    onClick: () => void;
+    wide?: boolean;
+}): import("react").JSX.Element;
+export declare const Sep: () => import("react").JSX.Element;
+export interface DropOption<T> {
+    value: T;
+    label: string;
+    /** secondary text on the right (example, shortcut) */
+    hint?: string;
+    icon?: string;
+    /** label style (font / style previews) */
+    style?: CSSProperties;
+    disabled?: boolean;
+    /** separator above this option */
+    sep?: boolean;
+}
+/**
+ * Styled dropdown (listbox). Never takes focus from the editor: mouse down is prevented and,
+ * while open, keys are captured at the window (arrows, Enter, Escape, type-ahead).
+ */
+export declare function Dropdown<T extends string | number>(props: {
+    title: string;
+    options: DropOption<T>[];
+    onChange: (v: T) => void;
+    /** selected value (check mark); omit for command menus */
+    value?: T | '';
+    placeholder?: string;
+    /** fixed trigger content (menus); null = icon only */
+    label?: ReactNode;
+    icon?: string;
+    width?: number;
+    menuWidth?: number;
+    disabled?: boolean;
+    /** popup aligned to the trigger's right edge */
+    alignRight?: boolean;
+}): import("react").JSX.Element;
+/** Value picker (fonts, styles, formats…). */
+export declare function Select<T extends string | number>(props: {
+    value: T | '';
+    options: DropOption<T>[];
+    onChange: (v: T) => void;
+    title: string;
+    width?: number;
+    placeholder?: string;
+    menuWidth?: number;
+    disabled?: boolean;
+}): import("react").JSX.Element;
+/** Font size box: − [size] + with a list of common sizes (Google Docs style). */
+export declare function SizeBox(props: {
+    value?: number;
+    placeholder?: number;
+    sizes?: number[];
+    onChange: (n: number) => void;
+    title?: string;
+    disabled?: boolean;
+}): import("react").JSX.Element;
+/**
+ * One-line toolbar: items that do not fit move into a "more" popover (like Google Docs).
+ * Item widths are measured once per set of items and cached for resizes.
+ */
+export declare function ToolbarRow({ children }: {
+    children: ReactNode;
+}): import("react").JSX.Element;
+export declare function ColorBtn(props: {
+    icon: string;
+    title: string;
+    value?: string;
+    onPick: (c: string | null) => void;
+    palette?: string[];
+    noneLabel?: string;
+}): import("react").JSX.Element;
+export declare const FONTS: string[];
+export declare const SIZES: number[];
+/** Font picker options (each shown in its own face); keeps an unknown current font at the top. */
+export declare function fontOptions(current?: string): DropOption<string>[];
+/** Picks the first name of a CSS font stack. */
+export declare function fontName(css: string | undefined): string;
+export declare function download(blob: Blob, name: string): void;
+/** Command menu: fixed label, items with optional icons. */
+export declare function Menu(props: {
+    title: string;
+    label: string;
+    icon?: string;
+    items: {
+        value: string;
+        label: string;
+        icon?: string;
+        disabled?: boolean;
+        sep?: boolean;
+        hint?: string;
+    }[];
+    onPick: (v: string) => void;
+    width?: number;
+}): import("react").JSX.Element;
+/** Small popover anchored under a toolbar button. */
+export declare function Pop(props: {
+    icon: string;
+    title: string;
+    children: (close: () => void) => ReactNode;
+    active?: boolean;
+    disabled?: boolean;
+    chevron?: boolean;
+}): import("react").JSX.Element;
+/** rows × cols picker for new tables */
+export declare function GridPicker({ onPick }: {
+    onPick: (r: number, c: number) => void;
+}): import("react").JSX.Element;
+/** Inline text prompt (URL, sheet name…) inside a popover. */
+export declare function PromptBox(props: {
+    placeholder: string;
+    initial?: string;
+    ok: string;
+    onOk: (v: string) => void;
+    extra?: ReactNode;
+}): import("react").JSX.Element;
+/** Opens the OS file picker (images by default). */
+export declare function pickFiles(accept?: string, multiple?: boolean): Promise<File[]>;

package/dist/types/react/edit/input.d.ts

@@ -0,0 +1,81 @@
+/**
+ * Controlled contentEditable: the DOM is only a view. Every mutation is taken from
+ * `beforeinput` (cancelled) and applied to the model through a RichHost; IME
+ * composition (Vietnamese Telex/VNI, CJK…) is committed on `compositionend`.
+ */
+import { type Pos, type RRun, type Sel } from './rich';
+export interface RichPara {
+    runs: RRun[];
+}
+export interface ReplaceOpts {
+    label?: string;
+    /** rebuild paragraph DOM (after IME composition mutated it) */
+    remount?: boolean;
+}
+export interface RichHost<P extends RichPara = RichPara> {
+    para(pa: string): P | undefined;
+    /** inclusive list of paragraph addresses from a to b in one container, or null */
+    span(a: string, b: string): string[] | null;
+    prev(pa: string): string | undefined;
+    next(pa: string): string | undefined;
+    cmp(a: string, b: string): number;
+    /** replace contiguous paragraphs; `sel` is the selection afterwards */
+    replace(pas: string[], next: P[], sel: Sel, opts?: ReplaceOpts): void;
+    withRuns(p: P, runs: RRun[]): P;
+    split(p: P, left: RRun[], right: RRun[], atEnd: boolean): [P, P];
+    join(a: P, b: P, runs: RRun[]): P;
+    /** Backspace at offset 0 (e.g. leave a list); true when handled */
+    backspaceAtStart?(pa: string, p: P): boolean;
+    /** Tab inside a paragraph (e.g. indent list); true when handled */
+    tab?(sel: Sel, shift: boolean): boolean;
+    undo(): void;
+    redo(): void;
+    toggle?(key: 'b' | 'i' | 'u'): void;
+    shortcut?(e: KeyboardEvent): boolean;
+    /** style for text typed into an empty paragraph */
+    defaultRun?(p: P): Partial<RRun> | undefined;
+    /** paste with formatting / files; true when handled */
+    pasteRich?(sel: Sel, data: DataTransfer): boolean;
+    /** caret style for the next typed text (set after formatting a collapsed selection) */
+    pendingStyle?(): Partial<RRun> | undefined;
+    clearPending?(): void;
+    onSelection?(sel: Sel | null): void;
+}
+export declare function ordered(host: RichHost, s: Sel): [Pos, Pos];
+export declare function opDelete(host: RichHost, sel: Sel, opts?: ReplaceOpts): void;
+/**
+ * Inserts runs at the selection; `lines[i]` (i > 0) start new paragraphs.
+ * `props[i]` can adjust the paragraph created for line i (e.g. heading style from pasted HTML).
+ */
+export declare function opInsertRuns(host: RichHost, sel: Sel, lines: RRun[][], opts?: ReplaceOpts, props?: ((p: RichPara) => RichPara)[]): void;
+export declare function opInsert(host: RichHost, sel: Sel, text: string, opts?: ReplaceOpts): void;
+export declare function opEnter(host: RichHost, sel: Sel): void;
+export declare function opBackspace(host: RichHost, sel: Sel, word?: boolean): void;
+export declare function opDeleteForward(host: RichHost, sel: Sel, word?: boolean): void;
+export declare function posFromDom(root: HTMLElement, node: Node, offset: number): Pos | null;
+export declare function domFromPos(root: HTMLElement, pos: Pos): [Node, number] | null;
+/** Selection object that can see into the shadow root containing `node` (web component embeds). */
+export declare function getSel(node: Node): Selection | null;
+export declare class RichInput {
+    private host;
+    private root;
+    private composing;
+    private justComposed;
+    private raf;
+    lastSel: Sel | null;
+    constructor(host: RichHost);
+    attach(root: HTMLElement): void;
+    detach(): void;
+    get isComposing(): boolean;
+    readSel(): Sel | null;
+    /** current selection, falling back to the last known one (e.g. after focusing a toolbar control) */
+    sel(): Sel | null;
+    /** Applies a model selection to the DOM; false when its paragraph isn't rendered. */
+    restore(sel: Sel | null, focus?: boolean): boolean;
+    private rangeSel;
+    private onBeforeInput;
+    private onCompStart;
+    private onCompEnd;
+    private onKeyDown;
+    private onSelChange;
+}

package/dist/types/react/edit/rich.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Pure run-level text operations shared by the DOCX and PPTX editors.
+ * A run is either text ({ t: 'text', text }) or an atomic object counting as one character.
+ */
+export interface RRun {
+    t: string;
+    text?: string;
+    s?: object;
+    d?: object;
+    src?: unknown;
+    href?: string;
+    lk?: string;
+}
+export interface Pos {
+    /** paragraph address (container path; last segment = index in container) */
+    pa: string;
+    o: number;
+}
+export interface Sel {
+    a: Pos;
+    f: Pos;
+}
+export declare const rlen: (r: RRun) => number;
+export declare const plen: (runs: RRun[]) => number;
+export declare const collapsed: (s: Sel) => boolean;
+export declare const shiftPa: (pa: string, d: number) => string;
+export declare function runsText(runs: RRun[]): string;
+/** Merges adjacent identical text runs and drops empty ones. */
+export declare function normalize<R extends RRun>(runs: R[]): R[];
+/** Splits runs at offset o (text runs are cut). */
+export declare function splitRuns<R extends RRun>(runs: R[], o: number): [R[], R[]];
+export declare function sliceRuns<R extends RRun>(runs: R[], a: number, b: number): R[];
+/** Text run whose style applies at offset o (left affinity). */
+export declare function runAt<R extends RRun>(runs: R[], o: number): R | undefined;
+export declare function insertText<R extends RRun>(runs: R[], o: number, text: string, style?: Partial<R>, fallback?: Partial<R>): R[];
+export declare function deleteRange<R extends RRun>(runs: R[], a: number, b: number): R[];
+export declare function formatRange<R extends RRun>(runs: R[], a: number, b: number, s: object, d: object): R[];
+/** Previous grapheme boundary (surrogate pairs + combining marks). */
+export declare function prevBoundary(text: string, o: number): number;
+export declare function nextBoundary(text: string, o: number): number;

package/dist/types/react/injectStyles.d.ts

@@ -0,0 +1,4 @@
+import css from './styles.css?inline';
+/** Injects the viewer stylesheet once into a document or shadow root. */
+export declare function injectStyles(target?: Document | ShadowRoot | undefined): void;
+export { css as stylesText };

package/dist/types/react/pptx/PptxEditor.d.ts

@@ -0,0 +1,95 @@
+import type { PRunSet, SlideModel, TextBody, TPara, TRun } from '../../core/pptx/types';
+import type { DocumentClient } from '../../core/worker/client';
+import { RichInput, type ReplaceOpts, type RichHost } from '../edit/input';
+import { type RRun, type Sel } from '../edit/rich';
+type RunStyle = Omit<TRun, 'text' | 'br' | 'fld' | 'src' | 'href'>;
+export interface EPara {
+    runs: RRun[];
+    base: TPara;
+    algn: TPara['algn'];
+    algnSet?: boolean;
+    /** paragraph changes made here (written back) */
+    pp?: {
+        lvl?: number;
+        bullet?: 'none' | 'bullet' | 'number';
+        lnPct?: number;
+    };
+    k?: number;
+    caret?: RRun;
+}
+export interface PptxFormat {
+    b: boolean;
+    i: boolean;
+    u: boolean;
+    strike: boolean;
+    sz?: number;
+    color?: string;
+    font?: string;
+    algn?: string;
+    hl?: string;
+    baseline?: number;
+    bullet?: 'none' | 'bullet' | 'number';
+    lvl: number;
+    lnPct?: number;
+}
+export declare function toTPara(p: EPara, num?: number): TPara;
+/** Text editing of one shape on one slide. */
+export declare class PptxEditor implements RichHost<EPara> {
+    private client;
+    readonly input: RichInput;
+    paras: EPara[];
+    body?: TextBody;
+    slide: number;
+    sid: number;
+    pendingSel: Sel | null;
+    private history;
+    private future;
+    private pend;
+    private timer;
+    private changedSinceCommit;
+    onChange?: () => void;
+    onCommitted?: (slide: number, model: SlideModel) => void;
+    onDirty?: () => void;
+    onState?: (s: PptxFormat | null) => void;
+    constructor(client: DocumentClient);
+    get active(): boolean;
+    begin(slide: number, sid: number, body: TextBody): void;
+    end(): void;
+    text(): TextBody | undefined;
+    para(pa: string): EPara;
+    span(a: string, b: string): string[];
+    prev(pa: string): string | undefined;
+    next(pa: string): string | undefined;
+    cmp(a: string, b: string): number;
+    withRuns(p: EPara, runs: RRun[]): EPara;
+    split(p: EPara, left: RRun[], right: RRun[]): [EPara, EPara];
+    join(a: EPara, _b: EPara, runs: RRun[]): EPara;
+    defaultRun(p: EPara): Partial<RRun> | undefined;
+    pendingStyle(): Partial<RRun> | undefined;
+    clearPending(): void;
+    replace(pas: string[], next: EPara[], sel: Sel, opts?: ReplaceOpts & {
+        history?: boolean;
+    }): void;
+    undo(): void;
+    redo(): void;
+    private restore;
+    commit(): void;
+    format(s: Partial<RunStyle>, d: PRunSet): void;
+    toggle(key: 'b' | 'i' | 'u' | 'strike'): void;
+    setSize(sz: number): void;
+    setColor(c: string | null): void;
+    setFont(name: string): void;
+    setAlign(algn: TPara['algn']): void;
+    /** applies a paragraph-level change to the selected paragraphs */
+    private paraOp;
+    toggleBullet(kind: 'bullet' | 'number'): void;
+    indentLevel(d: 1 | -1): void;
+    setLineSpacing(x: number): void;
+    setHighlight(c: string | null): void;
+    toggleBaseline(kind: 'sup' | 'sub'): void;
+    clearFormat(): void;
+    state(sel?: Sel | null): PptxFormat | null;
+    onSelection(sel: Sel | null): void;
+    shortcut?: (e: KeyboardEvent) => boolean;
+}
+export {};

package/dist/types/react/pptx/PptxToolbar.d.ts

@@ -0,0 +1,36 @@
+import type { ShapeKind } from '../../core/pptx/types';
+import { type DropOption } from '../edit/Toolbar';
+import type { PptxEditor } from './PptxEditor';
+export declare const SHAPES: DropOption<string>[];
+export type Arrange = 'front' | 'forward' | 'backward' | 'back';
+export type Rotate = 'cw' | 'ccw' | 'flipH' | 'flipV';
+export type AlignTo = 'left' | 'center' | 'right' | 'top' | 'middle' | 'bottom';
+export type SlideCmd = 'add' | 'duplicate' | 'delete' | 'up' | 'down' | 'hide';
+export declare function PptxToolbar(props: {
+    editor: PptxEditor;
+    /** selected shape (not editing its text) */
+    shape: {
+        canText: boolean;
+        anchor?: 't' | 'ctr' | 'b';
+    } | null;
+    /** anchor of the text box being edited */
+    textAnchor?: 't' | 'ctr' | 'b';
+    canUndo: boolean;
+    onUndo: (redo: boolean) => void;
+    onInsert: (k: ShapeKind) => void;
+    onFill: (c: string | null) => void;
+    onLine: (p: {
+        color?: string | null;
+        w?: number;
+        dash?: string;
+    }) => void;
+    onArrange: (k: Arrange) => void;
+    onRotate: (k: Rotate) => void;
+    onAlign: (k: AlignTo) => void;
+    onAnchor: (a: 't' | 'ctr' | 'b') => void;
+    onDuplicate: () => void;
+    onDelete: () => void;
+    onBackground: (c: string | null) => void;
+    onSlide: (k: SlideCmd) => void;
+    onPresent: (fromStart: boolean) => void;
+}): import("react").JSX.Element;