taon 21.0.51 → 21.0.53

package/lib-prod/realtime/realtime-strategy/realtime-strategy-ipc.ts

@@ -1,344 +0,0 @@
-//#region imports
-/* */                                                    
-import type * as Electron from 'electron';
-import { ipcMain } from 'electron'; // @backend
-import { Server, ServerOptions } from 'socket.io';
-import type { io, ManagerOptions, SocketOptions } from 'socket.io-client';
-
-import { EndpointContext } from '../../endpoint-context';
-import { Symbols__NS__classMethodsNames, Symbols__NS__classNameStaticProperty, Symbols__NS__ctxInClassOrClassObj, Symbols__NS__fullClassNameStaticProperty, Symbols__NS__metadata, Symbols__NS__old, Symbols__NS__orignalClass, Symbols__NS__orignalClassClonesObj, Symbols__NS__REALTIME } from '../../symbols';
-import { RealtimeModels__NS__ChangeOption, RealtimeModels__NS__EventHandler, RealtimeModels__NS__SubsManagerOpt } from '../realtime.models';
-
-import { RealtimeStrategy } from './realtime-strategy';
-//#endregion
-
-//#region mock server ipc
-export class MockServerIpc {
-  static serverByContextName = new Map<string, MockServerIpc>();
-
-  static from(contextName: string): MockServerIpc {
-    if (!MockServerIpc.serverByContextName.has(contextName)) {
-      MockServerIpc.serverByContextName.set(
-        contextName,
-        new MockServerIpc(contextName),
-      );
-    }
-    return MockServerIpc.serverByContextName.get(contextName);
-  }
-
-  namespacesByName = new Map<string, MockNamespaceIpc>();
-
-  //#region constructor
-  constructor(public contextName: string) {
-    MockServerIpc.serverByContextName.set(contextName, this);
-  }
-  //#endregion
-
-  //#region of
-  of(namespace: string): MockNamespaceIpc {
-    if (!this.namespacesByName.has(namespace)) {
-      this.namespacesByName.set(
-        namespace,
-        new MockNamespaceIpc(namespace, this),
-      );
-    }
-    return this.namespacesByName.get(namespace);
-  }
-  //#endregion
-}
-//#endregion
-
-//#region mock namespace ipc
-export class MockNamespaceIpc {
-  //#region fields & getters
-  electronClients = new Set<Electron.WebContents>();
-  roomsByRoomName: {
-    [roomName: string]: Set<Electron.WebContents>;
-  } = {};
-
-  private namespaceEventHandlers: {
-    [eventName: string]: Set<RealtimeModels__NS__EventHandler>;
-  } = {};
-  //#endregion
-
-  //#region constructor
-  constructor(
-    /**
-     * Namespace name
-     */
-    public name: string,
-    public server: MockServerIpc,
-  ) {}
-  //#endregion
-
-  //#region on
-  on(eventName: string, callback: RealtimeModels__NS__EventHandler) {
-    //#region @backendFunc
-    const listenKey = `(${this.name}) "${eventName}"`;
-
-    if (!this.namespaceEventHandlers[eventName]) {
-      this.namespaceEventHandlers[eventName] = new Set();
-    }
-    this.namespaceEventHandlers[eventName].add(callback);
-
-    ipcMain.on(listenKey, (eventElectron, ...args) => {
-      this.electronClients.add(eventElectron.sender);
-
-      const connectionListener = `(${this.name}) "connection"`;
-      if (connectionListener === listenKey) {
-        callback(this, ...args);
-      } else {
-        if (eventName.includes(`:${Symbols__NS__REALTIME.KEYroomSubscribe}`)) {
-          const roomName = args[0];
-          this.join(eventElectron.sender, roomName);
-        } else if (
-          eventName.includes(`:${Symbols__NS__REALTIME.KEYroomUnsubscribe}`)
-        ) {
-          const roomName = args[0];
-          this.leave(eventElectron.sender, roomName);
-        } else {
-          callback(...args);
-        }
-      }
-    });
-    // this.emit(listenKey); // QUICK_FIX
-    //#endregion
-  }
-  //#endregion
-
-  //#region off
-  off(event: string, callback?: RealtimeModels__NS__EventHandler) {
-    //#region @backendFunc
-    if (!this.namespaceEventHandlers[event]) {
-      return;
-    }
-
-    if (callback) {
-      this.namespaceEventHandlers[event].delete(callback);
-    } else {
-      delete this.namespaceEventHandlers[event];
-    }
-    const removeKey = `(${this.name}) "${event}"`;
-    ipcMain.removeListener(removeKey, callback);
-    //#endregion
-  }
-  //#endregion
-
-  //#region emit
-  emit(eventName: string, ...args: any[]) {
-    //#region @backendFunc
-    const sendEventKey = `(${this.name}) "${eventName}"`;
-    for (const webContents of this.electronClients) {
-      webContents.send(sendEventKey, ...args);
-    }
-    // const allWindows = Electron.BrowserWindow.getAllWindows();
-    // allWindows.forEach((win, index) => {
-    //   win.webContents.send(sendEventKey, ...args);
-    // });
-    //#endregion
-  }
-  //#endregion
-
-  //#region to
-  to(roomName: string) {
-    const electronClientsInroom = this.roomsByRoomName[roomName];
-    return new RoomEmitterIpc(electronClientsInroom, this.name, true);
-  }
-  //#endregion
-
-  //#region in
-  in(roomName: string) {
-    const electronClientsInroom = this.roomsByRoomName[roomName];
-    return new RoomEmitterIpc(electronClientsInroom, this.name, false);
-  }
-  //#endregion
-
-  //#region join
-  join(webContents: Electron.WebContents, roomName: string) {
-    if (!this.roomsByRoomName[roomName]) {
-      this.roomsByRoomName[roomName] = new Set();
-    }
-    this.roomsByRoomName[roomName].add(webContents);
-  }
-  //#endregion
-
-  //#region leave
-  leave(webContents: Electron.WebContents, roomName: string) {
-    if (this.roomsByRoomName[roomName]) {
-      this.roomsByRoomName[roomName].delete(webContents);
-      if (this.roomsByRoomName[roomName].size === 0) {
-        delete this.roomsByRoomName[roomName];
-      }
-    }
-  }
-  //#endregion
-
-  //#region path
-  path() {
-    return this.name;
-  }
-  //#endregion
-
-  //#region get nsp
-  get nsp() {
-    const self = this;
-    return {
-      get name() {
-        return self.name;
-      },
-    };
-  }
-  //#endregion
-}
-
-//#endregion
-
-//#region room emitter ipc
-class RoomEmitterIpc {
-  //#region constructor
-  constructor(
-    private electronClients: Set<Electron.WebContents>,
-    /**
-     * namespace name
-     */
-    private name: string,
-    private includeSender: boolean = false,
-    private sender: MockSocketIpc = null, // TODO QUICK FIX how to include sender
-  ) {}
-  //#endregion
-
-  //#region emit in room
-  emit(eventName: string, ...args: any[]): void {
-    const emitEvent = `(${this.name}) "${eventName}"`;
-    this.electronClients?.forEach(webContents => {
-      webContents.send(emitEvent, ...args);
-    });
-  }
-  //#endregion
-}
-//#endregion
-
-//#region mock socket ipc
-export class MockSocketIpc {
-  //#region fields & getters
-
-  //#region fields & getters / ipc renderer
-/* */
-/* */
-  
-  //#endregion
-
-  //#region fields & getters / event handlers by name
-  private socketEventHandlers = {} as {
-    [eventName: string]: Set<RealtimeModels__NS__EventHandler>;
-  };
-  //#endregion
-
-  //#region fields & getters / name
-  get name() {
-    return this.namespaceName;
-  }
-  //#endregion
-
-  //#endregion
-
-  //#region constructor
-  /**
-   * @param namespaceName instead url for ipc
-   */
-  constructor(public namespaceName: string) {
-/* */
-/* */
-  
-  }
-  //#endregion
-
-  //#region on
-  on(eventName: string, callback: (event: any, ...args: any[]) => void) {
-/* */
-/* */
-/* */
-/* */
-/* */
-/* */
-/* */
-/* */
-/* */
-/* */
-/* */
-/* */
-/* */
-/* */
-/* */
-  
-  }
-  //#endregion
-
-  //#region off
-  off(event: string, callback?: (event: any, ...args: any[]) => void) {
-/* */
-/* */
-/* */
-/* */
-/* */
-/* */
-/* */
-/* */
-/* */
-/* */
-/* */
-/* */
-/* */
-/* */
-/* */
-  
-  }
-  //#endregion
-
-  //#region emit
-  emit(event: string, ...args: any[]) {
-/* */
-/* */
-/* */
-  
-  }
-  //#endregion
-}
-//#endregion
-
-/**
- * Purpose:
- * - backend-browser communication between 2 processes in electron mode
- */
-export class RealtimeStrategyIpc extends RealtimeStrategy {
-  //#region to string
-  toString(): string {
-    return 'ipc';
-  }
-  //#endregion
-
-  //#region constructor
-  constructor(protected ctx: EndpointContext) {
-    super(ctx);
-  }
-  //#endregion
-
-  //#region server & io
-  ioServer(__: string, opt: ServerOptions) {
-    const namespace = opt?.path || '/';
-    const server = MockServerIpc.from(this.ctx.contextName);
-    return server.of(namespace) as any;
-  }
-
-  get ioClient() {
-    const clientIo = (
-      __: string,
-      opt?: Partial<ManagerOptions & SocketOptions>,
-    ): MockSocketIpc => {
-      const namespace = opt?.path || '/';
-      return new MockSocketIpc(namespace);
-    };
-    return clientIo as any;
-  }
-  //#endregion
-}

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

@@ -1,349 +0,0 @@
-//#region imports
-import type { EndpointContext } from '../../endpoint-context';
-import { RealtimeStrategy } from './realtime-strategy';
-import { Symbols__NS__classMethodsNames, Symbols__NS__classNameStaticProperty, Symbols__NS__ctxInClassOrClassObj, Symbols__NS__fullClassNameStaticProperty, Symbols__NS__metadata, Symbols__NS__old, Symbols__NS__orignalClass, Symbols__NS__orignalClassClonesObj, Symbols__NS__REALTIME } from '../../symbols';
-import { ManagerOptions, SocketOptions } from 'socket.io-client';
-import { RealtimeModels__NS__ChangeOption, RealtimeModels__NS__EventHandler, RealtimeModels__NS__SubsManagerOpt } from '../realtime.models';
-import { ServerOptions } from 'socket.io';
-//#endregion
-
-//#region mock server
-class MockServer {
-  static serverByUrl = new Map<string, MockServer>();
-  static from(url: string): MockServer {
-    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());
-  }
-
-  namespacesByName = new Map<string, MockNamespace>();
-
-  //#region constructor
-  constructor(public url: string) {
-    MockServer.serverByUrl.set(url, this);
-  }
-  //#endregion
-
-  //#region of
-  of(namespace: string): MockNamespace {
-    if (!this.namespacesByName.has(namespace)) {
-      this.namespacesByName.set(namespace, new MockNamespace(namespace, this));
-    }
-    return this.namespacesByName.get(namespace);
-  }
-  //#endregion
-
-  //#region path
-  path() {
-    return this.url;
-  }
-  //#endregion
-}
-//#endregion
-
-//#region mock namespace
-class MockNamespace {
-  /**
-   * All sockets connected to this namespace
-   */
-  public readonly allSocketsForNamespace = new Set<MockSocket>();
-  /**
-   * Rooms and their sockets
-   */
-  private socketByRoomName: {
-    [roomName: string]: Set<MockSocket>;
-  } = {};
-  /**
-   * Event handlers for this namespace
-   */
-  public namespaceEventHandlers: {
-    [eventName: string]: Set<RealtimeModels__NS__EventHandler>;
-  } = {};
-
-  //#region constructor
-  constructor(
-    /**
-     * unique namespace name
-     */
-    public name: string,
-    public server: MockServer,
-  ) {}
-  //#endregion
-
-  //#region on
-  on(eventName: string, handler: RealtimeModels__NS__EventHandler): void {
-    // console.log(`ON EVNET event "${eventName}"`);
-    if (!this.namespaceEventHandlers[eventName]) {
-      this.namespaceEventHandlers[eventName] =
-        new Set<RealtimeModels__NS__EventHandler>();
-    }
-
-    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: string, ...args: any[]): void {
-    this.allSocketsForNamespace?.forEach(socket => {
-      socket.emit(event, ...args);
-    });
-  }
-  //#endregion
-
-  //#region connect
-  connect(socket: MockSocket): void {
-    this.allSocketsForNamespace.add(socket);
-    socket.namespaceInstance = this;
-  }
-  //#endregion
-
-  //#region to
-  to(roomName: string): RoomEmitter {
-    const socketsInRoom = this.socketByRoomName[roomName];
-    return new RoomEmitter(socketsInRoom, true);
-  }
-  //#endregion
-
-  //#region to room
-  in(roomName: string): RoomEmitter {
-    const socketsInRoom = this.socketByRoomName[roomName];
-    return new RoomEmitter(socketsInRoom, false);
-  }
-  //#endregion
-
-  //#region join room
-  joinRoom(roomName: string, socket: MockSocket): void {
-    if (!this.socketByRoomName[roomName]) {
-      this.socketByRoomName[roomName] = new Set<MockSocket>();
-    }
-    this.socketByRoomName[roomName].add(socket);
-  }
-  //#endregion
-
-  //#region leave room
-  leaveRoom(roomName: string, socket: MockSocket): void {
-    const roomSockets = this.socketByRoomName[roomName];
-    if (roomSockets) {
-      this.socketByRoomName[roomName].delete(socket);
-    }
-  }
-  //#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(
-    private sockets: Set<MockSocket>,
-    private includeSender: boolean = false,
-    private sender: MockSocket = null, // TODO QUICK FIX how to include sender
-  ) {}
-  //#endregion
-
-  //#region emit in room
-  emit(event: string, ...args: any[]): void {
-    // 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
-}
-//#endregion
-
-//#region mock socket
-class MockSocket {
-  public namespaceInstance: MockNamespace;
-  private socketEventHandlers = {} as {
-    [eventName: string]: Set<RealtimeModels__NS__EventHandler>;
-  };
-  get id() {
-    return this.nsp.name;
-  }
-
-  //#region constructor
-  constructor(
-    public url: string,
-    opts?: Partial<ManagerOptions & SocketOptions>,
-  ) {
-    // @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;
-      },
-    };
-  }
-  //#endregion
-
-  //#region path
-  path() {
-    return this.namespaceInstance?.name;
-  }
-  //#endregion
-
-  //#region on
-  on(eventName: string, handler: RealtimeModels__NS__EventHandler): void {
-    if (!this.socketEventHandlers[eventName]) {
-      this.socketEventHandlers[eventName] =
-        new Set<RealtimeModels__NS__EventHandler>();
-    }
-    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: string, ...args: any[]): void {
-    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 {
-      // 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: string): void {
-    this.namespaceInstance.joinRoom(roomName, this);
-  }
-  //#endregion
-
-  //#region leave room
-  leave(roomName: string): void {
-    this.namespaceInstance.leaveRoom(roomName, this);
-  }
-  //#endregion
-}
-//#endregion
-
-/**
- * Purpose:
- * - browser-browser communication mock (in websql mode)
- */
-export class RealtimeStrategyMock extends RealtimeStrategy {
-  //#region toString
-  toString(): string {
-    return 'mock';
-  }
-  //#endregion
-
-  //#region constructor
-  constructor(protected ctx: EndpointContext) {
-    super(ctx);
-  }
-  //#endregion
-
-  //#region server & io
-  ioServer(url: string, opt: ServerOptions) {
-    const server = MockServer.from(url || this.ctx.uriOrigin);
-    return server.of(opt?.path || '/') as any;
-  }
-
-  get ioClient() {
-    const clientIo = (
-      uri: string,
-      opts?: Partial<ManagerOptions & SocketOptions>,
-    ): MockSocket => {
-      return new MockSocket(uri || this.ctx.uriOrigin, opts as any);
-    };
-    return clientIo as any;
-  }
-  //#endregion
-}

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

@@ -1,30 +0,0 @@
-import { EndpointContext } from '../../endpoint-context';
-import { RealtimeStrategy } from './realtime-strategy';
-//#region @backend
-import { Server, ServerOptions } from 'socket.io';
-//#endregion
-import { io, ManagerOptions, Socket, SocketOptions } from 'socket.io-client';
-
-/**
- * Purpose:
- * - backend-browser communication
- * - backend-backend communication
- */
-export class RealtimeStrategySocketIO extends RealtimeStrategy {
-  toString(): string {
-    return 'socket-io';
-  }
-  constructor(protected ctx: EndpointContext) {
-    super(ctx);
-  }
-
-  ioServer(...args) {
-    //#region @backendFunc
-    return new Server(...args);
-    //#endregion
-  }
-
-  get ioClient() {
-    return io;
-  }
-}