@q9labsai/chalk-whiteboard 4.1.16 → 5.0.0

package/dist/collab/engine.d.ts

@@ -51,13 +51,17 @@ export declare class ExcalidrawCollabEngine {
     private sceneId;
     private sceneGeneration;
     private canDraw;
-    private lastBroadcastedOrReceivedElementsHash;
+    private storedImageFileIds;
     private broadcastedElementVersions;
+    private rejectedElementVersions;
+    private deferredRemoteElements;
     private submissionInFlight;
     private dirtyDuringSubmission;
     private disposed;
     private changeDebounce;
-    private fullSyncTimer;
+    private changeDebounceDeadline;
+    private submissionRetryTimer;
+    private submissionRetries;
     private readonly filesSync;
     private readonly presence;
     private readonly unsubPointerUp;
@@ -66,7 +70,7 @@ export declare class ExcalidrawCollabEngine {
     setCanDraw(next: boolean): void;
     clear(): Promise<WhiteboardCommit>;
     dispose(): void;
-    handleChange(_elements: readonly OrderedExcalidrawElement[], _appState: AppState, files: BinaryFiles): void;
+    handleChange(_elements: readonly OrderedExcalidrawElement[], _appState: AppState, _files: BinaryFiles): void;
     handlePointerUpdate(payload: {
         pointer: {
             x: number;
@@ -93,13 +97,18 @@ export declare class ExcalidrawCollabEngine {
         elements: readonly WhiteboardWireElement[];
         appState?: SharedWhiteboardAppState;
     }): void;
+    private stripUnstoredImages;
     private flushNow;
     private flushOnDispose;
-    private scheduleFullSync;
-    private sendFullSync;
+    private isUnsubmitted;
+    private applyDeferredRemoteElements;
+    private clearChangeDebounce;
+    private resetSubmissionRetries;
+    private scheduleSubmissionRetry;
     private submissionContext;
     private submit;
     private submitFinalUpdate;
+    private toSubmissionElements;
     private applyRemoteElements;
     private requestSnapshot;
 }

package/dist/collab/files.d.ts

@@ -1,23 +1,13 @@
-import type { BinaryFiles, ExcalidrawImperativeAPI, OrderedExcalidrawElement } from "./types.js";
-import type { WhiteboardUploadInstructions } from "./wire.js";
-export type WhiteboardFileSyncPhase = "idle" | "uploading" | "awaiting_remote_upload" | "downloading" | "error";
+import type { ExcalidrawImperativeAPI, OrderedExcalidrawElement } from "./types.js";
+export type WhiteboardFileSyncPhase = "idle" | "awaiting_remote_upload" | "downloading" | "error";
 export interface WhiteboardFileSyncState {
     phase: WhiteboardFileSyncPhase;
-    uploading: number;
-    uploadQueued: number;
     remotePendingUploads: number;
     downloading: number;
     downloadQueued: number;
     lastErrorAtMs: number | null;
 }
 export interface WhiteboardFileTransfer {
-    readonly upload: (input: {
-        readonly fileId: string;
-        readonly mimeType: string;
-        readonly byteLength: number;
-        readonly sha256: string;
-        readonly dataURL: string;
-    }) => Promise<void>;
     readonly download: (fileId: string) => Promise<{
         readonly mimeType: string;
         readonly dataURL: string;
@@ -25,40 +15,26 @@ export interface WhiteboardFileTransfer {
 }
 export interface WhiteboardFileTransferOptions {
     fileTransfer?: WhiteboardFileTransfer;
-    initiateUpload?: (input: {
-        fileId: string;
-        mimeType: string;
-        byteLength: number;
-        sha256: string;
-    }) => Promise<WhiteboardUploadInstructions>;
-    finalizeUpload?: (uploadId: string) => Promise<void>;
     presignDownload?: (fileId: string) => Promise<{
         downloadUrl: string;
     }>;
 }
 interface WhiteboardFilesSyncOptions extends WhiteboardFileTransferOptions {
     excalidrawAPI: ExcalidrawImperativeAPI;
-    uploadThrottleMs?: number;
     downloadThrottleMs?: number;
     onStateChange?: (state: WhiteboardFileSyncState) => void;
 }
 export declare class WhiteboardFilesSync {
     private readonly opts;
-    private uploadTimer;
     private downloadTimer;
-    private uploadQueue;
     private downloadQueue;
-    private uploading;
     private downloading;
     constructor(opts: WhiteboardFilesSyncOptions);
     private remotePendingUploads;
     private lastErrorAtMs;
-    handleLocalScene(elementsAll: readonly OrderedExcalidrawElement[], files: BinaryFiles): void;
     handleRemoteScene(elementsAll: readonly OrderedExcalidrawElement[]): void;
     dispose(): void;
-    private scheduleUpload;
     private scheduleDownload;
-    private processNextUpload;
     private processNextDownload;
     private emitState;
 }

package/dist/collab/index.js

@@ -1,12 +1,12 @@
 import {
   mergeWhiteboardElements
-} from "../chunk-4XG2ABSP.js";
+} from "../chunk-W4FLPXAX.js";
 import {
   ExcalidrawCollabEngine,
   fromWireElement,
   isWireElement,
   toWireElement
-} from "../chunk-F4B4ANIZ.js";
+} from "../chunk-6ZV7GBAC.js";
 export {
   ExcalidrawCollabEngine,
   fromWireElement,

package/dist/collab/order.d.ts

@@ -0,0 +1,6 @@
+type OrderedElement = {
+    readonly index: string | null;
+    readonly id: string;
+};
+export declare function compareElementOrder(left: OrderedElement, right: OrderedElement): number;
+export {};

package/dist/collab/syncable.d.ts

@@ -1,2 +1,4 @@
 import type { OrderedExcalidrawElement } from "./types.js";
 export declare const filterSyncableElements: (elements: readonly OrderedExcalidrawElement[]) => OrderedExcalidrawElement[];
+export declare const remoteImageFileIds: (elements: readonly OrderedExcalidrawElement[]) => string[];
+export declare const retainStoredImages: (elements: readonly OrderedExcalidrawElement[], storedFileIds: ReadonlySet<string>) => OrderedExcalidrawElement[];

package/dist/collab/wire.d.ts

@@ -1,4 +1,5 @@
 import type { OrderedExcalidrawElement } from "./types.js";
+export declare const ELEMENT_ENCODED_BYTES_LIMIT: number;
 export type WhiteboardJsonValue = null | boolean | number | string | readonly WhiteboardJsonValue[] | {
     readonly [key: string]: WhiteboardJsonValue;
 };
@@ -25,5 +26,10 @@ export interface WhiteboardUploadInstructions {
     readonly expiresAt: string;
 }
 export declare function toWireElement(element: OrderedExcalidrawElement): WhiteboardWireElement;
+/**
+ * The element as the engine submits it. It equals `toWireElement` while the element fits the size that Sync stores.
+ * A larger element gets its points rounded and, when that is not enough, thinned. Throws when no copy fits.
+ */
+export declare function toFittedWireElement(element: OrderedExcalidrawElement): WhiteboardWireElement;
 export declare function fromWireElement(element: WhiteboardWireElement): OrderedExcalidrawElement;
 export declare function isWireElement(value: unknown): value is WhiteboardWireElement;

package/dist/embedded/chalk-whiteboard/asset-manifest.json

@@ -1216,8 +1216,8 @@
     },
     {
       "path": "renderer.js",
-      "bytes": 8501481,
-      "sha256": "0c4c6df489516442d98fb69d33d1129d762ba3404a2eaf6f3e7fd7ea391cb6d9"
+      "bytes": 8497928,
+      "sha256": "7f754073f20cee4b3adceb40731faf75d94849f6ce01a0b2e30fdad10867a5d9"
     },
     {
       "path": "THIRD_PARTY_NOTICES.json",