@yuuvis/client-core 0.6.5

package/esm2022/lib/util/utils.mjs

@@ -0,0 +1,373 @@
+import { EMPTY as observableEmpty } from 'rxjs';
+import { Sort } from './utils.helper.enum';
+export class Utils {
+    static optionsToURLParams(options) {
+        if (options) {
+            const searchParams = new URLSearchParams();
+            Object.keys(options).map((k) => searchParams.append(k, options[k]));
+            return `?${searchParams.toString()}`;
+        }
+        return '';
+    }
+    /**
+     * Get all focusable child elements of a host element.
+     * @param host The host/parent element
+     * @returns Array of focusable child elements
+     */
+    static getFocusableChildren(host) {
+        return Array.from(host.querySelectorAll('a[href], button, input, textarea, select, details,[tabindex]:not([tabindex="-1"])')).filter((el) => !el.hasAttribute('disabled') && !el.getAttribute('aria-hidden'));
+    }
+    static hasProperty(o, property) {
+        if (typeof o !== 'object' || o === null) {
+            return false;
+        }
+        return Object.hasOwn(o, property);
+    }
+    static patternToRegExp(pattern) {
+        return new RegExp(pattern.replaceAll('*', '.*'));
+    }
+    /**
+     * Utility method for adding parameters to a given URI.
+     *
+     * @param uri The uri string to attach the parameters to
+     * @param params The object containing parameters to be appended
+     * @returns the given uri extended by the given parameters + remove empty parameters
+     */
+    static buildUri(uri, params) {
+        const q = Object.keys(params)
+            .filter((k) => !Utils.isEmptyOrFalse(params[k]))
+            .map((k) => k + '=' + encodeURIComponent(typeof params[k] === 'object' ? JSON.stringify(params[k]) : params[k]))
+            .join('&');
+        return uri + (q ? '?' + q : '');
+    }
+    static formatMailTo(value, isEmail) {
+        if (isEmail && !!value) {
+            if (Array.isArray(value)) {
+                return value.join().replace(/,/g, '; ');
+            }
+            else {
+                return value.replace(/,/g, '; ');
+            }
+        }
+        return value;
+    }
+    /**
+     * Creates a unique identifier.
+     * @returns A Universally Unique Identifier
+     */
+    static uuid() {
+        return Utils._p8() + Utils._p8(true) + Utils._p8(true) + Utils._p8();
+    }
+    /**
+     * Encode a filename safe for sending chars beyond ASCII-7bit using quoted printable encoding.
+     *
+     * @param filename The file name
+     * @returns The quoted printable filename
+     */
+    static encodeFileName(filename) {
+        const fileName = Utils.encodeToQuotedPrintable(Utils.encodeToUtf8(filename)).replace(/_/g, '=5F');
+        return `=?UTF-8?Q?${fileName}?=`;
+    }
+    /**
+     *
+     * @param boolean s
+     * @return string
+     */
+    static _p8(s) {
+        const p = (Math.random().toString(16) + '000000000').substr(2, 8);
+        return s ? `-${p.substr(0, 4)}-${p.substr(4, 4)}` : p;
+    }
+    /**
+     * Converts a javascript text to the utf-8 converted variant.
+     * See [unicode]{@link http://thlist.onlinehome.de/thomas_homepage/unicode/UTF-8%20Konvertierung%20mittels%20JavaScript.htm} for reference
+     *
+     * @param rawinput The input string
+     * @returns The utf-8 converted string
+     */
+    static encodeToUtf8(rawinput) {
+        /**
+         * Normalize line breaks
+         */
+        rawinput = rawinput.replace(/\r\n/g, '\n');
+        let utfreturn = '';
+        for (let n = 0; n < rawinput.length; n++) {
+            /**
+             * Unicode for current char
+             */
+            const c = rawinput.charCodeAt(n);
+            if (c < 128) {
+                /**
+                 * All chars range 0-127 => 1byte
+                 */
+                utfreturn += String.fromCharCode(c);
+            }
+            else if (c > 127 && c < 2048) {
+                /**
+                 * All chars range from 127 to 2047 => 2byte
+                 */
+                utfreturn += String.fromCharCode((c >> 6) | 192);
+                utfreturn += String.fromCharCode((c & 63) | 128);
+            }
+            else {
+                /**
+                 * All chars range from 2048 to 66536 => 3byte
+                 */
+                utfreturn += String.fromCharCode((c >> 12) | 224);
+                utfreturn += String.fromCharCode(((c >> 6) & 63) | 128);
+                utfreturn += String.fromCharCode((c & 63) | 128);
+            }
+        }
+        return utfreturn;
+    }
+    /**
+     * See [quoted-printable]{@link https://github.com/mathiasbynens/quoted-printable/blob/master/quoted-printable.js}
+     **/
+    static quotedPrintable(symbol) {
+        if (symbol > '\xFF') {
+            throw RangeError('`encodeToQuotedPrintable` expects extended ASCII input only. Missing prior UTF-8 encoding?');
+        }
+        const codePoint = symbol.charCodeAt(0);
+        const hexadecimal = codePoint.toString(16).toUpperCase();
+        return '=' + ('0' + hexadecimal).slice(-2);
+    }
+    /**
+     * Encode symbols that are definitely unsafe (i.e. unsafe in any context). The regular expression describes these unsafe symbols.
+     *
+     * @param rawinput Input string to be encoded
+     * @returns The encoded string
+     */
+    static encodeToQuotedPrintable(rawinput) {
+        const encoded = rawinput.replace(/[\0-\b\n-\x1F=\x7F-\uD7FF\uDC00-\uFFFF]|[\uD800-\uDBFF][\uDC00-\uDFFF]|[\uD800-\uDBFF]/g, this.quotedPrintable);
+        return encoded;
+    }
+    /**
+     * Sorts An Array of Object by given key
+     * See [ng-packagr issues 696]{@link https://github.com/dherges/ng-packagr/issues/696}
+     *
+     * @param key
+     * @param order
+     * @param locales
+     * @param options
+     * @returns (a: any, b: any) => number
+     */
+    static sortValues(key = '', order = Sort.ASC, locales, options) {
+        const f = (a, b) => {
+            let comparison;
+            const varA = Utils.getProperty(a, key);
+            const varB = Utils.getProperty(b, key);
+            if (typeof varA === 'number' && typeof varB === 'number') {
+                comparison = varA - varB;
+            }
+            else if (varA instanceof Date && varB instanceof Date) {
+                comparison = new Date(varA).getTime() - new Date(varB).getTime();
+            }
+            else {
+                const stringA = varA || varA === 0 ? varA.toString() : '';
+                const stringB = varB || varB === 0 ? varB.toString() : '';
+                comparison = stringA.localeCompare(stringB, locales, options);
+            }
+            return order === Sort.DESC ? comparison * -1 : comparison;
+        };
+        return f;
+    }
+    /**
+     * [ng-packagr issues 696]{@link https://github.com/dherges/ng-packagr/issues/696}
+     *
+     * @param object
+     * @param string key
+     * @returns any
+     */
+    static getProperty(object, key = '') {
+        const f = key ? key.split('.').reduce((o, k) => (o || {})[k], object) : object;
+        return f;
+    }
+    /**
+     * @param object
+     * @param key
+     * @param value
+     */
+    static setProperty(object, key = '', value) {
+        const [head, ...rest] = key.split('.');
+        !rest.length ? (object[head] = value) : Utils.setProperty(object[head] || (object[head] = {}), value, rest.join('.'));
+    }
+    /**
+     * Use on Observable.catch or Observable.subscribe to return empty value
+     * [ng-packagr issues 696]{@link https://github.com/dherges/ng-packagr/issues/696}
+     *
+     * @param (error) => any callback
+     * @returns (error) => Observable<never>
+     */
+    static empty(callback) {
+        const f = () => {
+            return observableEmpty;
+        };
+        return f;
+    }
+    // /**
+    //  * Use on Observable.catch with specific skipNotification function !!!
+    //  * [ng-packagr issues 696]{@link https://github.com/dherges/ng-packagr/issues/696}
+    //  *
+    //  * @param skipNotification
+    //  * @param callback
+    //  * @param name
+    //  * @param message
+    //  */
+    // public static catchSkip(skipNotification?: (error: any) => any, callback?: (error: any) => any, name?: string, message?: string) {
+    //   const f = (error: any) => {
+    //     const _error = callback && callback(error);
+    //     const _skipNotification = skipNotification && skipNotification(error);
+    //     return throwError(() => new YuvError(_error instanceof Error ? _error : error, name, message, _skipNotification));
+    //   };
+    //   return f;
+    // }
+    // /**
+    //  * Use on Observable.catch !!!
+    //  * [ng-packagr issues]{@link https://github.com/dherges/ng-packagr/issues/696}
+    //  *
+    //  * @param callback
+    //  * @param name
+    //  * @param message
+    //  * @param skipNotification
+    //  * @return (error) => Observable<never>
+    //  */
+    // public static catch(callback?: (error: any) => any, name?: string, message?: string, skipNotification?: boolean) {
+    //   const f = (error: any) => {
+    //     const _error = callback && callback(error);
+    //     return throwError(() => new YuvError(_error instanceof Error ? _error : error, name, message, skipNotification));
+    //   };
+    //   return f;
+    // }
+    // /**
+    //  * Use on Observable.subscribe !!!
+    //  * [ng-packagr issues]{@link https://github.com/dherges/ng-packagr/issues/696}
+    //  *
+    //  * @param callback
+    //  * @param name
+    //  * @param message
+    //  * @param skipNotification
+    //  * @return (error) => void
+    //  */
+    // public static throw(callback?: (error: any) => any, name?: string, message?: string, skipNotification?: boolean) {
+    //   const f = (error: any) => {
+    //     const _error = callback && callback(error);
+    //     throw new YuvError(_error instanceof Error ? _error : error, name, message, skipNotification);
+    //   };
+    //   return f;
+    // }
+    // /**
+    //  * Use on Observable.subscribe only if you want to skip notification / toast!!!
+    //  *
+    //  * @param callback
+    //  * @param name
+    //  * @param message
+    //  * @param skipNotification
+    //  * @return (error) => void
+    //  */
+    // public static logError(callback?: (error: any) => any, name?: string, message?: string, skipNotification = true) {
+    //   return Utils.throw(callback, name, message, skipNotification);
+    // }
+    // /**
+    //  * Checks if element is visible
+    //  *
+    //  * @param elem
+    //  * @return boolean
+    //  */
+    // public static isVisible(elem: any): boolean {
+    //   return !!(elem.offsetWidth || elem.offsetHeight || elem.getClientRects().length);
+    // }
+    static getBaseHref(removeTrailingSlash) {
+        const baseEl = document.getElementsByTagName('base')[0];
+        const baseHref = baseEl ? baseEl.getAttribute('href') : undefined;
+        return baseHref ? (removeTrailingSlash ? baseHref.substr(0, baseHref.length - 1) : baseHref) : '';
+    }
+    /**
+     * Truncate a string (first argument) if it is longer than the given maximum string length (second argument).
+     * Return the truncated string with a ... ending or whats provided.
+     *
+     * @param string str
+     * @param number num
+     */
+    static truncateString(str, num, ending = '...') {
+        if (str.length > num) {
+            if (num > 3) {
+                num -= 3;
+            }
+            str = `${str.substring(0, num)}${ending}`;
+        }
+        return str;
+    }
+    /**
+     * Get the TimeZone Offsest as minutes
+     */
+    static getTimezoneOffset() {
+        return new Date().getTimezoneOffset();
+    }
+    /**
+     * Transform to date with yyyy-mm-dd format
+     */
+    static transformDate(v) {
+        return v && new Date(new Date(v).getTime() - new Date(v).getTimezoneOffset() * 60 * 1000).toISOString().slice(0, 10);
+    }
+    static isEdge() {
+        return new RegExp('Edge', 'i').test(navigator.userAgent);
+    }
+    static isFirefox() {
+        return new RegExp('firefox', 'i').test(navigator.userAgent);
+    }
+    static isSafari() {
+        return new RegExp('^((?!chrome|android|crios|fxios).)*safari', 'i').test(navigator.userAgent);
+    }
+    static isEmpty(obj) {
+        if (obj == null || obj === '') {
+            return true;
+        }
+        if (typeof obj === 'number') {
+            return isNaN(obj);
+        }
+        return typeof obj === 'boolean' ? false : !Object.keys(obj).length;
+    }
+    static isEmptyOrFalse(val) {
+        return typeof val === 'boolean' ? !val : Utils.isEmpty(val);
+    }
+    static escapeHtml(str) {
+        str = str ? str : '';
+        const entityMap = {
+            '&': '&amp;',
+            '<': '&lt;',
+            '>': '&gt;',
+            '"': '&quot;',
+            "'": '&#39;',
+            '/': '&#x2F;'
+        };
+        return String(str).replace(/[&<>"'\/]/g, (s) => entityMap[s]);
+    }
+    static arrayToObject(arr = [], keyProperty, valueProperty) {
+        const key = typeof keyProperty === 'string' ? (o) => o[keyProperty] : keyProperty;
+        const value = typeof valueProperty === 'string' ? (o) => o[valueProperty] : valueProperty;
+        return arr.reduce((acc, cur, i) => {
+            acc[key ? key(cur) : i] = value ? value(cur) : cur;
+            return acc;
+        }, {});
+    }
+    // public static navigate(newTab: boolean, router: Router, commands: any[], navigationExtras?: NavigationExtras): Promise<any> {
+    //   if (newTab) {
+    //     return new Promise(() => Utils.openWindow(router.serializeUrl(router.createUrlTree(commands, navigationExtras))));
+    //   } else {
+    //     return router.navigate(commands, navigationExtras);
+    //   }
+    // }
+    // public static openWindow(url: string = '', target = '_blank', features?: string): Window | null {
+    //   return window.open(url.match(new RegExp('^/.+')) ? url.replace(new RegExp('^/'), '') : url, target, features); // relative to host
+    // }
+    static downloadBlob(content, mimeType, filename) {
+        const bom = new Uint8Array([0xef, 0xbb, 0xbf]); // FORM BOM
+        const blob = new Blob([bom, content], { type: 'octet/stream' });
+        const a = document.createElement('a');
+        const url = window.URL.createObjectURL(blob);
+        a.setAttribute('href', url);
+        a.setAttribute('download', filename);
+        a.click();
+        URL.revokeObjectURL(url);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"utils.js","sourceRoot":"","sources":["../../../../../../../libs/yuuvis/client-core/src/lib/util/utils.ts"],"names":[],"mappings":"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","sourcesContent":["import { EMPTY as observableEmpty } from 'rxjs';\nimport { FormattedMailTo, Sort } from './utils.helper.enum';\n\nexport class Utils {\n  static optionsToURLParams(options: Record<string, any>): string {\n    if (options) {\n      const searchParams = new URLSearchParams();\n      Object.keys(options).map((k) => searchParams.append(k, options[k]));\n      return `?${searchParams.toString()}`;\n    }\n    return '';\n  }\n\n  /**\n   * Get all focusable child elements of a host element.\n   * @param host The host/parent element\n   * @returns Array of focusable child elements\n   */\n  public static getFocusableChildren(host: HTMLElement): Element[] {\n    return Array.from(host.querySelectorAll('a[href], button, input, textarea, select, details,[tabindex]:not([tabindex=\"-1\"])')).filter(\n      (el) => !el.hasAttribute('disabled') && !el.getAttribute('aria-hidden')\n    );\n  }\n\n  public static hasProperty(o: unknown, property: string): boolean {\n    if (typeof o !== 'object' || o === null) {\n      return false;\n    }\n    return Object.hasOwn(o, property);\n  }\n\n  public static patternToRegExp(pattern: string): RegExp {\n    return new RegExp(pattern.replaceAll('*', '.*'));\n  }\n\n  /**\n   * Utility method for adding parameters to a given URI.\n   *\n   * @param uri The uri string to attach the parameters to\n   * @param params The object containing parameters to be appended\n   * @returns the given uri extended by the given parameters + remove empty parameters\n   */\n  public static buildUri(uri: string, params: any): string {\n    const q = Object.keys(params)\n      .filter((k) => !Utils.isEmptyOrFalse(params[k]))\n      .map((k) => k + '=' + encodeURIComponent(typeof params[k] === 'object' ? JSON.stringify(params[k]) : params[k]))\n      .join('&');\n    return uri + (q ? '?' + q : '');\n  }\n\n  public static formatMailTo(value: FormattedMailTo, isEmail: boolean): FormattedMailTo {\n    if (isEmail && !!value) {\n      if (Array.isArray(value)) {\n        return value.join().replace(/,/g, '; ');\n      } else {\n        return value.replace(/,/g, '; ');\n      }\n    }\n    return value;\n  }\n\n  /**\n   * Creates a unique identifier.\n   * @returns A Universally Unique Identifier\n   */\n  public static uuid(): string {\n    return Utils._p8() + Utils._p8(true) + Utils._p8(true) + Utils._p8();\n  }\n\n  /**\n   * Encode a filename safe for sending chars beyond ASCII-7bit using quoted printable encoding.\n   *\n   * @param filename The file name\n   * @returns The quoted printable filename\n   */\n  public static encodeFileName(filename: string): string {\n    const fileName = Utils.encodeToQuotedPrintable(Utils.encodeToUtf8(filename)).replace(/_/g, '=5F');\n    return `=?UTF-8?Q?${fileName}?=`;\n  }\n\n  /**\n   *\n   * @param boolean s\n   * @return string\n   */\n  private static _p8(s?: boolean): string {\n    const p = (Math.random().toString(16) + '000000000').substr(2, 8);\n    return s ? `-${p.substr(0, 4)}-${p.substr(4, 4)}` : p;\n  }\n\n  /**\n   * Converts a javascript text to the utf-8 converted variant.\n   * See [unicode]{@link http://thlist.onlinehome.de/thomas_homepage/unicode/UTF-8%20Konvertierung%20mittels%20JavaScript.htm} for reference\n   *\n   * @param rawinput The input string\n   * @returns The utf-8 converted string\n   */\n  private static encodeToUtf8(rawinput: string) {\n    /**\n     * Normalize line breaks\n     */\n    rawinput = rawinput.replace(/\\r\\n/g, '\\n');\n    let utfreturn = '';\n    for (let n = 0; n < rawinput.length; n++) {\n      /**\n       * Unicode for current char\n       */\n      const c = rawinput.charCodeAt(n);\n      if (c < 128) {\n        /**\n         * All chars range 0-127 => 1byte\n         */\n        utfreturn += String.fromCharCode(c);\n      } else if (c > 127 && c < 2048) {\n        /**\n         * All chars range from 127 to 2047 => 2byte\n         */\n        utfreturn += String.fromCharCode((c >> 6) | 192);\n        utfreturn += String.fromCharCode((c & 63) | 128);\n      } else {\n        /**\n         * All chars range from 2048 to 66536 => 3byte\n         */\n        utfreturn += String.fromCharCode((c >> 12) | 224);\n        utfreturn += String.fromCharCode(((c >> 6) & 63) | 128);\n        utfreturn += String.fromCharCode((c & 63) | 128);\n      }\n    }\n    return utfreturn;\n  }\n\n  /**\n   * See [quoted-printable]{@link https://github.com/mathiasbynens/quoted-printable/blob/master/quoted-printable.js}\n   **/\n  private static quotedPrintable(symbol: string) {\n    if (symbol > '\\xFF') {\n      throw RangeError('`encodeToQuotedPrintable` expects extended ASCII input only. Missing prior UTF-8 encoding?');\n    }\n    const codePoint = symbol.charCodeAt(0);\n    const hexadecimal = codePoint.toString(16).toUpperCase();\n    return '=' + ('0' + hexadecimal).slice(-2);\n  }\n\n  /**\n   * Encode symbols that are definitely unsafe (i.e. unsafe in any context). The regular expression describes these unsafe symbols.\n   *\n   * @param rawinput Input string to be encoded\n   * @returns The encoded string\n   */\n  private static encodeToQuotedPrintable(rawinput: string): string {\n    const encoded = rawinput.replace(/[\\0-\\b\\n-\\x1F=\\x7F-\\uD7FF\\uDC00-\\uFFFF]|[\\uD800-\\uDBFF][\\uDC00-\\uDFFF]|[\\uD800-\\uDBFF]/g, this.quotedPrintable);\n    return encoded;\n  }\n\n  /**\n   * Sorts An Array of Object by given key\n   * See [ng-packagr issues 696]{@link https://github.com/dherges/ng-packagr/issues/696}\n   *\n   * @param key\n   * @param order\n   * @param locales\n   * @param options\n   * @returns (a: any, b: any) => number\n   */\n  public static sortValues(key = '', order = Sort.ASC, locales?: string | string[], options?: Intl.CollatorOptions) {\n    const f = (a: any, b: any) => {\n      let comparison: number;\n      const varA = Utils.getProperty(a, key);\n      const varB = Utils.getProperty(b, key);\n\n      if (typeof varA === 'number' && typeof varB === 'number') {\n        comparison = varA - varB;\n      } else if (varA instanceof Date && varB instanceof Date) {\n        comparison = new Date(varA).getTime() - new Date(varB).getTime();\n      } else {\n        const stringA = varA || varA === 0 ? varA.toString() : '';\n        const stringB = varB || varB === 0 ? varB.toString() : '';\n        comparison = stringA.localeCompare(stringB, locales, options);\n      }\n      return order === Sort.DESC ? comparison * -1 : comparison;\n    };\n    return f;\n  }\n\n  /**\n   * [ng-packagr issues 696]{@link https://github.com/dherges/ng-packagr/issues/696}\n   *\n   * @param object\n   * @param string key\n   * @returns any\n   */\n  public static getProperty(object: any, key = ''): any {\n    const f = key ? key.split('.').reduce((o, k) => (o || {})[k], object) : object;\n    return f;\n  }\n\n  /**\n   * @param object\n   * @param key\n   * @param value\n   */\n  public static setProperty(object: any, key = '', value: any): any {\n    const [head, ...rest] = key.split('.');\n    !rest.length ? (object[head] = value) : Utils.setProperty(object[head] || (object[head] = {}), value, rest.join('.'));\n  }\n\n  /**\n   * Use on Observable.catch or Observable.subscribe to return empty value\n   * [ng-packagr issues 696]{@link https://github.com/dherges/ng-packagr/issues/696}\n   *\n   * @param (error) => any callback\n   * @returns (error) => Observable<never>\n   */\n  public static empty(callback?: (error: any) => any) {\n    const f = () => {\n      return observableEmpty;\n    };\n    return f;\n  }\n\n  // /**\n  //  * Use on Observable.catch with specific skipNotification function !!!\n  //  * [ng-packagr issues 696]{@link https://github.com/dherges/ng-packagr/issues/696}\n  //  *\n  //  * @param skipNotification\n  //  * @param callback\n  //  * @param name\n  //  * @param message\n  //  */\n  // public static catchSkip(skipNotification?: (error: any) => any, callback?: (error: any) => any, name?: string, message?: string) {\n  //   const f = (error: any) => {\n  //     const _error = callback && callback(error);\n  //     const _skipNotification = skipNotification && skipNotification(error);\n  //     return throwError(() => new YuvError(_error instanceof Error ? _error : error, name, message, _skipNotification));\n  //   };\n  //   return f;\n  // }\n\n  // /**\n  //  * Use on Observable.catch !!!\n  //  * [ng-packagr issues]{@link https://github.com/dherges/ng-packagr/issues/696}\n  //  *\n  //  * @param callback\n  //  * @param name\n  //  * @param message\n  //  * @param skipNotification\n  //  * @return (error) => Observable<never>\n  //  */\n  // public static catch(callback?: (error: any) => any, name?: string, message?: string, skipNotification?: boolean) {\n  //   const f = (error: any) => {\n  //     const _error = callback && callback(error);\n  //     return throwError(() => new YuvError(_error instanceof Error ? _error : error, name, message, skipNotification));\n  //   };\n  //   return f;\n  // }\n\n  // /**\n  //  * Use on Observable.subscribe !!!\n  //  * [ng-packagr issues]{@link https://github.com/dherges/ng-packagr/issues/696}\n  //  *\n  //  * @param callback\n  //  * @param name\n  //  * @param message\n  //  * @param skipNotification\n  //  * @return (error) => void\n  //  */\n  // public static throw(callback?: (error: any) => any, name?: string, message?: string, skipNotification?: boolean) {\n  //   const f = (error: any) => {\n  //     const _error = callback && callback(error);\n  //     throw new YuvError(_error instanceof Error ? _error : error, name, message, skipNotification);\n  //   };\n  //   return f;\n  // }\n\n  // /**\n  //  * Use on Observable.subscribe only if you want to skip notification / toast!!!\n  //  *\n  //  * @param callback\n  //  * @param name\n  //  * @param message\n  //  * @param skipNotification\n  //  * @return (error) => void\n  //  */\n  // public static logError(callback?: (error: any) => any, name?: string, message?: string, skipNotification = true) {\n  //   return Utils.throw(callback, name, message, skipNotification);\n  // }\n\n  // /**\n  //  * Checks if element is visible\n  //  *\n  //  * @param elem\n  //  * @return boolean\n  //  */\n  // public static isVisible(elem: any): boolean {\n  //   return !!(elem.offsetWidth || elem.offsetHeight || elem.getClientRects().length);\n  // }\n\n  public static getBaseHref(removeTrailingSlash?: boolean) {\n    const baseEl = document.getElementsByTagName('base')[0];\n    const baseHref = baseEl ? baseEl.getAttribute('href') : undefined;\n    return baseHref ? (removeTrailingSlash ? baseHref.substr(0, baseHref.length - 1) : baseHref) : '';\n  }\n\n  /**\n   * Truncate a string (first argument) if it is longer than the given maximum string length (second argument).\n   * Return the truncated string with a ... ending or whats provided.\n   *\n   * @param string str\n   * @param number num\n   */\n  public static truncateString(str: string, num: number, ending = '...') {\n    if (str.length > num) {\n      if (num > 3) {\n        num -= 3;\n      }\n      str = `${str.substring(0, num)}${ending}`;\n    }\n    return str;\n  }\n\n  /**\n   * Get the TimeZone Offsest as minutes\n   */\n  public static getTimezoneOffset(): number {\n    return new Date().getTimezoneOffset();\n  }\n\n  /**\n   * Transform to date with yyyy-mm-dd format\n   */\n  public static transformDate(v: Date | string): string {\n    return v && new Date(new Date(v).getTime() - new Date(v).getTimezoneOffset() * 60 * 1000).toISOString().slice(0, 10);\n  }\n\n  public static isEdge(): boolean {\n    return new RegExp('Edge', 'i').test(navigator.userAgent);\n  }\n\n  public static isFirefox(): boolean {\n    return new RegExp('firefox', 'i').test(navigator.userAgent);\n  }\n\n  public static isSafari(): boolean {\n    return new RegExp('^((?!chrome|android|crios|fxios).)*safari', 'i').test(navigator.userAgent);\n  }\n\n  public static isEmpty(obj: any) {\n    if (obj == null || obj === '') {\n      return true;\n    }\n\n    if (typeof obj === 'number') {\n      return isNaN(obj);\n    }\n\n    return typeof obj === 'boolean' ? false : !Object.keys(obj).length;\n  }\n\n  public static isEmptyOrFalse(val: any) {\n    return typeof val === 'boolean' ? !val : Utils.isEmpty(val);\n  }\n\n  public static escapeHtml(str: string) {\n    str = str ? str : '';\n    const entityMap: any = {\n      '&': '&amp;',\n      '<': '&lt;',\n      '>': '&gt;',\n      '\"': '&quot;',\n      \"'\": '&#39;',\n      '/': '&#x2F;'\n    };\n    return String(str).replace(/[&<>\"'\\/]/g, (s) => entityMap[s]);\n  }\n\n  public static arrayToObject<T>(\n    arr: any[] = [],\n    keyProperty?: string | ((o: any) => string),\n    valueProperty?: string | ((o: any) => any)\n  ): { [key: string]: T } {\n    const key = typeof keyProperty === 'string' ? (o: any) => o[keyProperty] : keyProperty;\n    const value = typeof valueProperty === 'string' ? (o: any) => o[valueProperty] : valueProperty;\n    return arr.reduce((acc: any, cur, i) => {\n      acc[key ? key(cur) : i] = value ? value(cur) : cur;\n      return acc;\n    }, {});\n  }\n\n  // public static navigate(newTab: boolean, router: Router, commands: any[], navigationExtras?: NavigationExtras): Promise<any> {\n  //   if (newTab) {\n  //     return new Promise(() => Utils.openWindow(router.serializeUrl(router.createUrlTree(commands, navigationExtras))));\n  //   } else {\n  //     return router.navigate(commands, navigationExtras);\n  //   }\n  // }\n\n  // public static openWindow(url: string = '', target = '_blank', features?: string): Window | null {\n  //   return window.open(url.match(new RegExp('^/.+')) ? url.replace(new RegExp('^/'), '') : url, target, features); // relative to host\n  // }\n\n  public static downloadBlob(content: any, mimeType: string, filename: string): void {\n    const bom = new Uint8Array([0xef, 0xbb, 0xbf]); // FORM BOM\n    const blob = new Blob([bom, content], { type: 'octet/stream' });\n    const a = document.createElement('a');\n    const url = window.URL.createObjectURL(blob);\n    a.setAttribute('href', url);\n    a.setAttribute('download', filename);\n    a.click();\n    URL.revokeObjectURL(url);\n  }\n}\n"]}

package/esm2022/yuuvis-client-core.mjs

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './index';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoieXV1dmlzLWNsaWVudC1jb3JlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vbGlicy95dXV2aXMvY2xpZW50LWNvcmUvc3JjL3l1dXZpcy1jbGllbnQtY29yZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7R0FFRztBQUVILGNBQWMsU0FBUyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBHZW5lcmF0ZWQgYnVuZGxlIGluZGV4LiBEbyBub3QgZWRpdC5cbiAqL1xuXG5leHBvcnQgKiBmcm9tICcuL2luZGV4JztcbiJdfQ==