@rws-framework/client 2.0.6

package/src/services/NotifyService.ts

@@ -0,0 +1,49 @@
+import RWSNotify, { NotifyLogType } from '../types/RWSNotify';
+import TheService from './_service';
+/**
+ * @class
+ * @extends TheService
+ */
+class NotifyServiceInstance extends TheService {
+    private notifier: RWSNotify;
+
+    public setNotifier(notifier: RWSNotify)
+    {
+        this.notifier = notifier;
+    }
+
+    public alert(message: string, logType: NotifyLogType = 'info', onConfirm?: (params: any) => void): void
+    {
+        if(!this.notifier){
+            console.warn('No notifier added to RWS Client');
+            return;
+        }
+        
+        this.notifier(message, logType, 'alert', onConfirm);
+    }
+
+    public notify(message: string, logType: NotifyLogType = 'info', onConfirm?: (params: any) => void): void
+    {
+        if(!this.notifier){
+            console.warn('No notifier added to RWS Client');
+            return;
+        }
+
+        this.notifier(message, logType, 'notification', onConfirm);
+    }
+
+    public silent(message: string, logType: NotifyLogType = 'info'): void
+    {
+        if(!this.notifier){
+            console.warn('No notifier added to RWS Client');
+            return;
+        }
+
+        this.notifier(message, logType, 'silent');
+    }
+}
+
+const NotifyService = NotifyServiceInstance.getSingleton();
+
+export default NotifyService;
+export { NotifyServiceInstance };

package/src/services/RoutingService.ts

@@ -0,0 +1,46 @@
+
+import TheService from './_service';
+import Router from 'url-router';
+import { RWSRouter, IRWSRouteResult, RouteReturn } from '../routing/_router';
+import UtilsService, {UtilsServiceInstance} from './UtilsService';
+import { IRWSViewComponent } from '../interfaces/IRWSViewComponent';
+import ConfigService, { ConfigServiceInstance } from './ConfigService';
+
+type IFrontRoutes = Record<string, unknown>; 
+
+class RoutingService extends TheService {
+    private router: Router<any>;
+    private routes: IFrontRoutes;
+
+    constructor(@UtilsService private utilsService: UtilsServiceInstance, @ConfigService private config: ConfigServiceInstance){
+        super();        
+    }    
+
+    public apply(comp: IRWSViewComponent): RWSRouter
+    {                    
+        this.routes = this.config.get('routes');
+        this.router = new Router(this.routes);
+   
+        return new RWSRouter(comp, this.router, this.utilsService);
+    }
+
+    public routeHandler = <T>(comp:  T) => () => {
+        return comp;
+    };  
+
+    public getRoutes(): IFrontRoutes
+    {
+        return this.routes;
+    }
+}
+
+const renderRouteComponent = <T>(routeName: string, cmp: T, defaultRouteParams: any = {}) => (): [string, T, any] => [routeName, cmp, defaultRouteParams];
+
+const _ROUTING_EVENT_NAME = 'routing.route.change';
+interface IRoutingEvent {
+  routeName: string,
+  component: IRWSViewComponent
+}
+
+export default RoutingService.getSingleton();
+export { RoutingService as RoutingServiceInstance, IFrontRoutes, RWSRouter, IRWSRouteResult, renderRouteComponent, RouteReturn, _ROUTING_EVENT_NAME, IRoutingEvent};

package/src/services/ServiceWorkerService.ts

@@ -0,0 +1,60 @@
+import RWSService from 'rws-js-client/src/services/_service';
+
+
+class ServiceWorkerService extends RWSService {   
+    async registerServiceWorker(): Promise<void>
+    {
+        await ServiceWorkerService.registerServiceWorker();
+    }
+
+    static registerServiceWorker(): Promise<void>
+    {
+        if ('serviceWorker' in navigator) 
+        {
+            navigator.serviceWorker.getRegistrations().then(registrations => {
+                if (registrations.length) {
+                  return;
+                }
+
+                try {
+                    return (navigator.serviceWorker.register(
+                        '/service_worker.js',
+                        {
+                            scope: '/'          
+                        }
+                    ).then((registration) => {
+                        if (registration.installing) {
+                            console.log('Service worker installing');
+                        } else if (registration.waiting) {
+                            console.log('Service worker installed');
+                        } else if (registration.active) {
+                            console.log('Service worker active');
+                        }
+                    }));                
+                            
+                } catch (error) {      
+                    console.error(`Registration failed with ${error}`);
+                }
+            });    
+            
+            return;
+        }
+    }
+
+    sendDataToServiceWorker(type: string, data: any, asset_type: string = 'data_push')
+    {
+        if (navigator.serviceWorker.controller) {
+            navigator.serviceWorker.controller.postMessage({
+              command: type,
+              asset_type,
+              params: data
+            });
+          } else {
+            throw new Error('Service worker is not available');
+          }
+    }
+}
+
+
+export default ServiceWorkerService.getSingleton();
+export { ServiceWorkerService as ServiceWorkerServiceInstance };

package/src/services/UtilsService.ts

@@ -0,0 +1,103 @@
+import TheService from './_service';
+import ApiService, {ApiServiceInstance} from './ApiService';
+
+import { RawSourceMap  } from 'source-map';
+
+let sourceMap: RawSourceMap = null; 
+
+class UtilsService extends TheService {
+    private apiService: ApiServiceInstance;
+
+    constructor(@ApiService apiService: ApiServiceInstance){
+        super();
+        this.apiService = apiService;
+    }
+
+    async getFileContents(filePath: string): Promise<string>
+    {    
+        return this.apiService.pureGet(filePath);
+    }
+    
+    mergeDeep<T>(target: T | any, source: T  | any): T 
+    {
+        const isObject = (obj: any) => obj && typeof obj === 'object';
+
+        if (!isObject(target) || !isObject(source)) {
+            return source;
+        }
+
+        Object.keys(source).forEach(key => {
+            const targetValue = target[key];
+            const sourceValue = source[key];
+
+            if (Array.isArray(targetValue) && Array.isArray(sourceValue)) {
+                target[key] = targetValue.concat(sourceValue);
+            } else if (isObject(targetValue) && isObject(sourceValue)) {
+                target[key] = this.mergeDeep(Object.assign({}, targetValue), sourceValue);
+            } else {
+                target[key] = sourceValue;
+            }
+        });
+
+        return target;
+    }
+
+    async fetchSourceMap(jsFilePath: string): Promise<RawSourceMap> 
+    {
+        // Assuming the source map URL is the JS file URL with a '.map' extension
+        const sourceMapUrl = jsFilePath;
+
+        try {
+            const response = await fetch(sourceMapUrl);
+            if (!response.ok) {
+                throw new Error(`HTTP error! Status: ${response.status}`);
+            }
+            return await response.json();
+        } catch (error) {
+            console.error('Failed to fetch source map:', error);
+            return null;
+        }
+    }
+
+    async getCurrentLineNumber(error: Error = null): Promise<number> {
+        if(!error){
+            error = new Error();
+        }  
+        
+        return 0;
+
+        // const stack = error.stack || '';
+        // const stackLines = stack.split('\n');
+        // const relevantLine = stackLines[1];
+
+        // // Extract file path from the stack line
+        // const match = relevantLine.match(/\((.*?):\d+:\d+\)/);
+        // if (!match) return -1;
+        // const filePath = match[1];
+
+        // // Assuming the source map is in the same directory with '.map' extension
+        // const sourceMapPath = `${filePath}.map`;    
+
+        // if(sourceMap === null){
+        //     sourceMap = await this.fetchSourceMap(sourceMapPath);       
+        // }
+
+        // let originalPosition: any = null;
+
+        // await SourceMapConsumer.with(sourceMap, null, consumer => {
+        //     const lineMatch = relevantLine.match(/:(\d+):(\d+)/);
+        //     if (!lineMatch) return -1;
+            
+        //     originalPosition = consumer.originalPositionFor({
+        //       line: parseInt(lineMatch[1]), // Example line and column
+        //       column: parseInt(lineMatch[2])
+        //     });            
+        // });        
+     
+        // return originalPosition.line;
+    }
+}
+
+export default UtilsService.getSingleton();
+
+export { UtilsService as UtilsServiceInstance }

package/src/services/WSService.ts

@@ -0,0 +1,218 @@
+import TheService from './_service';
+import { io, Socket } from 'socket.io-client';
+import ITheUser from '../interfaces/IRWSUser';
+import { v4 as uuid } from 'uuid';
+import { ping, disconnect as disconnectWs, reconnect as reconnectWs } from './_ws_handlers/ConnectionHandler';
+import WSEventHandler from './_ws_handlers/EventHandler';
+import WSMessageHandler from './_ws_handlers/MessageHandler';
+
+type WSEvent = string;
+type WSStatus = 'WS_OPEN' | 'WS_CLOSED' | 'WS_CONNECTING';
+
+// function logClickableLink(text: string, url: string) {  
+//     console.log('[', url, ']:', text);  
+// }
+
+// const getCurrentLineNumber = UtilsService.getCurrentLineNumber;
+
+
+const  wsLog = async (fakeError: Error, text: any, socketId: string = null, isError: boolean = false): Promise<void> => {  
+    const logit = isError ? console.error : console.log;
+    logit(`[webpack://junction_ai_trainer_ui/${module.id.replace('./', '')}:`, `<WS-CLIENT>${socketId ? `(${socketId})` : ''}`, text);
+};
+
+class WSService extends TheService {
+    static websocket_instance: Socket;
+    private _ws: Socket | null = null;
+  
+  
+    private user: ITheUser | null = null;
+    private url: string | null = null;
+  
+    private _status_string: WSStatus = 'WS_CLOSED';
+
+    public _wsId: string | null = null;
+
+  
+    public _interval: any = null;    
+    public _connecting: boolean = false;
+    public _shut_down: boolean = false;
+    public reconnects: number = 0;
+
+    public eventListeners: Map<string, Array<(instance: WSService, params: any) => any>> = new Map();
+
+    public async init(url: string, user?: ITheUser, transports: string[] = null): Promise<WSService> {
+        this._connecting = true;        
+        wsLog(new Error(), 'Connecting to: ' + url);
+        this.url = url;
+        this.user = user;            
+
+        const headers = this.user?.jwt_token ? {
+            Authorization: 'Bearer ' + this.user?.jwt_token,
+        } : {};
+
+        if(!WSService.websocket_instance){
+            console.log('WSSERVICE', headers);
+            const tokenString = headers.Authorization ? `?token=${this.user.jwt_token}` : '' ;
+            WSService.websocket_instance = io(this.url + tokenString, { 
+                auth: user?.jwt_token ? { token:  user.jwt_token} : {}, 
+                transports:  transports || null 
+            });
+        }          
+        //, transports:  ['websocket']
+        this._ws = WSService.websocket_instance;
+
+  
+
+        if (this.user?.mongoId) {
+            this._wsId = this.user.mongoId;
+        }else{
+            this._wsId = uuid();
+        }
+
+        let socketId: string = null;
+
+        this._ws.on('connect', () => {
+            socketId = this.socket().id;         
+
+            wsLog(new Error(), 'Socket connected with ID: ' + socketId, socketId);
+
+            this._connecting = false;
+            this._ws.connected = true;  
+
+            this.executeEventListener('ws:connected');               
+        
+            wsLog(new Error(), 'Emitting ping to server', socketId);
+            ping(this);
+        });
+        
+        this._ws.on('__PONG__', async (data: any) => {              
+            if (data === '__PONG__') {
+                wsLog(new Error(), 'Recieving valid ping callback from server', socketId);                                                           
+                return;
+            }
+        });
+
+        this._ws.on('disconnect', async (e) => {              
+            wsLog(new Error(), 'Disconnected from the server', socketId);              
+            this.executeEventListener('ws:disconnected', { socketId: socketId, error: e });
+            socketId = null;
+        });
+
+        this._ws.on('error', async (error: Error) => {
+            wsLog(error, 'Socket error:', socketId, true);
+            console.error(error);
+            this.executeEventListener('ws:error', { socketId: socketId, error: error });
+
+        });
+        
+
+        // this._interval = setInterval(() => {
+        //     ping(_self);
+        // }, 3000);
+
+        this.reconnects = 0;
+
+        if (this._ws?.connected) {
+            this._connecting = false;
+        }
+
+        this.statusChange();
+
+        return this;
+    }
+
+    public getStatus(): WSStatus {
+        return this._status_string;
+    }  
+
+    public isActive(): boolean {
+        return !this._connecting && this._ws?.connected;
+    }
+
+    setUser(user: ITheUser): void
+    {
+        this.user = user;
+    }
+
+    public listenForMessage(callback: (data: any, isJson?: boolean) => void, method?: string): () => void 
+    {
+        const disableHandler = () => {
+            this.socket().off(method, callback);
+        };
+
+        WSMessageHandler.listenForMessage(this, callback, method);
+
+        return disableHandler.bind(this);
+    }
+
+    async waitForStatus(): Promise<void>
+    {
+        return new Promise((resolve, reject) => {
+            let iteration = 0;
+            const t = setInterval(() => {
+                if(iteration > 4){
+                    clearInterval(t);
+                    reject('Websocket did not connect!');                  
+                }
+
+                if(this.isActive()){                        
+                    clearInterval(t);
+                    resolve();                  
+                }
+
+                iteration++;
+            }, 1000);
+        });
+    }
+
+    public sendMessage<T>(method: string, msg: T): void {                
+        WSMessageHandler.sendMessage<T>(this, method, msg);
+    }
+
+    public statusChange(): void {
+        let status: WSStatus = 'WS_CLOSED';
+        if (this._connecting) {
+            status = 'WS_CONNECTING';
+        } else if (this.isActive()) {
+            status = 'WS_OPEN';
+        }
+
+        this.executeEventListener('ws:status_change', { status });      
+        this._status_string = status;
+    }
+
+    public on(event: WSEvent, callback: (wsInstance: WSService, params: any) => any): void {
+        WSEventHandler.on(this, event, callback);
+    }
+
+    public executeEventListener(event: WSEvent, params: any = {}): void {
+        WSEventHandler.executeEventListener(this, event, params);
+    }
+
+    public socket(): Socket
+    {
+        return this._ws;
+    }
+
+    public disconnect()
+    {
+        disconnectWs(this);
+    }
+
+    public reconnect()
+    {
+        reconnectWs(this);
+    }
+
+    getUser(): ITheUser {
+        return this.user;
+    }
+
+    getUrl(): string {
+        return this.url;
+    }
+}
+
+export default WSService.getSingleton();
+export { WSService as WSServiceInstance, WSEvent, WSService as WSInstance, WSStatus };

package/src/services/_service.ts

@@ -0,0 +1,50 @@
+import { DI, InterfaceSymbol, Key, Registration, FoundationElementDefinition } from "@microsoft/fast-foundation";
+import RWSContainer from "../components/_container";
+import RWSWindow, { loadRWSRichWindow, RWSWindowComponentInterface } from "../interfaces/RWSWindow";
+
+export interface IWithDI<T> {
+    new (...args: any[]): T;
+    getSingleton: <T extends Key>(this: IWithDI<T>) => InterfaceSymbol<T>;
+    register: <T extends Key>(this: IWithDI<T>) => void;    
+}
+
+export default abstract class TheRWSService {
+    _RELOADABLE: boolean = false;
+
+    constructor() {    
+    }
+
+    register<T extends Key>(this: IWithDI<T>): void 
+    {
+        this.getSingleton();
+    }
+    
+    getSingleton<T extends Key>(this: IWithDI<T>): InterfaceSymbol<T> 
+    {
+        return this.getSingleton();
+    }
+
+    public static register<T extends Key>(this: IWithDI<T>): void
+    {                                        
+        this.getSingleton();
+    }
+    
+    public static getSingleton<T extends Key>(this: IWithDI<T>): InterfaceSymbol<T>
+    {                  
+        const richWindow = loadRWSRichWindow();        
+
+        if(Object.keys(richWindow.RWS._registered).includes(this.name)){            
+            return richWindow.RWS._registered[this.name];        
+        }
+
+        const interf = DI.createInterface<T>(this.name);
+   
+        RWSContainer().register(
+            Registration.singleton(interf, this)
+        );
+
+        richWindow.RWS._registered[this.name] = interf;
+
+        return interf;
+    }
+}

package/src/services/_ws_handlers/ConnectionHandler.ts

@@ -0,0 +1,52 @@
+import { WSInstance } from '../WSService';
+
+
+function ping(instance: WSInstance): void {    
+    instance.socket().emit('__PING__');
+    // instance._timeout = setTimeout(() => {
+    //     reconnect(instance);
+    // }, 3000);
+}
+
+
+function reconnect(instance: WSInstance): void {    
+    disconnect(instance, true);
+    const rc = instance.reconnects;
+    if (rc < 2) {
+        instance.executeEventListener('ws:reconnect', { reconnects: rc + 1 });        
+        instance._connecting = true;
+        instance.reconnects++;
+        setTimeout(() => {
+            instance.init(instance.getUrl()!, instance.getUser());
+            instance.reconnects = rc + 1;
+        }, 1500);
+
+        instance.statusChange();
+    } else {
+        disconnect(instance);
+    }
+}
+function disconnect(instance: WSInstance, noEvent = false): void {
+
+    if(instance.socket()){
+        instance.socket().disconnect();
+    }
+
+    if(!noEvent){
+        console.log(`{WS}${instance.socket() ? `(${instance.socket().id}):` : ''} Disconnected from WS`);
+        instance.executeEventListener('ws:disconnected');
+    }
+    
+    clearInterval(instance._interval);
+
+    instance._connecting = false;
+    instance._shut_down = true;
+
+    instance.statusChange();
+}    
+
+export {
+    ping,
+    reconnect,
+    disconnect
+};

package/src/services/_ws_handlers/EventHandler.ts

@@ -0,0 +1,28 @@
+import { WSInstance, WSEvent } from '../WSService';
+
+function on(instance: WSInstance, event: WSEvent, callback: (wsInstance: WSInstance, params: any) => any): void {
+    let listeners = instance.eventListeners.get(event);
+    if (!listeners) {
+        listeners = [];
+        instance.eventListeners.set(event, listeners);
+    }
+    listeners.push(callback);
+}
+
+function executeEventListener(instance: WSInstance, event: WSEvent, params: any = {}): void {    
+    const listeners = instance.eventListeners.get(event);
+    if (listeners) {
+        listeners.forEach(callback => {
+            try {
+                callback(instance, params);
+            } catch (e) {
+                console.error(`Error executing callback for event '${event}':`, e);
+            }
+        });
+    }
+}
+
+export default {
+    on,
+    executeEventListener
+};

package/src/services/_ws_handlers/MessageHandler.ts

@@ -0,0 +1,49 @@
+import { WSInstance } from '../WSService';
+
+function listenForMessage(instance: WSInstance, callback: (data: any, isJson?: boolean) => void, method?: string): WSInstance {
+    if (!instance.socket()) {
+        throw new Error('socket is not active');
+    }
+
+    instance.socket().on(method || 'message', (data: any) => {
+        try {            
+            const parsedData = JSON.parse(data);
+            if (!!method && parsedData.method === method) {                              
+                callback(parsedData, true);
+                instance.executeEventListener('ws:message_received', { message: parsedData });
+
+            } else if (!method) {
+                callback(parsedData, true);
+            }            
+        } catch (e) {
+            console.error(e);
+            
+            if (!method) {                
+                callback(data);
+            }
+        }
+    });
+
+    return instance;
+}
+
+function sendMessage<T>(instance: WSInstance, method: string, msg: T): void {
+    if (!instance.socket()) {
+        throw new Error('socket is not active');
+    }
+
+    const the_message = {
+        user_id: instance.socket().id,
+        method: method,
+        msg: msg
+    };
+
+    
+    instance.socket().emit(method, JSON.stringify(the_message));
+    instance.executeEventListener('ws:message_sent', { message: the_message });
+} 
+
+export default{
+    listenForMessage,
+    sendMessage
+};