superdoc 2.29.0-next.1 → 2.29.0-next.13

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

@@ -1,19 +1,62 @@
-declare const _default: import('vue').DefineComponent<{}, {
-    close: Function;
-    mode: string;
-    resolve: Function;
-    request: Record<string, any>;
+import { PropType } from 'vue';
+import { FindReplaceHandle, SurfaceComponentProps, SurfaceMode, SurfaceRequest } from '../../core/types/index.js';
+declare const _default: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    surfaceId: {
+        type: StringConstructor;
+        default: string;
+    };
+    mode: {
+        type: PropType<SurfaceMode>;
+        default: string;
+    };
+    request: {
+        type: PropType<SurfaceRequest>;
+        default: () => {};
+    };
+    resolve: {
+        type: PropType<SurfaceComponentProps["resolve"]>;
+        default: () => void;
+    };
+    close: {
+        type: PropType<SurfaceComponentProps["close"]>;
+        default: () => void;
+    };
+    findReplace: {
+        type: PropType<FindReplaceHandle>;
+        required: true;
+    };
+}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    surfaceId: {
+        type: StringConstructor;
+        default: string;
+    };
+    mode: {
+        type: PropType<SurfaceMode>;
+        default: string;
+    };
+    request: {
+        type: PropType<SurfaceRequest>;
+        default: () => {};
+    };
+    resolve: {
+        type: PropType<SurfaceComponentProps["resolve"]>;
+        default: () => void;
+    };
+    close: {
+        type: PropType<SurfaceComponentProps["close"]>;
+        default: () => void;
+    };
+    findReplace: {
+        type: PropType<FindReplaceHandle>;
+        required: true;
+    };
+}>> & Readonly<{}>, {
+    close: (reason?: unknown) => void;
+    mode: SurfaceMode;
+    resolve: (data?: unknown) => void;
+    request: SurfaceRequest;
     surfaceId: string;
-    findReplace: Record<string, any>;
-    $props: {
-        readonly close?: Function | undefined;
-        readonly mode?: string | undefined;
-        readonly resolve?: Function | undefined;
-        readonly request?: Record<string, any> | undefined;
-        readonly surfaceId?: string | undefined;
-        readonly findReplace?: Record<string, any> | undefined;
-    };
-}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {
     findInputRef: HTMLInputElement;
 }, HTMLDivElement>;
 export default _default;

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

@@ -1,17 +1,60 @@
-declare const _default: import('vue').DefineComponent<{}, {
-    close: Function;
-    mode: string;
-    resolve: Function;
-    request: Record<string, any>;
+import { PropType } from 'vue';
+import { PasswordPromptHandle, SurfaceComponentProps, SurfaceMode, SurfaceRequest } from '../../core/types/index.js';
+declare const _default: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    surfaceId: {
+        type: StringConstructor;
+        default: string;
+    };
+    mode: {
+        type: PropType<SurfaceMode>;
+        default: string;
+    };
+    request: {
+        type: PropType<SurfaceRequest>;
+        default: () => {};
+    };
+    resolve: {
+        type: PropType<SurfaceComponentProps["resolve"]>;
+        default: () => void;
+    };
+    close: {
+        type: PropType<SurfaceComponentProps["close"]>;
+        default: () => void;
+    };
+    passwordPrompt: {
+        type: PropType<PasswordPromptHandle>;
+        required: true;
+    };
+}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    surfaceId: {
+        type: StringConstructor;
+        default: string;
+    };
+    mode: {
+        type: PropType<SurfaceMode>;
+        default: string;
+    };
+    request: {
+        type: PropType<SurfaceRequest>;
+        default: () => {};
+    };
+    resolve: {
+        type: PropType<SurfaceComponentProps["resolve"]>;
+        default: () => void;
+    };
+    close: {
+        type: PropType<SurfaceComponentProps["close"]>;
+        default: () => void;
+    };
+    passwordPrompt: {
+        type: PropType<PasswordPromptHandle>;
+        required: true;
+    };
+}>> & Readonly<{}>, {
+    close: (reason?: unknown) => void;
+    mode: SurfaceMode;
+    resolve: (data?: unknown) => void;
+    request: SurfaceRequest;
     surfaceId: string;
-    passwordPrompt: Record<string, any>;
-    $props: {
-        readonly close?: Function | undefined;
-        readonly mode?: string | undefined;
-        readonly resolve?: Function | undefined;
-        readonly request?: Record<string, any> | undefined;
-        readonly surfaceId?: string | undefined;
-        readonly passwordPrompt?: Record<string, any> | undefined;
-    };
-}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, HTMLDivElement>;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, HTMLDivElement>;
 export default _default;

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

@@ -1,10 +1,18 @@
-declare const _default: import('vue').DefineComponent<{}, {
-    rootEl: import('vue').Ref<null, null>;
-    surface: Record<string, any>;
-    $props: {
-        readonly surface?: Record<string, any> | undefined;
+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;
     };
-}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {
+}>, {
+    rootEl: import('vue').Ref<HTMLElement | null, HTMLElement | null>;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    surface: {
+        type: PropType<ActiveSurface>;
+        required: true;
+    };
+}>> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {
     floatingRef: HTMLDivElement;
 }, HTMLDivElement>;
 export default _default;

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

@@ -1,16 +1,25 @@
-declare const _default: import('vue').DefineComponent<{}, {
-    geometryTarget: Record<string, any>;
-    $props: {
-        readonly geometryTarget?: Record<string, any> | undefined;
+import { PropType } from 'vue';
+declare const _default: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    geometryTarget: {
+        type: PropType<HTMLElement | null>;
+        default: null;
     };
-}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {
+}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    geometryTarget: {
+        type: PropType<HTMLElement | null>;
+        default: null;
+    };
+}>> & Readonly<{}>, {
+    geometryTarget: HTMLElement | null;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {
     hostRef: HTMLDivElement;
-    floatingRef: import('vue').CreateComponentPublicInstanceWithMixins<Readonly<{}> & Readonly<{}>, {
-        rootEl: import('vue').Ref<null, null>;
-        surface: Record<string, any>;
-        $props: {
-            readonly surface?: Record<string, any> | undefined;
+    floatingRef: import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('vue').ExtractPropTypes<{
+        surface: {
+            type: PropType<import('../../core/surface-manager.js').ActiveSurface>;
+            required: true;
         };
+    }>> & Readonly<{}>, {
+        rootEl: import('vue').Ref<HTMLElement | null, HTMLElement | null>;
     }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, import('vue').PublicProps, {}, true, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {
         floatingRef: HTMLDivElement;
     }, HTMLDivElement, import('vue').ComponentProvideOptions, {
@@ -20,12 +29,13 @@ declare const _default: import('vue').DefineComponent<{}, {
         C: {};
         M: {};
         Defaults: {};
-    }, Readonly<{}> & Readonly<{}>, {
-        rootEl: import('vue').Ref<null, null>;
-        surface: Record<string, any>;
-        $props: {
-            readonly surface?: Record<string, any> | undefined;
+    }, Readonly<import('vue').ExtractPropTypes<{
+        surface: {
+            type: PropType<import('../../core/surface-manager.js').ActiveSurface>;
+            required: true;
         };
+    }>> & Readonly<{}>, {
+        rootEl: import('vue').Ref<HTMLElement | null, HTMLElement | null>;
     }, {}, {}, {}, {}> | null;
 }, any>;
 export default _default;

package/dist/superdoc/src/components/surfaces/focusable-selector.d.ts

@@ -1,5 +1 @@
-/**
- * CSS selector matching all focusable elements within a surface shell.
- * Used by SurfaceDialog (focus trap, initial focus) and SurfaceFloating (initial focus).
- */
-export const FOCUSABLE_SELECTOR: string;
+export declare const FOCUSABLE_SELECTOR: string;

package/dist/superdoc/src/components/surfaces/watermark-surface-runtime.d.ts

@@ -1,8 +1,8 @@
-/** The runtime owns its Vue component; consumers only need the surface request value. */
-export function createWatermarkSurfaceRuntime(getContainer?: () => HTMLElement | null): {
-  component: unknown;
-  captureFocusReturn(): (isCurrent: () => boolean) => Promise<void>;
-  mount(): void;
-  announce(message: string): void;
-  destroy(): void;
+/** Keeps Vue rendering and post-dismissal announcements outside the public type graph. */
+export declare function createWatermarkSurfaceRuntime(getContainer?: () => HTMLElement | null): {
+    component: unknown;
+    captureFocusReturn(): (isCurrent: () => boolean) => Promise<void>;
+    mount(): void;
+    announce(message: string): void;
+    destroy(): void;
 };

package/dist/superdoc/src/composables/find-shortcut-owner.d.ts

@@ -1,32 +1,39 @@
+/**
+ * Shared ownership registry for the ambient (no-focus) Cmd/Ctrl+F shortcut.
+ *
+ * Several SuperDoc instances can be mounted on one page, and each registers a
+ * document-level capture listener for the find shortcut. When focus is inside
+ * an instance that instance handles the shortcut, but when focus is on <body>
+ * (fresh page load, clicks on page chrome) every instance would otherwise
+ * consider itself eligible — and `stopPropagation()` cannot suppress sibling
+ * listeners already registered on the same node, so multiple find bars would
+ * open. This registry elects a single ambient owner: the most recently mounted
+ * or interacted-with instance.
+ */
 /**
  * Make `owner` the ambient find-shortcut owner. Call on mount and on user
  * interaction (pointerdown / focusin inside the instance) so "the SuperDoc the
  * user last touched" wins the ambient shortcut.
- * @param {unknown} owner
  */
-export function claimFindShortcut(owner: unknown): void;
+export declare function claimFindShortcut(owner: unknown): void;
 /**
  * Clear ownership if `owner` currently holds it. Call on unmount.
- * @param {unknown} owner
  */
-export function releaseFindShortcut(owner: unknown): void;
+export declare function releaseFindShortcut(owner: unknown): void;
 /**
  * Whether `owner` may handle the ambient (no-focus) find shortcut. With no
  * claimed owner any instance may handle it (single-instance pages), relying on
  * the `defaultPrevented` check in {@link shouldHandleFindShortcut} to keep the
  * shortcut single-fire.
- * @param {unknown} owner
  */
-export function ownsAmbientFindShortcut(owner: unknown): boolean;
+export declare function ownsAmbientFindShortcut(owner: unknown): boolean;
 /**
  * Decide whether one SuperDoc instance's capture listener should handle a
  * find-shortcut keydown. `defaultPrevented` covers the cross-instance race
  * directly: the first instance to act marks the event, and sibling capture
  * listeners on the same node skip it.
- * @param {KeyboardEvent} event
- * @param {{ focusInside: boolean, owner: unknown }} context
  */
-export function shouldHandleFindShortcut(event: KeyboardEvent, { focusInside, owner }: {
+export declare function shouldHandleFindShortcut(event: KeyboardEvent, { focusInside, owner }: {
     focusInside: boolean;
     owner: unknown;
 }): boolean;

package/dist/superdoc/src/composables/replace-continuation.d.ts

@@ -8,30 +8,26 @@
  * longer looking at.
  *
  * A leaf module rather than a closure inside `useFindReplace`, following
- * `find-shortcut-owner.js`. The guard previously lived in two byte-identical
+ * `find-shortcut-owner.ts`. The guard previously lived in two byte-identical
  * inline closures, each of which needed a full composable driving a
  * worker-backed host caught mid-swap to reach one branch. Nothing could, so it
  * shipped with a comment admitting it was verified by inspection only. The
  * duplication was the tell: logic worth stating twice is worth naming once.
  */
+type ReplaceSession = {
+    getSnapshot: () => unknown;
+};
+type ReplaceContinuationDeps<S extends ReplaceSession> = {
+    getCurrentSession: () => S | null;
+    applySlice: (snapshot: unknown) => void;
+    onSettled: () => void;
+};
 /**
  * Build the continuation that publishes a settled replace back into the panel.
  *
  * The session handle itself is the identity. `onSettled` always runs, including
  * when the write is skipped: it clears the pending flag that gates the replace
  * controls, and leaving it set would disable them with nothing left to settle.
- *
- * @param {{ getSnapshot: () => unknown }} session The handle captured when the replace was issued.
- * @param {object} deps
- * @param {() => unknown} deps.getCurrentSession Reads the live session identity.
- * @param {(snapshot: unknown) => void} deps.applySlice Publishes a snapshot into the panel.
- * @param {() => void} deps.onSettled Runs whether or not the write was skipped.
- * @returns {() => void}
  */
-export function createReplaceContinuation(session: {
-    getSnapshot: () => unknown;
-}, { getCurrentSession, applySlice, onSettled }: {
-    getCurrentSession: () => unknown;
-    applySlice: (snapshot: unknown) => void;
-    onSettled: () => void;
-}): () => void;
+export declare function createReplaceContinuation<S extends ReplaceSession>(session: S, { getCurrentSession, applySlice, onSettled }: ReplaceContinuationDeps<S>): () => void;
+export {};

package/dist/superdoc/src/composables/use-comment-small-screen.d.ts

@@ -1,10 +1,14 @@
-export function useCommentSmallScreen({ commentsModuleConfig, superdocRoot, layers }: {
-    commentsModuleConfig: any;
-    superdocRoot: any;
-    layers: any;
-}): {
-    superdocContainerWidth: import('vue').Ref<number, number>;
-    isCompactCommentsMode: import('vue').Ref<boolean, boolean>;
+import { Ref } from 'vue';
+import { CommentsConfig } from '../core/types/index.js';
+interface UseCommentSmallScreenOptions {
+    commentsModuleConfig: Readonly<Ref<CommentsConfig | null | undefined>>;
+    superdocRoot: Readonly<Ref<HTMLElement | null>>;
+    layers: Readonly<Ref<HTMLElement | null>>;
+}
+export declare function useCommentSmallScreen({ commentsModuleConfig, superdocRoot, layers }: UseCommentSmallScreenOptions): {
+    superdocContainerWidth: Ref<number, number>;
+    isCompactCommentsMode: Ref<boolean, boolean>;
     recalculateCompactCommentsMode: () => void;
     ensureCompactMeasurementObserver: () => void;
 };
+export {};

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

@@ -1,21 +1,47 @@
-export function useCompactCommentPopover({ activeComment, pendingComment, activeCompactComment, showCommentsSidebar, selectionPosition, activeZoom, superdocRoot, layers, documents, resolveCommentPositionEntry, clearActiveComment, clearPendingComment, }: {
-    activeComment: any;
-    pendingComment: any;
-    activeCompactComment: any;
-    showCommentsSidebar: any;
-    selectionPosition: any;
-    activeZoom: any;
-    superdocRoot: any;
-    layers: any;
-    documents: any;
-    resolveCommentPositionEntry: any;
-    clearActiveComment: any;
-    clearPendingComment: any;
-}): {
-    compactCommentPopoverStyle: import('vue').ComputedRef<{
-        top: string;
-        right: string;
-    }>;
+import { Ref } from 'vue';
+import { RuntimeDocument } from '../core/types/index.js';
+type CompactComment = {
+    commentId?: unknown;
+    importedId?: unknown;
+    selection?: {
+        source?: unknown;
+    } | null;
+};
+type CompactSelectionPosition = {
+    top?: unknown;
+    bottom?: unknown;
+    source?: unknown;
+};
+type CommentPositionLookup = (commentOrId: unknown) => {
+    entry: {
+        bounds?: {
+            top?: unknown;
+            bottom?: unknown;
+        } | null;
+    } | null;
+};
+type PopoverStyle = {
+    top: string;
+    left?: string;
+    right: string;
+};
+interface UseCompactCommentPopoverOptions {
+    activeComment: Readonly<Ref<unknown>>;
+    pendingComment: Readonly<Ref<CompactComment | null | undefined>>;
+    activeCompactComment: Readonly<Ref<CompactComment | null | undefined>>;
+    showCommentsSidebar: Readonly<Ref<unknown>>;
+    selectionPosition: Readonly<Ref<CompactSelectionPosition | null | undefined>>;
+    activeZoom: Readonly<Ref<number | null | undefined>>;
+    superdocRoot: Readonly<Ref<HTMLElement | null>>;
+    layers: Readonly<Ref<HTMLElement | null>>;
+    documents: Readonly<Ref<readonly Pick<RuntimeDocument, 'type'>[] | null | undefined>>;
+    resolveCommentPositionEntry: CommentPositionLookup;
+    clearActiveComment: () => void;
+    clearPendingComment: () => void;
+}
+export declare function useCompactCommentPopover({ activeComment, pendingComment, activeCompactComment, showCommentsSidebar, selectionPosition, activeZoom, superdocRoot, layers, documents, resolveCommentPositionEntry, clearActiveComment, clearPendingComment, }: UseCompactCommentPopoverOptions): {
+    compactCommentPopoverStyle: import('vue').ComputedRef<PopoverStyle>;
     closeCompactCommentPopover: () => void;
     resetClickAnchor: () => void;
 };
+export {};