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

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

@@ -1,230 +1,26 @@
 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,
- *  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;
+import { WhiteboardPage, WhiteboardPageRenderer, WhiteboardPageSize, WhiteboardStoredPageData } from './WhiteboardPage.js';
+export type { WhiteboardPageSize };
+export type WhiteboardPageData = 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;
@@ -237,9 +33,27 @@ export type WhiteboardEventMap = {
     change: [WhiteboardData];
 };
 export type WhiteboardInit = {
-    Renderer?: any;
+    Renderer?: WhiteboardPageRenderer;
     enabled?: boolean;
     onChange?: (data: WhiteboardData) => void;
     onSetData?: (pages: WhiteboardPage[]) => void;
     onEnabledChange?: (enabled: boolean) => void;
 };
+export declare class Whiteboard extends EventEmitter<WhiteboardEventMap> {
+    #private;
+    constructor(props?: WhiteboardInit);
+    register(type: string, items: WhiteboardRegistryItem[]): void;
+    getType(type: string): WhiteboardRegistryItem[] | undefined;
+    setTool(tool: string): void;
+    getTool(): string;
+    setEnabled(enabled: boolean): void;
+    isEnabled(): boolean;
+    setOpacity(opacity: number): void;
+    getOpacity(): number;
+    getPages(): WhiteboardPage[];
+    rerender(): void;
+    setPageSize(pageIndex: number, size: WhiteboardPageSize): void;
+    getPage(pageIndex: number): WhiteboardPage | undefined;
+    getWhiteboardData(): WhiteboardData;
+    setWhiteboardData(json: WhiteboardDataInput): void;
+}

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

@@ -1,210 +1,31 @@
-/**
- * @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 WhiteboardItemId = string | number;
+export type WhiteboardStrokeType = 'draw' | 'erase';
 export type WhiteboardStroke = {
     points: number[][];
     color?: string;
     width?: number;
-    type?: "draw" | "erase";
+    type?: WhiteboardStrokeType;
 };
 export type WhiteboardTextItem = {
-    id?: string | number;
+    id?: WhiteboardItemId;
     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;
+    id?: WhiteboardItemId;
     stickerId?: string;
     x: number;
     y: number;
@@ -217,10 +38,10 @@ export type WhiteboardStoredStroke = {
     pointsN: number[][];
     widthN?: number;
     color?: string;
-    type?: "draw" | "erase";
+    type?: WhiteboardStrokeType;
 };
 export type WhiteboardStoredTextItem = {
-    id: string | number;
+    id: WhiteboardItemId;
     xN: number;
     yN: number;
     content: string;
@@ -228,8 +49,8 @@ export type WhiteboardStoredTextItem = {
     widthN?: number | null;
 };
 export type WhiteboardStoredImageItem = {
-    id: string | number;
-    stickerId?: string | number | null;
+    id: WhiteboardItemId;
+    stickerId?: WhiteboardItemId | null;
     xN: number;
     yN: number;
     src: string;
@@ -242,10 +63,163 @@ export type WhiteboardStoredPageData = {
     text?: WhiteboardStoredTextItem[];
     images?: WhiteboardStoredImageItem[];
 };
+export type WhiteboardSerializedPage = {
+    strokes: WhiteboardStoredStroke[];
+    text: WhiteboardStoredTextItem[];
+    images: WhiteboardStoredImageItem[];
+};
+export type WhiteboardRendererEvent = {
+    target?: unknown;
+    cancelBubble?: boolean;
+};
+export interface WhiteboardRendererNode {
+    _whiteboardId?: WhiteboardItemId;
+    on(events: string, handler: (event: WhiteboardRendererEvent) => void): unknown;
+    destroy(): unknown;
+    name(): string;
+    name(name: string): unknown;
+}
+export interface WhiteboardShapeNode extends WhiteboardRendererNode {
+    x(): number;
+    x(value: number): unknown;
+    y(): number;
+    y(value: number): unknown;
+    width(): number;
+    width(value: number): unknown;
+    height(): number;
+    height(value: number): unknown;
+    scaleX(): number;
+    scaleY(): number;
+    scale(scale: Point): unknown;
+    draggable(value: boolean): unknown;
+    position(): Point;
+}
+export interface WhiteboardTextNode extends WhiteboardShapeNode {
+    scaleY(): number;
+    scaleY(value: number): unknown;
+    setAttrs(attrs: {
+        width: number;
+        scaleX: number;
+        scaleY?: number;
+    }): unknown;
+    text(): string;
+    text(value: string): unknown;
+    fontSize(): number;
+    fontFamily(): string;
+    fill(): string | CanvasGradient;
+}
+export interface WhiteboardLineNode extends WhiteboardRendererNode {
+    points(points: number[]): unknown;
+}
+export type WhiteboardBox = {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    rotation: number;
+};
+export type WhiteboardBoundBoxFunc = (oldBox: WhiteboardBox, newBox: WhiteboardBox) => WhiteboardBox;
+export interface WhiteboardTransformerNode {
+    destroy(): unknown;
+    nodes(nodes: WhiteboardShapeNode[]): unknown;
+    enabledAnchors(anchors: string[]): unknown;
+    boundBoxFunc(fn: WhiteboardBoundBoxFunc): unknown;
+}
+export interface WhiteboardLayerNode {
+    add(child: WhiteboardRendererNode | WhiteboardTransformerNode): unknown;
+    find(selector: string): WhiteboardShapeNode[];
+    destroyChildren(): unknown;
+    batchDraw(): unknown;
+    listening(listening: boolean): unknown;
+    getCanvas(): {
+        setPixelRatio(ratio: number): unknown;
+    };
+}
+export interface WhiteboardStageNode {
+    on(events: string, handler: (event: WhiteboardRendererEvent) => void): unknown;
+    add(layer: WhiteboardLayerNode): unknown;
+    size(size: {
+        width: number;
+        height: number;
+    }): unknown;
+    getPointerPosition(): Point | null;
+    destroy(): unknown;
+}
+export type WhiteboardLineConfig = {
+    points: number[];
+    stroke: string;
+    strokeWidth: number;
+    lineCap: 'round';
+    lineJoin: 'round';
+    globalCompositeOperation: 'destination-out' | 'source-over';
+};
+export interface WhiteboardPageRenderer {
+    Stage: new (config: {
+        container: HTMLDivElement;
+        width: number;
+        height: number;
+    }) => WhiteboardStageNode;
+    Layer: new () => WhiteboardLayerNode;
+    Line: new (config: WhiteboardLineConfig) => WhiteboardLineNode;
+    Text: new (config: {
+        x: number;
+        y: number;
+        text: string;
+        fontSize: number;
+        fontFamily: string;
+        fill: string;
+        draggable: boolean;
+        width: number | undefined;
+    }) => WhiteboardTextNode;
+    Image: new (config: {
+        x: number;
+        y: number;
+        image: HTMLImageElement;
+        width: number;
+        height: number;
+        draggable: boolean;
+    }) => WhiteboardShapeNode;
+    Transformer: new (config: {
+        enabledAnchors: string[];
+        rotateEnabled: boolean;
+        keepRatio: boolean;
+        boundBoxFunc: WhiteboardBoundBoxFunc;
+    }) => WhiteboardTransformerNode;
+}
 export type WhiteboardPageInit = {
     pageIndex: number;
     enabled: boolean;
-    Renderer: any;
+    Renderer?: WhiteboardPageRenderer;
     onChange?: () => void;
     onToolChange?: (tool: string) => void;
 };
+export declare class WhiteboardPage {
+    #private;
+    pageIndex: number;
+    strokes: WhiteboardStoredStroke[];
+    text: WhiteboardStoredTextItem[];
+    images: WhiteboardStoredImageItem[];
+    size: WhiteboardPageSize | null;
+    originalSize: {
+        width: number | null;
+        height: number | null;
+    } | null;
+    constructor(props: WhiteboardPageInit);
+    setTool(tool: string): void;
+    getTool(): string;
+    setEnabled(enabled: boolean): void;
+    isEnabled(): boolean;
+    setSize(size: WhiteboardPageSize): void;
+    resize(width: number, height: number): void;
+    mount(container: HTMLDivElement): void;
+    render(): void;
+    renderStrokes(): void;
+    renderText(): void;
+    renderImages(): void;
+    destroy(): void;
+    toJSON(): WhiteboardSerializedPage;
+    applyData(data?: WhiteboardStoredPageData): void;
+    addStroke(stroke: WhiteboardStroke): void;
+    addText(item: WhiteboardTextItem): void;
+    addImage(item: WhiteboardImageItem): void;
+}

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

@@ -1 +1,14 @@
-export function createTextarea(options?: {}): HTMLTextAreaElement;
+export type TextareaSize = number | string;
+export interface TextareaOptions {
+    value?: string;
+    left?: number;
+    top?: number;
+    width?: TextareaSize;
+    height?: TextareaSize;
+    fontSize?: TextareaSize;
+    fontFamily?: string;
+    color?: string;
+    background?: string;
+    resize?: string;
+}
+export declare function createTextarea(options?: TextareaOptions): HTMLTextAreaElement;

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

@@ -1 +1 @@
-export function flattenPoints(points: any): any;
+export declare function flattenPoints(points: readonly (readonly number[])[]): number[];

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

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