nexabase-console 2.1.7 → 2.1.9

package/dist/firestore/GeoPoint.d.ts

@@ -5,6 +5,7 @@ export declare class GeoPoint {
     isEqual(other: GeoPoint): boolean;
     toString(): string;
     toJSON(): {
+        __nexa_type__: string;
         latitude: number;
         longitude: number;
     };

package/dist/firestore/GeoPoint.js

@@ -23,7 +23,7 @@ class GeoPoint {
         return `GeoPoint(latitude=${this.latitude}, longitude=${this.longitude})`;
     }
     toJSON() {
-        return { latitude: this.latitude, longitude: this.longitude };
+        return { __nexa_type__: 'geopoint', latitude: this.latitude, longitude: this.longitude };
     }
 }
 exports.GeoPoint = GeoPoint;

package/dist/firestore/Timestamp.d.ts

@@ -11,6 +11,7 @@ export declare class Timestamp {
     valueOf(): string;
     toString(): string;
     toJSON(): {
+        __nexa_type__: string;
         seconds: number;
         nanoseconds: number;
     };

package/dist/firestore/Timestamp.js

@@ -56,7 +56,7 @@ class Timestamp {
         return `Timestamp(seconds=${this.seconds}, nanoseconds=${this.nanoseconds})`;
     }
     toJSON() {
-        return { seconds: this.seconds, nanoseconds: this.nanoseconds };
+        return { __nexa_type__: 'timestamp', seconds: this.seconds, nanoseconds: this.nanoseconds };
     }
 }
 exports.Timestamp = Timestamp;

package/dist/index.d.ts

@@ -28,6 +28,7 @@ export * from './persistence/LocalStore';
 export * from './persistence/MutationQueue';
 export * from './sync/SyncEngine';
 export * from './sync/ConflictResolver';
+export * from './sync/CrossTabSync';
 export * from './transport/HttpClient';
 export * from './transport/SSEClient';
 export * from './transport/WebSocketClient';

package/dist/index.js

@@ -52,6 +52,7 @@ __exportStar(require("./persistence/MutationQueue"), exports);
 // Sync
 __exportStar(require("./sync/SyncEngine"), exports);
 __exportStar(require("./sync/ConflictResolver"), exports);
+__exportStar(require("./sync/CrossTabSync"), exports);
 // Transport
 __exportStar(require("./transport/HttpClient"), exports);
 __exportStar(require("./transport/SSEClient"), exports);

package/dist/sync/CrossTabSync.d.ts

@@ -0,0 +1,83 @@
+export interface CrossTabMessage<T = any> {
+    id: string;
+    senderTabId: string;
+    projectId?: string;
+    type: string;
+    timestamp: number;
+    payload: T;
+}
+export interface LocalMutationPayload {
+    path: string;
+    action: 'set' | 'patch' | 'update' | 'delete' | string;
+    data?: any;
+    metadata?: {
+        mutationId?: string;
+        source?: 'local' | 'server' | string;
+        state?: 'pending' | 'acknowledged' | string;
+        hasPendingWrites?: boolean;
+        [key: string]: any;
+    };
+}
+export type CrossTabMessageHandler<T = any> = (payload: T, message: CrossTabMessage<T>) => void;
+export type MutationSyncHandler = (path: string, action: string, data?: any, metadata?: LocalMutationPayload['metadata']) => void;
+/**
+ * Serializes rich JavaScript objects (Timestamp, GeoPoint, Date) into structured JSON-safe
+ * objects with explicit type tags so they can cross BroadcastChannel or localStorage boundaries safely.
+ */
+export declare function serializeCrossTabData(data: any, seen?: WeakSet<object>): any;
+/**
+ * Deserializes structured JSON-safe objects back into rich JavaScript types (Timestamp, GeoPoint, etc.).
+ */
+export declare function deserializeCrossTabData(data: any): any;
+/**
+ * Checks if native BroadcastChannel is supported in the current environment.
+ */
+export declare function isBroadcastChannelSupported(): boolean;
+/**
+ * CrossTabSyncChannel provides ultra-fast, local cross-tab state synchronization
+ * with native BroadcastChannel support and automatic fallback to localStorage storage events.
+ */
+export declare class CrossTabSyncChannel {
+    readonly channelName: string;
+    readonly tabId: string;
+    private broadcastChannel;
+    private listeners;
+    private wildcardListeners;
+    private storageListener;
+    private isClosed;
+    constructor(channelName: string);
+    private initTransport;
+    private handleIncomingRawMessage;
+    /**
+     * Broadcasts a typed message across all other browser tabs.
+     */
+    broadcast<T = any>(type: string, payload: T, projectId?: string): void;
+    /**
+     * Broadcasts a local mutation event (write, update, delete) to keep caches across tabs in sync instantly.
+     */
+    broadcastMutation(path: string, action: string, data?: any, metadata?: LocalMutationPayload['metadata'], projectId?: string): void;
+    /**
+     * Subscribes to a specific event type. Returns an unsubscribe callback.
+     */
+    on<T = any>(type: string, handler: CrossTabMessageHandler<T>): () => void;
+    /**
+     * Subscribes to all incoming messages regardless of type.
+     */
+    onAny(handler: CrossTabMessageHandler): () => void;
+    /**
+     * Helper specifically for listening to local mutations across tabs.
+     */
+    onMutation(handler: MutationSyncHandler): () => void;
+    /**
+     * Closes the channel and removes all event listeners.
+     */
+    close(): void;
+}
+/**
+ * Returns a singleton instance of CrossTabSyncChannel for the given channel name.
+ */
+export declare function getCrossTabChannel(channelName: string): CrossTabSyncChannel;
+/**
+ * Creates or gets a project-scoped cross-tab synchronization channel.
+ */
+export declare function getProjectCrossTabChannel(projectId: string): CrossTabSyncChannel;

package/dist/sync/CrossTabSync.js

@@ -0,0 +1,317 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CrossTabSyncChannel = void 0;
+exports.serializeCrossTabData = serializeCrossTabData;
+exports.deserializeCrossTabData = deserializeCrossTabData;
+exports.isBroadcastChannelSupported = isBroadcastChannelSupported;
+exports.getCrossTabChannel = getCrossTabChannel;
+exports.getProjectCrossTabChannel = getProjectCrossTabChannel;
+const Timestamp_1 = require("../firestore/Timestamp");
+const GeoPoint_1 = require("../firestore/GeoPoint");
+const QueryUtils_1 = require("../firestore/QueryUtils");
+/**
+ * Generates a unique Tab ID for distinguishing cross-tab messages from current tab.
+ */
+function createTabId() {
+    if (typeof crypto !== 'undefined' && typeof crypto.randomUUID === 'function') {
+        return crypto.randomUUID();
+    }
+    return `tab_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
+}
+/**
+ * Serializes rich JavaScript objects (Timestamp, GeoPoint, Date) into structured JSON-safe
+ * objects with explicit type tags so they can cross BroadcastChannel or localStorage boundaries safely.
+ */
+function serializeCrossTabData(data, seen = new WeakSet()) {
+    if (data === null || data === undefined)
+        return data;
+    const type = typeof data;
+    if (type === 'boolean' || type === 'number' || type === 'string')
+        return data;
+    if (data instanceof Date) {
+        return {
+            __nexa_type__: 'timestamp',
+            seconds: Math.floor(data.getTime() / 1000),
+            nanoseconds: (data.getTime() % 1000) * 1000000
+        };
+    }
+    if (data instanceof Timestamp_1.Timestamp) {
+        return {
+            __nexa_type__: 'timestamp',
+            seconds: data.seconds,
+            nanoseconds: data.nanoseconds
+        };
+    }
+    // Handle Timestamp-like objects (e.g. if prototype was stripped)
+    if (typeof data === 'object' &&
+        'seconds' in data &&
+        'nanoseconds' in data &&
+        typeof data.seconds === 'number' &&
+        typeof data.nanoseconds === 'number') {
+        return {
+            __nexa_type__: 'timestamp',
+            seconds: data.seconds,
+            nanoseconds: data.nanoseconds
+        };
+    }
+    if (data instanceof GeoPoint_1.GeoPoint) {
+        return {
+            __nexa_type__: 'geopoint',
+            latitude: data.latitude,
+            longitude: data.longitude
+        };
+    }
+    if (typeof data === 'object' &&
+        'latitude' in data &&
+        'longitude' in data &&
+        typeof data.latitude === 'number' &&
+        typeof data.longitude === 'number') {
+        return {
+            __nexa_type__: 'geopoint',
+            latitude: data.latitude,
+            longitude: data.longitude
+        };
+    }
+    if (Array.isArray(data)) {
+        if (seen.has(data))
+            return null;
+        seen.add(data);
+        const res = data.map((item) => serializeCrossTabData(item, seen));
+        seen.delete(data);
+        return res;
+    }
+    if (typeof data === 'object') {
+        if (seen.has(data))
+            return null;
+        seen.add(data);
+        const res = {};
+        for (const key of Object.keys(data)) {
+            res[key] = serializeCrossTabData(data[key], seen);
+        }
+        seen.delete(data);
+        return res;
+    }
+    return data;
+}
+/**
+ * Deserializes structured JSON-safe objects back into rich JavaScript types (Timestamp, GeoPoint, etc.).
+ */
+function deserializeCrossTabData(data) {
+    return (0, QueryUtils_1.reviveNexaData)(data);
+}
+/**
+ * Checks if native BroadcastChannel is supported in the current environment.
+ */
+function isBroadcastChannelSupported() {
+    return typeof window !== 'undefined' && typeof window.BroadcastChannel !== 'undefined';
+}
+/**
+ * CrossTabSyncChannel provides ultra-fast, local cross-tab state synchronization
+ * with native BroadcastChannel support and automatic fallback to localStorage storage events.
+ */
+class CrossTabSyncChannel {
+    constructor(channelName) {
+        this.broadcastChannel = null;
+        this.listeners = new Map();
+        this.wildcardListeners = new Set();
+        this.storageListener = null;
+        this.isClosed = false;
+        this.channelName = channelName;
+        this.tabId = createTabId();
+        this.initTransport();
+    }
+    initTransport() {
+        if (typeof window === 'undefined')
+            return;
+        if (isBroadcastChannelSupported()) {
+            try {
+                this.broadcastChannel = new window.BroadcastChannel(this.channelName);
+                this.broadcastChannel.onmessage = (event) => {
+                    this.handleIncomingRawMessage(event.data);
+                };
+                return;
+            }
+            catch (err) {
+                console.warn(`[CrossTabSyncChannel] Native BroadcastChannel failed for "${this.channelName}", falling back to StorageEvent:`, err);
+            }
+        }
+        // Fallback: localStorage storage events
+        if (typeof window.addEventListener === 'function' && typeof window.localStorage !== 'undefined') {
+            const storageKey = `__nexa_crosstab_${this.channelName}`;
+            this.storageListener = (e) => {
+                if (e.key === storageKey && e.newValue) {
+                    try {
+                        const raw = JSON.parse(e.newValue);
+                        this.handleIncomingRawMessage(raw);
+                    }
+                    catch (parseErr) {
+                        // Ignore parse errors from concurrent writes
+                    }
+                }
+            };
+            window.addEventListener('storage', this.storageListener);
+        }
+    }
+    handleIncomingRawMessage(raw) {
+        if (!raw || typeof raw !== 'object')
+            return;
+        const msg = raw;
+        // Discard messages originating from the current tab
+        if (msg.senderTabId === this.tabId)
+            return;
+        // Reconstruct rich objects (Timestamp, GeoPoint)
+        const revivedPayload = deserializeCrossTabData(msg.payload);
+        const message = {
+            ...msg,
+            payload: revivedPayload
+        };
+        // Notify specific type listeners
+        if (msg.type && this.listeners.has(msg.type)) {
+            const typeSet = this.listeners.get(msg.type);
+            typeSet.forEach((fn) => {
+                try {
+                    fn(revivedPayload, message);
+                }
+                catch (e) {
+                    console.error(`[CrossTabSyncChannel] Error in listener for type "${msg.type}":`, e);
+                }
+            });
+        }
+        // Notify wildcard listeners
+        this.wildcardListeners.forEach((fn) => {
+            try {
+                fn(revivedPayload, message);
+            }
+            catch (e) {
+                console.error(`[CrossTabSyncChannel] Error in wildcard listener:`, e);
+            }
+        });
+    }
+    /**
+     * Broadcasts a typed message across all other browser tabs.
+     */
+    broadcast(type, payload, projectId) {
+        if (this.isClosed)
+            return;
+        const serializedPayload = serializeCrossTabData(payload);
+        const message = {
+            id: `msg_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`,
+            senderTabId: this.tabId,
+            projectId,
+            type,
+            timestamp: Date.now(),
+            payload: serializedPayload
+        };
+        // 1. Native BroadcastChannel
+        if (this.broadcastChannel) {
+            try {
+                this.broadcastChannel.postMessage(message);
+                return;
+            }
+            catch (e) {
+                console.warn('[CrossTabSyncChannel] BroadcastChannel postMessage failed:', e);
+            }
+        }
+        // 2. StorageEvent Fallback
+        if (typeof window !== 'undefined' && typeof window.localStorage !== 'undefined') {
+            try {
+                const storageKey = `__nexa_crosstab_${this.channelName}`;
+                window.localStorage.setItem(storageKey, JSON.stringify(message));
+            }
+            catch (e) {
+                // Storage quota or restriction
+            }
+        }
+    }
+    /**
+     * Broadcasts a local mutation event (write, update, delete) to keep caches across tabs in sync instantly.
+     */
+    broadcastMutation(path, action, data, metadata, projectId) {
+        const payload = {
+            path,
+            action,
+            data,
+            metadata
+        };
+        this.broadcast('LOCAL_MUTATION', payload, projectId);
+    }
+    /**
+     * Subscribes to a specific event type. Returns an unsubscribe callback.
+     */
+    on(type, handler) {
+        if (!this.listeners.has(type)) {
+            this.listeners.set(type, new Set());
+        }
+        this.listeners.get(type).add(handler);
+        return () => {
+            const set = this.listeners.get(type);
+            if (set) {
+                set.delete(handler);
+                if (set.size === 0) {
+                    this.listeners.delete(type);
+                }
+            }
+        };
+    }
+    /**
+     * Subscribes to all incoming messages regardless of type.
+     */
+    onAny(handler) {
+        this.wildcardListeners.add(handler);
+        return () => {
+            this.wildcardListeners.delete(handler);
+        };
+    }
+    /**
+     * Helper specifically for listening to local mutations across tabs.
+     */
+    onMutation(handler) {
+        return this.on('LOCAL_MUTATION', (payload) => {
+            if (payload && payload.path && payload.action) {
+                handler(payload.path, payload.action, payload.data, payload.metadata);
+            }
+        });
+    }
+    /**
+     * Closes the channel and removes all event listeners.
+     */
+    close() {
+        this.isClosed = true;
+        this.listeners.clear();
+        this.wildcardListeners.clear();
+        if (this.broadcastChannel) {
+            try {
+                this.broadcastChannel.close();
+            }
+            catch (e) { }
+            this.broadcastChannel = null;
+        }
+        if (this.storageListener && typeof window !== 'undefined') {
+            try {
+                window.removeEventListener('storage', this.storageListener);
+            }
+            catch (e) { }
+            this.storageListener = null;
+        }
+    }
+}
+exports.CrossTabSyncChannel = CrossTabSyncChannel;
+// Global registry for CrossTab channels by name
+const channelsRegistry = new Map();
+/**
+ * Returns a singleton instance of CrossTabSyncChannel for the given channel name.
+ */
+function getCrossTabChannel(channelName) {
+    let channel = channelsRegistry.get(channelName);
+    if (!channel) {
+        channel = new CrossTabSyncChannel(channelName);
+        channelsRegistry.set(channelName, channel);
+    }
+    return channel;
+}
+/**
+ * Creates or gets a project-scoped cross-tab synchronization channel.
+ */
+function getProjectCrossTabChannel(projectId) {
+    return getCrossTabChannel(`nexabase_tab_sync_${projectId}`);
+}

package/dist/sync/SyncEngine.d.ts

@@ -1,14 +1,14 @@
 import { MutationQueue } from '../persistence/MutationQueue';
 import { SSEClient } from '../transport/SSEClient';
+import { CrossTabSyncChannel, MutationSyncHandler } from './CrossTabSync';
 export declare class SyncEngine {
     private projectId;
     private mutationQueue;
     private sseClient;
-    private broadcastChannel;
+    private crossTabChannel;
     constructor(projectId: string, mutationQueue: MutationQueue, sseClient: SSEClient);
-    private initCrossTabSync;
-    private _serializeForBroadcast;
-    broadcastLocalMutation(path: string, action: string, data?: any): void;
-    listenCrossTab(onMutation: (path: string, action: string, data?: any) => void): () => void;
+    getCrossTabChannel(): CrossTabSyncChannel;
+    broadcastLocalMutation(path: string, action: string, data?: any, metadata?: any): void;
+    listenCrossTab(onMutation: MutationSyncHandler): () => void;
     syncOfflineMutations(): Promise<void>;
 }

package/dist/sync/SyncEngine.js

@@ -1,82 +1,22 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SyncEngine = void 0;
+const CrossTabSync_1 = require("./CrossTabSync");
 class SyncEngine {
     constructor(projectId, mutationQueue, sseClient) {
-        this.broadcastChannel = null;
         this.projectId = projectId;
         this.mutationQueue = mutationQueue;
         this.sseClient = sseClient;
-        this.initCrossTabSync();
+        this.crossTabChannel = (0, CrossTabSync_1.getProjectCrossTabChannel)(this.projectId);
     }
-    initCrossTabSync() {
-        if (typeof window !== 'undefined' && 'BroadcastChannel' in window && !this.broadcastChannel) {
-            try {
-                this.broadcastChannel = new BroadcastChannel(`nexabase_tab_sync_${this.projectId}`);
-            }
-            catch (e) {
-                console.warn('[SyncEngine] BroadcastChannel initialization failed:', e);
-            }
-        }
+    getCrossTabChannel() {
+        return this.crossTabChannel;
     }
-    _serializeForBroadcast(data, seen = new WeakSet()) {
-        if (data === null || data === undefined)
-            return data;
-        if (typeof data === 'boolean' || typeof data === 'number' || typeof data === 'string')
-            return data;
-        if (data instanceof Date) {
-            return { __nexa_type__: 'timestamp', seconds: Math.floor(data.getTime() / 1000), nanoseconds: (data.getTime() % 1000) * 1000000 };
-        }
-        // Check if it's a Timestamp object (even without prototype due to potential prior cloning)
-        if (typeof data === 'object' && 'seconds' in data && 'nanoseconds' in data && typeof data.seconds === 'number' && typeof data.nanoseconds === 'number') {
-            return { __nexa_type__: 'timestamp', seconds: data.seconds, nanoseconds: data.nanoseconds };
-        }
-        // Check for GeoPoint
-        if (typeof data === 'object' && 'latitude' in data && 'longitude' in data && typeof data.latitude === 'number' && typeof data.longitude === 'number') {
-            return { __nexa_type__: 'geopoint', latitude: data.latitude, longitude: data.longitude };
-        }
-        if (Array.isArray(data)) {
-            if (seen.has(data))
-                return null;
-            seen.add(data);
-            const res = data.map(item => this._serializeForBroadcast(item, seen));
-            seen.delete(data);
-            return res;
-        }
-        if (typeof data === 'object') {
-            if (seen.has(data))
-                return null;
-            seen.add(data);
-            const res = {};
-            for (const key of Object.keys(data)) {
-                res[key] = this._serializeForBroadcast(data[key], seen);
-            }
-            seen.delete(data);
-            return res;
-        }
-        return data;
-    }
-    broadcastLocalMutation(path, action, data) {
-        if (this.broadcastChannel) {
-            try {
-                const serialized = this._serializeForBroadcast(data);
-                this.broadcastChannel.postMessage({ type: 'LOCAL_MUTATION', path, action, data: serialized });
-            }
-            catch (e) { }
-        }
+    broadcastLocalMutation(path, action, data, metadata) {
+        this.crossTabChannel.broadcastMutation(path, action, data, metadata, this.projectId);
     }
     listenCrossTab(onMutation) {
-        if (!this.broadcastChannel)
-            return () => { };
-        const handler = (event) => {
-            if (event.data && event.data.type === 'LOCAL_MUTATION') {
-                onMutation(event.data.path, event.data.action, event.data.data);
-            }
-        };
-        this.broadcastChannel.addEventListener('message', handler);
-        return () => {
-            this.broadcastChannel.removeEventListener('message', handler);
-        };
+        return this.crossTabChannel.onMutation(onMutation);
     }
     async syncOfflineMutations() {
         await this.mutationQueue.syncQueue();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nexabase-console",
-  "version": "2.1.7",
+  "version": "2.1.9",
   "description": "SDK Client resmi untuk NexaBase: Platform Sinkronisasi NoSQL, Realtime, File Storage, & Autentikasi Offline-First.",
   "main": "dist/index.cjs",
   "module": "dist/index.js",