superdoc 2.29.0-next.3 → 2.29.0

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 {};