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

package/components/base/esm2022/pipes/custom-pipes.mjs

@@ -0,0 +1,473 @@
+import { Inject, Pipe } from '@angular/core';
+import { DatePipe, DecimalPipe } from '@angular/common';
+import { AbstractI18nService, App, CURRENCY_INFO, CustomPipeManager, hasOffsetStr, isDefined, replace } from '@wm/core';
+import { WmPipe } from "./wm-pipe";
+import { filter, includes, isDate, isFunction, isObject, isUndefined, startsWith } from "lodash-es";
+import * as momentLib from 'moment-timezone/moment-timezone';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+import * as i2 from "@wm/core";
+const moment = momentLib.default || window['moment'];
+const getEpochValue = data => {
+    let epoch;
+    // For data in form of string number ('123'), convert to number (123). And don't parse date objects.
+    if (!isDate(data) && !isNaN(data)) {
+        data = parseInt(data, 10);
+    }
+    // get the timestamp value. If data is time string, append date string to the time value
+    epoch = moment(data).valueOf() || moment(new Date().toDateString() + ' ' + data).valueOf();
+    return epoch;
+};
+export class TrailingZeroDecimalPipe {
+    transform(value, selectedLocale, numberfilter, localefilter, trailingzero, decimalValue, skipTrailingZeroCheck, formattedLocale) {
+        numberfilter = trailingzero && !skipTrailingZeroCheck ? `1.${decimalValue.length}-16` : numberfilter;
+        const locale = formattedLocale ? formattedLocale['number'] : undefined;
+        return this.decimalPipe.transform(value, numberfilter, localefilter || locale || selectedLocale);
+    }
+    constructor(decimalPipe) {
+        this.decimalPipe = decimalPipe;
+    }
+    static { this.ɵfac = function TrailingZeroDecimalPipe_Factory(__ngFactoryType__) { return new (__ngFactoryType__ || TrailingZeroDecimalPipe)(i0.ɵɵdirectiveInject(i1.DecimalPipe, 16)); }; }
+    static { this.ɵpipe = /*@__PURE__*/ i0.ɵɵdefinePipe({ name: "trailingZeroDecimalPipe", type: TrailingZeroDecimalPipe, pure: true, standalone: true }); }
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(TrailingZeroDecimalPipe, [{
+        type: Pipe,
+        args: [{
+                standalone: true,
+                name: 'trailingZeroDecimalPipe'
+            }]
+    }], () => [{ type: i1.DecimalPipe }], null); })();
+export class ToDatePipe extends WmPipe {
+    // This method calls the custom formatter fn after applying the exisitng date pattern
+    returnFn(data, args, variables) {
+        if (this.isCustomPipe) {
+            if (args) {
+                args[0] = data;
+            }
+            return this.customFormatter(data, args, variables);
+        }
+        return data;
+    }
+    transform(data, format, timezone, compInstance) {
+        let timestamp;
+        // 'null' is to be treated as a special case, If user wants to enter null value, empty string will be passed to the backend
+        if (data === 'null' || data === '') {
+            return this.returnFn('', arguments, this.app.Variables);
+        }
+        if (!isDefined(data)) {
+            return this.returnFn('', arguments, this.app.Variables);
+        }
+        timestamp = getEpochValue(data);
+        if (timestamp) {
+            if (format === 'timestamp') {
+                return this.returnFn(timestamp, arguments, this.app.Variables);
+            }
+            if (format === 'UTC') {
+                return this.returnFn(new Date(timestamp).toISOString(), arguments, this.app.Variables);
+            }
+            let formattedVal;
+            const timeZone = this.i18nService ? this.i18nService.getTimezone(compInstance) : timezone;
+            if (timeZone && (data === timestamp || hasOffsetStr(data))) {
+                formattedVal = moment(timestamp).tz(timeZone).format(format.replaceAll('y', 'Y').replaceAll('d', 'D').replace('a', 'A'));
+            }
+            else {
+                formattedVal = this.datePipe.transform(timestamp, format);
+            }
+            return this.returnFn(formattedVal, arguments, this.app.Variables);
+        }
+        return this.returnFn('', arguments, this.app.Variables);
+    }
+    constructor(datePipe, i18nService, app, customPipeManager) {
+        super('toDate', customPipeManager);
+        this.datePipe = datePipe;
+        this.i18nService = i18nService;
+        this.app = app;
+        this.customPipeManager = customPipeManager;
+    }
+    static { this.ɵfac = function ToDatePipe_Factory(__ngFactoryType__) { return new (__ngFactoryType__ || ToDatePipe)(i0.ɵɵdirectiveInject(i1.DatePipe, 16), i0.ɵɵdirectiveInject(i2.AbstractI18nService, 16), i0.ɵɵdirectiveInject(i2.App, 16), i0.ɵɵdirectiveInject(i2.CustomPipeManager, 16)); }; }
+    static { this.ɵpipe = /*@__PURE__*/ i0.ɵɵdefinePipe({ name: "toDate", type: ToDatePipe, pure: true, standalone: true }); }
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(ToDatePipe, [{
+        type: Pipe,
+        args: [{
+                standalone: true,
+                name: 'toDate'
+            }]
+    }], () => [{ type: i1.DatePipe }, { type: i2.AbstractI18nService }, { type: i2.App }, { type: i2.CustomPipeManager }], null); })();
+export class ToNumberPipe {
+    transform(data, fracSize) {
+        if (fracSize && !String(fracSize).match(/^(\d+)?\.((\d+)(-(\d+))?)?$/)) {
+            fracSize = '1.' + fracSize + '-' + fracSize;
+        }
+        if (!isNaN(+data)) {
+            const locale = this.i18nService && this.i18nService.getwidgetLocale() ? this.i18nService.getwidgetLocale() : undefined;
+            const formattedLocale = locale ? locale['number'] : null;
+            return this.decimalPipe.transform(data, fracSize, formattedLocale);
+        }
+    }
+    constructor(decimalPipe, i18nService) {
+        this.decimalPipe = decimalPipe;
+        this.i18nService = i18nService;
+    }
+    static { this.ɵfac = function ToNumberPipe_Factory(__ngFactoryType__) { return new (__ngFactoryType__ || ToNumberPipe)(i0.ɵɵdirectiveInject(i1.DecimalPipe, 16), i0.ɵɵdirectiveInject(AbstractI18nService, 16)); }; }
+    static { this.ɵpipe = /*@__PURE__*/ i0.ɵɵdefinePipe({ name: "toNumber", type: ToNumberPipe, pure: true, standalone: true }); }
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(ToNumberPipe, [{
+        type: Pipe,
+        args: [{
+                standalone: true,
+                name: 'toNumber'
+            }]
+    }], () => [{ type: i1.DecimalPipe }, { type: i2.AbstractI18nService, decorators: [{
+                type: Inject,
+                args: [AbstractI18nService]
+            }] }], null); })();
+export class ToCurrencyPipe {
+    transform(data, currencySymbol, fracSize) {
+        const _currencySymbol = (CURRENCY_INFO[currencySymbol] || {}).symbol || currencySymbol || '';
+        let _val = new ToNumberPipe(this.decimalPipe, this.i18nService).transform(data, fracSize);
+        const isNegativeNumber = startsWith(_val, '-');
+        if (isNegativeNumber) {
+            _val = _val.replace('-', '');
+        }
+        return _val ? isNegativeNumber ? '-' + _currencySymbol + _val : _currencySymbol + _val : '';
+    }
+    constructor(decimalPipe, i18nService) {
+        this.decimalPipe = decimalPipe;
+        this.i18nService = i18nService;
+    }
+    static { this.ɵfac = function ToCurrencyPipe_Factory(__ngFactoryType__) { return new (__ngFactoryType__ || ToCurrencyPipe)(i0.ɵɵdirectiveInject(i1.DecimalPipe, 16), i0.ɵɵdirectiveInject(AbstractI18nService, 16)); }; }
+    static { this.ɵpipe = /*@__PURE__*/ i0.ɵɵdefinePipe({ name: "toCurrency", type: ToCurrencyPipe, pure: true, standalone: true }); }
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(ToCurrencyPipe, [{
+        type: Pipe,
+        args: [{
+                standalone: true,
+                name: 'toCurrency'
+            }]
+    }], () => [{ type: i1.DecimalPipe }, { type: i2.AbstractI18nService, decorators: [{
+                type: Inject,
+                args: [AbstractI18nService]
+            }] }], null); })();
+export class PrefixPipe {
+    transform(data, padding) {
+        return (isUndefined(data) || data === null || data === '') ? data : ((padding || '') + data);
+    }
+    static { this.ɵfac = function PrefixPipe_Factory(__ngFactoryType__) { return new (__ngFactoryType__ || PrefixPipe)(); }; }
+    static { this.ɵpipe = /*@__PURE__*/ i0.ɵɵdefinePipe({ name: "prefix", type: PrefixPipe, pure: true, standalone: true }); }
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(PrefixPipe, [{
+        type: Pipe,
+        args: [{
+                standalone: true,
+                name: 'prefix'
+            }]
+    }], null, null); })();
+export class SuffixPipe {
+    transform(data, padding) {
+        return (isUndefined(data) || data === null || data === '') ? data : (data + (padding || ''));
+    }
+    static { this.ɵfac = function SuffixPipe_Factory(__ngFactoryType__) { return new (__ngFactoryType__ || SuffixPipe)(); }; }
+    static { this.ɵpipe = /*@__PURE__*/ i0.ɵɵdefinePipe({ name: "suffix", type: SuffixPipe, pure: true, standalone: true }); }
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(SuffixPipe, [{
+        type: Pipe,
+        args: [{
+                standalone: true,
+                name: 'suffix'
+            }]
+    }], null, null); })();
+/**
+ * Custom pipe: It is work as interceptor between the user custom pipe function and angular pipe
+ */
+export class CustomPipe {
+    constructor(app, custmeUserPipe) {
+        this.app = app;
+        this.custmeUserPipe = custmeUserPipe;
+    }
+    transform(data, pipename) {
+        let argumentArr = [];
+        for (let i = 2; i < arguments.length; i++) {
+            argumentArr.push(arguments[i]);
+        }
+        let pipeRef = this.custmeUserPipe.getCustomPipe(pipename);
+        if (!pipeRef || !isFunction(pipeRef.formatter)) {
+            console.warn('formatter is not defined, please check the custom pipes documentation');
+            return data;
+        }
+        try {
+            return pipeRef.formatter(data, ...argumentArr, this.app.Variables);
+        }
+        catch (error) {
+            console.error('Pipe name: ' + pipename, error);
+            return data;
+        }
+    }
+    static { this.ɵfac = function CustomPipe_Factory(__ngFactoryType__) { return new (__ngFactoryType__ || CustomPipe)(i0.ɵɵdirectiveInject(i2.App, 16), i0.ɵɵdirectiveInject(i2.CustomPipeManager, 16)); }; }
+    static { this.ɵpipe = /*@__PURE__*/ i0.ɵɵdefinePipe({ name: "custom", type: CustomPipe, pure: true, standalone: true }); }
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(CustomPipe, [{
+        type: Pipe,
+        args: [{
+                standalone: true,
+                name: 'custom'
+            }]
+    }], () => [{ type: i2.App }, { type: i2.CustomPipeManager }], null); })();
+export class TimeFromNowPipe {
+    transform(data) {
+        let timestamp;
+        if (!isDefined(data)) {
+            return undefined;
+        }
+        timestamp = getEpochValue(data);
+        return timestamp ? moment(timestamp).fromNow() : undefined;
+    }
+    static { this.ɵfac = function TimeFromNowPipe_Factory(__ngFactoryType__) { return new (__ngFactoryType__ || TimeFromNowPipe)(); }; }
+    static { this.ɵpipe = /*@__PURE__*/ i0.ɵɵdefinePipe({ name: "timeFromNow", type: TimeFromNowPipe, pure: true, standalone: true }); }
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(TimeFromNowPipe, [{
+        type: Pipe,
+        args: [{
+                standalone: true,
+                name: 'timeFromNow'
+            }]
+    }], null, null); })();
+export class NumberToStringPipe extends ToNumberPipe {
+    static { this.ɵfac = /*@__PURE__*/ (() => { let ɵNumberToStringPipe_BaseFactory; return function NumberToStringPipe_Factory(__ngFactoryType__) { return (ɵNumberToStringPipe_BaseFactory || (ɵNumberToStringPipe_BaseFactory = i0.ɵɵgetInheritedFactory(NumberToStringPipe)))(__ngFactoryType__ || NumberToStringPipe); }; })(); }
+    static { this.ɵpipe = /*@__PURE__*/ i0.ɵɵdefinePipe({ name: "numberToString", type: NumberToStringPipe, pure: true, standalone: true }); }
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(NumberToStringPipe, [{
+        type: Pipe,
+        args: [{
+                standalone: true,
+                name: 'numberToString'
+            }]
+    }], null, null); })();
+export class StringToNumberPipe {
+    transform(data) {
+        return Number(data) || undefined;
+    }
+    static { this.ɵfac = function StringToNumberPipe_Factory(__ngFactoryType__) { return new (__ngFactoryType__ || StringToNumberPipe)(); }; }
+    static { this.ɵpipe = /*@__PURE__*/ i0.ɵɵdefinePipe({ name: "stringToNumber", type: StringToNumberPipe, pure: true, standalone: true }); }
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(StringToNumberPipe, [{
+        type: Pipe,
+        args: [{
+                standalone: true,
+                name: 'stringToNumber'
+            }]
+    }], null, null); })();
+export class FilterPipe {
+    transform(data, field, value) {
+        if (!data) {
+            return [];
+        }
+        // If object is passed as first paramter
+        if (isObject(field)) {
+            return filter(data, field);
+        }
+        // If key value pair is provided
+        return filter(data, item => {
+            return includes(item[field], value);
+        });
+    }
+    static { this.ɵfac = function FilterPipe_Factory(__ngFactoryType__) { return new (__ngFactoryType__ || FilterPipe)(); }; }
+    static { this.ɵpipe = /*@__PURE__*/ i0.ɵɵdefinePipe({ name: "filter", type: FilterPipe, pure: true, standalone: true }); }
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(FilterPipe, [{
+        type: Pipe,
+        args: [{
+                standalone: true,
+                name: 'filter'
+            }]
+    }], null, null); })();
+export class FileSizePipe {
+    transform(bytes, precision) {
+        const units = [
+            'bytes',
+            'KB',
+            'MB',
+            'GB',
+            'TB',
+            'PB'
+        ];
+        /*Todo[shubham]
+        if (isNaN(parseFloat(bytes)) || !isFinite(bytes)) {
+            return isMobile() ? '' : '?';
+        }*/
+        let unit = 0;
+        while (bytes >= 1024) {
+            bytes /= 1024;
+            unit++;
+        }
+        return bytes.toFixed(+precision) + ' ' + units[unit];
+    }
+    static { this.ɵfac = function FileSizePipe_Factory(__ngFactoryType__) { return new (__ngFactoryType__ || FileSizePipe)(); }; }
+    static { this.ɵpipe = /*@__PURE__*/ i0.ɵɵdefinePipe({ name: "filesize", type: FileSizePipe, pure: true, standalone: true }); }
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(FileSizePipe, [{
+        type: Pipe,
+        args: [{
+                standalone: true,
+                name: 'filesize'
+            }]
+    }], null, null); })();
+export class FileIconClassPipe {
+    transform(fileExtension) {
+        const fileClassMapping = {
+            'zip': 'fa-file-zip-o',
+            'pdf': 'fa-file-pdf-o',
+            'rar': 'fa-file-archive-o',
+            'txt': 'fa-file-text-o',
+            'ppt': 'fa-file-powerpoint-o',
+            'pot': 'fa-file-powerpoint-o',
+            'pps': 'fa-file-powerpoint-o',
+            'pptx': 'fa-file-powerpoint-o',
+            'potx': 'fa-file-powerpoint-o',
+            'ppsx': 'fa-file-powerpoint-o',
+            'mpg': 'fa-file-movie-o',
+            'mp4': 'fa-file-movie-o',
+            'mov': 'fa-file-movie-o',
+            'avi': 'fa-file-movie-o',
+            'mp3': 'fa-file-audio-o',
+            'docx': 'fa-file-word-o',
+            'js': 'fa-file-code-o',
+            'md': 'fa-file-code-o',
+            'html': 'fa-file-code-o',
+            'css': 'fa-file-code-o',
+            'xlsx': 'fa-file-excel-o',
+            'png': 'fa-file-image-o',
+            'jpg': 'fa-file-image-o',
+            'jpeg': 'fa-file-image-o',
+            'file': 'fa-file-o',
+            'default': 'fa-file-o'
+        };
+        return 'fa ' + (fileClassMapping[fileExtension] || 'fa-file-o');
+    }
+    static { this.ɵfac = function FileIconClassPipe_Factory(__ngFactoryType__) { return new (__ngFactoryType__ || FileIconClassPipe)(); }; }
+    static { this.ɵpipe = /*@__PURE__*/ i0.ɵɵdefinePipe({ name: "fileIconClass", type: FileIconClassPipe, pure: true, standalone: true }); }
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(FileIconClassPipe, [{
+        type: Pipe,
+        args: [{
+                standalone: true,
+                name: 'fileIconClass'
+            }]
+    }], null, null); })();
+export class StateClassPipe {
+    transform(state) {
+        const stateClassMap = {
+            'success': 'wi wi-check-circle text-success',
+            'error': 'wi wi-error text-danger'
+        };
+        return stateClassMap[state.toLowerCase()];
+    }
+    static { this.ɵfac = function StateClassPipe_Factory(__ngFactoryType__) { return new (__ngFactoryType__ || StateClassPipe)(); }; }
+    static { this.ɵpipe = /*@__PURE__*/ i0.ɵɵdefinePipe({ name: "stateClass", type: StateClassPipe, pure: true, standalone: true }); }
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(StateClassPipe, [{
+        type: Pipe,
+        args: [{
+                standalone: true,
+                name: 'stateClass'
+            }]
+    }], null, null); })();
+export class TemplateReplacePipe {
+    transform(data, replaceObj) {
+        return replace(data, replaceObj);
+    }
+    static { this.ɵfac = function TemplateReplacePipe_Factory(__ngFactoryType__) { return new (__ngFactoryType__ || TemplateReplacePipe)(); }; }
+    static { this.ɵpipe = /*@__PURE__*/ i0.ɵɵdefinePipe({ name: "templateReplace", type: TemplateReplacePipe, pure: true, standalone: true }); }
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(TemplateReplacePipe, [{
+        type: Pipe,
+        args: [{
+                standalone: true,
+                name: 'templateReplace'
+            }]
+    }], null, null); })();
+export class FileExtensionFromMimePipe {
+    transform(mimeType) {
+        const typeMapping = {
+            'audio/aac': '.aac',
+            'application/x-abiword': '.abw',
+            'application/vnd.android.package-archive': '.apk',
+            'video/x-msvideo': '.avi',
+            'application/vnd.amazon.ebook': '.azw',
+            'application/octet-stream': '.bin',
+            'image/bmp': '.bmp',
+            'application/x-bzip': '.bz',
+            'application/x-bzip2': '.bz2',
+            'application/x-csh': '.csh',
+            'text/css': '.css',
+            'text/csv': '.csv',
+            'application/msword': '.doc',
+            'application/vnd.openxmlformats-officedocument.wordprocessingml.document': '.docx',
+            'application/vnd.ms-fontobject': '.eot',
+            'application/epub+zip': '.epub',
+            'application/ecmascript': '.es',
+            'image/gif': '.gif',
+            'text/html': '.html',
+            'image/x-icon': '.ico',
+            'text/calendar': '.ics',
+            'application/java-archive': '.jar',
+            'image/jpeg': ['.jpeg', '.jpg'],
+            'application/javascript': '.js',
+            'application/json': '.json',
+            'audio/midi': '.mid',
+            'audio/x-midi': '.midi',
+            'video/mpeg': '.mpeg',
+            'application/vnd.apple.installer+xml': 'mpkg',
+            'application/vnd.oasis.opendocument.presentation': '.odp',
+            'application/vnd.oasis.opendocument.spreadsheet': '.ods',
+            'application/vnd.oasis.opendocument.text': '.odt',
+            'audio/ogg': '.oga',
+            'video/ogg': '.ogv',
+            'application/ogg': '.ogx',
+            'font/otf': '.otf',
+            'image/png': '.png',
+            'application/pdf': '.pdf',
+            'application/vnd.ms-powerpoint': '.ppt',
+            'application/vnd.openxmlformats-officedocument.presentationml.presentation': '.pptx',
+            'application/x-rar-compressed': '.rar',
+            'application/rtf': '.rtf',
+            'application/x-sh': '.sh',
+            'image/svg+xml': '.svg',
+            'application/x-shockwave-flash': '.swf',
+            'application/x-tar': '.tar',
+            'image/tiff': '.tiff',
+            'application/typescript': '.ts',
+            'font/ttf': '.ttf',
+            'text/plain': '.txt',
+            'application/vnd.visio': '.vsd',
+            'audio/wav': '.wav',
+            'audio/webm': '.weba',
+            'video/webm': '.webm',
+            'image/webp': '.webp',
+            'font/woff': '.woff',
+            'font/woff2': '.woff2',
+            'application/xhtml+xml': '.xhtml',
+            'application/vnd.ms-excel': '.xls',
+            'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet': '.xlsx',
+            'application/xml': '.xml',
+            'application/vnd.mozilla.xul+xml': '.xul',
+            'application/zip': '.zip',
+            'video/3gpp': '.3gp',
+            'audio/3gpp': '.3gp',
+            'video/3gpp2': '.3g2',
+            'audio/3gpp2': '.3g2',
+            'application/x-7z-compressed': '.7z'
+        };
+        return typeMapping[mimeType];
+    }
+    static { this.ɵfac = function FileExtensionFromMimePipe_Factory(__ngFactoryType__) { return new (__ngFactoryType__ || FileExtensionFromMimePipe)(); }; }
+    static { this.ɵpipe = /*@__PURE__*/ i0.ɵɵdefinePipe({ name: "fileExtensionFromMime", type: FileExtensionFromMimePipe, pure: true, standalone: true }); }
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(FileExtensionFromMimePipe, [{
+        type: Pipe,
+        args: [{
+                standalone: true,
+                name: 'fileExtensionFromMime'
+            }]
+    }], null, null); })();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"custom-pipes.js","sourceRoot":"","sources":["../../../../../projects/components/base/src/pipes/custom-pipes.ts"],"names":[],"mappings":"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","sourcesContent":["import {Inject, Pipe, PipeTransform} from '@angular/core';\nimport {DatePipe, DecimalPipe} from '@angular/common';\nimport {AbstractI18nService, App, CURRENCY_INFO, CustomPipeManager, hasOffsetStr, isDefined, replace} from '@wm/core';\nimport {WmPipe} from \"./wm-pipe\";\nimport {filter, includes, isDate, isFunction, isObject, isUndefined, startsWith} from \"lodash-es\";\n\nimport * as momentLib from 'moment-timezone/moment-timezone';\n\nconst moment = momentLib.default || window['moment'];\n\nconst getEpochValue = data => {\n    let epoch;\n    // For data in form of string number ('123'), convert to number (123). And don't parse date objects.\n    if (!isDate(data) && !isNaN(data)) {\n        data = parseInt(data, 10);\n    }\n    // get the timestamp value. If data is time string, append date string to the time value\n    epoch = moment(data).valueOf() || moment(new Date().toDateString() + ' ' + data).valueOf();\n    return epoch;\n};\n\n@Pipe({\n    standalone: true,\n    name: 'trailingZeroDecimalPipe'\n})\nexport class TrailingZeroDecimalPipe implements PipeTransform {\n    transform(value: any, selectedLocale: string, numberfilter: string, localefilter: any, trailingzero: boolean, decimalValue: string, skipTrailingZeroCheck?: boolean, formattedLocale?): any {\n        numberfilter = trailingzero && !skipTrailingZeroCheck ? `1.${decimalValue.length}-16`: numberfilter;\n        const locale = formattedLocale ? formattedLocale['number'] : undefined;\n        return this.decimalPipe.transform(value, numberfilter, localefilter || locale || selectedLocale);\n    }\n\n    constructor(private decimalPipe: DecimalPipe) { }\n\n}\n\n@Pipe({\n  standalone: true,\n    name: 'toDate'\n})\nexport class ToDatePipe extends WmPipe implements PipeTransform {\n    // This method calls the custom formatter fn after applying the exisitng date pattern\n    returnFn(data, args, variables) {\n        if (this.isCustomPipe) {\n            if (args) {\n                args[0] = data;\n            }\n            return this.customFormatter(data, args, variables);\n        }\n        return data;\n    }\n    transform(data: any, format: any, timezone?, compInstance?) {\n        let timestamp;\n        // 'null' is to be treated as a special case, If user wants to enter null value, empty string will be passed to the backend\n        if (data === 'null' || data === '') {\n            return this.returnFn('', arguments, this.app.Variables);\n        }\n        if (!isDefined(data)) {\n            return this.returnFn('',arguments, this.app.Variables);\n        }\n        timestamp = getEpochValue(data);\n        if (timestamp) {\n            if (format === 'timestamp') {\n                return this.returnFn(timestamp, arguments, this.app.Variables);\n            }\n            if (format === 'UTC') {\n                return this.returnFn(new Date(timestamp).toISOString(), arguments, this.app.Variables);\n            }\n            let formattedVal;\n            const timeZone = this.i18nService ? this.i18nService.getTimezone(compInstance) : timezone;\n            if (timeZone && (data === timestamp || hasOffsetStr(data))) {\n                formattedVal = (moment(timestamp) as any).tz(timeZone).format(format.replaceAll('y', 'Y').replaceAll('d', 'D').replace('a', 'A'));\n            } else {\n                formattedVal = this.datePipe.transform(timestamp, format);\n            }\n            return this.returnFn(formattedVal, arguments, this.app.Variables);\n        }\n        return this.returnFn('', arguments,this.app.Variables);\n    }\n\n    constructor(\n        private datePipe: DatePipe,\n        private i18nService: AbstractI18nService,\n        private app: App,\n        protected customPipeManager: CustomPipeManager\n    ) {\n        super('toDate', customPipeManager);\n    }\n}\n\n@Pipe({\n    standalone: true,\n    name: 'toNumber'\n})\nexport class ToNumberPipe implements PipeTransform {\n    transform(data, fracSize) {\n        if (fracSize && !String(fracSize).match(/^(\\d+)?\\.((\\d+)(-(\\d+))?)?$/)) {\n            fracSize = '1.' + fracSize + '-' + fracSize;\n        }\n        if (!isNaN(+data)) {\n            const locale = this.i18nService && this.i18nService.getwidgetLocale() ? this.i18nService.getwidgetLocale() : undefined;\n            const formattedLocale = locale ? locale['number'] : null;\n            return this.decimalPipe.transform(data, fracSize, formattedLocale);\n        }\n    }\n    constructor(private decimalPipe: DecimalPipe,  @Inject(AbstractI18nService) private i18nService: AbstractI18nService) {\n    }\n}\n\n@Pipe({\n    standalone: true,\n    name: 'toCurrency'\n})\nexport class ToCurrencyPipe implements PipeTransform {\n    transform(data, currencySymbol, fracSize) {\n        const _currencySymbol = (CURRENCY_INFO[currencySymbol] || {}).symbol || currencySymbol || '';\n        let _val = new ToNumberPipe(this.decimalPipe, this.i18nService).transform(data, fracSize);\n        const isNegativeNumber = startsWith(_val, '-');\n        if (isNegativeNumber) {\n            _val = _val.replace('-','');\n        }\n        return _val ? isNegativeNumber ? '-'+ _currencySymbol +_val :_currencySymbol + _val : '';\n    }\n\n    constructor(private decimalPipe: DecimalPipe, @Inject(AbstractI18nService) private i18nService: AbstractI18nService) {\n    }\n}\n\n@Pipe({\n    standalone: true,\n    name: 'prefix'\n})\nexport class PrefixPipe implements PipeTransform {\n    transform(data, padding) {\n        return (isUndefined(data) || data === null || data === '') ? data : ((padding || '') + data);\n    }\n}\n\n@Pipe({\n    standalone: true,\n    name: 'suffix'\n})\nexport class SuffixPipe implements PipeTransform {\n    transform(data, padding) {\n        return (isUndefined(data) || data === null || data === '') ? data : (data + (padding || ''));\n    }\n}\n\n\n/**\n * Custom pipe: It is work as interceptor between the user custom pipe function and angular pipe\n */\n@Pipe({\n    standalone: true,\n    name: 'custom'\n})\nexport class CustomPipe implements PipeTransform {\n    constructor(private app: App, private custmeUserPipe: CustomPipeManager) {\n\n    }\n    transform(data, pipename) {\n       let argumentArr = [];\n       for(let i =2 ; i<arguments.length; i++ ){\n        argumentArr.push(arguments[i]);\n       }\n\n        let pipeRef = this.custmeUserPipe.getCustomPipe(pipename);\n        if (!pipeRef || !isFunction(pipeRef.formatter)) {\n            console.warn('formatter is not defined, please check the custom pipes documentation');\n            return data;\n        }\n\n        try{\n            return pipeRef.formatter(data, ...argumentArr, this.app.Variables);\n        } catch(error){\n            console.error('Pipe name: '+pipename, error);\n            return data;\n         }\n    }\n}\n\n@Pipe({\n    standalone: true,\n    name: 'timeFromNow'\n})\nexport class TimeFromNowPipe implements PipeTransform {\n    transform(data) {\n        let timestamp;\n        if (!isDefined(data)) {\n            return undefined;\n        }\n        timestamp = getEpochValue(data);\n        return timestamp ? moment(timestamp).fromNow() : undefined;\n    }\n}\n\n@Pipe({\n    standalone: true,\n    name: 'numberToString'\n})\nexport class NumberToStringPipe extends ToNumberPipe implements PipeTransform { }\n\n@Pipe({\n    standalone: true,\n    name: 'stringToNumber'\n})\nexport class StringToNumberPipe implements PipeTransform {\n    transform(data) {\n        return Number(data) || undefined;\n    }\n}\n\n@Pipe({\n    standalone: true,\n    name: 'filter'\n})\nexport class FilterPipe implements PipeTransform {\n    transform(data: any[], field: any, value: any) {\n        if (!data) {\n            return [];\n        }\n        // If object is passed as first paramter\n        if (isObject(field)) {\n            return filter(data, field);\n        }\n        // If key value pair is provided\n        return filter(data, item => {\n            return includes(item[field], value);\n        });\n    }\n}\n\n@Pipe({\n    standalone: true,\n    name: 'filesize'\n})\nexport class FileSizePipe implements PipeTransform {\n    transform(bytes: number, precision: number) {\n        const units = [\n            'bytes',\n            'KB',\n            'MB',\n            'GB',\n            'TB',\n            'PB'\n        ];\n\n        /*Todo[shubham]\n        if (isNaN(parseFloat(bytes)) || !isFinite(bytes)) {\n            return isMobile() ? '' : '?';\n        }*/\n        let unit = 0;\n        while (bytes >= 1024) {\n            bytes /= 1024;\n            unit++;\n        }\n        return bytes.toFixed(+precision) + ' ' + units[unit];\n    }\n}\n\n@Pipe({\n    standalone: true,\n    name: 'fileIconClass'\n})\nexport class FileIconClassPipe implements PipeTransform {\n    transform(fileExtension: any) {\n        const fileClassMapping = {\n            'zip'       :   'fa-file-zip-o',\n            'pdf'       :   'fa-file-pdf-o',\n            'rar'       :   'fa-file-archive-o',\n            'txt'       :   'fa-file-text-o',\n            'ppt'       :   'fa-file-powerpoint-o',\n            'pot'       :   'fa-file-powerpoint-o',\n            'pps'       :   'fa-file-powerpoint-o',\n            'pptx'      :   'fa-file-powerpoint-o',\n            'potx'      :   'fa-file-powerpoint-o',\n            'ppsx'      :   'fa-file-powerpoint-o',\n            'mpg'       :   'fa-file-movie-o',\n            'mp4'       :   'fa-file-movie-o',\n            'mov'       :   'fa-file-movie-o',\n            'avi'       :   'fa-file-movie-o',\n            'mp3'       :   'fa-file-audio-o',\n            'docx'      :   'fa-file-word-o',\n            'js'        :   'fa-file-code-o',\n            'md'        :   'fa-file-code-o',\n            'html'      :   'fa-file-code-o',\n            'css'       :   'fa-file-code-o',\n            'xlsx'      :   'fa-file-excel-o',\n            'png'       :   'fa-file-image-o',\n            'jpg'       :   'fa-file-image-o',\n            'jpeg'      :   'fa-file-image-o',\n            'file'      :   'fa-file-o',\n            'default'   :   'fa-file-o'\n        };\n\n        return 'fa ' + (fileClassMapping[fileExtension] || 'fa-file-o');\n    }\n}\n\n@Pipe({\n    standalone: true,\n    name: 'stateClass'\n})\nexport class StateClassPipe implements PipeTransform {\n    transform(state) {\n        const stateClassMap = {\n            'success': 'wi wi-check-circle text-success',\n            'error'     : 'wi wi-error text-danger'\n        };\n        return stateClassMap[state.toLowerCase()];\n    }\n}\n\n@Pipe({\n    standalone: true,\n    name: 'templateReplace'\n})\nexport class TemplateReplacePipe implements PipeTransform {\n    transform(data:any, replaceObj:any) {\n        return replace(data, replaceObj);\n    }\n}\n\n@Pipe({\n    standalone: true,\n    name: 'fileExtensionFromMime'\n})\nexport class FileExtensionFromMimePipe implements PipeTransform {\n    transform(mimeType: any) {\n        const typeMapping = {\n            'audio/aac': '.aac',\n            'application/x-abiword': '.abw',\n            'application/vnd.android.package-archive': '.apk',\n            'video/x-msvideo': '.avi',\n            'application/vnd.amazon.ebook': '.azw',\n            'application/octet-stream': '.bin',\n            'image/bmp': '.bmp',\n            'application/x-bzip': '.bz',\n            'application/x-bzip2': '.bz2',\n            'application/x-csh': '.csh',\n            'text/css': '.css',\n            'text/csv': '.csv',\n            'application/msword': '.doc',\n            'application/vnd.openxmlformats-officedocument.wordprocessingml.document': '.docx',\n            'application/vnd.ms-fontobject': '.eot',\n            'application/epub+zip': '.epub',\n            'application/ecmascript': '.es',\n            'image/gif': '.gif',\n            'text/html': '.html',\n            'image/x-icon': '.ico',\n            'text/calendar': '.ics',\n            'application/java-archive': '.jar',\n            'image/jpeg': ['.jpeg', '.jpg'],\n            'application/javascript': '.js',\n            'application/json': '.json',\n            'audio/midi': '.mid',\n            'audio/x-midi': '.midi',\n            'video/mpeg': '.mpeg',\n            'application/vnd.apple.installer+xml': 'mpkg',\n            'application/vnd.oasis.opendocument.presentation': '.odp',\n            'application/vnd.oasis.opendocument.spreadsheet': '.ods',\n            'application/vnd.oasis.opendocument.text': '.odt',\n            'audio/ogg': '.oga',\n            'video/ogg': '.ogv',\n            'application/ogg': '.ogx',\n            'font/otf': '.otf',\n            'image/png': '.png',\n            'application/pdf': '.pdf',\n            'application/vnd.ms-powerpoint': '.ppt',\n            'application/vnd.openxmlformats-officedocument.presentationml.presentation': '.pptx',\n            'application/x-rar-compressed': '.rar',\n            'application/rtf': '.rtf',\n            'application/x-sh': '.sh',\n            'image/svg+xml': '.svg',\n            'application/x-shockwave-flash': '.swf',\n            'application/x-tar': '.tar',\n            'image/tiff': '.tiff',\n            'application/typescript': '.ts',\n            'font/ttf': '.ttf',\n            'text/plain': '.txt',\n            'application/vnd.visio': '.vsd',\n            'audio/wav': '.wav',\n            'audio/webm': '.weba',\n            'video/webm': '.webm',\n            'image/webp': '.webp',\n            'font/woff': '.woff',\n            'font/woff2': '.woff2',\n            'application/xhtml+xml': '.xhtml',\n            'application/vnd.ms-excel': '.xls',\n            'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet': '.xlsx',\n            'application/xml': '.xml',\n            'application/vnd.mozilla.xul+xml': '.xul',\n            'application/zip': '.zip',\n            'video/3gpp': '.3gp',\n            'audio/3gpp': '.3gp',\n            'video/3gpp2': '.3g2',\n            'audio/3gpp2': '.3g2',\n            'application/x-7z-compressed': '.7z'\n        };\n\n        return typeMapping[mimeType];\n    }\n}\n\n\n"]}

package/components/base/esm2022/pipes/image.pipe.mjs

@@ -0,0 +1,19 @@
+import { Pipe } from '@angular/core';
+import { transformFileURI } from '@wm/core';
+import { getImageUrl } from '../utils/widget-utils';
+import * as i0 from "@angular/core";
+export class ImagePipe {
+    transform(url, encode, defaultImageUrl) {
+        return transformFileURI(getImageUrl(url, encode, defaultImageUrl));
+    }
+    static { this.ɵfac = function ImagePipe_Factory(__ngFactoryType__) { return new (__ngFactoryType__ || ImagePipe)(); }; }
+    static { this.ɵpipe = /*@__PURE__*/ i0.ɵɵdefinePipe({ name: "image", type: ImagePipe, pure: true, standalone: true }); }
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(ImagePipe, [{
+        type: Pipe,
+        args: [{
+                standalone: true,
+                name: 'image'
+            }]
+    }], null, null); })();
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW1hZ2UucGlwZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2NvbXBvbmVudHMvYmFzZS9zcmMvcGlwZXMvaW1hZ2UucGlwZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsSUFBSSxFQUFpQixNQUFNLGVBQWUsQ0FBQztBQUdwRCxPQUFPLEVBQUUsZ0JBQWdCLEVBQUUsTUFBTSxVQUFVLENBQUM7QUFFNUMsT0FBTyxFQUFFLFdBQVcsRUFBRSxNQUFNLHVCQUF1QixDQUFDOztBQU1wRCxNQUFNLE9BQU8sU0FBUztJQUNsQixTQUFTLENBQUMsR0FBVyxFQUFFLE1BQWdCLEVBQUUsZUFBd0I7UUFDN0QsT0FBTyxnQkFBZ0IsQ0FBQyxXQUFXLENBQUMsR0FBRyxFQUFFLE1BQU0sRUFBRSxlQUFlLENBQUMsQ0FBQyxDQUFDO0lBQ3ZFLENBQUM7MEdBSFEsU0FBUzsrRUFBVCxTQUFTOztpRkFBVCxTQUFTO2NBSnJCLElBQUk7ZUFBQztnQkFDSixVQUFVLEVBQUUsSUFBSTtnQkFDZCxJQUFJLEVBQUUsT0FBTzthQUNoQiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IFBpcGUsIFBpcGVUcmFuc2Zvcm0gfSBmcm9tICdAYW5ndWxhci9jb3JlJztcblxuXG5pbXBvcnQgeyB0cmFuc2Zvcm1GaWxlVVJJIH0gZnJvbSAnQHdtL2NvcmUnO1xuXG5pbXBvcnQgeyBnZXRJbWFnZVVybCB9IGZyb20gJy4uL3V0aWxzL3dpZGdldC11dGlscyc7XG5cbkBQaXBlKHtcbiAgc3RhbmRhbG9uZTogdHJ1ZSxcbiAgICBuYW1lOiAnaW1hZ2UnXG59KVxuZXhwb3J0IGNsYXNzIEltYWdlUGlwZSBpbXBsZW1lbnRzIFBpcGVUcmFuc2Zvcm0ge1xuICAgIHRyYW5zZm9ybSh1cmw6IHN0cmluZywgZW5jb2RlPzogYm9vbGVhbiwgZGVmYXVsdEltYWdlVXJsPzogc3RyaW5nKSB7XG4gICAgICAgIHJldHVybiB0cmFuc2Zvcm1GaWxlVVJJKGdldEltYWdlVXJsKHVybCwgZW5jb2RlLCBkZWZhdWx0SW1hZ2VVcmwpKTtcbiAgICB9XG59XG4iXX0=

package/components/base/esm2022/pipes/sanitize.pipe.mjs

@@ -0,0 +1,44 @@
+import { Pipe, SecurityContext } from "@angular/core";
+import { DomSanitizer } from "@angular/platform-browser";
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/platform-browser";
+export class SanitizePipe {
+    constructor(domSanitizer) {
+        this.domSanitizer = domSanitizer;
+    }
+    transform(content, context) {
+        if (content === null || content === undefined) {
+            return '';
+        }
+        switch (context) {
+            case 'html':
+            case SecurityContext.HTML:
+                return this.domSanitizer.sanitize(SecurityContext.HTML, content);
+            case 'style':
+            case SecurityContext.STYLE:
+                return this.domSanitizer.sanitize(SecurityContext.STYLE, content);
+            case 'script':
+            case SecurityContext.SCRIPT:
+                return this.domSanitizer.sanitize(SecurityContext.SCRIPT, content);
+            case 'url':
+            case SecurityContext.URL:
+                return this.domSanitizer.sanitize(SecurityContext.URL, content);
+            case 'resource':
+            case SecurityContext.RESOURCE_URL:
+                return this.domSanitizer.sanitize(SecurityContext.RESOURCE_URL, content);
+            case 'none':
+            case SecurityContext.NONE:
+                return this.domSanitizer.sanitize(SecurityContext.NONE, content);
+        }
+    }
+    static { this.ɵfac = function SanitizePipe_Factory(__ngFactoryType__) { return new (__ngFactoryType__ || SanitizePipe)(i0.ɵɵdirectiveInject(i1.DomSanitizer, 16)); }; }
+    static { this.ɵpipe = /*@__PURE__*/ i0.ɵɵdefinePipe({ name: "sanitize", type: SanitizePipe, pure: true, standalone: true }); }
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(SanitizePipe, [{
+        type: Pipe,
+        args: [{
+                standalone: true,
+                name: 'sanitize'
+            }]
+    }], () => [{ type: i1.DomSanitizer }], null); })();
+//# sourceMappingURL=data:application/json;base64,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