@q9labsai/chalk-whiteboard 4.0.0

package/dist/embedded/manifest.d.ts

@@ -0,0 +1,40 @@
+export declare const chalkEmbeddedWhiteboardManifest: Readonly<{
+    readonly rendererBuildId: "chalk-excalidraw-0.18.1-r1";
+    readonly bridge: Readonly<{
+        current: 1;
+        minimum: number;
+        maximum: number;
+        priorCompatible: never[];
+    }>;
+    readonly excalidraw: Readonly<{
+        version: "0.18.1";
+        package: string;
+        restoreImplementation: string;
+    }>;
+    readonly entrypoint: "chalk-whiteboard/index.html";
+    readonly bundledAssets: readonly string[];
+    readonly schemaVersion: number;
+    readonly document: {
+        format: string;
+        supportedElementTypes: string[];
+        supportedSharedAppStateFields: string[];
+        preserveUnknownOptionalElementFields: boolean;
+        unknownRequiredFeaturePolicy: string;
+    };
+    readonly assets: {
+        fonts: string[];
+        math: string;
+        runtimeContentDelivery: boolean;
+    };
+    readonly clientSkew: {
+        rendererBuildMustMatch: boolean;
+        initialBridgeHasNoPriorRelease: boolean;
+        newerRequiredFeaturesOpenReadOnly: boolean;
+    };
+    readonly security: {
+        networkPolicy: string;
+        rendererReceivesCredentials: boolean;
+        rendererReceivesSignedURLs: boolean;
+    };
+}>;
+export declare const chalkEmbeddedWhiteboardSupportedElementTypes: ReadonlySet<string>;

package/dist/embedded/protocol.d.ts

@@ -0,0 +1,211 @@
+import type { WhiteboardCommit, WhiteboardWireElement } from "../collab/wire.js";
+export declare const CHALK_EMBEDDED_WHITEBOARD_BRIDGE_VERSION: 1;
+export declare const CHALK_EMBEDDED_WHITEBOARD_EXCALIDRAW_VERSION: "0.18.1";
+export declare const CHALK_EMBEDDED_WHITEBOARD_RENDERER_BUILD_ID: "chalk-excalidraw-0.18.1-r1";
+export declare const CHALK_EMBEDDED_WHITEBOARD_MAX_MESSAGE_BYTES: number;
+export type ChalkEmbeddedWhiteboardTheme = "light" | "dark";
+export type ChalkEmbeddedWhiteboardViewport = {
+    readonly width: number;
+    readonly height: number;
+    readonly scale: number;
+};
+export type ChalkEmbeddedWhiteboardOperationResult = {
+    readonly requestId: string;
+    readonly ok: true;
+    readonly result?: unknown;
+} | {
+    readonly requestId: string;
+    readonly ok: false;
+    readonly error: {
+        readonly code: string;
+        readonly message: string;
+        readonly recoverable: boolean;
+    };
+};
+export type ChalkEmbeddedWhiteboardHostMessage = {
+    readonly type: "initialize";
+    readonly payload: {
+        readonly canDraw: boolean;
+        readonly canClear: boolean;
+        readonly theme: ChalkEmbeddedWhiteboardTheme;
+        readonly localParticipantColor?: string;
+    };
+} | {
+    readonly type: "apply_snapshot";
+    readonly payload: {
+        readonly sceneId: string;
+        readonly revision: string;
+        readonly sceneGeneration: string;
+        readonly elements: readonly WhiteboardWireElement[];
+        readonly appState?: {
+            readonly viewBackgroundColor?: string;
+        };
+    };
+} | {
+    readonly type: "apply_update";
+    readonly payload: {
+        readonly sceneId: string;
+        readonly revision: string;
+        readonly sceneGeneration: string;
+        readonly elements: readonly WhiteboardWireElement[];
+    };
+} | {
+    readonly type: "apply_cursor";
+    readonly payload: {
+        readonly participantId: string;
+        readonly displayName: string;
+        readonly x: number;
+        readonly y: number;
+        readonly occurredAt: string;
+    };
+} | {
+    readonly type: "reset_required";
+    readonly payload: {
+        readonly sceneId: string;
+        readonly reason: "scene_changed" | "cursor_expired" | "gap";
+    };
+} | {
+    readonly type: "set_capabilities";
+    readonly payload: {
+        readonly canDraw: boolean;
+        readonly canClear: boolean;
+    };
+} | {
+    readonly type: "set_viewport";
+    readonly payload: ChalkEmbeddedWhiteboardViewport;
+} | {
+    readonly type: "operation_result";
+    readonly payload: ChalkEmbeddedWhiteboardOperationResult;
+} | {
+    readonly type: "provide_file_bytes";
+    readonly payload: {
+        readonly requestId: string;
+        readonly fileId: string;
+        readonly mimeType: string;
+        readonly dataURL: string;
+    };
+} | {
+    readonly type: "request_user_export";
+    readonly payload: {
+        readonly requestId: string;
+        readonly format: "png" | "svg";
+    };
+} | {
+    readonly type: "prepare_close";
+    readonly payload: {
+        readonly reason: string;
+    };
+};
+export type ChalkEmbeddedWhiteboardRendererMessage = {
+    readonly type: "ready";
+    readonly payload: {
+        readonly excalidrawVersion: typeof CHALK_EMBEDDED_WHITEBOARD_EXCALIDRAW_VERSION;
+        readonly supportedBridgeVersions: readonly [typeof CHALK_EMBEDDED_WHITEBOARD_BRIDGE_VERSION];
+    };
+} | {
+    readonly type: "local_update";
+    readonly payload: {
+        readonly requestId: string;
+        readonly sceneId: string;
+        readonly sceneGeneration: string;
+        readonly syncAll: boolean;
+        readonly elements: readonly WhiteboardWireElement[];
+    };
+} | {
+    readonly type: "cursor";
+    readonly payload: {
+        readonly x: number;
+        readonly y: number;
+    };
+} | {
+    readonly type: "camera";
+    readonly payload: {
+        readonly scrollX: number;
+        readonly scrollY: number;
+        readonly zoom: number;
+    };
+} | {
+    readonly type: "request_snapshot";
+    readonly payload: {
+        readonly requestId: string;
+    };
+} | {
+    readonly type: "clear";
+    readonly payload: {
+        readonly requestId: string;
+    };
+} | {
+    readonly type: "file_read";
+    readonly payload: {
+        readonly requestId: string;
+        readonly fileId: string;
+    };
+} | {
+    readonly type: "file_write";
+    readonly payload: {
+        readonly requestId: string;
+        readonly fileId: string;
+        readonly mimeType: string;
+        readonly byteLength: number;
+        readonly sha256: string;
+        readonly dataURL: string;
+    };
+} | {
+    readonly type: "user_export";
+    readonly payload: {
+        readonly requestId: string;
+        readonly format: "png" | "svg";
+        readonly mimeType: string;
+        readonly dataURL: string;
+    };
+} | {
+    readonly type: "metric";
+    readonly payload: {
+        readonly name: string;
+        readonly value: number;
+        readonly attributes?: Readonly<Record<string, string | number | boolean>>;
+    };
+} | {
+    readonly type: "error";
+    readonly payload: {
+        readonly code: string;
+        readonly message: string;
+        readonly recoverable: boolean;
+    };
+} | {
+    readonly type: "close_ready";
+    readonly payload: {
+        readonly reason: string;
+    };
+};
+export type ChalkEmbeddedWhiteboardBridgeEnvelope<Message extends {
+    readonly type: string;
+    readonly payload: unknown;
+}> = Message extends unknown ? {
+    readonly bridgeVersion: typeof CHALK_EMBEDDED_WHITEBOARD_BRIDGE_VERSION;
+    readonly rendererBuildId: typeof CHALK_EMBEDDED_WHITEBOARD_RENDERER_BUILD_ID;
+    readonly rendererGeneration: string;
+    readonly messageId: string;
+    readonly payloadBytes: number;
+    readonly journeyId: string;
+    readonly traceparent?: string;
+    readonly tracestate?: string;
+    readonly type: Message["type"];
+    readonly payload: Message["payload"];
+} : never;
+export type ChalkEmbeddedWhiteboardHostEnvelope = ChalkEmbeddedWhiteboardBridgeEnvelope<ChalkEmbeddedWhiteboardHostMessage>;
+export type ChalkEmbeddedWhiteboardRendererEnvelope = ChalkEmbeddedWhiteboardBridgeEnvelope<ChalkEmbeddedWhiteboardRendererMessage>;
+export interface ChalkEmbeddedWhiteboardMessageContext {
+    readonly rendererGeneration: string;
+    readonly journeyId: string;
+    readonly traceparent?: string;
+    readonly tracestate?: string;
+    readonly nextMessageId: () => string;
+}
+export declare function encodeEmbeddedWhiteboardMessage<Message extends {
+    readonly type: string;
+    readonly payload: unknown;
+}>(message: Message, context: ChalkEmbeddedWhiteboardMessageContext): string;
+export declare function decodeEmbeddedWhiteboardHostMessage(value: string, expectedGeneration?: string): ChalkEmbeddedWhiteboardHostEnvelope;
+export declare function decodeEmbeddedWhiteboardRendererMessage(value: string, expectedGeneration?: string): ChalkEmbeddedWhiteboardRendererEnvelope;
+export type ChalkEmbeddedWhiteboardCommit = WhiteboardCommit;

package/dist/embedded/renderer-bridge.d.ts

@@ -0,0 +1,37 @@
+import type { WhiteboardCommit } from "../collab/wire.js";
+import { type ChalkEmbeddedWhiteboardHostEnvelope, type ChalkEmbeddedWhiteboardRendererMessage } from "./protocol.js";
+declare global {
+    interface Window {
+        ReactNativeWebView?: {
+            postMessage: (message: string) => void;
+        };
+    }
+}
+type HostListener = (message: ChalkEmbeddedWhiteboardHostEnvelope) => void;
+export declare class ChalkEmbeddedWhiteboardRendererBridge {
+    #private;
+    start(): void;
+    dispose(): void;
+    subscribe(listener: HostListener): () => void;
+    post(message: ChalkEmbeddedWhiteboardRendererMessage): void;
+    submitUpdate(input: {
+        readonly sceneId: string;
+        readonly sceneGeneration?: string;
+        readonly syncAll: boolean;
+        readonly elements: readonly import("../collab/wire").WhiteboardWireElement[];
+    }): Promise<WhiteboardCommit>;
+    requestSnapshot(): Promise<void>;
+    clear(): Promise<WhiteboardCommit>;
+    uploadFile(input: {
+        readonly fileId: string;
+        readonly mimeType: string;
+        readonly byteLength: number;
+        readonly sha256: string;
+        readonly dataURL: string;
+    }): Promise<void>;
+    downloadFile(fileId: string): Promise<{
+        readonly mimeType: string;
+        readonly dataURL: string;
+    }>;
+}
+export {};

package/dist/embedded/renderer.d.ts

@@ -0,0 +1,25 @@
+import type { WhiteboardCollaborationEvent } from "../collab/engine.js";
+import { ChalkEmbeddedWhiteboardRendererBridge } from "./renderer-bridge.js";
+declare global {
+    interface Window {
+        EXCALIDRAW_ASSET_PATH?: string;
+    }
+}
+export declare function createCollaborationBridge(rendererBridge: ChalkEmbeddedWhiteboardRendererBridge): {
+    submitUpdate: (payload: Parameters<ChalkEmbeddedWhiteboardRendererBridge["submitUpdate"]>[0]) => Promise<import("..").WhiteboardCommit>;
+    sendCursor: ({ x, y }: {
+        readonly x: number;
+        readonly y: number;
+    }) => void;
+    requestSnapshot: () => Promise<void>;
+    clear: () => Promise<import("..").WhiteboardCommit>;
+    fileTransfer: {
+        upload: (input: Parameters<ChalkEmbeddedWhiteboardRendererBridge["uploadFile"]>[0]) => Promise<void>;
+        download: (fileId: string) => Promise<{
+            readonly mimeType: string;
+            readonly dataURL: string;
+        }>;
+    };
+    subscribe: (listener: (event: WhiteboardCollaborationEvent) => void) => () => boolean;
+    onSubmissionError: (cause: unknown) => void;
+};

package/dist/engine-UMQR3O33.js

@@ -0,0 +1,6 @@
+import {
+  ExcalidrawCollabEngine
+} from "./chunk-FLUO6BVL.js";
+export {
+  ExcalidrawCollabEngine
+};

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export type { AppState, BinaryFileData, BinaryFiles, Collaborator, CollaboratorPointer, ExcalidrawElement, ExcalidrawImperativeAPI, OrderedExcalidrawElement } from "./collab/index.js";
+export { fromWireElement, isWireElement, mergeWhiteboardElements, toWireElement } from "./collab/index.js";
+export type { WhiteboardCollaborationEvent, WhiteboardCommit, WhiteboardFileTransfer, WhiteboardJsonValue, WhiteboardUploadInstructions, WhiteboardWireElement } from "./collab/index.js";

package/dist/index.js

@@ -0,0 +1,14 @@
+import {
+  mergeWhiteboardElements
+} from "./chunk-4XG2ABSP.js";
+import {
+  fromWireElement,
+  isWireElement,
+  toWireElement
+} from "./chunk-FLUO6BVL.js";
+export {
+  fromWireElement,
+  isWireElement,
+  mergeWhiteboardElements,
+  toWireElement
+};

package/dist/react/MathEditor.d.ts

@@ -0,0 +1,17 @@
+import { type ReactNode } from "react";
+import type { WhiteboardCanvasClassNames } from "./WhiteboardCanvas.js";
+export interface MathEditorIcons {
+    close?: ReactNode;
+    submit?: ReactNode;
+    submitting?: ReactNode;
+}
+interface MathEditorProps {
+    initialLatex: string;
+    isEditing: boolean;
+    classNames: WhiteboardCanvasClassNames;
+    icons: MathEditorIcons;
+    onClose: () => void;
+    onSubmit: (latex: string) => Promise<void>;
+}
+export declare function MathEditor({ initialLatex, isEditing, classNames, icons, onClose, onSubmit }: MathEditorProps): React.JSX.Element;
+export {};

package/dist/react/WhiteboardCanvas.d.ts

@@ -0,0 +1,47 @@
+import { type ReactNode } from "react";
+import type { ExcalidrawImperativeAPI } from "@excalidraw/excalidraw/types";
+import type { ExcalidrawCollabEngineOptions } from "../collab/engine.js";
+export interface WhiteboardCollaborationOptions extends Omit<ExcalidrawCollabEngineOptions, "excalidrawAPI" | "canDraw"> {
+    canDraw?: boolean;
+}
+export interface WhiteboardCanvasClassNames {
+    root: string;
+    toolbar: string;
+    toolbarButton: string;
+    loading: string;
+    loadingContent: string;
+    error: string;
+    mathOverlay: string;
+    mathDialog: string;
+    mathHeader: string;
+    mathTitle: string;
+    mathCloseButton: string;
+    mathBody: string;
+    mathTextarea: string;
+    mathError: string;
+    mathActions: string;
+    mathCancelButton: string;
+    mathSubmitButton: string;
+}
+export interface WhiteboardCanvasIcons {
+    close?: ReactNode;
+    loading?: ReactNode;
+    submit?: ReactNode;
+    submitting?: ReactNode;
+}
+export interface WhiteboardCanvasProps {
+    className?: string;
+    isVisible?: boolean;
+    canDraw?: boolean;
+    theme?: "light" | "dark";
+    excalidrawCssPath?: string;
+    localParticipantColor?: string;
+    collab?: WhiteboardCollaborationOptions;
+    classNames?: Partial<WhiteboardCanvasClassNames>;
+    icons?: WhiteboardCanvasIcons;
+    onExcalidrawApiReady?: (api: ExcalidrawImperativeAPI) => void;
+    onLoadError?: (error: Error) => void;
+}
+declare function WhiteboardCanvasBase(props: WhiteboardCanvasProps): React.JSX.Element;
+export declare const WhiteboardCanvas: import("react").MemoExoticComponent<typeof WhiteboardCanvasBase>;
+export {};

package/dist/react/index.d.ts

@@ -0,0 +1,7 @@
+export { WhiteboardCanvas } from "./WhiteboardCanvas.js";
+export type { WhiteboardCanvasClassNames, WhiteboardCanvasIcons, WhiteboardCanvasProps, WhiteboardCollaborationOptions } from "./WhiteboardCanvas.js";
+export { appendOrReplaceMathElement, CHALK_MATH_CUSTOM_DATA_KEY, CHALK_MATH_RENDERER, createMathFileId, createMathImageAsset, getChalkMathData, getInsertionPoint, getSelectedMathElement, isChalkMathElement, svgToDataUrl } from "./math-elements.js";
+export type { ChalkMathCustomData, MathImageAsset } from "./math-elements.js";
+export { getRenderedSvgSize, renderLatexToSvg } from "./mathjax-renderer.js";
+export type { RenderedMathSvg } from "./mathjax-renderer.js";
+export type { AppState, BinaryFileData, BinaryFiles, Collaborator, CollaboratorPointer, ExcalidrawElement, ExcalidrawImperativeAPI, OrderedExcalidrawElement } from "../collab/index.js";