ooxml-ui 1.4.1 → 1.6.0

package/dist/visio/viewer-export.d.ts

@@ -0,0 +1,17 @@
+import type { VisioDocument } from 'ooxml-core/visio';
+/** Raster resolution of PDF and PNG output; large pages are scaled down to the canvas cap. */
+export declare const EXPORT_DPI = 150;
+/** Pixel size of a page at `dpi`, scaled down so neither side exceeds the canvas cap. */
+export declare function rasterSize(widthIn: number, heightIn: number, dpi?: number): {
+    width: number;
+    height: number;
+};
+/** Draw one exported page SVG on a white canvas. Resolves once the image has loaded. */
+export declare function rasterizePage(doc: Document, model: VisioDocument, pageIndex: number, dpi?: number): Promise<HTMLCanvasElement>;
+/** The current page as a PNG picture. */
+export declare function exportPagePng(doc: Document, model: VisioDocument, pageIndex: number): Promise<Blob>;
+/**
+ * Every foreground page (with its background pages) as one raster PDF page of the drawing's
+ * page size. Text is not selectable: the pages are pictures, not vector PDF.
+ */
+export declare function exportDocumentPdf(doc: Document, model: VisioDocument): Promise<Blob>;

package/dist/visio/viewer-format-painter.d.ts

@@ -0,0 +1,20 @@
+import type { ViewerController, ViewerState } from './controller.js';
+export type FormatPainterMode = 'once' | 'sticky' | 'cancel';
+/**
+ * Visio's Format Painter: a click copies the selected shape's formatting and applies it once to
+ * the next selection; a double click keeps it on until Escape or another click on the button.
+ * Each application is one atomic, undoable edit of existing core format commands.
+ */
+export declare class ViewerFormatPainter {
+    #private;
+    private readonly root;
+    private readonly controller;
+    private readonly announce;
+    private readonly edit;
+    constructor(root: ShadowRoot, controller: ViewerController, announce: (message: string) => void, edit: (run: () => Promise<void>, success: string) => void);
+    get armed(): boolean;
+    /** Double clicking the button keeps the painter on (the second click arrives first). */
+    wire(): () => void;
+    run(mode: FormatPainterMode): void;
+    render(state: ViewerState): void;
+}

package/dist/visio/viewer-format-shape.d.ts

@@ -0,0 +1,16 @@
+import type { ViewerController, ViewerState } from './controller.js';
+/**
+ * Home > Shape Styles dialog launcher: Visio's Format Shape with Fill, Line and Effects sections.
+ * Every change becomes one undoable format-shape edit per selected shape.
+ */
+export declare class ViewerFormatShape {
+    #private;
+    private readonly root;
+    private readonly controller;
+    private readonly announce;
+    constructor(root: ShadowRoot, controller: ViewerController, announce: (message: string) => void);
+    wire(): () => void;
+    show(): void;
+    close(): void;
+    render(state: ViewerState): void;
+}

package/dist/visio/viewer-grouping.d.ts

@@ -0,0 +1,13 @@
+import type { ViewerController, ViewerState } from './controller.js';
+type Operation = 'group' | 'ungroup';
+/** Group and Ungroup availability; the controller owns the transaction and new selection. */
+export declare class ViewerGrouping {
+    private readonly root;
+    private readonly controller;
+    private readonly edit;
+    constructor(root: ShadowRoot, controller: ViewerController, edit: (run: () => Promise<void>, message: string) => void);
+    private reason;
+    run(operation: Operation): void;
+    render(state: ViewerState): void;
+}
+export {};

package/dist/visio/viewer-guides.d.ts

@@ -0,0 +1,27 @@
+import type { VisioPage } from 'ooxml-core/visio';
+import { type VisioPagePoint } from 'ooxml-core/visio/ui';
+import type { ViewerController, ViewerState } from './controller.js';
+/**
+ * View > Guides and View > Dynamic Grid. Guides are the page's `Type="Guide"` shapes, drawn as
+ * dashed lines when Guides is on: drag from the top ruler for a horizontal guide or the left
+ * ruler for a vertical one, drag a guide to move it, click it and press Delete to remove it.
+ * Each is one source edit. Moving shapes snaps to shown guides and, with Dynamic Grid, to other
+ * shapes' edges and centres, showing alignment hints while dragging.
+ */
+export declare class ViewerGuides {
+    #private;
+    private readonly root;
+    private readonly viewport;
+    private readonly rulers;
+    private readonly controller;
+    private readonly announce;
+    constructor(root: ShadowRoot, viewport: HTMLElement, rulers: HTMLElement, controller: ViewerController, announce: (message: string) => void);
+    get shown(): boolean;
+    toggleGuides(): void;
+    toggleDynamicGrid(): void;
+    /** Snap a shape drag; draws alignment hints. Unchanged when no snapping is active. */
+    snap(page: VisioPage, ids: readonly string[], delta: VisioPagePoint): VisioPagePoint;
+    clearHints(): void;
+    wire(): () => void;
+    render(state: ViewerState): void;
+}

package/dist/visio/viewer-insert-dialog.d.ts

@@ -0,0 +1,41 @@
+type Dialog = HTMLElement & {
+    open: boolean;
+    show(): void;
+    close(): void;
+};
+type Button = HTMLElement & {
+    disabled: boolean;
+};
+export interface FieldSpec {
+    name: string;
+    label: string;
+    /** A select lists choices; a text field accepts at most `maxLength` characters. */
+    choices?: boolean;
+    maxLength?: number;
+    placeholder?: string;
+    /** A checkbox (read with `checked`) or a number field instead of text. */
+    input?: 'checkbox' | 'number';
+}
+/**
+ * A small form on the shared `office-ui-dialog` shell: labelled fields, an alert line and footer
+ * buttons. Enter in a text field presses the first button. Document semantics stay with callers.
+ */
+export declare class InsertDialog {
+    readonly dialog: Dialog;
+    readonly error: HTMLElement;
+    readonly fields: Map<string, HTMLInputElement | HTMLSelectElement>;
+    readonly buttons: Map<string, Button>;
+    constructor(root: ShadowRoot, className: string, heading: string, specs: readonly FieldSpec[], buttons: readonly string[], press: (button: string) => void);
+    value(name: string): string;
+    checked(name: string): boolean;
+    /**
+     * Replace a select's choices; the current value is kept as an extra choice when unknown.
+     * `labels` names each value; `none: false` drops the leading empty choice.
+     */
+    choices(name: string, values: readonly string[], current: string, options?: {
+        labels?: readonly string[];
+        none?: boolean;
+    }): void;
+    busy(value: boolean): void;
+}
+export {};

package/dist/visio/viewer-insert.d.ts

@@ -0,0 +1,25 @@
+import type { ViewerController, ViewerState } from './controller.js';
+import type { VisioInsertItem } from './ribbon-action.js';
+import { InsertDialog } from './viewer-insert-dialog.js';
+type Run = (action: () => Promise<void>, success: string) => void;
+/**
+ * Insert-tab Pictures, Link and ScreenTip, plus Ctrl+click link following. Pictures are read
+ * from a local file only; links open in a new tab with noopener and never navigate the app.
+ */
+export declare class ViewerInsert {
+    #private;
+    private readonly root;
+    private readonly controller;
+    private readonly announce;
+    private readonly run;
+    readonly input: HTMLInputElement;
+    readonly link: InsertDialog;
+    readonly tip: InsertDialog;
+    constructor(root: ShadowRoot, controller: ViewerController, announce: (message: string) => void, run: Run);
+    open(item: VisioInsertItem): void;
+    close(): void;
+    /** Ctrl+click follows a shape's link like Visio; Shift keeps additive selection. */
+    wire(viewport: HTMLElement): () => void;
+    render(state: ViewerState): void;
+}
+export {};

package/dist/visio/viewer-issues.d.ts

@@ -0,0 +1,29 @@
+import { type VisioDiagramIssue, type VisioRuleSetId } from 'ooxml-core/visio/ui';
+import type { ViewerController, ViewerState } from './controller.js';
+/**
+ * Process > Check Diagram, the Issues window and Ignore This Issue. The rules are the core's
+ * generic ones. Ignored issues last for this session only: Visio keeps them in the document's
+ * Validation part with its own rule sets, which this viewer does not write.
+ */
+export declare class ViewerIssues {
+    #private;
+    private readonly root;
+    private readonly controller;
+    private readonly announce;
+    readonly host: HTMLElement;
+    readonly list: HTMLUListElement;
+    readonly summary: HTMLParagraphElement;
+    readonly showIgnored: HTMLInputElement;
+    constructor(root: ShadowRoot, controller: ViewerController, announce: (message: string) => void);
+    get open(): boolean;
+    get issues(): readonly VisioDiagramIssue[];
+    get ignored(): ReadonlySet<string>;
+    show(open?: boolean): void;
+    toggleRuleSet(id: VisioRuleSetId): void;
+    /** Check Diagram: run the enabled rule sets over every foreground page. */
+    check(): void;
+    /** Ignore This Issue: hide the selected issue (or the first visible one) for this session. */
+    ignore(): void;
+    wire(): () => void;
+    render(state: ViewerState): void;
+}

package/dist/visio/viewer-layer-assign.d.ts

@@ -0,0 +1,17 @@
+import type { ViewerController, ViewerState } from './controller.js';
+import { ViewerDialog } from './viewer-dialog.js';
+/**
+ * Home > Editing > Layers > Assign to Layer: checkboxes for the page's layers (mixed membership
+ * starts indeterminate and is kept unless changed) and a New layer field. OK commits one
+ * `assign-layers` source edit, so assignment and new layers undo together.
+ */
+export declare class ViewerLayerAssign {
+    #private;
+    private readonly root;
+    private readonly controller;
+    private readonly announce;
+    readonly dialog: ViewerDialog;
+    constructor(root: ShadowRoot, controller: ViewerController, announce: (message: string) => void);
+    open(): void;
+    render(state: ViewerState): void;
+}

package/dist/visio/viewer-layout-commands.d.ts

@@ -0,0 +1,41 @@
+import type { ViewerController, ViewerState } from './controller.js';
+import type { VisioLayoutAction } from './ribbon-action.js';
+import { ViewerExplorer } from './viewer-explorer.js';
+import { ViewerGuides } from './viewer-guides.js';
+import { ViewerLayerAssign } from './viewer-layer-assign.js';
+import { ViewerLayout } from './viewer-layout.js';
+import { ViewerPasteSpecial } from './viewer-paste-special.js';
+import { ViewerSelectType } from './viewer-select-type.js';
+/** Where Help and Show Training lead: the viewer's own guide, not Microsoft's help. */
+export declare const VISIO_GUIDE_URL = "https://christophervr.github.io/ooxml/visio/";
+export interface LayoutCommandHost {
+    root: ShadowRoot;
+    viewport: HTMLElement;
+    /** The drawing window wrapper holding the rulers. */
+    rulers: HTMLElement;
+    controller: ViewerController;
+    announce(message: string): void;
+    /** The command runner shared with the other ribbon commands (status and focus handling). */
+    edit(run: () => Promise<void>, message: string): void;
+    /** Paste the viewer's own shape clipboard, as Ctrl+V does. */
+    pasteShapes(): Promise<void>;
+}
+/**
+ * Arrangement, layout, layers, selection, view aids and help commands: Auto Align & Space,
+ * Re-Layout Page and its Layout dialog, Assign to Layer, Select by Type, Paste Special, Guides,
+ * Dynamic Grid, Drawing Explorer, Help and Show Training.
+ */
+export declare class ViewerLayoutCommands {
+    private readonly host;
+    readonly layout: ViewerLayout;
+    readonly layers: ViewerLayerAssign;
+    readonly select: ViewerSelectType;
+    readonly paste: ViewerPasteSpecial;
+    readonly guides: ViewerGuides;
+    readonly explorer: ViewerExplorer;
+    constructor(host: LayoutCommandHost);
+    run(action: VisioLayoutAction): void;
+    wire(): () => void;
+    close(): void;
+    render(state: ViewerState): void;
+}

package/dist/visio/viewer-layout.d.ts

@@ -0,0 +1,24 @@
+import { type VisioLayoutStyle } from 'ooxml-core/visio/ui';
+import type { ViewerController, ViewerState } from './controller.js';
+import { ViewerDialog } from './viewer-dialog.js';
+type Run = (action: () => Promise<void>, message: string) => void;
+/**
+ * Home > Arrange > Auto Align & Space and Design > Re-Layout Page with its Layout dialog. Both
+ * act on the selection (two or more shapes) or the whole page and commit one move batch, so a
+ * layout is a single undo step. Glued connectors follow through core glue recalculation.
+ */
+export declare class ViewerLayout {
+    #private;
+    private readonly root;
+    private readonly controller;
+    private readonly run;
+    readonly options: ViewerDialog;
+    constructor(root: ShadowRoot, controller: ViewerController, run: Run);
+    autoAlign(): void;
+    reLayout(style: VisioLayoutStyle, spacing?: number): void;
+    showOptions(): void;
+    render(state: ViewerState): void;
+    /** Whether Position can open for Auto Align & Space. */
+    available(state: ViewerState): boolean;
+}
+export {};

package/dist/visio/viewer-page-breaks.d.ts

@@ -0,0 +1,6 @@
+import type { VisioPageBreaks } from 'ooxml-core/visio/ui';
+/**
+ * View > Page Breaks: dashed lines where printed sheets split the page. The overlay is viewer
+ * chrome in page inches (the paper's viewBox), never document content, and is not exported.
+ */
+export declare function drawPageBreaks(svg: SVGSVGElement, breaks: VisioPageBreaks | undefined): void;

package/dist/visio/viewer-page-setup-dialog.d.ts

@@ -0,0 +1,20 @@
+import type { VisioEdit, VisioPage } from 'ooxml-core/visio';
+import type { ViewerController, ViewerState } from './controller.js';
+import type { VisioPageSetupTab } from './page-setup-action.js';
+/**
+ * Visio's Page Setup dialog (Design > Page Setup launcher, File > Print > Page Setup). OK commits
+ * one page transaction; Size to fit drawing contents follows as a second step because it also
+ * moves shapes. The core refuses formulas and locks it cannot prove.
+ */
+export declare class ViewerPageSetupDialog {
+    #private;
+    private readonly controller;
+    private readonly announce;
+    constructor(root: ShadowRoot, controller: ViewerController, announce?: (message: string) => void);
+    get element(): HTMLElement;
+    show(tab?: VisioPageSetupTab): void;
+    close(): void;
+    render(state: ViewerState): void;
+    /** The page transaction the form describes, or a message for the first invalid field. */
+    edits(page: VisioPage): VisioEdit[] | string;
+}

package/dist/visio/viewer-page-setup.d.ts

@@ -0,0 +1,23 @@
+import type { ViewerController, ViewerState } from './controller.js';
+import type { VisioPageSetupCommand } from './page-setup-action.js';
+import { ViewerPageSetupDialog } from './viewer-page-setup-dialog.js';
+type Edit = (run: () => Promise<void>, message: string) => void;
+/**
+ * Design > Page Setup and Backgrounds, File > Page Setup and View > Page Breaks. Every change is
+ * one source-backed core edit, so undo and redo come from the document history; locks, formulas
+ * and unmanaged background pages are refused by the core with its reason.
+ */
+export declare class ViewerPageSetup {
+    #private;
+    private readonly root;
+    private readonly controller;
+    private readonly edit;
+    private readonly announce;
+    readonly dialog: ViewerPageSetupDialog;
+    constructor(root: ShadowRoot, controller: ViewerController, edit: Edit, announce: (message: string) => void);
+    get pageBreaks(): boolean;
+    run(command: VisioPageSetupCommand): void;
+    wire(): () => void;
+    render(state: ViewerState): void;
+}
+export {};

package/dist/visio/viewer-paste-special.d.ts

@@ -0,0 +1,18 @@
+import type { ViewerController, ViewerState } from './controller.js';
+import { ViewerDialog } from './viewer-dialog.js';
+/**
+ * Home > Clipboard > Paste Special: paste the clipboard as Visio shapes (the viewer's own shape
+ * clipboard), as unformatted text in a new text box, or as a picture (PNG, JPEG or GIF through
+ * the picture insertion edit). Reading the clipboard needs the browser's permission.
+ */
+export declare class ViewerPasteSpecial {
+    #private;
+    private readonly root;
+    private readonly controller;
+    private readonly announce;
+    private readonly pasteShapes;
+    readonly dialog: ViewerDialog;
+    constructor(root: ShadowRoot, controller: ViewerController, announce: (message: string) => void, pasteShapes: () => Promise<void>);
+    open(): void;
+    render(state: ViewerState): void;
+}

package/dist/visio/viewer-pointer-gestures.d.ts

@@ -1,3 +1,5 @@
+import type { VisioPage } from 'ooxml-core/visio';
+import { type VisioPagePoint } from 'ooxml-core/visio/ui';
 import type { ViewerController, ViewerState } from './controller.js';
 /** Direct pointer movement and full-enclosure marquee; release is the only source edit. */
 export declare class ViewerPointerGestures {
@@ -8,6 +10,9 @@ export declare class ViewerPointerGestures {
     constructor(viewport: HTMLElement, controller: ViewerController, options: {
         active(): boolean;
         announce(message: string): void;
+        /** Guides and Dynamic Grid: adjust a drag delta and show alignment hints. */
+        snap?(page: VisioPage, ids: readonly string[], delta: VisioPagePoint): VisioPagePoint;
+        clearSnap?(): void;
     });
     render(state: ViewerState): void;
     wire(): () => void;

package/dist/visio/viewer-presentation.d.ts

@@ -0,0 +1,29 @@
+import type { VisioDocument, VisioPage } from 'ooxml-core/visio';
+import type { ViewerController, ViewerState } from './controller.js';
+/** Visio presents foreground pages only; background pages appear under the pages using them. */
+export declare function presentationPages(document: VisioDocument | null | undefined): VisioPage[];
+/** The chrome-free presentation surface: a stage, a page indicator and previous/next/exit. */
+export declare function createPresentation(doc: Document): HTMLElement;
+/**
+ * Visio's Presentation Mode (F5): the current foreground page fitted to the screen on a dark
+ * backdrop, read only, one page at a time. It renders its own copy of each page, so the drawing
+ * window's page, zoom and selection are never touched and are exactly as before on exit. The
+ * Fullscreen API is used when the browser allows it; otherwise the overlay covers the window.
+ */
+export declare class ViewerPresentation {
+    #private;
+    private readonly root;
+    private readonly controller;
+    readonly overlay: HTMLElement;
+    constructor(root: ShadowRoot, controller: ViewerController);
+    get active(): boolean;
+    /** 0-based position among the foreground pages, while presenting. */
+    get index(): number;
+    start(): void;
+    exit(): void;
+    /** Move to a 0-based foreground page, clamped. */
+    go(index: number): void;
+    wire(): () => void;
+    /** Sync the entry points and, while presenting, the shown page with the controller state. */
+    render(state: ViewerState): void;
+}

package/dist/visio/viewer-review.d.ts

@@ -0,0 +1,23 @@
+import type { ViewerController, ViewerState } from './controller.js';
+import type { VisioRibbonAction } from './ribbon-action.js';
+import { ViewerComments } from './viewer-comments.js';
+import { ViewerIssues } from './viewer-issues.js';
+import { ViewerShapeReport } from './viewer-shape-report.js';
+import { ViewerSubprocess } from './viewer-subprocess.js';
+type Run = (action: () => Promise<void>, success: string) => void;
+type ReviewAction = Extract<VisioRibbonAction, {
+    type: 'review';
+}>;
+/** Review and Process tab commands: comments, shape reports, diagram checks and subprocesses. */
+export declare class ViewerReview {
+    private readonly root;
+    readonly comments: ViewerComments;
+    readonly issues: ViewerIssues;
+    readonly report: ViewerShapeReport;
+    readonly subprocess: ViewerSubprocess;
+    constructor(root: ShadowRoot, viewport: HTMLElement, controller: ViewerController, announce: (message: string) => void, run: Run);
+    run(action: ReviewAction): void;
+    wire(): () => void;
+    render(state: ViewerState): void;
+}
+export {};

package/dist/visio/viewer-select-type.d.ts

@@ -0,0 +1,16 @@
+import type { ViewerController, ViewerState } from './controller.js';
+import { ViewerDialog } from './viewer-dialog.js';
+/**
+ * Home > Editing > Select > Select by Type: select the page's shapes by shape type, by layer or
+ * by master. Selection only: nothing is edited, so this works on read-only drawings too.
+ */
+export declare class ViewerSelectType {
+    #private;
+    private readonly root;
+    private readonly controller;
+    private readonly announce;
+    readonly dialog: ViewerDialog;
+    constructor(root: ShadowRoot, controller: ViewerController, announce: (message: string) => void);
+    open(): void;
+    render(state: ViewerState): void;
+}

package/dist/visio/viewer-shape-data.d.ts

@@ -0,0 +1,16 @@
+import type { ViewerController, ViewerState } from './controller.js';
+import { InsertDialog } from './viewer-insert-dialog.js';
+/**
+ * Visio's Define Shape Data dialog: add, change and delete the selected shape's Shape Data rows
+ * (label, type, format, value, prompt, hidden). Each change is one undoable core edit.
+ */
+export declare class ViewerShapeData {
+    #private;
+    private readonly root;
+    private readonly controller;
+    private readonly announce;
+    readonly form: InsertDialog;
+    constructor(root: ShadowRoot, controller: ViewerController, announce: (message: string) => void);
+    open(): void;
+    render(state: ViewerState): void;
+}

package/dist/visio/viewer-shape-report.d.ts

@@ -0,0 +1,26 @@
+import { type VisioShapeReport } from 'ooxml-core/visio/ui';
+import type { ViewerController } from './controller.js';
+type Dialog = HTMLElement & {
+    open: boolean;
+    show(): void;
+    close(): void;
+};
+/**
+ * Review > Shape Reports: a table of every shape on the current page or in the drawing, with
+ * Export CSV (a local download) and Copy (tab-separated text). The report itself is built in core.
+ */
+export declare class ViewerShapeReport {
+    #private;
+    private readonly root;
+    private readonly controller;
+    private readonly announce;
+    readonly dialog: Dialog;
+    readonly scope: HTMLSelectElement;
+    readonly table: HTMLTableElement;
+    readonly status: HTMLElement;
+    constructor(root: ShadowRoot, controller: ViewerController, announce: (message: string) => void);
+    get report(): VisioShapeReport | undefined;
+    show(): void;
+    dispose(): void;
+}
+export {};

package/dist/visio/viewer-shape-styles.d.ts

@@ -0,0 +1,9 @@
+import { type VisioPage, type VisioShape } from 'ooxml-core/visio';
+import type { RibbonCommand } from './ribbon-parts.js';
+/** Accent 1-6 of the page theme, or the Office colours a theme-less drawing uses. */
+export declare function pageAccentColor(page: VisioPage | undefined, accent: number): string;
+/**
+ * Selection state for Home > Shape Styles: the Quick Styles gallery and the Effects presets follow
+ * the same admission as Fill and Line. Bevel and 3-D Rotation keep their reasons.
+ */
+export declare function renderShapeStyleControls(root: ShadowRoot, shapes: readonly VisioShape[], reason: string, set: (element: RibbonCommand | null, reason: string) => void, page?: VisioPage): void;

package/dist/visio/viewer-shape-target.d.ts

@@ -0,0 +1,7 @@
+import type { VisioShapeSelection } from 'ooxml-core/visio/ui';
+/**
+ * The shape a pointer selects, as in Visio: the first click on a group member selects the
+ * outermost group; clicking again inside a selected group subselects one level deeper.
+ * Additive clicks always use the outermost group.
+ */
+export declare function pointerShapeTarget(node: EventTarget | null, selected: readonly Pick<VisioShapeSelection, 'id'>[], additive?: boolean): SVGGElement | null;

package/dist/visio/viewer-stencil.d.ts

@@ -1,6 +1,6 @@
 import type { ViewerController } from './controller.js';
 /**
  * Shapes window interaction: drag a master onto the page to drop it there, or activate it to add
- * it at the page centre. Only masters the core can create are draggable; the rest stay inert.
+ * it at the page centre. Ellipses and circles are native ellipses; the rest are core outlines.
  */
 export declare function wireStencil(pane: HTMLElement, viewport: HTMLElement, controller: ViewerController, announce: (message: string) => void): () => void;

package/dist/visio/viewer-subprocess.d.ts

@@ -0,0 +1,22 @@
+import type { ViewerController, ViewerState } from './controller.js';
+import { InsertDialog } from './viewer-insert-dialog.js';
+type Run = (action: () => Promise<void>, success: string) => void;
+type Mode = 'new' | 'selection' | 'existing';
+/**
+ * Process > Subprocess. Create New and Create from Selection are one core transaction (one undo
+ * step); Link to Existing adds a hyperlink to a chosen page. Links follow with Ctrl+click.
+ */
+export declare class ViewerSubprocess {
+    #private;
+    private readonly root;
+    private readonly controller;
+    private readonly announce;
+    private readonly run;
+    readonly link: InsertDialog;
+    constructor(root: ShadowRoot, controller: ViewerController, announce: (message: string) => void, run: Run);
+    reason(state: ViewerState, mode: Mode): string;
+    start(mode: Mode): void;
+    close(): void;
+    render(state: ViewerState): void;
+}
+export {};

package/dist/visio/viewer-text-block.d.ts

@@ -0,0 +1,23 @@
+import type { ViewerController, ViewerState } from './controller.js';
+/**
+ * Home > Tools > Text Block (Ctrl+Shift+4): the selected shape's text block gets a frame that
+ * moves, eight resize handles and a rotation handle. Releasing writes one undoable format-text
+ * edit with the TxtPinX/TxtPinY/TxtWidth/TxtHeight/TxtAngle cells.
+ */
+export declare class ViewerTextBlockTool {
+    #private;
+    private readonly viewport;
+    private readonly controller;
+    private readonly options;
+    constructor(viewport: HTMLElement, controller: ViewerController, options: {
+        announce(message: string): void;
+        edit(run: () => Promise<void>, success: string): void;
+        /** The tool turned on or off. */
+        changed(active: boolean): void;
+    });
+    get active(): boolean;
+    toggle(): void;
+    exit(): void;
+    render(state: ViewerState): void;
+    wire(): () => void;
+}

package/dist/visio/viewer-text-dialog.d.ts

@@ -0,0 +1,24 @@
+import { type VisioTextDialogValues } from 'ooxml-core/visio/ui';
+type Dialog = HTMLElement & {
+    open: boolean;
+    show(): void;
+    close(): void;
+};
+type Button = HTMLElement & {
+    disabled: boolean;
+};
+export type TextDialogTab = 'font' | 'character' | 'paragraph' | 'text-block' | 'tabs' | 'bullets';
+/** Visio's Text dialog on the shared office-ui-dialog: tabs, typed fields and footer buttons. */
+export declare function createTextDialog(root: ShadowRoot, press: (button: string) => void): {
+    dialog: Dialog;
+    error: HTMLParagraphElement;
+    buttons: Map<string, Button>;
+    select: (id: TextDialogTab, focus?: boolean) => void;
+    /** Show values; fonts fill the Font list and an unknown current font is kept. */
+    write(values: VisioTextDialogValues, fonts: readonly string[]): void;
+    /** Read the fields over `base`; invalid numbers keep the base value. */
+    read(base: VisioTextDialogValues): VisioTextDialogValues;
+    busy(value: boolean): void;
+};
+export type TextDialogView = ReturnType<typeof createTextDialog>;
+export {};

package/dist/visio/viewer-text-features.d.ts

@@ -0,0 +1,24 @@
+import type { ViewerController, ViewerState } from './controller.js';
+import type { VisioTextFeature } from './ribbon-action.js';
+import { ViewerTextBlockTool } from './viewer-text-block.js';
+type Edit = (run: () => Promise<void>, success: string) => void;
+/**
+ * Text features: the Text dialog (Font and Paragraph launchers), the Text Block tool, Insert
+ * Symbol and Field, and Review Spelling and Language. Spelling is the browser's own spell checker
+ * in the shape text editor; no dictionary is bundled.
+ */
+export declare class ViewerTextFeatures {
+    #private;
+    private readonly root;
+    private readonly viewport;
+    private readonly controller;
+    private readonly announce;
+    private readonly edit;
+    private readonly reveal;
+    readonly textBlock: ViewerTextBlockTool;
+    constructor(root: ShadowRoot, viewport: HTMLElement, controller: ViewerController, announce: (message: string) => void, edit: Edit, reveal: (panel: 'edit', focus: boolean) => void);
+    run(feature: VisioTextFeature): void;
+    wire(): () => void;
+    render(state: ViewerState, pointerTool: boolean): void;
+}
+export {};

package/dist/visio/viewer-text-insert.d.ts

@@ -0,0 +1,28 @@
+import type { VisioPage } from 'ooxml-core/visio';
+import { type VisioFieldCategory } from 'ooxml-core/visio/ui';
+import type { ViewerController } from './controller.js';
+type Dialog = HTMLElement & {
+    open: boolean;
+    show(): void;
+    close(): void;
+};
+export interface TextInsertTarget {
+    page: VisioPage;
+    shapeId: string;
+    /** The shape text editor when it holds the caret for this shape. */
+    editor?: HTMLTextAreaElement;
+}
+/** Insert > Symbol and Insert > Field. Edits go through the controller; fields stay atomic. */
+export declare class ViewerTextInsert {
+    #private;
+    private readonly controller;
+    private readonly announce;
+    readonly symbol: Dialog;
+    readonly field: Dialog;
+    constructor(root: ShadowRoot, controller: ViewerController, announce: (message: string) => void);
+    open(kind: 'symbol' | 'field', target: TextInsertTarget): void;
+    close(): void;
+    /** Close when the drawing the dialog was opened for is replaced. */
+    render(): void;
+}
+export type { VisioFieldCategory };