ngx-edu-sharing-ui 0.7.0 → 9.0.1

package/esm2022/lib/util/color-helper.mjs

@@ -0,0 +1,124 @@
+export class ColorHelper {
+    static cssColorToRgb(color) {
+        color = color.trim();
+        if (color.startsWith('rgb')) {
+            let result = /rgb.?\(\s*([\d]*)\s*,\s*([\d]*)\s*,\s*([\d*]*)\s*/i.exec(color);
+            return result ? [parseInt(result[1]), parseInt(result[2]), parseInt(result[3])] : null;
+        }
+        let result = /^#?([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})$/i.exec(color);
+        return result
+            ? [parseInt(result[1], 16), parseInt(result[2], 16), parseInt(result[3], 16)]
+            : null;
+    }
+    /**
+     * returns the estimated color brightness for a css color based on a pereceived brightness factor
+     * Value between [0,1] and -1 if the css string was not readable
+     * @param {string} color
+     * @returns {number}
+     */
+    static getColorBrightness(color) {
+        const rgb = ColorHelper.cssColorToRgb(color);
+        if (rgb) {
+            // return (rgb[0]*0.2126 + rgb[1]*0.7152 + rgb[2]*0.0722) / 255;
+            const a = rgb.map((v) => {
+                v /= 255;
+                return v <= 0.03928 ? v / 12.92 : Math.pow((v + 0.055) / 1.055, 2.4);
+            });
+            return a[0] * 0.2126 + a[1] * 0.7152 + a[2] * 0.0722;
+        }
+        return -1;
+    }
+    static getRatio(l1, l2) {
+        // calculate the color contrast ratio
+        return l1 > l2 ? (l2 + 0.05) / (l1 + 0.05) : (l1 + 0.05) / (l2 + 0.05);
+    }
+    /**
+     * returns 0 (black) or 1 (white)
+     * @param color
+     */
+    static getPreferredColor(color) {
+        if (!color) {
+            return PreferredColor.Black;
+        }
+        const brightness = ColorHelper.getColorBrightness(color);
+        const ratioBlack = ColorHelper.getRatio(0, brightness);
+        const ratioWhite = ColorHelper.getRatio(1, brightness);
+        return ratioBlack > ratioWhite ? PreferredColor.Black : PreferredColor.White;
+    }
+    static rgbToHex(rgb) {
+        return ('#' +
+            ColorHelper.componentToHex(rgb[0]) +
+            ColorHelper.componentToHex(rgb[1]) +
+            ColorHelper.componentToHex(rgb[2]));
+    }
+    static componentToHex(c) {
+        var hex = Math.max(0, Math.min(Math.round(c), 255)).toString(16);
+        return hex.length == 1 ? '0' + hex : hex;
+    }
+    static rgbToHsl(rgb) {
+        const r = rgb[0] / 255;
+        const g = rgb[1] / 255;
+        const b = rgb[2] / 255;
+        const max = Math.max(r, g, b);
+        const min = Math.min(r, g, b);
+        // tslint:disable-next-line:one-variable-per-declaration prefer-const
+        let h, s, l = (max + min) / 2;
+        if (max === min) {
+            h = s = 0;
+        }
+        else {
+            const d = max - min;
+            s = l > 0.5 ? d / (2 - max - min) : d / (max + min);
+            switch (max) {
+                case r:
+                    h = (g - b) / d + (g < b ? 6 : 0);
+                    break;
+                case g:
+                    h = (b - r) / d + 2;
+                    break;
+                case b:
+                    h = (r - g) / d + 4;
+                    break;
+            }
+            h /= 6;
+        }
+        return [h, s, l];
+    }
+    static hue2rgb(p, q, t) {
+        if (t < 0)
+            t += 1;
+        if (t > 1)
+            t -= 1;
+        if (t < 1 / 6)
+            return p + (q - p) * 6 * t;
+        if (t < 1 / 2)
+            return q;
+        if (t < 2 / 3)
+            return p + (q - p) * (2 / 3 - t) * 6;
+        return p;
+    }
+    static hslToRgb(hsl) {
+        const h = hsl[0];
+        const s = hsl[1];
+        const l = hsl[2];
+        // tslint:disable-next-line:one-variable-per-declaration
+        let r, g, b;
+        if (s === 0) {
+            r = g = b = l;
+        }
+        else {
+            const q = l < 0.5 ? l * (1 + s) : l + s - l * s;
+            const p = 2 * l - q;
+            r = ColorHelper.hue2rgb(p, q, h + 1 / 3);
+            g = ColorHelper.hue2rgb(p, q, h);
+            b = ColorHelper.hue2rgb(p, q, h - 1 / 3);
+        }
+        return [r * 255, g * 255, b * 255];
+    }
+}
+export var PreferredColor;
+(function (PreferredColor) {
+    PreferredColor[PreferredColor["Black"] = 0] = "Black";
+    PreferredColor[PreferredColor["White"] = 1] = "White";
+})(PreferredColor || (PreferredColor = {}));
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"color-helper.js","sourceRoot":"","sources":["../../../../../projects/edu-sharing-ui/src/lib/util/color-helper.ts"],"names":[],"mappings":"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","sourcesContent":["export class ColorHelper {\n    public static cssColorToRgb(color: string): number[] {\n        color = color.trim();\n        if (color.startsWith('rgb')) {\n            let result = /rgb.?\\(\\s*([\\d]*)\\s*,\\s*([\\d]*)\\s*,\\s*([\\d*]*)\\s*/i.exec(color);\n            return result ? [parseInt(result[1]), parseInt(result[2]), parseInt(result[3])] : null;\n        }\n        let result = /^#?([a-f\\d]{2})([a-f\\d]{2})([a-f\\d]{2})$/i.exec(color);\n        return result\n            ? [parseInt(result[1], 16), parseInt(result[2], 16), parseInt(result[3], 16)]\n            : null;\n    }\n\n    /**\n     * returns the estimated color brightness for a css color based on a pereceived brightness factor\n     * Value between [0,1] and -1 if the css string was not readable\n     * @param {string} color\n     * @returns {number}\n     */\n    public static getColorBrightness(color: string) {\n        const rgb = ColorHelper.cssColorToRgb(color);\n        if (rgb) {\n            // return (rgb[0]*0.2126 + rgb[1]*0.7152 + rgb[2]*0.0722) / 255;\n            const a = rgb.map((v) => {\n                v /= 255;\n                return v <= 0.03928 ? v / 12.92 : Math.pow((v + 0.055) / 1.055, 2.4);\n            });\n            return a[0] * 0.2126 + a[1] * 0.7152 + a[2] * 0.0722;\n        }\n        return -1;\n    }\n\n    private static getRatio(l1: number, l2: number) {\n        // calculate the color contrast ratio\n        return l1 > l2 ? (l2 + 0.05) / (l1 + 0.05) : (l1 + 0.05) / (l2 + 0.05);\n    }\n    /**\n     * returns 0 (black) or 1 (white)\n     * @param color\n     */\n    public static getPreferredColor(color: string): PreferredColor {\n        if (!color) {\n            return PreferredColor.Black;\n        }\n        const brightness = ColorHelper.getColorBrightness(color);\n        const ratioBlack = ColorHelper.getRatio(0, brightness);\n        const ratioWhite = ColorHelper.getRatio(1, brightness);\n        return ratioBlack > ratioWhite ? PreferredColor.Black : PreferredColor.White;\n    }\n\n    public static rgbToHex(rgb: number[]): string {\n        return (\n            '#' +\n            ColorHelper.componentToHex(rgb[0]) +\n            ColorHelper.componentToHex(rgb[1]) +\n            ColorHelper.componentToHex(rgb[2])\n        );\n    }\n    public static componentToHex(c: number) {\n        var hex = Math.max(0, Math.min(Math.round(c), 255)).toString(16);\n        return hex.length == 1 ? '0' + hex : hex;\n    }\n    public static rgbToHsl(rgb: number[]) {\n        const r = rgb[0] / 255;\n        const g = rgb[1] / 255;\n        const b = rgb[2] / 255;\n        const max = Math.max(r, g, b);\n        const min = Math.min(r, g, b);\n        // tslint:disable-next-line:one-variable-per-declaration prefer-const\n        let h,\n            s,\n            l = (max + min) / 2;\n        if (max === min) {\n            h = s = 0;\n        } else {\n            const d = max - min;\n            s = l > 0.5 ? d / (2 - max - min) : d / (max + min);\n\n            switch (max) {\n                case r:\n                    h = (g - b) / d + (g < b ? 6 : 0);\n                    break;\n                case g:\n                    h = (b - r) / d + 2;\n                    break;\n                case b:\n                    h = (r - g) / d + 4;\n                    break;\n            }\n            h /= 6;\n        }\n        return [h, s, l];\n    }\n    private static hue2rgb(p: number, q: number, t: number) {\n        if (t < 0) t += 1;\n        if (t > 1) t -= 1;\n        if (t < 1 / 6) return p + (q - p) * 6 * t;\n        if (t < 1 / 2) return q;\n        if (t < 2 / 3) return p + (q - p) * (2 / 3 - t) * 6;\n        return p;\n    }\n    public static hslToRgb(hsl: number[]) {\n        const h = hsl[0];\n        const s = hsl[1];\n        const l = hsl[2];\n        // tslint:disable-next-line:one-variable-per-declaration\n        let r, g, b;\n        if (s === 0) {\n            r = g = b = l;\n        } else {\n            const q = l < 0.5 ? l * (1 + s) : l + s - l * s;\n            const p = 2 * l - q;\n\n            r = ColorHelper.hue2rgb(p, q, h + 1 / 3);\n            g = ColorHelper.hue2rgb(p, q, h);\n            b = ColorHelper.hue2rgb(p, q, h - 1 / 3);\n        }\n\n        return [r * 255, g * 255, b * 255];\n    }\n}\nexport enum PreferredColor {\n    Black,\n    White,\n}\n"]}

package/esm2022/lib/util/duration-helper.mjs

@@ -0,0 +1,102 @@
+export var DurationFormat;
+(function (DurationFormat) {
+    /**
+     * format with colon, i.e. H:MM:SS
+     */
+    DurationFormat["Colon"] = "colon";
+    /**
+     * format with Hh Mm Ss
+     */
+    DurationFormat["Hms"] = "hms";
+})(DurationFormat || (DurationFormat = {}));
+export class DurationHelper {
+    static getDurationInSeconds(value) {
+        // PT1H5M23S
+        // or 00:00:00
+        // or 00:00
+        if (!value)
+            return 0;
+        try {
+            let result = value.split(':');
+            if (result.length == 3) {
+                let h = result[0] ? parseInt(result[0]) : 0;
+                let m = result[1] ? parseInt(result[1]) : 0;
+                let s = result[2] ? parseInt(result[2]) : 0;
+                let time = h * 60 * 60 + m * 60 + s;
+                return time;
+            }
+            if (result.length == 2) {
+                let m = result[0] ? parseInt(result[0]) : 0;
+                let s = result[1] ? parseInt(result[1]) : 0;
+                let time = m * 60 + s;
+                return time;
+            }
+        }
+        catch (e) {
+            return value;
+        }
+        try {
+            let regexp = new RegExp('PT(\\d+H)?(\\d+M)?(\\d+S)?');
+            let result = regexp.exec(value);
+            let h = result[1] ? parseInt(result[1]) : 0;
+            let m = result[2] ? parseInt(result[2]) : 0;
+            let s = result[3] ? parseInt(result[3]) : 0;
+            let time = h * 60 * 60 + m * 60 + s;
+            return time;
+        }
+        catch (e) {
+            return value;
+        }
+    }
+    static getDurationFormatted(duration, format = DurationFormat.Colon) {
+        let time = DurationHelper.getDurationInSeconds(duration);
+        if (!time)
+            return '';
+        let h = Math.floor(time / 60 / 60);
+        let m = Math.floor(Math.floor(time / 60) % 60);
+        let s = Math.floor(time % 60);
+        let options = {
+            minimumIntegerDigits: 2,
+            maximumFractionDigits: 0,
+        };
+        let numberFormat = new Intl.NumberFormat([], options);
+        let str = '';
+        /*
+      if(h>0) {
+        str = format.format(h) + "h";
+      }
+      if(m>0) {
+        if (str)
+          str += " ";
+        str += format.format(m) + "m";
+      }
+      if(s>0) {
+        if (str)
+          str += " ";
+        str += format.format(s) + "s";
+      }
+      */
+        if (format === DurationFormat.Colon) {
+            str =
+                numberFormat.format(h) +
+                    ':' +
+                    numberFormat.format(m) +
+                    ':' +
+                    numberFormat.format(s);
+        }
+        else {
+            if (h > 0) {
+                str += h + 'h';
+            }
+            if (m > 0) {
+                str += ' ' + m + 'm';
+            }
+            if (s > 0) {
+                str += ' ' + s + 's';
+            }
+            str = str.trim();
+        }
+        return str;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"duration-helper.js","sourceRoot":"","sources":["../../../../../projects/edu-sharing-ui/src/lib/util/duration-helper.ts"],"names":[],"mappings":"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","sourcesContent":["export enum DurationFormat {\n    /**\n     * format with colon, i.e. H:MM:SS\n     */\n    Colon = 'colon',\n    /**\n     * format with Hh Mm Ss\n     */\n    Hms = 'hms',\n}\nexport class DurationHelper {\n    public static getDurationInSeconds(value: string): number {\n        // PT1H5M23S\n        // or 00:00:00\n        // or 00:00\n        if (!value) return 0;\n        try {\n            let result = value.split(':');\n            if (result.length == 3) {\n                let h = result[0] ? parseInt(result[0]) : 0;\n                let m = result[1] ? parseInt(result[1]) : 0;\n                let s = result[2] ? parseInt(result[2]) : 0;\n                let time = h * 60 * 60 + m * 60 + s;\n                return time;\n            }\n            if (result.length == 2) {\n                let m = result[0] ? parseInt(result[0]) : 0;\n                let s = result[1] ? parseInt(result[1]) : 0;\n                let time = m * 60 + s;\n                return time;\n            }\n        } catch (e) {\n            return value as unknown as number;\n        }\n        try {\n            let regexp = new RegExp('PT(\\\\d+H)?(\\\\d+M)?(\\\\d+S)?');\n            let result = regexp.exec(value);\n            let h = result[1] ? parseInt(result[1]) : 0;\n            let m = result[2] ? parseInt(result[2]) : 0;\n            let s = result[3] ? parseInt(result[3]) : 0;\n            let time = h * 60 * 60 + m * 60 + s;\n            return time;\n        } catch (e) {\n            return value as unknown as number;\n        }\n    }\n    public static getDurationFormatted(\n        duration: string,\n        format: DurationFormat = DurationFormat.Colon,\n    ): string {\n        let time = DurationHelper.getDurationInSeconds(duration);\n        if (!time) return '';\n        let h = Math.floor(time / 60 / 60);\n        let m = Math.floor(Math.floor(time / 60) % 60);\n        let s = Math.floor(time % 60);\n        let options: Intl.NumberFormatOptions = {\n            minimumIntegerDigits: 2,\n            maximumFractionDigits: 0,\n        };\n        let numberFormat = new Intl.NumberFormat([], options);\n        let str = '';\n        /*\n      if(h>0) {\n        str = format.format(h) + \"h\";\n      }\n      if(m>0) {\n        if (str)\n          str += \" \";\n        str += format.format(m) + \"m\";\n      }\n      if(s>0) {\n        if (str)\n          str += \" \";\n        str += format.format(s) + \"s\";\n      }\n      */\n        if (format === DurationFormat.Colon) {\n            str =\n                numberFormat.format(h) +\n                ':' +\n                numberFormat.format(m) +\n                ':' +\n                numberFormat.format(s);\n        } else {\n            if (h > 0) {\n                str += h + 'h';\n            }\n            if (m > 0) {\n                str += ' ' + m + 'm';\n            }\n            if (s > 0) {\n                str += ' ' + s + 's';\n            }\n            str = str.trim();\n        }\n        return str;\n    }\n}\n"]}

package/esm2022/lib/util/functions.mjs

@@ -0,0 +1,13 @@
+export function notNull(value) {
+    return value !== undefined && value !== null;
+}
+export function isTrue(value) {
+    return value ?? false;
+}
+export function microTick() {
+    return Promise.resolve();
+}
+export function macroTick() {
+    return new Promise((resolve) => setTimeout(() => resolve()));
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZnVuY3Rpb25zLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvZWR1LXNoYXJpbmctdWkvc3JjL2xpYi91dGlsL2Z1bmN0aW9ucy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxNQUFNLFVBQVUsT0FBTyxDQUFJLEtBQVE7SUFDL0IsT0FBTyxLQUFLLEtBQUssU0FBUyxJQUFJLEtBQUssS0FBSyxJQUFJLENBQUM7QUFDakQsQ0FBQztBQUVELE1BQU0sVUFBVSxNQUFNLENBQUMsS0FBYztJQUNqQyxPQUFPLEtBQUssSUFBSSxLQUFLLENBQUM7QUFDMUIsQ0FBQztBQUVELE1BQU0sVUFBVSxTQUFTO0lBQ3JCLE9BQU8sT0FBTyxDQUFDLE9BQU8sRUFBRSxDQUFDO0FBQzdCLENBQUM7QUFFRCxNQUFNLFVBQVUsU0FBUztJQUNyQixPQUFPLElBQUksT0FBTyxDQUFDLENBQUMsT0FBTyxFQUFFLEVBQUUsQ0FBQyxVQUFVLENBQUMsR0FBRyxFQUFFLENBQUMsT0FBTyxFQUFFLENBQUMsQ0FBQyxDQUFDO0FBQ2pFLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgZnVuY3Rpb24gbm90TnVsbDxUPih2YWx1ZTogVCk6IGJvb2xlYW4ge1xuICAgIHJldHVybiB2YWx1ZSAhPT0gdW5kZWZpbmVkICYmIHZhbHVlICE9PSBudWxsO1xufVxuXG5leHBvcnQgZnVuY3Rpb24gaXNUcnVlKHZhbHVlOiBib29sZWFuKTogYm9vbGVhbiB7XG4gICAgcmV0dXJuIHZhbHVlID8/IGZhbHNlO1xufVxuXG5leHBvcnQgZnVuY3Rpb24gbWljcm9UaWNrKCk6IFByb21pc2U8dm9pZD4ge1xuICAgIHJldHVybiBQcm9taXNlLnJlc29sdmUoKTtcbn1cblxuZXhwb3J0IGZ1bmN0aW9uIG1hY3JvVGljaygpOiBQcm9taXNlPHZvaWQ+IHtcbiAgICByZXR1cm4gbmV3IFByb21pc2UoKHJlc29sdmUpID0+IHNldFRpbWVvdXQoKCkgPT4gcmVzb2x2ZSgpKSk7XG59XG4iXX0=

package/esm2022/lib/util/helper.mjs

@@ -0,0 +1,64 @@
+import { isNumeric } from './isNumeric';
+import { isArray } from 'lodash';
+export class Helper {
+    static deepCopy(data) {
+        if (data == null)
+            return null;
+        return JSON.parse(JSON.stringify(data));
+    }
+    static deepCopyArray(data) {
+        if (!Array.isArray(data))
+            return data;
+        return data.slice();
+    }
+    /**
+     * Returns true if both objects have the same values stored
+     * will not work for classes including methods or similar dynamic data
+     * @param object1
+     * @param object2
+     * @returns {boolean}
+     */
+    static objectEquals(object1, object2) {
+        if (object1 == null)
+            return object2 == null;
+        if (object2 == null)
+            return object1 == null;
+        return JSON.stringify(object1) == JSON.stringify(object2);
+    }
+    /**
+     * get data from an object based on a dotted path
+     * also supports arrays like "array.0.key"
+     * @param nested the object to return the data from
+     * @param path the path of the field location in dotted notation
+     */
+    static getDotPathFromNestedObject(nested, path) {
+        const split = path.split('.');
+        let obj = nested;
+        for (let key of split) {
+            if (isNumeric(key)) {
+                obj = obj?.[parseInt(key)];
+            }
+            else {
+                if (isArray(obj)) {
+                    return obj;
+                }
+                obj = obj?.[key];
+            }
+        }
+        return obj;
+    }
+    static filterObjectPropertyNested(obj, property) {
+        for (let i in obj) {
+            if (!obj.hasOwnProperty(i))
+                continue;
+            if (property.includes(i)) {
+                delete obj[i];
+            }
+            else if (typeof obj[i] === 'object') {
+                Helper.filterObjectPropertyNested(obj[i], property);
+            }
+        }
+        return obj;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/util/isNumeric.mjs

@@ -0,0 +1,11 @@
+/**
+ * Copy paste from rxjs/util/isNumeric since importing it from there will trigger a warning about
+ * CommonJS or AMD dependencies and indeed increase the bundle size a bit.
+ */
+// From https://github.com/ReactiveX/rxjs/blob/6.x/src/internal/util/isArray.ts
+const isArray = (() => Array.isArray || ((x) => x && typeof x.length === 'number'))();
+// From https://github.com/ReactiveX/rxjs/blob/6.x/src/internal/util/isNumeric.ts
+export function isNumeric(val) {
+    return !isArray(val) && val - parseFloat(val) + 1 >= 0;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaXNOdW1lcmljLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvZWR1LXNoYXJpbmctdWkvc3JjL2xpYi91dGlsL2lzTnVtZXJpYy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7O0dBR0c7QUFFSCwrRUFBK0U7QUFDL0UsTUFBTSxPQUFPLEdBQUcsQ0FBQyxHQUFHLEVBQUUsQ0FDbEIsS0FBSyxDQUFDLE9BQU8sSUFBSSxDQUFDLENBQUksQ0FBTSxFQUFZLEVBQUUsQ0FBQyxDQUFDLElBQUksT0FBTyxDQUFDLENBQUMsTUFBTSxLQUFLLFFBQVEsQ0FBQyxDQUFDLEVBQUUsQ0FBQztBQUVyRixpRkFBaUY7QUFDakYsTUFBTSxVQUFVLFNBQVMsQ0FBQyxHQUFRO0lBQzlCLE9BQU8sQ0FBQyxPQUFPLENBQUMsR0FBRyxDQUFDLElBQUksR0FBRyxHQUFHLFVBQVUsQ0FBQyxHQUFHLENBQUMsR0FBRyxDQUFDLElBQUksQ0FBQyxDQUFDO0FBQzNELENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIENvcHkgcGFzdGUgZnJvbSByeGpzL3V0aWwvaXNOdW1lcmljIHNpbmNlIGltcG9ydGluZyBpdCBmcm9tIHRoZXJlIHdpbGwgdHJpZ2dlciBhIHdhcm5pbmcgYWJvdXRcbiAqIENvbW1vbkpTIG9yIEFNRCBkZXBlbmRlbmNpZXMgYW5kIGluZGVlZCBpbmNyZWFzZSB0aGUgYnVuZGxlIHNpemUgYSBiaXQuXG4gKi9cblxuLy8gRnJvbSBodHRwczovL2dpdGh1Yi5jb20vUmVhY3RpdmVYL3J4anMvYmxvYi82Lngvc3JjL2ludGVybmFsL3V0aWwvaXNBcnJheS50c1xuY29uc3QgaXNBcnJheSA9ICgoKSA9PlxuICAgIEFycmF5LmlzQXJyYXkgfHwgKDxUPih4OiBhbnkpOiB4IGlzIFRbXSA9PiB4ICYmIHR5cGVvZiB4Lmxlbmd0aCA9PT0gJ251bWJlcicpKSgpO1xuXG4vLyBGcm9tIGh0dHBzOi8vZ2l0aHViLmNvbS9SZWFjdGl2ZVgvcnhqcy9ibG9iLzYueC9zcmMvaW50ZXJuYWwvdXRpbC9pc051bWVyaWMudHNcbmV4cG9ydCBmdW5jdGlvbiBpc051bWVyaWModmFsOiBhbnkpOiB2YWwgaXMgbnVtYmVyIHwgc3RyaW5nIHtcbiAgICByZXR1cm4gIWlzQXJyYXkodmFsKSAmJiB2YWwgLSBwYXJzZUZsb2F0KHZhbCkgKyAxID49IDA7XG59XG4iXX0=

package/esm2022/lib/util/rest-helper.mjs

@@ -0,0 +1,33 @@
+import { RestConstants } from 'ngx-edu-sharing-api';
+/**
+ * Different helper functions, may be used globally
+ */
+export class RestHelper {
+    static { this.SPACES_STORE_REF = 'workspace://SpacesStore/'; }
+    static getName(node) {
+        if (node.name)
+            return node.name;
+        if (node.title)
+            return node.title;
+        if (node.ref)
+            return node.ref.id;
+        return null;
+    }
+    static getTitle(node) {
+        if (node?.title)
+            return node.title;
+        if (node?.name) {
+            return node?.name;
+        }
+        if (node?.properties) {
+            return RestHelper.getTitleFromProperties(node?.properties);
+        }
+        return '';
+    }
+    static getTitleFromProperties(properties) {
+        return properties[RestConstants.LOM_PROP_TITLE]
+            ? properties[RestConstants.LOM_PROP_TITLE]
+            : properties[RestConstants.CM_NAME];
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/util/ui-animation.mjs

@@ -0,0 +1,146 @@
+import { style, animate, transition, state } from '@angular/animations';
+export class UIAnimation {
+    static { this.ANIMATION_TIME_FAST = 100; }
+    static { this.ANIMATION_TIME_NORMAL = 200; }
+    static { this.ANIMATION_TIME_SLOW = 300; }
+    static fade(time = UIAnimation.ANIMATION_TIME_NORMAL) {
+        return [
+            transition(':enter', [style({ opacity: 0 }), animate(time, style({ opacity: 1 }))]),
+            transition(':leave', [animate(time, style({ opacity: 0 }))]),
+        ];
+    }
+    static fromBottom(time = UIAnimation.ANIMATION_TIME_NORMAL) {
+        return [
+            transition(':enter', [
+                style({ transform: 'translateY(100%)' }),
+                animate(time, style({ transform: 'translateY(0)' })),
+            ]),
+            transition(':leave', [
+                style({ transform: 'translateY(0)' }),
+                animate(time, style({ transform: 'translateY(100%)' })),
+            ]),
+        ];
+    }
+    static fromLeft(time = UIAnimation.ANIMATION_TIME_NORMAL) {
+        return [
+            transition(':enter', [
+                style({ transform: 'translateX(-100%)' }),
+                animate(time, style({ transform: 'translateX(0)' })),
+            ]),
+            transition(':leave', [
+                style({ transform: 'translateX(0)' }),
+                animate(time, style({ transform: 'translateX(-100%)' })),
+            ]),
+        ];
+    }
+    static fromRight(time = UIAnimation.ANIMATION_TIME_NORMAL) {
+        return [
+            transition(':enter', [
+                style({ transform: 'translateX(100%)' }),
+                animate(time, style({ transform: 'translateX(0)' })),
+            ]),
+            transition(':leave', [
+                style({ transform: 'translateX(0)' }),
+                animate(time, style({ transform: 'translateX(100%)' })),
+            ]),
+        ];
+    }
+    static infobarBottom(time = UIAnimation.ANIMATION_TIME_NORMAL) {
+        return [
+            transition(':enter', [
+                style({ bottom: '-70px' }),
+                animate(time + 'ms ease', style({ bottom: '0' })),
+            ]),
+            transition(':leave', [
+                style({ bottom: '0' }),
+                animate(time + 'ms ease', style({ bottom: '-70px' })),
+            ]),
+        ];
+    }
+    /**
+     * Useful animation for opening any overflow menus
+     * @param time
+     * @returns {AnimationStateTransitionMetadata[]}
+     */
+    static openOverlay(time = UIAnimation.ANIMATION_TIME_NORMAL) {
+        return [
+            transition(':enter', [
+                style({ 'transform-origin': '50% 0%', transform: 'scaleY(0.5)', opacity: 0 }),
+                animate(time, style({ transform: 'scaleY(1)', opacity: 1 })),
+            ]),
+            transition(':leave', [
+                style({ 'transform-origin': '50% 0%', transform: 'scaleY(1)', opacity: 1 }),
+                animate(time, style({ transform: 'scaleY(0.5)', opacity: 0 })),
+            ]),
+        ];
+    }
+    /**
+     * Useful animation for opening any overflow menus - inverted (from bottom to top)
+     * @param time
+     * @returns {AnimationStateTransitionMetadata[]}
+     */
+    static openOverlayBottom(time = UIAnimation.ANIMATION_TIME_NORMAL) {
+        return [
+            transition(':enter', [
+                style({ 'transform-origin': '50% 100%', transform: 'scaleY(0.5)', opacity: 0 }),
+                animate(time, style({ transform: 'scaleY(1)', opacity: 1 })),
+            ]),
+            transition(':leave', [
+                style({ 'transform-origin': '50% 100%', transform: 'scaleY(1)', opacity: 1 }),
+                animate(time, style({ transform: 'scaleY(0.5)', opacity: 0 })),
+            ]),
+        ];
+    }
+    /**
+     * Useful animation to switch different content insides a dialog (navigating between contents)
+     * @param time
+     * @returns {AnimationStateTransitionMetadata[]}
+     */
+    static switchDialog(time = UIAnimation.ANIMATION_TIME_NORMAL) {
+        return [
+            transition(':enter', [
+                style({ 'transform-origin': '50% 0%', transform: 'scaleY(0)', opacity: 0 }),
+                animate(time, style({ transform: 'scaleY(1)', opacity: 1 })),
+            ]),
+        ];
+    }
+    /**
+     * Useful animation to switch different content insides a dialog (navigating between contents)
+     * This is a special variant which does work without ngIf fields, it will remove display states
+     */
+    static switchDialogBoolean(time = UIAnimation.ANIMATION_TIME_NORMAL) {
+        return [
+            state('false', style({
+                opacity: 0,
+                'transform-origin': '50% 0%',
+                transform: 'scaleY(0)',
+                display: 'none',
+            })),
+            state('true', style({ opacity: 1, 'transform-origin': '50% 0%', transform: 'scaleY(100%)' })),
+            transition('false => true', [style({ display: '' }), animate(time + 'ms ease-in-out')]),
+            transition('true => false', [animate(time + 'ms ease-in-out')]),
+        ];
+    }
+    /**
+     * Useful animation for showing any modal cards
+     * @param time
+     * @returns {AnimationStateTransitionMetadata[]}
+     */
+    static cardAnimation(time = UIAnimation.ANIMATION_TIME_NORMAL) {
+        return [
+            transition(':enter', [
+                style({
+                    'transform-origin': '50% 0%',
+                    transform: 'scaleY(0.5) translateY(-100%)',
+                    opacity: 0,
+                }),
+                animate(time + 'ms ease', style({ transform: 'scaleY(1) translateY(0)', opacity: 1 })),
+            ]),
+            transition(':leave', [
+                style({ 'transform-origin': '50% 0%', opacity: 1 }),
+                animate(time + 'ms ease', style({ opacity: 0 })),
+            ]),
+        ];
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ui-animation.js","sourceRoot":"","sources":["../../../../../projects/edu-sharing-ui/src/lib/util/ui-animation.ts"],"names":[],"mappings":"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","sourcesContent":["import { style, animate, transition, trigger, state } from '@angular/animations';\nexport class UIAnimation {\n    public static ANIMATION_TIME_FAST = 100;\n    public static ANIMATION_TIME_NORMAL = 200;\n    public static ANIMATION_TIME_SLOW = 300;\n    public static fade(time = UIAnimation.ANIMATION_TIME_NORMAL) {\n        return [\n            transition(':enter', [style({ opacity: 0 }), animate(time, style({ opacity: 1 }))]),\n            transition(':leave', [animate(time, style({ opacity: 0 }))]),\n        ];\n    }\n    public static fromBottom(time = UIAnimation.ANIMATION_TIME_NORMAL) {\n        return [\n            transition(':enter', [\n                style({ transform: 'translateY(100%)' }),\n                animate(time, style({ transform: 'translateY(0)' })),\n            ]),\n            transition(':leave', [\n                style({ transform: 'translateY(0)' }),\n                animate(time, style({ transform: 'translateY(100%)' })),\n            ]),\n        ];\n    }\n    public static fromLeft(time = UIAnimation.ANIMATION_TIME_NORMAL) {\n        return [\n            transition(':enter', [\n                style({ transform: 'translateX(-100%)' }),\n                animate(time, style({ transform: 'translateX(0)' })),\n            ]),\n            transition(':leave', [\n                style({ transform: 'translateX(0)' }),\n                animate(time, style({ transform: 'translateX(-100%)' })),\n            ]),\n        ];\n    }\n    public static fromRight(time: number | string = UIAnimation.ANIMATION_TIME_NORMAL) {\n        return [\n            transition(':enter', [\n                style({ transform: 'translateX(100%)' }),\n                animate(time, style({ transform: 'translateX(0)' })),\n            ]),\n            transition(':leave', [\n                style({ transform: 'translateX(0)' }),\n                animate(time, style({ transform: 'translateX(100%)' })),\n            ]),\n        ];\n    }\n    public static infobarBottom(time = UIAnimation.ANIMATION_TIME_NORMAL) {\n        return [\n            transition(':enter', [\n                style({ bottom: '-70px' }),\n                animate(time + 'ms ease', style({ bottom: '0' })),\n            ]),\n            transition(':leave', [\n                style({ bottom: '0' }),\n                animate(time + 'ms ease', style({ bottom: '-70px' })),\n            ]),\n        ];\n    }\n    /**\n     * Useful animation for opening any overflow menus\n     * @param time\n     * @returns {AnimationStateTransitionMetadata[]}\n     */\n    public static openOverlay(time = UIAnimation.ANIMATION_TIME_NORMAL) {\n        return [\n            transition(':enter', [\n                style({ 'transform-origin': '50% 0%', transform: 'scaleY(0.5)', opacity: 0 }),\n                animate(time, style({ transform: 'scaleY(1)', opacity: 1 })),\n            ]),\n            transition(':leave', [\n                style({ 'transform-origin': '50% 0%', transform: 'scaleY(1)', opacity: 1 }),\n                animate(time, style({ transform: 'scaleY(0.5)', opacity: 0 })),\n            ]),\n        ];\n    }\n    /**\n     * Useful animation for opening any overflow menus - inverted (from bottom to top)\n     * @param time\n     * @returns {AnimationStateTransitionMetadata[]}\n     */\n    public static openOverlayBottom(time = UIAnimation.ANIMATION_TIME_NORMAL) {\n        return [\n            transition(':enter', [\n                style({ 'transform-origin': '50% 100%', transform: 'scaleY(0.5)', opacity: 0 }),\n                animate(time, style({ transform: 'scaleY(1)', opacity: 1 })),\n            ]),\n            transition(':leave', [\n                style({ 'transform-origin': '50% 100%', transform: 'scaleY(1)', opacity: 1 }),\n                animate(time, style({ transform: 'scaleY(0.5)', opacity: 0 })),\n            ]),\n        ];\n    }\n    /**\n     * Useful animation to switch different content insides a dialog (navigating between contents)\n     * @param time\n     * @returns {AnimationStateTransitionMetadata[]}\n     */\n    public static switchDialog(time = UIAnimation.ANIMATION_TIME_NORMAL) {\n        return [\n            transition(':enter', [\n                style({ 'transform-origin': '50% 0%', transform: 'scaleY(0)', opacity: 0 }),\n                animate(time, style({ transform: 'scaleY(1)', opacity: 1 })),\n            ]),\n        ];\n    }\n    /**\n     * Useful animation to switch different content insides a dialog (navigating between contents)\n     * This is a special variant which does work without ngIf fields, it will remove display states\n     */\n    public static switchDialogBoolean(time = UIAnimation.ANIMATION_TIME_NORMAL) {\n        return [\n            state(\n                'false',\n                style({\n                    opacity: 0,\n                    'transform-origin': '50% 0%',\n                    transform: 'scaleY(0)',\n                    display: 'none',\n                }),\n            ),\n            state(\n                'true',\n                style({ opacity: 1, 'transform-origin': '50% 0%', transform: 'scaleY(100%)' }),\n            ),\n            transition('false => true', [style({ display: '' }), animate(time + 'ms ease-in-out')]),\n            transition('true => false', [animate(time + 'ms ease-in-out')]),\n        ];\n    }\n    /**\n     * Useful animation for showing any modal cards\n     * @param time\n     * @returns {AnimationStateTransitionMetadata[]}\n     */\n    public static cardAnimation(time = UIAnimation.ANIMATION_TIME_NORMAL) {\n        return [\n            transition(':enter', [\n                style({\n                    'transform-origin': '50% 0%',\n                    transform: 'scaleY(0.5) translateY(-100%)',\n                    opacity: 0,\n                }),\n                animate(\n                    time + 'ms ease',\n                    style({ transform: 'scaleY(1) translateY(0)', opacity: 1 }),\n                ),\n            ]),\n            transition(':leave', [\n                style({ 'transform-origin': '50% 0%', opacity: 1 }),\n                animate(time + 'ms ease', style({ opacity: 0 })),\n            ]),\n        ];\n    }\n}\n"]}

package/esm2022/lib/util/ui-constants.mjs

@@ -0,0 +1,21 @@
+export class UIConstants {
+    static { this.ROUTER_PREFIX = 'components/'; }
+    // also declared in scss!
+    static { this.MOBILE_WIDTH = 700; }
+    static { this.MOBILE_HEIGHT = 750; }
+    static { this.MOBILE_HEIGHT_WITH_KEYBOARD = 550; }
+    static { this.MOBILE_STAGE = 100; }
+    static { this.MOBILE_TAB_SWITCH_WIDTH = UIConstants.MOBILE_WIDTH + UIConstants.MOBILE_STAGE * 2; }
+    static { this.MEDIA_QUERY_MIN_WIDTH = 'min-width'; }
+    static { this.MEDIA_QUERY_MAX_WIDTH = 'max-width'; }
+    static { this.MEDIA_QUERY_MIN_HEIGHT = 'min-height'; }
+    static { this.MEDIA_QUERY_MAX_HEIGHT = 'max-height'; }
+    static { this.QUERY_PARAM_LIST_VIEW_TYPE = 'displayType'; }
+}
+export var OPEN_URL_MODE;
+(function (OPEN_URL_MODE) {
+    OPEN_URL_MODE[OPEN_URL_MODE["Current"] = 0] = "Current";
+    OPEN_URL_MODE[OPEN_URL_MODE["Blank"] = 1] = "Blank";
+    OPEN_URL_MODE[OPEN_URL_MODE["BlankSystemBrowser"] = 2] = "BlankSystemBrowser";
+})(OPEN_URL_MODE || (OPEN_URL_MODE = {}));
+//# sourceMappingURL=data:application/json;base64,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