superdoc 2.29.0-next.3 → 2.29.0-next.9

package/dist/superdoc/src/components/PdfViewer/PdfViewerDocument.vue.d.ts

@@ -1,20 +1,66 @@
-declare const _default: import('vue').DefineComponent<{}, {
-    $emit: (event: "page-rendered" | "page-error" | "selection-raw" | "bypass-selection" | "page-focus", ...args: any[]) => void;
-    pages: unknown[];
-    config: Record<string, any>;
+import { PropType } from 'vue';
+import { PdfViewerConfig, PdfViewerDocumentData, PdfViewerPageData } from './pdf-viewer-types.js';
+declare const _default: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    config: {
+        type: PropType<PdfViewerConfig>;
+        required: true;
+    };
+    pdf: {
+        type: PropType<PdfViewerDocumentData | null>;
+    };
+    pages: {
+        type: PropType<PdfViewerPageData[]>;
+        required: true;
+    };
+    scale: {
+        type: NumberConstructor;
+        required: true;
+    };
+    hasTextLayer: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    outputScale: {
+        type: NumberConstructor;
+    };
+}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "page-rendered": (...args: any[]) => void;
+    "page-error": (...args: any[]) => void;
+    "selection-raw": (...args: any[]) => void;
+    "bypass-selection": (...args: any[]) => void;
+    "page-focus": (...args: any[]) => void;
+}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    config: {
+        type: PropType<PdfViewerConfig>;
+        required: true;
+    };
+    pdf: {
+        type: PropType<PdfViewerDocumentData | null>;
+    };
+    pages: {
+        type: PropType<PdfViewerPageData[]>;
+        required: true;
+    };
+    scale: {
+        type: NumberConstructor;
+        required: true;
+    };
+    hasTextLayer: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    outputScale: {
+        type: NumberConstructor;
+    };
+}>> & Readonly<{
+    "onPage-rendered"?: ((...args: any[]) => any) | undefined;
+    "onPage-error"?: ((...args: any[]) => any) | undefined;
+    "onSelection-raw"?: ((...args: any[]) => any) | undefined;
+    "onBypass-selection"?: ((...args: any[]) => any) | undefined;
+    "onPage-focus"?: ((...args: any[]) => any) | undefined;
+}>, {
     hasTextLayer: boolean;
-    scale?: number | undefined;
-    pdf?: Record<string, any> | undefined;
-    outputScale?: number | undefined;
-    $props: {
-        readonly pages?: unknown[] | undefined;
-        readonly config?: Record<string, any> | undefined;
-        readonly hasTextLayer?: boolean | undefined;
-        readonly scale?: number | undefined;
-        readonly pdf?: Record<string, any> | undefined;
-        readonly outputScale?: number | undefined;
-    };
-}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {
     documentRef: HTMLDivElement;
     documentWrapper: HTMLDivElement;
 }, HTMLDivElement>;

package/dist/superdoc/src/components/PdfViewer/PdfViewerPage.vue.d.ts

@@ -1,22 +1,82 @@
-declare const _default: import('vue').DefineComponent<{}, {
-    $emit: (event: "page-rendered" | "page-error" | "text-layer-rendered" | "text-layer-error" | "selection-raw" | "bypass-selection", ...args: any[]) => void;
-    page: Record<string, any>;
-    pages: unknown[];
-    config: Record<string, any>;
-    scale: number;
+import { PropType } from 'vue';
+import { PdfViewerConfig, PdfViewerPageData } from './pdf-viewer-types.js';
+declare const _default: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    config: {
+        type: PropType<PdfViewerConfig>;
+        required: true;
+    };
+    page: {
+        type: PropType<PdfViewerPageData>;
+        required: true;
+    };
+    pages: {
+        type: PropType<PdfViewerPageData[]>;
+        required: true;
+    };
+    scale: {
+        type: NumberConstructor;
+        required: true;
+    };
+    hasTextLayer: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    outputScale: {
+        type: NumberConstructor;
+        default: number;
+    };
+    documentEl: {
+        type: PropType<HTMLElement | null>;
+        default: null;
+    };
+}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "page-rendered": (...args: any[]) => void;
+    "page-error": (...args: any[]) => void;
+    "text-layer-rendered": (...args: any[]) => void;
+    "text-layer-error": (...args: any[]) => void;
+    "selection-raw": (...args: any[]) => void;
+    "bypass-selection": (...args: any[]) => void;
+}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    config: {
+        type: PropType<PdfViewerConfig>;
+        required: true;
+    };
+    page: {
+        type: PropType<PdfViewerPageData>;
+        required: true;
+    };
+    pages: {
+        type: PropType<PdfViewerPageData[]>;
+        required: true;
+    };
+    scale: {
+        type: NumberConstructor;
+        required: true;
+    };
+    hasTextLayer: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    outputScale: {
+        type: NumberConstructor;
+        default: number;
+    };
+    documentEl: {
+        type: PropType<HTMLElement | null>;
+        default: null;
+    };
+}>> & Readonly<{
+    "onPage-rendered"?: ((...args: any[]) => any) | undefined;
+    "onPage-error"?: ((...args: any[]) => any) | undefined;
+    "onText-layer-rendered"?: ((...args: any[]) => any) | undefined;
+    "onText-layer-error"?: ((...args: any[]) => any) | undefined;
+    "onSelection-raw"?: ((...args: any[]) => any) | undefined;
+    "onBypass-selection"?: ((...args: any[]) => any) | undefined;
+}>, {
     hasTextLayer: boolean;
     outputScale: number;
-    documentEl: Record<string, any>;
-    $props: {
-        readonly page?: Record<string, any> | undefined;
-        readonly pages?: unknown[] | undefined;
-        readonly config?: Record<string, any> | undefined;
-        readonly scale?: number | undefined;
-        readonly hasTextLayer?: boolean | undefined;
-        readonly outputScale?: number | undefined;
-        readonly documentEl?: Record<string, any> | undefined;
-    };
-}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {
+    documentEl: HTMLElement | null;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {
     pageRef: HTMLDivElement;
     canvasRef: HTMLCanvasElement;
     textLayerRef: HTMLDivElement;

package/dist/superdoc/src/components/PdfViewer/pdf-viewer-types.d.ts

@@ -0,0 +1,45 @@
+import { Raw } from 'vue';
+import { PDFDocumentProxy, PDFPageProxy, TextLayer } from 'pdfjs-dist';
+export type PdfViewerLib = {
+    TextLayer?: typeof TextLayer;
+};
+export type PdfViewerConfig = {
+    pdfLib?: PdfViewerLib;
+    workerSrc?: string;
+    setWorker?: boolean;
+    textLayer?: boolean;
+    outputScale?: number;
+};
+export type PdfViewerDocumentData = {
+    documentId: string;
+    pdfjsDocument: Raw<PDFDocumentProxy>;
+};
+export type PdfViewerPageData = {
+    documentId: string;
+    pageId: string;
+    pageNumber: number;
+    pageIsRendered: boolean;
+    pdfjsPage: Raw<PDFPageProxy>;
+};
+export type PdfPageRenderedPayload = {
+    page: PdfViewerPageData;
+    documentId: string;
+    pageIndex: number;
+    pageNumber: number;
+    width: number;
+    height: number;
+    originalWidth: number;
+    originalHeight: number;
+};
+export type PdfSelectionBounds = {
+    top: number;
+    left: number;
+    bottom: number;
+    right: number;
+};
+export type PdfSelectionRawPayload = {
+    selectionBounds: PdfSelectionBounds;
+    documentId: string;
+    page: number;
+    source: 'pdf';
+};

package/dist/superdoc/src/components/Whiteboard/WhiteboardLayer.vue.d.ts

@@ -1,19 +1,84 @@
-declare const _default: import('vue').DefineComponent<{}, {
+import { PropType } from 'vue';
+import { WhiteboardPage as WhiteboardPageModel } from '../../core/whiteboard/WhiteboardPage.js';
+import { WhiteboardDropTarget, WhiteboardPageOffset, WhiteboardPageSize } from './whiteboard-types.js';
+declare const _default: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    whiteboard: {
+        type: PropType<WhiteboardDropTarget>;
+        required: true;
+    };
+    pages: {
+        type: PropType<WhiteboardPageModel[]>;
+        default: () => never[];
+    };
+    pageSizes: {
+        type: PropType<Record<number, WhiteboardPageSize>>;
+        default: () => {};
+    };
+    pageOffsets: {
+        type: PropType<Record<number, WhiteboardPageOffset>>;
+        default: () => {};
+    };
+    enabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    /**
+     * Pointer ownership flag, separate from `enabled` (which controls show + Konva
+     * interactivity). When the whiteboard surface overlays a PDF, the host passes
+     * `interactive` so a visible-but-inert whiteboard layer never swallows PDF text
+     * selection or PDF comment selection. Defaults to `enabled` to preserve the
+     * legacy single-flag behavior when a host does not provide an explicit value.
+     */
+    interactive: {
+        type: PropType<boolean | null>;
+        default: null;
+    };
+    opacity: {
+        type: NumberConstructor;
+        default: number;
+    };
+}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    whiteboard: {
+        type: PropType<WhiteboardDropTarget>;
+        required: true;
+    };
+    pages: {
+        type: PropType<WhiteboardPageModel[]>;
+        default: () => never[];
+    };
+    pageSizes: {
+        type: PropType<Record<number, WhiteboardPageSize>>;
+        default: () => {};
+    };
+    pageOffsets: {
+        type: PropType<Record<number, WhiteboardPageOffset>>;
+        default: () => {};
+    };
+    enabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    /**
+     * Pointer ownership flag, separate from `enabled` (which controls show + Konva
+     * interactivity). When the whiteboard surface overlays a PDF, the host passes
+     * `interactive` so a visible-but-inert whiteboard layer never swallows PDF text
+     * selection or PDF comment selection. Defaults to `enabled` to preserve the
+     * legacy single-flag behavior when a host does not provide an explicit value.
+     */
+    interactive: {
+        type: PropType<boolean | null>;
+        default: null;
+    };
+    opacity: {
+        type: NumberConstructor;
+        default: number;
+    };
+}>> & Readonly<{}>, {
     enabled: boolean;
     opacity: number;
-    pages: unknown[];
-    whiteboard: Record<string, any>;
-    pageSizes: Record<string, any>;
-    pageOffsets: Record<string, any>;
-    interactive: boolean;
-    $props: {
-        readonly enabled?: boolean | undefined;
-        readonly opacity?: number | undefined;
-        readonly pages?: unknown[] | undefined;
-        readonly whiteboard?: Record<string, any> | undefined;
-        readonly pageSizes?: Record<string, any> | undefined;
-        readonly pageOffsets?: Record<string, any> | undefined;
-        readonly interactive?: boolean | undefined;
-    };
-}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, HTMLDivElement>;
+    pages: WhiteboardPageModel[];
+    pageSizes: Record<number, WhiteboardPageSize>;
+    pageOffsets: Record<number, WhiteboardPageOffset>;
+    interactive: boolean | null;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, HTMLDivElement>;
 export default _default;

package/dist/superdoc/src/components/Whiteboard/WhiteboardPage.vue.d.ts

@@ -1,17 +1,53 @@
-declare const _default: import('vue').DefineComponent<{}, {
+import { PropType } from 'vue';
+import { WhiteboardPage } from '../../core/whiteboard/WhiteboardPage.js';
+import { WhiteboardDropTarget, WhiteboardPageOffset, WhiteboardPageSize } from './whiteboard-types.js';
+declare const _default: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    whiteboard: {
+        type: PropType<WhiteboardDropTarget>;
+        required: true;
+    };
+    page: {
+        type: PropType<WhiteboardPage>;
+        required: true;
+    };
+    pageSize: {
+        type: PropType<WhiteboardPageSize | null>;
+        default: null;
+    };
+    pageOffset: {
+        type: PropType<WhiteboardPageOffset | null>;
+        default: null;
+    };
+    enabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    whiteboard: {
+        type: PropType<WhiteboardDropTarget>;
+        required: true;
+    };
+    page: {
+        type: PropType<WhiteboardPage>;
+        required: true;
+    };
+    pageSize: {
+        type: PropType<WhiteboardPageSize | null>;
+        default: null;
+    };
+    pageOffset: {
+        type: PropType<WhiteboardPageOffset | null>;
+        default: null;
+    };
+    enabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>> & Readonly<{}>, {
     enabled: boolean;
-    page: Record<string, any>;
-    whiteboard: Record<string, any>;
-    pageSize: Record<string, any>;
-    pageOffset: Record<string, any>;
-    $props: {
-        readonly enabled?: boolean | undefined;
-        readonly page?: Record<string, any> | undefined;
-        readonly whiteboard?: Record<string, any> | undefined;
-        readonly pageSize?: Record<string, any> | undefined;
-        readonly pageOffset?: Record<string, any> | undefined;
-    };
-}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {
+    pageSize: WhiteboardPageSize | null;
+    pageOffset: WhiteboardPageOffset | null;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {
     containerRef: HTMLDivElement;
 }, HTMLDivElement>;
 export default _default;

package/dist/superdoc/src/components/Whiteboard/use-whiteboard.d.ts

@@ -1,18 +1,33 @@
-export function useWhiteboard({ proxy, layers, documents, modules }: {
-    proxy: any;
-    layers: any;
-    documents: any;
-    modules: any;
-}): {
-    whiteboard: any;
-    whiteboardModuleConfig: import('vue').ComputedRef<any>;
-    whiteboardPages: import('vue').ShallowRef<never[], never[]>;
-    whiteboardPageSizes: {};
-    whiteboardPageOffsets: {};
-    whiteboardEnabled: import('vue').Ref<any, any>;
-    whiteboardOpacity: import('vue').Ref<number, number>;
-    whiteboardReady: import('vue').Ref<boolean, boolean>;
-    handleWhiteboardPageReady: (payload: any) => void;
+import { Ref } from 'vue';
+import { SuperDoc } from '../../core/SuperDoc.js';
+import { Document, Modules } from '../../core/types/index.js';
+import { WhiteboardPageSize } from '../../core/whiteboard/Whiteboard.js';
+import { WhiteboardPage } from '../../core/whiteboard/WhiteboardPage.js';
+import { PdfPageRenderedPayload } from '../PdfViewer/pdf-viewer-types.js';
+import { WhiteboardPageOffset } from './whiteboard-types.js';
+type WhiteboardDocument = Pick<Document, 'id' | 'type'>;
+type WhiteboardPageReadyPayload = Pick<PdfPageRenderedPayload, 'pageIndex' | 'width' | 'height' | 'originalWidth' | 'originalHeight'>;
+export type UseWhiteboardOptions = {
+    proxy: {
+        $superdoc: Pick<SuperDoc, 'emit' | 'whiteboard'>;
+    };
+    layers: Ref<HTMLElement | null>;
+    documents: Ref<WhiteboardDocument[]>;
+    modules: Modules;
+};
+export declare const useWhiteboard: ({ proxy, layers, documents, modules }: UseWhiteboardOptions) => {
+    whiteboard: import('../../core/whiteboard/Whiteboard.js').Whiteboard | null;
+    whiteboardModuleConfig: import('vue').ComputedRef<{
+        enabled?: boolean;
+    } | null>;
+    whiteboardPages: import('vue').ShallowRef<WhiteboardPage[], WhiteboardPage[]>;
+    whiteboardPageSizes: Record<number, WhiteboardPageSize>;
+    whiteboardPageOffsets: Record<number, WhiteboardPageOffset>;
+    whiteboardEnabled: Ref<boolean, boolean>;
+    whiteboardOpacity: Ref<number, number>;
+    whiteboardReady: Ref<boolean, boolean>;
+    handleWhiteboardPageReady: (payload: WhiteboardPageReadyPayload | null | undefined) => void;
     updateWhiteboardPageSizes: () => void;
     updateWhiteboardPageOffsets: () => void;
 };
+export {};

package/dist/superdoc/src/components/Whiteboard/whiteboard-types.d.ts

@@ -0,0 +1,11 @@
+import { Whiteboard } from '../../core/whiteboard/Whiteboard.js';
+export type WhiteboardPageSize = {
+    width: number;
+    height: number;
+    originalWidth?: number | null;
+};
+export type WhiteboardPageOffset = {
+    top: number;
+    left: number;
+};
+export type WhiteboardDropTarget = Pick<Whiteboard, 'getTool' | 'getType'>;

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