superdoc 2.28.0 → 2.29.0-next.2

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

@@ -1,39 +1,184 @@
-declare const _default: import('vue').DefineComponent<{}, {
-    target: string;
-    href: string;
-    tooltip: string;
-    rel: string;
-    documentMode: string;
-    ui: Record<string, any>;
-    textTarget: Record<string, any>;
-    hyperlinkTarget: Record<string, any>;
+import { PropType, Ref } from 'vue';
+import { SuperDocUI } from '../../../public/ui/types.js';
+type LinkInputUI = Partial<Pick<SuperDocUI, 'selection' | 'toolbar' | 'document'>> & Pick<SuperDocUI, 'commands'>;
+interface LinkItem {
+    attributes?: Ref<{
+        href?: unknown;
+    } | undefined>;
+}
+declare const _default: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    showInput: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    showLink: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    goToAnchor: {
+        type: PropType<(anchorUrl: string) => unknown>;
+        default: () => void;
+    };
+    /** The shared UI controller (single command-state truth). */
+    ui: {
+        type: PropType<LinkInputUI | null>;
+        default: null;
+    };
+    /** The built-in `link` toolbar item, for current-href fallback. */
+    linkItem: {
+        type: PropType<LinkItem | null>;
+        default: null;
+    };
+    closePopover: {
+        type: PropType<() => void>;
+        default: () => void;
+    };
+    href: {
+        type: PropType<string | null>;
+        default: null;
+    };
+    target: {
+        type: PropType<string | null>;
+        default: null;
+    };
+    rel: {
+        type: PropType<string | null>;
+        default: null;
+    };
+    tooltip: {
+        type: PropType<string | null>;
+        default: null;
+    };
+    clickedElement: {
+        type: PropType<HTMLElement | null>;
+        default: null;
+    };
+    hyperlinkTarget: {
+        type: PropType<object | null>;
+        default: null;
+    };
+    hyperlinkText: {
+        type: PropType<string | null>;
+        default: null;
+    };
+    textTarget: {
+        type: PropType<object | null>;
+        default: null;
+    };
+    selectedText: {
+        type: PropType<string | null>;
+        default: null;
+    };
+    /**
+     * Re-applies the toolbar's pre-interaction selection capture before the link
+     * command runs. LinkInput executes the command directly (bypassing Toolbar.vue's
+     * handleCommand → restoreSelection), so without this the command would wrap
+     * whatever selection remains after the dropdown interaction instead of the text
+     * the user highlighted. Supplied by renderLinkDropdown.
+     */
+    restoreSelection: {
+        type: PropType<() => void>;
+        default: () => void;
+    };
+    documentMode: {
+        type: PropType<string | null>;
+        default: null;
+    };
+}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    showInput: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    showLink: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    goToAnchor: {
+        type: PropType<(anchorUrl: string) => unknown>;
+        default: () => void;
+    };
+    /** The shared UI controller (single command-state truth). */
+    ui: {
+        type: PropType<LinkInputUI | null>;
+        default: null;
+    };
+    /** The built-in `link` toolbar item, for current-href fallback. */
+    linkItem: {
+        type: PropType<LinkItem | null>;
+        default: null;
+    };
+    closePopover: {
+        type: PropType<() => void>;
+        default: () => void;
+    };
+    href: {
+        type: PropType<string | null>;
+        default: null;
+    };
+    target: {
+        type: PropType<string | null>;
+        default: null;
+    };
+    rel: {
+        type: PropType<string | null>;
+        default: null;
+    };
+    tooltip: {
+        type: PropType<string | null>;
+        default: null;
+    };
+    clickedElement: {
+        type: PropType<HTMLElement | null>;
+        default: null;
+    };
+    hyperlinkTarget: {
+        type: PropType<object | null>;
+        default: null;
+    };
+    hyperlinkText: {
+        type: PropType<string | null>;
+        default: null;
+    };
+    textTarget: {
+        type: PropType<object | null>;
+        default: null;
+    };
+    selectedText: {
+        type: PropType<string | null>;
+        default: null;
+    };
+    /**
+     * Re-applies the toolbar's pre-interaction selection capture before the link
+     * command runs. LinkInput executes the command directly (bypassing Toolbar.vue's
+     * handleCommand → restoreSelection), so without this the command would wrap
+     * whatever selection remains after the dropdown interaction instead of the text
+     * the user highlighted. Supplied by renderLinkDropdown.
+     */
+    restoreSelection: {
+        type: PropType<() => void>;
+        default: () => void;
+    };
+    documentMode: {
+        type: PropType<string | null>;
+        default: null;
+    };
+}>> & Readonly<{}>, {
+    target: string | null;
+    href: string | null;
+    tooltip: string | null;
+    rel: string | null;
+    documentMode: string | null;
+    ui: LinkInputUI | null;
+    textTarget: object | null;
+    hyperlinkTarget: object | null;
+    restoreSelection: () => void;
     showInput: boolean;
     showLink: boolean;
-    goToAnchor: Function;
-    linkItem: Record<string, any>;
-    closePopover: Function;
-    clickedElement: Record<string, any>;
-    hyperlinkText: string;
-    selectedText: string;
-    restoreSelection: Function;
-    $props: {
-        readonly target?: string | undefined;
-        readonly href?: string | undefined;
-        readonly tooltip?: string | undefined;
-        readonly rel?: string | undefined;
-        readonly documentMode?: string | undefined;
-        readonly ui?: Record<string, any> | undefined;
-        readonly textTarget?: Record<string, any> | undefined;
-        readonly hyperlinkTarget?: Record<string, any> | undefined;
-        readonly showInput?: boolean | undefined;
-        readonly showLink?: boolean | undefined;
-        readonly goToAnchor?: Function | undefined;
-        readonly linkItem?: Record<string, any> | undefined;
-        readonly closePopover?: Function | undefined;
-        readonly clickedElement?: Record<string, any> | undefined;
-        readonly hyperlinkText?: string | undefined;
-        readonly selectedText?: string | undefined;
-        readonly restoreSelection?: Function | undefined;
-    };
-}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, HTMLDivElement>;
+    goToAnchor: (anchorUrl: string) => unknown;
+    linkItem: LinkItem | null;
+    closePopover: () => void;
+    clickedElement: HTMLElement | null;
+    hyperlinkText: string | null;
+    selectedText: string | null;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, HTMLDivElement>;
 export default _default;

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

@@ -1,14 +1,43 @@
-declare const _default: import('vue').DefineComponent<{}, {
-    $emit: (event: "update" | "select", ...args: any[]) => void;
-    styles: unknown[];
-    selectedOption: string;
-    updateLabel: string;
-    $props: {
-        readonly styles?: unknown[] | undefined;
-        readonly selectedOption?: string | undefined;
-        readonly updateLabel?: string | undefined;
+import { PropType } from 'vue';
+import { StyleCatalogItem } from '../../../public/ui/types.js';
+type LinkedStyleOption = Partial<Pick<StyleCatalogItem, 'id' | 'name' | 'preview'>>;
+declare const _default: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    styles: {
+        type: PropType<LinkedStyleOption[]>;
+        default: () => never[];
+    };
+    selectedOption: {
+        type: PropType<string | null>;
+        default: null;
+    };
+    updateLabel: {
+        type: StringConstructor;
+        default: string;
+    };
+}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    update: (style: Partial<Pick<StyleCatalogItem, "id" | "name" | "preview">>) => any;
+    select: (style: Partial<Pick<StyleCatalogItem, "id" | "name" | "preview">>) => any;
+}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    styles: {
+        type: PropType<LinkedStyleOption[]>;
+        default: () => never[];
     };
-}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {
+    selectedOption: {
+        type: PropType<string | null>;
+        default: null;
+    };
+    updateLabel: {
+        type: StringConstructor;
+        default: string;
+    };
+}>> & Readonly<{
+    onUpdate?: ((style: Partial<Pick<StyleCatalogItem, "id" | "name" | "preview">>) => any) | undefined;
+    onSelect?: ((style: Partial<Pick<StyleCatalogItem, "id" | "name" | "preview">>) => any) | undefined;
+}>, {
+    styles: Partial<Pick<StyleCatalogItem, "id" | "name" | "preview">>[];
+    selectedOption: string | null;
+    updateLabel: string;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {
     styleRefs: HTMLDivElement[];
 }, HTMLDivElement>;
 export default _default;

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

@@ -1,25 +1,136 @@
-declare const _default: import('vue').DefineComponent<{}, {
-    close: Function;
+import { PropType } from 'vue';
+import { HeaderFooterKind, HeaderFooterPageNumberAlignment, HeaderFooterPageNumbersInfo, SectionPageNumberingFormat } from '../../../../../document-api/src/index.js';
+import { CommandExecutionResult, CommandState } from '../../../public/ui/types.js';
+type PagePosition = 'top' | 'bottom';
+interface PageNumberChoice {
+    position: PagePosition;
+    alignment?: HeaderFooterPageNumberAlignment;
+    showOnFirstPage?: boolean;
+    format?: SectionPageNumberingFormat;
+    start?: number | null;
+}
+interface RememberedChoice {
+    position: PagePosition;
+    alignment: HeaderFooterPageNumberAlignment | null;
+    showOnFirstPage: boolean;
+}
+type PageNumberMenuOutcome = {
+    action: 'apply';
+    choice: RememberedChoice;
+} | {
+    action: 'remove';
+    kinds: HeaderFooterKind[];
+} | {
+    action: 'cursor';
+};
+declare const _default: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    /** Command state of `page-numbers-apply`, read when the popover opens. */
+    pageNumbersState: {
+        type: PropType<CommandState | null>;
+        default: null;
+    };
+    /** Command state of `page-number-insert` (insert at the header/footer cursor). */
+    atCursorState: {
+        type: PropType<CommandState | null>;
+        default: null;
+    };
+    /** Header/footer structure cannot be suggested, so numbering needs Editing. */
+    suggesting: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    /** The selection is in a header or footer, so a disabled cursor insert needs a collapsed caret. */
+    inHeaderFooter: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    /** Resolves the caret section's page numbers (`headerFooters.pageNumbers.get`), or null. */
+    loadCurrent: {
+        type: PropType<() => Promise<HeaderFooterPageNumbersInfo | null>>;
+        default: null;
+    };
+    /** Runs `page-numbers-apply` with `{ position, alignment?, showOnFirstPage?, format?, start? }`. */
+    applyPageNumbers: {
+        type: PropType<(choice: PageNumberChoice) => Promise<CommandExecutionResult>>;
+        required: true;
+    };
+    /** Runs `page-numbers-remove`. */
+    removePageNumbers: {
+        type: PropType<() => Promise<CommandExecutionResult>>;
+        required: true;
+    };
+    /** Runs `page-number-insert` at the header/footer cursor. */
+    insertAtCursor: {
+        type: PropType<() => Promise<CommandExecutionResult>>;
+        required: true;
+    };
+    /** Closes the popover after a successful action. */
+    close: {
+        type: PropType<(outcome: PageNumberMenuOutcome) => void>;
+        required: true;
+    };
+    /** Last choice made in this session, used when the section has no numbers yet. */
+    initialChoice: {
+        type: PropType<RememberedChoice | null>;
+        default: null;
+    };
+}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    /** Command state of `page-numbers-apply`, read when the popover opens. */
+    pageNumbersState: {
+        type: PropType<CommandState | null>;
+        default: null;
+    };
+    /** Command state of `page-number-insert` (insert at the header/footer cursor). */
+    atCursorState: {
+        type: PropType<CommandState | null>;
+        default: null;
+    };
+    /** Header/footer structure cannot be suggested, so numbering needs Editing. */
+    suggesting: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    /** The selection is in a header or footer, so a disabled cursor insert needs a collapsed caret. */
+    inHeaderFooter: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    /** Resolves the caret section's page numbers (`headerFooters.pageNumbers.get`), or null. */
+    loadCurrent: {
+        type: PropType<() => Promise<HeaderFooterPageNumbersInfo | null>>;
+        default: null;
+    };
+    /** Runs `page-numbers-apply` with `{ position, alignment?, showOnFirstPage?, format?, start? }`. */
+    applyPageNumbers: {
+        type: PropType<(choice: PageNumberChoice) => Promise<CommandExecutionResult>>;
+        required: true;
+    };
+    /** Runs `page-numbers-remove`. */
+    removePageNumbers: {
+        type: PropType<() => Promise<CommandExecutionResult>>;
+        required: true;
+    };
+    /** Runs `page-number-insert` at the header/footer cursor. */
+    insertAtCursor: {
+        type: PropType<() => Promise<CommandExecutionResult>>;
+        required: true;
+    };
+    /** Closes the popover after a successful action. */
+    close: {
+        type: PropType<(outcome: PageNumberMenuOutcome) => void>;
+        required: true;
+    };
+    /** Last choice made in this session, used when the section has no numbers yet. */
+    initialChoice: {
+        type: PropType<RememberedChoice | null>;
+        default: null;
+    };
+}>> & Readonly<{}>, {
     suggesting: boolean;
-    pageNumbersState: Record<string, any>;
-    atCursorState: Record<string, any>;
+    pageNumbersState: CommandState | null;
+    atCursorState: CommandState | null;
     inHeaderFooter: boolean;
-    loadCurrent: Function;
-    applyPageNumbers: Function;
-    removePageNumbers: Function;
-    insertAtCursor: Function;
-    initialChoice: Record<string, any>;
-    $props: {
-        readonly close?: Function | undefined;
-        readonly suggesting?: boolean | undefined;
-        readonly pageNumbersState?: Record<string, any> | undefined;
-        readonly atCursorState?: Record<string, any> | undefined;
-        readonly inHeaderFooter?: boolean | undefined;
-        readonly loadCurrent?: Function | undefined;
-        readonly applyPageNumbers?: Function | undefined;
-        readonly removePageNumbers?: Function | undefined;
-        readonly insertAtCursor?: Function | undefined;
-        readonly initialChoice?: Record<string, any> | undefined;
-    };
-}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, HTMLDivElement>;
+    loadCurrent: () => Promise<HeaderFooterPageNumbersInfo | null>;
+    initialChoice: RememberedChoice | null;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, HTMLDivElement>;
 export default _default;

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

@@ -1,26 +1,5 @@
-declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
-export default _default;
-type __VLS_WithTemplateSlots<T, S> = T & (new () => {
-    $slots: S;
-});
-declare const __VLS_component: import('vue').DefineComponent<{}, {
-    disabled: boolean;
-    contentStyle: Record<string, any>;
-    trigger: string;
-    delay: number;
-    duration: number;
-    $props: {
-        readonly disabled?: boolean | undefined;
-        readonly contentStyle?: Record<string, any> | undefined;
-        readonly trigger?: string | undefined;
-        readonly delay?: number | undefined;
-        readonly duration?: number | undefined;
-    };
-}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {
-    triggerRef: HTMLSpanElement;
-    contentRef: HTMLDivElement;
-}, any>;
-type __VLS_TemplateResult = {
+import { CSSProperties, PropType } from 'vue';
+declare function __VLS_template(): {
     attrs: Partial<{}>;
     slots: {
         trigger?(_: {}): any;
@@ -32,3 +11,63 @@ type __VLS_TemplateResult = {
     };
     rootEl: any;
 };
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    trigger: {
+        type: StringConstructor;
+        default: string;
+    };
+    delay: {
+        type: NumberConstructor;
+        default: number;
+    };
+    duration: {
+        type: NumberConstructor;
+        default: number;
+    };
+    disabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    contentStyle: {
+        type: PropType<CSSProperties>;
+        default: () => {};
+    };
+}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    trigger: {
+        type: StringConstructor;
+        default: string;
+    };
+    delay: {
+        type: NumberConstructor;
+        default: number;
+    };
+    duration: {
+        type: NumberConstructor;
+        default: number;
+    };
+    disabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    contentStyle: {
+        type: PropType<CSSProperties>;
+        default: () => {};
+    };
+}>> & Readonly<{}>, {
+    disabled: boolean;
+    contentStyle: CSSProperties;
+    duration: number;
+    trigger: string;
+    delay: number;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {
+    triggerRef: HTMLSpanElement;
+    contentRef: HTMLDivElement;
+}, any>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

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

@@ -1,24 +1,109 @@
-declare const _default: import('vue').DefineComponent<{}, {
-    $emit: (event: "buttonClick" | "textSubmit" | "mainClick", ...args: any[]) => void;
+import { MaybeRef, PropType, Ref, StyleValue } from 'vue';
+interface ToolbarButtonItem {
+    name: Ref<string>;
+    active: MaybeRef<boolean>;
+    icon: Ref<string | undefined>;
+    label: Ref<string | undefined>;
+    hideLabel: Ref<boolean | undefined>;
+    iconColor: Ref<string | undefined>;
+    hasCaret: Ref<boolean | undefined>;
+    splitButton: Ref<boolean>;
+    disabled: Ref<boolean | undefined>;
+    expand: Ref<boolean>;
+    inlineTextInputVisible: Ref<boolean | undefined>;
+    hasInlineTextInput: Ref<boolean | undefined>;
+    style: Ref<StyleValue | undefined>;
+    attributes: Ref<{
+        className?: unknown;
+        ariaLabel?: string;
+    }>;
+    nestedOptions?: Ref<{
+        label?: string;
+    }[]>;
+}
+declare const _default: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    iconColor: {
+        type: PropType<string | null>;
+        default: null;
+    };
+    active: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    isNarrow: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    isWide: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    toolbarItem: {
+        type: PropType<ToolbarButtonItem>;
+        required: true;
+    };
+    defaultLabel: {
+        type: PropType<string | null>;
+        default: null;
+    };
+    isOverflowItem: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    allowEnterPropagation: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    buttonClick: () => any;
+    textSubmit: (value: string) => any;
+    mainClick: () => any;
+}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    iconColor: {
+        type: PropType<string | null>;
+        default: null;
+    };
+    active: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    isNarrow: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    isWide: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    toolbarItem: {
+        type: PropType<ToolbarButtonItem>;
+        required: true;
+    };
+    defaultLabel: {
+        type: PropType<string | null>;
+        default: null;
+    };
+    isOverflowItem: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    allowEnterPropagation: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>> & Readonly<{
+    onButtonClick?: (() => any) | undefined;
+    onTextSubmit?: ((value: string) => any) | undefined;
+    onMainClick?: (() => any) | undefined;
+}>, {
     active: boolean;
     isNarrow: boolean;
     isWide: boolean;
-    defaultLabel: string;
-    iconColor: string;
-    toolbarItem: Record<string, any>;
+    defaultLabel: string | null;
+    iconColor: string | null;
     isOverflowItem: boolean;
     allowEnterPropagation: boolean;
-    $props: {
-        readonly active?: boolean | undefined;
-        readonly isNarrow?: boolean | undefined;
-        readonly isWide?: boolean | undefined;
-        readonly defaultLabel?: string | undefined;
-        readonly iconColor?: string | undefined;
-        readonly toolbarItem?: Record<string, any> | undefined;
-        readonly isOverflowItem?: boolean | undefined;
-        readonly allowEnterPropagation?: boolean | undefined;
-    };
-}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {
     inlineInput: HTMLInputElement;
 }, HTMLDivElement>;
 export default _default;