superdoc 2.29.0-next.3 → 2.29.0-next.9

package/dist/superdoc/src/helpers/comment-focus.d.ts

@@ -1,4 +1,21 @@
-export function getPreferredCommentFocusTargetClientY(): number;
-export function getVisibleThreadAnchorClientY(layersElement: any, positionEntry: any): any;
-export function getVisibleThreadHighlightClientY(threadIds: any): any;
-export function scrollThreadAnchorToFocusTarget(presentation: any, primaryThreadId: any, fallbackThreadId: any, targetClientY: any): any;
+type ClientRectSource = {
+    getBoundingClientRect?: () => {
+        top: number;
+    };
+};
+type ThreadPositionEntry = {
+    bounds?: {
+        top?: number;
+    } | null;
+} | null | undefined;
+type ThreadAnchorPresentation = {
+    getReachableThreadAnchorClientY: (threadId: string, targetClientY: number) => number | null | undefined;
+    scrollThreadAnchorToClientY: (threadId: string, targetClientY: number, options: {
+        behavior: ScrollBehavior;
+    }) => boolean | null | undefined;
+};
+export declare const getPreferredCommentFocusTargetClientY: () => number;
+export declare const getVisibleThreadAnchorClientY: (layersElement: ClientRectSource | null | undefined, positionEntry: ThreadPositionEntry) => number | null;
+export declare const getVisibleThreadHighlightClientY: (threadIds: ReadonlyArray<string | number | null | undefined> | null | undefined) => number | null;
+export declare const scrollThreadAnchorToFocusTarget: (presentation: ThreadAnchorPresentation | null | undefined, primaryThreadId: string | null | undefined, fallbackThreadId: string | null | undefined, targetClientY: number | null | undefined) => number | null;
+export {};

package/dist/superdoc/src/helpers/deprecation.d.ts

@@ -1,9 +1,8 @@
+import { Editor } from '../core/types/index.js';
 /**
  * Log a console.warn once per key. Subsequent calls with the same key are no-ops.
- * @param {string} key
- * @param {string} message
  */
-export function warnOnce(key: string, message: string): void;
+export declare function warnOnce(key: string, message: string): void;
 /**
  * Wrap an Editor instance in a Proxy that emits one-time deprecation
  * warnings when consumers access ProseMirror internals or editor commands.
@@ -11,16 +10,11 @@ export function warnOnce(key: string, message: string): void;
  * The proxy is fully transparent — all property access and method calls are
  * forwarded to the underlying editor. Only the warning side-effect is added.
  *
- * @param {import('../core/types/index.js').Editor} editor
- * @returns {import('../core/types/index.js').Editor} Proxied editor (or the
- *   original if null/already wrapped)
+ * @returns Proxied editor (or the original if null/already wrapped)
  */
-export function createDeprecatedEditorProxy(editor: import('../core/types/index.js').Editor): import('../core/types/index.js').Editor;
+export declare function createDeprecatedEditorProxy<T extends Editor | null | undefined>(editor: T): T;
 /**
  * Unwrap a potentially proxied editor back to the raw Editor instance.
  * Safe to call on an already-raw editor — returns it unchanged.
- *
- * @param {import('../core/types/index.js').Editor | null | undefined} editor
- * @returns {import('../core/types/index.js').Editor | null | undefined}
  */
-export function unwrapEditor(editor: import('../core/types/index.js').Editor | null | undefined): import('../core/types/index.js').Editor | null | undefined;
+export declare function unwrapEditor(editor: Editor | null | undefined): Editor | null | undefined;

package/dist/superdoc/src/helpers/interaction-trace.d.ts

@@ -1,26 +1,9 @@
-/**
- * @param {string} stage
- * @param {string} branch
- * @param {Record<string, unknown> | undefined} [meta]
- * @returns {{ traceId: string, spanId: string } | null}
- */
-export function startInteractionSpan(stage: string, branch: string, meta?: Record<string, unknown> | undefined): {
+type InteractionSpan = {
     traceId: string;
     spanId: string;
-} | null;
-/**
- * @param {{ traceId: string, spanId: string } | null | undefined} span
- * @param {Record<string, unknown> | undefined} [meta]
- */
-export function endInteractionSpan(span: {
-    traceId: string;
-    spanId: string;
-} | null | undefined, meta?: Record<string, unknown> | undefined): void;
-/**
- * @param {string} stage
- * @param {string} branch
- * @param {Record<string, unknown> | undefined} meta
- * @param {() => any} fn
- * @returns {any}
- */
-export function withInteractionSpan(stage: string, branch: string, meta: Record<string, unknown> | undefined, fn: () => any): any;
+};
+type InteractionMeta = Record<string, unknown> | undefined;
+export declare function startInteractionSpan(stage: string, branch: string, meta?: InteractionMeta): InteractionSpan | null;
+export declare function endInteractionSpan(span: InteractionSpan | null | undefined, meta?: InteractionMeta): void;
+export declare function withInteractionSpan<T>(stage: string, branch: string, meta: InteractionMeta, fn: () => T): T;
+export {};

package/dist/superdoc/src/helpers/mark-raw-component.d.ts

@@ -0,0 +1 @@
+export declare function markRawComponent(component: unknown): unknown;

package/dist/superdoc/src/helpers/object-guards.d.ts

@@ -1,5 +1 @@
-/**
- * @param {unknown} value
- * @returns {value is Record<string, unknown>}
- */
-export function isPlainObject(value: unknown): value is Record<string, unknown>;
+export declare function isPlainObject(value: unknown): value is Record<string, unknown>;

package/dist/superdoc/src/helpers/selection-source.d.ts

@@ -1 +1 @@
-export const DOCUMENT_EDITOR_SELECTION_SOURCE: "document-editor";
+export declare const DOCUMENT_EDITOR_SELECTION_SOURCE = "document-editor";

package/dist/superdoc/src/helpers/use-selection.d.ts

@@ -1,17 +1,37 @@
-export default function useSelection(params: any): {
-    documentId: import('vue').Ref<any, any>;
-    page: import('vue').Ref<any, any>;
-    selectionBounds: any;
-    source: import('vue').Ref<any, any>;
-    getValues: () => {
-        documentId: any;
-        page: any;
-        selectionBounds: any;
-        source: any;
-    };
+import { Ref } from 'vue';
+type SelectionBounds = {
+    top?: number;
+    left?: number;
+    right?: number;
+    bottom?: number;
+};
+type UseSelectionParams = {
+    documentId?: unknown;
+    page?: number;
+    selectionBounds?: SelectionBounds | null;
+    source?: string | null;
+};
+type ContainerLocation = {
+    top: number;
+    left: number;
+};
+type SelectionValues<Bounds extends SelectionBounds> = {
+    documentId: unknown;
+    page: number | undefined;
+    selectionBounds: Bounds;
+    source: string | null | undefined;
+};
+type SelectionModel<Bounds extends SelectionBounds> = {
+    documentId: Ref<unknown>;
+    page: Ref<number | undefined>;
+    selectionBounds: Bounds;
+    source: Ref<string | null | undefined>;
+    getValues: () => SelectionValues<Bounds>;
     getContainerId: () => string;
-    getContainerLocation: (parentContainer: any) => {
-        top: number;
-        left: number;
-    };
+    getContainerLocation: (parentContainer: Pick<Element, 'getBoundingClientRect'> | null | undefined) => ContainerLocation;
 };
+export default function useSelection<Bounds extends SelectionBounds>(params: UseSelectionParams & {
+    selectionBounds: Bounds;
+}): SelectionModel<Bounds>;
+export default function useSelection(params: UseSelectionParams): SelectionModel<SelectionBounds>;
+export {};

package/dist/superdoc/src/internal/diagnostics/diagnostic-dedupe.d.ts

@@ -11,13 +11,13 @@
  * come from the shell, not be inferred from `onV2EditorReady` timing: that
  * event only fires on success, fires AFTER the diagnostics events on the
  * success path, and never fires at all for a failed attempt.
- *
- * @param {{generation?: unknown} | null} [payload]
- * @returns {number}
  */
-export function getV2DiagnosticGeneration(payload?: {
+export declare function getV2DiagnosticGeneration(payload?: {
     generation?: unknown;
 } | null): number;
+export interface V2DiagnosticDedupe {
+    shouldEmit(documentId: string | null | undefined, generation: number, internalCode: string | null | undefined): boolean;
+}
 /**
  * Creates a dedupe tracker for diagnostic emissions, scoped by documentId
  * and generation. The key is `internalCode` only (per active generation) --
@@ -43,12 +43,8 @@ export function getV2DiagnosticGeneration(payload?: {
  * a long-lived SuperDoc instance's life (e.g. a document-management app
  * cycling through many files); evicting on document removal would need to
  * hook document-lifecycle wiring, which is out of scope here.
- *
- * @returns {{ shouldEmit: (documentId: string | null | undefined, generation: number, internalCode: string | null | undefined) => boolean }}
  */
-export function createV2DiagnosticDedupe(): {
-    shouldEmit: (documentId: string | null | undefined, generation: number, internalCode: string | null | undefined) => boolean;
-};
+export declare function createV2DiagnosticDedupe(): V2DiagnosticDedupe;
 /**
  * A single boot failure can translate to a generic reason-based diagnostic
  * (`translateBootFailureReason`, e.g. `source-load-failed` -> `PARSE_ERROR`)
@@ -61,12 +57,7 @@ export function createV2DiagnosticDedupe(): {
  * `bootErrorName`-classified diagnostic (render-pipeline signal, not
  * package-integrity) is never redundant this way, since it carries genuinely
  * distinct information from the package diagnostics.
- *
- * @param {{internalCode?: string} | null} bootDiagnostic
- * @param {string} reason
- * @param {readonly unknown[]} translatedRecords
- * @returns {boolean}
  */
-export function isBootDiagnosticRedundant(bootDiagnostic: {
+export declare function isBootDiagnosticRedundant(bootDiagnostic: {
     internalCode?: string;
 } | null, reason: string, translatedRecords: readonly unknown[]): boolean;

package/dist/superdoc/src/internal/toolbar/built-in/AIWriter.vue.d.ts

@@ -72,10 +72,10 @@ declare const _default: import('vue').DefineComponent<import('vue').ExtractPropT
 }>> & Readonly<{}>, {
     target: SelectionTarget | null;
     doc: AiWriterDocument | null;
-    restoreSelection: () => void;
     selectedText: string;
-    endpoint: string;
+    restoreSelection: () => void;
     apiKey: string;
+    endpoint: string;
 }, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {
     textareaRef: HTMLTextAreaElement;
 }, HTMLFormElement>;

package/dist/superdoc/src/internal/toolbar/built-in/ButtonGroup.vue.d.ts

@@ -1,27 +1,7 @@
-import { PropType, Ref, StyleValue } from 'vue';
-import { default as ToolbarButton } from './ToolbarButton.vue.js';
-import { default as ToolbarDropdown } from './ToolbarDropdown.vue.js';
-import { default as FontFamilyCombobox } from './FontFamilyCombobox.vue';
-type ButtonItem = InstanceType<typeof ToolbarButton>['$props']['toolbarItem'];
-type ComboBoxProps = InstanceType<typeof FontFamilyCombobox>['$props'];
-type ComboBoxItem = ComboBoxProps['item'];
-type ComboBoxCommand = Parameters<NonNullable<ComboBoxProps['onCommand']>>[0];
-type DropdownOption = NonNullable<InstanceType<typeof ToolbarDropdown>['$props']['options']>[number];
-export interface ToolbarGroupItem extends ButtonItem {
-    type: string;
-    id: Ref<string>;
-    isNarrow: Ref<boolean | undefined>;
-    isWide: Ref<boolean | undefined>;
-    tooltip: Ref<string | undefined>;
-    argument: Ref<unknown>;
-    command?: unknown;
-    splitButtonCommand?: unknown;
-    restoreEditorFocus: boolean;
-    dropdownStyles: Ref<StyleValue | undefined>;
-    dropdownValueKey: Ref<string | undefined>;
-    selectedValue: Ref<string | number | null | undefined>;
-    nestedOptions: Ref<DropdownOption[]>;
-}
+import { PropType } from 'vue';
+import { ToolbarItem, ToolbarItemOption as DropdownOption } from '../built-in-toolbar.js';
+import { ComboBoxCommand, ComboBoxItem } from './ToolbarComboBox.vue.js';
+export type ToolbarGroupItem = Pick<ToolbarItem, 'type' | 'id' | 'name' | 'active' | 'icon' | 'label' | 'hideLabel' | 'iconColor' | 'hasCaret' | 'splitButton' | 'disabled' | 'expand' | 'inlineTextInputVisible' | 'hasInlineTextInput' | 'style' | 'attributes' | 'nestedOptions' | 'isNarrow' | 'isWide' | 'tooltip' | 'argument' | 'command' | 'splitButtonCommand' | 'restoreEditorFocus' | 'dropdownStyles' | 'dropdownValueKey' | 'selectedValue'>;
 export interface ToolbarGroupCommand {
     item: ToolbarGroupItem | ComboBoxItem;
     argument?: unknown;

package/dist/superdoc/src/internal/toolbar/built-in/FontFamilyCombobox.vue.d.ts

@@ -0,0 +1,34 @@
+import { PropType } from 'vue';
+import { ComboBoxCommand, ComboBoxItem, ComboBoxTabOut } from './ToolbarComboBox.vue.js';
+declare const _default: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    item: {
+        type: PropType<ComboBoxItem>;
+        required: true;
+    };
+    uiFontFamily: {
+        type: StringConstructor;
+        default: string;
+    };
+}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    command: (payload: ComboBoxCommand) => any;
+    "item-clicked": () => any;
+    "tab-out": (event: ComboBoxTabOut) => any;
+    "editor-handoff": () => any;
+}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    item: {
+        type: PropType<ComboBoxItem>;
+        required: true;
+    };
+    uiFontFamily: {
+        type: StringConstructor;
+        default: string;
+    };
+}>> & Readonly<{
+    onCommand?: ((payload: ComboBoxCommand) => any) | undefined;
+    "onItem-clicked"?: (() => any) | undefined;
+    "onTab-out"?: ((event: ComboBoxTabOut) => any) | undefined;
+    "onEditor-handoff"?: (() => any) | undefined;
+}>, {
+    uiFontFamily: string;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, HTMLDivElement>;
+export default _default;

package/dist/superdoc/src/internal/toolbar/built-in/FontSizeCombobox.vue.d.ts

@@ -0,0 +1,34 @@
+import { PropType } from 'vue';
+import { ComboBoxCommand, ComboBoxItem, ComboBoxTabOut } from './ToolbarComboBox.vue.js';
+declare const _default: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    item: {
+        type: PropType<ComboBoxItem>;
+        required: true;
+    };
+    uiFontFamily: {
+        type: StringConstructor;
+        default: string;
+    };
+}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    command: (payload: ComboBoxCommand) => any;
+    "item-clicked": () => any;
+    "tab-out": (event: ComboBoxTabOut) => any;
+    "editor-handoff": () => any;
+}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    item: {
+        type: PropType<ComboBoxItem>;
+        required: true;
+    };
+    uiFontFamily: {
+        type: StringConstructor;
+        default: string;
+    };
+}>> & Readonly<{
+    onCommand?: ((payload: ComboBoxCommand) => any) | undefined;
+    "onItem-clicked"?: (() => any) | undefined;
+    "onTab-out"?: ((event: ComboBoxTabOut) => any) | undefined;
+    "onEditor-handoff"?: (() => any) | undefined;
+}>, {
+    uiFontFamily: string;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, HTMLDivElement>;
+export default _default;

package/dist/superdoc/src/internal/toolbar/built-in/LinkInput.vue.d.ts

@@ -171,7 +171,6 @@ declare const _default: import('vue').DefineComponent<import('vue').ExtractPropT
     ui: LinkInputUI | null;
     textTarget: object | null;
     hyperlinkTarget: object | null;
-    restoreSelection: () => void;
     showInput: boolean;
     showLink: boolean;
     goToAnchor: (anchorUrl: string) => unknown;
@@ -180,5 +179,6 @@ declare const _default: import('vue').DefineComponent<import('vue').ExtractPropT
     clickedElement: HTMLElement | null;
     hyperlinkText: string | null;
     selectedText: string | null;
+    restoreSelection: () => void;
 }, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, HTMLDivElement>;
 export default _default;

package/dist/superdoc/src/internal/toolbar/built-in/Toolbar.vue.d.ts

@@ -1,6 +1,12 @@
-declare const _default: import('vue').DefineComponent<{}, {
-    $emit: (event: "select" | "toggle" | "command", ...args: any[]) => void;
-}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {
+declare const _default: import('vue').DefineComponent<{}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    select: (...args: any[]) => void;
+    toggle: (...args: any[]) => void;
+    command: (...args: any[]) => void;
+}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{
+    onSelect?: ((...args: any[]) => any) | undefined;
+    onToggle?: ((...args: any[]) => any) | undefined;
+    onCommand?: ((...args: any[]) => any) | undefined;
+}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {
     toolbarRoot: HTMLDivElement;
 }, HTMLDivElement>;
 export default _default;

package/dist/superdoc/src/internal/toolbar/built-in/ToolbarComboBox.vue.d.ts

@@ -1,5 +1,5 @@
 import { CSSProperties, PropType, Ref, StyleValue } from 'vue';
-interface ComboBoxOption {
+export interface ComboBoxOption {
     key: string;
     label: string;
     value?: string;
@@ -8,7 +8,7 @@ interface ComboBoxOption {
         [key: string]: unknown;
     };
 }
-interface ComboBoxItem {
+export interface ComboBoxItem {
     id?: Ref<string>;
     name: Ref<string>;
     label?: Ref<string | number | null | undefined>;
@@ -25,6 +25,12 @@ interface TabOutTarget {
     shiftKey: boolean;
     target: HTMLInputElement | null;
 }
+export type ComboBoxCommand = {
+    item: ComboBoxItem;
+    argument: string;
+    option: ComboBoxOption | null;
+};
+export type ComboBoxTabOut = KeyboardEvent | TabOutTarget;
 declare const _default: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
     item: {
         type: PropType<ComboBoxItem>;
@@ -43,13 +49,9 @@ declare const _default: import('vue').DefineComponent<import('vue').ExtractPropT
         default: (value: string) => string;
     };
 }>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
-    command: (payload: {
-        item: ComboBoxItem;
-        argument: string;
-        option: ComboBoxOption | null;
-    }) => any;
+    command: (payload: ComboBoxCommand) => any;
     "item-clicked": () => any;
-    "tab-out": (event: KeyboardEvent | TabOutTarget) => any;
+    "tab-out": (event: ComboBoxTabOut) => any;
     "editor-handoff": () => any;
 }, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
     item: {
@@ -69,13 +71,9 @@ declare const _default: import('vue').DefineComponent<import('vue').ExtractPropT
         default: (value: string) => string;
     };
 }>> & Readonly<{
-    onCommand?: ((payload: {
-        item: ComboBoxItem;
-        argument: string;
-        option: ComboBoxOption | null;
-    }) => any) | undefined;
+    onCommand?: ((payload: ComboBoxCommand) => any) | undefined;
     "onItem-clicked"?: (() => any) | undefined;
-    "onTab-out"?: ((event: KeyboardEvent | TabOutTarget) => any) | undefined;
+    "onTab-out"?: ((event: ComboBoxTabOut) => any) | undefined;
     "onEditor-handoff"?: (() => any) | undefined;
 }>, {
     uiFontFamily: string;

package/dist/superdoc/src/internal/toolbar/built-in/ToolbarDropdown.vue.d.ts

@@ -1,15 +1,5 @@
 import { CSSProperties, PropType } from 'vue';
-interface DropdownOption {
-    key?: string | number;
-    label?: string;
-    type?: string;
-    disabled?: boolean;
-    class?: unknown;
-    props?: Record<string, unknown>;
-    icon?: string | object | ((option: DropdownOption) => unknown);
-    render?: () => unknown;
-    [member: string]: unknown;
-}
+import { ToolbarItemOption as DropdownOption } from '../built-in-toolbar.js';
 interface DropdownMenuProps {
     class?: unknown;
     style?: CSSProperties;

package/dist/superdoc/src/internal/toolbar/built-in/color-dropdown-helpers.d.ts

@@ -1,23 +1,13 @@
-export function makeColorOption(color: any, label?: null): {
-    label: null;
+import { BuiltInToolbar, ToolbarItem } from '../built-in-toolbar.js';
+type ColorOption = {
+    label: string;
     icon: string;
-    value: any;
-    style: {
-        color: any;
-        boxShadow: string;
-        borderRadius: string;
-    };
+    value: string;
+    style: Record<string, string>;
 };
-export function renderColorOptions(superToolbar: any, button: any, customIcons?: any[], hasNoneIcon?: boolean): import('vue').VNode<import('vue').RendererNode, import('vue').RendererElement, {
+type ColorDropdownToolbar = Pick<BuiltInToolbar, 'emitCommand' | 'superdoc' | 'activeEditor'>;
+type ColorDropdownButton = Pick<ToolbarItem, 'name' | 'type' | 'command' | 'isCustomToolbarItem' | 'iconColor' | 'expand'>;
+export declare const renderColorOptions: (superToolbar: ColorDropdownToolbar, button: ColorDropdownButton, customIcons?: ColorOption[][], hasNoneIcon?: boolean) => import('vue').VNode<import('vue').RendererNode, import('vue').RendererElement, {
     [key: string]: any;
 }>;
-export const icons: {
-    label: null;
-    icon: string;
-    value: any;
-    style: {
-        color: any;
-        boxShadow: string;
-        borderRadius: string;
-    };
-}[][];
+export {};

package/dist/superdoc/src/internal/toolbar/built-in/constants.d.ts

@@ -1,51 +1,18 @@
-/**
- * The single seam that composes the font dropdown options: it turns the active document's
- * {@link import('../../../../../shared/font-system/src/index.js').DocumentFontOption}s into toolbar font options and unions them
- * with the bundled defaults. The toolbar only asks for the result; it does not know how a font previews.
- *
- * - A consumer-provided `configFonts` list is returned UNCHANGED (custom toolbars own their list).
- * - With no document options, returns `undefined` so the caller keeps its fallback to {@link TOOLBAR_FONTS}.
- * - Otherwise: bundled defaults and document fonts are deduped by normalized logical family, then sorted
- *   alphabetically by the visible font name. `label`/`key` stay the pure logical family (active-state
- *   matching + the stored value), and the preview renders in `previewFamily`.
- *
- * @param {ReadonlyArray<import('../../../../../shared/font-system/src/index.js').DocumentFontOption>} documentOptions
- * @param {Array} [configFonts] - the consumer's `fonts` config, if any
- * @returns {Array|undefined}
- */
-export function composeToolbarFontOptions(documentOptions: ReadonlyArray<import('../../../../../shared/font-system/src/index.js').DocumentFontOption>, configFonts?: any[]): any[] | undefined;
-/**
- * Map the host-computed, activation-aware font-family options onto the toolbar option shape. PURE: it
- * receives the already-resolved list from `superdoc.fonts.getFontFamilyOptions()` (the host owns the
- * `@superdoc/font-system` computation this module must not import). Returns `undefined` for an empty
- * list so the caller keeps its {@link TOOLBAR_FONTS} fallback. `label` is the Word-facing logical
- * family (stored on the selection + used for active-state matching), `key` is a stable option key, and
- * the row preview renders in `previewFamily` (falling back to the label).
- *
- * @param {ReadonlyArray<import('../../../../../shared/font-system/src/index.js').FontFamilyOption>} options
- * @returns {Array|undefined}
- */
-export function mapFontFamilyOptionsToToolbar(options: ReadonlyArray<import('../../../../../shared/font-system/src/index.js').FontFamilyOption>): any[] | undefined;
-export const TOOLBAR_FONTS: {
+import { DocumentFontOption, FontFamilyOption } from '../../../../../shared/font-system/src/index.js';
+import { ToolbarFontOption } from '../../../core/types/index.js';
+export declare const TOOLBAR_FONTS: ToolbarFontOption[];
+export declare function composeToolbarFontOptions(documentOptions: readonly DocumentFontOption[] | null | undefined, configFonts?: readonly ToolbarFontOption[]): readonly ToolbarFontOption[] | undefined;
+export declare function mapFontFamilyOptionsToToolbar(options: readonly FontFamilyOption[] | null | undefined): ToolbarFontOption[] | undefined;
+export declare const TOOLBAR_FONT_SIZES: {
     label: string;
     key: string;
     props: {
-        style: {
-            fontFamily: string;
-        };
         'data-item': string;
     };
 }[];
-export const TOOLBAR_FONT_SIZES: {
-    label: string;
-    key: string;
-    props: {
-        'data-item': string;
-    };
-}[];
-export namespace RESPONSIVE_BREAKPOINTS {
-    let sm: number;
-    let md: number;
-    let lg: number;
-    let xl: number;
-}
+export declare const RESPONSIVE_BREAKPOINTS: {
+    sm: number;
+    md: number;
+    lg: number;
+    xl: number;
+};

package/dist/superdoc/src/internal/toolbar/built-in/default-items.d.ts

@@ -1,18 +1,35 @@
-/**
- * Set or clear the link item's `href` without disturbing the rest of its
- * attributes. The static configuration (`ariaLabel`, and anything added later)
- * lives in the same object as the transient href, so rebuilding that object
- * from the keys a caller knows about silently drops the others.
- *
- * Exported because the built-in toolbar's `updateToolbarState()` writes the
- * href on its own path, without going through this item's handlers. Both
- * callers share this one rule so the two cannot drift apart.
- */
-export function withLinkHref(attributes: any, href: any): any;
-export function makeDefaultItems({ superToolbar, toolbarIcons, toolbarTexts, toolbarFonts, hideButtons, availableWidth, role, isDev, configuredItemNames, configuredItemOrder, excludedItemNames, additionalItems, }?: {
-    isDev?: boolean | undefined;
-    additionalItems?: never[] | undefined;
-}): {
-    defaultItems: any[];
-    overflowItems: any[];
+import { ToolbarItemAttributes } from './use-toolbar-item.js';
+import { BuiltInToolbar, ToolbarItem } from '../built-in-toolbar.js';
+type DefaultItemsToolbar = Pick<BuiltInToolbar, 'config' | 'ui' | 'superdoc' | 'activeEditor' | 'pendingSelectionCapture' | 'emitCommand' | 'isCommandEnabled' | 'getLinkedStyleOptions' | 'getActiveLinkedStyleId' | 'updateLinkedStyleToMatchSelection'>;
+interface DefaultItemsInput {
+    superToolbar: DefaultItemsToolbar;
+    toolbarIcons: Readonly<Record<string, unknown>>;
+    toolbarTexts: Readonly<Record<string, unknown>>;
+    toolbarFonts?: readonly FontOption[] | null;
+    hideButtons: boolean;
+    availableWidth: number;
+    role: string;
+    isDev?: boolean;
+    configuredItemNames?: ReadonlySet<string> | null;
+    configuredItemOrder?: readonly string[] | null;
+    excludedItemNames?: ReadonlySet<string> | null;
+    additionalItems?: readonly ToolbarItem[];
+}
+type FontOption = {
+    label: string;
+    key: string;
+    value?: string;
+    props?: {
+        style?: {
+            fontFamily?: string;
+            [key: string]: unknown;
+        };
+        [key: string]: unknown;
+    };
 };
+export declare function withLinkHref(attributes: ToolbarItemAttributes, href: unknown): ToolbarItemAttributes;
+export declare const makeDefaultItems: ({ superToolbar, toolbarIcons: configuredIcons, toolbarTexts: configuredTexts, toolbarFonts, hideButtons, availableWidth, role, isDev, configuredItemNames, configuredItemOrder, excludedItemNames, additionalItems, }: DefaultItemsInput) => {
+    defaultItems: ToolbarItem[];
+    overflowItems: ToolbarItem[];
+};
+export {};

package/dist/superdoc/src/internal/toolbar/built-in/toolbar-focus-helpers.d.ts

@@ -1,2 +1,10 @@
-export function preventEditorFocusTransfer(event: any): void;
-export function refocusEditorSurface(superToolbar: any, preferredEditor?: null): void;
+type FocusTarget = {
+    focus?: unknown;
+};
+type RefocusToolbar = {
+    superdoc?: FocusTarget | null;
+    activeEditor?: FocusTarget | null;
+};
+export declare const preventEditorFocusTransfer: (event: Pick<Event, "target" | "preventDefault">) => void;
+export declare const refocusEditorSurface: (superToolbar: RefocusToolbar | null | undefined, preferredEditor?: FocusTarget | null) => void;
+export {};