ooxml-ui 0.27.2 → 0.28.0

package/dist/xlsx/backstage/index.d.ts

@@ -0,0 +1,14 @@
+import type { BackstageHost } from './parts';
+export type { BackstageHost, EditorOptions, CalculationMode, IterationSettings } from './parts';
+export { compatibilityNotes, formatNotes } from './pages-info';
+export { createTemplateWorkbook, TEMPLATES, type TemplateId } from 'ooxml-core/xlsx/ui';
+export type BackstagePage = 'info' | 'new' | 'open' | 'saveAs' | 'print' | 'export' | 'options' | 'customize';
+export interface Backstage {
+    readonly element: HTMLElement;
+    open(page?: BackstagePage): void;
+    close(): void;
+    readonly isOpen: boolean;
+    /** Re-renders the open page (after a locale change). */
+    relocalize(): void;
+}
+export declare function createBackstage(host: BackstageHost): Backstage;

package/dist/xlsx/backstage/pages-file.d.ts

@@ -0,0 +1,6 @@
+import { type PageContext } from './parts';
+export declare function renderNew(page: PageContext): void;
+export declare function renderOpen(page: PageContext): void;
+export declare function renderSaveAs(page: PageContext): void;
+export declare function renderPrint(page: PageContext): void;
+export declare function renderExport(page: PageContext): void;

package/dist/xlsx/backstage/pages-info.d.ts

@@ -0,0 +1,10 @@
+/** File > Info: name and save state, compatibility notes, properties and workbook facts. */
+import type { Workbook } from 'ooxml-core/xlsx';
+import { type PageContext } from './parts';
+type T = PageContext['t'];
+/** Notes about what this editor does with the opened format (shown on Info and on load). */
+export declare function formatNotes(workbook: Workbook, t: T): string[];
+/** Every note for Info: the format notes, then what the loader reported. */
+export declare function compatibilityNotes(workbook: Workbook, t: T): string[];
+export declare function renderInfo(page: PageContext): void;
+export {};

package/dist/xlsx/backstage/pages-options.d.ts

@@ -0,0 +1,7 @@
+import { type PageContext } from './parts';
+export declare function renderOptions(page: PageContext): void;
+/**
+ * Customize Ribbon, reduced to showing and hiding: every tab, group and command with a checkbox.
+ * Unchecked commands go into `hiddenActions` (and the `ribbon-customize` event).
+ */
+export declare function renderCustomize(page: PageContext): void;

package/dist/xlsx/backstage/parts.d.ts

@@ -0,0 +1,53 @@
+/** Shared building blocks and the host interface of the File backstage pages. */
+import type { WorkbookProperties } from 'ooxml-core/xlsx';
+import type { EditorContext } from 'ooxml-core/xlsx/ui';
+import type { FileCommand } from '../events';
+import type { SaveState } from '../title-bar';
+import type { TemplateId } from 'ooxml-core/xlsx/ui';
+export type CalculationMode = 'automatic' | 'manual';
+/** Iterative calculation: maximum iterations and maximum change; undefined when off. */
+export type IterationSettings = {
+    count: number;
+    delta: number;
+} | undefined;
+export interface EditorOptions {
+    locale: string;
+    theme: string;
+    author: string;
+    calculation: CalculationMode;
+    iteration: IterationSettings;
+}
+/** What the File view needs from the editor; every value is read when a page opens. */
+export interface BackstageHost {
+    readonly ctx: EditorContext;
+    fileName(): string;
+    saveState(): SaveState;
+    fileCommand(command: FileCommand, fileName?: string): void;
+    newFromTemplate(id: TemplateId): void;
+    close(): void;
+    options(): EditorOptions;
+    setOption<K extends keyof EditorOptions>(key: K, value: EditorOptions[K]): void;
+    /** Sets a workbook property (title, author, ...); an empty value clears it. */
+    setProperty<K extends keyof WorkbookProperties>(key: K, value: WorkbookProperties[K]): void;
+    passwordProtected?(): boolean;
+    setPassword?(): Promise<void>;
+    removePassword?(): void;
+    hiddenActions(): readonly string[];
+    setHiddenActions(ids: string[]): void;
+}
+export interface PageContext {
+    host: BackstageHost;
+    content: HTMLElement;
+    t: EditorContext['t'];
+    doc: Document;
+}
+export declare function heading(page: PageContext, text: string, level?: 'h2' | 'h3'): HTMLElement;
+export declare function paragraph(page: PageContext, text: string, className?: string): HTMLElement;
+export declare function primary(page: PageContext, label: string, run: () => void): HTMLButtonElement;
+export declare function labelled(page: PageContext, label: string, control: HTMLElement): HTMLElement;
+/** An action card: a title, a description and one button. */
+export declare function card(page: PageContext, title: string, description: string, action: HTMLElement): HTMLElement;
+export declare function facts(page: PageContext, rows: Array<[string, string]>): HTMLElement;
+export declare function noteList(page: PageContext, notes: string[], empty: string): HTMLElement;
+/** Runs a file command after closing the backstage, as Excel does. */
+export declare const runFile: (page: PageContext, command: FileCommand, fileName?: string) => () => void;

package/dist/xlsx/backstage/properties-custom.d.ts

@@ -0,0 +1,4 @@
+import type { Workbook } from 'ooxml-core/xlsx';
+import { type PageContext } from './parts';
+/** Edits known custom-property values while retaining unknown variants verbatim. */
+export declare function customProperties(page: PageContext, workbook: Workbook): HTMLElement;

package/dist/xlsx/clipboard.d.ts

@@ -0,0 +1,26 @@
+import { type CellRange, type ClipboardPayload, type PasteMode } from 'ooxml-core/xlsx';
+import type { EditorContext } from 'ooxml-core/xlsx/ui';
+export interface ClipboardHost {
+    ctx: EditorContext;
+    /** The focus sink textarea (native copy/cut/paste events fire on it). */
+    sink: HTMLTextAreaElement;
+    isEditing(): boolean;
+    /** Shows (or clears) the marching-ants marquee. */
+    setMarquee(range: CellRange | undefined, sheet: number): void;
+    /** Selects the pasted range. */
+    selectRange(range: CellRange): void;
+}
+export interface GridClipboard {
+    copy(cut: boolean): ClipboardPayload | undefined;
+    prepareNativeCopy(cut: boolean): void;
+    writeSystem(cut: boolean): Promise<boolean>;
+    pasteSystem(mode?: PasteMode): Promise<boolean>;
+    paste(data: {
+        html?: string;
+        text?: string;
+    }, mode?: PasteMode): boolean;
+    clearMarquee(): boolean;
+    internal(): ClipboardPayload | undefined;
+    destroy(): void;
+}
+export declare function createGridClipboard(host: ClipboardHost): GridClipboard;

package/dist/xlsx/commands/index.d.ts

@@ -0,0 +1,11 @@
+import type { Command } from 'ooxml-core/xlsx/ui';
+import type { EditorContext } from 'ooxml-core/xlsx/ui';
+import { commandTabs } from '../ribbon/tabs/index.js';
+/** Every UI-COMMANDS command (fresh objects; safe to register on several editors). */
+export declare function allCommands(): Command[];
+/**
+ * Registers the commands, dialogs and ribbon tabs on `ctx`. Returns a disposer for the listeners
+ * it adds (the format painter).
+ */
+export declare function installCommands(ctx: EditorContext): () => void;
+export { commandTabs };

package/dist/xlsx/commands/insert-now.d.ts

@@ -0,0 +1,4 @@
+import type { Command } from 'ooxml-core/xlsx/ui';
+/** Today's date or the current time (to the minute) as a serial, in local wall time. */
+export declare function nowSerial(kind: 'date' | 'time', now?: Date): number;
+export declare function insertNowCommands(): Command[];

package/dist/xlsx/commands/insert.d.ts

@@ -0,0 +1,7 @@
+import { type ChartType } from 'ooxml-core/xlsx';
+import type { Command } from 'ooxml-core/xlsx/ui';
+import type { EditorContext } from 'ooxml-core/xlsx/ui';
+export declare const CHART_TYPES: ReadonlyArray<readonly [type: ChartType, label: string, glyph: string]>;
+/** Inserts a picture file at the active cell (scaled to at most 640 px wide, like Excel's fit). */
+export declare function insertPicture(ctx: EditorContext, file: File): Promise<void>;
+export declare function insertCommands(): Command[];

package/dist/xlsx/commands/register-icons.d.ts

@@ -0,0 +1,2 @@
+/** Registers every glyph once (idempotent; safe during SSR because it touches no DOM). */
+export declare function registerSheetIcons(): void;

package/dist/xlsx/commands/review.d.ts

@@ -0,0 +1,6 @@
+import type { Comment } from 'ooxml-core/xlsx';
+import type { Command } from 'ooxml-core/xlsx/ui';
+import type { EditorContext } from 'ooxml-core/xlsx/ui';
+declare const commentAt: (ctx: EditorContext) => Comment | undefined;
+export declare function reviewCommands(): Command[];
+export { commentAt };

package/dist/xlsx/commands/styles.d.ts

@@ -0,0 +1,17 @@
+import type { Command } from 'ooxml-core/xlsx/ui';
+import type { EditorContext } from 'ooxml-core/xlsx/ui';
+import { COLOR_SCALES, DATA_BAR_COLORS, ICON_SETS } from 'ooxml-core/xlsx/ui';
+/** Quick rule kinds opened by the Highlight Cells and Top / Bottom menus. */
+export declare const QUICK_RULES: ReadonlyArray<readonly [kind: string, label: string]>;
+export declare function styleCommands(): Command[];
+export declare const tableStyleGalleryItems: (ctx: EditorContext) => {
+    id: string;
+    label: string;
+    preview: string;
+}[];
+export declare const cellStyleGalleryItems: (ctx: EditorContext) => {
+    id: string;
+    preview?: string;
+    label: string;
+}[];
+export { COLOR_SCALES, DATA_BAR_COLORS, ICON_SETS };

package/dist/xlsx/commands/test-support.d.ts

@@ -0,0 +1,25 @@
+import { type Workbook } from 'ooxml-core/xlsx';
+import type { EditorContext, GridController } from 'ooxml-core/xlsx/ui';
+export interface TestContext extends EditorContext {
+    select(ref: string): void;
+    toasts: {
+        message: string;
+        kind?: string;
+    }[];
+    events: {
+        type: string;
+        detail: unknown;
+    }[];
+    setReadOnly(value: boolean): void;
+}
+export declare function createTestContext(workbook?: Workbook, options?: {
+    grid?: Partial<GridController>;
+    dom?: boolean;
+}): TestContext;
+/** The open dialog element by `data-dialog` name. */
+export declare function dialogEl(ctx: EditorContext, name: string): HTMLElement;
+export declare function clickButton(root: HTMLElement, label: string): void;
+export declare function inputByLabel<T extends HTMLElement = HTMLInputElement>(root: HTMLElement, label: string): T;
+export declare function setValue(el: HTMLInputElement | HTMLSelectElement | HTMLTextAreaElement, value: string): void;
+export declare function pressKey(el: HTMLElement, key: string): void;
+export declare const tick: () => Promise<void>;

package/dist/xlsx/commands/view.d.ts

@@ -0,0 +1,7 @@
+import type { Command } from 'ooxml-core/xlsx/ui';
+import type { EditorContext } from 'ooxml-core/xlsx/ui';
+export declare const currentZoom: (ctx: EditorContext) => number;
+export declare function setZoom(ctx: EditorContext, percent: number): void;
+/** The zoom at which the selection fills the visible grid (10 to 400 percent). */
+export declare function zoomToFit(ctx: EditorContext): number | undefined;
+export declare function viewCommands(): Command[];

package/dist/xlsx/component.d.ts

@@ -0,0 +1,66 @@
+/**
+ * `<xlsx-editor>`: the properties, attributes and lifecycle. Methods are in element-api.ts, state
+ * in editor-core.ts and the DOM in editor-shell.ts.
+ */
+import type { Workbook } from 'ooxml-core/xlsx';
+import { XlsxEditorApi } from './element-api';
+import type { XlsxEditorEventMap } from './events';
+import type { EditorLocale, EditorLocaleInput } from 'ooxml-core/xlsx/ui';
+import { type EditorThemeMode, type XlsxTheme } from './theme';
+/** Theme tokens, applied to the host as `--xve-<kebab-key>` custom properties. */
+export type XlsxThemeColors = Partial<XlsxTheme>;
+type Listener<K extends keyof XlsxEditorEventMap> = (this: XlsxEditorElement, event: CustomEvent<XlsxEditorEventMap[K]>) => unknown;
+/** Typed event overloads (redeclaring hides the inherited ones, so the DOM map is repeated). */
+export interface XlsxEditorElement {
+    addEventListener<K extends keyof XlsxEditorEventMap>(type: K, listener: Listener<K>, options?: boolean | AddEventListenerOptions): void;
+    addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: XlsxEditorElement, event: HTMLElementEventMap[K]) => unknown, options?: boolean | AddEventListenerOptions): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+    removeEventListener<K extends keyof XlsxEditorEventMap>(type: K, listener: Listener<K>, options?: boolean | EventListenerOptions): void;
+    removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: XlsxEditorElement, event: HTMLElementEventMap[K]) => unknown, options?: boolean | EventListenerOptions): void;
+    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+}
+export declare class XlsxEditorElement extends XlsxEditorApi {
+    static get observedAttributes(): readonly string[];
+    private shell;
+    connectedCallback(): void;
+    attributeChangedCallback(name: string, _old: string | null, value: string | null): void;
+    /** Interface language: `en`, `fr`, `de`, `es`, `zh-CN` (any tag mapping to one). */
+    get locale(): EditorLocale;
+    set locale(value: EditorLocaleInput);
+    get readOnly(): boolean;
+    set readOnly(value: boolean);
+    /** Shown in the title bar and used by Save and Download. Default `Book1.xlsx`. */
+    get fileName(): string;
+    set fileName(value: string);
+    /** Author recorded on new comments. Default `Author`. */
+    get authorName(): string;
+    set authorName(value: string);
+    /** `light`, `dark` or `auto` (default, follows the OS). */
+    get theme(): EditorThemeMode;
+    set theme(value: EditorThemeMode);
+    get showToolbar(): boolean;
+    set showToolbar(value: boolean);
+    get showFormulaBar(): boolean;
+    set showFormulaBar(value: boolean);
+    /** Token overrides applied inline as `--xve-*` custom properties. */
+    get themeColors(): XlsxThemeColors;
+    set themeColors(value: XlsxThemeColors | undefined);
+    /** Command ids the ribbon, menus, Tell me and shortcuts leave out. */
+    get hiddenActions(): string[];
+    set hiddenActions(value: readonly string[]);
+    /** The open workbook model, or null. Assigning one shows it with a fresh undo history. */
+    get workbook(): Workbook | null;
+    set workbook(value: Workbook | null);
+    /** Unsaved changes since the last load, save or `markClean()`. */
+    get dirty(): boolean;
+    get activeSheet(): number;
+    set activeSheet(index: number);
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'xlsx-editor': XlsxEditorElement;
+    }
+}
+/** Registers `<xlsx-editor>` once; a no-op without `customElements` (server rendering). */
+export declare function defineXlsxEditor(): void;
+export {};

package/dist/xlsx/context-menu/index.d.ts

@@ -0,0 +1,2 @@
+export { cellMenu, columnHeaderMenu, rowHeaderMenu, tabMenu, type CellMenuState, type HeaderMenuState, type MenuEntry, type TabMenuState, } from 'ooxml-core/xlsx/ui';
+export { currentContextMenu, openContextMenu, type ContextMenuHandle, type OpenMenuOptions, } from './menu.js';

package/dist/xlsx/context-menu/menu.d.ts

@@ -0,0 +1,14 @@
+import type { EditorContext } from 'ooxml-core/xlsx/ui';
+import type { MenuEntry } from 'ooxml-core/xlsx/ui';
+export interface ContextMenuHandle {
+    close(): void;
+    readonly element: HTMLElement;
+}
+export interface OpenMenuOptions {
+    onClose?: () => void;
+    /** Called after an item ran or the menu was dismissed with Escape/Tab. */
+    restoreFocus?: () => void;
+}
+/** The menu currently open for a context, if any. */
+export declare const currentContextMenu: (ctx: EditorContext) => ContextMenuHandle | undefined;
+export declare function openContextMenu(ctx: EditorContext, entries: MenuEntry[], x: number, y: number, options?: OpenMenuOptions): ContextMenuHandle;

package/dist/xlsx/dialogs/cell-shift.d.ts

@@ -0,0 +1,5 @@
+import type { EditorContext } from 'ooxml-core/xlsx/ui';
+export type ShiftChoice = 'right' | 'down' | 'left' | 'up' | 'row' | 'column';
+export declare function openCellShift(ctx: EditorContext, mode: 'insert' | 'delete'): Promise<ShiftChoice | undefined>;
+/** Data > Group / Ungroup on a selection that is neither whole rows nor whole columns. */
+export declare function openOutlineAxis(ctx: EditorContext, mode: 'group' | 'ungroup'): Promise<'rows' | 'cols' | undefined>;

package/dist/xlsx/dialogs/cf-common.d.ts

@@ -0,0 +1,29 @@
+import { type CellRange, type ConditionalOperator, type ConditionalRule, type DifferentialStyle, type TimePeriod } from 'ooxml-core/xlsx';
+import type { EditorContext } from 'ooxml-core/xlsx/ui';
+/** A rule operand as typed: `=...` is a formula, a number stays, other text becomes a literal. */
+export declare function operand(text: string): string;
+/** The text a stored operand shows in a field (formulas get their `=` back). */
+export declare function operandText(formula: string | undefined): string;
+/** Parses "A1:B2 C3" or "=$A$1:$B$2,C3" into ranges; undefined when any part is invalid. */
+export declare function parseRefs(text: string): CellRange[] | undefined;
+export declare const formatRefs: (ranges: CellRange[]) => string;
+export declare const OPERATORS: ReadonlyArray<readonly [ConditionalOperator, string]>;
+/** "A Date Occurring" periods in the order Excel's drop-down lists them. */
+export declare const TIME_PERIOD_LABELS: ReadonlyArray<readonly [TimePeriod, string]>;
+/** A one-line description of a rule, as the Rules Manager lists it. */
+export declare function describeRule(ctx: EditorContext, rule: ConditionalRule): string;
+/** The "AaBbCcYyZz" sample of a differential style (or a gradient for scales and bars). */
+export declare function previewBox(ctx: EditorContext): {
+    element: HTMLDivElement;
+    show(rule: ConditionalRule | DifferentialStyle | undefined): void;
+};
+/** Opens Format Cells in differential mode; resolves the new style or undefined. */
+export declare function customFormat(ctx: EditorContext, dxf: DifferentialStyle): Promise<DifferentialStyle | undefined>;
+/** Whether a rule carries a differential style. */
+export declare const hasStyle: (rule: ConditionalRule) => rule is Extract<ConditionalRule, {
+    style: DifferentialStyle;
+}>;
+/** Whether a rule type supports Stop If True in the model. */
+export declare const hasStopIfTrue: (rule: ConditionalRule) => rule is Extract<ConditionalRule, {
+    stopIfTrue?: boolean;
+}>;

package/dist/xlsx/dialogs/cf-manager.d.ts

@@ -0,0 +1,8 @@
+import { type ConditionalFormat } from 'ooxml-core/xlsx';
+import type { EditorContext } from 'ooxml-core/xlsx/ui';
+import { type RuleEdit } from './cf-rule.js';
+/** Flattens a sheet's formats into one entry per rule, sorted by priority. */
+export declare function stageRules(formats: ConditionalFormat[]): RuleEdit[];
+/** One conditional format per staged rule, priorities 1..n in list order. */
+export declare function unstageRules(entries: RuleEdit[]): ConditionalFormat[];
+export declare function cfManagerDialog(ctx: EditorContext): Promise<ConditionalFormat[] | undefined>;

package/dist/xlsx/dialogs/cf-quick.d.ts

@@ -0,0 +1,10 @@
+import type { ConditionalRule, DifferentialStyle, TimePeriod } from 'ooxml-core/xlsx';
+import type { EditorContext } from 'ooxml-core/xlsx/ui';
+export declare const QUICK_KINDS: string[];
+/** The rule a quick dialog builds from its fields (exported for tests). */
+export declare function quickRule(kind: string, values: string[], style: DifferentialStyle, extra: {
+    rank?: number;
+    unique?: boolean;
+    period?: TimePeriod;
+}): ConditionalRule;
+export declare function cfQuickDialog(ctx: EditorContext, props: unknown): Promise<ConditionalRule | undefined>;

package/dist/xlsx/dialogs/cf-rule-panels.d.ts

@@ -0,0 +1,20 @@
+import type { ConditionalRule, DifferentialStyle } from 'ooxml-core/xlsx';
+import type { EditorContext } from 'ooxml-core/xlsx/ui';
+export type PanelRead = ConditionalRule | {
+    error: string;
+    control: HTMLElement;
+    vars?: Record<string, string | number>;
+};
+export interface RulePanel {
+    element: HTMLElement;
+    /** Whether the panel's rules take a differential style (Format... button). */
+    styled: boolean;
+    load(rule: ConditionalRule): void;
+    read(style: DifferentialStyle): PanelRead;
+    focus(): void;
+}
+export declare function containsPanel(ctx: EditorContext): RulePanel;
+export declare function topPanel(ctx: EditorContext): RulePanel;
+export declare function averagePanel(ctx: EditorContext): RulePanel;
+export declare function uniquePanel(ctx: EditorContext): RulePanel;
+export declare function formulaPanel(ctx: EditorContext): RulePanel;

package/dist/xlsx/dialogs/cf-rule-scale.d.ts

@@ -0,0 +1,3 @@
+import type { EditorContext } from 'ooxml-core/xlsx/ui';
+import type { RulePanel } from './cf-rule-panels.js';
+export declare function valuesPanel(ctx: EditorContext): RulePanel;

package/dist/xlsx/dialogs/cf-rule.d.ts

@@ -0,0 +1,13 @@
+import type { CellRange, ConditionalRule } from 'ooxml-core/xlsx';
+import type { EditorContext } from 'ooxml-core/xlsx/ui';
+export interface RuleEdit {
+    rule: ConditionalRule;
+    ranges: CellRange[];
+}
+type Kind = 'values' | 'contains' | 'top' | 'average' | 'unique' | 'formula';
+export declare function kindOf(rule: ConditionalRule): Kind;
+/** Shows the rule editor; resolves the edited rule (priority 1, the caller renumbers). */
+export declare function editRuleDialog(ctx: EditorContext, initial?: RuleEdit): Promise<RuleEdit | undefined>;
+/** The 'cf-rule' dialog: a new rule on the selection, or `{ format, rule }` edits that rule. */
+export declare function cfRuleDialog(ctx: EditorContext, props: unknown): Promise<RuleEdit | undefined>;
+export {};

package/dist/xlsx/dialogs/comments-list.d.ts

@@ -0,0 +1,2 @@
+import type { EditorContext } from 'ooxml-core/xlsx/ui';
+export declare function openCommentsList(ctx: EditorContext): Promise<string | undefined>;

package/dist/xlsx/dialogs/create-names.d.ts

@@ -0,0 +1,8 @@
+import { type DefinedName } from 'ooxml-core/xlsx';
+import type { EditorContext } from 'ooxml-core/xlsx/ui';
+export type LabelEdge = 'top' | 'left' | 'bottom' | 'right';
+/** Turns label text into a valid name: spaces to `_`, other invalid characters dropped. */
+export declare function sanitizeName(label: string): string | undefined;
+/** The names a selection yields for the chosen label edges. */
+export declare function namesFromSelection(ctx: EditorContext, edges: readonly LabelEdge[]): DefinedName[];
+export declare function openCreateNames(ctx: EditorContext): Promise<number | undefined>;

package/dist/xlsx/dialogs/create-table.d.ts

@@ -0,0 +1,6 @@
+import { type Table } from 'ooxml-core/xlsx';
+import type { EditorContext } from 'ooxml-core/xlsx/ui';
+export interface CreateTableProps {
+    styleName?: string;
+}
+export declare function openCreateTable(ctx: EditorContext, props?: CreateTableProps): Promise<Table | undefined>;

package/dist/xlsx/dialogs/data-validation.d.ts

@@ -0,0 +1,3 @@
+import { type DataValidation } from 'ooxml-core/xlsx';
+import type { EditorContext } from 'ooxml-core/xlsx/ui';
+export declare function dataValidationDialog(ctx: EditorContext): Promise<DataValidation | null | undefined>;

package/dist/xlsx/dialogs/define-name.d.ts

@@ -0,0 +1,9 @@
+import { type DefinedName } from 'ooxml-core/xlsx';
+import type { EditorContext } from 'ooxml-core/xlsx/ui';
+export interface DefineNameProps {
+    name?: string;
+    localSheet?: number;
+}
+/** `=Sheet1!$A$1:$B$2` for the current selection. */
+export declare function selectionReference(ctx: EditorContext): string;
+export declare function openDefineName(ctx: EditorContext, props?: DefineNameProps): Promise<DefinedName | undefined>;

package/dist/xlsx/dialogs/fields.d.ts

@@ -0,0 +1,47 @@
+import type { EditorContext } from 'ooxml-core/xlsx/ui';
+type El = HTMLElement;
+declare const make: <K extends keyof HTMLElementTagNameMap>(ctx: EditorContext, tag: K, className?: string) => HTMLElementTagNameMap[K];
+export declare const el: typeof make;
+export declare const nextId: (prefix: string) => string;
+/** A labelled control in one row: `<label>text</label><control>`. */
+export declare function field<T extends El>(ctx: EditorContext, label: string, control: T): HTMLLabelElement;
+export declare function textInput(ctx: EditorContext, value?: string, name?: string): HTMLInputElement;
+export declare function numberInput(ctx: EditorContext, value: number, min: number, max: number, step?: number): HTMLInputElement;
+export declare function textArea(ctx: EditorContext, value?: string, rows?: number): HTMLTextAreaElement;
+/** A native select; option labels are English keys unless `raw` is set. */
+export declare function select(ctx: EditorContext, options: ReadonlyArray<readonly [value: string, label: string]>, value?: string, raw?: boolean): HTMLSelectElement;
+export declare function checkbox(ctx: EditorContext, label: string, checked?: boolean): {
+    wrapper: HTMLLabelElement;
+    input: HTMLInputElement;
+};
+/** A radio group; returns the wrapper and a getter / setter for the chosen value. */
+export declare function radios(ctx: EditorContext, legend: string, options: ReadonlyArray<readonly [value: string, label: string]>, value: string): {
+    element: HTMLFieldSetElement;
+    get(): string;
+    set(v: string): void;
+    inputs: HTMLInputElement[];
+};
+export declare function fieldset(ctx: EditorContext, legend: string, ...children: El[]): HTMLFieldSetElement;
+export declare function row(ctx: EditorContext, ...children: El[]): HTMLDivElement;
+export declare function text(ctx: EditorContext, key: string, className?: string, vars?: Record<string, string | number>): HTMLParagraphElement;
+/** A list box (`role="listbox"`) of options with keyboard selection; `raw` labels are shown as is. */
+export declare function listBox(ctx: EditorContext, label: string, onChange?: (value: string) => void, onActivate?: (value: string) => void): {
+    element: HTMLDivElement;
+    setItems(items: ReadonlyArray<readonly [value: string, label: string]>, raw?: boolean): void;
+    value(): string | undefined;
+    select(value: string): void;
+};
+/** Accessible tabs (`role="tablist"`, arrow keys move between tabs). */
+export declare function tabs(ctx: EditorContext, pages: ReadonlyArray<{
+    id: string;
+    label: string;
+    panel: HTMLElement;
+}>, initial?: string): {
+    element: HTMLDivElement;
+    show(id: string): void;
+    current(): string;
+};
+export declare function panel(ctx: EditorContext, ...children: El[]): HTMLDivElement;
+/** Marks a field invalid with a translated message, focusing it; returns undefined. */
+export declare function invalid(ctx: EditorContext, control: HTMLElement, message: string, vars?: Record<string, string | number>): undefined;
+export {};

package/dist/xlsx/dialogs/fill-series.d.ts

@@ -0,0 +1,10 @@
+import type { EditorContext } from 'ooxml-core/xlsx/ui';
+export type SeriesType = 'linear' | 'growth' | 'date';
+export type DateUnit = 'day' | 'weekday' | 'month' | 'year';
+/** `count` values starting at `start`; stops before passing `stop`. */
+export declare function seriesValues(start: number, count: number, type: SeriesType, step: number, options?: {
+    stop?: number;
+    unit?: DateUnit;
+    date1904?: boolean;
+}): number[];
+export declare function openFillSeries(ctx: EditorContext): Promise<number | undefined>;

package/dist/xlsx/dialogs/find-replace.d.ts

@@ -0,0 +1,8 @@
+import { type FindMatch } from 'ooxml-core/xlsx';
+import type { EditorContext } from 'ooxml-core/xlsx/ui';
+export interface FindReplaceProps {
+    tab?: 'find' | 'replace';
+}
+/** Matches after the active cell first (wrapping), as Find Next walks them. */
+export declare function orderFrom(matches: FindMatch[], sheet: number, row: number, col: number, byColumns: boolean): FindMatch[];
+export declare function openFindReplace(ctx: EditorContext, props?: FindReplaceProps): Promise<number | undefined>;

package/dist/xlsx/dialogs/format-cells/alignment-tab.d.ts

@@ -0,0 +1,5 @@
+import type { FormatTab, TabInit } from 'ooxml-core/xlsx/ui';
+/** Excel's textRotation (0-90 up, 91-180 down) as dialog degrees (-90 to 90). */
+export declare const rotationToDegrees: (r: number) => number;
+export declare const degreesToRotation: (d: number) => number;
+export declare function alignmentTab(init: TabInit): FormatTab;

package/dist/xlsx/dialogs/format-cells/border-tab.d.ts

@@ -0,0 +1,4 @@
+import type { BorderStyle } from 'ooxml-core/xlsx';
+import type { FormatTab, TabInit } from 'ooxml-core/xlsx/ui';
+export declare const LINE_STYLES: ReadonlyArray<readonly [BorderStyle | 'none', string, string]>;
+export declare function borderTab(init: TabInit): FormatTab;

package/dist/xlsx/dialogs/format-cells/color-swatches.d.ts

@@ -0,0 +1,10 @@
+import type { Color } from 'ooxml-core/xlsx';
+import type { EditorContext } from 'ooxml-core/xlsx/ui';
+export declare const colorKey: (color: Color | undefined) => string;
+export interface SwatchGrid {
+    element: HTMLDivElement;
+    value(): Color | undefined;
+    set(color: Color | undefined): void;
+}
+/** `noneLabel` names the "no colour" button (`Automatic` or `No Color`). */
+export declare function swatchGrid(ctx: EditorContext, label: string, noneLabel: string, initial: Color | undefined, onChange?: (color: Color | undefined) => void): SwatchGrid;

package/dist/xlsx/dialogs/format-cells/fill-tab.d.ts

@@ -0,0 +1,11 @@
+import type { Color, Fill, PatternType } from 'ooxml-core/xlsx';
+import type { FormatTab, TabInit } from 'ooxml-core/xlsx/ui';
+export declare const PATTERNS: ReadonlyArray<readonly [PatternType, string]>;
+/** The dialog's three fields for a fill. */
+export declare function readFill(fill: Fill, dxf: boolean): {
+    background?: Color;
+    patternColor?: Color;
+    pattern: PatternType;
+};
+export declare function buildFill(background: Color | undefined, patternColor: Color | undefined, pattern: PatternType, dxf: boolean): Fill;
+export declare function fillTab(init: TabInit): FormatTab;

package/dist/xlsx/dialogs/format-cells/font-tab.d.ts

@@ -0,0 +1,2 @@
+import type { FormatTab, TabInit } from 'ooxml-core/xlsx/ui';
+export declare function fontTab(init: TabInit): FormatTab;

package/dist/xlsx/dialogs/format-cells/index.d.ts

@@ -0,0 +1,6 @@
+import type { DifferentialStyle } from 'ooxml-core/xlsx';
+import type { EditorContext } from 'ooxml-core/xlsx/ui';
+import type { FormatCellsProps } from 'ooxml-core/xlsx/ui';
+export type { FormatCellsProps, FormatTabId } from 'ooxml-core/xlsx/ui';
+export declare function openFormatCells(ctx: EditorContext, props?: FormatCellsProps): Promise<true | DifferentialStyle | undefined>;
+export declare function registerFormatCellsDialogs(ctx: EditorContext): void;

package/dist/xlsx/dialogs/format-cells/number-tab.d.ts

@@ -0,0 +1,7 @@
+import { type CellValue } from 'ooxml-core/xlsx';
+import type { FormatTab, TabInit } from 'ooxml-core/xlsx/ui';
+export declare function format(value: CellValue, code: string, date1904: boolean): {
+    text: string;
+    color?: string;
+};
+export declare function numberTab(init: TabInit): FormatTab;

package/dist/xlsx/dialogs/format-cells/protection-tab.d.ts

@@ -0,0 +1,2 @@
+import type { FormatTab, TabInit } from 'ooxml-core/xlsx/ui';
+export declare function protectionTab(init: TabInit): FormatTab;

package/dist/xlsx/dialogs/format-cells/tab-color.d.ts

@@ -0,0 +1,6 @@
+import type { Color } from 'ooxml-core/xlsx';
+import type { EditorContext } from 'ooxml-core/xlsx/ui';
+/** Resolves with `{ color }` (color undefined for No Color); undefined when cancelled. */
+export declare function openTabColorDialog(ctx: EditorContext): Promise<{
+    color: Color | undefined;
+} | undefined>;

package/dist/xlsx/dialogs/frame.d.ts

@@ -0,0 +1,27 @@
+import type { EditorContext } from 'ooxml-core/xlsx/ui';
+export interface DialogSpec<T> {
+    /** English heading (translated here). */
+    heading: string;
+    body: HTMLElement | HTMLElement[];
+    /** English label of the confirm button; default `OK`. Null hides OK (a Close-only dialog). */
+    okLabel?: string | null;
+    cancelLabel?: string;
+    /** Extra footer buttons, before Cancel / OK. */
+    buttons?: HTMLButtonElement[];
+    /** Validates and applies; return undefined to keep the dialog open. */
+    submit?(): T | undefined | Promise<T | undefined>;
+    /** Called once the dialog is in the document and open (set the initial focus here). */
+    opened?(): void;
+    /** Wider frame for tabbed dialogs. */
+    wide?: boolean;
+    /** `data-dialog` name, for tests and styling. */
+    name: string;
+}
+export interface OpenDialog {
+    element: HTMLElement;
+    close(): void;
+}
+/** A plain footer / body button (`primary` gets the accent look). */
+export declare function button(ctx: EditorContext, label: string, primary?: boolean): HTMLButtonElement;
+/** Opens a dialog and resolves with its result (undefined when cancelled or closed). */
+export declare function showDialog<T>(ctx: EditorContext, spec: DialogSpec<T>, handle?: (open: OpenDialog) => void): Promise<T | undefined>;