@push.rocks/smartsocket 2.0.19

package/dist_ts/smartsocket.classes.socketconnection.js

@@ -0,0 +1,169 @@
+import * as plugins from './smartsocket.plugins.js';
+import './smartsocket.pluginstyped.js';
+import './interfaces/index.js';
+// import classes
+import './smartsocket.classes.smartsocket.js';
+import './smartsocket.classes.socketfunction.js';
+import { SocketRequest } from './smartsocket.classes.socketrequest.js';
+// socket.io
+import './smartsocket.classes.smartsocketclient.js';
+import { logger } from './smartsocket.logging.js';
+// export classes
+export let allSocketConnections = new plugins.lik.ObjectMap();
+/**
+ * class SocketConnection represents a websocket connection
+ */
+export class SocketConnection {
+    constructor(optionsArg) {
+        this.authenticated = false;
+        this.eventSubject = new plugins.smartrx.rxjs.Subject();
+        this.eventStatus = 'new';
+        this.tagStore = {};
+        this.tagStoreObservable = new plugins.smartrx.rxjs.Subject();
+        this.remoteTagStoreObservable = new plugins.smartrx.rxjs.Subject();
+        this.alias = optionsArg.alias;
+        this.authenticated = optionsArg.authenticated;
+        this.side = optionsArg.side;
+        this.smartsocketRef = optionsArg.smartsocketHost;
+        this.socket = optionsArg.socket;
+        // standard behaviour that is always true
+        allSocketConnections.add(this);
+        // handle connection
+        this.socket.on('connect', async () => {
+            this.updateStatus('connected');
+        });
+        this.socket.on('disconnect', async () => {
+            logger.log('info', `SocketConnection with >alias ${this.alias} on >side ${this.side} disconnected`);
+            await this.disconnect();
+            allSocketConnections.remove(this);
+            this.eventSubject.next('disconnected');
+        });
+    }
+    /**
+     * adds a tag to a connection
+     */
+    async addTag(tagArg) {
+        const done = plugins.smartpromise.defer();
+        this.tagStore[tagArg.id] = tagArg;
+        this.tagStoreObservable.next(this.tagStore);
+        const remoteSubscription = this.remoteTagStoreObservable.subscribe((remoteTagStore) => {
+            if (!remoteTagStore[tagArg.id]) {
+                return;
+            }
+            const localTagString = plugins.smartjson.stringify(tagArg);
+            const remoteTagString = plugins.smartjson.stringify(remoteTagStore[tagArg.id]);
+            if (localTagString === remoteTagString) {
+                remoteSubscription.unsubscribe();
+                done.resolve();
+            }
+        });
+        this.socket.emit('updateTagStore', this.tagStore);
+        await done.promise;
+    }
+    /**
+     * gets a tag by id
+     * @param tagIdArg
+     */
+    async getTagById(tagIdArg) {
+        return this.tagStore[tagIdArg];
+    }
+    /**
+     * removes a tag from a connection
+     */
+    async removeTagById(tagIdArg) {
+        delete this.tagStore[tagIdArg];
+        this.tagStoreObservable.next(this.tagStore);
+        this.socket.emit('updateTagStore', this.tagStore);
+    }
+    // authenticating --------------------------
+    /**
+     * authenticate the socket
+     */
+    authenticate() {
+        const done = plugins.smartpromise.defer();
+        this.socket.on('dataAuth', async (dataArg) => {
+            logger.log('info', 'received authentication data...');
+            this.socket.removeAllListeners('dataAuth');
+            if (dataArg.alias) {
+                // TODO: authenticate password
+                this.alias = dataArg.alias;
+                this.authenticated = true;
+                this.socket.emit('authenticated');
+                logger.log('ok', `socket with >>alias ${this.alias} is authenticated!`);
+                done.resolve(this);
+            }
+            else {
+                this.authenticated = false;
+                await this.disconnect();
+                done.reject('a socket tried to connect, but could not authenticated.');
+            }
+        });
+        const requestAuthPayload = {
+            serverAlias: this.smartsocketRef.alias,
+        };
+        this.socket.emit('requestAuth', requestAuthPayload);
+        return done.promise;
+    }
+    // listening -------------------------------
+    /**
+     * listen to function requests
+     */
+    listenToFunctionRequests() {
+        const done = plugins.smartpromise.defer();
+        if (this.authenticated) {
+            this.socket.on('function', (dataArg) => {
+                // check if requested function is available to the socket's scope
+                // logger.log('info', 'function request received');
+                const referencedFunction = this.smartsocketRef.socketFunctions.findSync((socketFunctionArg) => {
+                    return socketFunctionArg.name === dataArg.funcCallData.funcName;
+                });
+                if (referencedFunction) {
+                    // logger.log('ok', 'function in access scope');
+                    const localSocketRequest = new SocketRequest(this.smartsocketRef, {
+                        side: 'responding',
+                        originSocketConnection: this,
+                        shortId: dataArg.shortId,
+                        funcCallData: dataArg.funcCallData,
+                    });
+                    localSocketRequest.createResponse(); // takes care of creating response and sending it back
+                }
+                else {
+                    logger.log('warn', 'function not existent or out of access scope');
+                }
+            });
+            this.socket.on('functionResponse', (dataArg) => {
+                // logger.log('info', `received response for request with id ${dataArg.shortId}`);
+                const targetSocketRequest = SocketRequest.getSocketRequestById(this.smartsocketRef, dataArg.shortId);
+                targetSocketRequest.handleResponse(dataArg);
+            });
+            this.socket.on('updateTagStore', async (tagStoreArg) => {
+                if (!plugins.smartjson.deepEqualObjects(this.tagStore, tagStoreArg)) {
+                    this.tagStore = tagStoreArg;
+                    this.socket.emit('updateTagStore', this.tagStore);
+                    this.tagStoreObservable.next(this.tagStore);
+                }
+                this.remoteTagStoreObservable.next(tagStoreArg);
+            });
+            logger.log('info', `now listening to function requests for ${this.alias} on side ${this.side}`);
+            done.resolve(this);
+        }
+        else {
+            const errMessage = 'socket needs to be authenticated first';
+            logger.log('error', errMessage);
+            done.reject(errMessage);
+        }
+        return done.promise;
+    }
+    // disconnecting ----------------------
+    async disconnect() {
+        this.socket.disconnect(true);
+        this.updateStatus('disconnected');
+    }
+    updateStatus(statusArg) {
+        if (this.eventStatus !== statusArg) {
+            this.eventSubject.next(statusArg);
+        }
+        this.eventStatus = statusArg;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/smartsocket.classes.socketfunction.d.ts

@@ -0,0 +1,45 @@
+import * as plugins from './smartsocket.plugins.js';
+import { SocketConnection } from './smartsocket.classes.socketconnection.js';
+import { Smartsocket } from './smartsocket.classes.smartsocket.js';
+import { SmartsocketClient } from './smartsocket.classes.smartsocketclient.js';
+/**
+ * interface of the contructor options of class SocketFunction
+ */
+export interface ISocketFunctionConstructorOptions<T extends plugins.typedrequestInterfaces.ITypedRequest> {
+    funcName: T['method'];
+    funcDef: TFuncDef<T>;
+}
+/**
+ * interface of the Socket Function call, in other words the object that routes a call to a function
+ */
+export interface ISocketFunctionCallDataRequest<T extends plugins.typedrequestInterfaces.ITypedRequest> {
+    funcName: T['method'];
+    funcDataArg: T['request'];
+}
+/**
+ * interface of the Socket Function call, in other words the object that routes a call to a function
+ */
+export interface ISocketFunctionCallDataResponse<T extends plugins.typedrequestInterfaces.ITypedRequest> {
+    funcName: T['method'];
+    funcDataArg: T['response'];
+}
+/**
+ * interface for function definition of SocketFunction
+ */
+export type TFuncDef<T extends plugins.typedrequestInterfaces.ITypedRequest> = (dataArg: T['request'], connectionArg: SocketConnection) => PromiseLike<T['response']>;
+/**
+ * class that respresents a function that can be transparently called using a SocketConnection
+ */
+export declare class SocketFunction<T extends plugins.typedrequestInterfaces.ITypedRequest> {
+    static getSocketFunctionByName<Q extends plugins.typedrequestInterfaces.ITypedRequest>(smartsocketRefArg: Smartsocket | SmartsocketClient, functionNameArg: string): SocketFunction<Q>;
+    name: string;
+    funcDef: TFuncDef<T>;
+    /**
+     * the constructor for SocketFunction
+     */
+    constructor(optionsArg: ISocketFunctionConstructorOptions<T>);
+    /**
+     * invokes the function of this SocketFunction
+     */
+    invoke(dataArg: ISocketFunctionCallDataRequest<T>, socketConnectionArg: SocketConnection): Promise<ISocketFunctionCallDataResponse<T>>;
+}

package/dist_ts/smartsocket.classes.socketfunction.js

@@ -0,0 +1,40 @@
+import './smartsocket.plugins.js';
+// import classes
+import './smartsocket.classes.socketconnection.js';
+import './smartsocket.classes.smartsocket.js';
+import './smartsocket.classes.smartsocketclient.js';
+// export classes
+/**
+ * class that respresents a function that can be transparently called using a SocketConnection
+ */
+export class SocketFunction {
+    // STATIC
+    static getSocketFunctionByName(smartsocketRefArg, functionNameArg) {
+        return smartsocketRefArg.socketFunctions.findSync((socketFunctionArg) => {
+            return socketFunctionArg.name === functionNameArg;
+        });
+    }
+    /**
+     * the constructor for SocketFunction
+     */
+    constructor(optionsArg) {
+        this.name = optionsArg.funcName;
+        this.funcDef = optionsArg.funcDef;
+    }
+    /**
+     * invokes the function of this SocketFunction
+     */
+    async invoke(dataArg, socketConnectionArg) {
+        if (dataArg.funcName === this.name) {
+            const funcResponseData = {
+                funcName: this.name,
+                funcDataArg: await this.funcDef(dataArg.funcDataArg, socketConnectionArg),
+            };
+            return funcResponseData;
+        }
+        else {
+            throw new Error("SocketFunction.name does not match the data argument's .name!");
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic21hcnRzb2NrZXQuY2xhc3Nlcy5zb2NrZXRmdW5jdGlvbi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3RzL3NtYXJ0c29ja2V0LmNsYXNzZXMuc29ja2V0ZnVuY3Rpb24udHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBeUIsMEJBQTBCLENBQUM7QUFFcEQsaUJBQWlCO0FBQ2pCLE9BQWlDLDJDQUEyQyxDQUFDO0FBQzdFLE9BQTRCLHNDQUFzQyxDQUFDO0FBQ25FLE9BQWtDLDRDQUE0QyxDQUFDO0FBMEMvRSxpQkFBaUI7QUFFakI7O0dBRUc7QUFDSCxNQUFNLE9BQU8sY0FBYztJQUN6QixTQUFTO0lBQ0YsTUFBTSxDQUFDLHVCQUF1QixDQUNuQyxpQkFBa0QsRUFDbEQsZUFBdUI7UUFFdkIsT0FBTyxpQkFBaUIsQ0FBQyxlQUFlLENBQUMsUUFBUSxDQUFDLENBQUMsaUJBQWlCLEVBQUUsRUFBRTtZQUN0RSxPQUFPLGlCQUFpQixDQUFDLElBQUksS0FBSyxlQUFlLENBQUM7UUFDcEQsQ0FBQyxDQUFDLENBQUM7SUFDTCxDQUFDO0lBTUQ7O09BRUc7SUFDSCxZQUFZLFVBQWdEO1FBQzFELElBQUksQ0FBQyxJQUFJLEdBQUcsVUFBVSxDQUFDLFFBQVEsQ0FBQztRQUNoQyxJQUFJLENBQUMsT0FBTyxHQUFHLFVBQVUsQ0FBQyxPQUFPLENBQUM7SUFDcEMsQ0FBQztJQUVEOztPQUVHO0lBQ0ksS0FBSyxDQUFDLE1BQU0sQ0FDakIsT0FBMEMsRUFDMUMsbUJBQXFDO1FBRXJDLElBQUksT0FBTyxDQUFDLFFBQVEsS0FBSyxJQUFJLENBQUMsSUFBSSxFQUFFO1lBQ2xDLE1BQU0sZ0JBQWdCLEdBQXVDO2dCQUMzRCxRQUFRLEVBQUUsSUFBSSxDQUFDLElBQUk7Z0JBQ25CLFdBQVcsRUFBRSxNQUFNLElBQUksQ0FBQyxPQUFPLENBQUMsT0FBTyxDQUFDLFdBQVcsRUFBRSxtQkFBbUIsQ0FBQzthQUMxRSxDQUFDO1lBQ0YsT0FBTyxnQkFBZ0IsQ0FBQztTQUN6QjthQUFNO1lBQ0wsTUFBTSxJQUFJLEtBQUssQ0FBQywrREFBK0QsQ0FBQyxDQUFDO1NBQ2xGO0lBQ0gsQ0FBQztDQUNGIn0=

package/dist_ts/smartsocket.classes.socketrequest.d.ts

@@ -0,0 +1,47 @@
+import * as plugins from './smartsocket.plugins.js';
+import { ISocketFunctionCallDataRequest, ISocketFunctionCallDataResponse } from './smartsocket.classes.socketfunction.js';
+import { SocketConnection } from './smartsocket.classes.socketconnection.js';
+import { Smartsocket } from './smartsocket.classes.smartsocket.js';
+import { SmartsocketClient } from './smartsocket.classes.smartsocketclient.js';
+export type TSocketRequestStatus = 'new' | 'pending' | 'finished';
+export type TSocketRequestSide = 'requesting' | 'responding';
+/**
+ * interface of constructor of class SocketRequest
+ */
+export interface ISocketRequestConstructorOptions<T extends plugins.typedrequestInterfaces.ITypedRequest> {
+    side: TSocketRequestSide;
+    originSocketConnection: SocketConnection;
+    shortId: string;
+    funcCallData?: ISocketFunctionCallDataRequest<T>;
+}
+/**
+ * request object that is sent initially and may or may not receive a response
+ */
+export interface ISocketRequestDataObject<T extends plugins.typedrequestInterfaces.ITypedRequest> {
+    funcCallData: ISocketFunctionCallDataRequest<T> | ISocketFunctionCallDataResponse<T>;
+    shortId: string;
+    responseTimeout?: number;
+}
+export declare class SocketRequest<T extends plugins.typedrequestInterfaces.ITypedRequest> {
+    static getSocketRequestById(smartsocketRef: Smartsocket | SmartsocketClient, shortIdArg: string): SocketRequest<any>;
+    status: TSocketRequestStatus;
+    side: TSocketRequestSide;
+    shortid: string;
+    originSocketConnection: SocketConnection;
+    funcCallData: ISocketFunctionCallDataRequest<T>;
+    done: plugins.smartpromise.Deferred<ISocketFunctionCallDataResponse<T>>;
+    smartsocketRef: Smartsocket | SmartsocketClient;
+    constructor(smartsocketRefArg: Smartsocket | SmartsocketClient, optionsArg: ISocketRequestConstructorOptions<T>);
+    /**
+     * dispatches a socketrequest from the requesting to the receiving side
+     */
+    dispatch(): Promise<ISocketFunctionCallDataResponse<T>>;
+    /**
+     * handles the response that is received by the requesting side
+     */
+    handleResponse(responseDataArg: ISocketRequestDataObject<T>): Promise<void>;
+    /**
+     * creates the response on the responding side
+     */
+    createResponse(): Promise<void>;
+}

package/dist_ts/smartsocket.classes.socketrequest.js

@@ -0,0 +1,72 @@
+import * as plugins from './smartsocket.plugins.js';
+// import interfaces
+import { SocketFunction, } from './smartsocket.classes.socketfunction.js';
+// import classes
+import './smartsocket.classes.socketconnection.js';
+import { logger } from './smartsocket.logging.js';
+import './smartsocket.classes.smartsocket.js';
+import './smartsocket.classes.smartsocketclient.js';
+// export classes
+export class SocketRequest {
+    // STATIC
+    static getSocketRequestById(smartsocketRef, shortIdArg) {
+        return smartsocketRef.socketRequests.findSync((socketRequestArg) => {
+            return socketRequestArg.shortid === shortIdArg;
+        });
+    }
+    constructor(smartsocketRefArg, optionsArg) {
+        // INSTANCE
+        this.status = 'new';
+        this.done = plugins.smartpromise.defer();
+        this.smartsocketRef = smartsocketRefArg;
+        this.side = optionsArg.side;
+        this.shortid = optionsArg.shortId;
+        this.funcCallData = optionsArg.funcCallData;
+        this.originSocketConnection = optionsArg.originSocketConnection;
+        this.smartsocketRef.socketRequests.add(this);
+    }
+    // requesting --------------------------
+    /**
+     * dispatches a socketrequest from the requesting to the receiving side
+     */
+    dispatch() {
+        const requestData = {
+            funcCallData: this.funcCallData,
+            shortId: this.shortid,
+        };
+        this.originSocketConnection.socket.emit('function', requestData);
+        return this.done.promise;
+    }
+    /**
+     * handles the response that is received by the requesting side
+     */
+    async handleResponse(responseDataArg) {
+        // logger.log('info', 'handling response!');
+        this.done.resolve(responseDataArg.funcCallData);
+        this.smartsocketRef.socketRequests.remove(this);
+    }
+    // responding --------------------------
+    /**
+     * creates the response on the responding side
+     */
+    async createResponse() {
+        const targetSocketFunction = SocketFunction.getSocketFunctionByName(this.smartsocketRef, this.funcCallData.funcName);
+        if (!targetSocketFunction) {
+            logger.log('error', `There is no SocketFunction defined for ${this.funcCallData.funcName}`);
+            return;
+        }
+        // logger.log('info', `invoking ${targetSocketFunction.name}`);
+        targetSocketFunction
+            .invoke(this.funcCallData, this.originSocketConnection)
+            .then((resultData) => {
+            // logger.log('info', 'got resultData. Sending it to requesting party.');
+            const responseData = {
+                funcCallData: resultData,
+                shortId: this.shortid,
+            };
+            this.originSocketConnection.socket.emit('functionResponse', responseData);
+            this.smartsocketRef.socketRequests.remove(this);
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/smartsocket.classes.socketserver.d.ts

@@ -0,0 +1,35 @@
+/// <reference types="node" resolution-mode="require"/>
+/// <reference types="node" resolution-mode="require"/>
+import * as pluginsTyped from './smartsocket.pluginstyped.js';
+import { Smartsocket } from './smartsocket.classes.smartsocket.js';
+/**
+ * class socketServer
+ * handles the attachment of socketIo to whatever server is in play
+ */
+export declare class SocketServer {
+    private smartsocket;
+    private httpServerDeferred;
+    private httpServer;
+    /**
+     * wether httpServer is standalone
+     */
+    private standaloneServer;
+    constructor(smartSocketInstance: Smartsocket);
+    /**
+     * starts the server with another server
+     * also works with an express style server
+     */
+    setExternalServer(serverType: 'smartexpress', serverArg: pluginsTyped.smartexpress.Server): Promise<void>;
+    /**
+     * gets the server for socket.io
+     */
+    getServerForSocketIo(): Promise<pluginsTyped.http.Server<typeof pluginsTyped.http.IncomingMessage, typeof pluginsTyped.http.ServerResponse> | pluginsTyped.https.Server<typeof pluginsTyped.http.IncomingMessage, typeof pluginsTyped.http.ServerResponse>>;
+    /**
+     * starts listening to incoming sockets:
+     */
+    start(): Promise<void>;
+    /**
+     * closes the server
+     */
+    stop(): Promise<void>;
+}

package/dist_ts/smartsocket.classes.socketserver.js

@@ -0,0 +1,78 @@
+import * as plugins from './smartsocket.plugins.js';
+import './smartsocket.pluginstyped.js';
+// used in case no other server is supplied
+import './smartsocket.classes.smartsocket.js';
+import { logger } from './smartsocket.logging.js';
+/**
+ * class socketServer
+ * handles the attachment of socketIo to whatever server is in play
+ */
+export class SocketServer {
+    constructor(smartSocketInstance) {
+        /**
+         * wether httpServer is standalone
+         */
+        this.standaloneServer = false;
+        this.smartsocket = smartSocketInstance;
+    }
+    /**
+     * starts the server with another server
+     * also works with an express style server
+     */
+    async setExternalServer(serverType, serverArg) {
+        this.httpServerDeferred = plugins.smartpromise.defer();
+        await serverArg.startedPromise;
+        this.httpServer = serverArg.httpServer;
+        this.httpServerDeferred.resolve();
+    }
+    /**
+     * gets the server for socket.io
+     */
+    async getServerForSocketIo() {
+        if (this.httpServerDeferred) {
+            await this.httpServerDeferred.promise;
+        }
+        if (this.httpServer) {
+            return this.httpServer;
+        }
+        else {
+            const httpModule = await this.smartsocket.smartenv.getSafeNodeModule('http');
+            this.httpServer = new httpModule.Server();
+            this.standaloneServer = true;
+            return this.httpServer;
+        }
+    }
+    /**
+     * starts listening to incoming sockets:
+     */
+    async start() {
+        const done = plugins.smartpromise.defer();
+        // handle http servers
+        // in case an external server has been set "this.standaloneServer" should be false
+        if (this.httpServer && this.standaloneServer) {
+            if (!this.smartsocket.options.port) {
+                logger.log('error', 'there should be a port specifed for smartsocket!');
+                throw new Error('there should be a port specified for smartsocket');
+            }
+            this.httpServer.listen(this.smartsocket.options.port, () => {
+                logger.log('success', `Server started in standalone mode on ${this.smartsocket.options.port}`);
+                done.resolve();
+            });
+        }
+        else {
+            done.resolve();
+        }
+        // nothing else to do if express server is set
+        await done.promise;
+        return;
+    }
+    /**
+     * closes the server
+     */
+    async stop() {
+        if (this.httpServer) {
+            this.httpServer.close();
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/smartsocket.logging.d.ts

@@ -0,0 +1,2 @@
+import * as plugins from './smartsocket.plugins.js';
+export declare const logger: plugins.smartlog.ConsoleLog;

package/dist_ts/smartsocket.logging.js

@@ -0,0 +1,3 @@
+import * as plugins from './smartsocket.plugins.js';
+export const logger = new plugins.smartlog.ConsoleLog();
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic21hcnRzb2NrZXQubG9nZ2luZy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3RzL3NtYXJ0c29ja2V0LmxvZ2dpbmcudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxLQUFLLE9BQU8sTUFBTSwwQkFBMEIsQ0FBQztBQUVwRCxNQUFNLENBQUMsTUFBTSxNQUFNLEdBQUcsSUFBSSxPQUFPLENBQUMsUUFBUSxDQUFDLFVBQVUsRUFBRSxDQUFDIn0=

package/dist_ts/smartsocket.plugins.d.ts

@@ -0,0 +1,13 @@
+import * as typedrequestInterfaces from '@apiglobal/typedrequest-interfaces';
+export { typedrequestInterfaces };
+import * as isohash from '@pushrocks/isohash';
+import * as isounique from '@pushrocks/isounique';
+import * as lik from '@pushrocks/lik';
+import * as smartenv from '@pushrocks/smartenv';
+import * as smartjson from '@pushrocks/smartjson';
+import * as smartlog from '@pushrocks/smartlog';
+import * as smartdelay from '@pushrocks/smartdelay';
+import * as smartpromise from '@pushrocks/smartpromise';
+import * as smarttime from '@pushrocks/smarttime';
+import * as smartrx from '@pushrocks/smartrx';
+export { isohash, isounique, lik, smartenv, smartjson, smartlog, smartdelay, smartpromise, smarttime, smartrx, };

package/dist_ts/smartsocket.plugins.js

@@ -0,0 +1,16 @@
+// apiglobal scope
+import * as typedrequestInterfaces from '@apiglobal/typedrequest-interfaces';
+export { typedrequestInterfaces };
+// pushrocks scope
+import * as isohash from '@pushrocks/isohash';
+import * as isounique from '@pushrocks/isounique';
+import * as lik from '@pushrocks/lik';
+import * as smartenv from '@pushrocks/smartenv';
+import * as smartjson from '@pushrocks/smartjson';
+import * as smartlog from '@pushrocks/smartlog';
+import * as smartdelay from '@pushrocks/smartdelay';
+import * as smartpromise from '@pushrocks/smartpromise';
+import * as smarttime from '@pushrocks/smarttime';
+import * as smartrx from '@pushrocks/smartrx';
+export { isohash, isounique, lik, smartenv, smartjson, smartlog, smartdelay, smartpromise, smarttime, smartrx, };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic21hcnRzb2NrZXQucGx1Z2lucy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3RzL3NtYXJ0c29ja2V0LnBsdWdpbnMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsa0JBQWtCO0FBQ2xCLE9BQU8sS0FBSyxzQkFBc0IsTUFBTSxvQ0FBb0MsQ0FBQztBQUU3RSxPQUFPLEVBQUUsc0JBQXNCLEVBQUUsQ0FBQztBQUVsQyxrQkFBa0I7QUFDbEIsT0FBTyxLQUFLLE9BQU8sTUFBTSxvQkFBb0IsQ0FBQztBQUM5QyxPQUFPLEtBQUssU0FBUyxNQUFNLHNCQUFzQixDQUFDO0FBQ2xELE9BQU8sS0FBSyxHQUFHLE1BQU0sZ0JBQWdCLENBQUM7QUFDdEMsT0FBTyxLQUFLLFFBQVEsTUFBTSxxQkFBcUIsQ0FBQztBQUNoRCxPQUFPLEtBQUssU0FBUyxNQUFNLHNCQUFzQixDQUFDO0FBQ2xELE9BQU8sS0FBSyxRQUFRLE1BQU0scUJBQXFCLENBQUM7QUFDaEQsT0FBTyxLQUFLLFVBQVUsTUFBTSx1QkFBdUIsQ0FBQztBQUNwRCxPQUFPLEtBQUssWUFBWSxNQUFNLHlCQUF5QixDQUFDO0FBQ3hELE9BQU8sS0FBSyxTQUFTLE1BQU0sc0JBQXNCLENBQUM7QUFDbEQsT0FBTyxLQUFLLE9BQU8sTUFBTSxvQkFBb0IsQ0FBQztBQUU5QyxPQUFPLEVBQ0wsT0FBTyxFQUNQLFNBQVMsRUFDVCxHQUFHLEVBQ0gsUUFBUSxFQUNSLFNBQVMsRUFDVCxRQUFRLEVBQ1IsVUFBVSxFQUNWLFlBQVksRUFDWixTQUFTLEVBQ1QsT0FBTyxHQUNSLENBQUMifQ==

package/dist_ts/smartsocket.pluginstyped.d.ts

@@ -0,0 +1,15 @@
+import type * as http from 'http';
+import type * as https from 'https';
+export { http, https };
+import type * as smartexpress from '@pushrocks/smartexpress';
+export { smartexpress };
+import type { Socket as ServerSocket, Server as ServerServer } from 'socket.io';
+import type { Socket as ClientSocket, connect as ClientIo } from 'socket.io-client';
+export declare namespace socketIo {
+    type Socket = ServerSocket;
+    type Server = ServerServer;
+}
+export declare namespace socketIoClient {
+    type Socket = ClientSocket;
+    type connect = typeof ClientIo;
+}

package/dist_ts/smartsocket.pluginstyped.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic21hcnRzb2NrZXQucGx1Z2luc3R5cGVkLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vdHMvc21hcnRzb2NrZXQucGx1Z2luc3R5cGVkLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIifQ==

package/npmextra.json

@@ -0,0 +1,18 @@
+{
+  "gitzone": {
+    "projectType": "npm",
+    "module": {
+      "githost": "gitlab.com",
+      "gitscope": "pushrocks",
+      "gitrepo": "smartsocket",
+      "description": "easy and secure websocket communication",
+      "npmPackagename": "@pushrocks/smartsocket",
+      "license": "MIT",
+      "projectDomain": "push.rocks"
+    }
+  },
+  "npmci": {
+    "npmGlobalTools": [],
+    "npmAccessLevel": "public"
+  }
+}