@rws-framework/client 2.20.0 → 2.20.2

package/src/services/ConfigService.ts

@@ -1,126 +1,126 @@
-import TheService from './_service';
-import IRWSConfig from '../types/IRWSConfig';
-import { RWSFillBuild } from '../components/_decorators/RWSFillBuild';
-import { sendEventToOutside } from '../components/_event_handling';
-
-
-
-
-const __SENT_TO_COMPONENTS: string[] = [];
-
-@RWSFillBuild()
-class ConfigService extends TheService {  
-    static _DEFAULT: boolean = false;
-    static isLoaded: boolean = false;
-    
-    _DEFAULTS: Partial<IRWSConfig> = {};
-    _BUILD_OVERRIDE: IRWSConfig = {};
-
-    private data: IRWSConfig = {};    
-  
-    constructor() {
-        super();       
-    }    
-  
-    public get(key: keyof IRWSConfig): any
-    {       
-                
-        if(!this._DEFAULTS){
-            throw new Error('No _DEFAULTS loaded!');
-        }        
-
-        
-        const isInDefaults: boolean = Object.keys(this._DEFAULTS).includes(key as string);
-        const isInData: boolean = Object.keys(this.data).includes(key as string);
-        const isInBuildVars: boolean = Object.keys(this._BUILD_OVERRIDE).includes(key as string);
-
-        let isDev = false;
-
-        if((Object.keys(this._BUILD_OVERRIDE).includes('dev'))){
-            isDev = Object.keys(this._BUILD_OVERRIDE).includes('dev') && this._BUILD_OVERRIDE.dev;
-        }
-
-        if(!isInData){        
-            let defaultVal = null;
-
-            if(isInDefaults){
-                defaultVal = this._DEFAULTS[key];                   
-            }                             
-                        
-            if(defaultVal && defaultVal[0] === '@'){
-                defaultVal = this.data[((defaultVal as string).slice(1)) as keyof IRWSConfig];
-            }
-
-            if(isInBuildVars && Object.keys(this._BUILD_OVERRIDE).includes(key as string)){
-                if(isDev){
-                    console.warn(`.rws.json override [${key}]:`), this._BUILD_OVERRIDE[key];
-                }
-
-                defaultVal = this._BUILD_OVERRIDE[key];
-            }
-
-            return defaultVal;
-        }        
-
-        return this.data[key as keyof IRWSConfig];
-    }
-
-    public set<V extends keyof IRWSConfig>(key: V, value: IRWSConfig[V]){
-        this.data[key] = value;
-    }
-
-    async waitForConfig(tagName: string): Promise<boolean>
-    {        
-        let t: NodeJS.Timeout | null = null;
-
-        if(!this.data._noLoad || __SENT_TO_COMPONENTS.includes(tagName)){
-            return;
-        }
-
-        __SENT_TO_COMPONENTS.push(tagName); 
-
-        sendEventToOutside<{tagName: string}>('rws_cfg_call', {tagName})
-
-        return new Promise((resolve) => {
-            const tick = () => {
-                if(ConfigService.isLoaded){                                    
-                    clearTimeout(t);    
-                    resolve(true);
-                    return;
-                }
-    
-                t = setTimeout(tick, 200);
-            };
-    
-            t = setTimeout(tick, 200);
-        });       
-    }
-
-    isLoaded(): boolean
-    {
-        return ConfigService.isLoaded;
-    }
-
-    mergeConfig(config: IRWSConfig) {
-        const unloaded = ConfigService.isLoaded;     
-
-        this.data.plugins = [];
-        
-        this.data = Object.assign(this.data, config);
-
-        if(unloaded){
-            ConfigService.isLoaded = true;
-        }
-
-        return this.data;
-    }
-
-    getData(): IRWSConfig
-    {
-        return this.data;
-    }
-}
-
-export default ConfigService.getSingleton('ConfigService');
-
+import TheService from './_service';
+import IRWSConfig from '../types/IRWSConfig';
+import { RWSFillBuild } from '../components/_decorators/RWSFillBuild';
+import { sendEventToOutside } from '../components/_event_handling';
+
+
+
+
+const __SENT_TO_COMPONENTS: string[] = [];
+
+@RWSFillBuild()
+class ConfigService extends TheService {  
+    static _DEFAULT: boolean = false;
+    static isLoaded: boolean = false;
+    
+    _DEFAULTS: Partial<IRWSConfig> = {};
+    _BUILD_OVERRIDE: IRWSConfig = {};
+
+    private data: IRWSConfig = {};    
+  
+    constructor() {
+        super();       
+    }    
+  
+    public get(key: keyof IRWSConfig): any
+    {       
+                
+        if(!this._DEFAULTS){
+            throw new Error('No _DEFAULTS loaded!');
+        }        
+
+        
+        const isInDefaults: boolean = Object.keys(this._DEFAULTS).includes(key as string);
+        const isInData: boolean = Object.keys(this.data).includes(key as string);
+        const isInBuildVars: boolean = Object.keys(this._BUILD_OVERRIDE).includes(key as string);
+
+        let isDev = false;
+
+        if((Object.keys(this._BUILD_OVERRIDE).includes('dev'))){
+            isDev = Object.keys(this._BUILD_OVERRIDE).includes('dev') && this._BUILD_OVERRIDE.dev;
+        }
+
+        if(!isInData){        
+            let defaultVal = null;
+
+            if(isInDefaults){
+                defaultVal = this._DEFAULTS[key];                   
+            }                             
+                        
+            if(defaultVal && defaultVal[0] === '@'){
+                defaultVal = this.data[((defaultVal as string).slice(1)) as keyof IRWSConfig];
+            }
+
+            if(isInBuildVars && Object.keys(this._BUILD_OVERRIDE).includes(key as string)){
+                if(isDev){
+                    console.warn(`.rws.json override [${key}]:`), this._BUILD_OVERRIDE[key];
+                }
+
+                defaultVal = this._BUILD_OVERRIDE[key];
+            }
+
+            return defaultVal;
+        }        
+
+        return this.data[key as keyof IRWSConfig];
+    }
+
+    public set<V extends keyof IRWSConfig>(key: V, value: IRWSConfig[V]){
+        this.data[key] = value;
+    }
+
+    async waitForConfig(tagName: string): Promise<boolean>
+    {        
+        let t: NodeJS.Timeout | null = null;
+
+        if(!this.data._noLoad || __SENT_TO_COMPONENTS.includes(tagName)){
+            return;
+        }
+
+        __SENT_TO_COMPONENTS.push(tagName); 
+
+        sendEventToOutside<{tagName: string}>('rws_cfg_call', {tagName})
+
+        return new Promise((resolve) => {
+            const tick = () => {
+                if(ConfigService.isLoaded){                                    
+                    clearTimeout(t);    
+                    resolve(true);
+                    return;
+                }
+    
+                t = setTimeout(tick, 200);
+            };
+    
+            t = setTimeout(tick, 200);
+        });       
+    }
+
+    isLoaded(): boolean
+    {
+        return ConfigService.isLoaded;
+    }
+
+    mergeConfig(config: IRWSConfig) {
+        const unloaded = ConfigService.isLoaded;     
+
+        this.data.plugins = [];
+        
+        this.data = Object.assign(this.data, config);
+
+        if(unloaded){
+            ConfigService.isLoaded = true;
+        }
+
+        return this.data;
+    }
+
+    getData(): IRWSConfig
+    {
+        return this.data;
+    }
+}
+
+export default ConfigService.getSingleton('ConfigService');
+
 export { ConfigService as ConfigServiceInstance };

package/src/services/DOMService.ts

@@ -1,94 +1,94 @@
-import RWSService from './_service';
-import { DOM } from '@microsoft/fast-element';
-import DOMPurify from 'dompurify';
-
-type TagsProcessorType = { [tagName: string]: string | Transformer };
-type DOMOutputType<T extends Element> = NodeListOf<T> | T | null;
-
-//@ts-ignore
-declare let trustedTypes: TrustedTypePolicyFactory;
-
-
-class DOMService extends RWSService {
-    static _DEFAULT: boolean = true;
-    parse$<T extends Element>(input: NodeListOf<T>, directReturn: boolean = false): DOMOutputType<T> {    
-        if(input.length > 1 || directReturn) {
-            return input;
-        }
-    
-        if(input.length === 1) {
-            return input[0];
-        }
-    
-        return null;
-    }
-
-    $<T extends Element>(shadowRoot: ShadowRoot, selectors: string, directReturn: boolean = false): DOMOutputType<T> {        
-        const elements = shadowRoot.querySelectorAll<T>(selectors);
-        return elements ? this.parse$<T>(elements, directReturn) : null;    
-    }
-
-    async scrollToBottom(scrollContainer: HTMLDivElement, contentSelector: string = '.scroll-content') {
-        if (scrollContainer) {
-            const scrollContent = scrollContainer.querySelector(contentSelector) as HTMLElement;
-
-            if (scrollContent) {
-                scrollContainer.scrollTop = (scrollContent.scrollHeight - scrollContainer.clientHeight) + 150;              
-            }
-        }        
-    }
-
-    setHTMLPolicy(policyName: string, policyImplementation: (html: string) => string): void
-    {
-        const myPolicy = trustedTypes.createPolicy(policyName, {
-            createHTML(html: string) {              
-                return policyImplementation(html);
-            }
-        });
-          
-        DOM.setHTMLPolicy(myPolicy as any);        
-    }
-
-    private enforceAllowedTags(htmlText: string, allowedHTMLTags: string[]): string
-    {
-        // Create a regular expression pattern to match HTML tags
-        const tagPattern = /<\s*\/?\s*([^\s>/]+)(\s+[^>]*)?>/g;
-
-        // Replace any tags in the htmlText that are not in allowedHTMLTags array
-        const sanitizedText = htmlText.replace(tagPattern, (match, tag, attributes) => {
-            const lowerCaseTag = tag.toLowerCase();
-
-            if (allowedHTMLTags.includes(lowerCaseTag)) {
-                return match; // Return the original tag if it's allowed
-            } else {
-                // Replace the disallowed tag with an empty string
-                return '';
-            }
-        });
-
-        return sanitizedText;
-    }   
-
-    async onDOMLoad(): Promise<void>
-    {
-        return new Promise<void>((resolve) => {
-            document.addEventListener('DOMContentLoaded', () => {
-                resolve();
-            });
-        });
-    }
-
-    sanitizeHTML(
-        line: string,                
-        sanitizeOptions: DOMPurify.Config = { })
-    {
-        const output: string = line.trim();
-        const sanitized = DOMPurify.sanitize(output, { USE_PROFILES: { html: true }, ...sanitizeOptions});
-        return sanitized;
-    }
-}
-
-
-
-export default DOMService.getSingleton();
+import RWSService from './_service';
+import { DOM } from '@microsoft/fast-element';
+import DOMPurify from 'dompurify';
+
+type TagsProcessorType = { [tagName: string]: string | Transformer };
+type DOMOutputType<T extends Element> = NodeListOf<T> | T | null;
+
+//@ts-ignore
+declare let trustedTypes: TrustedTypePolicyFactory;
+
+
+class DOMService extends RWSService {
+    static _DEFAULT: boolean = true;
+    parse$<T extends Element>(input: NodeListOf<T>, directReturn: boolean = false): DOMOutputType<T> {    
+        if(input.length > 1 || directReturn) {
+            return input;
+        }
+    
+        if(input.length === 1) {
+            return input[0];
+        }
+    
+        return null;
+    }
+
+    $<T extends Element>(shadowRoot: ShadowRoot, selectors: string, directReturn: boolean = false): DOMOutputType<T> {        
+        const elements = shadowRoot.querySelectorAll<T>(selectors);
+        return elements ? this.parse$<T>(elements, directReturn) : null;    
+    }
+
+    async scrollToBottom(scrollContainer: HTMLDivElement, contentSelector: string = '.scroll-content') {
+        if (scrollContainer) {
+            const scrollContent = scrollContainer.querySelector(contentSelector) as HTMLElement;
+
+            if (scrollContent) {
+                scrollContainer.scrollTop = (scrollContent.scrollHeight - scrollContainer.clientHeight) + 150;              
+            }
+        }        
+    }
+
+    setHTMLPolicy(policyName: string, policyImplementation: (html: string) => string): void
+    {
+        const myPolicy = trustedTypes.createPolicy(policyName, {
+            createHTML(html: string) {              
+                return policyImplementation(html);
+            }
+        });
+          
+        DOM.setHTMLPolicy(myPolicy as any);        
+    }
+
+    private enforceAllowedTags(htmlText: string, allowedHTMLTags: string[]): string
+    {
+        // Create a regular expression pattern to match HTML tags
+        const tagPattern = /<\s*\/?\s*([^\s>/]+)(\s+[^>]*)?>/g;
+
+        // Replace any tags in the htmlText that are not in allowedHTMLTags array
+        const sanitizedText = htmlText.replace(tagPattern, (match, tag, attributes) => {
+            const lowerCaseTag = tag.toLowerCase();
+
+            if (allowedHTMLTags.includes(lowerCaseTag)) {
+                return match; // Return the original tag if it's allowed
+            } else {
+                // Replace the disallowed tag with an empty string
+                return '';
+            }
+        });
+
+        return sanitizedText;
+    }   
+
+    async onDOMLoad(): Promise<void>
+    {
+        return new Promise<void>((resolve) => {
+            document.addEventListener('DOMContentLoaded', () => {
+                resolve();
+            });
+        });
+    }
+
+    sanitizeHTML(
+        line: string,                
+        sanitizeOptions: DOMPurify.Config = { })
+    {
+        const output: string = line.trim();
+        const sanitized = DOMPurify.sanitize(output, { USE_PROFILES: { html: true }, ...sanitizeOptions});
+        return sanitized;
+    }
+}
+
+
+
+export default DOMService.getSingleton();
 export { DOMOutputType, DOMService, TagsProcessorType, DOMService as DOMServiceInstance }; 

package/src/services/NotifyService.ts

@@ -1,48 +1,48 @@
-import RWSNotify, { NotifyLogType } from '../types/RWSNotify';
-import TheService from './_service';
-/**
- * @class
- * @extends TheService
- */
-class NotifyService extends TheService {
-    static _DEFAULT: boolean = true;
-    private notifier: RWSNotify;
-
-    public setNotifier(notifier: RWSNotify)
-    {
-        this.notifier = notifier;
-    }
-
-    public alert(message: string, logType: NotifyLogType = 'info', onConfirm?: (params: any) => void, alertOptions?: any): any
-    {
-        if(!this.notifier){
-            console.warn('No notifier added to RWS Client');
-            return;
-        }
-        
-        return this.notifier(message, logType, 'alert', onConfirm, alertOptions);
-    }
-
-    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');
-    }
-}
-
-export default NotifyService.getSingleton();
+import RWSNotify, { NotifyLogType } from '../types/RWSNotify';
+import TheService from './_service';
+/**
+ * @class
+ * @extends TheService
+ */
+class NotifyService extends TheService {
+    static _DEFAULT: boolean = true;
+    private notifier: RWSNotify;
+
+    public setNotifier(notifier: RWSNotify)
+    {
+        this.notifier = notifier;
+    }
+
+    public alert(message: string, logType: NotifyLogType = 'info', onConfirm?: (params: any) => void, alertOptions?: any): any
+    {
+        if(!this.notifier){
+            console.warn('No notifier added to RWS Client');
+            return;
+        }
+        
+        return this.notifier(message, logType, 'alert', onConfirm, alertOptions);
+    }
+
+    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');
+    }
+}
+
+export default NotifyService.getSingleton();
 export { NotifyService as NotifyServiceInstance };

package/src/services/ServiceWorkerService.ts

@@ -1,61 +1,61 @@
-import RWSService from './_service';
-
-
-class ServiceWorkerService extends RWSService {   
-    static _DEFAULT: boolean = true;
-    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();
+import RWSService from './_service';
+
+
+class ServiceWorkerService extends RWSService {   
+    static _DEFAULT: boolean = true;
+    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 };