oasis-editor 0.0.1 → 0.0.2

package/dist/ui/canvas/canvasBorders.d.ts

@@ -0,0 +1,17 @@
+export interface CanvasBorderEdge {
+    width: number;
+    color: string;
+    type: "solid" | "dashed" | "dotted" | "none";
+}
+export interface CanvasBorderBox {
+    top?: CanvasBorderEdge;
+    right?: CanvasBorderEdge;
+    bottom?: CanvasBorderEdge;
+    left?: CanvasBorderEdge;
+}
+/**
+ * Strokes the four edges of a rectangular box. Edges left `undefined` are
+ * skipped. Shared by table-cell borders and paragraph borders so both render
+ * dashes/dotted/solid identically.
+ */
+export declare function drawBorderBox(ctx: CanvasRenderingContext2D, left: number, top: number, width: number, height: number, borders: CanvasBorderBox): void;

package/dist/ui/canvas/canvasDropCapPainter.d.ts

@@ -0,0 +1,16 @@
+import { EditorLayoutLine, EditorParagraphNode } from '../../../../core/model.js';
+
+/**
+ * Draws a paragraph's drop cap (the large initial letter). The wrapping body
+ * text has already been shortened by the matching exclusion in
+ * `resolveDropCapExclusion`, so the cap occupies the gap to the left of those
+ * lines. The cap baseline aligns with the baseline of its last spanned line
+ * (mirroring `drawParagraph`'s `line.top + line.height * 0.8`).
+ */
+export declare function drawDropCapForParagraph(options: {
+    ctx: CanvasRenderingContext2D;
+    paragraph: EditorParagraphNode;
+    lines: EditorLayoutLine[];
+    originX: number;
+    paragraphTop: number;
+}): void;

package/dist/ui/canvas/canvasParagraphPainter.d.ts

@@ -1,5 +1,6 @@
-import { EditorLayoutLine, EditorParagraphNode, EditorState } from '../../../../core/model.js';
+import { EditorLayoutLine, EditorPageSettings, EditorParagraphNode, EditorState } from '../../../../core/model.js';
 
+export declare function resolveCanvasFontFamily(fontFamily: string | null | undefined): string;
 export declare function resolveCanvasTextRenderMetrics(styles: {
     superscript?: boolean;
     subscript?: boolean;
@@ -9,4 +10,25 @@ export declare function resolveCanvasTextRenderMetrics(styles: {
     fontSize: number;
     baselineOffset: number;
 };
-export declare function drawParagraph(ctx: CanvasRenderingContext2D, paragraph: EditorParagraphNode, lines: EditorLayoutLine[], state: EditorState, originX: number, originY: number, onUpdate: () => void): void;
+/**
+ * Paints the floating images anchored within a paragraph, mirroring
+ * `drawFloatingTextBoxesForParagraph`. Split into `behind`/`front` layers so a
+ * `behindDoc` image renders under the text and others render over it.
+ */
+export declare function drawFloatingImagesForParagraph(options: {
+    ctx: CanvasRenderingContext2D;
+    paragraphLines: EditorLayoutLine[];
+    state: EditorState;
+    pageSettings: EditorPageSettings;
+    contentLeft: number;
+    contentTop: number;
+    contentWidth: number;
+    paragraphTop: number;
+    onUpdate: () => void;
+    layer: "behind" | "front";
+}): void;
+export declare function drawParagraph(ctx: CanvasRenderingContext2D, paragraph: EditorParagraphNode, lines: EditorLayoutLine[], state: EditorState, originX: number, originY: number, onUpdate: () => void, pageIndex?: number): void;
+export declare function resolveFragmentPaintBounds(line: EditorLayoutLine, fragment: EditorLayoutLine["fragments"][number]): {
+    left: number;
+    right: number;
+} | null;

package/dist/ui/canvas/canvasTextBoxPainter.d.ts

@@ -0,0 +1,24 @@
+import { EditorLayoutLine, EditorPageSettings, EditorState, EditorTextBoxData } from '../../../../core/model.js';
+
+export declare function drawTextBoxShape(ctx: CanvasRenderingContext2D, textBox: EditorTextBoxData, x: number, y: number, width: number, height: number): void;
+export declare function renderTextBoxContent(ctx: CanvasRenderingContext2D, textBox: EditorTextBoxData, state: EditorState, x: number, y: number, width: number, height: number, pageIndex: number, onUpdate: () => void): void;
+/**
+ * Paint a text box (shape + content) at the given box, honoring
+ * `textBox.rotation`. Rotation pivots around the box center so the painted
+ * result lines up with the selection overlay (which rotates the same way).
+ * Shared by inline and floating text box rendering.
+ */
+export declare function paintTextBox(ctx: CanvasRenderingContext2D, textBox: EditorTextBoxData, state: EditorState, x: number, y: number, width: number, height: number, pageIndex: number, onUpdate: () => void): void;
+export declare function drawFloatingTextBoxesForParagraph(options: {
+    ctx: CanvasRenderingContext2D;
+    paragraphLines: EditorLayoutLine[];
+    state: EditorState;
+    pageSettings: EditorPageSettings;
+    contentLeft: number;
+    contentTop: number;
+    contentWidth: number;
+    paragraphTop: number;
+    pageIndex: number;
+    onUpdate: () => void;
+    layer: "behind" | "front";
+}): void;

package/dist/ui/canvas/imageContour.d.ts

@@ -0,0 +1,10 @@
+import { EditorWrapPolygonPoint } from '../../../../core/model.js';
+
+/**
+ * Pure mask → fractional contour. A mostly-opaque or empty mask, or one whose
+ * boundary degenerates, yields the rectangle. Exported for deterministic tests
+ * (the canvas rasterization path needs a real browser).
+ */
+export declare function traceAlphaMaskContour(mask: Uint8Array, width: number, height: number): EditorWrapPolygonPoint[];
+/** Traces (and caches) the wrap contour for a decoded, same-origin image. */
+export declare function traceImageAlphaContour(img: HTMLImageElement): EditorWrapPolygonPoint[];

package/dist/ui/canvas/textBoxRenderHeight.d.ts

@@ -0,0 +1,14 @@
+import { EditorState, EditorTextBoxData } from '../../../../core/model.js';
+
+export declare function getTextBoxPadding(textBox: EditorTextBoxData): {
+    left: number;
+    top: number;
+    right: number;
+    bottom: number;
+};
+/**
+ * The height the text box is actually painted at: its stored height, or the
+ * content-measured height when auto-fit is on. Selection overlays must use this
+ * so the resize handles match the rendered box rather than the stored height.
+ */
+export declare function resolveTextBoxRenderHeight(textBox: EditorTextBoxData, state: EditorState, pageIndex: number): number;

package/dist/ui/canvas/verticalText.d.ts

@@ -0,0 +1,104 @@
+import { EditorParagraphNode, EditorState } from '../../../../core/model.js';
+
+/**
+ * How a block of text should be painted given its OOXML flow direction.
+ * - `horizontal`: normal left-to-right horizontal text (no transform).
+ * - `rotate-cw`: rotated 90° clockwise — text reads top→bottom, columns
+ *   advance right→left (`w:textDirection` `tbRl`, DrawingML `vert`).
+ * - `rotate-ccw`: rotated 90° counter-clockwise — text reads bottom→top,
+ *   columns advance left→right (`btLr`, `vert270`).
+ * - `stack`: upright glyphs stacked top→bottom — DrawingML `wordArtVert` (and
+ *   East-Asian CJK content).
+ *
+ * Note on the "V" variants: like Word, Latin `lrTbV` renders horizontally and
+ * `tbRlV` renders rotated (≈ `tbRl`); only `wordArtVert` stacks glyphs upright.
+ */
+export type VerticalRenderMode = "horizontal" | "rotate-cw" | "rotate-ccw" | "stack";
+/**
+ * Map an OOXML text-direction token (`w:textDirection/@w:val` or
+ * `wps:bodyPr/@vert`) to a canvas render mode.
+ */
+export declare function resolveVerticalMode(direction: string | null | undefined): VerticalRenderMode;
+export interface VerticalBox {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+/**
+ * Map a point in a rotated box's local layout space (where `lx` runs along the
+ * box's long/vertical axis and `ly` across its short axis) to screen space.
+ * This is the point form of the affine transform applied by `withRotatedBox`.
+ */
+export declare function projectRotatedPoint(box: VerticalBox, mode: "rotate-cw" | "rotate-ccw", lx: number, ly: number): {
+    x: number;
+    y: number;
+};
+/**
+ * Project a horizontal-layout caret slot into the screen-space rectangle it
+ * occupies once the box is rotated. `flow` is the slot's position along the text
+ * flow (its `left`), `cross` is its cross-flow position (`cursorY + slot.top`),
+ * `advance` is the glyph advance along the flow, and `crossThickness` is the line
+ * height. Returns the axis-aligned `{ left, top, height }` used by the generic
+ * slot-based hit-test/selection scorers.
+ */
+export declare function projectRotatedSlot(box: VerticalBox, mode: "rotate-cw" | "rotate-ccw", flow: number, cross: number, advance: number, crossThickness: number): {
+    left: number;
+    top: number;
+    height: number;
+};
+/**
+ * Run `paint` inside a canvas transform so that content laid out horizontally
+ * in a width/height-swapped coordinate space appears rotated to fill `box`.
+ *
+ * The callback paints at local origin (0, 0) into a box whose dimensions are
+ * `(layoutWidth = box.height, layoutHeight = box.width)` — i.e. text flows
+ * along the box's long (vertical) axis.
+ */
+export declare function withRotatedBox(ctx: CanvasRenderingContext2D, box: VerticalBox, mode: "rotate-cw" | "rotate-ccw", paint: (layoutWidth: number, layoutHeight: number) => void): void;
+/** Estimate the vertical extent (px) of a paragraph painted as stacked glyphs. */
+export declare function estimateStackedParagraphHeight(paragraph: EditorParagraphNode, state: EditorState): number;
+/**
+ * Estimate the horizontal extent (px) of a single stacked column — the column
+ * width `drawStackedParagraph` reserves for the paragraph's widest glyph.
+ */
+export declare function estimateStackedColumnWidth(paragraph: EditorParagraphNode, state: EditorState): number;
+/** One upright glyph positioned within a stacked column (screen space). */
+export interface StackedGlyph {
+    char: string;
+    /** Paragraph text offset of this glyph. */
+    offset: number;
+    /** Column center x. */
+    centerX: number;
+    /** Glyph top y. */
+    top: number;
+    /** Column width. */
+    width: number;
+    /** Glyph height (advance along the column). */
+    height: number;
+    /** Canvas font string for painting. */
+    font: string;
+    /** Fill color. */
+    color: string;
+}
+export interface StackedLayout {
+    glyphs: StackedGlyph[];
+    /** The x edge consumed, so callers can chain paragraphs as adjacent columns. */
+    endColumnRight: number;
+}
+/**
+ * Compute the upright-glyph layout for a paragraph stacked top→bottom inside
+ * `box`. Columns advance right→left when `columnsRtl` (East-Asian CJK default),
+ * or left→right for Latin WordArt "Stacked" text (`wordArtVert`). `startColumn`
+ * is the right edge of the first column when RTL, or its left edge when LTR.
+ * This is the single source of truth shared by `drawStackedParagraph` (paint)
+ * and the layout snapshot (caret/selection geometry), so the two cannot drift.
+ */
+export declare function layoutStackedGlyphs(paragraph: EditorParagraphNode, state: EditorState, box: VerticalBox, startColumn: number, columnsRtl?: boolean): StackedLayout;
+/**
+ * Paint a paragraph as upright glyphs stacked top→bottom inside `box`.
+ * Successive columns (after a hard break or when the box overflows) advance
+ * right→left when `columnsRtl`, otherwise left→right. Returns the far edge
+ * consumed so callers can chain paragraphs as adjacent columns.
+ */
+export declare function drawStackedParagraph(ctx: CanvasRenderingContext2D, paragraph: EditorParagraphNode, state: EditorState, box: VerticalBox, startColumn: number, columnsRtl?: boolean): number;

package/dist/ui/components/Dialogs/FontDialog.d.ts

@@ -1,67 +1,4 @@
-import { EditorLigatures, EditorNumberForm, EditorNumberSpacing, EditorUnderlineStyle } from '../../../../../../core/model.js';
+import { FontDialogProps } from '../../../font-dialog/FontDialogTypes.js';
 
-export interface FontDialogInitialValues {
-    fontFamily: string;
-    fontSize: string;
-    color: string;
-    colorMode: "automatic" | "custom";
-    highlight: string;
-    bold: boolean;
-    italic: boolean;
-    underline: boolean;
-    underlineStyle: EditorUnderlineStyle | null;
-    underlineColor: string;
-    strike: boolean;
-    doubleStrike: boolean;
-    superscript: boolean;
-    subscript: boolean;
-    smallCaps: boolean;
-    allCaps: boolean;
-    hidden: boolean;
-    characterScale: string;
-    characterSpacing: string;
-    baselineShift: string;
-    kerningThreshold: string;
-    ligatures: EditorLigatures | "";
-    numberSpacing: EditorNumberSpacing | "";
-    numberForm: EditorNumberForm | "";
-    stylisticSet: string;
-    contextualAlternates: boolean;
-}
-export interface FontDialogApplyValues {
-    fontFamily: string | null;
-    fontSize: number | null;
-    color: string | null;
-    colorMode: "automatic" | "custom";
-    highlight: string | null;
-    bold: boolean;
-    italic: boolean;
-    underline: boolean;
-    underlineStyle: EditorUnderlineStyle | null;
-    underlineColor: string | null;
-    strike: boolean;
-    doubleStrike: boolean;
-    superscript: boolean;
-    subscript: boolean;
-    smallCaps: boolean;
-    allCaps: boolean;
-    hidden: boolean;
-    characterScale: number | null;
-    characterSpacing: number | null;
-    baselineShift: number | null;
-    kerningThreshold: number | null;
-    ligatures: EditorLigatures | null;
-    numberSpacing: EditorNumberSpacing | null;
-    numberForm: EditorNumberForm | null;
-    stylisticSet: number | null;
-    contextualAlternates: boolean;
-}
-export interface FontDialogProps {
-    isOpen: boolean;
-    initial: FontDialogInitialValues;
-    familyOptions: string[];
-    sizeOptions: number[];
-    onClose: () => void;
-    onApply: (values: FontDialogApplyValues, original: FontDialogInitialValues) => void;
-}
+export type { FontDialogInitialValues, FontDialogApplyValues, FontDialogProps, } from '../../../font-dialog/FontDialogTypes.js';
 export declare function FontDialog(props: FontDialogProps): import("solid-js").JSX.Element;

package/dist/ui/components/Dialogs/FontDialogModel.d.ts

@@ -1,4 +1,5 @@
 import { EditorLigatures, EditorNumberForm, EditorNumberSpacing } from '../../../../../../core/model.js';
+import { FontTabValues, AdvancedTabValues, FontDialogInitialValues, FontDialogApplyValues } from '../../../font-dialog/FontDialogTypes.js';
 
 export type FontDialogSpacingMode = "normal" | "expanded" | "condensed";
 export type FontDialogPositionMode = "normal" | "raised" | "lowered";
@@ -13,3 +14,7 @@ export declare function ligaturesToCss(value: EditorLigatures | ""): string | un
 export declare function numericToCss(numberSpacing: EditorNumberSpacing | "", numberForm: EditorNumberForm | ""): string | undefined;
 export declare function featureSettingsToCss(stylisticSet: string, contextualAlternates: boolean): string | undefined;
 export declare function resolveFontFaceStyle(bold: boolean, italic: boolean): FontFaceStyle;
+export declare function createFontTabValuesFromInitial(initial: FontDialogInitialValues): FontTabValues;
+export declare function createAdvancedTabValuesFromInitial(initial: FontDialogInitialValues): AdvancedTabValues;
+export declare function buildFontDialogPreviewStyle(font: FontTabValues, advanced: AdvancedTabValues): Record<string, string | number | undefined>;
+export declare function buildFontDialogApplyValues(font: FontTabValues, advanced: AdvancedTabValues): FontDialogApplyValues;

package/dist/ui/components/Dialogs/ParagraphDialog.d.ts

@@ -0,0 +1,49 @@
+import { EditorBorderStyle, EditorParagraphStyle } from '../../../../../../core/model.js';
+
+export interface ParagraphDialogInitialValues {
+    align: string;
+    indentLeft: string;
+    indentRight: string;
+    indentFirstLine: string;
+    indentHanging: string;
+    spacingBefore: string;
+    spacingAfter: string;
+    lineHeight: string;
+    shading: string;
+    borderStyle: string;
+    borderWidth: string;
+    borderColor: string;
+    borderSideTop: boolean;
+    borderSideRight: boolean;
+    borderSideBottom: boolean;
+    borderSideLeft: boolean;
+}
+export interface ParagraphDialogBorders {
+    top: EditorBorderStyle | null;
+    right: EditorBorderStyle | null;
+    bottom: EditorBorderStyle | null;
+    left: EditorBorderStyle | null;
+}
+export interface ParagraphDialogApplyValues {
+    align: EditorParagraphStyle["align"] | null;
+    indentLeft: number | null;
+    indentRight: number | null;
+    indentFirstLine: number | null;
+    indentHanging: number | null;
+    spacingBefore: number | null;
+    spacingAfter: number | null;
+    lineHeight: number | null;
+    shading: string | null;
+    /**
+     * Per-edge paragraph borders. The dialog edits one shared style/width/color
+     * and toggles which edges carry it; each edge is the shared border or `null`.
+     */
+    borders: ParagraphDialogBorders;
+}
+export interface ParagraphDialogProps {
+    isOpen: boolean;
+    initial: ParagraphDialogInitialValues;
+    onClose: () => void;
+    onApply: (values: ParagraphDialogApplyValues, original: ParagraphDialogInitialValues) => void;
+}
+export declare function ParagraphDialog(props: ParagraphDialogProps): import("solid-js").JSX.Element;

package/dist/ui/components/Dialogs/TablePropertiesDialog.d.ts

@@ -0,0 +1,80 @@
+import { EditorBorderStyle, EditorDocxWidthValue, EditorTableRowHeightRule } from '../../../../../../core/model.js';
+
+type TableWidthUnit = "points" | "percent";
+type BorderStyleValue = "none" | "solid" | "dashed" | "dotted";
+export interface TablePropertiesDialogInitialValues {
+    activeTab?: "table" | "row" | "column" | "cell" | "altText";
+    tableWidth: string;
+    tableWidthUnit: TableWidthUnit;
+    tableAlign: "" | "left" | "center" | "right";
+    tableIndentLeft: string;
+    tableWrapping: "none" | "around";
+    floatingSummary: string;
+    rowHeight: string;
+    rowHeightRule: EditorTableRowHeightRule | "";
+    repeatHeader: boolean;
+    allowBreakAcrossPages: boolean;
+    hiddenRow: boolean;
+    columnWidth: string;
+    cellWidth: string;
+    cellVerticalAlign: "" | "top" | "middle" | "bottom";
+    cellTextDirection: "" | "lrTb" | "tbRl" | "btLr" | "lrTbV" | "tbRlV";
+    cellNoWrap: boolean;
+    cellFitText: boolean;
+    cellHideMark: boolean;
+    marginTop: string;
+    marginRight: string;
+    marginBottom: string;
+    marginLeft: string;
+    borderStyle: BorderStyleValue;
+    borderWidth: string;
+    borderColor: string;
+    borderTop: boolean;
+    borderRight: boolean;
+    borderBottom: boolean;
+    borderLeft: boolean;
+    shading: string;
+    altTitle: string;
+    altDescription: string;
+}
+export interface TablePropertiesDialogBorders {
+    top: EditorBorderStyle | null;
+    right: EditorBorderStyle | null;
+    bottom: EditorBorderStyle | null;
+    left: EditorBorderStyle | null;
+}
+export interface TablePropertiesDialogApplyValues {
+    tableWidth: EditorDocxWidthValue | null;
+    tableAlign: "left" | "center" | "right" | null;
+    tableIndentLeft: EditorDocxWidthValue | null;
+    rowHeight: EditorDocxWidthValue | null;
+    rowHeightRule: EditorTableRowHeightRule | null;
+    repeatHeader: boolean;
+    cantSplit: boolean;
+    hiddenRow: boolean;
+    columnWidth: EditorDocxWidthValue | null;
+    cellWidth: EditorDocxWidthValue | null;
+    cellVerticalAlign: "top" | "middle" | "bottom" | null;
+    cellTextDirection: "lrTb" | "tbRl" | "btLr" | "lrTbV" | "tbRlV" | null;
+    cellNoWrap: boolean | null;
+    cellFitText: boolean | null;
+    cellHideMark: boolean | null;
+    margins: {
+        top: number | null;
+        right: number | null;
+        bottom: number | null;
+        left: number | null;
+    };
+    borders: TablePropertiesDialogBorders;
+    shading: string | null;
+    altTitle: string | null;
+    altDescription: string | null;
+}
+export interface TablePropertiesDialogProps {
+    isOpen: boolean;
+    initial: TablePropertiesDialogInitialValues;
+    onClose: () => void;
+    onApply: (values: TablePropertiesDialogApplyValues, original: TablePropertiesDialogInitialValues) => void;
+}
+export declare function TablePropertiesDialog(props: TablePropertiesDialogProps): import("solid-js").JSX.Element;
+export {};

package/dist/ui/components/Dialogs/font-dialog/AdvancedFontTab.d.ts

@@ -0,0 +1,6 @@
+import { FontDialogController } from '../../../../FontDialogController.js';
+
+export interface AdvancedFontTabProps {
+    ctrl: FontDialogController;
+}
+export declare function AdvancedFontTab(props: AdvancedFontTabProps): import("solid-js").JSX.Element;

package/dist/ui/components/Dialogs/font-dialog/FontDialogController.d.ts

@@ -0,0 +1,21 @@
+import { Accessor, Setter } from '../../../../solid-js';
+import { FontDialogTab, FontTabValues, AdvancedTabValues, FontStylePreset } from '../../../../FontDialogTypes.js';
+
+export interface FontDialogController {
+    activeTab: Accessor<FontDialogTab>;
+    setActiveTab: (tab: FontDialogTab) => void;
+    fontTabValues: Accessor<FontTabValues>;
+    setFontTabValues: Setter<FontTabValues>;
+    advancedTabValues: Accessor<AdvancedTabValues>;
+    setAdvancedTabValues: Setter<AdvancedTabValues>;
+    updateFontTab: <K extends keyof FontTabValues>(key: K, value: FontTabValues[K]) => void;
+    updateAdvancedTab: <K extends keyof AdvancedTabValues>(key: K, value: AdvancedTabValues[K]) => void;
+    selectedFontStyle: Accessor<FontStylePreset>;
+    visibleFamilyOptions: Accessor<string[]>;
+    effectiveSizeOptions: Accessor<number[]>;
+    customSizeError: Accessor<string>;
+    advancedValidationError: Accessor<string>;
+    previewStyle: Accessor<Record<string, string | number | undefined>>;
+    applyFontStylePreset: (preset: FontStylePreset) => void;
+    handleApply: () => void;
+}

package/dist/ui/components/Dialogs/font-dialog/FontDialogTypes.d.ts

@@ -0,0 +1,112 @@
+import { EditorLigatures, EditorNumberForm, EditorNumberSpacing, EditorUnderlineStyle } from '../../../../../../../../core/model.js';
+import { FontDialogSpacingMode, FontDialogPositionMode } from '../../../../../FontDialogModel.js';
+
+export declare const DEFAULT_COLOR = "#111827";
+export declare const DEFAULT_HIGHLIGHT = "#fef08a";
+export declare const DEFAULT_SHADING = "#fef3c7";
+export declare const WORD_FONT_SIZES: number[];
+export declare const WORD_CHARACTER_SCALES: number[];
+export type FontDialogTab = "font" | "advanced";
+export type FontStylePreset = "regular" | "italic" | "bold" | "boldItalic";
+export type UnderlineStyleValue = EditorUnderlineStyle | "none";
+export interface FontTabValues {
+    familyFilter: string;
+    fontFamily: string;
+    fontSize: string;
+    colorMode: "automatic" | "custom";
+    color: string;
+    highlight: string;
+    shading: string;
+    bold: boolean;
+    italic: boolean;
+    underline: boolean;
+    underlineStyle: UnderlineStyleValue;
+    underlineColor: string;
+    strike: boolean;
+    doubleStrike: boolean;
+    superscript: boolean;
+    subscript: boolean;
+    smallCaps: boolean;
+    allCaps: boolean;
+    hidden: boolean;
+}
+export interface AdvancedTabValues {
+    characterScale: string;
+    spacingMode: FontDialogSpacingMode;
+    spacingAmount: string;
+    positionMode: FontDialogPositionMode;
+    positionAmount: string;
+    kerningEnabled: boolean;
+    kerningThreshold: string;
+    ligatures: EditorLigatures | "";
+    numberSpacing: EditorNumberSpacing | "";
+    numberForm: EditorNumberForm | "";
+    stylisticSet: string;
+    contextualAlternates: boolean;
+}
+export interface FontDialogInitialValues {
+    fontFamily: string;
+    fontSize: string;
+    color: string;
+    colorMode: "automatic" | "custom";
+    highlight: string;
+    shading: string;
+    bold: boolean;
+    italic: boolean;
+    underline: boolean;
+    underlineStyle: EditorUnderlineStyle | null;
+    underlineColor: string;
+    strike: boolean;
+    doubleStrike: boolean;
+    superscript: boolean;
+    subscript: boolean;
+    smallCaps: boolean;
+    allCaps: boolean;
+    hidden: boolean;
+    characterScale: string;
+    characterSpacing: string;
+    baselineShift: string;
+    kerningThreshold: string;
+    ligatures: EditorLigatures | "";
+    numberSpacing: EditorNumberSpacing | "";
+    numberForm: EditorNumberForm | "";
+    stylisticSet: string;
+    contextualAlternates: boolean;
+}
+export interface FontDialogApplyValues {
+    fontFamily: string | null;
+    fontSize: number | null;
+    color: string | null;
+    colorMode: "automatic" | "custom";
+    highlight: string | null;
+    shading: string | null;
+    bold: boolean;
+    italic: boolean;
+    underline: boolean;
+    underlineStyle: EditorUnderlineStyle | null;
+    underlineColor: string | null;
+    strike: boolean;
+    doubleStrike: boolean;
+    superscript: boolean;
+    subscript: boolean;
+    smallCaps: boolean;
+    allCaps: boolean;
+    hidden: boolean;
+    characterScale: number | null;
+    characterSpacing: number | null;
+    baselineShift: number | null;
+    kerningThreshold: number | null;
+    ligatures: EditorLigatures | null;
+    numberSpacing: EditorNumberSpacing | null;
+    numberForm: EditorNumberForm | null;
+    stylisticSet: number | null;
+    contextualAlternates: boolean;
+}
+export interface FontDialogProps {
+    isOpen: boolean;
+    initial: FontDialogInitialValues;
+    familyOptions: string[];
+    sizeOptions: number[];
+    onClose: () => void;
+    onApply: (values: FontDialogApplyValues, original: FontDialogInitialValues) => void;
+}

package/dist/ui/components/Dialogs/font-dialog/FontPreview.d.ts

@@ -0,0 +1,6 @@
+export interface FontPreviewProps {
+    class?: string;
+    testId: string;
+    style: Record<string, string | number | undefined>;
+}
+export declare function FontPreview(props: FontPreviewProps): import("solid-js").JSX.Element;

package/dist/ui/components/Dialogs/font-dialog/FontTab.d.ts

@@ -0,0 +1,6 @@
+import { FontDialogController } from '../../../../FontDialogController.js';
+
+export interface FontTabProps {
+    ctrl: FontDialogController;
+}
+export declare function FontTab(props: FontTabProps): import("solid-js").JSX.Element;

package/dist/ui/components/Dialogs/font-dialog/useFontDialogController.d.ts

@@ -0,0 +1,4 @@
+import { FontDialogProps } from '../../../../FontDialogTypes.js';
+import { FontDialogController } from '../../../../FontDialogController.js';
+
+export declare function useFontDialogController(props: FontDialogProps): FontDialogController;

package/dist/ui/components/FloatingToolbar/FloatingLayoutOptions.d.ts

@@ -0,0 +1,17 @@
+import { Accessor, JSX } from '../../../solid-js';
+import { LayoutOptionsOverlay } from '../../../../../editorUiTypes.js';
+
+/** Minimal box geometry (surface-relative) used to anchor the popup. */
+export interface LayoutOptionsAnchorBox {
+    left: number;
+    top: number;
+    width: number;
+    height: number;
+}
+export interface FloatingLayoutOptionsProps {
+    box: Accessor<LayoutOptionsAnchorBox | null>;
+    layoutOptions: LayoutOptionsOverlay;
+    surfaceRef: () => HTMLElement | undefined;
+    readOnly?: boolean;
+}
+export declare function FloatingLayoutOptions(props: FloatingLayoutOptionsProps): JSX.Element;

package/dist/ui/components/Menubar/Menubar.d.ts

@@ -1,7 +1,8 @@
 import { JSX } from '../../../solid-js';
-import { MenubarHost } from '../../../menuRegistry.js';
+import { MenuRegistry, MenubarHost } from '../../../menuRegistry.js';
 
 export interface MenubarProps {
     host: () => MenubarHost;
+    registry?: MenuRegistry;
 }
 export declare function Menubar(props: MenubarProps): JSX.Element;