oasis-editor 0.0.1

package/dist/ui/components/Toolbar/primitives/Menu.d.ts

@@ -0,0 +1,20 @@
+import { JSX } from '../../../../solid-js';
+
+export interface MenuProps {
+    icon?: string;
+    label?: string;
+    tooltip?: string;
+    testId?: string;
+    active?: boolean;
+    disabled?: boolean;
+    hideChevron?: boolean;
+    /** Extra class for the popover panel. */
+    panelClass?: string;
+    keepMounted?: boolean;
+    children: JSX.Element;
+}
+/**
+ * A dropdown: an icon/label trigger button that opens a portalled panel.
+ * Replaces ToolbarDropdown; built on the shared Popover primitive.
+ */
+export declare function Menu(props: MenuProps): JSX.Element;

package/dist/ui/components/Toolbar/primitives/Popover.d.ts

@@ -0,0 +1,34 @@
+import { JSX } from '../../../../solid-js';
+import { PopoverPlacement } from '../../../../usePopoverPosition.js';
+
+export interface PopoverTriggerApi {
+    /** Attach to the element that the panel should be anchored/positioned to. */
+    ref: (el: HTMLElement) => void;
+    open: boolean;
+    setOpen: (open: boolean) => void;
+    toggle: () => void;
+}
+export interface PopoverProps {
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    /** Renders the trigger; must attach `api.ref` to the positioning anchor. */
+    trigger: (api: PopoverTriggerApi) => JSX.Element;
+    children: JSX.Element;
+    placement?: PopoverPlacement;
+    panelClass?: string;
+    panelRole?: JSX.HTMLAttributes<HTMLDivElement>["role"];
+    panelTestId?: string;
+    onPanelMouseLeave?: () => void;
+    closeOnEscape?: boolean;
+    /**
+     * Keep the panel mounted (hidden) while closed so nested Solid state — e.g.
+     * an open sub-menu inside a metrics/table panel — survives reopening.
+     */
+    keepMounted?: boolean;
+}
+/**
+ * The single portalled popover primitive. Every dropdown / split / color /
+ * grid / spacing menu composes this instead of re-implementing portal +
+ * positioning + click-outside.
+ */
+export declare function Popover(props: PopoverProps): JSX.Element;

package/dist/ui/components/Toolbar/primitives/Select.d.ts

@@ -0,0 +1,12 @@
+import { JSX } from '../../../../solid-js';
+
+export interface ToolbarSelectProps extends JSX.SelectHTMLAttributes<HTMLSelectElement> {
+    wide?: boolean;
+    small?: boolean;
+    tooltip?: string;
+}
+/**
+ * HTML select wrapper. Keeps the uncontrolled-with-sync pattern: the value is
+ * pushed imperatively in an effect to avoid SolidJS controlled-select pitfalls.
+ */
+export declare function Select(props: ToolbarSelectProps): JSX.Element;

package/dist/ui/components/Toolbar/primitives/Separator.d.ts

@@ -0,0 +1,6 @@
+import { JSX } from '../../../../solid-js';
+
+/** Vertical divider between toolbar item groups. */
+export declare function Separator(props: {
+    hidden?: boolean;
+}): JSX.Element;

package/dist/ui/components/Toolbar/primitives/SplitButton.d.ts

@@ -0,0 +1,30 @@
+import { JSX } from '../../../../solid-js';
+
+type PanelRole = JSX.HTMLAttributes<HTMLDivElement>["role"];
+export interface SplitButtonProps {
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    tooltip?: string;
+    rootClass?: string;
+    rootActive?: boolean;
+    /** Main (left) button. */
+    mainContent: JSX.Element;
+    mainTestId?: string;
+    mainAriaLabel?: string;
+    mainPressed?: boolean;
+    onMain: () => void;
+    /** Chevron (right) button. */
+    menuTestId?: string;
+    menuAriaLabel?: string;
+    /** Popover panel. */
+    panelClass?: string;
+    panelRole?: PanelRole;
+    onPanelMouseLeave?: () => void;
+    children: JSX.Element;
+}
+/**
+ * Split button: a main action button plus a chevron that opens a popover.
+ * Backs the underline and color controls (same markup/classes preserved).
+ */
+export declare function SplitButton(props: SplitButtonProps): JSX.Element;
+export {};

package/dist/ui/components/Toolbar/primitives/useDismiss.d.ts

@@ -0,0 +1,15 @@
+import { Accessor } from '../../../../solid-js';
+
+export interface DismissOptions {
+    /** Elements that should NOT trigger a dismiss when clicked (anchor + panel). */
+    refs: Accessor<Array<HTMLElement | undefined>>;
+    open: Accessor<boolean>;
+    onDismiss: () => void;
+    /** Dismiss when Escape is pressed. Defaults to true. */
+    closeOnEscape?: boolean;
+}
+/**
+ * Click-outside + Escape dismissal for popovers. Listeners are attached only
+ * while `open` is true. Replaces the per-component `handleClickOutside` copies.
+ */
+export declare function useDismiss(options: DismissOptions): void;

package/dist/ui/components/Toolbar/primitives/usePopoverPosition.d.ts

@@ -0,0 +1,31 @@
+import { Accessor } from '../../../../solid-js';
+
+export type PopoverPlacement = "bottom-start" | "bottom-end";
+export interface PopoverPositionOptions {
+    /** The element the panel is anchored to. */
+    anchor: Accessor<HTMLElement | undefined>;
+    /** The floating panel element (used to measure its width for clamping). */
+    panel: Accessor<HTMLElement | undefined>;
+    /** Whether the popover is currently open. Listeners attach only while open. */
+    open: Accessor<boolean>;
+    placement?: PopoverPlacement;
+    /** Vertical gap between anchor and panel, in px. */
+    gap?: number;
+    /** Minimum distance from the viewport edges, in px. */
+    viewportPadding?: number;
+    /** Fallback panel width when it cannot be measured yet, in px. */
+    fallbackWidth?: number;
+}
+export interface PopoverCoords {
+    top: number;
+    left: number;
+}
+/**
+ * Viewport-aware positioning for a portalled popover panel.
+ *
+ * Consolidates the `updateCoords` logic that used to be copy-pasted across
+ * ColorSplitButton, UnderlineSplitButton, LineSpacingButton, TableGridPicker
+ * and ToolbarDropdown. The math is preserved verbatim: anchor below, left
+ * clamped into the viewport accounting for the measured panel width.
+ */
+export declare function usePopoverPosition(options: PopoverPositionOptions): Accessor<PopoverCoords>;

package/dist/ui/components/Toolbar/registry/ToolbarRegistry.d.ts

@@ -0,0 +1,23 @@
+import { ToolbarItem } from '../../../../../schema/items.js';
+
+export interface ToolbarRegistry {
+    /** Add or update by id (last-write-wins). New items append, then sort by `order`. */
+    register(item: ToolbarItem): void;
+    /** Insert positionally before an existing item. */
+    insertBefore(targetId: string, item: ToolbarItem): void;
+    /** Insert positionally after an existing item. */
+    insertAfter(targetId: string, item: ToolbarItem): void;
+    /** Replace an existing item in place, preserving its position. */
+    replace(targetId: string, item: ToolbarItem): void;
+    remove(id: string): void;
+    /** Move an existing item to an absolute index. */
+    move(id: string, toIndex: number): void;
+    get(id: string): ToolbarItem | undefined;
+    getOrdered(): ToolbarItem[];
+    /** Backward-friendly alias for getOrdered. */
+    getItems(): ToolbarItem[];
+    clear(): void;
+    /** Subscribe to mutations; returns an unsubscribe function. */
+    onChange(callback: () => void): () => void;
+}
+export declare function createToolbarRegistry(): ToolbarRegistry;

package/dist/ui/components/Toolbar/renderers/ToolbarItemRenderer.d.ts

@@ -0,0 +1,13 @@
+import { JSX } from '../../../../solid-js';
+import { ToolbarActionApi, ToolbarItem } from '../../../../../schema/items.js';
+
+/**
+ * Renders a single toolbar item by dispatching on its `type` to the renderer
+ * map. Wraps each item so contextual visibility toggles `display` instead of
+ * unmounting — required by the imperative OverflowManager (DOM moves break if
+ * the child count changes).
+ */
+export declare function ToolbarItemRenderer(props: {
+    item: ToolbarItem;
+    api: ToolbarActionApi;
+}): JSX.Element;

package/dist/ui/components/Toolbar/renderers/renderers.d.ts

@@ -0,0 +1,14 @@
+import { Component } from '../../../../solid-js';
+import { ToolbarActionApi, ToolbarItem, ToolbarItemType } from '../../../../../schema/items.js';
+
+export interface RendererProps<I extends ToolbarItem = ToolbarItem> {
+    item: I;
+    api: ToolbarActionApi;
+}
+export declare const TOOLBAR_RENDERERS: Record<ToolbarItemType, Component<RendererProps>>;
+/**
+ * Register a renderer for a custom item `type`. Lets consumers add entirely new
+ * control kinds without modifying the toolbar core.
+ */
+export declare function registerToolbarRenderer(type: string, component: Component<RendererProps>): void;
+export declare function resolveRenderer(type: string): Component<RendererProps> | undefined;

package/dist/ui/components/Toolbar/schema/items.d.ts

@@ -0,0 +1,136 @@
+import { JSX } from '../../../../solid-js';
+import { CommandBus } from '../../../../../../../../core/commands/CommandBus.js';
+import { CommandRef } from '../../../../../../../../core/commands/CommandRef.js';
+import { TranslationKey } from '../../../../../../../../i18n/index.js';
+import { ColorPalette } from '../../../../palette.js';
+
+/** Reactive snapshot of a command's state, as consumed by toolbar items. */
+export interface ToolbarCommandState {
+    isEnabled: boolean;
+    isActive: boolean;
+    value: unknown;
+}
+/**
+ * Narrow, read-only view of a document's named style. Carried as the value of
+ * the `documentStyles` command, for building select option lists.
+ */
+export interface ToolbarDocumentStyle {
+    id: string;
+    name: string;
+    fontFamily?: string;
+    fontSize?: number;
+}
+/**
+ * Narrow surface every toolbar item depends on (DIP/ISP). Items only dispatch
+ * and observe commands — they never touch editor internals or `EditorState`.
+ * Even option-list data (e.g. document styles) arrives via `commandState`.
+ */
+export interface ToolbarActionApi {
+    commands: CommandBus<ToolbarCommandState>;
+    t(key: TranslationKey, params?: unknown[]): string;
+    focusEditor(): void;
+}
+/** Per-item reactive overrides. All optional; default to command-derived. */
+export interface ItemReactiveOverrides {
+    isActive?: (api: ToolbarActionApi) => boolean;
+    isDisabled?: (api: ToolbarActionApi) => boolean;
+    value?: (api: ToolbarActionApi) => unknown;
+    /** Contextual visibility — item stays mounted; the renderer toggles display. */
+    isVisible?: (api: ToolbarActionApi) => boolean;
+}
+interface ToolbarItemBase extends ItemReactiveOverrides {
+    id: string;
+    order?: number;
+    /** Logical section id (used for grouping/ordering, not rendering layout). */
+    group?: string;
+    testId?: string;
+    tooltipKey?: TranslationKey;
+    tooltip?: string;
+    iconName?: string;
+}
+export interface ButtonItem extends ToolbarItemBase {
+    type: "button";
+    /** The command this button dispatches — the only way an item acts. */
+    command: CommandRef;
+    labelKey?: TranslationKey;
+    label?: string;
+    wide?: boolean;
+}
+export interface ToggleItem extends ToolbarItemBase {
+    type: "toggle";
+    /** Toggles dispatch and derive `active` from this command (or an override). */
+    command: CommandRef;
+    labelKey?: TranslationKey;
+    label?: string;
+    wide?: boolean;
+}
+export type MenuContent = {
+    kind: "items";
+    items: ToolbarItem[];
+} | {
+    kind: "custom";
+    render: (api: ToolbarActionApi) => JSX.Element;
+};
+export interface SplitItem extends ToolbarItemBase {
+    type: "split";
+    /** Command the main button dispatches (the chevron opens `menu`). */
+    command: CommandRef;
+    /** Chevron-opened content. */
+    menu: MenuContent;
+}
+export interface MenuItem extends ToolbarItemBase {
+    type: "menu";
+    content: MenuContent;
+    labelKey?: TranslationKey;
+    label?: string;
+    hideChevron?: boolean;
+    keepMounted?: boolean;
+    /** Extra class applied to the popover panel (e.g. "oasis-editor-toolbar-panel"). */
+    panelClass?: string;
+}
+export interface SelectOption {
+    value: string;
+    label: string;
+}
+export interface SelectItem extends ToolbarItemBase {
+    type: "select";
+    /** Command dispatched with the chosen value as payload. */
+    command: CommandRef;
+    options: (api: ToolbarActionApi) => SelectOption[];
+    /** Leading "empty" option label, if any (e.g. font placeholder). */
+    placeholder?: string;
+    width?: "wide" | "small" | "default";
+}
+export interface ColorPickerItem extends ToolbarItemBase {
+    type: "colorPicker";
+    kind: "color" | "highlight";
+    /** Command dispatched with the chosen color (or null) as payload. */
+    command: CommandRef;
+    palette?: ColorPalette;
+    defaultValue: string;
+}
+export interface GridPickerItem extends ToolbarItemBase {
+    type: "gridPicker";
+    /** Command dispatched with `{ rows, cols }` as payload. */
+    command: CommandRef;
+    maxRows?: number;
+    maxCols?: number;
+}
+export interface SeparatorItem {
+    type: "separator";
+    id: string;
+    order?: number;
+    group?: string;
+    isVisible?: (api: ToolbarActionApi) => boolean;
+}
+export interface GroupItem extends ToolbarItemBase {
+    type: "group";
+    items: ToolbarItem[];
+}
+export interface CustomItem extends ToolbarItemBase {
+    type: "custom";
+    render: (api: ToolbarActionApi) => JSX.Element;
+}
+export type ToolbarItem = ButtonItem | ToggleItem | SplitItem | MenuItem | SelectItem | ColorPickerItem | GridPickerItem | SeparatorItem | GroupItem | CustomItem;
+export type ToolbarItemType = ToolbarItem["type"];
+export {};

package/dist/ui/components/Toolbar/schema/palette.d.ts

@@ -0,0 +1,15 @@
+export interface ColorSwatch {
+    name: string;
+    value: string;
+}
+export interface ThemeColor {
+    name: string;
+    /** Shades from lightest to darkest, rendered as a vertical column. */
+    values: string[];
+}
+export interface ColorPalette {
+    themeColors: ThemeColor[];
+    standardColors: ColorSwatch[];
+    /** Show the native `<input type="color">` "more colors" action. Default true. */
+    allowCustom?: boolean;
+}

package/dist/ui/components/Toolbar/state/bindItem.d.ts

@@ -0,0 +1,28 @@
+import { CommandRef } from '../../../../../../../../core/commands/CommandRef.js';
+import { ToolbarActionApi, ToolbarItem } from '../../../../../schema/items.js';
+
+export interface ItemBinding {
+    active: () => boolean;
+    disabled: () => boolean;
+    value: () => unknown;
+    visible: () => boolean;
+}
+/**
+ * Resolves an item's reactive display state. Per-item overrides win; otherwise
+ * the bound command's state is used (DIP — controls never read editor internals).
+ */
+export declare function bindItem(item: ToolbarItem, api: ToolbarActionApi): ItemBinding;
+/** Unified action dispatch through the command registry. */
+export declare function runItem(item: {
+    command: CommandRef;
+}, api: ToolbarActionApi): void;
+/** Resolve a tooltip from `tooltipKey` (i18n) or literal `tooltip`. */
+export declare function resolveTooltip(item: {
+    tooltipKey?: Parameters<ToolbarActionApi["t"]>[0];
+    tooltip?: string;
+}, api: ToolbarActionApi): string | undefined;
+/** Resolve a label from `labelKey` (i18n) or literal `label`. */
+export declare function resolveLabel(item: {
+    labelKey?: Parameters<ToolbarActionApi["t"]>[0];
+    label?: string;
+}, api: ToolbarActionApi): string | undefined;

package/dist/ui/components/Toolbar/state/createToolbarApi.d.ts

@@ -0,0 +1,14 @@
+import { CommandBus } from '../../../../../../../../core/commands/CommandBus.js';
+import { ToolbarActionApi, ToolbarCommandState } from '../../../../../schema/items.js';
+
+/**
+ * Narrow host the toolbar needs from its embedding editor: nothing but the
+ * command registry — dispatch operations and observe their reactive state.
+ * There is no god context and no out-of-band editor read.
+ */
+export interface ToolbarHost {
+    commands: CommandBus<ToolbarCommandState>;
+    focusEditor(): void;
+}
+/** Builds the {@link ToolbarActionApi} from the narrow {@link ToolbarHost}. */
+export declare function createToolbarApi(host: () => ToolbarHost): ToolbarActionApi;

package/dist/ui/components/Toolbar/underlineStyles.d.ts

@@ -0,0 +1,16 @@
+import { EditorUnderlineStyle } from '../../../../../../core/model.js';
+
+export interface UnderlineStyleOption {
+    /** Word-style underline value (e.g. "single", "double", "dotted"). */
+    value: EditorUnderlineStyle;
+    /** Human-readable label. */
+    label: string;
+    /** CSS used by the menu preview stroke. */
+    preview: {
+        borderStyle: "solid" | "dashed" | "dotted" | "double" | "wavy";
+        borderBottomWidth?: string;
+        /** Optional inline SVG fallback for wavy patterns (canvas + PDF approximate this). */
+        svg?: string;
+    };
+}
+export declare const UNDERLINE_STYLE_OPTIONS: UnderlineStyleOption[];

package/dist/ui/editorHistory.d.ts

@@ -0,0 +1,25 @@
+import { EditorState } from '../../core/model.js';
+
+export interface EditorTransactionOptions {
+    mergeKey?: string;
+}
+export interface EditorTransactionMeta {
+    mergeKey: string;
+    timestamp: number;
+}
+export interface EditorHistoryState {
+    undoStack: EditorState[];
+    redoStack: EditorState[];
+    lastTransactionMeta: EditorTransactionMeta | null;
+}
+export declare function createEmptyEditorHistoryState(): EditorHistoryState;
+export declare function applyEditorHistoryTransaction(history: EditorHistoryState, previous: EditorState, next: EditorState, options?: EditorTransactionOptions, now?: number): EditorHistoryState;
+export declare function resetEditorHistoryGrouping(history: EditorHistoryState): EditorHistoryState;
+export declare function takeEditorUndoStep(history: EditorHistoryState, current: EditorState): {
+    history: EditorHistoryState;
+    nextState: EditorState;
+} | null;
+export declare function takeEditorRedoStep(history: EditorHistoryState, current: EditorState): {
+    history: EditorHistoryState;
+    nextState: EditorState;
+} | null;

package/dist/ui/editorUiTypes.d.ts

@@ -0,0 +1,65 @@
+import { Accessor } from '../solid-js';
+import { EditorState, EditorLayoutParagraph } from '../../core/model.js';
+export interface InputBox {
+    left: number;
+    top: number;
+    height: number;
+}
+export interface CaretBox extends InputBox {
+    visible: boolean;
+}
+export interface SelectionBox {
+    left: number;
+    top: number;
+    width: number;
+    height: number;
+}
+export interface SelectedImageBox {
+    paragraphId: string;
+    startOffset: number;
+    endOffset: number;
+    left: number;
+    top: number;
+    width: number;
+    height: number;
+}
+export interface RevisionBox {
+    revisionId: string;
+    author: string;
+    date: number;
+    type: "insert" | "delete";
+    left: number;
+    top: number;
+}
+export type ImageResizeHandleDirection = "n" | "ne" | "e" | "se" | "s" | "sw" | "w" | "nw";
+export declare const IMAGE_RESIZE_HANDLE_DIRECTIONS: ImageResizeHandleDirection[];
+export interface EditorSurfaceProps {
+    state: Accessor<EditorState>;
+    measuredBlockHeights?: Accessor<Record<string, number>>;
+    measuredParagraphLayouts?: Accessor<Record<string, EditorLayoutParagraph>>;
+    layoutMode?: "fast" | "wordParity";
+    /**
+     * Phase 4: scroll viewport accessor for page virtualization.
+     * When provided, only pages within (or near) the viewport are rendered with
+     * their full block content; off-screen pages are replaced with a same-sized
+     * placeholder so scroll geometry is preserved. Optional — when omitted, all
+     * pages render in full (legacy behaviour).
+     */
+    viewportRef?: () => HTMLElement | undefined;
+    onSurfaceMouseDown: (event: MouseEvent) => void;
+    onSurfaceClick?: (event: MouseEvent) => void;
+    onSurfaceMouseMove?: (event: MouseEvent) => void;
+    onSurfaceDblClick: (event: MouseEvent) => void;
+    onParagraphMouseDown: (paragraphId: string, event: MouseEvent & {
+        currentTarget: HTMLParagraphElement;
+    }) => void;
+    onImageMouseDown: (paragraphId: string, paragraphOffset: number, event: MouseEvent & {
+        currentTarget: HTMLElement;
+    }) => void;
+    onImageResizeHandleMouseDown: (paragraphId: string, paragraphOffset: number, direction: ImageResizeHandleDirection, event: MouseEvent & {
+        currentTarget: HTMLElement;
+    }) => void;
+    onTableDragHandleMouseDown: (tableId: string, event: MouseEvent) => void;
+    onRevisionMouseEnter: (revisionId: string, event: MouseEvent) => void;
+    onRevisionMouseLeave?: (revisionId: string, event: MouseEvent) => void;
+}

package/dist/ui/imageGeometry.d.ts

@@ -0,0 +1,15 @@
+import { EditorDocument } from '../../core/model.js';
+
+export declare const DEFAULT_MAX_INSERTED_IMAGE_WIDTH = 624;
+/**
+ * Maximum inline image width in CSS pixels for the given paragraph context.
+ *
+ * - When the paragraph lives inside a table cell, returns the cell's inner
+ *   content width so the image fits the cell instead of overflowing it.
+ * - When the paragraph is in the regular body/header/footer flow, returns
+ *   the page's content width (between margins).
+ *
+ * The `_surface` parameter is kept for API compatibility with callers that
+ * pass it; it is not used internally.
+ */
+export declare function getMaxInlineImageWidth(_surface: HTMLElement | undefined, document: EditorDocument, paragraphId?: string, activeSectionIndex?: number): number;

package/dist/ui/layoutIdentity.d.ts

@@ -0,0 +1,23 @@
+import { EditorLayoutBlock, EditorLayoutDocument, EditorLayoutPage, EditorLayoutParagraph } from '../../core/model.js';
+
+/**
+ * Returns true when two projected paragraph layouts produce visually identical
+ * output (same text, same line breaks, same vertical metrics). Reusing the
+ * previous object reference lets downstream consumers (canvas paint, DOM
+ * reconciliation) short-circuit work via cheap identity comparisons.
+ */
+export declare function areLayoutParagraphsEquivalentForRender(previous: EditorLayoutParagraph | undefined, next: EditorLayoutParagraph | undefined): boolean;
+export declare function canReuseLayoutBlock(previous: EditorLayoutBlock | undefined, next: EditorLayoutBlock): previous is EditorLayoutBlock;
+export declare function canReuseLayoutPage(previous: EditorLayoutPage | undefined, next: EditorLayoutPage): previous is EditorLayoutPage;
+/**
+ * Creates a stateful function that preserves object identity for projected
+ * layout pages/blocks when their contents are unchanged. Pages whose blocks
+ * are all reused will themselves be reused, so reactive consumers can skip
+ * work on a per-page basis.
+ *
+ * Usage:
+ *
+ *     const stabilize = createLayoutIdentityStabilizer();
+ *     const stableLayout = stabilize(projectDocumentLayout(...));
+ */
+export declare function createLayoutIdentityStabilizer(): (layout: EditorLayoutDocument) => EditorLayoutDocument;

package/dist/ui/layoutInvalidation.d.ts

@@ -0,0 +1,9 @@
+import { EditorState } from '../../core/model.js';
+import { LayoutInvalidation } from '../../app/controllers/useEditorLayout.js';
+
+/**
+ * Cheap diff between two editor states. Produces an explicit
+ * `LayoutInvalidation` hint for the layout controller, so the layout effect
+ * never has to walk every paragraph in the document on every keystroke.
+ */
+export declare function computeLayoutInvalidationFromTransaction(prev: EditorState, next: EditorState): LayoutInvalidation;

package/dist/ui/mount.d.ts

@@ -0,0 +1,10 @@
+import { OasisEditorAppProps } from '../OasisEditorApp.js';
+
+export interface OasisMountInstance {
+    unmount: () => void;
+}
+/**
+ * Public vanilla JS mount function.
+ * Wraps the Solid.js entry point for framework-agnostic usage.
+ */
+export declare function mount(target: HTMLElement, props?: OasisEditorAppProps): OasisMountInstance;

package/dist/ui/shells/BalloonShell.d.ts

@@ -0,0 +1,3 @@
+import { ShellProps } from '../../DocumentShell.js';
+
+export declare function BalloonShell(props: ShellProps): import("solid-js").JSX.Element;

package/dist/ui/shells/DocumentShell.d.ts

@@ -0,0 +1,29 @@
+import { Accessor } from '../../solid-js';
+import { OasisEditorEditorFileHandlers, OasisEditorEditorInputHandlers, OasisEditorEditorLayoutProps, OasisEditorEditorOverlayProps, OasisEditorEditorRefProps, OasisEditorEditorSurfaceHandlers } from '../../../OasisEditorEditor.js';
+import { ToolbarHost } from '../../../components/Toolbar/state/createToolbarApi.js';
+import { ToolbarRegistry } from '../../../components/Toolbar/registry/ToolbarRegistry.js';
+import { EditorLayoutParagraph, EditorState } from '../../../../core/model.js';
+
+export interface ShellProps {
+    state: EditorState;
+    toolbarHost: () => ToolbarHost;
+    persistenceStatus: () => string;
+    toolbarRegistry: ToolbarRegistry;
+    showChrome: boolean;
+    showTitleBar: boolean;
+    showMenubar: boolean;
+    showToolbar: boolean;
+    showOutline: boolean;
+    isReadOnly: boolean;
+    measuredBlockHeights: Accessor<Record<string, number>>;
+    measuredParagraphLayouts: Accessor<Record<string, EditorLayoutParagraph>>;
+    viewportHeight: Accessor<number | string | undefined>;
+    showFloatingTableToolbar: Accessor<boolean>;
+    layout: Omit<OasisEditorEditorLayoutProps, "measuredBlockHeights" | "measuredParagraphLayouts" | "viewportHeight" | "readOnly">;
+    overlays: Omit<OasisEditorEditorOverlayProps, "toolbarHost" | "persistenceStatus" | "showFloatingTableToolbar">;
+    refs: OasisEditorEditorRefProps;
+    surfaceHandlers: OasisEditorEditorSurfaceHandlers;
+    inputHandlers: OasisEditorEditorInputHandlers;
+    fileHandlers: OasisEditorEditorFileHandlers;
+}
+export declare function DocumentShell(props: ShellProps): import("solid-js").JSX.Element;

package/dist/ui/shells/InlineShell.d.ts

@@ -0,0 +1,3 @@
+import { ShellProps } from '../../DocumentShell.js';
+
+export declare function InlineShell(props: ShellProps): import("solid-js").JSX.Element;

package/dist/ui/tableGeometry.d.ts

@@ -0,0 +1,16 @@
+import { EditorDocument, EditorState, EditorTableNode } from '../../core/model.js';
+
+/**
+ * Computes the visual column widths (in CSS pixels) for a table, taking
+ * into account `table.gridCols`, the resolved table width, and the number
+ * of visual columns derived from colSpan.
+ */
+export declare function resolveTableColumnWidthsPx(table: EditorTableNode, pageContentWidthPx: number): number[];
+/**
+ * Returns the inner content width (in CSS pixels) of the cell that contains the
+ * paragraph with the given id, or null if the paragraph is not inside a table
+ * in the active section. The returned width is what's actually available for
+ * inline content (subtracts borders and horizontal padding).
+ */
+export declare function getTableCellContentWidthForParagraph(document: EditorDocument, paragraphId: string, activeSectionIndex: number): number | null;
+export declare function getTableCellContentWidthForParagraphInState(state: EditorState, paragraphId: string): number | null;

package/dist/ui/tableUiUtils.d.ts

@@ -0,0 +1,5 @@
+import { measureParagraphLayoutFromRects } from '../../layoutProjection/index.js';
+
+export declare function resolveClickOffset(event: MouseEvent & {
+    currentTarget: HTMLParagraphElement;
+}, layoutParagraph: ReturnType<typeof measureParagraphLayoutFromRects>): number;