@fileverse-dev/dsheet 2.0.36-shortcut-1 → 2.0.36-shortcut-3

package/dist/sync-local/SyncManager.d.ts

@@ -0,0 +1,69 @@
+import { Awareness } from 'y-protocols/awareness.js';
+import { SyncManagerConfig, CollabConnectionConfig, CollabServices, CollabCallbacks, CollabStatus, CollabState } from './types';
+
+export declare class SyncManager {
+    private onCollabStateChange;
+    private _status;
+    private _context;
+    private _awareness;
+    private socketClient;
+    private roomKey;
+    private roomKeyBytes;
+    private isOwner;
+    private updateQueue;
+    private uncommittedUpdatesIdList;
+    private contentTobeAppliedQueue;
+    private isProcessing;
+    /** Prevents parallel terminateSession calls (UI + effect cleanup). */
+    private _terminating;
+    private flushTimer;
+    private readonly FLUSH_INTERVAL_MS;
+    private readonly MAX_QUEUE_SIZE;
+    private _awarenessUpdateHandler;
+    private ydoc;
+    private servicesRef;
+    private callbacksRef;
+    private onLocalUpdate?;
+    constructor(config: SyncManagerConfig, onCollabStateChange: (state: CollabState) => void);
+    /** Called by useSyncManager on every render to keep refs fresh */
+    updateRefs(services: CollabServices | undefined, callbacks: CollabCallbacks | undefined, onLocalUpdate?: (updatedDocContent: string, updateChunk: string) => void): void;
+    get isConnected(): boolean;
+    get isReady(): boolean;
+    get awareness(): Awareness | null;
+    get status(): CollabStatus;
+    get collabState(): CollabState;
+    private send;
+    private runExitActions;
+    private runEntryActions;
+    connect(config: CollabConnectionConfig): Promise<void>;
+    disconnect(): Promise<void>;
+    terminateSession(): Promise<void>;
+    enqueueLocalUpdate(update: Uint8Array): void;
+    private flushUpdates;
+    private awaitFlush;
+    /**
+     * Fire-and-forget: merge all queued updates, encrypt, and emit via Socket.IO
+     * without awaiting the server ACK. The server broadcasts to peers immediately
+     * (before MongoDB write), so content reaches observers in near-real-time.
+     * ACK callback handles updateId tracking and auto-commit asynchronously.
+     */
+    private sendUpdateBatch;
+    forceCleanup(): void;
+    private handleConnectionError;
+    private handleReconnection;
+    private connectSocket;
+    private syncLatestCommit;
+    private initializeAwareness;
+    private cleanupAwareness;
+    private commitLocalContents;
+    private broadcastLocalContents;
+    private processUpdateQueue;
+    private processNextUpdate;
+    private processCommit;
+    private handleRemoteContentUpdate;
+    private applyRemoteYjsUpdate;
+    private applyQueuedRemoteContents;
+    private withRetry;
+    private disconnectInternal;
+    private resetInternalState;
+}

package/dist/sync-local/collabStateMachine.d.ts

@@ -0,0 +1,23 @@
+import { CollabStatus, CollabEvent, CollabContext, CollabState, CollabErrorCode } from './types';
+
+export declare const INITIAL_CONTEXT: CollabContext;
+type TransitionResult = {
+    status: CollabStatus;
+    context: Partial<CollabContext>;
+} | null;
+/**
+ * Transition map: (currentStatus, eventType) → nextStatus + context mutations.
+ * Returns null if the transition is invalid.
+ */
+export declare function transition(currentStatus: CollabStatus, event: CollabEvent, context: CollabContext): TransitionResult;
+/**
+ * Derives the consumer-facing CollabState from internal status + context.
+ */
+export declare function deriveCollabState(status: CollabStatus, context: CollabContext): CollabState;
+/** Helper to create a CollabError */
+export declare function createCollabError(code: CollabErrorCode, message: string, recoverable?: boolean): {
+    code: CollabErrorCode;
+    message: string;
+    recoverable: boolean;
+};
+export {};

package/dist/sync-local/crypto/index.d.ts

@@ -0,0 +1,6 @@
+export declare const crypto: {
+    generateKeyPair: () => import('@fileverse/crypto/ecies').EciesKeyPairBytes;
+    encryptData: (key: Uint8Array, message: Uint8Array) => string;
+    decryptData: (key: Uint8Array, message: string) => Uint8Array<ArrayBufferLike>;
+    generateRandomBytes: <E extends import('@fileverse/crypto/types').EncodingType = "bytes">(length?: number, encoding?: E) => import('@fileverse/crypto/types').EncodedReturnType<E>;
+};

package/dist/sync-local/index.d.ts

@@ -0,0 +1,3 @@
+export { useSyncManager } from './useSyncManager';
+export { SyncManager } from './SyncManager';
+export type { SyncManagerConfig, CollabConnectionConfig, CollabServices, CollabCallbacks, CollaborationProps, CollabSessionMeta, CollabStatus, CollabState, CollabError, CollabErrorCode, CollabEvent, CollabContext, CollabUser, } from './types';

package/dist/sync-local/socketClient.d.ts

@@ -0,0 +1,68 @@
+import { ISocketInitConfig, RoomMember, SocketStatusEnum, SendUpdateResponse, CommitResponse, AckResponse } from './types';
+import { Awareness } from 'y-protocols/awareness.js';
+
+interface ISocketClientConfig {
+    wsUrl: string;
+    roomKey: string;
+    roomId: string;
+    ownerEdSecret?: string;
+    contractAddress?: string;
+    ownerAddress?: string;
+    onHandshakeData?: (response: {
+        data: AckResponse;
+        roomKey: string;
+    }) => void;
+    roomInfo?: {
+        documentTitle: string;
+        portalAddress: string;
+        commentKey: string;
+    };
+}
+export declare class SocketClient {
+    private _socketUrl;
+    private _socket;
+    private _webSocketStatus;
+    private _isIntentionalDisconnect;
+    get isConnected(): boolean;
+    get status(): SocketStatusEnum;
+    private _websocketServiceDid;
+    private roomId;
+    roomMembers: RoomMember[];
+    private collaborationKeyPair;
+    private ownerKeyPair?;
+    private contractAddress?;
+    private ownerUcan?;
+    private collaborationUcan?;
+    private ownerAddress?;
+    private roomKey;
+    private roomInfo?;
+    private awareness;
+    private connectionAttemptErrorCount;
+    private _onHandshakeData;
+    constructor(config: ISocketClientConfig);
+    registerAwareness(awareness: Awareness): void;
+    private _emitWithAck;
+    private _fetchRoomMembers;
+    sendUpdate({ update }: {
+        update: string;
+    }): Promise<SendUpdateResponse>;
+    commitUpdates({ updates, cid }: {
+        updates: string[];
+        cid: string;
+    }): Promise<CommitResponse>;
+    fetchLatestCommit(): Promise<AckResponse<any>>;
+    getUncommittedChanges(): Promise<AckResponse<any>>;
+    broadcastAwareness(awarenessUpdate: string): Promise<void>;
+    disconnect: () => void;
+    terminateSession: () => Promise<void>;
+    private getCollaborationKeyPair;
+    private isUcanValid;
+    private getOwnerToken;
+    private buildSessionToken;
+    private _handleHandShake;
+    private _handleAwarenessUpdate;
+    connectSocket(config: ISocketInitConfig): Promise<void>;
+    private _onSessionTerminated;
+    private resetSocketClient;
+}
+export {};

package/dist/sync-local/types/index.d.ts

@@ -0,0 +1,212 @@
+import * as Y from 'yjs';
+export interface CollabUser {
+    clientId: number;
+    name: string;
+    color: string;
+    isEns: boolean;
+    cell?: {
+        r: number;
+        c: number;
+        sheetId: string;
+    };
+}
+/** Connection identity — changes to these trigger reconnect */
+export interface CollabConnectionConfig {
+    roomKey: string;
+    roomId: string;
+    wsUrl: string;
+    isOwner: boolean;
+    ownerEdSecret?: string;
+    contractAddress?: string;
+    ownerAddress?: string;
+    roomInfo?: {
+        documentTitle: string;
+        portalAddress: string;
+        commentKey: string;
+    };
+}
+/** Session metadata — changes to these update awareness, NOT reconnect */
+export interface CollabSessionMeta {
+    username: string;
+    color?: string;
+    isEns?: boolean;
+}
+/** Storage integrations the sync engine depends on */
+export interface CollabServices {
+    commitToStorage?: (file: File) => Promise<string>;
+    fetchFromStorage?: (cid: string) => Promise<any>;
+}
+export type CollabErrorCode = 'CONNECTION_FAILED' | 'AUTH_FAILED' | 'SYNC_FAILED' | 'TIMEOUT' | 'UNKNOWN';
+export type CollabError = {
+    code: CollabErrorCode;
+    message: string;
+    recoverable: boolean;
+};
+export type CollabStatus = 'idle' | 'connecting' | 'syncing' | 'ready' | 'reconnecting' | 'error' | 'terminated';
+export type CollabState = {
+    status: 'idle';
+} | {
+    status: 'connecting';
+} | {
+    status: 'syncing';
+    hasUnmergedPeerUpdates: boolean;
+} | {
+    status: 'ready';
+} | {
+    status: 'reconnecting';
+    attempt: number;
+    maxAttempts: number;
+} | {
+    status: 'error';
+    error: CollabError;
+} | {
+    status: 'terminated';
+    reason?: string;
+};
+export type CollabEvent = {
+    type: 'CONNECT';
+} | {
+    type: 'AUTH_SUCCESS';
+} | {
+    type: 'SYNC_COMPLETE';
+} | {
+    type: 'SET_UNMERGED_UPDATES';
+    hasUpdates: boolean;
+} | {
+    type: 'SOCKET_DROPPED';
+} | {
+    type: 'RECONNECTED';
+} | {
+    type: 'RETRY_EXHAUSTED';
+} | {
+    type: 'ERROR';
+    error: CollabError;
+} | {
+    type: 'SESSION_TERMINATED';
+    reason?: string;
+} | {
+    type: 'RESET';
+};
+export interface CollabContext {
+    hasUnmergedPeerUpdates: boolean;
+    reconnectAttempt: number;
+    maxReconnectAttempts: number;
+    error: CollabError | null;
+    terminationReason?: string;
+}
+/** Event callbacks the consumer reacts to */
+export interface CollabCallbacks {
+    onStateChange?: (state: CollabState) => void;
+    onError?: (error: CollabError) => void;
+    onCollaboratorsChange?: (collaborators: CollabUser[]) => void;
+    onHandshakeData?: (data: {
+        data: AckResponse;
+        roomKey: string;
+    }) => void;
+}
+/** Discriminated union — TypeScript enforces config+services only when enabled */
+export type CollaborationProps = {
+    enabled: false;
+} | {
+    enabled: true;
+    connection: CollabConnectionConfig;
+    session: CollabSessionMeta;
+    services: CollabServices;
+    on?: CollabCallbacks;
+};
+export interface SyncManagerConfig {
+    ydoc: Y.Doc;
+    services?: CollabServices;
+    callbacks?: CollabCallbacks;
+    onLocalUpdate?: (updatedDocContent: string, updateChunk: string) => void;
+    /** Origins to ignore in the ydoc update handler (e.g. IndexedDB provider) */
+    ignoredOrigins?: Array<{
+        current: unknown;
+    }>;
+}
+export declare enum ServerErrorCode {
+    AUTH_TOKEN_MISSING = "AUTH_TOKEN_MISSING",
+    AUTH_TOKEN_INVALID = "AUTH_TOKEN_INVALID",
+    SESSION_NOT_FOUND = "SESSION_NOT_FOUND",
+    SESSION_TERMINATED = "SESSION_TERMINATED",
+    SESSION_DID_MISSING = "SESSION_DID_MISSING",
+    DOCUMENT_ID_MISSING = "DOCUMENT_ID_MISSING",
+    UPDATE_DATA_MISSING = "UPDATE_DATA_MISSING",
+    COMMIT_UNAUTHORIZED = "COMMIT_UNAUTHORIZED",
+    COMMIT_MISSING_DATA = "COMMIT_MISSING_DATA",
+    INVALID_ADDRESS = "INVALID_ADDRESS",
+    NOT_AUTHENTICATED = "NOT_AUTHENTICATED",
+    DB_ERROR = "DB_ERROR",
+    INTERNAL_ERROR = "INTERNAL_ERROR",
+    APP_MISMATCH = "APP_MISMATCH"
+}
+export interface AckResponse<T = Record<string, any>> {
+    status: boolean;
+    statusCode: number;
+    data?: T;
+    error?: string;
+    errorCode?: ServerErrorCode;
+}
+export interface SendUpdateResponse extends AckResponse<{
+    id: string;
+    documentId: string;
+    data: string;
+    updateType: string;
+    commitCid: string | null;
+    createdAt: number;
+}> {
+}
+export interface CommitResponse extends AckResponse<{
+    cid: string;
+    createdAt: number;
+    documentId: string;
+    updates: string[];
+}> {
+}
+export interface ISocketInitConfig {
+    onHandshakeSuccess: () => void;
+    onDisconnect: () => void;
+    onSocketDropped: () => void;
+    onError: (err: Error) => void;
+    onHandShakeError: (err: Error, statusCode?: number) => void;
+    onContentUpdate: (data: {
+        id: string;
+        data: string;
+        createdAt: number;
+        roomId: string;
+    }) => void;
+    onMembershipChange: (data: {
+        action: string;
+        user: {
+            role: string;
+        };
+        roomId: string;
+    }) => void;
+    onSessionTerminated: (data: {
+        roomId: string;
+    }) => void;
+    onReconnectFailed: () => void;
+}
+export declare enum SocketStatusEnum {
+    CLOSED = "CLOSED",
+    CONNECTED = "CONNECTED",
+    CONNECTING = "CONNECTING",
+    DISCONNECTING = "DISCONNECTING",
+    DISCONNECTED = "DISCONNECTED"
+}
+export interface RoomMember {
+    username: string;
+    userId: string;
+    role: 'owner' | 'editor';
+}
+export type AppType = 'ddoc' | 'dsheet';
+export interface IAuthArgs {
+    collaborationToken: string;
+    documentId: string;
+    ownerToken?: string;
+    ownerAddress?: string;
+    contractAddress?: string;
+    sessionDid?: string;
+    roomInfo?: string;
+    appType?: AppType;
+}

package/dist/sync-local/useSyncManager.d.ts

@@ -0,0 +1,12 @@
+import { SyncManagerConfig, CollabConnectionConfig, CollabState } from './types';
+
+export declare const useSyncManager: (config: SyncManagerConfig) => {
+    state: CollabState;
+    connect: (connectConfig: CollabConnectionConfig) => void;
+    disconnect: () => void;
+    terminateSession: () => void;
+    isReady: boolean;
+    isSyncing: boolean;
+    awareness: import('y-protocols/awareness.js').Awareness | null;
+    hasCollabContentInitialised: boolean;
+};

package/dist/sync-local/utils/createAwarenessUpdateHandler.d.ts

@@ -0,0 +1,8 @@
+import { Awareness } from 'y-protocols/awareness';
+import { SocketClient } from '../socketClient';
+
+export declare const createAwarenessUpdateHandler: (awareness: Awareness, socketClient: SocketClient, roomKey: string) => ({ added, updated, removed, }: {
+    added: number[];
+    updated: number[];
+    removed: number[];
+}, origin: any) => void;

package/dist/sync-local/utils/objectToFile.d.ts

@@ -0,0 +1 @@
+export declare const objectToFile: (data: Record<string, unknown>, fileName: string) => File;

package/dist/{use-xlsx-import-impl-ehiopPNr.js → use-xlsx-import-impl-AI2QDZt1.js}

@@ -1,6 +1,6 @@
-import { g as Ue } from "./executeStringFunction-6r6Tl4Z6.js";
+import { g as Ue } from "./executeStringFunction-tdvZ0KTi.js";
 import * as qe from "yjs";
-import { m as Xe, y as Ze } from "./index-D-9Q_hz4.js";
+import { m as Xe, y as Ze } from "./index-D_IxoHMJ.js";
 import { n as Je } from "./xlsx-hyperlink-inline-DzewAypN.js";
 import { toast as Be } from "@fileverse/ui";
 var We = { exports: {} };