ooxml-ui 0.27.2 → 0.28.0

package/dist/docx/ribbon-parts.d.ts

@@ -0,0 +1,53 @@
+import type { RibbonAction } from './ribbon-action';
+import { type RibbonIcon } from './ribbon-icons';
+/** Building blocks for ribbon tabs: buttons, selects, labelled groups and rows. */
+export declare const button: (label: string, text: string, action: RibbonAction, className?: string) => HTMLButtonElement;
+export declare const select: (label: string, values: Array<[string, string]>, action: (value: string) => RibbonAction) => HTMLSelectElement;
+/**
+ * Word's dropdown command: an icon over a caption with a caret. The real `<select>` stays in the
+ * DOM, transparent and covering the whole control, so the browser's native list opens on click,
+ * assistive technology sees a combobox, and the editor keeps reading and writing `select.value`.
+ * `compact` drops the caption, leaving an icon and caret (Word's Line and Paragraph Spacing).
+ */
+export declare const menuSelect: (label: string, icon: RibbonIcon, values: Array<[string, string]>, action: (value: string) => RibbonAction, options?: {
+    compact?: boolean;
+    momentary?: boolean;
+}) => HTMLDivElement;
+/**
+ * A row-height command with its own dropdown, like Word's Find and Select: the main button runs
+ * `main`; the caret opens a menu of related commands (a transparent select over the caret).
+ */
+export declare const splitInline: (main: HTMLButtonElement, menuLabel: string, values: Array<[string, string]>, action: (value: string) => RibbonAction) => HTMLDivElement;
+/** Wraps an existing select in the dropdown-command look (see `menuSelect`). */
+export declare const menuAround: (control: HTMLSelectElement, label: string, icon: RibbonIcon, options?: {
+    compact?: boolean;
+    momentary?: boolean;
+}) => HTMLDivElement;
+/** A labelled number field (Word's indent spinners). `label` is both the visible text and the name. */
+export declare const spinner: (label: string, action: (value: number) => RibbonAction, options: {
+    min: number;
+    max: number;
+    step: number;
+}) => HTMLLabelElement;
+/** Word's dialog launcher: the small corner button of a group that opens its full dialog. */
+export declare const launcher: (label: string, action: RibbonAction) => HTMLButtonElement;
+export declare const group: (label: string, ...children: HTMLElement[]) => HTMLDivElement;
+export declare const row: (...children: HTMLElement[]) => HTMLDivElement;
+/** An icon button. `large` stacks a caption under a 28px icon, as Word's big commands do. */
+export declare const tool: (label: string, icon: RibbonIcon, action: RibbonAction, options?: {
+    large?: boolean;
+    inline?: boolean;
+    caption?: string;
+    className?: string;
+}) => HTMLButtonElement;
+/** A stack of controls filling a group's height, such as Paste's Cut/Copy column. */
+export declare const stack: (...children: HTMLElement[]) => HTMLDivElement;
+/**
+ * Word's split colour button: the main half applies the last chosen colour (shown as a bar under
+ * the icon) and the caret opens a swatch popover. `choices` are `[value, English label]` pairs.
+ */
+export declare const colorSplit: (label: string, icon: RibbonIcon, choices: Array<[string, string]>, action: (value: string) => RibbonAction, initial: string, grid?: {
+    noneLabel?: string;
+}) => HTMLDivElement;
+/** Records `value` as the colour a split button applies next and draws it in the bar. */
+export declare function setColorControl(main: HTMLElement, value: string): void;

package/dist/docx/ribbon-popover.d.ts

@@ -0,0 +1,16 @@
+/** Closes whichever ribbon popover is open. */
+export declare function closeRibbonPopover(): void;
+/**
+ * Shows `pop` under `anchor` and wires dismissal: Escape, a pointer press elsewhere, or `close()`.
+ * Fixed positioning keeps it clear of the ribbon's overflow clipping. Returns false (and closes) when
+ * the same anchor was already open, so the caret works as a toggle.
+ */
+export declare function mountPopover(anchor: HTMLElement, pop: HTMLElement, expanded: HTMLElement, align?: 'start' | 'end'): boolean;
+/** Opens a swatch grid under the caret button `anchor`. */
+export declare function openSwatchPopover(anchor: HTMLElement, choices: Array<[string, string]>, choose: (value: string) => void): void;
+/**
+ * Opens a scrolling list of `items` under a combo box, with `current` marked and scrolled into view.
+ * Up/Down move through the entries, Enter chooses, Escape closes. `preview` sets each entry in its
+ * own font face.
+ */
+export declare function openListPopover(anchor: HTMLElement, items: readonly string[], current: string, preview: boolean, choose: (value: string) => void): void;

package/dist/docx/ribbon-router.d.ts

@@ -0,0 +1,4 @@
+import type { EditorCore } from './editor-core';
+import type { RibbonAction } from './ribbon';
+/** Routes a ribbon action to the controller that owns it. */
+export declare function routeRibbonAction(core: EditorCore, action: RibbonAction): void;

package/dist/docx/ribbon-tab-api.d.ts

@@ -0,0 +1,29 @@
+/**
+ * The tab row belongs to the shared `office-ui-ribbon`: it builds the tabs from the panels, keeps one
+ * panel visible and renders the File button. Everything docx does to a tab is therefore done to its
+ * panel, through these helpers, so no other module reaches into the ribbon's shadow root.
+ */
+export type RibbonElement = HTMLElement & {
+    selected: string;
+    focusTab(): void;
+    focusFile(): void;
+    setTabHidden(tab: string, reason: string, hidden: boolean): void;
+    tabButton(tab: string): HTMLButtonElement | null;
+    fileButton(): HTMLButtonElement | null;
+};
+/** The panel of tab `key` (`home`, `table`, `header-footer`...). */
+export declare function panelOf(ribbon: ParentNode, key: string): HTMLElement | null;
+/** Every panel, in tab order. */
+export declare function panelsOf(ribbon: ParentNode): HTMLElement[];
+/** The key of the tab that is showing. */
+export declare function selectedTab(ribbon: HTMLElement): string;
+export declare function selectTab(ribbon: HTMLElement, key: string): void;
+/** Why a tab can be missing: the tools do not apply to the selection, or a customisation removed it. */
+export type TabHiddenReason = 'contextual' | 'custom';
+/** Hides or shows tab `key` for one reason; the shared ribbon shows it once no reason hides it. */
+export declare function setTabHidden(ribbon: HTMLElement, key: string, reason: TabHiddenReason, hidden: boolean): void;
+export declare const isTabHidden: (panel: HTMLElement) => boolean;
+/** The rendered tab buttons, for focus and key tips only. */
+export declare function tabButtons(ribbon: HTMLElement): HTMLButtonElement[];
+/** The File button the ribbon renders. */
+export declare function fileButton(ribbon: HTMLElement): HTMLButtonElement | null;

package/dist/docx/ribbon-tabs.d.ts

@@ -0,0 +1,2 @@
+/** The Insert, Layout, References, Review and View tabs. */
+export declare function buildOtherPanels(panels: Map<string, HTMLElement>): void;

package/dist/docx/ribbon-visibility.d.ts

@@ -0,0 +1,8 @@
+import { type RibbonActionId } from 'ooxml-core/docx/ui';
+/** Stable action id of a ribbon control (looked up from its English label, whatever the locale). */
+export declare function ribbonControlId(control: HTMLElement): RibbonActionId | null;
+/**
+ * Applies `showToolbar` and `hiddenActions` to the ribbon. Groups and tabs whose controls are all
+ * hidden are hidden too, and the active tab moves to the first visible one. Unknown ids are ignored.
+ */
+export declare function applyRibbonVisibility(toolbar: HTMLElement, showToolbar: boolean, hiddenActions: readonly RibbonActionId[]): void;

package/dist/docx/ribbon.d.ts

@@ -0,0 +1,5 @@
+export type { RibbonAction } from './ribbon-action';
+export declare function createRibbon(locale?: string): HTMLElement;
+/** Gives every select the tooltip of its selected label so an ellipsized value stays readable. */
+export declare function syncSelectTitles(root: ParentNode): void;
+export declare function setRibbonLocale(root: HTMLElement, value: string): void;

package/dist/docx/ruler-sync.d.ts

@@ -0,0 +1,7 @@
+import type { DocumentModel } from 'ooxml-core/docx';
+import type { EditorView } from 'prosemirror-view';
+import { type RulerGeometry } from './ruler';
+/** The ruler geometry for the paragraph holding the selection, from the document's page attributes. */
+export declare function rulerGeometry(view: EditorView, model: DocumentModel): RulerGeometry;
+/** Redraws the ruler, if the View tab has it on, for the current selection and zoom. */
+export declare function syncRuler(toolbar: HTMLElement, view: EditorView, model: DocumentModel): void;

package/dist/docx/ruler.d.ts

@@ -0,0 +1,36 @@
+import type { ParagraphFormat } from './paragraph-format';
+/** Everything the ruler draws, in CSS pixels at 100% zoom (96 per inch). */
+export interface RulerGeometry {
+    pageWidth: number;
+    marginLeft: number;
+    marginRight: number;
+    /** Current paragraph's indents, measured from the margins. */
+    indentLeft: number;
+    indentRight: number;
+    /** Extra first-line offset from the left indent: positive first line, negative hanging. */
+    firstLine: number;
+}
+export declare const PX_PER_INCH = 96;
+/** Marker positions from the page's left edge: first-line, left indent, right indent. */
+export declare function markerPositions(geometry: RulerGeometry): {
+    firstLine: number;
+    left: number;
+    right: number;
+};
+/** Whole-inch labels of the ruler: 0 at the left margin, counting toward the right margin. */
+export declare function inchLabels(geometry: RulerGeometry): Array<{
+    at: number;
+    text: string;
+}>;
+export type RulerMarker = 'first-line' | 'left' | 'right';
+/** The paragraph fields a marker dragged to `x` (px from the page's left edge) changes. */
+export declare function markerChange(marker: RulerMarker, x: number, geometry: RulerGeometry): Partial<Pick<ParagraphFormat, 'leftInches' | 'rightInches' | 'special' | 'specialInches'>>;
+/**
+ * Word's horizontal ruler above the page: inch ticks counted from the left margin, the margins
+ * shaded, and draggable markers for the current paragraph's first-line, left and right indents.
+ * Dragging snaps to sixteenths of an inch and applies as one undoable step on release. Margin
+ * edges and tab stops are not draggable.
+ */
+export declare function createRuler(onChange?: (change: ReturnType<typeof markerChange>) => void): HTMLElement;
+/** Positions the ruler's parts for `geometry`; `zoom` matches the page's CSS zoom. */
+export declare function updateRuler(ruler: HTMLElement, geometry: RulerGeometry, zoom: number): void;

package/dist/docx/run-adapter.d.ts

@@ -0,0 +1,9 @@
+import type { TextRun } from 'ooxml-core/docx';
+import type { Node as ProseMirrorNode } from 'prosemirror-model';
+/** A note reference's number in document order and its label in the document's number format. */
+export type NoteNumberLookup = (kind: 'footnote' | 'endnote', id: string) => {
+    number: number;
+    label: string;
+};
+export declare function runToInlineNodes(run: TextRun, noteNumber?: NoteNumberLookup): ProseMirrorNode[];
+export declare function appendInlineNode(runs: TextRun[], child: ProseMirrorNode): void;

package/dist/docx/run-marks.d.ts

@@ -0,0 +1,4 @@
+import type { TextRun } from 'ooxml-core/docx';
+import type { Mark } from 'prosemirror-model';
+/** ProseMirror marks carrying a text run's character formatting, links, fields and revisions. */
+export declare function marksForRun(run: TextRun): Mark[];

package/dist/docx/run-scale.d.ts

@@ -0,0 +1,11 @@
+import type { RunFormatting } from 'ooxml-core/docx';
+import { type TextMeasurer } from 'ooxml-core/docx/layout';
+export interface ScaledSegment {
+    from: number;
+    to: number;
+    css: string;
+}
+/** Reserve scaled advances while leaving source text available to the browser's caret/selection. */
+export declare function scaledSegments(text: string, formatting: RunFormatting, family: string | undefined, measurer: TextMeasurer): ScaledSegment[];
+/** Each editor owns its cache; replacing it when fonts load avoids measuring fallback faces forever. */
+export declare function scaleMeasurer(): TextMeasurer;

package/dist/docx/run-styles.d.ts

@@ -0,0 +1,19 @@
+import { Plugin, PluginKey, type EditorState } from 'prosemirror-state';
+import type { Node as ProseMirrorNode } from 'prosemirror-model';
+import { type DocumentModel, type RunFormatting, type TextRun } from 'ooxml-core/docx';
+type Theme = NonNullable<DocumentModel['theme']>;
+export declare function themeFontOf(formatting: RunFormatting, theme: Theme | undefined): string | undefined;
+/** CSS for inherited run formatting; direct formatting still renders through the run's own marks. */
+export declare function runFormattingCss(formatting: RunFormatting, theme?: Theme, direct?: RunFormatting): string;
+/** The run a text node stands for, with its marks as direct formatting. */
+export declare function runOf(node: ProseMirrorNode): TextRun | undefined;
+/**
+ * Renders formatting a run inherits from document defaults, its paragraph style, its table's style
+ * (e.g. a bold header row), its character style and the theme. It is display-only: decorations
+ * never enter the model or collaboration steps.
+ */
+export declare const runStylesKey: PluginKey<any>;
+/** The document model the editor's run-style decorations resolve against, if the plugin is on. */
+export declare function styleModelOf(state: EditorState): DocumentModel | undefined;
+export declare function runStylesPlugin(getModel: () => DocumentModel): Plugin<any>;
+export {};

package/dist/docx/scaled-paragraph-breaks.d.ts

@@ -0,0 +1,7 @@
+import type { Node as ProseMirrorNode } from 'prosemirror-model';
+import { Decoration } from 'prosemirror-view';
+/** Atomic scaled spans must not create a line break at a formatting boundary.
+ * Keep the paragraph's source whitespace and expose only the core's text breaks.
+ * Empty wbr widgets have no text to leak into copying, editing or serialization.
+ */
+export declare function scaledParagraphBreaks(paragraph: ProseMirrorNode, start: number): Decoration[];

package/dist/docx/schema.d.ts

@@ -0,0 +1,6 @@
+import { Schema } from 'prosemirror-model';
+export { wordHighlightColors } from 'ooxml-core/docx/ui';
+/** Single line spacing as a multiple of the font size, close to Calibri's and Arial's metrics. */
+export declare const NATURAL_LINE_HEIGHT = 1.2;
+export declare function paragraphStyle(attrs: Record<string, unknown>): string;
+export declare const schema: Schema<"doc" | "equation" | "fieldMarker" | "hardBreak" | "image" | "nestedTablePreview" | "noteReference" | "pageBreak" | "paragraph" | "table" | "tableCell" | "tableRow" | "text", "bold" | "characterStyle" | "comment" | "deletion" | "field" | "font" | "highlight" | "insertion" | "italic" | "language" | "link" | "runProperties" | "runRtl" | "strike" | "underline" | "verticalAlign">;

package/dist/docx/script-state.d.ts

@@ -0,0 +1,4 @@
+import type { EditorState } from 'prosemirror-state';
+export type Script = 'none' | 'superscript' | 'subscript';
+/** Effective script formatting, including paragraph/character styles and typing marks. */
+export declare function selectionScript(state: EditorState): Script | null;

package/dist/docx/search-controller.d.ts

@@ -0,0 +1,32 @@
+import { type Node as ProseMirrorNode } from 'prosemirror-model';
+import type { EditorView } from 'prosemirror-view';
+export interface SearchMatch {
+    from: number;
+    to: number;
+}
+export interface SearchStatus {
+    query: string;
+    count: number;
+    active: number;
+    readOnly: boolean;
+}
+export declare class SearchController {
+    private readonly getView;
+    private query;
+    private caseSensitive;
+    private matches;
+    private activeIndex;
+    constructor(getView: () => EditorView | undefined);
+    get status(): SearchStatus;
+    search(query: string, caseSensitive?: boolean): SearchStatus;
+    refresh(): SearchStatus;
+    findNext(): SearchMatch | null;
+    findPrevious(): SearchMatch | null;
+    replaceOne(replacement: string): boolean;
+    replaceAll(replacement: string): number;
+    private currentMatches;
+    private indexAtSelection;
+    private select;
+    private replace;
+}
+export declare function findTextMatches(doc: ProseMirrorNode, query: string, caseSensitive?: boolean): SearchMatch[];

package/dist/docx/search-panel.d.ts

@@ -0,0 +1,14 @@
+import type { EditorView } from 'prosemirror-view';
+export interface SearchPanelOptions {
+    getView: () => EditorView | undefined;
+    onClose?: () => void;
+}
+export interface SearchPanelHandle {
+    element: HTMLElement;
+    open(focus?: 'find' | 'replace'): void;
+    close(): void;
+    refresh(): void;
+    setLocale(locale: string): void;
+    readonly isOpen: boolean;
+}
+export declare function createSearchPanel(options: SearchPanelOptions, initialLocale?: string): SearchPanelHandle;

package/dist/docx/section-commands.d.ts

@@ -0,0 +1,14 @@
+import { Plugin } from 'prosemirror-state';
+import type { EditorView } from 'prosemirror-view';
+import { type DocumentModel, sectionsOf } from 'ooxml-core/docx';
+export { sectionsOf };
+/** The section containing the selection (Word applies page setup to the current section). */
+export declare function currentSectionIndex(view: EditorView, model: DocumentModel): number;
+export { setColumns, setLineNumbering, setMargins, setOrientation, setPageNumbering, setTitlePage, setVerticalAlign, withSection, } from 'ooxml-core/docx';
+/**
+ * Word's Layout > Breaks > Section Break: the current section ends after the selected paragraph
+ * and a new section with the same settings begins; `type` is how the new section starts.
+ */
+export declare function insertSectionBreak(view: EditorView, model: DocumentModel, type: 'nextPage' | 'continuous' | 'evenPage' | 'oddPage'): DocumentModel;
+/** Marks paragraphs that end a section, like Word's formatting marks for section breaks. */
+export declare function sectionBreaksPlugin(): Plugin<any>;

package/dist/docx/shell-labels.d.ts

@@ -0,0 +1,3 @@
+import { type EditorLocale } from './localization';
+/** Localizes the accessible names of the host element and the page surface. */
+export declare function applyShellLabels(host: HTMLElement, paper: HTMLElement | undefined, locale: EditorLocale): void;

package/dist/docx/shortcut-help.d.ts

@@ -0,0 +1,16 @@
+import { type ShortcutRegistry } from './keyboard';
+import { type EditorLocale, type LocalizationKey } from './localization';
+export interface ShortcutRow {
+    keys: string;
+    label: LocalizationKey;
+}
+/** Only bindings that exist in the editor's keymap are listed, grouped by action. */
+export declare function editorShortcutRows(mac: boolean, bindings?: Record<string, unknown>): ShortcutRow[];
+export declare function shortcutRows(registry: ShortcutRegistry, mac: boolean): ShortcutRow[];
+export interface ShortcutHelp {
+    element: HTMLElement;
+    readonly isOpen: boolean;
+    open(rows: ShortcutRow[], locale: EditorLocale): void;
+    close(): void;
+}
+export declare function createShortcutHelp(onClose: () => void): ShortcutHelp;

package/dist/docx/smartart-node-view.d.ts

@@ -0,0 +1,26 @@
+import type { DocxDiagram, ThemeCatalog } from 'ooxml-core/docx';
+import type { Node as ProseMirrorNode } from 'prosemirror-model';
+import type { NodeView } from 'prosemirror-view';
+/** What the shared renderer reports (`office-smartart-render`), as far as this view reads it. */
+interface RenderReport {
+    approximatedGeometries?: string[];
+    approximatedFills?: string[];
+    flattened3d?: number;
+}
+/** Registers `<office-ui-smartart>` once; a no-op without a DOM (server rendering). */
+export declare function registerSmartArt(): void;
+export declare function parseDiagram(value: unknown): DocxDiagram | undefined;
+/** The accessible name: alt text, then title, then the object name, then a generic label. */
+export declare function diagramLabel(node: ProseMirrorNode, diagram: DocxDiagram): string;
+/** Honest, human-readable notes shown beside the diagram (never a fidelity claim). */
+export declare function diagramNotes(diagram: DocxDiagram, report: RenderReport | undefined, themed?: {
+    unappliedTransforms: string[];
+    alphaDropped: boolean;
+}): string[];
+/**
+ * Node view for an image node that carries a SmartArt `diagram`: mounts `<office-ui-smartart>`
+ * with the cached drawing (theme colours resolved), scaled from the diagram frame to the run's
+ * size. Read-only: the diagram parts are never edited, and the node stays an atom.
+ */
+export declare function smartArtNodeView(node: ProseMirrorNode, diagram: DocxDiagram, theme: ThemeCatalog | undefined): NodeView;
+export {};

package/dist/docx/sort-commands.d.ts

@@ -0,0 +1,9 @@
+import type { EditorView } from 'prosemirror-view';
+export type SortOrder = 'ascending' | 'descending';
+/**
+ * Home > Sort: orders the selected paragraphs by their text, using the display language's
+ * collation with numbers compared as numbers ("Item 2" before "Item 10"). Only top-level
+ * paragraphs sort; a selection that includes a table is refused rather than partly sorted.
+ * Returns whether anything moved.
+ */
+export declare function sortParagraphs(view: EditorView, order: SortOrder, locale?: string): boolean;

package/dist/docx/spelling.d.ts

@@ -0,0 +1,6 @@
+import type { EditorView } from 'prosemirror-view';
+/**
+ * Word's Spelling toggle drives the browser's own spell checker on the editing surface. It does not
+ * bundle a dictionary, grammar checker or Word's Editor pane.
+ */
+export declare function syncSpellingButton(toolbar: HTMLElement | undefined, view: EditorView): void;

package/dist/docx/status-bar.d.ts

@@ -0,0 +1,23 @@
+export interface StatusBarHandlers {
+    setViewMode(mode: 'draft' | 'print'): void;
+    setZoom(percent: number): void;
+    showCompatibilityNotes(): void;
+}
+export interface StatusBar {
+    element: HTMLElement;
+    setPageAndWords(page: string, words: string): void;
+    setLanguage(language: string): void;
+    setNoteCount(count: number): void;
+    setViewMode(mode: 'draft' | 'print'): void;
+    setZoom(percent: number): void;
+    /** Redraws every label after the editor locale changed. */
+    relocalize(): void;
+}
+export declare const ZOOM_MIN = 50;
+export declare const ZOOM_MAX = 200;
+/**
+ * Word-style status bar: page/words/language on the left, views and zoom on the right. The shared
+ * `office-ui-status-bar` draws it from translated state and `office-ui-zoom-slider` supplies the zoom
+ * controls; this module only holds the model and routes the activations to the editor.
+ */
+export declare function createStatusBar(handlers: StatusBarHandlers): StatusBar;

package/dist/docx/style-gallery.d.ts

@@ -0,0 +1,22 @@
+import { type DocumentModel } from 'ooxml-core/docx';
+/** One tile: a style id (`''` is the paragraph's own default) and the name shown under its sample. */
+export interface GalleryStyle {
+    id: string;
+    name: string;
+}
+export type StyleKind = 'paragraph' | 'character';
+/** The paragraph styles Word shows as gallery tiles: the default first, technical styles left out. */
+export declare function recommendedStyles(all: readonly GalleryStyle[]): GalleryStyle[];
+/** The character styles Word offers in the gallery (Emphasis, Strong, ...), not linked or technical ones. */
+export declare function recommendedCharacterStyles(all: readonly GalleryStyle[]): GalleryStyle[];
+/** A tile previewing `style` on paper; `choose` receives the style id when it is clicked. */
+/** Word shows built-in style names capitalised ("Heading 1") although the file stores "heading 1". */
+export declare const displayStyleName: (name: string) => string;
+export declare function createStyleTile(style: GalleryStyle, model: DocumentModel, kind: StyleKind, choose: (id: string) => void): HTMLButtonElement;
+/** Marks the tile for `selected` pressed and (un)disables all of them. */
+export declare function markSelectedTiles(root: ParentNode, selected: string, disabled: boolean): void;
+/**
+ * Word's Styles gallery: a scrolling strip of tiles, each previewing its style. Tiles are rebuilt
+ * only when the list changes; `selected` just moves the pressed state. `choose` receives the id.
+ */
+export declare function syncStyleGallery(gallery: HTMLElement, styles: readonly GalleryStyle[], selected: string, model: DocumentModel, choose: (id: string) => void, disabled: boolean): void;

package/dist/docx/styles/index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Token presets are generated from theme/defaults.ts so the TypeScript presets and the shadow-root
+ * CSS cannot drift. `theme="auto"` (the default) follows the OS; explicit values always win.
+ */
+export declare const themeTokenText: string;
+export declare const editorStyleText: string;

package/dist/docx/styles-group.d.ts

@@ -0,0 +1,7 @@
+import type { DocumentModel } from 'ooxml-core/docx';
+import type { EditorView } from 'prosemirror-view';
+import { type EditorLocale } from './localization';
+/** Builds the Styles group on first use and keeps its gallery, tiles and state select current. */
+export declare function syncStylePicker(toolbar: HTMLElement, view: EditorView, model: DocumentModel, locale: EditorLocale): void;
+/** Removes the Styles group and its pane, so a new document builds them afresh. */
+export declare function resetStylePicker(toolbar?: HTMLElement): void;

package/dist/docx/styles-pane.d.ts

@@ -0,0 +1,15 @@
+import { type EditorLocale } from './localization';
+import type { StylesData } from './styles-popover';
+export interface StylesPane {
+    element: HTMLElement;
+    readonly isOpen: boolean;
+    open(): void;
+    close(): void;
+    /** Redraws the lists for the current document and selection (a no-op while closed). */
+    render(data: StylesData, locale: EditorLocale): void;
+}
+/**
+ * Word's Styles pane: a docked list of every paragraph and character style. Each row previews its
+ * style; choosing one applies it to the selection without closing the pane.
+ */
+export declare function createStylesPane(onClose: () => void): StylesPane;

package/dist/docx/styles-popover.d.ts

@@ -0,0 +1,24 @@
+import type { DocumentModel } from 'ooxml-core/docx';
+import { type GalleryStyle } from './style-gallery';
+/** Everything the expanded gallery and the Styles pane show and can do. */
+export interface StylesData {
+    /** Recommended styles, for the gallery and its expanded view. */
+    paragraph: GalleryStyle[];
+    character: GalleryStyle[];
+    /** Every style, for the Styles pane. */
+    allParagraph: GalleryStyle[];
+    allCharacter: GalleryStyle[];
+    selectedParagraph: string;
+    selectedCharacter: string;
+    model: DocumentModel;
+    disabled: boolean;
+    chooseParagraph(id: string): void;
+    chooseCharacter(id: string): void;
+    clearFormatting(): void;
+    openPane(): void;
+}
+/**
+ * Word's expanded Styles gallery: every paragraph style and every character style as preview
+ * tiles, then Clear Formatting and the Styles pane. Choosing a tile applies it and closes.
+ */
+export declare function openStylesGallery(anchor: HTMLElement, data: StylesData, onClose: () => void): void;

package/dist/docx/tab-stops-view.d.ts

@@ -0,0 +1,8 @@
+import { Plugin } from 'prosemirror-state';
+import { DecorationSet } from 'prosemirror-view';
+/**
+ * Sizes tabs on the editing surface at Word's tab stops (custom left/right/center/decimal stops
+ * with leaders, then default half-inch stops) by measuring the rendered text, since CSS tab sizes
+ * cannot follow per-paragraph stops. Display only: nothing enters the document or its history.
+ */
+export declare function tabStopsPlugin(): Plugin<DecorationSet>;

package/dist/docx/table-border-commands.d.ts

@@ -0,0 +1,51 @@
+import type { EditorState } from 'prosemirror-state';
+import type { Node as ProseMirrorNode } from 'prosemirror-model';
+import type { EditorView } from 'prosemirror-view';
+/** Borders for the cells of a simple (structure-editable) table, edited per cell like Word's Borders menu. */
+export type CellSide = 'top' | 'bottom' | 'left' | 'right';
+export type TableBorderPreset = 'none' | 'bottom' | 'top' | 'left' | 'right' | 'all' | 'outside' | 'insideH' | 'insideV';
+export interface BorderPen {
+    style: string;
+    sizeEighthPoints: number;
+    color?: string;
+}
+export interface TableBorderContext {
+    tablePos: number;
+    rows: number;
+    columns: number;
+    /** Inclusive cell rectangle covered by the selection. */
+    rect: {
+        top: number;
+        bottom: number;
+        left: number;
+        right: number;
+    };
+    cells: Array<{
+        pos: number;
+        row: number;
+        column: number;
+        node: ProseMirrorNode;
+    }>;
+}
+/** Word's default border pen: a single 0.5 pt automatic-colour line. */
+export declare const DEFAULT_PEN: BorderPen;
+/** The table and the cells the selection touches, or null outside a simple table. */
+export declare function tableBorderContext(state: EditorState): TableBorderContext | null;
+/**
+ * Home > Borders for table cells. A side preset toggles: when every targeted edge already shows a
+ * line they are removed, otherwise they are drawn with `pen`. `none` clears every edge of the
+ * selection, inside and out.
+ */
+export declare function setCellBorders(view: EditorView, preset: TableBorderPreset, pen?: BorderPen): boolean;
+export interface CellBorderSettings {
+    scope: 'cell' | 'table';
+    /** Edges to draw with `pen`; the others of the scope are cleared. */
+    sides: Partial<Record<CellSide | 'insideH' | 'insideV', boolean>>;
+    pen: BorderPen;
+    /** Omitted preserves existing fill, null explicitly clears it. */
+    fill?: string | null;
+}
+/** Borders and Shading dialog, Cell or Table scope: draws the checked edges and clears the others. */
+export declare function applyCellBorderSettings(view: EditorView, settings: CellBorderSettings): boolean;
+/** What the dialog shows for `scope`: which edges have a line, and the first line's pen. */
+export declare function readCellBorderSettings(state: EditorState, scope: 'cell' | 'table'): CellBorderSettings | null;

package/dist/docx/table-cell-alignment-dialog.d.ts

@@ -0,0 +1,8 @@
+import type { TableCell } from 'ooxml-core/docx';
+import type { tablePropertiesContext } from './table-properties';
+/** Exposes editable alignments without normalizing untouched imported or mixed values. */
+export declare function createCellAlignmentField(): {
+    element: HTMLFieldSetElement;
+    load(context: NonNullable<ReturnType<typeof tablePropertiesContext>>): void;
+    patch(): TableCell['verticalAlign'] | null | undefined;
+};

package/dist/docx/table-cell-margins-dialog.d.ts

@@ -0,0 +1,9 @@
+import { type TableCellMargins } from 'ooxml-core/docx';
+import type { tablePropertiesContext } from './table-properties';
+/** Selected-cell overrides stay separate from the table's defaults and untouched mixed values. */
+export declare function createCellMarginFields(onChange: () => void): {
+    element: HTMLFieldSetElement;
+    load(context: NonNullable<ReturnType<typeof tablePropertiesContext>>): void;
+    valid(): boolean;
+    patch(): TableCellMargins | null | undefined;
+};

package/dist/docx/table-commands.d.ts

@@ -0,0 +1,6 @@
+import type { EditorView } from 'prosemirror-view';
+export type TableCommand = 'rowBefore' | 'rowAfter' | 'deleteRow' | 'columnBefore' | 'columnAfter' | 'deleteColumn' | 'deleteTable';
+/** Reports whether the current selection can receive the requested table edit. */
+export declare function canExecuteTableCommand(view: EditorView, action: TableCommand): boolean;
+/** Applies a structural command to the rectangular table containing the selection. */
+export declare function executeTableCommand(view: EditorView, action: TableCommand): boolean;

package/dist/docx/table-model-adapter.d.ts

@@ -0,0 +1,15 @@
+import type { Node as ProseMirrorNode } from 'prosemirror-model';
+import type { Paragraph, Table, TableStyleCatalog } from 'ooxml-core/docx';
+export declare function tableNode(block: Table, paragraphNode: (paragraph: Paragraph) => ProseMirrorNode, tableStyles?: TableStyleCatalog): ProseMirrorNode;
+/** Reads editable formatting from nodes rather than a stale prior model. */
+export declare function tableFormattingFromNode(node: ProseMirrorNode): {
+    rowProperties: Table['rowProperties'];
+    cellMargins: Table['cellMargins'];
+};
+/** Rebuilds a simple (structurally editable) table directly from its visible ProseMirror rows. */
+export declare function convertSimpleTable(node: ProseMirrorNode, convertParagraph: (paragraph: ProseMirrorNode) => Paragraph, prior?: Table): Table['rows'];
+/**
+ * Patches paragraph content back into a merged/nested/complex table's prior structure by cell
+ * identity, leaving row/cell layout, merges and descriptive properties exactly as they were.
+ */
+export declare function convertMergedTable(node: ProseMirrorNode, prior: Table, convertParagraph: (paragraph: ProseMirrorNode) => Paragraph): Table;

package/dist/docx/table-picker.d.ts

@@ -0,0 +1,10 @@
+/** Word's table size picker: how many columns and rows fit the grid, and the hard limits. */
+export declare const PICKER_COLUMNS = 10;
+export declare const PICKER_ROWS = 8;
+/** Clamps a typed size to what the editor inserts. */
+export declare function clampTableSize(value: number, max: number): number;
+/**
+ * The Insert > Table drop-down: hover a grid to preview "columns x rows" and click to insert, or
+ * type a size. Arrow keys move over the grid and Enter inserts, so it works without a mouse.
+ */
+export declare function openTablePicker(anchor: HTMLElement, onPick: (rows: number, columns: number) => void, onClose: () => void): void;

package/dist/docx/table-properties-dialog.d.ts

@@ -0,0 +1,3 @@
+import type { EditorView } from 'prosemirror-view';
+import type { FormatDialog } from './font-dialog';
+export declare function createTablePropertiesDialog(viewOf: () => EditorView | undefined): FormatDialog;