superdoc 2.28.0 → 2.29.0-next.1

package/dist/superdoc/src/components/CommentsLayer/CommentHeader.vue.d.ts

@@ -1,8 +1,8 @@
 declare const _default: import('vue').DefineComponent<{}, {
     $emit: (event: "reject" | "resolve" | "reopen" | "overflow-select", ...args: any[]) => void;
     config: Record<string, any>;
-    isPendingInput: boolean;
     isActive: boolean;
+    isPendingInput: boolean;
     resolveDisabledReason: string;
     rejectDisabledReason: string;
     reopenDisabledReason: string;
@@ -12,8 +12,8 @@ declare const _default: import('vue').DefineComponent<{}, {
     timestamp?: number | undefined;
     $props: {
         readonly config?: Record<string, any> | undefined;
-        readonly isPendingInput?: boolean | undefined;
         readonly isActive?: boolean | undefined;
+        readonly isPendingInput?: boolean | undefined;
         readonly resolveDisabledReason?: string | undefined;
         readonly rejectDisabledReason?: string | undefined;
         readonly reopenDisabledReason?: string | undefined;

package/dist/superdoc/src/components/CommentsLayer/CommentInput.vue.d.ts

@@ -2,14 +2,14 @@ declare const _default: import('vue').DefineComponent<{}, {
     focus: (options: any) => void;
     $emit: (event: "focus", ...args: any[]) => void;
     config: Record<string, any>;
-    users: unknown[];
     isFocused: boolean;
+    users: unknown[];
     includeHeader: boolean;
     comment?: Record<string, any> | undefined;
     $props: {
         readonly config?: Record<string, any> | undefined;
-        readonly users?: unknown[] | undefined;
         readonly isFocused?: boolean | undefined;
+        readonly users?: unknown[] | undefined;
         readonly includeHeader?: boolean | undefined;
         readonly comment?: Record<string, any> | undefined;
     };

package/dist/superdoc/src/components/CommentsLayer/FloatingComments.vue.d.ts

@@ -1,11 +1,24 @@
-declare const _default: import('vue').DefineComponent<{}, {
-    parent: Record<string, any>;
-    currentDocument: Record<string, any>;
-    $props: {
-        readonly parent?: Record<string, any> | undefined;
-        readonly currentDocument?: Record<string, any> | undefined;
-    };
-}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {
+import { PropType } from 'vue';
+import { Document as SuperDocDocument } from '../../core/types/index.js';
+declare const _default: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    currentDocument: {
+        type: PropType<SuperDocDocument>;
+        required: true;
+    };
+    parent: {
+        type: PropType<HTMLElement>;
+        required: true;
+    };
+}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    currentDocument: {
+        type: PropType<SuperDocDocument>;
+        required: true;
+    };
+    parent: {
+        type: PropType<HTMLElement>;
+        required: true;
+    };
+}>> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {
     floatingCommentsContainer: HTMLDivElement;
 }, HTMLDivElement>;
 export default _default;

package/dist/superdoc/src/components/general/Avatar.vue.d.ts

@@ -0,0 +1,7 @@
+declare const _default: import('vue').DefineComponent<{}, {
+    user: Record<string, any>;
+    $props: {
+        readonly user?: Record<string, any> | undefined;
+    };
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, HTMLDivElement>;
+export default _default;

package/dist/superdoc/src/components/surfaces/SurfaceDialog.vue.d.ts

@@ -1,12 +1,30 @@
-declare const _default: import('vue').DefineComponent<{}, {
-    $emit: (event: "close", ...args: any[]) => void;
-    surface: Record<string, any>;
-    scrollLockTarget: Record<string, any>;
-    $props: {
-        readonly surface?: Record<string, any> | undefined;
-        readonly scrollLockTarget?: Record<string, any> | undefined;
-    };
-}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {
+import { PropType } from 'vue';
+import { ActiveSurface } from '../../core/surface-manager.js';
+declare const _default: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    surface: {
+        type: PropType<ActiveSurface>;
+        required: true;
+    };
+    scrollLockTarget: {
+        type: PropType<HTMLElement | null>;
+        default: null;
+    };
+}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    close: (...args: any[]) => void;
+}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    surface: {
+        type: PropType<ActiveSurface>;
+        required: true;
+    };
+    scrollLockTarget: {
+        type: PropType<HTMLElement | null>;
+        default: null;
+    };
+}>> & Readonly<{
+    onClose?: ((...args: any[]) => any) | undefined;
+}>, {
+    scrollLockTarget: HTMLElement | null;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {
     dialogRef: HTMLDivElement;
 }, HTMLDivElement>;
 export default _default;

package/dist/superdoc/src/components/surfaces/SurfaceExternalMount.vue.d.ts

@@ -1,19 +1,56 @@
-declare const _default: import('vue').DefineComponent<{}, {
-    close: Function;
-    mode: string;
-    resolve: Function;
-    request: Record<string, any>;
-    render: Function;
-    surfaceId: string;
-    $props: {
-        readonly close?: Function | undefined;
-        readonly mode?: string | undefined;
-        readonly resolve?: Function | undefined;
-        readonly request?: Record<string, any> | undefined;
-        readonly render?: Function | undefined;
-        readonly surfaceId?: string | undefined;
-    };
-}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {
+import { PropType } from 'vue';
+import { DirectSurfaceRequest, ExternalSurfaceRenderContext, SurfaceMode, SurfaceRequest } from '../../core/types/index.js';
+declare const _default: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    surfaceId: {
+        type: StringConstructor;
+        required: true;
+    };
+    mode: {
+        type: PropType<SurfaceMode>;
+        required: true;
+    };
+    request: {
+        type: PropType<SurfaceRequest>;
+        required: true;
+    };
+    render: {
+        type: PropType<NonNullable<DirectSurfaceRequest["render"]>>;
+        required: true;
+    };
+    resolve: {
+        type: PropType<ExternalSurfaceRenderContext["resolve"]>;
+        required: true;
+    };
+    close: {
+        type: PropType<ExternalSurfaceRenderContext["close"]>;
+        required: true;
+    };
+}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    surfaceId: {
+        type: StringConstructor;
+        required: true;
+    };
+    mode: {
+        type: PropType<SurfaceMode>;
+        required: true;
+    };
+    request: {
+        type: PropType<SurfaceRequest>;
+        required: true;
+    };
+    render: {
+        type: PropType<NonNullable<DirectSurfaceRequest["render"]>>;
+        required: true;
+    };
+    resolve: {
+        type: PropType<ExternalSurfaceRenderContext["resolve"]>;
+        required: true;
+    };
+    close: {
+        type: PropType<ExternalSurfaceRenderContext["close"]>;
+        required: true;
+    };
+}>> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {
     container: HTMLDivElement;
 }, HTMLDivElement>;
 export default _default;

package/dist/superdoc/src/composables/use-link-popover.d.ts

@@ -1,6 +1,6 @@
 import { SurfaceManager } from '../core/surface-manager.js';
 import { DocumentMode, Editor, HyperlinkActivationHandler, LinkPopoverResolver } from '../core/types/index.js';
-import { SuperDocUI } from '../public/ui/types.js';
+import { BorrowedSuperDocUI } from '../public/ui/types.js';
 /**
  * The `v2-link-click` payload the shell relays from the v2 host's
  * `onLinkClick` callback.
@@ -17,9 +17,9 @@ interface LinkClickPayload {
     editableText?: boolean;
 }
 interface UseLinkPopoverOptions {
-    getSurfaceManager: () => SurfaceManager | null | undefined;
+    getSurfaceManager: () => Pick<SurfaceManager, 'open'> | null | undefined;
     getActiveEditor: () => Editor | null | undefined;
-    getUi: () => SuperDocUI | null | undefined;
+    getUi: () => BorrowedSuperDocUI | null | undefined;
     getActivationHandler: () => HyperlinkActivationHandler | LinkPopoverResolver | null | undefined;
     getActivationHandlerSource?: () => 'hyperlinks.onActivate' | 'compatibility' | null | undefined;
     getBuiltInEditorDisabled?: () => boolean;

package/dist/superdoc/src/composables/use-superdoc-instance.d.ts

@@ -1,7 +1,10 @@
 import { ComponentPublicInstance } from 'vue';
 import { SuperDoc } from '../core/SuperDoc.js';
+export type SuperDocComponentProxy = ComponentPublicInstance & {
+    $superdoc: SuperDoc;
+};
 export interface SuperDocInstanceAccess {
-    proxy: ComponentPublicInstance;
+    proxy: SuperDocComponentProxy;
     superdoc: SuperDoc;
 }
 export declare function useSuperDocInstance(): SuperDocInstanceAccess;

package/dist/superdoc/src/core/SuperDoc.d.ts

@@ -692,7 +692,7 @@ export declare class SuperDoc extends EventEmitter<SuperDocEventMap> {
      * @deprecated replaceWith=`await superdoc.activeEditor.doc.getHtml({})` removeIn=v3.0
      * @param _options Ignored.
      */
-    getHTML(_options?: Parameters<Editor['getHTML']>[0]): unknown[];
+    getHTML(_options?: Parameters<NonNullable<Editor['getHTML']>>[0]): unknown[];
     /**
      * Lock the current superdoc and emit the `locked` event.
      *

package/dist/superdoc/src/core/collaboration/permissions.d.ts

@@ -11,6 +11,7 @@ export const PERMISSIONS: Readonly<{
     VERSION_HISTORY: "VERSION_HISTORY";
 }>;
 export function createTrackedChangePermissionResolver(superdoc: any): (payload?: {}) => any;
+export function readBuiltInTrackedChangePermissionDecision(superdoc: any, canPerform: any, permission: any, trackedChange: any): any;
 export function isAllowed(permission: string, role: string, isInternal: boolean, context?: {
     comment?: object | null | undefined;
     superdoc?: object | null | undefined;

package/dist/superdoc/src/core/types/index.d.ts

@@ -500,7 +500,12 @@ export interface Editor {
     setHighContrastMode?: (isHighContrast: boolean) => unknown;
     on?: (...args: unknown[]) => unknown;
     off?: (...args: unknown[]) => unknown;
-    getHTML: (options?: Record<string, unknown>) => unknown;
+    /**
+     * Not implemented by the superdoc@2 active editor; guard before calling.
+     *
+     * @deprecated replaceWith=`await editor.doc.getHtml({})` removeIn=v3.0
+     */
+    getHTML?: (options?: Record<string, unknown>) => unknown;
     getDocumentId?: () => string | null | undefined;
     /**
      * Narrow v2 extension facet for command execution and diagnostics, backed by
@@ -2997,9 +3002,9 @@ export interface SuperDocTrackedChangesBulkDecisionPayload {
  * the editor it is bound to and ignore anything else.
  *
  * Typed `unknown` rather than `Editor`: the active editor can be a v2 facade
- * that does not satisfy `Editor` (`getHTML` is required there and absent on the
- * facade), so annotating it as `Editor` would promise methods that are not
- * present. It is an identity token to compare, not an object to call.
+ * whose runtime shape does not match `Editor`, so annotating it as `Editor`
+ * would promise members it does not have. It is an identity token to compare,
+ * not an object to call.
  */
 export interface SuperDocDocumentReplacedPayload {
     editor: unknown;

package/dist/superdoc/src/helpers/is-finite-number.d.ts

@@ -0,0 +1 @@
+export declare function isFiniteNumber(value: unknown): value is number;

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

@@ -12,12 +12,12 @@
  * 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}} [payload]
+ * @param {{generation?: unknown} | null} [payload]
  * @returns {number}
  */
 export function getV2DiagnosticGeneration(payload?: {
     generation?: unknown;
-}): number;
+} | null): number;
 /**
  * Creates a dedupe tracker for diagnostic emissions, scoped by documentId
  * and generation. The key is `internalCode` only (per active generation) --

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

@@ -1,16 +1,16 @@
 declare const _default: import('vue').DefineComponent<{}, {
     target: Record<string, any>;
     doc: Record<string, any>;
-    selectedText: string;
     restoreSelection: Function;
+    selectedText: string;
     endpoint: string;
     apiKey: string;
     handleClose: Function;
     $props: {
         readonly target?: Record<string, any> | undefined;
         readonly doc?: Record<string, any> | undefined;
-        readonly selectedText?: string | undefined;
         readonly restoreSelection?: Function | undefined;
+        readonly selectedText?: string | undefined;
         readonly endpoint?: string | undefined;
         readonly apiKey?: string | undefined;
         readonly handleClose?: Function | undefined;

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;