superdoc 2.28.0 → 2.29.0-next.2

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

@@ -1,23 +1,12 @@
-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<{}, {
-    $emit: (event: "select", ...args: any[]) => void;
-    options: unknown[];
-    disabled: boolean;
-    contentStyle: Record<string, any>;
-    $props: {
-        readonly options?: unknown[] | undefined;
-        readonly disabled?: boolean | undefined;
-        readonly contentStyle?: Record<string, any> | undefined;
-    };
-}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {
-    triggerRef: HTMLDivElement;
-    menuRef: HTMLDivElement;
-}, HTMLDivElement>;
-type __VLS_TemplateResult = {
+import { CSSProperties, PropType, VNodeChild } from 'vue';
+type CommentsDropdownOption = {
+    key: string;
+    label: string;
+    disabled?: boolean;
+    iconString?: string;
+    icon?: VNodeChild | ((option: CommentsDropdownOption) => VNodeChild);
+};
+declare function __VLS_template(): {
     attrs: Partial<{}>;
     slots: {
         default?(_: {}): any;
@@ -28,3 +17,49 @@ type __VLS_TemplateResult = {
     };
     rootEl: HTMLDivElement;
 };
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    options: {
+        type: PropType<readonly CommentsDropdownOption[]>;
+        default: () => never[];
+    };
+    disabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    contentStyle: {
+        type: PropType<CSSProperties>;
+        default: () => {};
+    };
+}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    select: (...args: any[]) => void;
+}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    options: {
+        type: PropType<readonly CommentsDropdownOption[]>;
+        default: () => never[];
+    };
+    disabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    contentStyle: {
+        type: PropType<CSSProperties>;
+        default: () => {};
+    };
+}>> & Readonly<{
+    onSelect?: ((...args: any[]) => any) | undefined;
+}>, {
+    options: readonly CommentsDropdownOption[];
+    disabled: boolean;
+    contentStyle: CSSProperties;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {
+    triggerRef: HTMLDivElement;
+    menuRef: HTMLDivElement;
+}, HTMLDivElement>;
+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/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/CommentsLayer/InternalDropdown.vue.d.ts

@@ -1,10 +1,26 @@
-declare const _default: import('vue').DefineComponent<{}, {
-    $emit: (event: "select", ...args: any[]) => void;
-    isDisabled: boolean;
-    state?: string | undefined;
-    $props: {
-        readonly isDisabled?: boolean | undefined;
-        readonly state?: string | undefined;
+declare const _default: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    state: {
+        type: StringConstructor;
+        required: false;
+    };
+    isDisabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    select: (...args: any[]) => void;
+}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    state: {
+        type: StringConstructor;
+        required: false;
     };
-}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, HTMLDivElement>;
+    isDisabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>> & Readonly<{
+    onSelect?: ((...args: any[]) => any) | undefined;
+}>, {
+    isDisabled: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, HTMLDivElement>;
 export default _default;

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

@@ -1,4 +1,6 @@
-declare const _default: import('vue').DefineComponent<{}, {
-    $emit: (event: "anchor-activate", ...args: any[]) => void;
-}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, HTMLDivElement>;
+declare const _default: import('vue').DefineComponent<{}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "anchor-activate": (...args: any[]) => void;
+}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{
+    "onAnchor-activate"?: ((...args: any[]) => any) | undefined;
+}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, HTMLDivElement>;
 export default _default;

package/dist/superdoc/src/components/CommentsLayer/commentsList/ReviewDirectoryListItem.vue.d.ts

@@ -1,16 +1,64 @@
-declare const _default: import('vue').DefineComponent<{}, {
-    $emit: (event: "navigate" | "focus-item", ...args: any[]) => void;
-    index: number;
-    total: number;
-    item: Record<string, any>;
-    tabIndex: number;
-    $props: {
-        readonly index?: number | undefined;
-        readonly total?: number | undefined;
-        readonly item?: Record<string, any> | undefined;
-        readonly tabIndex?: number | undefined;
+import { PropType } from 'vue';
+import { CommentModel } from '../use-comment.js';
+export type PositionEntry = {
+    pageIndex?: number | null;
+    bounds?: {
+        top?: number;
+        bottom?: number;
+    } | null;
+};
+export type ReviewDirectoryItem = {
+    id: string | undefined;
+    comment: CommentModel;
+    floatingInstanceId: string | null;
+    floatingPageIndex: number | null | undefined;
+    floatingPositionEntry: PositionEntry | null;
+    isFloatingInstanceActive: boolean | undefined;
+    threadComments: CommentModel[];
+};
+declare const _default: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    item: {
+        type: PropType<ReviewDirectoryItem>;
+        required: true;
+    };
+    index: {
+        type: NumberConstructor;
+        required: true;
+    };
+    total: {
+        type: NumberConstructor;
+        required: true;
+    };
+    tabIndex: {
+        type: NumberConstructor;
+        default: number;
+    };
+}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    navigate: (...args: any[]) => void;
+    "focus-item": (...args: any[]) => void;
+}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    item: {
+        type: PropType<ReviewDirectoryItem>;
+        required: true;
     };
-}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {
+    index: {
+        type: NumberConstructor;
+        required: true;
+    };
+    total: {
+        type: NumberConstructor;
+        required: true;
+    };
+    tabIndex: {
+        type: NumberConstructor;
+        default: number;
+    };
+}>> & Readonly<{
+    onNavigate?: ((...args: any[]) => any) | undefined;
+    "onFocus-item"?: ((...args: any[]) => any) | undefined;
+}>, {
+    tabIndex: number;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {
     shell: HTMLDivElement;
 }, HTMLDivElement>;
 export default _default;

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

@@ -1,11 +1,25 @@
-declare const _default: import('vue').DefineComponent<{}, {
+declare const _default: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    showMainComments: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    showResolvedComments: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    showMainComments: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    showResolvedComments: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>> & Readonly<{}>, {
     showMainComments: boolean;
     showResolvedComments: boolean;
-    $props: {
-        readonly showMainComments?: boolean | undefined;
-        readonly showResolvedComments?: boolean | undefined;
-    };
-}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {
     listRoot: HTMLDivElement;
 }, HTMLDivElement>;
 export default _default;

package/dist/superdoc/src/components/CommentsLayer/use-comment.d.ts

@@ -326,4 +326,5 @@ export default function useComment(params: UseCommentParams): {
     };
     updateIdentityValues: (updates?: CommentIdentity) => void;
 };
+export type CommentModel = ReturnType<typeof useComment>;
 export {};

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

@@ -0,0 +1,14 @@
+import { PropType } from 'vue';
+import { User } from '../../core/types/index.js';
+declare const _default: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    user: {
+        type: PropType<User>;
+        required: true;
+    };
+}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    user: {
+        type: PropType<User>;
+        required: true;
+    };
+}>> & 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,7 +11,8 @@ export const PERMISSIONS: Readonly<{
     VERSION_HISTORY: "VERSION_HISTORY";
 }>;
 export function createTrackedChangePermissionResolver(superdoc: any): (payload?: {}) => any;
-export function isAllowed(permission: string, role: string, isInternal: boolean, context?: {
+export function readBuiltInTrackedChangePermissionDecision(superdoc: any, canPerform: any, permission: any, trackedChange: any): any;
+export function isAllowed(permission: string, role: string | undefined, isInternal: boolean | undefined, context?: {
     comment?: object | null | undefined;
     superdoc?: object | null | undefined;
     currentUser?: 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;