superdoc 2.2.0 → 2.3.0

package/dist/superdoc/src/core/v2-integration/browser-peer-runtime.d.ts

@@ -0,0 +1,3 @@
+export function readSuperDocV2BrowserRuntime(globalObject?: typeof globalThis): any;
+export function installSuperDocV2BrowserRuntime(runtime?: {}, globalObject?: typeof globalThis): any;
+export const SUPERDOC_V2_BROWSER_RUNTIME_GLOBAL_KEY: "__SUPERDOC_V2_BROWSER_RUNTIME__";

package/dist/superdoc/src/core/v2-integration/cdn-engine-loader.d.ts

@@ -0,0 +1,16 @@
+/**
+ * @param {typeof globalThis} globalObject
+ * @param {string} engineVersion
+ * @param {string | null} buildOverride
+ */
+export function resolveDocxEngineCdnBaseUrl(globalObject: typeof globalThis, engineVersion: string, buildOverride?: string | null): any;
+/** @param {{ engineVersion: string, buildBaseUrl: string | null }} options */
+export function configureCdnEngineLoader({ engineVersion, buildBaseUrl }: {
+    engineVersion: string;
+    buildBaseUrl: string | null;
+}): void;
+/**
+ * @param {string} url
+ * @returns {Promise<void>}
+ */
+export function loadStylesheetOnce(url: string): Promise<void>;

package/dist/superdoc/src/core/v2-integration/v2-integration.d.ts

@@ -0,0 +1,97 @@
+/**
+ * Replace the package loader before engine loading starts. The CDN entry uses
+ * this seam to fetch the exact engine version from its public package URL.
+ *
+ * @param {() => Promise<unknown>} loader
+ */
+export function configureDefaultV2IntegrationLoader(loader: () => Promise<unknown>): void;
+/** Load the engine before Vue evaluates the synchronous integration seam. */
+export function loadDefaultV2Integration(): Promise<void>;
+/** Load the engine for editor startup, preserving the fail-closed stub on failure. */
+export function loadDefaultV2IntegrationOrFallback(): Promise<void>;
+/**
+ * @param {unknown} item
+ * @returns {boolean}
+ */
+export function isSyntheticTrackedChangeCommentLaneItem(item: unknown): boolean;
+/**
+ * @param {{ trackedChange?: unknown, trackedChangeAnchorKey?: unknown } | null | undefined} row
+ * @returns {boolean}
+ */
+export function isV2SyntheticTrackedChangeRow(row: {
+    trackedChange?: unknown;
+    trackedChangeAnchorKey?: unknown;
+} | null | undefined): boolean;
+/**
+ * @returns {SuperDocV2Integration}
+ */
+export function createStubV2Integration(): SuperDocV2Integration;
+/**
+ * Build the default v2 integration the runtime always uses. The v2
+ * browser shell is the only source of the editor runtime; no customer-provided
+ * integration is consulted. Falls back to the local stub only if the engine
+ * shell throws during construction (defensive, never selects v1).
+ *
+ * @returns {SuperDocV2Integration}
+ */
+export function createDefaultV2Integration(): SuperDocV2Integration;
+/**
+ * Backwards-compatible alias. The v2 branch no longer reads any customer
+ * config; the parameter is ignored and retained only so existing call sites do
+ * not need to change in lockstep with this internalization.
+ *
+ * @returns {SuperDocV2Integration}
+ */
+export function resolveV2Integration(): SuperDocV2Integration;
+/**
+ * @param {SuperDocV2Integration | null | undefined} integration
+ * @returns {boolean}
+ */
+export function hasRealV2Integration(integration: SuperDocV2Integration | null | undefined): boolean;
+/**
+ * @typedef {Object} SuperDocV2Integration
+ * @property {number} version Integration contract version.
+ * @property {unknown} [capabilities] Optional capability snapshot/hints.
+ * @property {unknown} EditorComponent Vue component that boots the V2 DOCX editor.
+ * @property {unknown} [RulerComponent] Optional Vue component for the V2 ruler.
+ * @property {(...args: unknown[]) => unknown} [createGeometryPublisher] Factory for the V2 geometry publisher.
+ * @property {(...args: unknown[]) => unknown} [createReviewHydrationController] Factory for the V2 review-row hydration controller.
+ * @property {(value: unknown) => boolean} [isSyntheticTrackedChangeCommentLaneItem] Predicate for synthetic tracked-change comment-lane items.
+ * @property {(value: unknown) => boolean} [isV2SyntheticTrackedChangeRow] Predicate for synthesized V2 tracked-change rows.
+ */
+/** Default version for the local stub integration (V1-compatible). */
+export const SUPERDOC_V2_INTEGRATION_VERSION: 1;
+export type SuperDocV2Integration = {
+    /**
+     * Integration contract version.
+     */
+    version: number;
+    /**
+     * Optional capability snapshot/hints.
+     */
+    capabilities?: unknown;
+    /**
+     * Vue component that boots the V2 DOCX editor.
+     */
+    EditorComponent: unknown;
+    /**
+     * Optional Vue component for the V2 ruler.
+     */
+    RulerComponent?: unknown;
+    /**
+     * Factory for the V2 geometry publisher.
+     */
+    createGeometryPublisher?: ((...args: unknown[]) => unknown) | undefined;
+    /**
+     * Factory for the V2 review-row hydration controller.
+     */
+    createReviewHydrationController?: ((...args: unknown[]) => unknown) | undefined;
+    /**
+     * Predicate for synthetic tracked-change comment-lane items.
+     */
+    isSyntheticTrackedChangeCommentLaneItem?: ((value: unknown) => boolean) | undefined;
+    /**
+     * Predicate for synthesized V2 tracked-change rows.
+     */
+    isV2SyntheticTrackedChangeRow?: ((value: unknown) => boolean) | undefined;
+};

package/dist/superdoc/src/core/whiteboard/Whiteboard.d.ts

@@ -0,0 +1,247 @@
+import { EventEmitter } from '../EventEmitter.js';
+import { WhiteboardPage } from './WhiteboardPage.js';
+/**
+ * @typedef {{ width: number, height: number, originalWidth?: number, originalHeight?: number }} WhiteboardPageSize
+ *
+ * The page-level serialized shape is the normalized one (matches what
+ * `WhiteboardPage.toJSON()` actually returns). SD-3213 follow-up:
+ * the previous `any[]` typing meant consumers reading
+ * `whiteboard.getWhiteboardData().pages[0].strokes` had no
+ * IntelliSense — and a wrong assumption that fields like `.points`
+ * or `.x` would be present (runtime gives `pointsN` / `xN`).
+ *
+ * @typedef {import('./WhiteboardPage.js').WhiteboardStoredPageData} WhiteboardPageData
+ *
+ * Per-page size snapshot recorded in `WhiteboardDataMeta.pageSizes`.
+ * `originalWidth` / `originalHeight` are `number | null` because
+ * `getWhiteboardData()` writes `page.originalSize?.width ?? null` when
+ * the original size is unknown.
+ *
+ * @typedef {{ width: number, height: number, originalWidth: number | null, originalHeight: number | null }} WhiteboardPageSizeSnapshot
+ *
+ * @typedef {{ pageSizes: Record<string, WhiteboardPageSizeSnapshot> }} WhiteboardDataMeta
+ *
+ * `WhiteboardData` is the **output** shape: what `getWhiteboardData()`
+ * returns and what the `change` event payload carries. All three
+ * fields are required because the runtime always populates them.
+ * Consumers reading the change payload can write
+ * `data.meta.pageSizes` without optional chaining.
+ *
+ * @typedef {{ pages: Record<string, WhiteboardPageData>, meta: WhiteboardDataMeta, version: 1 }} WhiteboardData
+ *
+ * `WhiteboardDataInput` is the **input** shape accepted by
+ * `setWhiteboardData(json)`. All fields are optional because the
+ * runtime only reads `json?.pages`; callers can pass
+ * `{ pages: {...} }` without supplying `meta` or `version`. A round
+ * trip works (`setWhiteboardData(getWhiteboardData())`) because
+ * `WhiteboardData` is structurally assignable to `WhiteboardDataInput`.
+ *
+ * @typedef {{ pages?: Record<string, WhiteboardPageData>, meta?: WhiteboardDataMeta, version?: number }} WhiteboardDataInput
+ *
+ * Registry items the host can attach for UI palettes (stickers,
+ * comments, etc.). The shape is intentionally extensible: `id` is the
+ * one field the runtime actually relies on (filter, dedup); everything
+ * else is consumer-typed via `unknown` so palettes for new domains
+ * don't need a contract change.
+ *
+ * @typedef {{ id?: string | number, [key: string]: unknown }} WhiteboardRegistryItem
+ *
+ * Event map for `whiteboard.on(name, fn)` / `whiteboard.emit(name, ...)`.
+ * Closed map (no DefaultEventMap fallback) because every event the
+ * runtime emits is enumerated here; an unknown event name should be a
+ * type error, not an `unknown[]` payload. SD-3213 follow-up to the
+ * EventEmitter `unknown[]` drain: that change only fixed the
+ * untyped-event fallback; without this map, listeners on Whiteboard
+ * still received `unknown[]` because no event was named.
+ *
+ * @typedef {{
+ *  tool: [string],
+ *  enabled: [boolean],
+ *  opacity: [number],
+ *  setData: [WhiteboardPage[]],
+ *  change: [WhiteboardData],
+ * }} WhiteboardEventMap
+ *
+ * @typedef {{
+ *  Renderer?: any,
+ *  superdoc?: any,
+ *  enabled?: boolean,
+ *  onChange?: (data: WhiteboardData) => void,
+ *  onSetData?: (pages: WhiteboardPage[]) => void,
+ *  onEnabledChange?: (enabled: boolean) => void,
+ * }} WhiteboardInit
+ */
+/**
+ * Whiteboard manager for multi-page annotations.
+ *
+ * @extends {EventEmitter<WhiteboardEventMap>}
+ */
+export class Whiteboard extends EventEmitter<WhiteboardEventMap> {
+    /**
+     * Initialize the whiteboard instance.
+     * @param {WhiteboardInit} [props]
+     */
+    constructor(props?: WhiteboardInit);
+    /**
+     * Register items for a UI palette type (e.g. stickers, comments).
+     * @param {string} type
+     * @param {WhiteboardRegistryItem[]} items
+     */
+    register(type: string, items: WhiteboardRegistryItem[]): void;
+    /**
+     * Get registered items by type.
+     * @param {string} type
+     * @returns {WhiteboardRegistryItem[] | undefined}
+     */
+    getType(type: string): WhiteboardRegistryItem[] | undefined;
+    /**
+     * Set current tool for all pages.
+     * @param {string} tool
+     */
+    setTool(tool: string): void;
+    /**
+     * Get current tool.
+     * @returns {string}
+     */
+    getTool(): string;
+    /**
+     * Enable/disable interactivity for all pages.
+     * @param {boolean} enabled
+     */
+    setEnabled(enabled: boolean): void;
+    /**
+     * @returns {boolean}
+     */
+    isEnabled(): boolean;
+    /**
+     * Set overlay opacity.
+     * @param {number} opacity
+     */
+    setOpacity(opacity: number): void;
+    /**
+     * @returns {number}
+     */
+    getOpacity(): number;
+    /**
+     * Return all page instances.
+     * @returns {WhiteboardPage[]}
+     */
+    getPages(): WhiteboardPage[];
+    /**
+     * Re-render all pages.
+     */
+    rerender(): void;
+    /**
+     * Set size for a page (creates page if missing).
+     * @param {number} pageIndex
+     * @param {WhiteboardPageSize} size
+     */
+    setPageSize(pageIndex: number, size: WhiteboardPageSize): void;
+    /**
+     * Get a page by index.
+     * @param {number} pageIndex
+     * @returns {WhiteboardPage}
+     */
+    getPage(pageIndex: number): WhiteboardPage;
+    /**
+     * Serialize whiteboard data.
+     * @returns {WhiteboardData}
+     */
+    getWhiteboardData(): WhiteboardData;
+    /**
+     * Load whiteboard data from JSON.
+     * @param {WhiteboardDataInput} json
+     */
+    setWhiteboardData(json: WhiteboardDataInput): void;
+    #private;
+}
+/**
+ * The page-level serialized shape is the normalized one (matches what
+ * `WhiteboardPage.toJSON()` actually returns). SD-3213 follow-up:
+ * the previous `any[]` typing meant consumers reading
+ * `whiteboard.getWhiteboardData().pages[0].strokes` had no
+ * IntelliSense — and a wrong assumption that fields like `.points`
+ * or `.x` would be present (runtime gives `pointsN` / `xN`).
+ */
+export type WhiteboardPageSize = {
+    width: number;
+    height: number;
+    originalWidth?: number;
+    originalHeight?: number;
+};
+/**
+ * Per-page size snapshot recorded in `WhiteboardDataMeta.pageSizes`.
+ * `originalWidth` / `originalHeight` are `number | null` because
+ * `getWhiteboardData()` writes `page.originalSize?.width ?? null` when
+ * the original size is unknown.
+ */
+export type WhiteboardPageData = import('./WhiteboardPage.js').WhiteboardStoredPageData;
+export type WhiteboardPageSizeSnapshot = {
+    width: number;
+    height: number;
+    originalWidth: number | null;
+    originalHeight: number | null;
+};
+/**
+ * `WhiteboardData` is the **output** shape: what `getWhiteboardData()`
+ * returns and what the `change` event payload carries. All three
+ * fields are required because the runtime always populates them.
+ * Consumers reading the change payload can write
+ * `data.meta.pageSizes` without optional chaining.
+ */
+export type WhiteboardDataMeta = {
+    pageSizes: Record<string, WhiteboardPageSizeSnapshot>;
+};
+/**
+ * `WhiteboardDataInput` is the **input** shape accepted by
+ * `setWhiteboardData(json)`. All fields are optional because the
+ * runtime only reads `json?.pages`; callers can pass
+ * `{ pages: {...} }` without supplying `meta` or `version`. A round
+ * trip works (`setWhiteboardData(getWhiteboardData())`) because
+ * `WhiteboardData` is structurally assignable to `WhiteboardDataInput`.
+ */
+export type WhiteboardData = {
+    pages: Record<string, WhiteboardPageData>;
+    meta: WhiteboardDataMeta;
+    version: 1;
+};
+/**
+ * Registry items the host can attach for UI palettes (stickers,
+ * comments, etc.). The shape is intentionally extensible: `id` is the
+ * one field the runtime actually relies on (filter, dedup); everything
+ * else is consumer-typed via `unknown` so palettes for new domains
+ * don't need a contract change.
+ */
+export type WhiteboardDataInput = {
+    pages?: Record<string, WhiteboardPageData>;
+    meta?: WhiteboardDataMeta;
+    version?: number;
+};
+/**
+ * Event map for `whiteboard.on(name, fn)` / `whiteboard.emit(name, ...)`.
+ * Closed map (no DefaultEventMap fallback) because every event the
+ * runtime emits is enumerated here; an unknown event name should be a
+ * type error, not an `unknown[]` payload. SD-3213 follow-up to the
+ * EventEmitter `unknown[]` drain: that change only fixed the
+ * untyped-event fallback; without this map, listeners on Whiteboard
+ * still received `unknown[]` because no event was named.
+ */
+export type WhiteboardRegistryItem = {
+    id?: string | number;
+    [key: string]: unknown;
+};
+export type WhiteboardEventMap = {
+    tool: [string];
+    enabled: [boolean];
+    opacity: [number];
+    setData: [WhiteboardPage[]];
+    change: [WhiteboardData];
+};
+export type WhiteboardInit = {
+    Renderer?: any;
+    superdoc?: any;
+    enabled?: boolean;
+    onChange?: (data: WhiteboardData) => void;
+    onSetData?: (pages: WhiteboardPage[]) => void;
+    onEnabledChange?: (enabled: boolean) => void;
+};

package/dist/superdoc/src/core/whiteboard/WhiteboardPage.d.ts

@@ -0,0 +1,251 @@
+/**
+ * @typedef {{ width: number, height: number, originalWidth?: number, originalHeight?: number }} WhiteboardPageSize
+ * @typedef {{ x: number, y: number }} Point
+ *
+ * Authored input shapes — what `addStroke`/`addText`/`addImage` accept
+ * from a consumer (pixel-space coordinates, optional ids). The
+ * add* methods normalize these into the stored shapes below.
+ *
+ * @typedef {{ points: number[][], color?: string, width?: number, type?: 'draw'|'erase' }} WhiteboardStroke
+ * @typedef {{ id?: string|number, x: number, y: number, content: string, fontSize?: number, width?: number }} WhiteboardTextItem
+ * @typedef {{ id?: string|number, stickerId?: string, x: number, y: number, src: string, width?: number, height?: number, type?: string }} WhiteboardImageItem
+ *
+ * Stored / normalized shapes — what the page actually holds in
+ * `this.strokes` / `this.text` / `this.images` and what gets
+ * serialized via `toJSON()` and re-applied via `applyData()`. Fields
+ * suffixed with `N` (pointsN, xN, yN, widthN, heightN, fontSizeN) are
+ * normalized to the page's 0..1 coordinate space; raw `width`/`height`
+ * pairs are kept where consumers expect pixel sizes.
+ *
+ * SD-3213 follow-up: the public types were previously `any[]` for the
+ * fields and the toJSON / applyData signatures; consumers reading
+ * `page.strokes[0].points` would have hit pointsN at runtime with no
+ * IntelliSense. The named shapes below restore typing without
+ * over-committing the authored shapes (which the add* methods
+ * normalize away).
+ *
+ * @typedef {{ pointsN: number[][], widthN?: number, color?: string, type?: 'draw'|'erase' }} WhiteboardStoredStroke
+ * @typedef {{ id: string|number, xN: number, yN: number, content: string, fontSizeN?: number, widthN?: number | null }} WhiteboardStoredTextItem
+ * @typedef {{ id: string|number, stickerId?: string | number | null, xN: number, yN: number, src: string, widthN?: number | null, heightN?: number | null, type?: string }} WhiteboardStoredImageItem
+ *
+ * @typedef {{
+ *  strokes?: WhiteboardStoredStroke[],
+ *  text?: WhiteboardStoredTextItem[],
+ *  images?: WhiteboardStoredImageItem[],
+ * }} WhiteboardStoredPageData
+ *
+ * @typedef {{
+ *  pageIndex: number,
+ *  enabled: boolean,
+ *  Renderer: any,
+ *  onChange?: () => void,
+ *  onToolChange?: (tool: string) => void,
+ * }} WhiteboardPageInit
+ */
+/**
+ * Per-page whiteboard renderer/controller.
+ */
+export class WhiteboardPage {
+    /**
+     * Create a page controller.
+     * @param {WhiteboardPageInit} props
+     */
+    constructor(props: WhiteboardPageInit);
+    /** @type {number|null} */
+    pageIndex: number | null;
+    /** @type {WhiteboardStoredStroke[]} */
+    strokes: WhiteboardStoredStroke[];
+    /** @type {WhiteboardStoredTextItem[]} */
+    text: WhiteboardStoredTextItem[];
+    /** @type {WhiteboardStoredImageItem[]} */
+    images: WhiteboardStoredImageItem[];
+    /** @type {WhiteboardPageSize|null} */
+    size: WhiteboardPageSize | null;
+    /** @type {{ width: number|null, height: number|null }|null} */
+    originalSize: {
+        width: number | null;
+        height: number | null;
+    } | null;
+    /**
+     * Set tool for this page.
+     * @param {string} tool
+     */
+    setTool(tool: string): void;
+    /**
+     * Get current tool for this page.
+     * @returns {string}
+     */
+    getTool(): string;
+    /**
+     * Enable/disable interactivity for this page.
+     * @param {boolean} enabled
+     */
+    setEnabled(enabled: boolean): void;
+    /**
+     * @returns {boolean}
+     */
+    isEnabled(): boolean;
+    /**
+     * Store page size (does not resize canvas).
+     * @param {WhiteboardPageSize} size
+     */
+    setSize(size: WhiteboardPageSize): void;
+    /**
+     * Resize the Konva stage.
+     * @param {number} width
+     * @param {number} height
+     */
+    resize(width: number, height: number): void;
+    /**
+     * Mount Konva stage into a container.
+     * @param {HTMLElement} container
+     */
+    mount(container: HTMLElement): void;
+    /**
+     * Re-render all content for this page.
+     */
+    render(): void;
+    /**
+     * Render stroke paths.
+     */
+    renderStrokes(): void;
+    /**
+     * Render text nodes.
+     */
+    renderText(): void;
+    /**
+     * Render image/sticker nodes.
+     * NOTE: Images are reconciled by id to avoid re-creating nodes (prevents flicker).
+     * If src changes for an existing id, this path does not reload the image.
+     */
+    renderImages(): void;
+    /**
+     * Destroy Konva stage and clean up listeners.
+     */
+    destroy(): void;
+    /**
+     * Serialize page data.
+     * Returns the page's serializable shape. SD-3213 follow-up: fixed
+     * stale JSDoc that said `stickers` (which never existed on the
+     * runtime return) and typed the values as the stored normalized
+     * shapes instead of `any[]`.
+     *
+     * @returns {{ strokes: WhiteboardStoredStroke[], text: WhiteboardStoredTextItem[], images: WhiteboardStoredImageItem[] }}
+     */
+    toJSON(): {
+        strokes: WhiteboardStoredStroke[];
+        text: WhiteboardStoredTextItem[];
+        images: WhiteboardStoredImageItem[];
+    };
+    /**
+     * Apply data to this page and re-render.
+     * @param {WhiteboardStoredPageData} data
+     */
+    applyData(data?: WhiteboardStoredPageData): void;
+    /**
+     * Add a stroke to the model.
+     * @param {WhiteboardStroke} stroke
+     */
+    addStroke(stroke: WhiteboardStroke): void;
+    /**
+     * Add a text item to the model.
+     * @param {WhiteboardTextItem} item
+     */
+    addText(item: WhiteboardTextItem): void;
+    /**
+     * Add an image/sticker to the model.
+     * @param {WhiteboardImageItem} item
+     */
+    addImage(item: WhiteboardImageItem): void;
+    #private;
+}
+export type WhiteboardPageSize = {
+    width: number;
+    height: number;
+    originalWidth?: number;
+    originalHeight?: number;
+};
+/**
+ * Authored input shapes — what `addStroke`/`addText`/`addImage` accept
+ * from a consumer (pixel-space coordinates, optional ids). The
+ * add* methods normalize these into the stored shapes below.
+ */
+export type Point = {
+    x: number;
+    y: number;
+};
+export type WhiteboardStroke = {
+    points: number[][];
+    color?: string;
+    width?: number;
+    type?: "draw" | "erase";
+};
+export type WhiteboardTextItem = {
+    id?: string | number;
+    x: number;
+    y: number;
+    content: string;
+    fontSize?: number;
+    width?: number;
+};
+/**
+ * Stored / normalized shapes — what the page actually holds in
+ * `this.strokes` / `this.text` / `this.images` and what gets
+ * serialized via `toJSON()` and re-applied via `applyData()`. Fields
+ * suffixed with `N` (pointsN, xN, yN, widthN, heightN, fontSizeN) are
+ * normalized to the page's 0..1 coordinate space; raw `width`/`height`
+ * pairs are kept where consumers expect pixel sizes.
+ *
+ * SD-3213 follow-up: the public types were previously `any[]` for the
+ * fields and the toJSON / applyData signatures; consumers reading
+ * `page.strokes[0].points` would have hit pointsN at runtime with no
+ * IntelliSense. The named shapes below restore typing without
+ * over-committing the authored shapes (which the add* methods
+ * normalize away).
+ */
+export type WhiteboardImageItem = {
+    id?: string | number;
+    stickerId?: string;
+    x: number;
+    y: number;
+    src: string;
+    width?: number;
+    height?: number;
+    type?: string;
+};
+export type WhiteboardStoredStroke = {
+    pointsN: number[][];
+    widthN?: number;
+    color?: string;
+    type?: "draw" | "erase";
+};
+export type WhiteboardStoredTextItem = {
+    id: string | number;
+    xN: number;
+    yN: number;
+    content: string;
+    fontSizeN?: number;
+    widthN?: number | null;
+};
+export type WhiteboardStoredImageItem = {
+    id: string | number;
+    stickerId?: string | number | null;
+    xN: number;
+    yN: number;
+    src: string;
+    widthN?: number | null;
+    heightN?: number | null;
+    type?: string;
+};
+export type WhiteboardStoredPageData = {
+    strokes?: WhiteboardStoredStroke[];
+    text?: WhiteboardStoredTextItem[];
+    images?: WhiteboardStoredImageItem[];
+};
+export type WhiteboardPageInit = {
+    pageIndex: number;
+    enabled: boolean;
+    Renderer: any;
+    onChange?: () => void;
+    onToolChange?: (tool: string) => void;
+};

package/dist/superdoc/src/core/whiteboard/WhiteboardRenderer.d.ts

@@ -0,0 +1,2 @@
+import { default as Konva } from 'konva';
+export { Konva as WhiteboardRenderer };

package/dist/superdoc/src/core/whiteboard/helpers/createTextarea.d.ts

@@ -0,0 +1 @@
+export function createTextarea(options?: {}): HTMLTextAreaElement;

package/dist/superdoc/src/core/whiteboard/helpers/flattenPoints.d.ts

@@ -0,0 +1 @@
+export function flattenPoints(points: any): any;

package/dist/superdoc/src/core/whiteboard/helpers/getRandomId.d.ts

@@ -0,0 +1 @@
+export function getRandomId(prefix?: string): string;

package/dist/superdoc/src/helpers/collect-touched-tracked-change-ids.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Collect tracked-change mark IDs from ranges touched by an editor transaction.
+ *
+ * @param {import('../core/types/index.js').EditorTransactionLike} transaction
+ * @param {object} [options]
+ * @param {object|null} [options.trackChangesPluginKey] - The TrackChangesBasePluginKey to read metadata from
+ * @returns {Set<string>} Set of tracked-change mark IDs
+ */
+export function collectTouchedTrackedChangeIds(transaction: import('../core/types/index.js').EditorTransactionLike, { trackChangesPluginKey }?: {
+    trackChangesPluginKey?: object | null | undefined;
+}): Set<string>;

package/dist/superdoc/src/helpers/comment-focus.d.ts

@@ -0,0 +1,4 @@
+export function getPreferredCommentFocusTargetClientY(): number;
+export function getVisibleThreadAnchorClientY(layersElement: any, positionEntry: any): any;
+export function getVisibleThreadHighlightClientY(threadIds: any): any;
+export function scrollThreadAnchorToFocusTarget(presentation: any, primaryThreadId: any, fallbackThreadId: any, targetClientY: any): any;

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

@@ -0,0 +1,14 @@
+/**
+ * Normalize adaptive comments UI policy fields.
+ *
+ * @param {false | Record<string, unknown> | undefined} commentsConfig
+ * @returns {false | Record<string, unknown> | undefined}
+ */
+export function normalizeCommentsUiPolicy(commentsConfig: false | Record<string, unknown> | undefined): false | Record<string, unknown> | undefined;
+export const COMPACT_ANCHOR_SELECTOR: "[data-track-change-id], .superdoc-comment-highlight, .sd-comment-anchor";
+export const DEFAULT_COMMENTS_SIDEBAR_LANE_PX: 320;
+export const DEFAULT_COMMENTS_MIN_GUTTER_PX: 24;
+export const DEFAULT_DOCUMENT_VISIBLE_MIN_WIDTH_PX: 816;
+export const RIGHT_CLICK_COMMENT_SUPPRESS_MS: 250;
+export const DEFAULT_COMMENTS_DISPLAY_MODE: "sidebar";
+export const VALID_COMMENTS_DISPLAY_MODES: Set<string>;