taon 0.0.0 → 18.0.12

package/websql/esm2022/lib/realtime/realtime-core.mjs

@@ -0,0 +1,54 @@
+import { RealtimeClient } from './realtime-client';
+import { RealtimeServer } from './realtime-server';
+import { RealtimeStrategyIpc, RealtimeStrategyMock, RealtimeStrategySocketIO, } from './realtime-strategy'; /* */
+import { Helpers } from 'tnp-core/websql';
+/**
+ * Realtime class
+ * - mock (when browser-browser)
+ * - sockets (from socket io when backend-browser)
+ * - ipc (when electron is used or between processes)
+ * - webworker (when webworker is used in browser or nodejs)
+ */
+export class RealtimeCore {
+    constructor(ctx) {
+        this.ctx = ctx;
+        this.allHttpMethods = [
+            'GET',
+            'POST',
+            'PUT',
+            'DELETE',
+            'PATCH',
+            'OPTIONS',
+            'HEAD',
+        ];
+        this.strategy = this.resolveStrategy();
+        ctx.logFramework &&
+            console.log(`[taon] realtime strategy: ${this.strategy}`);
+        this.client = new RealtimeClient(this);
+        this.server = new RealtimeServer(this);
+    }
+    resolveStrategy() {
+        if (this.ctx.mode === 'backend-frontend(websql)') {
+            return new RealtimeStrategyMock(this.ctx);
+        }
+        if (this.ctx.mode === 'backend-frontend(ipc-electron)') {
+            return new RealtimeStrategyIpc(this.ctx);
+        }
+        return new RealtimeStrategySocketIO(this.ctx);
+    }
+    pathFor(namespace) {
+        const uri = this.ctx.uri;
+        let nsp = namespace ? namespace : '';
+        nsp = nsp === '/' ? '' : nsp;
+        const pathname = uri.pathname !== '/' ? uri.pathname : '';
+        let prefix = `taonContext-`;
+        if (Helpers.isElectron) {
+            prefix = ``;
+        }
+        const href = `${uri.origin}${pathname}/${prefix}${nsp}`;
+        return new URL(href);
+    }
+}
+;
+({}); // @--end-of-file-for-module=taon lib/realtime/realtime-core.ts
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmVhbHRpbWUtY29yZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3RtcC1saWJzLWZvci1kaXN0LXdlYnNxbC90YW9uL3Byb2plY3RzL3Rhb24vc3JjL2xpYi9yZWFsdGltZS9yZWFsdGltZS1jb3JlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUtBLE9BQU8sRUFBRSxjQUFjLEVBQUUsTUFBTSxtQkFBbUIsQ0FBQztBQUNuRCxPQUFPLEVBQUUsY0FBYyxFQUFFLE1BQU0sbUJBQW1CLENBQUM7QUFFbkQsT0FBTyxFQUFJLG1CQUFtQixFQUFJLG9CQUFvQixFQUFJLHdCQUF3QixHQUFHLE1BQU0scUJBQXFCLENBQUMsQ0FBQSxLQUFLO0FBT3RILE9BQU8sRUFBRSxPQUFPLEVBQUUsTUFBTSxpQkFBaUIsQ0FBQztBQUcxQzs7Ozs7O0dBTUc7QUFDSCxNQUFNLE9BQU8sWUFBWTtJQXNDdkIsWUFBbUIsR0FBb0I7UUFBcEIsUUFBRyxHQUFILEdBQUcsQ0FBaUI7UUFwQzlCLG1CQUFjLEdBQUc7WUFDeEIsS0FBSztZQUNMLE1BQU07WUFDTixLQUFLO1lBQ0wsUUFBUTtZQUNSLE9BQU87WUFDUCxTQUFTO1lBQ1QsTUFBTTtTQUNQLENBQUM7UUE2QkEsSUFBSSxDQUFDLFFBQVEsR0FBRyxJQUFJLENBQUMsZUFBZSxFQUFFLENBQUM7UUFDdkMsR0FBRyxDQUFDLFlBQVk7WUFDZCxPQUFPLENBQUMsR0FBRyxDQUFDLDZCQUE2QixJQUFJLENBQUMsUUFBUSxFQUFFLENBQUMsQ0FBQztRQUM1RCxJQUFJLENBQUMsTUFBTSxHQUFHLElBQUksY0FBYyxDQUFDLElBQUksQ0FBQyxDQUFDO1FBQ3ZDLElBQUksQ0FBQyxNQUFNLEdBQUcsSUFBSSxjQUFjLENBQUMsSUFBSSxDQUFDLENBQUM7SUFDekMsQ0FBQztJQUlPLGVBQWU7UUFDckIsSUFBSSxJQUFJLENBQUMsR0FBRyxDQUFDLElBQUksS0FBSywwQkFBMEIsRUFBRSxDQUFDO1lBQ2pELE9BQU8sSUFBSSxvQkFBb0IsQ0FBQyxJQUFJLENBQUMsR0FBRyxDQUFDLENBQUM7UUFDNUMsQ0FBQztRQUNELElBQUksSUFBSSxDQUFDLEdBQUcsQ0FBQyxJQUFJLEtBQUssZ0NBQWdDLEVBQUUsQ0FBQztZQUN2RCxPQUFPLElBQUksbUJBQW1CLENBQUMsSUFBSSxDQUFDLEdBQUcsQ0FBQyxDQUFDO1FBQzNDLENBQUM7UUFPRCxPQUFPLElBQUksd0JBQXdCLENBQUMsSUFBSSxDQUFDLEdBQUcsQ0FBQyxDQUFDO0lBQ2hELENBQUM7SUFJTSxPQUFPLENBQUMsU0FBa0I7UUFDL0IsTUFBTSxHQUFHLEdBQUcsSUFBSSxDQUFDLEdBQUcsQ0FBQyxHQUFHLENBQUM7UUFDekIsSUFBSSxHQUFHLEdBQUcsU0FBUyxDQUFDLENBQUMsQ0FBQyxTQUFTLENBQUMsQ0FBQyxDQUFDLEVBQUUsQ0FBQztRQUNyQyxHQUFHLEdBQUcsR0FBRyxLQUFLLEdBQUcsQ0FBQyxDQUFDLENBQUMsRUFBRSxDQUFDLENBQUMsQ0FBQyxHQUFHLENBQUM7UUFDN0IsTUFBTSxRQUFRLEdBQUcsR0FBRyxDQUFDLFFBQVEsS0FBSyxHQUFHLENBQUMsQ0FBQyxDQUFDLEdBQUcsQ0FBQyxRQUFRLENBQUMsQ0FBQyxDQUFDLEVBQUUsQ0FBQztRQUMxRCxJQUFJLE1BQU0sR0FBRyxjQUFjLENBQUM7UUFDNUIsSUFBSSxPQUFPLENBQUMsVUFBVSxFQUFFLENBQUM7WUFDdkIsTUFBTSxHQUFHLEVBQUUsQ0FBQztRQUNkLENBQUM7UUFDRCxNQUFNLElBQUksR0FBRyxHQUFHLEdBQUcsQ0FBQyxNQUFNLEdBQUcsUUFBUSxJQUFJLE1BQU0sR0FBRyxHQUFHLEVBQUUsQ0FBQztRQUV4RCxPQUFPLElBQUksR0FBRyxDQUFDLElBQUksQ0FBUSxDQUFDO0lBQzlCLENBQUM7Q0FFRjtBQUVBLENBQUM7QUFBQSxDQUFDLEVBQUUsQ0FBQyxDQUFDLENBQUMsK0RBQStEIiwic291cmNlc0NvbnRlbnQiOlsiXG5cblxuaW1wb3J0IHsgU29ja2V0IGFzIFNvY2tldENsaWVudCB9IGZyb20gJ3NvY2tldC5pby1jbGllbnQnO1xuaW1wb3J0IHR5cGUgeyBFbmRwb2ludENvbnRleHQgfSBmcm9tICcuLi9lbmRwb2ludC1jb250ZXh0JztcbmltcG9ydCB7IFJlYWx0aW1lQ2xpZW50IH0gZnJvbSAnLi9yZWFsdGltZS1jbGllbnQnO1xuaW1wb3J0IHsgUmVhbHRpbWVTZXJ2ZXIgfSBmcm9tICcuL3JlYWx0aW1lLXNlcnZlcic7XG5pbXBvcnQgdHlwZSB7IFJlYWx0aW1lU3RyYXRlZ3kgfSBmcm9tICcuL3JlYWx0aW1lLXN0cmF0ZWd5JztcbmltcG9ydCB7ICAgUmVhbHRpbWVTdHJhdGVneUlwYywgICBSZWFsdGltZVN0cmF0ZWd5TW9jaywgICBSZWFsdGltZVN0cmF0ZWd5U29ja2V0SU8sIH0gZnJvbSAnLi9yZWFsdGltZS1zdHJhdGVneSc7LyogKi9cbi8qICovXG4vKiAqL1xuLyogKi9cblxuaW1wb3J0IHsgRGVmYXVsdEV2ZW50c01hcCB9IGZyb20gJ3NvY2tldC5pby9kaXN0L3R5cGVkLWV2ZW50cyc7XG5pbXBvcnQgeyBTZXJ2ZXIgfSBmcm9tICdzb2NrZXQuaW8nO1xuaW1wb3J0IHsgSGVscGVycyB9IGZyb20gJ3RucC1jb3JlL3dlYnNxbCc7XG5cblxuLyoqXG4gKiBSZWFsdGltZSBjbGFzc1xuICogLSBtb2NrICh3aGVuIGJyb3dzZXItYnJvd3NlcilcbiAqIC0gc29ja2V0cyAoZnJvbSBzb2NrZXQgaW8gd2hlbiBiYWNrZW5kLWJyb3dzZXIpXG4gKiAtIGlwYyAod2hlbiBlbGVjdHJvbiBpcyB1c2VkIG9yIGJldHdlZW4gcHJvY2Vzc2VzKVxuICogLSB3ZWJ3b3JrZXIgKHdoZW4gd2Vid29ya2VyIGlzIHVzZWQgaW4gYnJvd3NlciBvciBub2RlanMpXG4gKi9cbmV4cG9ydCBjbGFzcyBSZWFsdGltZUNvcmUge1xuXG4gIHJlYWRvbmx5IGFsbEh0dHBNZXRob2RzID0gW1xuICAgICdHRVQnLFxuICAgICdQT1NUJyxcbiAgICAnUFVUJyxcbiAgICAnREVMRVRFJyxcbiAgICAnUEFUQ0gnLFxuICAgICdPUFRJT05TJyxcbiAgICAnSEVBRCcsXG4gIF07XG4gIHB1YmxpYyByZWFkb25seSBjbGllbnQ6IFJlYWx0aW1lQ2xpZW50O1xuICBwdWJsaWMgcmVhZG9ubHkgc2VydmVyOiBSZWFsdGltZVNlcnZlcjtcbiAgcHVibGljIHJlYWRvbmx5IHN0cmF0ZWd5OiBSZWFsdGltZVN0cmF0ZWd5O1xuICAvKipcbiAgICogZ2xvYmFsIEZFIHNvY2tldFxuICAgKi9cbiAgcHVibGljIEZFOiBTb2NrZXRDbGllbnQ8RGVmYXVsdEV2ZW50c01hcCwgRGVmYXVsdEV2ZW50c01hcD47XG4gIC8qKlxuICAgKiBzb2NrZXQgZm9yIG5hbWVzcGFjZXMgYW5kIHJvb21zXG4gICAqL1xuICBwdWJsaWMgRkVfUkVBTFRJTUU6IFNvY2tldENsaWVudDxEZWZhdWx0RXZlbnRzTWFwLCBEZWZhdWx0RXZlbnRzTWFwPjtcbiAgLyoqXG4gICAqIGdsb2JhbCBCRSBzb2NrZXRcbiAgICovXG4gIHB1YmxpYyBCRTogU2VydmVyPERlZmF1bHRFdmVudHNNYXAsIERlZmF1bHRFdmVudHNNYXAsIERlZmF1bHRFdmVudHNNYXAsIGFueT47XG4gIC8qKlxuICAgKiBzb2NrZXQgZm9yIG5hbWVzcGFjZXMgYW5kIHJvb21zXG4gICAqL1xuICBwdWJsaWMgQkVfUkVBTFRJTUU6IFNlcnZlcjxcbiAgICBEZWZhdWx0RXZlbnRzTWFwLFxuICAgIERlZmF1bHRFdmVudHNNYXAsXG4gICAgRGVmYXVsdEV2ZW50c01hcCxcbiAgICBhbnlcbiAgPjtcblxuXG5cbiAgY29uc3RydWN0b3IocHVibGljIGN0eDogRW5kcG9pbnRDb250ZXh0KSB7XG4gICAgdGhpcy5zdHJhdGVneSA9IHRoaXMucmVzb2x2ZVN0cmF0ZWd5KCk7XG4gICAgY3R4LmxvZ0ZyYW1ld29yayAmJlxuICAgICAgY29uc29sZS5sb2coYFt0YW9uXSByZWFsdGltZSBzdHJhdGVneTogJHt0aGlzLnN0cmF0ZWd5fWApO1xuICAgIHRoaXMuY2xpZW50ID0gbmV3IFJlYWx0aW1lQ2xpZW50KHRoaXMpO1xuICAgIHRoaXMuc2VydmVyID0gbmV3IFJlYWx0aW1lU2VydmVyKHRoaXMpO1xuICB9XG5cblxuXG4gIHByaXZhdGUgcmVzb2x2ZVN0cmF0ZWd5KCk6IFJlYWx0aW1lU3RyYXRlZ3kge1xuICAgIGlmICh0aGlzLmN0eC5tb2RlID09PSAnYmFja2VuZC1mcm9udGVuZCh3ZWJzcWwpJykge1xuICAgICAgcmV0dXJuIG5ldyBSZWFsdGltZVN0cmF0ZWd5TW9jayh0aGlzLmN0eCk7XG4gICAgfVxuICAgIGlmICh0aGlzLmN0eC5tb2RlID09PSAnYmFja2VuZC1mcm9udGVuZChpcGMtZWxlY3Ryb24pJykge1xuICAgICAgcmV0dXJuIG5ldyBSZWFsdGltZVN0cmF0ZWd5SXBjKHRoaXMuY3R4KTtcbiAgICB9XG5cblxuXG5cblxuXG4gICAgcmV0dXJuIG5ldyBSZWFsdGltZVN0cmF0ZWd5U29ja2V0SU8odGhpcy5jdHgpO1xuICB9XG5cblxuXG4gIHB1YmxpYyBwYXRoRm9yKG5hbWVzcGFjZT86IHN0cmluZykge1xuICAgIGNvbnN0IHVyaSA9IHRoaXMuY3R4LnVyaTtcbiAgICBsZXQgbnNwID0gbmFtZXNwYWNlID8gbmFtZXNwYWNlIDogJyc7XG4gICAgbnNwID0gbnNwID09PSAnLycgPyAnJyA6IG5zcDtcbiAgICBjb25zdCBwYXRobmFtZSA9IHVyaS5wYXRobmFtZSAhPT0gJy8nID8gdXJpLnBhdGhuYW1lIDogJyc7XG4gICAgbGV0IHByZWZpeCA9IGB0YW9uQ29udGV4dC1gO1xuICAgIGlmIChIZWxwZXJzLmlzRWxlY3Ryb24pIHtcbiAgICAgIHByZWZpeCA9IGBgO1xuICAgIH1cbiAgICBjb25zdCBocmVmID0gYCR7dXJpLm9yaWdpbn0ke3BhdGhuYW1lfS8ke3ByZWZpeH0ke25zcH1gO1xuXG4gICAgcmV0dXJuIG5ldyBVUkwoaHJlZikgYXMgVVJMO1xuICB9XG5cbn1cblxuIDsoe30pOyAvLyBALS1lbmQtb2YtZmlsZS1mb3ItbW9kdWxlPXRhb24gbGliL3JlYWx0aW1lL3JlYWx0aW1lLWNvcmUudHMiXX0=

package/websql/esm2022/lib/realtime/realtime-server.mjs

@@ -0,0 +1,158 @@
+import { Symbols } from '../symbols';
+import { Helpers, _ } from 'tnp-core/websql';
+import { ClassHelpers } from '../helpers/class-helpers';
+const SOCKET_EVENT_DEBOUNCE = 500;
+export class RealtimeServer {
+    constructor(core) {
+        this.core = core;
+        this.jobs = {};
+        this.core = core;
+        if (!core.ctx.disabledRealtime) {
+            this.init();
+        }
+    }
+    init() {
+        const nspPath = {
+            global: this.core.pathFor(),
+            realtime: this.core.pathFor(Symbols.REALTIME.NAMESPACE(this.core.ctx.contextName)),
+        };
+        this.core.BE = new this.core.strategy.Server(this.core.ctx.serverTcpUdp, {
+            path: nspPath.global.pathname,
+            cors: {
+                origin: this.core.ctx.config.frontendHost,
+                methods: this.core.allHttpMethods,
+            },
+        });
+        this.core.ctx.logRealtime &&
+            console.info(`CREATE GLOBAL NAMESPACE: '${this.core.BE.path()}' , path: '${nspPath.global.pathname}'`);
+        this.core.BE.on('connection', clientSocket => {
+            if (Helpers.isElectron) {
+                // @ts-ignore
+                this.core.BE.emit('connect'); // TODO QUICK_FIX
+            }
+            console.info(`client conected to namespace "${clientSocket.nsp?.name}",  host: ${this.core.ctx.host}`);
+        });
+        this.core.BE_REALTIME = new this.core.strategy.Server(this.core.ctx.serverTcpUdp, {
+            path: nspPath.realtime.pathname,
+            cors: {
+                origin: this.core.ctx.config.frontendHost,
+                methods: this.core.allHttpMethods,
+            },
+        });
+        this.core.ctx.logRealtime &&
+            console.info(`CREATE REALTIME NAMESPACE: '${this.core.BE_REALTIME.path()}' , path: '${nspPath.realtime.pathname}' `);
+        this.core.BE_REALTIME.on('connection', backendSocketForClient => {
+            console.info(`client conected to namespace "${backendSocketForClient.nsp?.name}",  host: ${this.core.ctx.host}`);
+            if (Helpers.isElectron) {
+                // @ts-ignore
+                backendSocketForClient = this.core.BE_REALTIME; // TODO QUICK_FIX
+                this.core.BE_REALTIME.emit('connect');
+            }
+            backendSocketForClient.on(Symbols.REALTIME.ROOM_NAME.SUBSCRIBE.CUSTOM(this.core.ctx.contextName), roomName => {
+                console.info(`Joining room ${roomName} in namespace  REALTIME` +
+                    ` host: ${this.core.ctx.contextName}/${this.core.ctx.host}`);
+                backendSocketForClient.join(roomName);
+            });
+            backendSocketForClient.on(Symbols.REALTIME.ROOM_NAME.SUBSCRIBE.ENTITY_UPDATE_EVENTS(this.core.ctx.contextName), roomName => {
+                console.info(`Joining room ${roomName} in namespace  REALTIME` +
+                    ` host: ${this.core.ctx.contextName}/${this.core.ctx.host}`);
+                backendSocketForClient.join(roomName);
+            });
+            backendSocketForClient.on(Symbols.REALTIME.ROOM_NAME.SUBSCRIBE.ENTITY_PROPERTY_UPDATE_EVENTS(this.core.ctx.contextName), roomName => {
+                console.info(`Joining room ${roomName} in namespace REALTIME ` +
+                    ` host: ${this.core.ctx.contextName}/${this.core.ctx.host}`);
+                backendSocketForClient.join(roomName);
+            });
+            backendSocketForClient.on(Symbols.REALTIME.ROOM_NAME.UNSUBSCRIBE.CUSTOM(this.core.ctx.contextName), roomName => {
+                console.info(`Leaving room ${roomName} in namespace  REALTIME` +
+                    ` host: ${this.core.ctx.contextName}/${this.core.ctx.host}`);
+                backendSocketForClient.leave(roomName);
+            });
+            backendSocketForClient.on(Symbols.REALTIME.ROOM_NAME.UNSUBSCRIBE.ENTITY_UPDATE_EVENTS(this.core.ctx.contextName), roomName => {
+                console.info(`Leaving room ${roomName} in namespace REALTIME ` +
+                    ` host: ${this.core.ctx.contextName}/${this.core.ctx.host}`);
+                backendSocketForClient.leave(roomName);
+            });
+            backendSocketForClient.on(Symbols.REALTIME.ROOM_NAME.UNSUBSCRIBE.ENTITY_PROPERTY_UPDATE_EVENTS(this.core.ctx.contextName), roomName => {
+                console.info(`Leaving room ${roomName} in namespace REALTIME ` +
+                    ` host: ${this.core.ctx.contextName}/${this.core.ctx.host}`);
+                backendSocketForClient.leave(roomName);
+            });
+        });
+    }
+    triggerChanges(entityObjOrClass, property, valueOfUniquPropery, customEvent, customEventData) {
+        let roomName;
+        if (this.core.ctx.disabledRealtime) {
+            return;
+        }
+        if (customEvent) {
+            roomName = Symbols.REALTIME.ROOM_NAME.CUSTOM(this.core.ctx.contextName, customEvent);
+        }
+        else {
+            let entityFn = entityObjOrClass;
+            const enittyIsObject = !_.isFunction(entityObjOrClass) && _.isObject(entityObjOrClass);
+            if (enittyIsObject) {
+                entityFn = ClassHelpers.getClassFnFromObject(entityObjOrClass);
+            }
+            const uniqueKey = ClassHelpers.getUniquKey(entityFn);
+            if (enittyIsObject) {
+                valueOfUniquPropery = entityObjOrClass[uniqueKey];
+            }
+            if (!valueOfUniquPropery) {
+                Helpers.error(`[Taon][Realtime] Entity without iD ! ${ClassHelpers.getName(entityFn)} `, true, true);
+                return;
+            }
+            roomName = _.isString(property)
+                ? Symbols.REALTIME.ROOM_NAME.UPDATE_ENTITY_PROPERTY(this.core.ctx.contextName, ClassHelpers.getName(entityFn), property, valueOfUniquPropery)
+                : Symbols.REALTIME.ROOM_NAME.UPDATE_ENTITY(this.core.ctx.contextName, ClassHelpers.getName(entityFn), valueOfUniquPropery);
+        }
+        const job = () => {
+            console.log(`Trigger realtime: ${this.core.ctx.contextName}/${roomName}`);
+            this.core.BE_REALTIME.in(roomName).emit(roomName, // roomName == eventName in room na
+            customEventData ? customEventData : '');
+        };
+        if (!_.isFunction(this.jobs[roomName])) {
+            this.jobs[roomName] = _.debounce(() => {
+                job();
+            }, SOCKET_EVENT_DEBOUNCE);
+        }
+        this.jobs[roomName]();
+    }
+    trigggerEntityChanges(entityObjOrClass, idToTrigger) {
+        if (this.core.ctx.disabledRealtime) {
+            const className = ClassHelpers.getName(entityObjOrClass);
+            console.warn(`[Taon][TrigggerEntityChanges] Entity "${className}' is not realtime`);
+            return;
+        }
+        this.triggerChanges(entityObjOrClass, void 0, idToTrigger);
+    }
+    trigggerEntityPropertyChanges(entityObjOrClass, property, idToTrigger) {
+        if (this.core.ctx.disabledRealtime) {
+            const className = ClassHelpers.getName(entityObjOrClass);
+            console.warn(`[Taon][TrigggerEntityPropertyChanges][property=${property}] Entity "${className}' is not realtime`);
+            return;
+        }
+        if (_.isArray(property)) {
+            property.forEach(propertyFromArr => {
+                this.triggerChanges(entityObjOrClass, propertyFromArr, idToTrigger);
+            });
+        }
+        else {
+            this.triggerChanges(entityObjOrClass, property, idToTrigger);
+        }
+    }
+    triggerCustomEvent(customEvent, dataToPush) {
+        this.triggerChanges(void 0, void 0, void 0, customEvent, dataToPush);
+    }
+    trigggerEntityTableChanges(entityClass) {
+        const className = ClassHelpers.getName(entityClass);
+        if (this.core.ctx.disabledRealtime) {
+            console.warn(`[Taon][TrigggerEntityTableChanges] Entity "${className}' is not realtime`);
+            return;
+        }
+        this.triggerChanges(entityClass, void 0, void 0, Symbols.REALTIME.TABLE_CHANGE(this.core.ctx.contextName, className));
+    }
+}
+;
+({}); // @--end-of-file-for-module=taon lib/realtime/realtime-server.ts
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"realtime-server.js","sourceRoot":"","sources":["../../../../../tmp-libs-for-dist-websql/taon/projects/taon/src/lib/realtime/realtime-server.ts"],"names":[],"mappings":"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","sourcesContent":["\n\n\nimport { Symbols } from '../symbols';\nimport { Helpers, _ } from 'tnp-core/websql';\nimport { RealtimeCore } from './realtime-core';\nimport { ClassHelpers } from '../helpers/class-helpers';\nimport type { BaseEntity } from '../base-classes/base-entity';\n\n\nconst SOCKET_EVENT_DEBOUNCE = 500;\n\nexport class RealtimeServer {\n  private jobs = {};\n  constructor(private core: RealtimeCore) {\n    this.core = core;\n    if (!core.ctx.disabledRealtime) {\n\n      this.init();\n\n    }\n  }\n\n\n  private init() {\n\n\n\n    const nspPath = {\n      global: this.core.pathFor(),\n      realtime: this.core.pathFor(\n        Symbols.REALTIME.NAMESPACE(this.core.ctx.contextName),\n      ),\n    };\n\n\n\n\n    this.core.BE = new this.core.strategy.Server(this.core.ctx.serverTcpUdp, {\n      path: nspPath.global.pathname,\n\n      cors: {\n        origin: this.core.ctx.config.frontendHost,\n        methods: this.core.allHttpMethods,\n      },\n    });\n\n    this.core.ctx.logRealtime &&\n      console.info(\n        `CREATE GLOBAL NAMESPACE: '${this.core.BE.path()}' , path: '${\n          nspPath.global.pathname\n        }'`,\n      );\n\n    this.core.BE.on('connection', clientSocket => {\n      if (Helpers.isElectron) {\n        // @ts-ignore\n        this.core.BE.emit('connect'); // TODO QUICK_FIX\n      }\n      console.info(\n        `client conected to namespace \"${clientSocket.nsp?.name}\",  host: ${this.core.ctx.host}`,\n      );\n    });\n\n\n\n\n    this.core.BE_REALTIME = new this.core.strategy.Server(\n      this.core.ctx.serverTcpUdp,\n      {\n        path: nspPath.realtime.pathname,\n        cors: {\n          origin: this.core.ctx.config.frontendHost,\n          methods: this.core.allHttpMethods,\n        },\n      },\n    );\n\n    this.core.ctx.logRealtime &&\n      console.info(\n        `CREATE REALTIME NAMESPACE: '${this.core.BE_REALTIME.path()}' , path: '${\n          nspPath.realtime.pathname\n        }' `,\n      );\n\n    this.core.BE_REALTIME.on('connection', backendSocketForClient => {\n      console.info(\n        `client conected to namespace \"${backendSocketForClient.nsp?.name}\",  host: ${this.core.ctx.host}`,\n      );\n\n      if (Helpers.isElectron) {\n        // @ts-ignore\n        backendSocketForClient = this.core.BE_REALTIME; // TODO QUICK_FIX\n        this.core.BE_REALTIME.emit('connect');\n      }\n\n      backendSocketForClient.on(\n        Symbols.REALTIME.ROOM_NAME.SUBSCRIBE.CUSTOM(this.core.ctx.contextName),\n        roomName => {\n          console.info(\n            `Joining room ${roomName} in namespace  REALTIME` +\n              ` host: ${this.core.ctx.contextName}/${this.core.ctx.host}`,\n          );\n          backendSocketForClient.join(roomName);\n        },\n      );\n\n      backendSocketForClient.on(\n        Symbols.REALTIME.ROOM_NAME.SUBSCRIBE.ENTITY_UPDATE_EVENTS(\n          this.core.ctx.contextName,\n        ),\n        roomName => {\n          console.info(\n            `Joining room ${roomName} in namespace  REALTIME` +\n              ` host: ${this.core.ctx.contextName}/${this.core.ctx.host}`,\n          );\n          backendSocketForClient.join(roomName);\n        },\n      );\n\n      backendSocketForClient.on(\n        Symbols.REALTIME.ROOM_NAME.SUBSCRIBE.ENTITY_PROPERTY_UPDATE_EVENTS(\n          this.core.ctx.contextName,\n        ),\n        roomName => {\n          console.info(\n            `Joining room ${roomName} in namespace REALTIME ` +\n              ` host: ${this.core.ctx.contextName}/${this.core.ctx.host}`,\n          );\n          backendSocketForClient.join(roomName);\n        },\n      );\n\n      backendSocketForClient.on(\n        Symbols.REALTIME.ROOM_NAME.UNSUBSCRIBE.CUSTOM(\n          this.core.ctx.contextName,\n        ),\n        roomName => {\n          console.info(\n            `Leaving room ${roomName} in namespace  REALTIME` +\n              ` host: ${this.core.ctx.contextName}/${this.core.ctx.host}`,\n          );\n          backendSocketForClient.leave(roomName);\n        },\n      );\n\n      backendSocketForClient.on(\n        Symbols.REALTIME.ROOM_NAME.UNSUBSCRIBE.ENTITY_UPDATE_EVENTS(\n          this.core.ctx.contextName,\n        ),\n        roomName => {\n          console.info(\n            `Leaving room ${roomName} in namespace REALTIME ` +\n              ` host: ${this.core.ctx.contextName}/${this.core.ctx.host}`,\n          );\n          backendSocketForClient.leave(roomName);\n        },\n      );\n\n      backendSocketForClient.on(\n        Symbols.REALTIME.ROOM_NAME.UNSUBSCRIBE.ENTITY_PROPERTY_UPDATE_EVENTS(\n          this.core.ctx.contextName,\n        ),\n        roomName => {\n          console.info(\n            `Leaving room ${roomName} in namespace REALTIME ` +\n              ` host: ${this.core.ctx.contextName}/${this.core.ctx.host}`,\n          );\n          backendSocketForClient.leave(roomName);\n        },\n      );\n    });\n\n\n\n\n  }\n\n\n\n\n  private triggerChanges(\n    entityObjOrClass: Function,\n    property?: string,\n    valueOfUniquPropery?: number | string,\n    customEvent?: string,\n    customEventData?: any,\n  ) {\n\n\n\n    let roomName: string;\n\n    if (this.core.ctx.disabledRealtime) {\n      return;\n    }\n\n    if (customEvent) {\n      roomName = Symbols.REALTIME.ROOM_NAME.CUSTOM(\n        this.core.ctx.contextName,\n        customEvent,\n      );\n    } else {\n      let entityFn = entityObjOrClass as Function;\n      const enittyIsObject =\n        !_.isFunction(entityObjOrClass) && _.isObject(entityObjOrClass);\n\n      if (enittyIsObject) {\n        entityFn = ClassHelpers.getClassFnFromObject(entityObjOrClass);\n      }\n\n      const uniqueKey = ClassHelpers.getUniquKey(entityFn);\n\n      if (enittyIsObject) {\n        valueOfUniquPropery = entityObjOrClass[uniqueKey];\n      }\n\n      if (!valueOfUniquPropery) {\n        Helpers.error(\n          `[Taon][Realtime] Entity without iD ! ${ClassHelpers.getName(\n            entityFn,\n          )} `,\n          true,\n          true,\n        );\n        return;\n      }\n\n      roomName = _.isString(property)\n        ? Symbols.REALTIME.ROOM_NAME.UPDATE_ENTITY_PROPERTY(\n            this.core.ctx.contextName,\n            ClassHelpers.getName(entityFn),\n            property,\n            valueOfUniquPropery,\n          )\n        : Symbols.REALTIME.ROOM_NAME.UPDATE_ENTITY(\n            this.core.ctx.contextName,\n            ClassHelpers.getName(entityFn),\n            valueOfUniquPropery,\n          );\n    }\n\n    const job = () => {\n      console.log(`Trigger realtime: ${this.core.ctx.contextName}/${roomName}`);\n      this.core.BE_REALTIME.in(roomName).emit(\n        roomName, // roomName == eventName in room na\n        customEventData ? customEventData : '',\n      );\n    };\n\n    if (!_.isFunction(this.jobs[roomName])) {\n      this.jobs[roomName] = _.debounce(() => {\n        job();\n      }, SOCKET_EVENT_DEBOUNCE);\n    }\n\n    this.jobs[roomName]();\n\n  }\n\n\n\n  public trigggerEntityChanges(\n    entityObjOrClass: Function,\n    idToTrigger?: number | string,\n  ) {\n    if (this.core.ctx.disabledRealtime) {\n      const className = ClassHelpers.getName(entityObjOrClass);\n\n      console.warn(\n        `[Taon][TrigggerEntityChanges] Entity \"${className}' is not realtime`,\n      );\n      return;\n    }\n    this.triggerChanges(entityObjOrClass as any, void 0, idToTrigger);\n  }\n\n\n\n  public trigggerEntityPropertyChanges<ENTITY extends BaseEntity>(\n    entityObjOrClass: new (...args) => ENTITY,\n    property: keyof ENTITY | (keyof ENTITY)[],\n    idToTrigger?: number | string,\n  ) {\n    if (this.core.ctx.disabledRealtime) {\n      const className = ClassHelpers.getName(entityObjOrClass);\n\n      console.warn(\n        `[Taon][TrigggerEntityPropertyChanges][property=${\n          property as string\n        }] Entity \"${className}' is not realtime`,\n      );\n      return;\n    }\n\n    if (_.isArray(property)) {\n      property.forEach(propertyFromArr => {\n        this.triggerChanges(\n          entityObjOrClass,\n          propertyFromArr as any,\n          idToTrigger,\n        );\n      });\n    } else {\n      this.triggerChanges(entityObjOrClass, property as any, idToTrigger);\n    }\n  }\n\n\n\n  public triggerCustomEvent(customEvent: string, dataToPush: any) {\n    this.triggerChanges(void 0, void 0, void 0, customEvent, dataToPush);\n  }\n\n\n\n  public trigggerEntityTableChanges(entityClass: Function) {\n    const className = ClassHelpers.getName(entityClass);\n    if (this.core.ctx.disabledRealtime) {\n      console.warn(\n        `[Taon][TrigggerEntityTableChanges] Entity \"${className}' is not realtime`,\n      );\n      return;\n    }\n\n    this.triggerChanges(\n      entityClass as any,\n      void 0,\n      void 0,\n      Symbols.REALTIME.TABLE_CHANGE(this.core.ctx.contextName, className),\n    );\n  }\n\n}\n\n ;({}); // @--end-of-file-for-module=taon lib/realtime/realtime-server.ts"]}

package/websql/esm2022/lib/realtime/realtime-strategy/index.mjs

@@ -0,0 +1,7 @@
+export * from './realtime-strategy';
+export * from './realtime-strategy-ipc';
+export * from './realtime-strategy-mock';
+export * from './realtime-strategy-socket-io';
+;
+({}); // @--end-of-file-for-module=taon lib/realtime/realtime-strategy/index.ts
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi90bXAtbGlicy1mb3ItZGlzdC13ZWJzcWwvdGFvbi9wcm9qZWN0cy90YW9uL3NyYy9saWIvcmVhbHRpbWUvcmVhbHRpbWUtc3RyYXRlZ3kvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBRUEsY0FBYyxxQkFBcUIsQ0FBQztBQUNwQyxjQUFjLHlCQUF5QixDQUFDO0FBQ3hDLGNBQWMsMEJBQTBCLENBQUM7QUFDekMsY0FBYywrQkFBK0IsQ0FBQztBQUU3QyxDQUFDO0FBQUEsQ0FBQyxFQUFFLENBQUMsQ0FBQyxDQUFDLHlFQUF5RSIsInNvdXJjZXNDb250ZW50IjpbIlxuXG5leHBvcnQgKiBmcm9tICcuL3JlYWx0aW1lLXN0cmF0ZWd5JztcbmV4cG9ydCAqIGZyb20gJy4vcmVhbHRpbWUtc3RyYXRlZ3ktaXBjJztcbmV4cG9ydCAqIGZyb20gJy4vcmVhbHRpbWUtc3RyYXRlZ3ktbW9jayc7XG5leHBvcnQgKiBmcm9tICcuL3JlYWx0aW1lLXN0cmF0ZWd5LXNvY2tldC1pbyc7XG5cbiA7KHt9KTsgLy8gQC0tZW5kLW9mLWZpbGUtZm9yLW1vZHVsZT10YW9uIGxpYi9yZWFsdGltZS9yZWFsdGltZS1zdHJhdGVneS9pbmRleC50cyJdfQ==

package/websql/esm2022/lib/realtime/realtime-strategy/realtime-strategy-ipc-models/realtime-strategy-ipc-main-namespace.mjs

@@ -0,0 +1,98 @@
+/* */
+/* */
+/* */
+export class IpcMainNamespace {
+    constructor(name) {
+        this.name = name;
+        this.rooms = {};
+        this.listeners = {};
+    }
+    on(event, callback) {
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        return (void 0);
+    }
+    off(event, callback) {
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        return (void 0);
+    }
+    emit(event, ...args) {
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        return (void 0);
+    }
+    to(room) {
+        return {
+            emit: (event, ...args) => {
+                const emitEvent = `(${this.name}) "${event}"`;
+                const allWindows = Electron.BrowserWindow.getAllWindows();
+                allWindows.forEach((win, index) => {
+                    win.webContents.send(emitEvent, ...args);
+                });
+            },
+        };
+    }
+    in(room) {
+        return {
+            emit: (event, ...args) => {
+                const sendEventKey = `(${this.name}) "${event}"`;
+                const allWindows = Electron.BrowserWindow.getAllWindows();
+                allWindows.forEach((win, index) => {
+                    win.webContents.send(sendEventKey, ...args);
+                });
+            },
+        };
+    }
+    join(webContents, room) {
+        if (!this.rooms[room]) {
+            this.rooms[room] = new Set();
+        }
+        this.rooms[room].add(webContents);
+    }
+    leave(webContents, room) {
+        if (this.rooms[room]) {
+            this.rooms[room].delete(webContents);
+            if (this.rooms[room].size === 0) {
+                delete this.rooms[room];
+            }
+        }
+    }
+    path() {
+        return this.name;
+    }
+    get nsp() {
+        const self = this;
+        return {
+            get name() {
+                return self.name;
+            },
+        };
+    }
+}
+;
+({}); // @--end-of-file-for-module=taon lib/realtime/realtime-strategy/realtime-strategy-ipc-models/realtime-strategy-ipc-main-namespace.ts
+//# sourceMappingURL=data:application/json;base64,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

package/websql/esm2022/lib/realtime/realtime-strategy/realtime-strategy-ipc-models/realtime-strategy-ipc-main-wrapper.mjs

@@ -0,0 +1,45 @@
+import { IpcMainNamespace } from './realtime-strategy-ipc-main-namespace';
+export class ioIpcStrategy {
+    constructor(contextName) {
+        this.contextName = contextName;
+        this.namespaces = {
+            ' /': new IpcMainNamespace('/'),
+        };
+    }
+    of(namespace) {
+        if (!this.namespaces[namespace]) {
+            this.namespaces[namespace] = new IpcMainNamespace(namespace);
+        }
+        return this.namespaces[namespace];
+    }
+    on(event, callback) {
+        const eventKey = `(${this.contextName}) "${event}"`;
+        this.namespaces['/'].on(eventKey, callback);
+    }
+    emit(event, ...args) {
+        const eventKey = `(${this.contextName}) "${event}"`;
+        this.namespaces['/'].emit(eventKey, ...args);
+    }
+    path() {
+        return '/';
+    }
+    get nsp() {
+        return {
+            get name() {
+                return '/';
+            },
+        };
+    }
+    in(room) {
+        return {
+            emit: (event, ...args) => {
+                Object.values(this.namespaces).forEach(namespace => {
+                    namespace.to(room).emit(event, ...args);
+                });
+            },
+        };
+    }
+}
+;
+({}); // @--end-of-file-for-module=taon lib/realtime/realtime-strategy/realtime-strategy-ipc-models/realtime-strategy-ipc-main-wrapper.ts
+//# sourceMappingURL=data:application/json;base64,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

package/websql/esm2022/lib/realtime/realtime-strategy/realtime-strategy-ipc-models/realtime-strategy-ipc-renderer-namespace.mjs

@@ -0,0 +1,40 @@
+export class IpcRendererNamespace {
+    constructor(name) {
+        this.name = name;
+        this.listeners = {};
+        this.ipcRenderer = window.require('electron').ipcRenderer;
+    }
+    on(eventName, callback) {
+        if (!this.listeners[eventName]) {
+            this.listeners[eventName] = [];
+        }
+        this.listeners[eventName].push(callback);
+        const listenToEvent = `(${this.name}) "${eventName}"`;
+        this.ipcRenderer.on(listenToEvent, callback);
+        if (eventName === 'connect') {
+            this.emit('connection');
+        }
+        else {
+            this.emit(eventName);
+        }
+    }
+    off(event, callback) {
+        if (!this.listeners[event])
+            return;
+        if (callback) {
+            this.listeners[event] = this.listeners[event].filter(listener => listener !== callback);
+        }
+        else {
+            delete this.listeners[event];
+        }
+        const removeListener = `(${this.name}) "${event}"`;
+        this.ipcRenderer.removeListener(removeListener, callback);
+    }
+    emit(event, ...args) {
+        const emitEvent = `(${this.name}) "${event}"`;
+        this.ipcRenderer.send(emitEvent, ...args);
+    }
+}
+;
+({}); // @--end-of-file-for-module=taon lib/realtime/realtime-strategy/realtime-strategy-ipc-models/realtime-strategy-ipc-renderer-namespace.ts
+//# sourceMappingURL=data:application/json;base64,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

package/websql/esm2022/lib/realtime/realtime-strategy/realtime-strategy-ipc-models/realtime-strategy-ipc-renderer-wrapper.mjs

@@ -0,0 +1,25 @@
+import { IpcRendererNamespace } from './realtime-strategy-ipc-renderer-namespace';
+export class IpcRendererWrapper {
+    constructor(contextName) {
+        this.contextName = contextName;
+        this.namespaces = {
+            '/': new IpcRendererNamespace('/'),
+        };
+        this.connected = false;
+    }
+    of(namespace) {
+        if (!this.namespaces[namespace]) {
+            this.namespaces[namespace] = new IpcRendererNamespace(namespace);
+        }
+        return this.namespaces[namespace];
+    }
+    on(event, callback) {
+        this.namespaces['/'].on(event, callback);
+    }
+    emit(event, ...args) {
+        this.namespaces['/'].emit(event, ...args);
+    }
+}
+;
+({}); // @--end-of-file-for-module=taon lib/realtime/realtime-strategy/realtime-strategy-ipc-models/realtime-strategy-ipc-renderer-wrapper.ts
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmVhbHRpbWUtc3RyYXRlZ3ktaXBjLXJlbmRlcmVyLXdyYXBwZXIuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi90bXAtbGlicy1mb3ItZGlzdC13ZWJzcWwvdGFvbi9wcm9qZWN0cy90YW9uL3NyYy9saWIvcmVhbHRpbWUvcmVhbHRpbWUtc3RyYXRlZ3kvcmVhbHRpbWUtc3RyYXRlZ3ktaXBjLW1vZGVscy9yZWFsdGltZS1zdHJhdGVneS1pcGMtcmVuZGVyZXItd3JhcHBlci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFFQSxPQUFPLEVBQUUsb0JBQW9CLEVBQUUsTUFBTSw0Q0FBNEMsQ0FBQztBQUVsRixNQUFNLE9BQU8sa0JBQWtCO0lBTTdCLFlBQW1CLFdBQW1CO1FBQW5CLGdCQUFXLEdBQVgsV0FBVyxDQUFRO1FBTDlCLGVBQVUsR0FBa0Q7WUFDbEUsR0FBRyxFQUFFLElBQUksb0JBQW9CLENBQUMsR0FBRyxDQUFDO1NBQ25DLENBQUM7UUFDTSxjQUFTLEdBQUcsS0FBSyxDQUFDO0lBSTFCLENBQUM7SUFFRCxFQUFFLENBQUMsU0FBaUI7UUFJbEIsSUFBSSxDQUFDLElBQUksQ0FBQyxVQUFVLENBQUMsU0FBUyxDQUFDLEVBQUUsQ0FBQztZQUNoQyxJQUFJLENBQUMsVUFBVSxDQUFDLFNBQVMsQ0FBQyxHQUFHLElBQUksb0JBQW9CLENBQ25ELFNBQVMsQ0FDVixDQUFDO1FBQ0osQ0FBQztRQUNELE9BQU8sSUFBSSxDQUFDLFVBQVUsQ0FBQyxTQUFTLENBQUMsQ0FBQztJQUNwQyxDQUFDO0lBRUQsRUFBRSxDQUFDLEtBQWEsRUFBRSxRQUE4QztRQVU5RCxJQUFJLENBQUMsVUFBVSxDQUFDLEdBQUcsQ0FBQyxDQUFDLEVBQUUsQ0FBQyxLQUFLLEVBQUUsUUFBUSxDQUFDLENBQUM7SUFDM0MsQ0FBQztJQUVELElBQUksQ0FBQyxLQUFhLEVBQUUsR0FBRyxJQUFXO1FBSWhDLElBQUksQ0FBQyxVQUFVLENBQUMsR0FBRyxDQUFDLENBQUMsSUFBSSxDQUFDLEtBQUssRUFBRSxHQUFHLElBQUksQ0FBQyxDQUFDO0lBQzVDLENBQUM7Q0FDRjtBQUVBLENBQUM7QUFBQSxDQUFDLEVBQUUsQ0FBQyxDQUFDLENBQUMsdUlBQXVJIiwic291cmNlc0NvbnRlbnQiOlsiXG5cbmltcG9ydCB7IElwY1JlbmRlcmVyTmFtZXNwYWNlIH0gZnJvbSAnLi9yZWFsdGltZS1zdHJhdGVneS1pcGMtcmVuZGVyZXItbmFtZXNwYWNlJztcblxuZXhwb3J0IGNsYXNzIElwY1JlbmRlcmVyV3JhcHBlciB7XG4gIHByaXZhdGUgbmFtZXNwYWNlczogeyBbbmFtZXNwYWNlOiBzdHJpbmddOiBJcGNSZW5kZXJlck5hbWVzcGFjZSB9ID0ge1xuICAgICcvJzogbmV3IElwY1JlbmRlcmVyTmFtZXNwYWNlKCcvJyksXG4gIH07XG4gIHByaXZhdGUgY29ubmVjdGVkID0gZmFsc2U7XG5cbiAgY29uc3RydWN0b3IocHVibGljIGNvbnRleHROYW1lOiBzdHJpbmcpIHtcblxuICB9XG5cbiAgb2YobmFtZXNwYWNlOiBzdHJpbmcpOiBJcGNSZW5kZXJlck5hbWVzcGFjZSB7XG5cblxuXG4gICAgaWYgKCF0aGlzLm5hbWVzcGFjZXNbbmFtZXNwYWNlXSkge1xuICAgICAgdGhpcy5uYW1lc3BhY2VzW25hbWVzcGFjZV0gPSBuZXcgSXBjUmVuZGVyZXJOYW1lc3BhY2UoXG4gICAgICAgIG5hbWVzcGFjZVxuICAgICAgKTtcbiAgICB9XG4gICAgcmV0dXJuIHRoaXMubmFtZXNwYWNlc1tuYW1lc3BhY2VdO1xuICB9XG5cbiAgb24oZXZlbnQ6IHN0cmluZywgY2FsbGJhY2s6IChldmVudDogYW55LCAuLi5hcmdzOiBhbnlbXSkgPT4gdm9pZCkge1xuXG5cblxuXG5cblxuXG5cblxuICAgIHRoaXMubmFtZXNwYWNlc1snLyddLm9uKGV2ZW50LCBjYWxsYmFjayk7XG4gIH1cblxuICBlbWl0KGV2ZW50OiBzdHJpbmcsIC4uLmFyZ3M6IGFueVtdKSB7XG5cblxuXG4gICAgdGhpcy5uYW1lc3BhY2VzWycvJ10uZW1pdChldmVudCwgLi4uYXJncyk7XG4gIH1cbn1cblxuIDsoe30pOyAvLyBALS1lbmQtb2YtZmlsZS1mb3ItbW9kdWxlPXRhb24gbGliL3JlYWx0aW1lL3JlYWx0aW1lLXN0cmF0ZWd5L3JlYWx0aW1lLXN0cmF0ZWd5LWlwYy1tb2RlbHMvcmVhbHRpbWUtc3RyYXRlZ3ktaXBjLXJlbmRlcmVyLXdyYXBwZXIudHMiXX0=

package/websql/esm2022/lib/realtime/realtime-strategy/realtime-strategy-ipc-models/realtime-strategy-ipc.models.mjs

@@ -0,0 +1,4 @@
+;
+({}); // @--end-of-file-for-module=taon lib/realtime/realtime-strategy/realtime-strategy-ipc-models/realtime-strategy-ipc.models.ts
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmVhbHRpbWUtc3RyYXRlZ3ktaXBjLm1vZGVscy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uL3RtcC1saWJzLWZvci1kaXN0LXdlYnNxbC90YW9uL3Byb2plY3RzL3Rhb24vc3JjL2xpYi9yZWFsdGltZS9yZWFsdGltZS1zdHJhdGVneS9yZWFsdGltZS1zdHJhdGVneS1pcGMtbW9kZWxzL3JlYWx0aW1lLXN0cmF0ZWd5LWlwYy5tb2RlbHMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBc0JDLENBQUM7QUFBQSxDQUFDLEVBQUUsQ0FBQyxDQUFDLENBQUMsNkhBQTZIIiwic291cmNlc0NvbnRlbnQiOlsiXG5cbmltcG9ydCB7IElwY01haW5OYW1lc3BhY2UgfSBmcm9tICcuL3JlYWx0aW1lLXN0cmF0ZWd5LWlwYy1tYWluLW5hbWVzcGFjZSc7XG5cbmV4cG9ydCBpbnRlcmZhY2UgUmVuZGVyZXJFdmVudExpc3RlbmVycyB7XG4gIFtldmVudDogc3RyaW5nXTogQXJyYXk8KGV2ZW50OiBhbnksIC4uLmFyZ3M6IGFueVtdKSA9PiB2b2lkPjtcbn1cblxuZXhwb3J0IGludGVyZmFjZSBFdmVudExpc3RlbmVycyB7XG4gIFtldmVudDogc3RyaW5nXTogQXJyYXk8XG4gICAgKGV2ZW50OiBFbGVjdHJvbi5JcGNNYWluRXZlbnQsIC4uLmFyZ3M6IGFueVtdKSA9PiB2b2lkXG4gID47XG59XG5cbmV4cG9ydCBpbnRlcmZhY2UgUm9vbXMge1xuICBbcm9vbTogc3RyaW5nXTogU2V0PEVsZWN0cm9uLldlYkNvbnRlbnRzPjtcbn1cblxuZXhwb3J0IGludGVyZmFjZSBOYW1lc3BhY2VzIHtcbiAgW25hbWVzcGFjZTogc3RyaW5nXTogSXBjTWFpbk5hbWVzcGFjZTtcbn1cblxuIDsoe30pOyAvLyBALS1lbmQtb2YtZmlsZS1mb3ItbW9kdWxlPXRhb24gbGliL3JlYWx0aW1lL3JlYWx0aW1lLXN0cmF0ZWd5L3JlYWx0aW1lLXN0cmF0ZWd5LWlwYy1tb2RlbHMvcmVhbHRpbWUtc3RyYXRlZ3ktaXBjLm1vZGVscy50cyJdfQ==

package/websql/esm2022/lib/realtime/realtime-strategy/realtime-strategy-ipc.mjs

@@ -0,0 +1,48 @@
+import { RealtimeStrategy } from './realtime-strategy';
+import { ioIpcStrategy as IoIpcStrategy } from './realtime-strategy-ipc-models/realtime-strategy-ipc-main-wrapper';
+import { IpcRendererWrapper } from './realtime-strategy-ipc-models/realtime-strategy-ipc-renderer-wrapper';
+/**
+ * Purpose:
+ * - backend-browser communication between 2 processes in electron mode
+ */
+export class RealtimeStrategyIpc extends RealtimeStrategy {
+    toString() {
+        return 'ipc';
+    }
+    establishConnection() {
+        throw new Error('Method not implemented.');
+    }
+    constructor(ctx) {
+        super(ctx);
+        this.ctx = ctx;
+        this.contextsServers = {};
+        this.contextsIO = {};
+    }
+    get io() {
+        return ((__, { path: namespacePath }) => {
+            if (this.contextsIO[namespacePath]) {
+                return this.contextsIO[namespacePath];
+            }
+            const wrap = new IpcRendererWrapper(this.ctx.contextName);
+            const nsp = wrap.of(namespacePath);
+            this.contextsIO[namespacePath] = nsp;
+            return nsp;
+        });
+        return void 0;
+    }
+    get Server() {
+        return ((___, { path: namespacePath }) => {
+            if (this.contextsServers[namespacePath]) {
+                return this.contextsServers[namespacePath];
+            }
+            const wrap = new IoIpcStrategy(this.ctx.contextName);
+            const nsp = wrap.of(namespacePath);
+            this.contextsServers[namespacePath] = nsp;
+            return nsp;
+        });
+        return void 0;
+    }
+}
+;
+({}); // @--end-of-file-for-module=taon lib/realtime/realtime-strategy/realtime-strategy-ipc.ts
+//# sourceMappingURL=data:application/json;base64,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

package/websql/esm2022/lib/realtime/realtime-strategy/realtime-strategy-mock-models/index.mjs

@@ -0,0 +1,5 @@
+export * from './realtime-strategy-mock-server';
+export * from './realtime-strategy-mock-client';
+;
+({}); // @--end-of-file-for-module=taon lib/realtime/realtime-strategy/realtime-strategy-mock-models/index.ts
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi90bXAtbGlicy1mb3ItZGlzdC13ZWJzcWwvdGFvbi9wcm9qZWN0cy90YW9uL3NyYy9saWIvcmVhbHRpbWUvcmVhbHRpbWUtc3RyYXRlZ3kvcmVhbHRpbWUtc3RyYXRlZ3ktbW9jay1tb2RlbHMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBRUEsY0FBYyxpQ0FBaUMsQ0FBQztBQUNoRCxjQUFjLGlDQUFpQyxDQUFDO0FBRy9DLENBQUM7QUFBQSxDQUFDLEVBQUUsQ0FBQyxDQUFDLENBQUMsdUdBQXVHIiwic291cmNlc0NvbnRlbnQiOlsiXG5cbmV4cG9ydCAqIGZyb20gJy4vcmVhbHRpbWUtc3RyYXRlZ3ktbW9jay1zZXJ2ZXInO1xuZXhwb3J0ICogZnJvbSAnLi9yZWFsdGltZS1zdHJhdGVneS1tb2NrLWNsaWVudCc7XG5cblxuIDsoe30pOyAvLyBALS1lbmQtb2YtZmlsZS1mb3ItbW9kdWxlPXRhb24gbGliL3JlYWx0aW1lL3JlYWx0aW1lLXN0cmF0ZWd5L3JlYWx0aW1lLXN0cmF0ZWd5LW1vY2stbW9kZWxzL2luZGV4LnRzIl19