taon 21.0.53 → 21.0.55

package/lib-prod/realtime/realtime-strategy/realtime-strategy-mock.js

@@ -1,262 +1,289 @@
-import { RealtimeStrategy } from "./realtime-strategy";
-import { Symbols__NS__REALTIME } from "../../symbols";
+import { RealtimeStrategy } from './realtime-strategy';
+import { Symbols__NS__REALTIME } from '../../symbols';
+//#endregion
+//#region mock server
 class MockServer {
-  //#region constructor
-  constructor(url) {
-    this.url = url;
-    MockServer.serverByUrl.set(url, this);
-  }
-  static serverByUrl = /* @__PURE__ */ new Map();
-  static from(url) {
-    if (!MockServer.serverByUrl.has(url)) {
-      MockServer.serverByUrl.set(url, new MockServer(url));
+    static { this.serverByUrl = new Map(); }
+    static from(url) {
+        if (!MockServer.serverByUrl.has(url)) {
+            MockServer.serverByUrl.set(url, new MockServer(url));
+        }
+        return MockServer.serverByUrl.get(url);
+    }
+    get allServers() {
+        return Array.from(MockServer.serverByUrl.values());
+    }
+    //#region constructor
+    constructor(url) {
+        this.url = url;
+        this.namespacesByName = new Map();
+        MockServer.serverByUrl.set(url, this);
+    }
+    //#endregion
+    //#region of
+    of(namespace) {
+        if (!this.namespacesByName.has(namespace)) {
+            this.namespacesByName.set(namespace, new MockNamespace(namespace, this));
+        }
+        return this.namespacesByName.get(namespace);
     }
-    return MockServer.serverByUrl.get(url);
-  }
-  get allServers() {
-    return Array.from(MockServer.serverByUrl.values());
-  }
-  namespacesByName = /* @__PURE__ */ new Map();
-  //#endregion
-  //#region of
-  of(namespace) {
-    if (!this.namespacesByName.has(namespace)) {
-      this.namespacesByName.set(namespace, new MockNamespace(namespace, this));
+    //#endregion
+    //#region path
+    path() {
+        return this.url;
     }
-    return this.namespacesByName.get(namespace);
-  }
-  //#endregion
-  //#region path
-  path() {
-    return this.url;
-  }
-  //#endregion
 }
+//#endregion
+//#region mock namespace
 class MockNamespace {
-  //#region constructor
-  constructor(name, server) {
-    this.name = name;
-    this.server = server;
-  }
-  /**
-   * All sockets connected to this namespace
-   */
-  allSocketsForNamespace = /* @__PURE__ */ new Set();
-  /**
-   * Rooms and their sockets
-   */
-  socketByRoomName = {};
-  /**
-   * Event handlers for this namespace
-   */
-  namespaceEventHandlers = {};
-  //#endregion
-  //#region on
-  on(eventName, handler) {
-    if (!this.namespaceEventHandlers[eventName]) {
-      this.namespaceEventHandlers[eventName] = /* @__PURE__ */ new Set();
+    //#region constructor
+    constructor(
+    /**
+     * unique namespace name
+     */
+    name, server) {
+        this.name = name;
+        this.server = server;
+        /**
+         * All sockets connected to this namespace
+         */
+        this.allSocketsForNamespace = new Set();
+        /**
+         * Rooms and their sockets
+         */
+        this.socketByRoomName = {};
+        /**
+         * Event handlers for this namespace
+         */
+        this.namespaceEventHandlers = {};
+    }
+    //#endregion
+    //#region on
+    on(eventName, handler) {
+        // console.log(`ON EVNET event "${eventName}"`);
+        if (!this.namespaceEventHandlers[eventName]) {
+            this.namespaceEventHandlers[eventName] =
+                new Set();
+        }
+        if (!this.namespaceEventHandlers[eventName].has(handler)) {
+            this.namespaceEventHandlers[eventName].add(handler);
+        }
+        // QUICK_FIX Emit connection event for backend
+        // TODO make it in emit
+        if (eventName === 'connection') {
+            setTimeout(() => {
+                this.emit('connection', this);
+            });
+        }
+    }
+    //#endregion
+    //#region emit
+    emit(event, ...args) {
+        this.allSocketsForNamespace?.forEach(socket => {
+            socket.emit(event, ...args);
+        });
+    }
+    //#endregion
+    //#region connect
+    connect(socket) {
+        this.allSocketsForNamespace.add(socket);
+        socket.namespaceInstance = this;
+    }
+    //#endregion
+    //#region to
+    to(roomName) {
+        const socketsInRoom = this.socketByRoomName[roomName];
+        return new RoomEmitter(socketsInRoom, true);
     }
-    if (!this.namespaceEventHandlers[eventName].has(handler)) {
-      this.namespaceEventHandlers[eventName].add(handler);
+    //#endregion
+    //#region to room
+    in(roomName) {
+        const socketsInRoom = this.socketByRoomName[roomName];
+        return new RoomEmitter(socketsInRoom, false);
     }
-    if (eventName === "connection") {
-      setTimeout(() => {
-        this.emit("connection", this);
-      });
+    //#endregion
+    //#region join room
+    joinRoom(roomName, socket) {
+        if (!this.socketByRoomName[roomName]) {
+            this.socketByRoomName[roomName] = new Set();
+        }
+        this.socketByRoomName[roomName].add(socket);
+    }
+    //#endregion
+    //#region leave room
+    leaveRoom(roomName, socket) {
+        const roomSockets = this.socketByRoomName[roomName];
+        if (roomSockets) {
+            this.socketByRoomName[roomName].delete(socket);
+        }
     }
-  }
-  //#endregion
-  //#region emit
-  emit(event, ...args) {
-    this.allSocketsForNamespace?.forEach((socket) => {
-      socket.emit(event, ...args);
-    });
-  }
-  //#endregion
-  //#region connect
-  connect(socket) {
-    this.allSocketsForNamespace.add(socket);
-    socket.namespaceInstance = this;
-  }
-  //#endregion
-  //#region to
-  to(roomName) {
-    const socketsInRoom = this.socketByRoomName[roomName];
-    return new RoomEmitter(socketsInRoom, true);
-  }
-  //#endregion
-  //#region to room
-  in(roomName) {
-    const socketsInRoom = this.socketByRoomName[roomName];
-    return new RoomEmitter(socketsInRoom, false);
-  }
-  //#endregion
-  //#region join room
-  joinRoom(roomName, socket) {
-    if (!this.socketByRoomName[roomName]) {
-      this.socketByRoomName[roomName] = /* @__PURE__ */ new Set();
+    //#endregion
+    //#region nsp + name
+    get nsp() {
+        const self = this;
+        return {
+            get name() {
+                return self.name;
+            },
+        };
     }
-    this.socketByRoomName[roomName].add(socket);
-  }
-  //#endregion
-  //#region leave room
-  leaveRoom(roomName, socket) {
-    const roomSockets = this.socketByRoomName[roomName];
-    if (roomSockets) {
-      this.socketByRoomName[roomName].delete(socket);
+    //#endregion
+    path() {
+        return this.name;
     }
-  }
-  //#endregion
-  //#region nsp + name
-  get nsp() {
-    const self = this;
-    return {
-      get name() {
-        return self.name;
-      }
-    };
-  }
-  //#endregion
-  path() {
-    return this.name;
-  }
 }
+//#endregion
+//#region room emitter
 class RoomEmitter {
-  //#region constructor
-  constructor(sockets, includeSender = false, sender = null) {
-    this.sockets = sockets;
-    this.includeSender = includeSender;
-    this.sender = sender;
-  }
-  //#endregion
-  //#region emit in room
-  emit(event, ...args) {
-    this.sockets?.forEach((socket) => {
-      if (this.includeSender || socket !== this.sender) {
-        socket.emit(event, ...args);
-      }
-    });
-  }
-  //#endregion
+    //#region constructor
+    constructor(sockets, includeSender = false, sender = null) {
+        this.sockets = sockets;
+        this.includeSender = includeSender;
+        this.sender = sender;
+    }
+    //#endregion
+    //#region emit in room
+    emit(event, ...args) {
+        // console.log(
+        //   `emit room emiter ${event} ,  this.sockets ${this.sockets.length}`,
+        // );
+        this.sockets?.forEach(socket => {
+            // console.log(`emit event ${event} to socket ${socket.id}`);
+            if (this.includeSender || socket !== this.sender) {
+                socket.emit(event, ...args);
+            }
+        });
+    }
 }
+//#endregion
+//#region mock socket
 class MockSocket {
-  //#region constructor
-  constructor(url, opts) {
-    this.url = url;
-    const [baseUrl, namespace] = [url, opts.path || "/"];
-    const namespaceName = namespace || "/";
-    const server = MockServer.from(url);
-    const ns = server.of(namespaceName);
-    ns.connect(this);
-  }
-  namespaceInstance;
-  socketEventHandlers = {};
-  get id() {
-    return this.nsp.name;
-  }
-  //#endregion
-  //#region nsp + name
-  get nsp() {
-    const self = this;
-    return {
-      get name() {
-        return self.namespaceInstance?.name;
-      }
-    };
-  }
-  //#endregion
-  //#region path
-  path() {
-    return this.namespaceInstance?.name;
-  }
-  //#endregion
-  //#region on
-  on(eventName, handler) {
-    if (!this.socketEventHandlers[eventName]) {
-      this.socketEventHandlers[eventName] = /* @__PURE__ */ new Set();
+    get id() {
+        return this.nsp.name;
+    }
+    //#region constructor
+    constructor(url, opts) {
+        this.url = url;
+        this.socketEventHandlers = {};
+        // @ts-ignore
+        const [baseUrl, namespace] = [url, opts.path || '/'];
+        // console.log({ url, baseUrl, namespace });
+        const namespaceName = namespace || '/';
+        // Look up the server instance from the registry
+        const server = MockServer.from(url);
+        const ns = server.of(namespaceName);
+        ns.connect(this);
+    }
+    //#endregion
+    //#region nsp + name
+    get nsp() {
+        const self = this;
+        return {
+            get name() {
+                return self.namespaceInstance?.name;
+            },
+        };
     }
-    this.socketEventHandlers[eventName].add(handler);
-    if (eventName === "connect") {
-      setTimeout(() => {
-        this.emit("connect");
-      });
+    //#endregion
+    //#region path
+    path() {
+        return this.namespaceInstance?.name;
     }
-  }
-  //#endregion
-  //#region emit
-  emit(eventName, ...args) {
-    eventName = eventName || "";
-    if (eventName.includes(`:${Symbols__NS__REALTIME.KEYroomSubscribe}`)) {
-      const room = args[0];
-      this.join(room);
-    } else if (eventName.includes(`:${Symbols__NS__REALTIME.KEYroomUnsubscribe}`)) {
-      const room = args[0];
-      this.leave(room);
-    } else {
-      if (this.namespaceInstance) {
-        const namespaceEventHandlers = this.namespaceInstance.namespaceEventHandlers[eventName] || [];
-        for (const namespaceEventHandler of namespaceEventHandlers) {
-          if (namespaceEventHandler) {
-            namespaceEventHandler(...args);
-          }
+    //#endregion
+    //#region on
+    on(eventName, handler) {
+        if (!this.socketEventHandlers[eventName]) {
+            this.socketEventHandlers[eventName] =
+                new Set();
         }
-        const allSocketsForNamespaceExceptCurrent = Array.from(
-          this.namespaceInstance.allSocketsForNamespace.values()
-        ).filter((socket) => socket !== this);
-        for (const socket of allSocketsForNamespaceExceptCurrent) {
-          const socketEventHandlers2 = socket.socketEventHandlers[eventName];
-          for (const socketEventHandler of socketEventHandlers2) {
-            if (socketEventHandler) {
-              socketEventHandler(...args);
-            }
-          }
+        this.socketEventHandlers[eventName].add(handler);
+        // QUICK_FIX client initing itself
+        if (eventName === 'connect') {
+            setTimeout(() => {
+                this.emit('connect');
+                // this.namespaceInstance.emit('connection', this); @UNCOMMNENT
+            });
+        }
+    }
+    //#endregion
+    //#region emit
+    emit(eventName, ...args) {
+        eventName = eventName || '';
+        if (eventName.includes(`:${Symbols__NS__REALTIME.KEYroomSubscribe}`)) {
+            const room = args[0];
+            this.join(room);
         }
-        const socketEventHandlers = this.socketEventHandlers[eventName] || [];
-        for (const clientHandler of socketEventHandlers) {
-          if (clientHandler) {
-            clientHandler(...args);
-          }
+        else if (eventName.includes(`:${Symbols__NS__REALTIME.KEYroomUnsubscribe}`)) {
+            const room = args[0];
+            this.leave(room);
         }
-      }
+        else {
+            // console.log('try to emit event (to server)', event);
+            if (this.namespaceInstance) {
+                const namespaceEventHandlers = this.namespaceInstance.namespaceEventHandlers[eventName] || [];
+                // emit to namespace events
+                for (const namespaceEventHandler of namespaceEventHandlers) {
+                    if (namespaceEventHandler) {
+                        namespaceEventHandler(...args);
+                    }
+                }
+                const allSocketsForNamespaceExceptCurrent = Array.from(this.namespaceInstance.allSocketsForNamespace.values()).filter(socket => socket !== this);
+                // emit to all sockets in namespace
+                for (const socket of allSocketsForNamespaceExceptCurrent) {
+                    const socketEventHandlers = socket.socketEventHandlers[eventName];
+                    for (const socketEventHandler of socketEventHandlers) {
+                        if (socketEventHandler) {
+                            socketEventHandler(...args);
+                        }
+                    }
+                }
+                // Emit to current socket
+                const socketEventHandlers = this.socketEventHandlers[eventName] || [];
+                for (const clientHandler of socketEventHandlers) {
+                    if (clientHandler) {
+                        clientHandler(...args);
+                    }
+                }
+            }
+        }
+    }
+    //#endregion
+    //#region join room
+    join(roomName) {
+        this.namespaceInstance.joinRoom(roomName, this);
+    }
+    //#endregion
+    //#region leave room
+    leave(roomName) {
+        this.namespaceInstance.leaveRoom(roomName, this);
     }
-  }
-  //#endregion
-  //#region join room
-  join(roomName) {
-    this.namespaceInstance.joinRoom(roomName, this);
-  }
-  //#endregion
-  //#region leave room
-  leave(roomName) {
-    this.namespaceInstance.leaveRoom(roomName, this);
-  }
-  //#endregion
 }
-class RealtimeStrategyMock extends RealtimeStrategy {
-  //#endregion
-  //#region constructor
-  constructor(ctx) {
-    super(ctx);
-    this.ctx = ctx;
-  }
-  //#region toString
-  toString() {
-    return "mock";
-  }
-  //#endregion
-  //#region server & io
-  ioServer(url, opt) {
-    const server = MockServer.from(url || this.ctx.uriOrigin);
-    return server.of(opt?.path || "/");
-  }
-  get ioClient() {
-    const clientIo = (uri, opts) => {
-      return new MockSocket(uri || this.ctx.uriOrigin, opts);
-    };
-    return clientIo;
-  }
-  //#endregion
+//#endregion
+/**
+ * Purpose:
+ * - browser-browser communication mock (in websql mode)
+ */
+export class RealtimeStrategyMock extends RealtimeStrategy {
+    //#region toString
+    toString() {
+        return 'mock';
+    }
+    //#endregion
+    //#region constructor
+    constructor(ctx) {
+        super(ctx);
+        this.ctx = ctx;
+    }
+    //#endregion
+    //#region server & io
+    ioServer(url, opt) {
+        const server = MockServer.from(url || this.ctx.uriOrigin);
+        return server.of(opt?.path || '/');
+    }
+    get ioClient() {
+        const clientIo = (uri, opts) => {
+            return new MockSocket(uri || this.ctx.uriOrigin, opts);
+        };
+        return clientIo;
+    }
 }
-export {
-  RealtimeStrategyMock
-};

package/lib-prod/realtime/realtime-strategy/realtime-strategy-socket-io.js

@@ -1,21 +1,27 @@
-import { RealtimeStrategy } from "./realtime-strategy";
-import { Server } from "socket.io";
-import { io } from "socket.io-client";
-class RealtimeStrategySocketIO extends RealtimeStrategy {
-  constructor(ctx) {
-    super(ctx);
-    this.ctx = ctx;
-  }
-  toString() {
-    return "socket-io";
-  }
-  ioServer(...args) {
-    return new Server(...args);
-  }
-  get ioClient() {
-    return io;
-  }
+import { RealtimeStrategy } from './realtime-strategy';
+//#region @backend
+import { Server } from 'socket.io';
+//#endregion
+import { io } from 'socket.io-client';
+/**
+ * Purpose:
+ * - backend-browser communication
+ * - backend-backend communication
+ */
+export class RealtimeStrategySocketIO extends RealtimeStrategy {
+    toString() {
+        return 'socket-io';
+    }
+    constructor(ctx) {
+        super(ctx);
+        this.ctx = ctx;
+    }
+    ioServer(...args) {
+        //#region @backendFunc
+        return new Server(...args);
+        //#endregion
+    }
+    get ioClient() {
+        return io;
+    }
 }
-export {
-  RealtimeStrategySocketIO
-};

package/lib-prod/realtime/realtime-strategy/realtime-strategy.js

@@ -1,14 +1,11 @@
-class RealtimeStrategy {
-  constructor(ctx) {
-    this.ctx = ctx;
-  }
-  get ioClient() {
-    throw new Error("Not implemented");
-  }
-  ioServer(url, opt) {
-    throw new Error("Not implemented");
-  }
+export class RealtimeStrategy {
+    constructor(ctx) {
+        this.ctx = ctx;
+    }
+    get ioClient() {
+        throw new Error('Not implemented');
+    }
+    ioServer(url, opt) {
+        throw new Error('Not implemented');
+    }
 }
-export {
-  RealtimeStrategy
-};