@lenne.tech/ng-base 13.1.0 → 13.3.0

package/esm2020/src/classes/helper.class.mjs

@@ -0,0 +1,304 @@
+/**
+ * Helper class
+ */
+export class Helper {
+    /**
+     * Simple filter function for plain objects
+     */
+    static filter(objects, filter) {
+        return (objects?.filter((element) => {
+            for (const [key, value] of Object.entries(filter)) {
+                if (Array.isArray(element[key])) {
+                    for (const item of element[key]) {
+                        if (!element[key].includs(value)) {
+                            return false;
+                        }
+                    }
+                }
+                else if (element[key] !== value) {
+                    return false;
+                }
+            }
+            return true;
+        }) || []);
+    }
+    /**
+     * Convert to a url/uri conform string
+     * Only:
+     * - lower case
+     * - chars, numbers and hyphens
+     */
+    static urlString(str, options = {}) {
+        // Config
+        const config = {
+            allowAll: false,
+            ...options,
+        };
+        // To string
+        str = str + '';
+        // Trim
+        str = str.trim();
+        // Lower case
+        str = str.toLowerCase();
+        if (!config.allowAll) {
+            // Replace spaces
+            str = str.trim().replace(/\s+/g, '-');
+            // Replace some special chars
+            str = str.replace('ä', 'ae');
+            str = str.replace('ö', 'oe');
+            str = str.replace('ü', 'ue');
+            str = str.replace('ß', 'ss');
+            // Remove other special chars
+            str = str.replace(/[^a-zA-Z0-9-]/g, '');
+        }
+        // Return url conform string
+        return encodeURI(str);
+    }
+    /**
+     * Simple map function
+     */
+    static map(source, target, options = {}) {
+        // Set config
+        const config = {
+            funcAllowed: false,
+            dateStringToDate: true,
+            ...options,
+        };
+        // Check source
+        if (!source || typeof source !== 'object' || Array.isArray(source)) {
+            return target;
+        }
+        // Update properties
+        for (const key of Object.keys(target)) {
+            if (source[key] !== undefined && (config.funcAllowed || typeof (source[key] !== 'function'))) {
+                if (typeof source[key] === 'string' && config.dateStringToDate) {
+                    if (Array.isArray(config.dateStringToDate)) {
+                        if (config.dateStringToDate.includes(key)) {
+                            target[key] = Helper.parseDate(source[key]);
+                        }
+                    }
+                    else {
+                        target[key] = Helper.parseDate(source[key]);
+                    }
+                }
+                else {
+                    target[key] = source[key];
+                }
+            }
+        }
+        // Return target
+        return target;
+    }
+    /**
+     * Create Object or Objects of specified type with specified data
+     */
+    static maps(data, targetClass) {
+        // Check data
+        if (!data || typeof data !== 'object') {
+            return undefined;
+        }
+        // Check array
+        if (!Array.isArray(data)) {
+            data = [data];
+        }
+        // Map
+        return data.map((item) => {
+            return targetClass.map(item);
+        });
+    }
+    /**
+     * Get plain parameter
+     */
+    static getPlainParameter(parameter) {
+        if (!parameter) {
+            return parameter;
+        }
+        return parameter?.split('?')?.shift()?.split('#')?.shift();
+    }
+    /**
+     * Get ID of an url parameter
+     */
+    static getParameterId(parameter) {
+        if (!parameter) {
+            return parameter;
+        }
+        return Helper.getPlainParameter(parameter)?.split('-').pop();
+    }
+    /**
+     * Delay
+     */
+    static delay(ms) {
+        const promise = new Promise((resolve) => setTimeout(resolve, ms));
+        return promise;
+    }
+    /**
+     * Deep freeze
+     * See https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/freeze#What_is_shallow_freeze
+     */
+    static deepFreeze(object, preparedObjects = []) {
+        // Prevent infinit regress
+        if (preparedObjects.includes(object)) {
+            return object;
+        }
+        preparedObjects.push(object);
+        // Retrieve the property names defined on object
+        const propNames = Object.getOwnPropertyNames(object);
+        // Freeze properties before freezing self
+        for (const name of propNames) {
+            const value = object[name];
+            if (value && typeof value === 'object') {
+                Helper.deepFreeze(value, preparedObjects);
+            }
+        }
+        return Object.freeze(object);
+    }
+    /**
+     * Generates an unique identifier with 24 characters
+     */
+    static getUID() {
+        let dt = new Date().getTime();
+        const uuid = 'xxxxxxxxxxxxxxxxxxxxxxxx'.replace(/[xy]/g, (c) => {
+            // eslint-disable-next-line no-bitwise
+            const r = (dt + Math.random() * 16) % 16 | 0;
+            dt = Math.floor(dt / 16);
+            // eslint-disable-next-line no-bitwise
+            return (c === 'x' ? r : (r & 0x3) | 0x8).toString(16);
+        });
+        return uuid;
+    }
+    /**
+     * Parse date string to date object
+     */
+    static parseDate(dateString) {
+        const reISO = /^(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2}):(\d{2}(?:\.\d*))(?:Z|(\+|-)([\d|:]*))?$/;
+        const reMsAjax = /^\/Date\((d|-|.*)\)[\/|\\]$/;
+        if (typeof dateString === 'string') {
+            const isoExec = reISO.exec(dateString);
+            if (isoExec) {
+                return new Date(dateString);
+            }
+            const msAjaxExec = reMsAjax.exec(dateString);
+            if (msAjaxExec) {
+                const cleaned = msAjaxExec[1].split(/[-+,.]/);
+                return new Date(cleaned[0] ? +cleaned[0] : 0 - +cleaned[1]);
+            }
+        }
+        return dateString;
+    }
+    /**
+     * Get browser name and version
+     */
+    static getBrowser() {
+        const userAgent = navigator.userAgent;
+        let data = userAgent.match(/(opera|chrome|safari|firefox|msie|trident(?=\/))\/?\s*(\d+)/i) || [];
+        let version;
+        if (/trident/i.test(data[1])) {
+            version = /\brv[ :]+(\d+)/g.exec(userAgent) || [];
+            return { name: 'IE', version: version[1] || '' };
+        }
+        if (data[1] === 'Chrome') {
+            version = userAgent.match(/\bOPR|Edge\/(\d+)/);
+            if (version != null) {
+                return { name: 'Opera', version: version[1] };
+            }
+        }
+        data = data[2] ? [data[1], data[2]] : [navigator.appName, navigator.appVersion, '-?'];
+        version = userAgent.match(/version\/(\d+)/i);
+        if (version !== null) {
+            data.splice(1, 1, version[1]);
+        }
+        return {
+            name: data[0],
+            version: data[1],
+        };
+    }
+    /**
+     * Whether first parameter is a deep subset of second parameter
+     * Hint: functions will be ignored
+     */
+    static isSubset(a, b) {
+        // Equal
+        if (a === b) {
+            return true;
+        }
+        // Different type
+        if (typeof a !== typeof b) {
+            return false;
+        }
+        // Process array
+        if (Array.isArray(a)) {
+            for (const [key, value] of Object.entries(a)) {
+                if (Helper.isSubset(value, b[key])) {
+                    return false;
+                }
+            }
+            return true;
+        }
+        // Process object
+        if (typeof a === 'object') {
+            const plain = JSON.parse(JSON.stringify(a));
+            for (const [key, value] of Object.entries(plain)) {
+                if (Helper.isSubset(value, b[key])) {
+                    return false;
+                }
+            }
+            return true;
+        }
+        // Else
+        return true;
+    }
+    /**
+     * Whether parameters are equal (have equal properties)
+     * Hint: functions will be ignored
+     */
+    static isEqual(a, b) {
+        return Helper.isSubset(a, b) && Helper.isSubset(b, a);
+    }
+    /**
+     * First level difference of two objects
+     * Hint: functions will be ignored and when an array or an object is different the hole array or object will used as property value
+     *
+     * @returns Record<string, any> Object with properties from first object
+     */
+    static getDiff(a, b, clone = true) {
+        const result = {};
+        let firstObject = a;
+        if (clone) {
+            firstObject = JSON.parse(JSON.stringify(a));
+        }
+        for (const [key, value] of Object.entries(firstObject)) {
+            if (!Helper.isSubset(value, b[key])) {
+                result[key] = value;
+            }
+        }
+        return result;
+    }
+    /**
+     * Check if propertie is type of HTMLCollection or NodeList
+     * See https://stackoverflow.com/a/7238344
+     *
+     * @param nodes
+     */
+    static isNodeList(nodes) {
+        try {
+            const stringRepr = Object.prototype.toString.call(nodes);
+            return (typeof nodes === 'object' &&
+                /^\[object (HTMLCollection|NodeList|Object)\]$/.test(stringRepr) &&
+                typeof nodes.length === 'number' &&
+                (nodes.length === 0 || (typeof nodes[0] === 'object' && nodes[0].nodeType > 0)));
+        }
+        catch (e) {
+            return false;
+        }
+    }
+    static arrayBufferToBase64(buffer) {
+        let binary = '';
+        const bytes = new Uint8Array(buffer);
+        const len = bytes.byteLength;
+        for (let i = 0; i < len; i++) {
+            binary += String.fromCharCode(bytes[i]);
+        }
+        return `data:image/*;base64, ${window.btoa(binary)}`;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"helper.class.js","sourceRoot":"","sources":["../../../../../projects/ng-base/src/classes/helper.class.ts"],"names":[],"mappings":"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","sourcesContent":["import { Standard } from './standard.class';\n\n/**\n * Helper class\n */\nexport class Helper {\n  /**\n   * Simple filter function for plain objects\n   */\n  static filter<T = { [key: string]: any }>(objects: T[], filter: { [key: string]: any }): T[] {\n    return (objects?.filter((element) => {\n      for (const [key, value] of Object.entries(filter)) {\n        if (Array.isArray(element[key])) {\n          for (const item of element[key]) {\n            if (!element[key].includs(value)) {\n              return false;\n            }\n          }\n        } else if (element[key] !== value) {\n          return false;\n        }\n      }\n      return true;\n    }) || []) as any[];\n  }\n\n  /**\n   * Convert to a url/uri conform string\n   * Only:\n   * - lower case\n   * - chars, numbers and hyphens\n   */\n  static urlString(str: any, options: { allowAll?: boolean } = {}): string {\n    // Config\n    const config = {\n      allowAll: false,\n      ...options,\n    };\n\n    // To string\n    str = str + '';\n\n    // Trim\n    str = str.trim();\n\n    // Lower case\n    str = str.toLowerCase();\n\n    if (!config.allowAll) {\n      // Replace spaces\n      str = str.trim().replace(/\\s+/g, '-');\n\n      // Replace some special chars\n      str = str.replace('ä', 'ae');\n      str = str.replace('ö', 'oe');\n      str = str.replace('ü', 'ue');\n      str = str.replace('ß', 'ss');\n\n      // Remove other special chars\n      str = str.replace(/[^a-zA-Z0-9-]/g, '');\n    }\n\n    // Return url conform string\n    return encodeURI(str);\n  }\n\n  /**\n   * Simple map function\n   */\n  public static map<T = { [key: string]: any }>(\n    source: Partial<T> | { [key: string]: any },\n    target: T,\n    options: { funcAllowed?: boolean; dateStringToDate?: boolean | string[] } = {}\n  ): T {\n    // Set config\n    const config = {\n      funcAllowed: false,\n      dateStringToDate: true,\n      ...options,\n    };\n\n    // Check source\n    if (!source || typeof source !== 'object' || Array.isArray(source)) {\n      return target;\n    }\n\n    // Update properties\n    for (const key of Object.keys(target)) {\n      if (source[key] !== undefined && (config.funcAllowed || typeof (source[key] !== 'function'))) {\n        if (typeof source[key] === 'string' && config.dateStringToDate) {\n          if (Array.isArray(config.dateStringToDate)) {\n            if (config.dateStringToDate.includes(key)) {\n              target[key] = Helper.parseDate(source[key]);\n            }\n          } else {\n            target[key] = Helper.parseDate(source[key]);\n          }\n        } else {\n          target[key] = source[key];\n        }\n      }\n    }\n\n    // Return target\n    return target;\n  }\n\n  /**\n   * Create Object or Objects of specified type with specified data\n   */\n  public static maps<T extends Standard>(\n    data: Partial<T> | Partial<T>[] | { [key: string]: any } | { [key: string]: any }[],\n    targetClass: new (...args: any[]) => T\n  ): T[] {\n    // Check data\n    if (!data || typeof data !== 'object') {\n      return undefined;\n    }\n\n    // Check array\n    if (!Array.isArray(data)) {\n      data = [data];\n    }\n\n    // Map\n    return (data as any).map((item: any) => {\n      return (targetClass as any).map(item);\n    });\n  }\n\n  /**\n   * Get plain parameter\n   */\n  public static getPlainParameter(parameter: string) {\n    if (!parameter) {\n      return parameter;\n    }\n    return parameter?.split('?')?.shift()?.split('#')?.shift();\n  }\n\n  /**\n   * Get ID of an url parameter\n   */\n  public static getParameterId(parameter: string) {\n    if (!parameter) {\n      return parameter;\n    }\n    return Helper.getPlainParameter(parameter)?.split('-').pop();\n  }\n\n  /**\n   * Delay\n   */\n  public static delay(ms: number) {\n    const promise = new Promise((resolve) => setTimeout(resolve, ms));\n    return promise;\n  }\n\n  /**\n   * Deep freeze\n   * See https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/freeze#What_is_shallow_freeze\n   */\n  public static deepFreeze(object: any, preparedObjects = []) {\n    // Prevent infinit regress\n    if (preparedObjects.includes(object as never)) {\n      return object;\n    }\n    preparedObjects.push(object as never);\n\n    // Retrieve the property names defined on object\n    const propNames = Object.getOwnPropertyNames(object);\n\n    // Freeze properties before freezing self\n    for (const name of propNames) {\n      const value = object[name];\n\n      if (value && typeof value === 'object') {\n        Helper.deepFreeze(value, preparedObjects);\n      }\n    }\n\n    return Object.freeze(object);\n  }\n\n  /**\n   * Generates an unique identifier with 24 characters\n   */\n  public static getUID(): string {\n    let dt = new Date().getTime();\n    const uuid = 'xxxxxxxxxxxxxxxxxxxxxxxx'.replace(/[xy]/g, (c) => {\n      // eslint-disable-next-line no-bitwise\n      const r = (dt + Math.random() * 16) % 16 | 0;\n      dt = Math.floor(dt / 16);\n      // eslint-disable-next-line no-bitwise\n      return (c === 'x' ? r : (r & 0x3) | 0x8).toString(16);\n    });\n    return uuid;\n  }\n\n  /**\n   * Parse date string to date object\n   */\n  public static parseDate(dateString: string) {\n    const reISO = /^(\\d{4})-(\\d{2})-(\\d{2})T(\\d{2}):(\\d{2}):(\\d{2}(?:\\.\\d*))(?:Z|(\\+|-)([\\d|:]*))?$/;\n    const reMsAjax = /^\\/Date\\((d|-|.*)\\)[\\/|\\\\]$/;\n    if (typeof dateString === 'string') {\n      const isoExec = reISO.exec(dateString);\n      if (isoExec) {\n        return new Date(dateString);\n      }\n      const msAjaxExec = reMsAjax.exec(dateString);\n      if (msAjaxExec) {\n        const cleaned = msAjaxExec[1].split(/[-+,.]/);\n        return new Date(cleaned[0] ? +cleaned[0] : 0 - +cleaned[1]);\n      }\n    }\n    return dateString;\n  }\n\n  /**\n   * Get browser name and version\n   */\n  public static getBrowser() {\n    const userAgent = navigator.userAgent;\n    let data = userAgent.match(/(opera|chrome|safari|firefox|msie|trident(?=\\/))\\/?\\s*(\\d+)/i) || [];\n    let version;\n    if (/trident/i.test(data[1])) {\n      version = /\\brv[ :]+(\\d+)/g.exec(userAgent) || [];\n      return { name: 'IE', version: version[1] || '' };\n    }\n    if (data[1] === 'Chrome') {\n      version = userAgent.match(/\\bOPR|Edge\\/(\\d+)/);\n      if (version != null) {\n        return { name: 'Opera', version: version[1] };\n      }\n    }\n    data = data[2] ? [data[1], data[2]] : [navigator.appName, navigator.appVersion, '-?'];\n    version = userAgent.match(/version\\/(\\d+)/i);\n    if (version !== null) {\n      data.splice(1, 1, version[1]);\n    }\n    return {\n      name: data[0],\n      version: data[1],\n    };\n  }\n\n  /**\n   * Whether first parameter is a deep subset of second parameter\n   * Hint: functions will be ignored\n   */\n  static isSubset(a: any, b: any) {\n    // Equal\n    if (a === b) {\n      return true;\n    }\n\n    // Different type\n    if (typeof a !== typeof b) {\n      return false;\n    }\n\n    // Process array\n    if (Array.isArray(a)) {\n      for (const [key, value] of Object.entries(a)) {\n        if (Helper.isSubset(value, b[key])) {\n          return false;\n        }\n      }\n      return true;\n    }\n\n    // Process object\n    if (typeof a === 'object') {\n      const plain = JSON.parse(JSON.stringify(a));\n      for (const [key, value] of Object.entries(plain)) {\n        if (Helper.isSubset(value, b[key])) {\n          return false;\n        }\n      }\n      return true;\n    }\n\n    // Else\n    return true;\n  }\n\n  /**\n   * Whether parameters are equal (have equal properties)\n   * Hint: functions will be ignored\n   */\n  static isEqual(a: any, b: any) {\n    return Helper.isSubset(a, b) && Helper.isSubset(b, a);\n  }\n\n  /**\n   * First level difference of two objects\n   * Hint: functions will be ignored and when an array or an object is different the hole array or object will used as property value\n   *\n   * @returns Record<string, any> Object with properties from first object\n   */\n  static getDiff(a: Record<string, any>, b: Record<string, any>, clone: boolean = true) {\n    const result = {};\n    let firstObject = a;\n    if (clone) {\n      firstObject = JSON.parse(JSON.stringify(a));\n    }\n    for (const [key, value] of Object.entries(firstObject)) {\n      if (!Helper.isSubset(value, b[key])) {\n        result[key] = value;\n      }\n    }\n    return result;\n  }\n\n  /**\n   * Check if propertie is type of HTMLCollection or NodeList\n   * See https://stackoverflow.com/a/7238344\n   *\n   * @param nodes\n   */\n  static isNodeList(nodes) {\n    try {\n      const stringRepr = Object.prototype.toString.call(nodes);\n      return (\n        typeof nodes === 'object' &&\n        /^\\[object (HTMLCollection|NodeList|Object)\\]$/.test(stringRepr) &&\n        typeof nodes.length === 'number' &&\n        (nodes.length === 0 || (typeof nodes[0] === 'object' && nodes[0].nodeType > 0))\n      );\n    } catch (e) {\n      return false;\n    }\n  }\n\n  static arrayBufferToBase64(buffer) {\n    let binary = '';\n    const bytes = new Uint8Array(buffer);\n    const len = bytes.byteLength;\n    for (let i = 0; i < len; i++) {\n      binary += String.fromCharCode(bytes[i]);\n    }\n    return `data:image/*;base64, ${window.btoa(binary)}`;\n  }\n}\n"]}

package/esm2020/src/classes/standard.class.mjs

@@ -0,0 +1,40 @@
+import { Helper } from './helper.class';
+/**
+ * Standard class
+ * Other classes should extend the Standard class, if they offer own functions
+ * If the extended class uses object properties with own map functions, it should implement its own map function
+ */
+export class Standard {
+    /**
+     * Static map method
+     */
+    static map(data, item = new this()) {
+        return item.map(data);
+    }
+    /**
+     * Map data into an object
+     */
+    map(data) {
+        return Helper.map(data, this);
+    }
+    /**
+     * Clone object (and map additional data)
+     */
+    clone(mapData) {
+        const current = JSON.parse(JSON.stringify(this));
+        if (mapData) {
+            Object.assign(current, mapData);
+        }
+        return new this.constructor().map(current);
+    }
+    /**
+     * Compare this with another object
+     * Hint: functions will be ignored and when an array or an object is different the hole array or object will used as property value
+     *
+     * @return Record<string, any> with properties of this object which are different
+     */
+    getDiff(compare, clone = true) {
+        return Helper.getDiff(this, compare, clone);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/src/decorators/debounce.decorator.mjs

@@ -0,0 +1,12 @@
+export function debounce(delay = 300) {
+    return function (target, propertyKey, descriptor) {
+        let timeout = null;
+        const original = descriptor.value;
+        descriptor.value = function (...args) {
+            clearTimeout(timeout);
+            timeout = setTimeout(() => original.apply(this, args), delay);
+        };
+        return descriptor;
+    };
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGVib3VuY2UuZGVjb3JhdG9yLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvbmctYmFzZS9zcmMvZGVjb3JhdG9ycy9kZWJvdW5jZS5kZWNvcmF0b3IudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsTUFBTSxVQUFVLFFBQVEsQ0FBQyxRQUFnQixHQUFHO0lBQzFDLE9BQU8sVUFBVSxNQUFXLEVBQUUsV0FBbUIsRUFBRSxVQUE4QjtRQUMvRSxJQUFJLE9BQU8sR0FBRyxJQUFJLENBQUM7UUFFbkIsTUFBTSxRQUFRLEdBQUcsVUFBVSxDQUFDLEtBQUssQ0FBQztRQUVsQyxVQUFVLENBQUMsS0FBSyxHQUFHLFVBQVUsR0FBRyxJQUFJO1lBQ2xDLFlBQVksQ0FBQyxPQUFPLENBQUMsQ0FBQztZQUN0QixPQUFPLEdBQUcsVUFBVSxDQUFDLEdBQUcsRUFBRSxDQUFDLFFBQVEsQ0FBQyxLQUFLLENBQUMsSUFBSSxFQUFFLElBQUksQ0FBQyxFQUFFLEtBQUssQ0FBQyxDQUFDO1FBQ2hFLENBQUMsQ0FBQztRQUVGLE9BQU8sVUFBVSxDQUFDO0lBQ3BCLENBQUMsQ0FBQztBQUNKLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgZnVuY3Rpb24gZGVib3VuY2UoZGVsYXk6IG51bWJlciA9IDMwMCk6IE1ldGhvZERlY29yYXRvciB7XG4gIHJldHVybiBmdW5jdGlvbiAodGFyZ2V0OiBhbnksIHByb3BlcnR5S2V5OiBzdHJpbmcsIGRlc2NyaXB0b3I6IFByb3BlcnR5RGVzY3JpcHRvcikge1xuICAgIGxldCB0aW1lb3V0ID0gbnVsbDtcblxuICAgIGNvbnN0IG9yaWdpbmFsID0gZGVzY3JpcHRvci52YWx1ZTtcblxuICAgIGRlc2NyaXB0b3IudmFsdWUgPSBmdW5jdGlvbiAoLi4uYXJncykge1xuICAgICAgY2xlYXJUaW1lb3V0KHRpbWVvdXQpO1xuICAgICAgdGltZW91dCA9IHNldFRpbWVvdXQoKCkgPT4gb3JpZ2luYWwuYXBwbHkodGhpcywgYXJncyksIGRlbGF5KTtcbiAgICB9O1xuXG4gICAgcmV0dXJuIGRlc2NyaXB0b3I7XG4gIH07XG59XG4iXX0=

package/esm2020/src/directives/context-menu.directive.mjs

@@ -0,0 +1,109 @@
+import { Directive, Input, Output } from '@angular/core';
+import * as i0 from "@angular/core";
+/**
+ * Directive vor context menu
+ * See https://stackblitz.com/edit/angular-custom-context-menu
+ */
+export class ContextMenuDirective {
+    constructor(el) {
+        this.el = el;
+        this.xGap = 0;
+        this.yGap = 0;
+        this.overflowSpace = 10;
+        this.selectors = '*';
+        this.clickedElement = null;
+        this.previousDisplayStatus = null;
+    }
+    ngOnInit() {
+        if (this.ltContextMenu) {
+            this.previousDisplayStatus = this.ltContextMenu.style.display;
+        }
+        // Add a click listener to the window,
+        // so that we can close the context menu on left click
+        window.addEventListener('click', () => {
+            this.showContextMenu(null, false);
+        });
+        // Close context menu when escape is pressed
+        window.addEventListener('keydown', (e) => {
+            if (e.code === 'Escape') {
+                this.showContextMenu(null, false);
+            }
+        });
+        // Add an event listener to listen to the 'contextmenu' event
+        this.el.nativeElement.addEventListener('contextmenu', (e) => {
+            // Prevent the default context menu to popup
+            if (e.preventDefault) {
+                e.preventDefault();
+            }
+            // Shows our own context menu
+            this.showContextMenu(e, true);
+        });
+    }
+    // Shows or hides our custom context menu, which is specified as a input
+    showContextMenu(event, show) {
+        const cm = this.ltContextMenu;
+        if (cm) {
+            // Try to open context menu
+            if (show && event && event instanceof MouseEvent) {
+                // Get valid clicked structureElement
+                const clickedElement = event?.target?.closest(this.selectors);
+                if (clickedElement) {
+                    // Set clicked structureElement
+                    this.clickedElement = clickedElement;
+                    setTimeout(() => {
+                        // Set display status
+                        cm.style.display = 'block';
+                        // Calculate top position
+                        let top = event.y + this.yGap;
+                        if (top + cm.offsetHeight + 10 > document.documentElement.clientHeight) {
+                            top = document.documentElement.clientHeight - cm.offsetHeight - this.overflowSpace;
+                        }
+                        // Calculate left position
+                        let left = event.x + this.xGap;
+                        if (left + cm.offsetWidth + 10 > document.documentElement.clientWidth) {
+                            left = document.documentElement.clientWidth - cm.offsetWidth - this.overflowSpace;
+                        }
+                        // Set position
+                        cm.style.top = top + 'px';
+                        cm.style.left = left + 'px';
+                        // Show
+                        cm.style.opacity = '1.0';
+                        cm.style['pointer-events'] = 'auto';
+                    }, 1);
+                    return;
+                }
+            }
+            // Close context menu
+            this.clickedElement = null;
+            if (this.previousDisplayStatus) {
+                cm.style.display = this.previousDisplayStatus;
+            }
+            cm.style.opacity = '0.01';
+            cm.style['pointer-events'] = 'none';
+        }
+    }
+}
+ContextMenuDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: ContextMenuDirective, deps: [{ token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Directive });
+ContextMenuDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.3.3", type: ContextMenuDirective, selector: "[ltContextMenu]", inputs: { contextMenuData: "contextMenuData", ltContextMenu: "ltContextMenu", xGap: "xGap", yGap: "yGap", overflowSpace: "overflowSpace", selectors: "selectors" }, outputs: { clickedElement: "clickedElement" }, exportAs: ["contextMenuData"], ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: ContextMenuDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[ltContextMenu]',
+                    exportAs: 'contextMenuData',
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }]; }, propDecorators: { contextMenuData: [{
+                type: Input
+            }], ltContextMenu: [{
+                type: Input
+            }], xGap: [{
+                type: Input
+            }], yGap: [{
+                type: Input
+            }], overflowSpace: [{
+                type: Input
+            }], selectors: [{
+                type: Input
+            }], clickedElement: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"context-menu.directive.js","sourceRoot":"","sources":["../../../../../projects/ng-base/src/directives/context-menu.directive.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAc,KAAK,EAAU,MAAM,EAAE,MAAM,eAAe,CAAC;;AAE7E;;;GAGG;AAKH,MAAM,OAAO,oBAAoB;IAU/B,YAAoB,EAAc;QAAd,OAAE,GAAF,EAAE,CAAY;QAPzB,SAAI,GAAG,CAAC,CAAC;QACT,SAAI,GAAG,CAAC,CAAC;QACT,kBAAa,GAAG,EAAE,CAAC;QACnB,cAAS,GAAG,GAAG,CAAC;QACf,mBAAc,GAAY,IAAI,CAAC;QACzC,0BAAqB,GAAW,IAAI,CAAC;IAEA,CAAC;IAEtC,QAAQ;QACN,IAAI,IAAI,CAAC,aAAa,EAAE;YACtB,IAAI,CAAC,qBAAqB,GAAG,IAAI,CAAC,aAAa,CAAC,KAAK,CAAC,OAAO,CAAC;SAC/D;QAED,sCAAsC;QACtC,sDAAsD;QACtD,MAAM,CAAC,gBAAgB,CAAC,OAAO,EAAE,GAAG,EAAE;YACpC,IAAI,CAAC,eAAe,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC;QACpC,CAAC,CAAC,CAAC;QAEH,4CAA4C;QAC5C,MAAM,CAAC,gBAAgB,CAAC,SAAS,EAAE,CAAC,CAAC,EAAE,EAAE;YACvC,IAAI,CAAC,CAAC,IAAI,KAAK,QAAQ,EAAE;gBACvB,IAAI,CAAC,eAAe,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC;aACnC;QACH,CAAC,CAAC,CAAC;QAEH,6DAA6D;QAC7D,IAAI,CAAC,EAAE,CAAC,aAAa,CAAC,gBAAgB,CAAC,aAAa,EAAE,CAAC,CAAC,EAAE,EAAE;YAC1D,4CAA4C;YAC5C,IAAI,CAAC,CAAC,cAAc,EAAE;gBACpB,CAAC,CAAC,cAAc,EAAE,CAAC;aACpB;YACD,6BAA6B;YAC7B,IAAI,CAAC,eAAe,CAAC,CAAC,EAAE,IAAI,CAAC,CAAC;QAChC,CAAC,CAAC,CAAC;IACL,CAAC;IAED,wEAAwE;IACxE,eAAe,CAAC,KAAK,EAAE,IAAa;QAClC,MAAM,EAAE,GAAG,IAAI,CAAC,aAAa,CAAC;QAC9B,IAAI,EAAE,EAAE;YACN,2BAA2B;YAC3B,IAAI,IAAI,IAAI,KAAK,IAAI,KAAK,YAAY,UAAU,EAAE;gBAChD,qCAAqC;gBACrC,MAAM,cAAc,GAAI,KAAK,EAAE,MAAsB,EAAE,OAAO,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;gBAC/E,IAAI,cAAc,EAAE;oBAClB,+BAA+B;oBAC/B,IAAI,CAAC,cAAc,GAAG,cAAc,CAAC;oBAErC,UAAU,CAAC,GAAG,EAAE;wBACd,qBAAqB;wBACrB,EAAE,CAAC,KAAK,CAAC,OAAO,GAAG,OAAO,CAAC;wBAE3B,yBAAyB;wBACzB,IAAI,GAAG,GAAG,KAAK,CAAC,CAAC,GAAG,IAAI,CAAC,IAAI,CAAC;wBAC9B,IAAI,GAAG,GAAG,EAAE,CAAC,YAAY,GAAG,EAAE,GAAG,QAAQ,CAAC,eAAe,CAAC,YAAY,EAAE;4BACtE,GAAG,GAAG,QAAQ,CAAC,eAAe,CAAC,YAAY,GAAG,EAAE,CAAC,YAAY,GAAG,IAAI,CAAC,aAAa,CAAC;yBACpF;wBAED,0BAA0B;wBAC1B,IAAI,IAAI,GAAG,KAAK,CAAC,CAAC,GAAG,IAAI,CAAC,IAAI,CAAC;wBAC/B,IAAI,IAAI,GAAG,EAAE,CAAC,WAAW,GAAG,EAAE,GAAG,QAAQ,CAAC,eAAe,CAAC,WAAW,EAAE;4BACrE,IAAI,GAAG,QAAQ,CAAC,eAAe,CAAC,WAAW,GAAG,EAAE,CAAC,WAAW,GAAG,IAAI,CAAC,aAAa,CAAC;yBACnF;wBAED,eAAe;wBACf,EAAE,CAAC,KAAK,CAAC,GAAG,GAAG,GAAG,GAAG,IAAI,CAAC;wBAC1B,EAAE,CAAC,KAAK,CAAC,IAAI,GAAG,IAAI,GAAG,IAAI,CAAC;wBAE5B,OAAO;wBACP,EAAE,CAAC,KAAK,CAAC,OAAO,GAAG,KAAK,CAAC;wBACzB,EAAE,CAAC,KAAK,CAAC,gBAAgB,CAAC,GAAG,MAAM,CAAC;oBACtC,CAAC,EAAE,CAAC,CAAC,CAAC;oBAEN,OAAO;iBACR;aACF;YAED,qBAAqB;YACrB,IAAI,CAAC,cAAc,GAAG,IAAI,CAAC;YAC3B,IAAI,IAAI,CAAC,qBAAqB,EAAE;gBAC9B,EAAE,CAAC,KAAK,CAAC,OAAO,GAAG,IAAI,CAAC,qBAAqB,CAAC;aAC/C;YACD,EAAE,CAAC,KAAK,CAAC,OAAO,GAAG,MAAM,CAAC;YAC1B,EAAE,CAAC,KAAK,CAAC,gBAAgB,CAAC,GAAG,MAAM,CAAC;SACrC;IACH,CAAC;;iHA1FU,oBAAoB;qGAApB,oBAAoB;2FAApB,oBAAoB;kBAJhC,SAAS;mBAAC;oBACT,QAAQ,EAAE,iBAAiB;oBAC3B,QAAQ,EAAE,iBAAiB;iBAC5B;iGAEU,eAAe;sBAAvB,KAAK;gBACG,aAAa;sBAArB,KAAK;gBACG,IAAI;sBAAZ,KAAK;gBACG,IAAI;sBAAZ,KAAK;gBACG,aAAa;sBAArB,KAAK;gBACG,SAAS;sBAAjB,KAAK;gBACI,cAAc;sBAAvB,MAAM","sourcesContent":["import { Directive, ElementRef, Input, OnInit, Output } from '@angular/core';\n\n/**\n * Directive vor context menu\n * See https://stackblitz.com/edit/angular-custom-context-menu\n */\n@Directive({\n  selector: '[ltContextMenu]',\n  exportAs: 'contextMenuData',\n})\nexport class ContextMenuDirective implements OnInit {\n  @Input() contextMenuData?: any;\n  @Input() ltContextMenu: HTMLElement;\n  @Input() xGap = 0;\n  @Input() yGap = 0;\n  @Input() overflowSpace = 10;\n  @Input() selectors = '*';\n  @Output() clickedElement: Element = null;\n  previousDisplayStatus: string = null;\n\n  constructor(private el: ElementRef) {}\n\n  ngOnInit() {\n    if (this.ltContextMenu) {\n      this.previousDisplayStatus = this.ltContextMenu.style.display;\n    }\n\n    // Add a click listener to the window,\n    // so that we can close the context menu on left click\n    window.addEventListener('click', () => {\n      this.showContextMenu(null, false);\n    });\n\n    // Close context menu when escape is pressed\n    window.addEventListener('keydown', (e) => {\n      if (e.code === 'Escape') {\n        this.showContextMenu(null, false);\n      }\n    });\n\n    // Add an event listener to listen to the 'contextmenu' event\n    this.el.nativeElement.addEventListener('contextmenu', (e) => {\n      // Prevent the default context menu to popup\n      if (e.preventDefault) {\n        e.preventDefault();\n      }\n      // Shows our own context menu\n      this.showContextMenu(e, true);\n    });\n  }\n\n  // Shows or hides our custom context menu, which is specified as a input\n  showContextMenu(event, show: boolean) {\n    const cm = this.ltContextMenu;\n    if (cm) {\n      // Try to open context menu\n      if (show && event && event instanceof MouseEvent) {\n        // Get valid clicked structureElement\n        const clickedElement = (event?.target as HTMLElement)?.closest(this.selectors);\n        if (clickedElement) {\n          // Set clicked structureElement\n          this.clickedElement = clickedElement;\n\n          setTimeout(() => {\n            // Set display status\n            cm.style.display = 'block';\n\n            // Calculate top position\n            let top = event.y + this.yGap;\n            if (top + cm.offsetHeight + 10 > document.documentElement.clientHeight) {\n              top = document.documentElement.clientHeight - cm.offsetHeight - this.overflowSpace;\n            }\n\n            // Calculate left position\n            let left = event.x + this.xGap;\n            if (left + cm.offsetWidth + 10 > document.documentElement.clientWidth) {\n              left = document.documentElement.clientWidth - cm.offsetWidth - this.overflowSpace;\n            }\n\n            // Set position\n            cm.style.top = top + 'px';\n            cm.style.left = left + 'px';\n\n            // Show\n            cm.style.opacity = '1.0';\n            cm.style['pointer-events'] = 'auto';\n          }, 1);\n\n          return;\n        }\n      }\n\n      // Close context menu\n      this.clickedElement = null;\n      if (this.previousDisplayStatus) {\n        cm.style.display = this.previousDisplayStatus;\n      }\n      cm.style.opacity = '0.01';\n      cm.style['pointer-events'] = 'none';\n    }\n  }\n}\n"]}

package/esm2020/src/directives/lazy-load.directive.mjs

@@ -0,0 +1,45 @@
+import { Directive, HostBinding, Input } from '@angular/core';
+import * as i0 from "@angular/core";
+/**
+ * Directive for lazy loading images
+ */
+export class LazyLoadDirective {
+    constructor(el) {
+        this.el = el;
+        this.srcAttr = null;
+    }
+    ngAfterViewInit() {
+        this.canLazyLoad() ? this.lazyLoadImage() : this.loadImage();
+    }
+    canLazyLoad() {
+        return window && 'IntersectionObserver' in window;
+    }
+    lazyLoadImage() {
+        const obs = new IntersectionObserver((entries) => {
+            entries.forEach(({ isIntersecting }) => {
+                if (isIntersecting) {
+                    this.loadImage();
+                    obs.unobserve(this.el.nativeElement);
+                }
+            });
+        });
+        obs.observe(this.el.nativeElement);
+    }
+    loadImage() {
+        this.srcAttr = this.src;
+    }
+}
+LazyLoadDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: LazyLoadDirective, deps: [{ token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Directive });
+LazyLoadDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.3.3", type: LazyLoadDirective, selector: "img[ltLazyLoad]", inputs: { src: "src" }, host: { properties: { "attr.src": "this.srcAttr" } }, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: LazyLoadDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: 'img[ltLazyLoad]',
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }]; }, propDecorators: { srcAttr: [{
+                type: HostBinding,
+                args: ['attr.src']
+            }], src: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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