@lenne.tech/ng-base 13.6.4 → 13.6.7

package/esm2020/shared/services/loader.service.mjs

@@ -0,0 +1,29 @@
+import { Injectable } from '@angular/core';
+import { BehaviorSubject } from 'rxjs';
+import * as i0 from "@angular/core";
+/**
+ * Loader service for loading indication
+ */
+export class LoaderService {
+    constructor() {
+        this.isLoading = new BehaviorSubject(false);
+    }
+    start() {
+        this.isLoading.next(true);
+    }
+    stop() {
+        this.isLoading.next(false);
+    }
+    getAsObservable() {
+        return this.isLoading.asObservable();
+    }
+}
+LoaderService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: LoaderService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+LoaderService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: LoaderService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: LoaderService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibG9hZGVyLnNlcnZpY2UuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9uZy1iYXNlL3NoYXJlZC9zZXJ2aWNlcy9sb2FkZXIuc2VydmljZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBQzNDLE9BQU8sRUFBRSxlQUFlLEVBQWMsTUFBTSxNQUFNLENBQUM7O0FBRW5EOztHQUVHO0FBSUgsTUFBTSxPQUFPLGFBQWE7SUFIMUI7UUFJUyxjQUFTLEdBQUcsSUFBSSxlQUFlLENBQUMsS0FBSyxDQUFDLENBQUM7S0FhL0M7SUFYUSxLQUFLO1FBQ1YsSUFBSSxDQUFDLFNBQVMsQ0FBQyxJQUFJLENBQUMsSUFBSSxDQUFDLENBQUM7SUFDNUIsQ0FBQztJQUVNLElBQUk7UUFDVCxJQUFJLENBQUMsU0FBUyxDQUFDLElBQUksQ0FBQyxLQUFLLENBQUMsQ0FBQztJQUM3QixDQUFDO0lBRU0sZUFBZTtRQUNwQixPQUFPLElBQUksQ0FBQyxTQUFTLENBQUMsWUFBWSxFQUFFLENBQUM7SUFDdkMsQ0FBQzs7MEdBYlUsYUFBYTs4R0FBYixhQUFhLGNBRlosTUFBTTsyRkFFUCxhQUFhO2tCQUh6QixVQUFVO21CQUFDO29CQUNWLFVBQVUsRUFBRSxNQUFNO2lCQUNuQiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEluamVjdGFibGUgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB7IEJlaGF2aW9yU3ViamVjdCwgT2JzZXJ2YWJsZSB9IGZyb20gJ3J4anMnO1xuXG4vKipcbiAqIExvYWRlciBzZXJ2aWNlIGZvciBsb2FkaW5nIGluZGljYXRpb25cbiAqL1xuQEluamVjdGFibGUoe1xuICBwcm92aWRlZEluOiAncm9vdCcsXG59KVxuZXhwb3J0IGNsYXNzIExvYWRlclNlcnZpY2Uge1xuICBwdWJsaWMgaXNMb2FkaW5nID0gbmV3IEJlaGF2aW9yU3ViamVjdChmYWxzZSk7XG5cbiAgcHVibGljIHN0YXJ0KCk6IHZvaWQge1xuICAgIHRoaXMuaXNMb2FkaW5nLm5leHQodHJ1ZSk7XG4gIH1cblxuICBwdWJsaWMgc3RvcCgpOiB2b2lkIHtcbiAgICB0aGlzLmlzTG9hZGluZy5uZXh0KGZhbHNlKTtcbiAgfVxuXG4gIHB1YmxpYyBnZXRBc09ic2VydmFibGUoKTogT2JzZXJ2YWJsZTxib29sZWFuPiB7XG4gICAgcmV0dXJuIHRoaXMuaXNMb2FkaW5nLmFzT2JzZXJ2YWJsZSgpO1xuICB9XG59XG4iXX0=

package/esm2020/shared/services/scroll.service.mjs

@@ -0,0 +1,179 @@
+import { Inject, Injectable } from '@angular/core';
+import { BASE_MODULE_CONFIG } from '../interfaces/base-module-config.interface';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/router";
+import * as i2 from "./image.service";
+/**
+ * Scroll service for autoscroll to specific fragments
+ */
+export class ScrollService {
+    /**
+     * Initializer
+     */
+    constructor(router, moduleConfig, imageService) {
+        this.router = router;
+        this.moduleConfig = moduleConfig;
+        this.imageService = imageService;
+        /**
+         * Is a scroll listener set
+         *
+         * @protected
+         */
+        this.scrollListener = false;
+        /**
+         * Current scroll timer;
+         *
+         * @protected
+         */
+        this.scrollTimer = -1;
+        const config = {
+            scrollDetectionOffset: 200,
+            scrollOffset: 100,
+            scrollSamplingRate: 100,
+            ...moduleConfig,
+        };
+        this.detectionOffset = config.scrollDetectionOffset;
+        this.scrollOffset = config.scrollOffset;
+        this.scrollSamplingRate = config.scrollSamplingRate;
+    }
+    /**
+     * Scroll to structureElement with specific ID
+     */
+    async scrollTo(id, options = {}) {
+        // Prepare config
+        const config = {
+            checkUrl: false,
+            loadImagesBefore: true,
+            resetStyles: false,
+            setOverflow: true,
+            stopPropagation: true,
+            ...options,
+        };
+        // Check current URL
+        if (config.checkUrl && this.router.url !== '/' && !this.router.url.startsWith('/#')) {
+            await this.router.navigate(['/'], { fragment: id });
+            return !config.stopPropagation;
+        }
+        // Check if target element exits
+        const el = document.getElementById(id);
+        if (!el) {
+            console.error('Missing scroll element with ID:', id);
+            return !config.stopPropagation;
+        }
+        // Check if body overflow is visible
+        // This is necessary for scroll handling
+        const body = document.querySelector('body');
+        let undoOverflowChanges = false;
+        const scrollBodyStyles = JSON.parse(JSON.stringify(window.getComputedStyle(body)));
+        if (config.setOverflow && (scrollBodyStyles.overflowX !== 'visible' || scrollBodyStyles.overflowY !== 'visible')) {
+            // Set body overflow to visible
+            console.warn('Style of body element for overflowX and overflowY will be set to "visible" for scrolling!');
+            body.style.overflowX = 'visible';
+            body.style.overflowY = 'visible';
+            undoOverflowChanges = true;
+        }
+        // Load images before scrolling (once)
+        if (config.loadImagesBefore) {
+            await this.imageService.preLoadImages();
+        }
+        // Get get bounding rect of target element
+        const cords = el.getBoundingClientRect();
+        // Scroll to element
+        window.scrollBy({ top: cords.top - this.scrollOffset, behavior: 'smooth' });
+        await this.scrollDone({
+            doneFunction: () => {
+                // Undo changes
+                if (undoOverflowChanges && config.resetStyles) {
+                    body.style.overflowX = scrollBodyStyles.overflowX;
+                    body.style.overflowY = scrollBodyStyles.overflowY;
+                    console.warn('Original style of body element for overflowX and overflowY is set.');
+                }
+            },
+        });
+        // Return stop propagation configuration
+        return !config.stopPropagation;
+    }
+    /**
+     * Get last active structureElement
+     */
+    getLastActiveElement(list) {
+        const currentScrollPosition = window.scrollY;
+        const elementsWithId = document.querySelectorAll('[id]');
+        let lastId = null;
+        let lastPosition = 0 - this.detectionOffset - 1;
+        elementsWithId.forEach((element) => {
+            const cords = element.getBoundingClientRect();
+            const top = cords.top + window.pageYOffset - this.detectionOffset;
+            if ((!list || !list.length || list.includes(element.id)) && // In list
+                top < currentScrollPosition && // In active area
+                lastPosition < top // Higher than the last one
+            ) {
+                lastId = element.id;
+                lastPosition = top;
+            }
+        });
+        return lastId;
+    }
+    /**
+     * Check if ID is active
+     */
+    isActive(id, list, isFirst) {
+        const lastActiveElement = this.getLastActiveElement(list);
+        return id === lastActiveElement || (lastActiveElement === null && isFirst);
+    }
+    /**
+     * Scroll done promise
+     */
+    async scrollDone(options = {}) {
+        // Init configuration
+        const config = {
+            doneFunction: undefined,
+            ...options,
+        };
+        // Wait for scroll done
+        await this.scrollDoneDetection();
+        // Get result
+        if (config.doneFunction) {
+            return config.doneFunction();
+        }
+    }
+    /**
+     * Scroll done detecton
+     *
+     * @protected
+     */
+    scrollDoneDetection() {
+        // Return current scroll promise (Singelton)
+        if (this.scrollPromise) {
+            return this.scrollPromise;
+        }
+        // Create current scroll promise
+        this.scrollPromise = new Promise((resolve) => {
+            this.scrollPromiseResolve = resolve;
+            if (this.scrollTimer !== -1) {
+                window.clearTimeout(this.scrollTimer);
+            }
+            this.scrollTimer = window.setTimeout(() => {
+                window.removeEventListener('scroll', this.scrollDoneDetection.bind(this));
+                this.scrollPromise = undefined;
+                resolve();
+            }, this.scrollSamplingRate);
+        });
+        // Lisitening to scroll event;
+        window.addEventListener('scroll', this.scrollDoneDetection.bind(this));
+        // Return promise
+        return this.scrollPromise;
+    }
+}
+ScrollService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: ScrollService, deps: [{ token: i1.Router }, { token: BASE_MODULE_CONFIG }, { token: i2.ImageService }], target: i0.ɵɵFactoryTarget.Injectable });
+ScrollService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: ScrollService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: ScrollService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return [{ type: i1.Router }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [BASE_MODULE_CONFIG]
+                }] }, { type: i2.ImageService }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"scroll.service.js","sourceRoot":"","sources":["../../../../../projects/ng-base/shared/services/scroll.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Inject, Injectable } from '@angular/core';\nimport { Router } from '@angular/router';\nimport { BASE_MODULE_CONFIG, BaseModuleConfig } from '../interfaces/base-module-config.interface';\nimport { ImageService } from './image.service';\n\n/**\n * Scroll service for autoscroll to specific fragments\n */\n@Injectable({\n  providedIn: 'root',\n})\nexport class ScrollService {\n  /**\n   * Current scroll promise\n   *\n   * @protected\n   */\n  protected scrollPromise: Promise<void>;\n\n  /**\n   * Resolve function of current scroll promise\n   *\n   * @protected\n   */\n  protected scrollPromiseResolve: (value: void | PromiseLike<void>) => void;\n\n  /**\n   * Is a scroll listener set\n   *\n   * @protected\n   */\n  protected scrollListener = false;\n\n  /**\n   * Current scroll timer;\n   *\n   * @protected\n   */\n  protected scrollTimer = -1;\n\n  /**\n   * Scroll offset\n   */\n  protected readonly scrollOffset: number;\n\n  /**\n   * Detection offset\n   * Should be >= scrollOffset\n   */\n  protected readonly detectionOffset: number;\n\n  /**\n   * Sampling rate for scroll done detection\n   */\n  protected readonly scrollSamplingRate: number;\n\n  /**\n   * Initializer\n   */\n  constructor(\n    protected router: Router,\n    @Inject(BASE_MODULE_CONFIG) protected moduleConfig: BaseModuleConfig,\n    protected imageService: ImageService\n  ) {\n    const config = {\n      scrollDetectionOffset: 200,\n      scrollOffset: 100,\n      scrollSamplingRate: 100,\n      ...moduleConfig,\n    };\n\n    this.detectionOffset = config.scrollDetectionOffset;\n    this.scrollOffset = config.scrollOffset;\n    this.scrollSamplingRate = config.scrollSamplingRate;\n  }\n\n  /**\n   * Scroll to structureElement with specific ID\n   */\n  async scrollTo(\n    id: string,\n    options: {\n      checkUrl?: boolean;\n      loadImagesBefore?: boolean;\n      resetStyles?: boolean;\n      setOverflow?: boolean;\n      stopPropagation?: boolean;\n    } = {}\n  ) {\n    // Prepare config\n    const config = {\n      checkUrl: false,\n      loadImagesBefore: true,\n      resetStyles: false,\n      setOverflow: true,\n      stopPropagation: true,\n      ...options,\n    };\n\n    // Check current URL\n    if (config.checkUrl && this.router.url !== '/' && !this.router.url.startsWith('/#')) {\n      await this.router.navigate(['/'], { fragment: id });\n      return !config.stopPropagation;\n    }\n\n    // Check if target element exits\n    const el = document.getElementById(id);\n    if (!el) {\n      console.error('Missing scroll element with ID:', id);\n      return !config.stopPropagation;\n    }\n\n    // Check if body overflow is visible\n    // This is necessary for scroll handling\n    const body = document.querySelector('body');\n    let undoOverflowChanges = false;\n    const scrollBodyStyles = JSON.parse(JSON.stringify(window.getComputedStyle(body)));\n    if (config.setOverflow && (scrollBodyStyles.overflowX !== 'visible' || scrollBodyStyles.overflowY !== 'visible')) {\n      // Set body overflow to visible\n      console.warn('Style of body element for overflowX and overflowY will be set to \"visible\" for scrolling!');\n      body.style.overflowX = 'visible';\n      body.style.overflowY = 'visible';\n      undoOverflowChanges = true;\n    }\n\n    // Load images before scrolling (once)\n    if (config.loadImagesBefore) {\n      await this.imageService.preLoadImages();\n    }\n\n    // Get get bounding rect of target element\n    const cords = el.getBoundingClientRect();\n\n    // Scroll to element\n    window.scrollBy({ top: cords.top - this.scrollOffset, behavior: 'smooth' });\n    await this.scrollDone({\n      doneFunction: () => {\n        // Undo changes\n        if (undoOverflowChanges && config.resetStyles) {\n          body.style.overflowX = scrollBodyStyles.overflowX;\n          body.style.overflowY = scrollBodyStyles.overflowY;\n          console.warn('Original style of body element for overflowX and overflowY is set.');\n        }\n      },\n    });\n\n    // Return stop propagation configuration\n    return !config.stopPropagation;\n  }\n\n  /**\n   * Get last active structureElement\n   */\n  getLastActiveElement(list?): string {\n    const currentScrollPosition = window.scrollY;\n    const elementsWithId = document.querySelectorAll('[id]');\n    let lastId = null;\n    let lastPosition = 0 - this.detectionOffset - 1;\n    elementsWithId.forEach((element) => {\n      const cords = element.getBoundingClientRect();\n      const top = cords.top + window.pageYOffset - this.detectionOffset;\n      if (\n        (!list || !list.length || list.includes(element.id)) && // In list\n        top < currentScrollPosition && // In active area\n        lastPosition < top // Higher than the last one\n      ) {\n        lastId = element.id;\n        lastPosition = top;\n      }\n    });\n    return lastId;\n  }\n\n  /**\n   * Check if ID is active\n   */\n  isActive(id, list?, isFirst?) {\n    const lastActiveElement = this.getLastActiveElement(list);\n    return id === lastActiveElement || (lastActiveElement === null && isFirst);\n  }\n\n  /**\n   * Scroll done promise\n   */\n  public async scrollDone(options: { doneFunction?: () => any | void } = {}): Promise<any> {\n    // Init configuration\n    const config = {\n      doneFunction: undefined,\n      ...options,\n    };\n\n    // Wait for scroll done\n    await this.scrollDoneDetection();\n\n    // Get result\n    if (config.doneFunction) {\n      return config.doneFunction();\n    }\n  }\n\n  /**\n   * Scroll done detecton\n   *\n   * @protected\n   */\n  protected scrollDoneDetection(): Promise<void> {\n    // Return current scroll promise (Singelton)\n    if (this.scrollPromise) {\n      return this.scrollPromise;\n    }\n\n    // Create current scroll promise\n    this.scrollPromise = new Promise((resolve) => {\n      this.scrollPromiseResolve = resolve;\n      if (this.scrollTimer !== -1) {\n        window.clearTimeout(this.scrollTimer);\n      }\n      this.scrollTimer = window.setTimeout(() => {\n        window.removeEventListener('scroll', this.scrollDoneDetection.bind(this));\n        this.scrollPromise = undefined;\n        resolve();\n      }, this.scrollSamplingRate);\n    });\n\n    // Lisitening to scroll event;\n    window.addEventListener('scroll', this.scrollDoneDetection.bind(this));\n\n    // Return promise\n    return this.scrollPromise;\n  }\n}\n"]}

package/esm2020/shared/services/storage.service.mjs

@@ -0,0 +1,132 @@
+import { Inject, Injectable } from '@angular/core';
+import { BASE_MODULE_CONFIG } from '../interfaces/base-module-config.interface';
+import * as i0 from "@angular/core";
+/**
+ * Storage service for local data storage
+ */
+export class StorageService {
+    /**
+     * Initializations
+     */
+    constructor(moduleConfig) {
+        this.moduleConfig = moduleConfig;
+        /**
+         * Storage
+         */
+        this.storage = null;
+        /**
+         * Prefix for storage keys
+         */
+        this.prefix = '';
+        // Set storage
+        const type = moduleConfig.storageType ? moduleConfig.storageType : 'local';
+        if (window[type + 'Storage']) {
+            this.storage = window[type + 'Storage'];
+        }
+        // Set prefix
+        this.prefix = '';
+        if (moduleConfig.prefix) {
+            this.prefix += moduleConfig.prefix + '_';
+        }
+        if (moduleConfig.version) {
+            this.prefix += moduleConfig.version + '_';
+        }
+    }
+    /**
+     * Save itemKeys
+     *
+     * If you want to save one item, use itemKeys and value parameters like these:
+     * save('KEY_OF_THE_ITEM', ITEM)
+     *
+     * If you want to save multiple items, use itemKeys only (value parameter will be ignored):
+     * save({'KEY_OF_ITEM_1': ITEM_1, 'KEY_OF_ITEM_2': ITEM_2, ...})
+     */
+    save(itemKeys, value) {
+        // Check local storage
+        if (!this.storage) {
+            return false;
+        }
+        // Check item keys and value
+        if (!itemKeys ||
+            (typeof itemKeys === 'object' && !Object.keys(itemKeys).length) ||
+            (typeof itemKeys === 'string' && value === undefined)) {
+            return false;
+        }
+        if (typeof itemKeys === 'object') {
+            for (const [itemKey, itemValue] of Object.entries(itemKeys)) {
+                this.storage.setItem(this.prefix + itemKey, JSON.stringify(itemValue));
+            }
+            return true;
+        }
+        this.storage.setItem(this.prefix + itemKeys, JSON.stringify(value));
+        return true;
+    }
+    /**
+     * Load items via key(s)
+     */
+    load(itemKeys) {
+        // Check local storage
+        if (!this.storage) {
+            return;
+        }
+        // Check item keys
+        if (!itemKeys || (Array.isArray(itemKeys) && !itemKeys.length)) {
+            return null;
+        }
+        if (Array.isArray(itemKeys)) {
+            const back = {};
+            itemKeys.forEach((itemKey) => {
+                const loadedItem = this.storage.getItem(this.prefix + itemKey);
+                if (loadedItem) {
+                    back[itemKey] = JSON.parse(loadedItem);
+                }
+                else {
+                    back[itemKey] = null;
+                }
+            });
+            return back;
+        }
+        let value = this.storage.getItem(this.prefix + itemKeys);
+        if (value) {
+            value = JSON.parse(value);
+        }
+        return value;
+    }
+    /**
+     * Remove item from storage
+     *
+     * @param itemKeys keys or key to remove
+     */
+    remove(itemKeys) {
+        // Check local storage
+        if (!this.storage) {
+            return false;
+        }
+        if (Array.isArray(itemKeys)) {
+            itemKeys.forEach((key) => {
+                this.storage.removeItem(this.prefix + key);
+            });
+            return true;
+        }
+        this.storage.removeItem(this.prefix + itemKeys);
+        return true;
+    }
+    /**
+     * Clear local storage
+     */
+    reset() {
+        this.storage.clear();
+    }
+}
+StorageService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: StorageService, deps: [{ token: BASE_MODULE_CONFIG }], target: i0.ɵɵFactoryTarget.Injectable });
+StorageService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: StorageService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: StorageService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: [BASE_MODULE_CONFIG]
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"storage.service.js","sourceRoot":"","sources":["../../../../../projects/ng-base/shared/services/storage.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Inject, Injectable } from '@angular/core';\nimport { BASE_MODULE_CONFIG, BaseModuleConfig } from '../interfaces/base-module-config.interface';\n\n/**\n * Storage service for local data storage\n */\n@Injectable({\n  providedIn: 'root',\n})\nexport class StorageService {\n  /**\n   * Storage\n   */\n  protected storage: any = null;\n\n  /**\n   * Prefix for storage keys\n   */\n  protected prefix = '';\n\n  /**\n   * Initializations\n   */\n  constructor(@Inject(BASE_MODULE_CONFIG) private moduleConfig: BaseModuleConfig) {\n    // Set storage\n    const type = moduleConfig.storageType ? moduleConfig.storageType : 'local';\n    if (window[type + 'Storage']) {\n      this.storage = window[type + 'Storage'];\n    }\n\n    // Set prefix\n    this.prefix = '';\n    if (moduleConfig.prefix) {\n      this.prefix += moduleConfig.prefix + '_';\n    }\n    if (moduleConfig.version) {\n      this.prefix += moduleConfig.version + '_';\n    }\n  }\n\n  /**\n   * Save itemKeys\n   *\n   * If you want to save one item, use itemKeys and value parameters like these:\n   * save('KEY_OF_THE_ITEM', ITEM)\n   *\n   * If you want to save multiple items, use itemKeys only (value parameter will be ignored):\n   * save({'KEY_OF_ITEM_1': ITEM_1, 'KEY_OF_ITEM_2': ITEM_2, ...})\n   */\n  public save(itemKeys: string | { [key: string]: any }, value?: any): boolean {\n    // Check local storage\n    if (!this.storage) {\n      return false;\n    }\n\n    // Check item keys and value\n    if (\n      !itemKeys ||\n      (typeof itemKeys === 'object' && !Object.keys(itemKeys).length) ||\n      (typeof itemKeys === 'string' && value === undefined)\n    ) {\n      return false;\n    }\n\n    if (typeof itemKeys === 'object') {\n      for (const [itemKey, itemValue] of Object.entries(itemKeys)) {\n        this.storage.setItem(this.prefix + itemKey, JSON.stringify(itemValue));\n      }\n      return true;\n    }\n\n    this.storage.setItem(this.prefix + itemKeys, JSON.stringify(value));\n    return true;\n  }\n\n  /**\n   * Load items via key(s)\n   */\n  public load(itemKeys: string | string[]): any {\n    // Check local storage\n    if (!this.storage) {\n      return;\n    }\n\n    // Check item keys\n    if (!itemKeys || (Array.isArray(itemKeys) && !itemKeys.length)) {\n      return null;\n    }\n\n    if (Array.isArray(itemKeys)) {\n      const back = {};\n      itemKeys.forEach((itemKey) => {\n        const loadedItem = this.storage.getItem(this.prefix + itemKey);\n        if (loadedItem) {\n          back[itemKey] = JSON.parse(loadedItem);\n        } else {\n          back[itemKey] = null;\n        }\n      });\n      return back;\n    }\n\n    let value = this.storage.getItem(this.prefix + itemKeys);\n    if (value) {\n      value = JSON.parse(value);\n    }\n\n    return value;\n  }\n\n  /**\n   * Remove item from storage\n   *\n   * @param itemKeys keys or key to remove\n   */\n  public remove(itemKeys: string | string[]): boolean {\n    // Check local storage\n    if (!this.storage) {\n      return false;\n    }\n\n    if (Array.isArray(itemKeys)) {\n      itemKeys.forEach((key) => {\n        this.storage.removeItem(this.prefix + key);\n      });\n      return true;\n    }\n\n    this.storage.removeItem(this.prefix + itemKeys);\n    return true;\n  }\n\n  /**\n   * Clear local storage\n   */\n  public reset(): void {\n    this.storage.clear();\n  }\n}\n"]}

package/esm2020/shared/services/user.service.mjs

@@ -0,0 +1,82 @@
+import { Injectable } from '@angular/core';
+import { map } from 'rxjs';
+import { Auth } from '../classes/auth.class';
+import { BasicUser } from '../classes/basic-user.class';
+import { GraphQLRequestType } from '../enums/graphql-request-type.enum';
+import { GraphQLPlusService } from './graphql-plus.service';
+import * as i0 from "@angular/core";
+import * as i1 from "apollo-angular";
+import * as i2 from "./graphql-meta.service";
+import * as i3 from "./loader.service";
+import * as i4 from "./auth.service";
+export class UserService extends GraphQLPlusService {
+    constructor(apollo, graphqlMetaService, loaderService, authService) {
+        super(apollo, graphqlMetaService, loaderService);
+        this.apollo = apollo;
+        this.graphqlMetaService = graphqlMetaService;
+        this.loaderService = loaderService;
+        this.authService = authService;
+    }
+    /**
+     * Login
+     *
+     * @param input
+     */
+    login(input) {
+        return this.graphQl('signIn', {
+            arguments: { input },
+            fields: ['token', { user: ['id', 'firstName', 'lastName', 'email', 'roles'] }],
+            type: GraphQLRequestType.QUERY,
+            loading: true,
+        }).pipe(map((response) => {
+            this.authService.token = response.token;
+            this.authService.currentUser = BasicUser.map(response.user);
+            return Auth.map({
+                token: response.token,
+                user: BasicUser.map(response.user),
+            });
+        }));
+    }
+    /**
+     * Register
+     *
+     * @param input
+     */
+    register(input) {
+        return this.graphQl('signUp', {
+            arguments: { input },
+            fields: ['token', { user: ['id', 'firstName', 'lastName', 'email', 'roles'] }],
+            type: GraphQLRequestType.MUTATION,
+            loading: true,
+        }).pipe(map((response) => {
+            this.authService.token = response.token;
+            this.authService.currentUser = BasicUser.map(response.user);
+            return Auth.map({
+                token: response.token,
+                user: BasicUser.map(response.user),
+            });
+        }));
+    }
+    /**
+     * Request password reset mail
+     *
+     * @param email
+     */
+    requestPasswordResetMail(email) {
+        return this.graphQl('requestPasswordResetMail', {
+            arguments: { email },
+            fields: [],
+            type: GraphQLRequestType.QUERY,
+            loading: true,
+        });
+    }
+}
+UserService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: UserService, deps: [{ token: i1.Apollo }, { token: i2.GraphQLMetaService }, { token: i3.LoaderService }, { token: i4.AuthService }], target: i0.ɵɵFactoryTarget.Injectable });
+UserService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: UserService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: UserService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return [{ type: i1.Apollo }, { type: i2.GraphQLMetaService }, { type: i3.LoaderService }, { type: i4.AuthService }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/shared/services/ws.service.mjs

@@ -0,0 +1,16 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+export class WsService {
+    reconnect() {
+        this.client?.restart();
+    }
+}
+WsService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: WsService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+WsService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: WsService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: WsService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoid3Muc2VydmljZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL25nLWJhc2Uvc2hhcmVkL3NlcnZpY2VzL3dzLnNlcnZpY2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFVBQVUsRUFBRSxNQUFNLGVBQWUsQ0FBQzs7QUFNM0MsTUFBTSxPQUFPLFNBQVM7SUFHcEIsU0FBUztRQUNQLElBQUksQ0FBQyxNQUFNLEVBQUUsT0FBTyxFQUFFLENBQUM7SUFDekIsQ0FBQzs7c0dBTFUsU0FBUzswR0FBVCxTQUFTLGNBRlIsTUFBTTsyRkFFUCxTQUFTO2tCQUhyQixVQUFVO21CQUFDO29CQUNWLFVBQVUsRUFBRSxNQUFNO2lCQUNuQiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEluamVjdGFibGUgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB7IFJlc3RhcnRhYmxlQ2xpZW50IH0gZnJvbSAnLi4vZnVuY3Rpb25zL3dzLWNsaWVudC5mdW5jdGlvbic7XG5cbkBJbmplY3RhYmxlKHtcbiAgcHJvdmlkZWRJbjogJ3Jvb3QnLFxufSlcbmV4cG9ydCBjbGFzcyBXc1NlcnZpY2Uge1xuICBjbGllbnQ6IFJlc3RhcnRhYmxlQ2xpZW50O1xuXG4gIHJlY29ubmVjdCgpIHtcbiAgICB0aGlzLmNsaWVudD8ucmVzdGFydCgpO1xuICB9XG59XG4iXX0=

package/esm2020/shared/types/graphql-fields.type.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZ3JhcGhxbC1maWVsZHMudHlwZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL25nLWJhc2Uvc2hhcmVkL3R5cGVzL2dyYXBocWwtZmllbGRzLnR5cGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEdyYXBoUUxGaWVsZHNPYmplY3QgfSBmcm9tICcuLi9pbnRlcmZhY2VzL2dyYXBocWwtZmllbGRzLW9iamVjdC5pbnRlcmZhY2UnO1xuXG4vKipcbiAqIEdyYXBoUUwgZmllbGRzXG4gKi9cbmV4cG9ydCB0eXBlIEdyYXBoUUxGaWVsZHMgPSBzdHJpbmcgfCBzdHJpbmdbXSB8IEdyYXBoUUxGaWVsZHNPYmplY3Q7XG4iXX0=

package/esm2020/shared/types/storage.type.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3RvcmFnZS50eXBlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvbmctYmFzZS9zaGFyZWQvdHlwZXMvc3RvcmFnZS50eXBlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIFN0b3JhZ2UgdHlwZXNcbiAqL1xuZXhwb3J0IHR5cGUgU3RvcmFnZVR5cGUgPSAnbG9jYWwnIHwgJ3Nlc3Npb24nO1xuIl19

package/esm2020/shared/validators/match.validator.mjs

@@ -0,0 +1,19 @@
+export class Validation {
+    static match(controlName, checkControlName) {
+        return (controls) => {
+            const control = controls.get(controlName);
+            const checkControl = controls.get(checkControlName);
+            if (checkControl?.errors && !checkControl.errors?.matching) {
+                return null;
+            }
+            if (control?.value !== checkControl?.value) {
+                controls.get(checkControlName)?.setErrors({ matching: true });
+                return { matching: true };
+            }
+            else {
+                return null;
+            }
+        };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibWF0Y2gudmFsaWRhdG9yLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvbmctYmFzZS9zaGFyZWQvdmFsaWRhdG9ycy9tYXRjaC52YWxpZGF0b3IudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBRUEsTUFBTSxPQUFPLFVBQVU7SUFDckIsTUFBTSxDQUFDLEtBQUssQ0FBQyxXQUFtQixFQUFFLGdCQUF3QjtRQUN4RCxPQUFPLENBQUMsUUFBeUIsRUFBRSxFQUFFO1lBQ25DLE1BQU0sT0FBTyxHQUFHLFFBQVEsQ0FBQyxHQUFHLENBQUMsV0FBVyxDQUFDLENBQUM7WUFDMUMsTUFBTSxZQUFZLEdBQUcsUUFBUSxDQUFDLEdBQUcsQ0FBQyxnQkFBZ0IsQ0FBQyxDQUFDO1lBQ3BELElBQUksWUFBWSxFQUFFLE1BQU0sSUFBSSxDQUFDLFlBQVksQ0FBQyxNQUFNLEVBQUUsUUFBUSxFQUFFO2dCQUMxRCxPQUFPLElBQUksQ0FBQzthQUNiO1lBQ0QsSUFBSSxPQUFPLEVBQUUsS0FBSyxLQUFLLFlBQVksRUFBRSxLQUFLLEVBQUU7Z0JBQzFDLFFBQVEsQ0FBQyxHQUFHLENBQUMsZ0JBQWdCLENBQUMsRUFBRSxTQUFTLENBQUMsRUFBRSxRQUFRLEVBQUUsSUFBSSxFQUFFLENBQUMsQ0FBQztnQkFDOUQsT0FBTyxFQUFFLFFBQVEsRUFBRSxJQUFJLEVBQUUsQ0FBQzthQUMzQjtpQkFBTTtnQkFDTCxPQUFPLElBQUksQ0FBQzthQUNiO1FBQ0gsQ0FBQyxDQUFDO0lBQ0osQ0FBQztDQUNGIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgQWJzdHJhY3RDb250cm9sLCBWYWxpZGF0b3JGbiB9IGZyb20gJ0Bhbmd1bGFyL2Zvcm1zJztcblxuZXhwb3J0IGNsYXNzIFZhbGlkYXRpb24ge1xuICBzdGF0aWMgbWF0Y2goY29udHJvbE5hbWU6IHN0cmluZywgY2hlY2tDb250cm9sTmFtZTogc3RyaW5nKTogVmFsaWRhdG9yRm4ge1xuICAgIHJldHVybiAoY29udHJvbHM6IEFic3RyYWN0Q29udHJvbCkgPT4ge1xuICAgICAgY29uc3QgY29udHJvbCA9IGNvbnRyb2xzLmdldChjb250cm9sTmFtZSk7XG4gICAgICBjb25zdCBjaGVja0NvbnRyb2wgPSBjb250cm9scy5nZXQoY2hlY2tDb250cm9sTmFtZSk7XG4gICAgICBpZiAoY2hlY2tDb250cm9sPy5lcnJvcnMgJiYgIWNoZWNrQ29udHJvbC5lcnJvcnM/Lm1hdGNoaW5nKSB7XG4gICAgICAgIHJldHVybiBudWxsO1xuICAgICAgfVxuICAgICAgaWYgKGNvbnRyb2w/LnZhbHVlICE9PSBjaGVja0NvbnRyb2w/LnZhbHVlKSB7XG4gICAgICAgIGNvbnRyb2xzLmdldChjaGVja0NvbnRyb2xOYW1lKT8uc2V0RXJyb3JzKHsgbWF0Y2hpbmc6IHRydWUgfSk7XG4gICAgICAgIHJldHVybiB7IG1hdGNoaW5nOiB0cnVlIH07XG4gICAgICB9IGVsc2Uge1xuICAgICAgICByZXR1cm4gbnVsbDtcbiAgICAgIH1cbiAgICB9O1xuICB9XG59XG4iXX0=

package/esm2020/src/base.module.mjs

@@ -1,9 +1,6 @@
-import { APOLLO_OPTIONS } from 'apollo-angular';
+import { APOLLO_OPTIONS, ApolloModule } from 'apollo-angular';
 import { HttpLink } from 'apollo-angular/http';
 import { NgModule } from '@angular/core';
-import { BASE_MODULE_CONFIG } from './interfaces/base-module-config.interface';
-import { AuthService } from './services/auth.service';
-import { WsService } from './services/ws.service';
 import { apolloOptionsFactory } from './factories/apollo-options.factory';
 import { ContextMenuDirective } from './directives/context-menu.directive';
 import { LazyLoadDirective } from './directives/lazy-load.directive';
@@ -12,6 +9,8 @@ import { ResizableDirective } from './directives/resizable.directive';
 import { EllipsesPipe } from './pipes/ellipses.pipe';
 import { SafeHtmlPipe } from './pipes/safe-html.pipe';
 import { DateAgoPipe } from './pipes/date-ago.pipe';
+import { AuthService, BASE_MODULE_CONFIG, WsService } from '@lenne.tech/ng-base/shared';
+import { HttpClientModule } from '@angular/common/http';
 import * as i0 from "@angular/core";
 // Imported and exported elements
 const elements = [
@@ -35,7 +34,7 @@ export class BaseModule {
     static forRoot(baseModuleConfig = {}, AppAuthService) {
         // Default config
         const config = {
-            apiUrl: 'localhost:3000',
+            apiUrl: '',
             authGuardRedirectUrl: '/auth',
             logging: false,
             version: null,
@@ -45,11 +44,14 @@ export class BaseModule {
             storageType: 'local',
             ...baseModuleConfig,
         };
+        if (config.logging) {
+            console.log('Config:', config);
+        }
         // Prepare providers
         const providers = [
             {
                 provide: BASE_MODULE_CONFIG,
-                useValue: baseModuleConfig,
+                useValue: config,
             },
         ];
         // Add apollo features if API URL is set
@@ -80,7 +82,7 @@ BaseModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "13
         // Pipes
         EllipsesPipe,
         SafeHtmlPipe,
-        DateAgoPipe], exports: [
+        DateAgoPipe], imports: [ApolloModule, HttpClientModule], exports: [
         // Directives
         ContextMenuDirective,
         LazyLoadDirective,
@@ -89,13 +91,14 @@ BaseModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "13
         // Pipes
         EllipsesPipe,
         SafeHtmlPipe,
-        DateAgoPipe] });
-BaseModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: BaseModule });
+        DateAgoPipe, ApolloModule, HttpClientModule] });
+BaseModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: BaseModule, imports: [[ApolloModule, HttpClientModule], ApolloModule, HttpClientModule] });
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: BaseModule, decorators: [{
             type: NgModule,
             args: [{
+                    imports: [ApolloModule, HttpClientModule],
                     declarations: elements,
-                    exports: elements,
+                    exports: [...elements, ApolloModule, HttpClientModule],
                 }]
         }] });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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