@wavemaker-ai/app-ng-runtime 1.0.0-rc.647469

package/runtime/base/esm2022/services/navigation.service.mjs

@@ -0,0 +1,307 @@
+import { Injectable, NgZone } from '@angular/core';
+import { NavigationStart, Router } from '@angular/router';
+import { App } from '@wm/core';
+import { CONSTANTS } from '@wm/variables';
+import { filter, isEmpty, isEqual } from "lodash-es";
+import * as i0 from "@angular/core";
+import * as i1 from "@wm/core";
+import * as i2 from "@angular/router";
+const parentSelector = 'body >app-root';
+export class NavigationServiceImpl {
+    constructor(app, router, zone) {
+        this.app = app;
+        this.router = router;
+        this.zone = zone;
+        this.history = new History();
+        this.isPageAddedToHistory = false;
+        this.router.events.subscribe(event => {
+            if (event instanceof NavigationStart) {
+                const url = event.url;
+                const urlParams = {};
+                let pageName;
+                if (!this.isPageAddedToHistory) {
+                    this.isPageAddedToHistory = false;
+                    if (url.indexOf('?') > 0) {
+                        url.substr(url.indexOf('?') + 1)
+                            .split('&')
+                            .forEach(s => {
+                            const splits = s.split('=');
+                            urlParams[splits[0]] = splits[1];
+                        });
+                        pageName = url.substr(0, url.indexOf('?'));
+                    }
+                    else {
+                        pageName = url;
+                    }
+                    if (pageName[0] === '/') {
+                        pageName = pageName.substr(1);
+                    }
+                    if (pageName) {
+                        /*
+                         * Commenting this code, one client project has Home_Page configured as Login Page.
+                         * So redirection to Home_Page post login is failing
+                         // if login page is being loaded and user is logged in, cancel that.
+                            if ($rs.isApplicationType) {
+                                stopLoginPagePostLogin($p);
+                            }
+                         */
+                        delete urlParams['name'];
+                        this.history.push(new PageInfo(pageName, urlParams, this.transition));
+                    }
+                }
+            }
+        });
+    }
+    getPageTransition() {
+        if (isEmpty(this.transition) || isEqual('none', this.transition)) {
+            return null;
+        }
+        return this.transition;
+    }
+    /**
+     * Navigates to particular page
+     * @param pageName
+     * @param options
+     */
+    goToPage(pageName, options) {
+        this.transition = options.transition || '';
+        // page is added to stack only when currentPage is available.
+        if (this.history.getCurrentPage()) {
+            this.isPageAddedToHistory = true;
+        }
+        this.history.push(new PageInfo(pageName, options.urlParams, this.transition));
+        /**
+         *  BrowserAnimcation module has issue with RouterOutlet
+            In the result every route appending to previous route instead of replace.
+            To fix the issue we are navigating inside the ngZones
+         *
+         *  */
+        this.zone.run(() => {
+            return this.router.navigate([`/${pageName}`], { queryParams: options.urlParams });
+        });
+    }
+    /**
+     * Navigates to last visited page.
+     */
+    goToPrevious() {
+        if (this.history.getPagesCount()) {
+            this.transition = this.history.getCurrentPage().transition;
+            if (!isEmpty(this.transition)) {
+                this.transition += '-exit';
+            }
+            this.history.pop();
+            this.isPageAddedToHistory = true;
+            window.history.back();
+        }
+    }
+    /** Todo[Shubham] Need to handle gotoElement in other partials
+     * Navigates to particular view
+     * @param viewName
+     * @param options
+     * @param variable
+     */
+    goToView(viewName, options, variable) {
+        options = options || {};
+        const pageName = options.pageName;
+        const transition = options.transition || '';
+        const $event = options.$event;
+        const activePage = this.app.activePage;
+        const prefabName = variable && variable._context && variable._context.prefabName;
+        // Check if app is Prefab
+        if (this.app.isPrefabType) {
+            this.goToElementView($(parentSelector).find('[name="' + viewName + '"]'), viewName, pageName, variable);
+        }
+        else {
+            // checking if the element is present in the page or not, if no show an error toaster
+            // if yes check if it is inside a partial/prefab in the page and then highlight the respective element
+            // else goto the page in which the element exists and highlight the element
+            if (pageName !== activePage.activePageName && !prefabName) {
+                if (this.isPartialWithNameExists(pageName)) {
+                    this.goToElementView($('[partialcontainer][content="' + pageName + '"]').find('[name="' + viewName + '"]'), viewName, pageName, variable);
+                }
+                else {
+                    // Todo[Shubham]: Make an API call to get all pages and check if the page name
+                    //  is a page and then do this call else show an error as:
+                    //  this.app.notifyApp(CONSTANTS.WIDGET_DOESNT_EXIST, 'error');
+                    this.goToPage(pageName, {
+                        viewName: viewName,
+                        $event: $event,
+                        transition: transition,
+                        urlParams: options.urlParams
+                    });
+                    // subscribe to an event named pageReady which notifies this subscriber
+                    // when all widgets in page are loaded i.e when page is ready
+                    const pageReadySubscriber = this.app.subscribe('pageReady', (page) => {
+                        this.goToElementView($(parentSelector).find('[name="' + viewName + '"]'), viewName, pageName, variable);
+                        pageReadySubscriber();
+                    });
+                }
+            }
+            else if (prefabName && this.isPrefabWithNameExists(prefabName)) {
+                this.goToElementView($('[prefabName="' + prefabName + '"]').find('[name="' + viewName + '"]'), viewName, pageName, variable);
+            }
+            else if (!pageName || pageName === activePage.activePageName) {
+                this.goToElementView($(parentSelector).find('[name="' + viewName + '"]'), viewName, pageName, variable);
+            }
+            else {
+                this.app.notifyApp(CONSTANTS.WIDGET_DOESNT_EXIST, 'error');
+            }
+        }
+    }
+    /*
+     * navigates the user to a view element with given name
+     * if the element not found in the compiled markup, the same is searched in the available dialogs in the page
+     */
+    goToElementView(viewElement, viewName, pageName, variable) {
+        let $el, parentDialog;
+        const activePage = this.app.activePage;
+        if (viewElement.length) {
+            if (!this.app.isPrefabType && pageName === activePage.activePageName) {
+                viewElement = this.getViewElementInActivePage(viewElement);
+            }
+            $el = viewElement[0].widget;
+            switch ($el.widgetType) {
+                case 'wm-accordionpane':
+                    this.showAncestors(viewElement, variable);
+                    $el.expand();
+                    break;
+                case 'wm-tabpane':
+                    this.showAncestors(viewElement, variable);
+                    $el.select();
+                    break;
+                case 'wm-segment-content':
+                    this.showAncestors(viewElement, variable);
+                    $el.navigate();
+                    break;
+                case 'wm-panel':
+                    /* flip the active flag */
+                    $el.expanded = true;
+                    break;
+            }
+        }
+        else {
+            parentDialog = this.showAncestorDialog(viewName);
+            setTimeout(() => {
+                if (parentDialog) {
+                    this.goToElementView($('[name="' + viewName + '"]'), viewName, pageName, variable);
+                }
+            });
+        }
+    }
+    /* If page name is equal to active pageName, this function returns the element in the page.
+     The element in the partial page is not selected.*/
+    getViewElementInActivePage($el) {
+        let selector;
+        if ($el.length > 1) {
+            selector = filter($el, (childSelector) => {
+                if (isEmpty($(childSelector).closest('[data-role = "partial"]')) && isEmpty($(childSelector).closest('[wmprefabcontainer]'))) {
+                    return childSelector;
+                }
+            });
+            if (selector) {
+                $el = $(selector);
+            }
+        }
+        return $el;
+    }
+    /**
+     * checks if the pagecontainer has the pageName.
+     */
+    isPartialWithNameExists(name) {
+        return $('[partialcontainer][content="' + name + '"]').length;
+    }
+    /**
+     * checks if the pagecontainer has the prefab.
+     */
+    isPrefabWithNameExists(prefabName) {
+        return $('[prefabName="' + prefabName + '"]').length;
+    }
+    /*
+     * shows all the parent container view elements for a given view element
+     */
+    showAncestors(element, variable) {
+        const ancestorSearchQuery = '[wm-navigable-element="true"]';
+        element
+            .parents(ancestorSearchQuery)
+            .toArray()
+            .reverse()
+            .forEach((parent) => {
+            const $el = parent.widget;
+            switch ($el.widgetType) {
+                case 'wm-accordionpane':
+                    $el.expand();
+                    break;
+                case 'wm-tabpane':
+                    $el.select();
+                    break;
+                case 'wm-segment-content':
+                    $el.navigate();
+                    break;
+                case 'wm-panel':
+                    /* flip the active flag */
+                    $el.expanded = true;
+                    break;
+            }
+        });
+    }
+    /*
+     * searches for a given view element inside the available dialogs in current page
+     * if found, the dialog is displayed, the dialog id is returned.
+     */
+    showAncestorDialog(viewName) {
+        let dialogId;
+        $('app-root [dialogtype]')
+            .each(function () {
+            const dialog = $(this);
+            if ($(dialog.html()).find('[name="' + viewName + '"]').length) {
+                dialogId = dialog.attr('name');
+                return false;
+            }
+        });
+        return dialogId;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: NavigationServiceImpl, deps: [{ token: i1.App }, { token: i2.Router }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: NavigationServiceImpl }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: NavigationServiceImpl, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [{ type: i1.App }, { type: i2.Router }, { type: i0.NgZone }] });
+class PageInfo {
+    constructor(name, urlParams, transition) {
+        this.name = name;
+        this.urlParams = urlParams;
+        this.transition = transition;
+        this.transition = isEmpty(this.transition) ? null : this.transition;
+    }
+    isEqual(page1) {
+        return page1 && page1.name === this.name && isEqual(page1.urlParams, this.urlParams);
+    }
+}
+class History {
+    constructor() {
+        this.stack = [];
+    }
+    getCurrentPage() {
+        return this.currentPage;
+    }
+    getPagesCount() {
+        return this.stack.length;
+    }
+    isLastVisitedPage(page) {
+        return this.getLastPage().isEqual(page);
+    }
+    push(pageInfo) {
+        if (this.currentPage) {
+            this.stack.push(this.currentPage);
+        }
+        this.currentPage = pageInfo;
+    }
+    pop() {
+        this.currentPage = this.stack.pop();
+        return this.currentPage;
+    }
+    getLastPage() {
+        return this.stack.length > 0 ? this.stack[this.stack.length - 1] : undefined;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"navigation.service.js","sourceRoot":"","sources":["../../../../../projects/runtime-base/src/services/navigation.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, NgZone } from '@angular/core';\nimport { NavigationStart, Router } from '@angular/router';\n\nimport { App, NavigationOptions, AbstractNavigationService } from '@wm/core';\nimport { CONSTANTS } from '@wm/variables';\nimport {filter, isEmpty, isEqual} from \"lodash-es\";\n\ndeclare const $;\n\nconst parentSelector = 'body >app-root';\n\n@Injectable()\nexport class NavigationServiceImpl implements AbstractNavigationService {\n    private history = new History();\n    private transition: string;\n    private isPageAddedToHistory = false;\n\n    constructor(private app: App, private router: Router, public zone: NgZone) {\n        this.router.events.subscribe(event => {\n            if (event instanceof NavigationStart) {\n                const url = event.url;\n                const urlParams = {};\n                let pageName;\n                if (!this.isPageAddedToHistory) {\n                    this.isPageAddedToHistory = false;\n                    if (url.indexOf('?') > 0) {\n                        url.substr(url.indexOf('?') + 1)\n                            .split('&')\n                            .forEach(s => {\n                                const splits = s.split('=');\n                                urlParams[splits[0]] = splits[1];\n                            });\n                        pageName = url.substr(0, url.indexOf('?'));\n                    } else {\n                        pageName = url;\n                    }\n                    if (pageName[0] === '/') {\n                        pageName = pageName.substr(1);\n                    }\n                    if (pageName) {\n                        /*\n                         * Commenting this code, one client project has Home_Page configured as Login Page.\n                         * So redirection to Home_Page post login is failing\n                         // if login page is being loaded and user is logged in, cancel that.\n                            if ($rs.isApplicationType) {\n                                stopLoginPagePostLogin($p);\n                            }\n                         */\n                        delete urlParams['name'];\n\n                        this.history.push(new PageInfo(pageName, urlParams, this.transition));\n                    }\n                }\n            }\n        });\n    }\n\n    public getPageTransition() {\n        if (isEmpty(this.transition) || isEqual('none', this.transition)) {\n            return null;\n        }\n        return this.transition;\n    }\n\n    /**\n     * Navigates to particular page\n     * @param pageName\n     * @param options\n     */\n    public goToPage(pageName: string, options: NavigationOptions) {\n        this.transition = options.transition || '';\n        // page is added to stack only when currentPage is available.\n        if (this.history.getCurrentPage()) {\n            this.isPageAddedToHistory = true;\n        }\n        this.history.push( new PageInfo(pageName, options.urlParams, this.transition));\n      /**\n       *  BrowserAnimcation module has issue with RouterOutlet\n          In the result every route appending to previous route instead of replace.\n          To fix the issue we are navigating inside the ngZones\n       *\n       *  */\n        this.zone.run(() => {\n            return this.router.navigate([`/${pageName}`], { queryParams: options.urlParams});\n        });\n\n    }\n\n    /**\n     * Navigates to last visited page.\n     */\n    public goToPrevious() {\n        if (this.history.getPagesCount()) {\n            this.transition = this.history.getCurrentPage().transition;\n            if (!isEmpty(this.transition)) {\n                this.transition += '-exit';\n            }\n            this.history.pop();\n            this.isPageAddedToHistory = true;\n            window.history.back();\n        }\n    }\n\n    /** Todo[Shubham] Need to handle gotoElement in other partials\n     * Navigates to particular view\n     * @param viewName\n     * @param options\n     * @param variable\n     */\n    public goToView(viewName: string, options: NavigationOptions, variable: any) {\n        options = options || {};\n        const pageName = options.pageName;\n        const transition = options.transition || '';\n        const $event = options.$event;\n        const activePage = this.app.activePage;\n        const prefabName = variable && variable._context && variable._context.prefabName;\n\n        // Check if app is Prefab\n        if (this.app.isPrefabType) {\n            this.goToElementView($(parentSelector).find('[name=\"' + viewName + '\"]'), viewName, pageName, variable);\n        } else {\n            // checking if the element is present in the page or not, if no show an error toaster\n            // if yes check if it is inside a partial/prefab in the page and then highlight the respective element\n            // else goto the page in which the element exists and highlight the element\n            if (pageName !== activePage.activePageName && !prefabName) {\n                if (this.isPartialWithNameExists(pageName)) {\n                    this.goToElementView($('[partialcontainer][content=\"' + pageName + '\"]').find('[name=\"' + viewName + '\"]'), viewName, pageName, variable);\n                } else {\n                    // Todo[Shubham]: Make an API call to get all pages and check if the page name\n                    //  is a page and then do this call else show an error as:\n                    //  this.app.notifyApp(CONSTANTS.WIDGET_DOESNT_EXIST, 'error');\n                    this.goToPage(pageName, {\n                        viewName: viewName,\n                        $event: $event,\n                        transition: transition,\n                        urlParams: options.urlParams\n                    });\n                    // subscribe to an event named pageReady which notifies this subscriber\n                    // when all widgets in page are loaded i.e when page is ready\n                    const pageReadySubscriber = this.app.subscribe('pageReady', (page) => {\n                        this.goToElementView($(parentSelector).find('[name=\"' + viewName + '\"]'), viewName, pageName, variable);\n                        pageReadySubscriber();\n                    });\n                }\n            } else if (prefabName && this.isPrefabWithNameExists(prefabName)) {\n                this.goToElementView($('[prefabName=\"' + prefabName + '\"]').find('[name=\"' + viewName + '\"]'), viewName, pageName, variable);\n            } else if (!pageName || pageName === activePage.activePageName) {\n                this.goToElementView($(parentSelector).find('[name=\"' + viewName + '\"]'), viewName, pageName, variable);\n            } else {\n                this.app.notifyApp(CONSTANTS.WIDGET_DOESNT_EXIST, 'error');\n            }\n        }\n    }\n\n    /*\n     * navigates the user to a view element with given name\n     * if the element not found in the compiled markup, the same is searched in the available dialogs in the page\n     */\n    private goToElementView(viewElement, viewName: string, pageName: string, variable: any) {\n        let $el, parentDialog;\n        const activePage = this.app.activePage;\n        if (viewElement.length) {\n            if (!this.app.isPrefabType && pageName === activePage.activePageName) {\n                viewElement = this.getViewElementInActivePage(viewElement);\n            }\n\n            $el = viewElement[0].widget;\n            switch ($el.widgetType) {\n                case 'wm-accordionpane':\n                    this.showAncestors(viewElement, variable);\n                    $el.expand();\n                    break;\n                case 'wm-tabpane':\n                    this.showAncestors(viewElement, variable);\n                    $el.select();\n                    break;\n                case 'wm-segment-content':\n                    this.showAncestors(viewElement, variable);\n                    $el.navigate();\n                    break;\n                case 'wm-panel':\n                    /* flip the active flag */\n                    $el.expanded = true;\n                    break;\n            }\n        } else {\n            parentDialog = this.showAncestorDialog(viewName);\n            setTimeout(() => {\n                if (parentDialog) {\n                    this.goToElementView($('[name=\"' + viewName + '\"]'), viewName, pageName, variable);\n                }\n            });\n        }\n    }\n\n    /* If page name is equal to active pageName, this function returns the element in the page.\n     The element in the partial page is not selected.*/\n    private getViewElementInActivePage($el) {\n        let selector;\n        if ($el.length > 1) {\n            selector = filter($el, (childSelector) => {\n                if (isEmpty($(childSelector).closest('[data-role = \"partial\"]')) && isEmpty($(childSelector).closest('[wmprefabcontainer]'))) {\n                    return childSelector;\n                }\n            });\n            if (selector) {\n                $el = $(selector);\n            }\n        }\n        return $el;\n    }\n\n    /**\n     * checks if the pagecontainer has the pageName.\n     */\n    private isPartialWithNameExists(name: string) {\n        return $('[partialcontainer][content=\"' + name + '\"]').length;\n    }\n\n    /**\n     * checks if the pagecontainer has the prefab.\n     */\n    private isPrefabWithNameExists(prefabName: string) {\n        return $('[prefabName=\"' + prefabName + '\"]').length;\n    }\n\n    /*\n     * shows all the parent container view elements for a given view element\n     */\n    private showAncestors(element, variable) {\n        const ancestorSearchQuery = '[wm-navigable-element=\"true\"]';\n\n        element\n            .parents(ancestorSearchQuery)\n            .toArray()\n            .reverse()\n            .forEach((parent) => {\n                const $el = parent.widget;\n                switch ($el.widgetType) {\n                    case 'wm-accordionpane':\n                        $el.expand();\n                        break;\n                    case 'wm-tabpane':\n                        $el.select();\n                        break;\n                    case 'wm-segment-content':\n                        $el.navigate();\n                        break;\n                    case 'wm-panel':\n                        /* flip the active flag */\n                        $el.expanded = true;\n                        break;\n                }\n            });\n    }\n\n\n\n    /*\n     * searches for a given view element inside the available dialogs in current page\n     * if found, the dialog is displayed, the dialog id is returned.\n     */\n    private showAncestorDialog(viewName: string) {\n        let dialogId;\n        $('app-root [dialogtype]')\n            .each(function () {\n                const dialog = $(this);\n                if ($(dialog.html()).find('[name=\"' + viewName + '\"]').length) {\n                    dialogId = dialog.attr('name');\n                    return false;\n                }\n            });\n        return dialogId;\n    }\n}\n\nclass PageInfo {\n\n    constructor(public name, public urlParams?, public transition?) {\n        this.transition = isEmpty(this.transition) ? null : this.transition;\n    }\n\n    public isEqual(page1: PageInfo) {\n        return page1 && page1.name === this.name && isEqual(page1.urlParams, this.urlParams);\n    }\n}\n\nclass History {\n    private stack: Array<PageInfo> = [];\n    private currentPage: PageInfo;\n\n    public getCurrentPage() {\n        return this.currentPage;\n    }\n\n    public getPagesCount() {\n        return this.stack.length;\n    }\n\n    public isLastVisitedPage(page: PageInfo) {\n        return this.getLastPage().isEqual(page);\n    }\n\n    public push(pageInfo: PageInfo) {\n        if (this.currentPage) {\n            this.stack.push(this.currentPage);\n        }\n        this.currentPage = pageInfo;\n    }\n\n    public pop() {\n        this.currentPage = this.stack.pop();\n        return this.currentPage;\n    }\n\n    public getLastPage() {\n        return this.stack.length > 0 ? this.stack[this.stack.length - 1] : undefined;\n    }\n}\n"]}

package/runtime/base/esm2022/services/pipe-provider.service.mjs

@@ -0,0 +1,127 @@
+import { ChangeDetectorRef, Compiler, Injectable, Injector, KeyValueDiffers } from '@angular/core';
+import { AsyncPipe, CurrencyPipe, DatePipe, DecimalPipe, I18nPluralPipe, I18nSelectPipe, JsonPipe, KeyValuePipe, LowerCasePipe, NgLocalization, PercentPipe, SlicePipe, TitleCasePipe, UpperCasePipe } from '@angular/common';
+import { CustomPipe, FileExtensionFromMimePipe, FileIconClassPipe, FileSizePipe, FilterPipe, NumberToStringPipe, PrefixPipe, SanitizePipe, StateClassPipe, StringToNumberPipe, SuffixPipe, TemplateReplacePipe, TimeFromNowPipe, ToCurrencyPipe, ToDatePipe, ToNumberPipe, TrustAsPipe } from '@wm/components/base';
+import { AbstractI18nService, App, CustomPipeManager, getSessionStorageItem } from '@wm/core';
+import { DomSanitizer } from "@angular/platform-browser";
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/platform-browser";
+import * as i2 from "@wm/core";
+export class PipeProvider {
+    setPipeData() {
+        this._pipeData = [
+            // TODO | NEED TO BE TESTED
+            this.preparePipeMeta(AsyncPipe, 'async', false, [ChangeDetectorRef]),
+            this.preparePipeMeta(SlicePipe, 'slice', false),
+            this.preparePipeMeta(PercentPipe, 'percent', true, [this._locale]),
+            this.preparePipeMeta(I18nPluralPipe, 'i18nPlural', true, [
+                NgLocalization
+            ]),
+            this.preparePipeMeta(I18nSelectPipe, 'i18nSelect', true),
+            this.preparePipeMeta(KeyValuePipe, 'keyvalue', false, [
+                KeyValueDiffers
+            ]),
+            this.preparePipeMeta(FileIconClassPipe, 'fileIconClass', true),
+            this.preparePipeMeta(FileExtensionFromMimePipe, 'fileExtensionFromMime', true),
+            this.preparePipeMeta(StateClassPipe, 'stateClass', true),
+            this.preparePipeMeta(FileSizePipe, 'filesize', true),
+            // TESTED
+            this.preparePipeMeta(FilterPipe, 'filter', true),
+            this.preparePipeMeta(UpperCasePipe, 'uppercase', true),
+            this.preparePipeMeta(LowerCasePipe, 'lowercase', true),
+            this.preparePipeMeta(JsonPipe, 'json', false),
+            this.preparePipeMeta(DecimalPipe, 'number', true, [this._locale]),
+            this.preparePipeMeta(TitleCasePipe, 'titlecase', true),
+            this.preparePipeMeta(CurrencyPipe, 'currency', true, [this._locale]),
+            this.preparePipeMeta(DatePipe, 'date', true, [this._locale]),
+            this.preparePipeMeta(ToDatePipe, 'toDate', true, [
+                new DatePipe(this._locale),
+                undefined,
+                this.injector.get(App),
+                this.injector.get(CustomPipeManager)
+            ]),
+            this.preparePipeMeta(ToNumberPipe, 'toNumber', true, [
+                new DecimalPipe(this._locale),
+                this.i18service
+            ]),
+            this.preparePipeMeta(ToCurrencyPipe, 'toCurrency', true, [
+                new DecimalPipe(this._locale),
+                this.i18service
+            ]),
+            this.preparePipeMeta(PrefixPipe, 'prefix', true),
+            this.preparePipeMeta(SuffixPipe, 'suffix', true),
+            this.preparePipeMeta(TimeFromNowPipe, 'timeFromNow', true),
+            this.preparePipeMeta(NumberToStringPipe, 'numberToString', true, [
+                new DecimalPipe(this._locale)
+            ]),
+            this.preparePipeMeta(StringToNumberPipe, 'stringToNumber', true),
+            this.preparePipeMeta(CustomPipe, 'custom', true, [this.injector.get(App), this.injector.get(CustomPipeManager)]),
+            this.preparePipeMeta(TrustAsPipe, 'trustAs', true, [this.domSanitizer]),
+            this.preparePipeMeta(SanitizePipe, 'sanitize', true, [this.domSanitizer]),
+            this.preparePipeMeta(TemplateReplacePipe, 'templateReplace', true),
+        ];
+    }
+    unknownPipe(name) {
+        throw Error(`The pipe '${name}' could not be found`);
+    }
+    constructor(compiler, injector, domSanitizer, i18service) {
+        this.compiler = compiler;
+        this.injector = injector;
+        this.domSanitizer = domSanitizer;
+        this.i18service = i18service;
+        this._locale = getSessionStorageItem('selectedLocale') || 'en';
+        this.preparePipeMeta = (reference, name, pure, diDeps = []) => ({
+            type: { reference, diDeps },
+            name,
+            pure
+        });
+        this._pipeData = [];
+        this._pipeMeta = new Map();
+        this.setPipeData();
+        this._pipeData.forEach(v => {
+            this._pipeMeta.set(v.name, v);
+        });
+        this.formatsByLocale = this.i18service ? this.i18service.getwidgetLocale() : {};
+    }
+    meta(name) {
+        const meta = this._pipeMeta.get(name);
+        if (!meta) {
+            this.unknownPipe(name);
+        }
+        return meta;
+    }
+    getPipeNameVsIsPureMap() {
+        const _map = new Map();
+        this._pipeMeta.forEach((v, k) => {
+            _map.set(k, v.pure);
+        });
+        return _map;
+    }
+    resolveDep(dep) {
+        return this.injector.get(dep.token.identifier.reference);
+    }
+    getInstance(name) {
+        const { type: { reference: ref, diDeps: deps } } = this.meta(name);
+        if (!ref) {
+            this.unknownPipe(name);
+        }
+        if (!deps.length) {
+            return new ref();
+        }
+        else {
+            const args = [];
+            for (const dep of deps) {
+                args.push(dep);
+            }
+            return new ref(...args);
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: PipeProvider, deps: [{ token: i0.Compiler }, { token: i0.Injector }, { token: i1.DomSanitizer }, { token: i2.AbstractI18nService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: PipeProvider, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: PipeProvider, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: i0.Compiler }, { type: i0.Injector }, { type: i1.DomSanitizer }, { type: i2.AbstractI18nService }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"pipe-provider.service.js","sourceRoot":"","sources":["../../../../../projects/runtime-base/src/services/pipe-provider.service.ts"],"names":[],"mappings":"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","sourcesContent":["import {ChangeDetectorRef, Compiler, Injectable, Injector, KeyValueDiffers, Pipe} from '@angular/core';\nimport {\n    AsyncPipe,\n    CurrencyPipe,\n    DatePipe,\n    DecimalPipe,\n    I18nPluralPipe,\n    I18nSelectPipe,\n    JsonPipe,\n    KeyValuePipe,\n    LowerCasePipe,\n    NgLocalization,\n    PercentPipe,\n    SlicePipe,\n    TitleCasePipe,\n    UpperCasePipe\n} from '@angular/common'\nimport {\n    CustomPipe,\n    FileExtensionFromMimePipe,\n    FileIconClassPipe,\n    FileSizePipe,\n    FilterPipe,\n    NumberToStringPipe,\n    PrefixPipe,\n    SanitizePipe,\n    StateClassPipe,\n    StringToNumberPipe,\n    SuffixPipe,\n    TemplateReplacePipe,\n    TimeFromNowPipe,\n    ToCurrencyPipe,\n    ToDatePipe,\n    ToNumberPipe,\n    TrustAsPipe\n} from '@wm/components/base';\nimport {AbstractI18nService, App, CustomPipeManager, getSessionStorageItem} from '@wm/core';\nimport {DomSanitizer} from \"@angular/platform-browser\";\n\n@Injectable({\n    providedIn: 'root'\n})\nexport class PipeProvider {\n    _pipeMeta;\n    _locale = getSessionStorageItem('selectedLocale') || 'en';\n    formatsByLocale;\n    preparePipeMeta = (\n        reference: Pipe,\n        name: string,\n        pure: boolean,\n        diDeps = []\n    ) => ({\n        type: { reference, diDeps },\n        name,\n        pure\n    });\n    _pipeData = [];\n\n    setPipeData() {\n        this._pipeData = [\n            // TODO | NEED TO BE TESTED\n            this.preparePipeMeta(AsyncPipe, 'async', false, [ChangeDetectorRef]),\n            this.preparePipeMeta(SlicePipe, 'slice', false),\n            this.preparePipeMeta(PercentPipe, 'percent', true, [this._locale]),\n            this.preparePipeMeta(I18nPluralPipe, 'i18nPlural', true, [\n                NgLocalization\n            ]),\n            this.preparePipeMeta(I18nSelectPipe, 'i18nSelect', true),\n            this.preparePipeMeta(KeyValuePipe, 'keyvalue', false, [\n                KeyValueDiffers\n            ]),\n            this.preparePipeMeta(FileIconClassPipe, 'fileIconClass', true),\n            this.preparePipeMeta(\n                FileExtensionFromMimePipe,\n                'fileExtensionFromMime',\n                true\n            ),\n            this.preparePipeMeta(StateClassPipe, 'stateClass', true),\n            this.preparePipeMeta(FileSizePipe, 'filesize', true),\n            // TESTED\n            this.preparePipeMeta(FilterPipe, 'filter', true),\n            this.preparePipeMeta(UpperCasePipe, 'uppercase', true),\n            this.preparePipeMeta(LowerCasePipe, 'lowercase', true),\n            this.preparePipeMeta(JsonPipe, 'json', false),\n            this.preparePipeMeta(DecimalPipe, 'number', true, [this._locale]),\n            this.preparePipeMeta(TitleCasePipe, 'titlecase', true),\n            this.preparePipeMeta(CurrencyPipe, 'currency', true, [this._locale]),\n            this.preparePipeMeta(DatePipe, 'date', true, [this._locale]),\n            this.preparePipeMeta(ToDatePipe, 'toDate', true, [\n                new DatePipe(this._locale),\n                undefined,\n                this.injector.get(App),\n                this.injector.get(CustomPipeManager)\n            ]),\n            this.preparePipeMeta(ToNumberPipe, 'toNumber', true, [\n                new DecimalPipe(this._locale),\n                this.i18service\n            ]),\n            this.preparePipeMeta(ToCurrencyPipe, 'toCurrency', true, [\n                new DecimalPipe(this._locale),\n                this.i18service\n            ]),\n            this.preparePipeMeta(PrefixPipe, 'prefix', true),\n            this.preparePipeMeta(SuffixPipe, 'suffix', true),\n            this.preparePipeMeta(TimeFromNowPipe, 'timeFromNow', true),\n            this.preparePipeMeta(NumberToStringPipe, 'numberToString', true, [\n                new DecimalPipe(this._locale)\n            ]),\n            this.preparePipeMeta(StringToNumberPipe, 'stringToNumber', true),\n            this.preparePipeMeta(CustomPipe, 'custom', true, [this.injector.get(App), this.injector.get(CustomPipeManager)]),\n            this.preparePipeMeta(TrustAsPipe, 'trustAs', true, [this.domSanitizer]),\n            this.preparePipeMeta(SanitizePipe, 'sanitize', true, [this.domSanitizer]),\n            this.preparePipeMeta(TemplateReplacePipe, 'templateReplace', true),\n        ];\n    }\n\n\n    unknownPipe(name) {\n        throw Error(`The pipe '${name}' could not be found`);\n    }\n\n    constructor(private compiler: Compiler, private injector: Injector, private domSanitizer:DomSanitizer, private i18service: AbstractI18nService) {\n        this._pipeMeta = new Map();\n        this.setPipeData();\n        this._pipeData.forEach(v => {\n            this._pipeMeta.set(v.name, v);\n        });\n        this.formatsByLocale = this.i18service? this.i18service.getwidgetLocale() : {};\n    }\n\n    meta(name) {\n        const meta = this._pipeMeta.get(name);\n        if (!meta) {\n            this.unknownPipe(name);\n        }\n        return meta;\n    }\n\n    getPipeNameVsIsPureMap() {\n        const _map = new Map();\n        this._pipeMeta.forEach((v, k) => {\n            _map.set(k, v.pure);\n        });\n        return _map;\n    }\n\n    resolveDep(dep) {\n        return this.injector.get(dep.token.identifier.reference);\n    }\n\n    getInstance(name) {\n        const {\n            type: { reference: ref, diDeps: deps }\n        } = this.meta(name);\n        if (!ref) {\n            this.unknownPipe(name);\n        }\n\n        if (!deps.length) {\n            return new ref();\n        } else {\n            const args = [];\n            for (const dep of deps) {\n                args.push(dep);\n            }\n            return new ref(...args);\n        }\n    }\n}"]}

package/runtime/base/esm2022/services/pipe.service.mjs

@@ -0,0 +1,33 @@
+import { Injectable } from "@angular/core";
+import { PipeProvider } from "./pipe-provider.service";
+import { App, setPipeProvider } from "@wm/core";
+import * as i0 from "@angular/core";
+import * as i1 from "./pipe-provider.service";
+import * as i2 from "@wm/core";
+export class PipeService {
+    constructor(pipeProvider, $app) {
+        this.pipeProvider = pipeProvider;
+        this.$app = $app;
+        this.supportedPipes = ["toDate", "toCurrency", "prefix", "suffix", "numberToString", "stringToNumber", "timeFromNow", "trustAs", "sanitize"];
+        // setting pipe provider, to be used for variables watcher in expression parser
+        setPipeProvider(pipeProvider);
+        if (this.$app.isApplicationType) {
+            this.supportedPipes.push('custom');
+        }
+    }
+    getPipe(name) {
+        if (this.supportedPipes.includes(name)) {
+            return this.pipeProvider.getInstance(name);
+        }
+        else {
+            throw Error(`The pipe '${name}' could not be found`);
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: PipeService, deps: [{ token: i1.PipeProvider }, { token: i2.App }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: PipeService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: PipeService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: () => [{ type: i1.PipeProvider }, { type: i2.App }] });
+//# sourceMappingURL=data:application/json;base64,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