@colijnit/transaction 12.1.79 → 12.1.80

package/esm2015/lib/cache/cache-field.js

@@ -0,0 +1,75 @@
+import { EventEmitter } from "@angular/core";
+// Class represents a value that is to be loaded only once, lazily, by its .loadFunction, despite how many times or how fast its getValue() is called.
+export class CacheField {
+    constructor() {
+        this.onLoad = new EventEmitter();
+        this._isLoaded = false;
+    }
+    // The value of this cache field. Warning: might not have been loaded yet. Call ensureLoaded() or getvalue() for true value.
+    get value() {
+        return this._value;
+    }
+    set value(value) {
+        this._value = value;
+        this._promiseValue = Promise.resolve(value);
+        this._isLoaded = true;
+    }
+    // Whether the value has been loaded or not.
+    get isLoaded() {
+        return this._isLoaded;
+    }
+    // Whether the value is currently loading or not.
+    get isLoading() {
+        return !this._isLoaded && (this._promiseValue !== null && this._promiseValue !== undefined);
+    }
+    get loadNeverCalled() {
+        return !this.isLoading && !this.isLoaded;
+    }
+    // Loads and returns the value. Only loads from db if it wasn't loaded before (or forceReload was given true)
+    getValue(forceReload) {
+        return this.ensureLoaded(forceReload);
+    }
+    setValue(value) {
+        this.value = value;
+    }
+    /**
+     * POSTCONDITION: The .value of this cache field contains the loaded value as fetched by the resolve data of its .loadFunction.
+     * Will load only once, consecutive calls will resolve immediately or wait until the first original database fetch was finished.
+     * @returns {Promise<any>} Postcondition holds after resolve
+     */
+    ensureLoaded(forceReload) {
+        if (!forceReload && this._promiseValue) {
+            return this._promiseValue;
+        }
+        else {
+            return this._load();
+        }
+    }
+    // POSTCONDITION: The .value of this cache field contains a freshly loaded value as fetched by the resolve data of its loadFunction.
+    reload() {
+        return this.ensureLoaded(true);
+    }
+    // Resets / invaldates this cache field. Makes sure that the next load() will really perform its load function body again (e.g. visit the DB,
+    // if that's ur function)
+    reset() {
+        this._value = undefined;
+        this._promiseValue = undefined;
+        this._isLoaded = false;
+    }
+    _load() {
+        if (this.loadFunction) {
+            this._promiseValue = this.loadFunction.call(this);
+            this._promiseValue.then((value) => {
+                this._value = value;
+                this._isLoaded = true;
+                this.onLoad.emit();
+                return value;
+            });
+            return this._promiseValue;
+        }
+        else {
+            return Promise.resolve(undefined);
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/cache/parameter-cache-field.js

@@ -0,0 +1,54 @@
+import { CacheField } from "./cache-field";
+import { ObjectUtils } from "@colijnit/ioneconnector/build/utils/object-utils";
+// Class represents cached values retrieved by a load function that is to be called only once per unique input parameter combination.
+export class ParameterCacheField {
+    constructor() {
+        // A map from cache params (keys: the loadFunction arguments) to their cache fields
+        this._paramsToCacheItems = new Map();
+    }
+    // Returns the value for given loadfunction parameters. Loads if not yet loaded.
+    getValue(...params) {
+        return this._getCacheField(params).getValue();
+    }
+    setValue(value, ...params) {
+        return this._getCacheField(params).setValue(value);
+    }
+    // Returns the freshly reloaded value for given loadfunction parameters.
+    reload(...params) {
+        return this._getCacheField(params).reload();
+    }
+    // Resets one or all cache items. If no params given, resets ALL cache items.
+    reset(...params) {
+        if (params && params.length > 0) {
+            this._getCacheField(params).reset();
+        }
+        else {
+            this._paramsToCacheItems.forEach(cacheItem => cacheItem.reset());
+            this._paramsToCacheItems.clear();
+            this._paramsToCacheItems = new Map(); // not sure if clear() is enough for garbage collector?
+        }
+    }
+    // Makes a new cache field if none existed for these params. Returns the cache field that matches given params.
+    _getCacheField(params) {
+        let existingCacheField = undefined;
+        this._paramsToCacheItems.forEach((value, key) => {
+            if (!existingCacheField && ObjectUtils.DeepEquals(params, key)) {
+                existingCacheField = value;
+            }
+        });
+        if (existingCacheField) {
+            return existingCacheField;
+        }
+        else {
+            return this._makeNewCacheField(params);
+        }
+    }
+    // Creates and returns a new loadField for given params
+    _makeNewCacheField(params) {
+        const cacheField = new CacheField();
+        cacheField.loadFunction = this.loadFunction.bind(cacheField, ...params);
+        this._paramsToCacheItems.set(params, cacheField);
+        return cacheField;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/cache/service/business-object-cache-manager.service.js

@@ -0,0 +1,150 @@
+import { Injectable } from "@angular/core";
+import { Subject } from "rxjs";
+import { CacheField } from "../cache-field";
+import { ParameterCacheField } from "../parameter-cache-field";
+import { ObjectUtils } from "@colijnit/ioneconnector/build/utils/object-utils";
+import * as i0 from "@angular/core";
+/**
+ * App-wide, top-level, 'dumb' BO cache manager service. It stores and returns simple and parameterized business object cache items.
+ *
+ * Several other services register cache items onto this manager, such as repositories or the more generic SelectMultipleSimpleCacheService.
+ *
+ * This is a dumb cache manager. It just functions as a point to add and retrieve generic cache items, but does not know how to actually
+ * LOAD these cache items from the database, or what exact types the items are.
+ *
+ * All caches are reset when the user logs out.
+ */
+export class BusinessObjectCacheManagerService {
+    constructor() {
+        // emits after this BO cache manager has been reset (e.g. after user logs out)
+        this.reset = new Subject();
+        // key: global cache id's, e.g. a model classe or any other arbitrary key for cache items
+        this._selectMultipleCache = new Map();
+        // key: global cache id's, e.g. a model classe or any other arbitrary key for cache items
+        this._selectMultipleParameterizedCache = new Map();
+        this._selectSingleCache = new Map();
+        this._selectSingleParameterizedCache = new Map();
+    }
+    // constructor(private _transactionService: TransactionService) {
+    //   this._logoutSub = this._transactionService.logout.subscribe(() => {
+    //     this._reset();
+    //   });
+    // }
+    ngOnDestroy() {
+        this._logoutSub.unsubscribe();
+    }
+    /**
+     * Creates and adds a new simple cache item for the given key with the given load function.
+     * @param key
+     * @param loadFunction e.g. () => { return this._dataService.selectMultiple(Color); }
+     * @param overrideOld Whether to allow an old cache item with the same key to become override by this newly created cache item.
+     * @returns The newly created cache item.
+     */
+    addNewSelectMultipleCacheItem(key, loadFunction, overrideOld = false) {
+        if (!overrideOld && this._selectMultipleCache.has(key)) {
+            return;
+        }
+        const newCacheItem = new CacheField();
+        newCacheItem.loadFunction = loadFunction;
+        this._selectMultipleCache.set(key, newCacheItem);
+        return newCacheItem;
+    }
+    addNewSelectSingleCacheItem(key, id = BusinessObjectCacheManagerService._NullBoId, loadFunction, overrideOld = false) {
+        const cacheId = id.toString();
+        if (!overrideOld && this.hasSingleCacheItem(key, id)) {
+            return;
+        }
+        if (!this._selectSingleCache.has(key)) {
+            this._selectSingleCache.set(key, {});
+        }
+        const newCacheItem = new CacheField();
+        newCacheItem.loadFunction = loadFunction;
+        this._selectSingleCache.get(key)[cacheId] = newCacheItem;
+        return newCacheItem;
+    }
+    addNewSelectSingleParameterizedCacheItem(key, loadFunction, overrideOld = false) {
+        if (!overrideOld && this._selectSingleParameterizedCache.has(key)) {
+            return;
+        }
+        const newCacheItem = new ParameterCacheField();
+        newCacheItem.loadFunction = loadFunction;
+        this._selectSingleParameterizedCache.set(key, newCacheItem);
+        return newCacheItem;
+    }
+    /**
+     * Creates and adds a new parameterized cache item for the given key with the given load function.
+     * @param key
+     * @param loadFunction e.g. (category: ArticleCategory) => { return this._dataService.selectMultiple(TurnoverGroupImage, category); }
+     * @param overrideOld Whether to allow an old cache item with the same key to become override by this newly created cache item.
+     */
+    addNewSelectMultipleParameterizedCacheItem(key, loadFunction, overrideOld = false) {
+        if (!overrideOld && this._selectMultipleParameterizedCache.has(key)) {
+            return;
+        }
+        const newCacheItem = new ParameterCacheField();
+        newCacheItem.loadFunction = loadFunction;
+        this._selectMultipleParameterizedCache.set(key, newCacheItem);
+        return newCacheItem;
+    }
+    hasSelectMultipleCacheItem(key) {
+        return this._selectMultipleCache.has(key);
+    }
+    hasSingleCacheItem(key, id = BusinessObjectCacheManagerService._NullBoId) {
+        const cacheId = id.toString();
+        return this._selectSingleCache.has(key) && !!this._selectSingleCache.get(key)[cacheId];
+    }
+    hasSelectMultipleParameterizedCacheItem(key) {
+        return this._selectMultipleParameterizedCache.has(key);
+    }
+    hasSelectSingleParameterizedCacheItem(key) {
+        return this._selectSingleParameterizedCache.has(key);
+    }
+    // Returns the simple cache item with the given key. T is the type of the cache value items requested, e.g. Color.
+    getSelectMultipleCacheItem(key) {
+        return this._selectMultipleCache.get(key);
+    }
+    getSingleCacheItem(key, id = BusinessObjectCacheManagerService._NullBoId) {
+        const cacheId = id.toString();
+        return this._selectSingleCache.has(key) && this._selectSingleCache.get(key)[cacheId];
+    }
+    // Returns the parameterized cache item with the given key. T is the type of the cache value items requested, e.g. Color.
+    getSelectMultipleParameterCacheItem(key) {
+        return this._selectMultipleParameterizedCache.get(key);
+    }
+    getSelectSingleParameterCacheItem(key) {
+        return this._selectSingleParameterizedCache.get(key);
+    }
+    _reset() {
+        this._selectMultipleCache.forEach((cacheItem) => {
+            if (cacheItem) {
+                cacheItem.reset();
+            }
+        });
+        this._selectSingleCache.forEach((cache) => {
+            if (cache) {
+                ObjectUtils.ForOwnProperty(cache, (cacheField) => {
+                    cacheField.reset();
+                });
+            }
+        });
+        this._selectSingleParameterizedCache.forEach((selSinParamCacheItem) => {
+            if (selSinParamCacheItem) {
+                selSinParamCacheItem.reset();
+            }
+        });
+        this._selectMultipleParameterizedCache.forEach((selMulParamCacheItem) => {
+            if (selMulParamCacheItem) {
+                selMulParamCacheItem.reset();
+            }
+        });
+        this.reset.next();
+    }
+}
+BusinessObjectCacheManagerService._NullBoId = -1;
+BusinessObjectCacheManagerService.ɵprov = i0.ɵɵdefineInjectable({ factory: function BusinessObjectCacheManagerService_Factory() { return new BusinessObjectCacheManagerService(); }, token: BusinessObjectCacheManagerService, providedIn: "root" });
+BusinessObjectCacheManagerService.decorators = [
+    { type: Injectable, args: [{
+                providedIn: "root"
+            },] }
+];
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"business-object-cache-manager.service.js","sourceRoot":"","sources":["../../../../../../projects/transaction/src/lib/cache/service/business-object-cache-manager.service.ts"],"names":[],"mappings":"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","sourcesContent":["import {Injectable, OnDestroy} from \"@angular/core\";\r\nimport {Subject, Subscription} from \"rxjs\";\r\nimport {CacheField} from \"../cache-field\";\r\nimport {ParameterCacheField} from \"../parameter-cache-field\";\r\nimport {BusinessObject} from \"@colijnit/ioneconnector/build/model/business-object\";\r\nimport {ObjectUtils} from \"@colijnit/ioneconnector/build/utils/object-utils\";\r\nimport {BusinessObjectIDType} from \"@colijnit/ioneconnector/build/type/business-object-id-type\";\r\n\r\n/**\r\n * App-wide, top-level, 'dumb' BO cache manager service. It stores and returns simple and parameterized business object cache items.\r\n *\r\n * Several other services register cache items onto this manager, such as repositories or the more generic SelectMultipleSimpleCacheService.\r\n *\r\n * This is a dumb cache manager. It just functions as a point to add and retrieve generic cache items, but does not know how to actually\r\n * LOAD these cache items from the database, or what exact types the items are.\r\n *\r\n * All caches are reset when the user logs out.\r\n */\r\n@Injectable({\r\n    providedIn: \"root\"\r\n  }\r\n)\r\nexport class BusinessObjectCacheManagerService implements OnDestroy {\r\n  // emits after this BO cache manager has been reset (e.g. after user logs out)\r\n  public readonly reset: Subject<void> = new Subject<void>();\r\n\r\n  private static _NullBoId: number = -1;\r\n\r\n  // key: global cache id's, e.g. a model classe or any other arbitrary key for cache items\r\n  private _selectMultipleCache: Map<any, CacheField<BusinessObject[]>> = new Map();\r\n\r\n  // key: global cache id's, e.g. a model classe or any other arbitrary key for cache items\r\n  private _selectMultipleParameterizedCache: Map<any, ParameterCacheField<BusinessObject[]>>\r\n    = new Map<any, ParameterCacheField<BusinessObject[]>>();\r\n\r\n  private _selectSingleCache: Map<{ new(): BusinessObject }, { [id: string]: CacheField<BusinessObject> }> = new Map();\r\n  private _selectSingleParameterizedCache: Map<any, ParameterCacheField<BusinessObject>>\r\n    = new Map<any, ParameterCacheField<BusinessObject>>();\r\n\r\n  private _logoutSub: Subscription;\r\n\r\n  // constructor(private _transactionService: TransactionService) {\r\n  //   this._logoutSub = this._transactionService.logout.subscribe(() => {\r\n  //     this._reset();\r\n  //   });\r\n  // }\r\n\r\n  ngOnDestroy(): void {\r\n    this._logoutSub.unsubscribe();\r\n  }\r\n\r\n  /**\r\n   * Creates and adds a new simple cache item for the given key with the given load function.\r\n   * @param key\r\n   * @param loadFunction e.g. () => { return this._dataService.selectMultiple(Color); }\r\n   * @param overrideOld Whether to allow an old cache item with the same key to become override by this newly created cache item.\r\n   * @returns The newly created cache item.\r\n   */\r\n  public addNewSelectMultipleCacheItem<T extends BusinessObject>(\r\n    key: any,\r\n    loadFunction: () => Promise<T[]>,\r\n    overrideOld: boolean = false\r\n  ): CacheField<T[]> {\r\n    if (!overrideOld && this._selectMultipleCache.has(key)) {\r\n      return;\r\n    }\r\n\r\n    const newCacheItem: CacheField<T[]> = new CacheField<T[]>();\r\n    newCacheItem.loadFunction = loadFunction;\r\n    this._selectMultipleCache.set(key, newCacheItem);\r\n    return newCacheItem;\r\n  }\r\n\r\n  public addNewSelectSingleCacheItem<T extends BusinessObject>(\r\n    key: { new(): T },\r\n    id: BusinessObjectIDType = BusinessObjectCacheManagerService._NullBoId,\r\n    loadFunction: () => Promise<T>,\r\n    overrideOld: boolean = false\r\n  ): CacheField<T> {\r\n    const cacheId: string = id.toString();\r\n    if (!overrideOld && this.hasSingleCacheItem(key, id)) {\r\n      return;\r\n    }\r\n    if (!this._selectSingleCache.has(key)) {\r\n      this._selectSingleCache.set(key, {});\r\n    }\r\n    const newCacheItem: CacheField<T> = new CacheField<T>();\r\n    newCacheItem.loadFunction = loadFunction;\r\n    this._selectSingleCache.get(key)[cacheId] = newCacheItem;\r\n    return newCacheItem;\r\n  }\r\n\r\n  public addNewSelectSingleParameterizedCacheItem<T extends BusinessObject>(\r\n    key: any,\r\n    loadFunction: (params?: any) => Promise<T>,\r\n    overrideOld: boolean = false\r\n  ): ParameterCacheField<T> {\r\n    if (!overrideOld && this._selectSingleParameterizedCache.has(key)) {\r\n      return;\r\n    }\r\n\r\n    const newCacheItem: ParameterCacheField<T> = new ParameterCacheField<T>();\r\n    newCacheItem.loadFunction = loadFunction;\r\n    this._selectSingleParameterizedCache.set(key, newCacheItem);\r\n    return newCacheItem;\r\n  }\r\n\r\n  /**\r\n   * Creates and adds a new parameterized cache item for the given key with the given load function.\r\n   * @param key\r\n   * @param loadFunction e.g. (category: ArticleCategory) => { return this._dataService.selectMultiple(TurnoverGroupImage, category); }\r\n   * @param overrideOld Whether to allow an old cache item with the same key to become override by this newly created cache item.\r\n   */\r\n  public addNewSelectMultipleParameterizedCacheItem<T extends BusinessObject>(\r\n    key: any,\r\n    loadFunction: (params?: any) => Promise<T[]>,\r\n    overrideOld: boolean = false\r\n  ): ParameterCacheField<T[]> {\r\n    if (!overrideOld && this._selectMultipleParameterizedCache.has(key)) {\r\n      return;\r\n    }\r\n\r\n    const newCacheItem: ParameterCacheField<T[]> = new ParameterCacheField<T[]>();\r\n    newCacheItem.loadFunction = loadFunction;\r\n    this._selectMultipleParameterizedCache.set(key, newCacheItem);\r\n    return newCacheItem;\r\n  }\r\n\r\n  public hasSelectMultipleCacheItem(key: any): boolean {\r\n    return this._selectMultipleCache.has(key);\r\n  }\r\n\r\n  public hasSingleCacheItem<T extends BusinessObject>(key: { new(): T }, id: BusinessObjectIDType = BusinessObjectCacheManagerService._NullBoId): boolean {\r\n    const cacheId: string = id.toString();\r\n    return this._selectSingleCache.has(key) && !!this._selectSingleCache.get(key)[cacheId];\r\n  }\r\n\r\n  public hasSelectMultipleParameterizedCacheItem(key: any): boolean {\r\n    return this._selectMultipleParameterizedCache.has(key);\r\n  }\r\n\r\n  public hasSelectSingleParameterizedCacheItem(key: any): boolean {\r\n    return this._selectSingleParameterizedCache.has(key);\r\n  }\r\n\r\n  // Returns the simple cache item with the given key. T is the type of the cache value items requested, e.g. Color.\r\n  public getSelectMultipleCacheItem<T extends BusinessObject>(key: any): CacheField<T[]> {\r\n    return <CacheField<T[]>>this._selectMultipleCache.get(key);\r\n  }\r\n\r\n  public getSingleCacheItem<T extends BusinessObject>(key: { new(): T }, id: BusinessObjectIDType = BusinessObjectCacheManagerService._NullBoId): CacheField<T> {\r\n    const cacheId: string = id.toString();\r\n    return this._selectSingleCache.has(key) && this._selectSingleCache.get(key)[cacheId] as CacheField<T>;\r\n  }\r\n\r\n  // Returns the parameterized cache item with the given key. T is the type of the cache value items requested, e.g. Color.\r\n  public getSelectMultipleParameterCacheItem<T extends BusinessObject>(key: any): ParameterCacheField<T[]> {\r\n    return <ParameterCacheField<T[]>>this._selectMultipleParameterizedCache.get(key);\r\n  }\r\n\r\n  public getSelectSingleParameterCacheItem<T extends BusinessObject>(key: any): ParameterCacheField<T> {\r\n    return <ParameterCacheField<T>>this._selectSingleParameterizedCache.get(key);\r\n  }\r\n\r\n  private _reset(): void {\r\n    this._selectMultipleCache.forEach((cacheItem: CacheField<BusinessObject[]>) => {\r\n      if (cacheItem) {\r\n        cacheItem.reset();\r\n      }\r\n    });\r\n\r\n    this._selectSingleCache.forEach((cache: { [p: string]: CacheField<BusinessObject> }) => {\r\n      if (cache) {\r\n        ObjectUtils.ForOwnProperty(cache, (cacheField: CacheField<BusinessObject>) => {\r\n          cacheField.reset();\r\n        });\r\n      }\r\n    });\r\n\r\n    this._selectSingleParameterizedCache.forEach((selSinParamCacheItem: ParameterCacheField<BusinessObject>) => {\r\n      if (selSinParamCacheItem) {\r\n        selSinParamCacheItem.reset();\r\n      }\r\n    });\r\n\r\n    this._selectMultipleParameterizedCache.forEach((selMulParamCacheItem: ParameterCacheField<BusinessObject[]>) => {\r\n      if (selMulParamCacheItem) {\r\n        selMulParamCacheItem.reset();\r\n      }\r\n    });\r\n\r\n    this.reset.next();\r\n  }\r\n}\r\n"]}

package/esm2015/lib/cache/service/select-multiple-cache.service.js

@@ -0,0 +1,38 @@
+import { Injectable } from "@angular/core";
+import { BusinessObjectCacheManagerService } from "./business-object-cache-manager.service";
+import { CacheField } from "../cache-field";
+import * as i0 from "@angular/core";
+import * as i1 from "./business-object-cache-manager.service";
+export class SelectMultipleCacheService {
+    constructor(_boCacheManager) {
+        this._boCacheManager = _boCacheManager;
+    }
+    /**
+     * Returns the global cache item for the select multiple of the given business object class. Creates a new cache item if not yet exists.
+     * @param clazz The BO class, e.g. CustomerFullObject
+     * @returns {CacheField<T[]>}
+     */
+    requestCache(clazz, loadFunction) {
+        if (!this._boCacheManager.hasSelectMultipleCacheItem(clazz)) {
+            this._createCacheItem(clazz, loadFunction);
+        }
+        // noinspection TypeScriptValidateTypes
+        return this._boCacheManager.getSelectMultipleCacheItem(clazz);
+    }
+    // Creates and returns a new select multiple cache item into the global business object cache manager for given business object class.
+    _createCacheItem(clazz, loadFunction) {
+        // noinspection TypeScriptValidateTypes
+        return this._boCacheManager.addNewSelectMultipleCacheItem(clazz, loadFunction);
+    }
+}
+SelectMultipleCacheService._NullCache = new CacheField();
+SelectMultipleCacheService.ɵprov = i0.ɵɵdefineInjectable({ factory: function SelectMultipleCacheService_Factory() { return new SelectMultipleCacheService(i0.ɵɵinject(i1.BusinessObjectCacheManagerService)); }, token: SelectMultipleCacheService, providedIn: "root" });
+SelectMultipleCacheService.decorators = [
+    { type: Injectable, args: [{
+                providedIn: "root"
+            },] }
+];
+SelectMultipleCacheService.ctorParameters = () => [
+    { type: BusinessObjectCacheManagerService }
+];
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/cache/service/select-multiple-parameterized-cache.service.js

@@ -0,0 +1,47 @@
+import { Injectable } from "@angular/core";
+import { Subject } from "rxjs";
+import { BusinessObjectCacheManagerService } from "./business-object-cache-manager.service";
+import * as i0 from "@angular/core";
+import * as i1 from "./business-object-cache-manager.service";
+// service resonsible for filling the global BO cache manager service with parameterized select multiple cache items
+export class SelectMultipleParameterizedCacheService {
+    constructor(_boCacheManager) {
+        this._boCacheManager = _boCacheManager;
+        // emits after this select multiple parameterized cache service has been reset (e.g. after user logs out)
+        this.reset = new Subject();
+        this._subs = [];
+        this._subs.push(this._boCacheManager.reset.subscribe(() => {
+            this.reset.next();
+        }));
+    }
+    ngOnDestroy() {
+        this._subs.forEach(sub => sub.unsubscribe());
+    }
+    /**
+     * Returns the global cache item for the parameterized select multiple of the given business object class. Creates a new cache item if not yet exists.
+     * @param clazz The BO class, used for undeflying dataService.selectMultiple(clazz) call.
+     * @returns {CacheField<T[]>}
+     */
+    requestCache(clazz, loadFunction) {
+        if (!this._boCacheManager.hasSelectMultipleParameterizedCacheItem(clazz)) {
+            this._createParameterizedCacheItem(clazz, loadFunction);
+        }
+        // noinspection TypeScriptValidateTypes
+        return this._boCacheManager.getSelectMultipleParameterCacheItem(clazz);
+    }
+    // Creates and returns a new  parameterized select multiple cache item into the global business object cache manager for given business object class.
+    _createParameterizedCacheItem(clazz, loadFunction) {
+        // noinspection TypeScriptValidateTypes
+        return this._boCacheManager.addNewSelectMultipleParameterizedCacheItem(clazz, loadFunction);
+    }
+}
+SelectMultipleParameterizedCacheService.ɵprov = i0.ɵɵdefineInjectable({ factory: function SelectMultipleParameterizedCacheService_Factory() { return new SelectMultipleParameterizedCacheService(i0.ɵɵinject(i1.BusinessObjectCacheManagerService)); }, token: SelectMultipleParameterizedCacheService, providedIn: "root" });
+SelectMultipleParameterizedCacheService.decorators = [
+    { type: Injectable, args: [{
+                providedIn: "root"
+            },] }
+];
+SelectMultipleParameterizedCacheService.ctorParameters = () => [
+    { type: BusinessObjectCacheManagerService }
+];
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/cache/service/select-single-cache.service.js

@@ -0,0 +1,30 @@
+import { Injectable } from "@angular/core";
+import { BusinessObjectCacheManagerService } from "./business-object-cache-manager.service";
+import * as i0 from "@angular/core";
+import * as i1 from "./business-object-cache-manager.service";
+export class SelectSingleCacheService {
+    constructor(_boCacheManager) {
+        this._boCacheManager = _boCacheManager;
+    }
+    requestCache(clazz, sourceId, loadFunction) {
+        if (!this._boCacheManager.hasSingleCacheItem(clazz, sourceId)) {
+            this._createCacheItem(clazz, sourceId, loadFunction);
+        }
+        // noinspection TypeScriptValidateTypes
+        return this._boCacheManager.getSingleCacheItem(clazz, sourceId);
+    }
+    _createCacheItem(clazz, sourceId, loadFunction) {
+        // noinspection TypeScriptValidateTypes
+        return this._boCacheManager.addNewSelectSingleCacheItem(clazz, sourceId, loadFunction);
+    }
+}
+SelectSingleCacheService.ɵprov = i0.ɵɵdefineInjectable({ factory: function SelectSingleCacheService_Factory() { return new SelectSingleCacheService(i0.ɵɵinject(i1.BusinessObjectCacheManagerService)); }, token: SelectSingleCacheService, providedIn: "root" });
+SelectSingleCacheService.decorators = [
+    { type: Injectable, args: [{
+                providedIn: "root"
+            },] }
+];
+SelectSingleCacheService.ctorParameters = () => [
+    { type: BusinessObjectCacheManagerService }
+];
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/component/animated-checkbox/animated-checkbox.component.js

@@ -0,0 +1,27 @@
+import { Component, HostBinding, Input, ViewEncapsulation } from "@angular/core";
+export class AnimatedCheckboxComponent {
+    constructor() {
+        this.checked = false;
+    }
+    showClass() {
+        return true;
+    }
+}
+AnimatedCheckboxComponent.decorators = [
+    { type: Component, args: [{
+                selector: "co-animated-checkbox",
+                template: `
+    <div class="checkbox">
+      <div class="checkmark" [class.show]="checked"></div>
+    </div>
+    <div class="label" *ngIf="label" [textContent]="label | localize"></div>
+  `,
+                encapsulation: ViewEncapsulation.None
+            },] }
+];
+AnimatedCheckboxComponent.propDecorators = {
+    checked: [{ type: Input }],
+    label: [{ type: Input }],
+    showClass: [{ type: HostBinding, args: ["class.co-animated-checkbox",] }]
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYW5pbWF0ZWQtY2hlY2tib3guY29tcG9uZW50LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvdHJhbnNhY3Rpb24vc3JjL2xpYi9jb21wb25lbnQvYW5pbWF0ZWQtY2hlY2tib3gvYW5pbWF0ZWQtY2hlY2tib3guY29tcG9uZW50LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBQyxTQUFTLEVBQUUsV0FBVyxFQUFFLEtBQUssRUFBRSxpQkFBaUIsRUFBQyxNQUFNLGVBQWUsQ0FBQztBQVkvRSxNQUFNLE9BQU8seUJBQXlCO0lBVnRDO1FBYVMsWUFBTyxHQUFZLEtBQUssQ0FBQztJQVVsQyxDQUFDO0lBSlEsU0FBUztRQUNkLE9BQU8sSUFBSSxDQUFDO0lBQ2QsQ0FBQzs7O1lBckJGLFNBQVMsU0FBQztnQkFDVCxRQUFRLEVBQUUsc0JBQXNCO2dCQUNoQyxRQUFRLEVBQUU7Ozs7O0dBS1Q7Z0JBQ0QsYUFBYSxFQUFFLGlCQUFpQixDQUFDLElBQUk7YUFDdEM7OztzQkFHRSxLQUFLO29CQUdMLEtBQUs7d0JBR0wsV0FBVyxTQUFDLDRCQUE0QiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7Q29tcG9uZW50LCBIb3N0QmluZGluZywgSW5wdXQsIFZpZXdFbmNhcHN1bGF0aW9ufSBmcm9tIFwiQGFuZ3VsYXIvY29yZVwiO1xyXG5cclxuQENvbXBvbmVudCh7XHJcbiAgc2VsZWN0b3I6IFwiY28tYW5pbWF0ZWQtY2hlY2tib3hcIixcclxuICB0ZW1wbGF0ZTogYFxyXG4gICAgPGRpdiBjbGFzcz1cImNoZWNrYm94XCI+XHJcbiAgICAgIDxkaXYgY2xhc3M9XCJjaGVja21hcmtcIiBbY2xhc3Muc2hvd109XCJjaGVja2VkXCI+PC9kaXY+XHJcbiAgICA8L2Rpdj5cclxuICAgIDxkaXYgY2xhc3M9XCJsYWJlbFwiICpuZ0lmPVwibGFiZWxcIiBbdGV4dENvbnRlbnRdPVwibGFiZWwgfCBsb2NhbGl6ZVwiPjwvZGl2PlxyXG4gIGAsXHJcbiAgZW5jYXBzdWxhdGlvbjogVmlld0VuY2Fwc3VsYXRpb24uTm9uZVxyXG59KVxyXG5leHBvcnQgY2xhc3MgQW5pbWF0ZWRDaGVja2JveENvbXBvbmVudCB7XHJcblxyXG4gIEBJbnB1dCgpXHJcbiAgcHVibGljIGNoZWNrZWQ6IGJvb2xlYW4gPSBmYWxzZTtcclxuXHJcbiAgQElucHV0KClcclxuICBwdWJsaWMgbGFiZWw6IHN0cmluZztcclxuXHJcbiAgQEhvc3RCaW5kaW5nKFwiY2xhc3MuY28tYW5pbWF0ZWQtY2hlY2tib3hcIilcclxuICBwdWJsaWMgc2hvd0NsYXNzKCkge1xyXG4gICAgcmV0dXJuIHRydWU7XHJcbiAgfVxyXG5cclxufVxyXG4iXX0=

package/esm2015/lib/component/animated-checkbox/animated-checkbox.module.js

@@ -0,0 +1,21 @@
+import { NgModule } from "@angular/core";
+import { CommonModule } from "@angular/common";
+import { AnimatedCheckboxComponent } from "./animated-checkbox.component";
+import { PipeModule } from "../../pipe/pipe.module";
+export class AnimatedCheckboxModule {
+}
+AnimatedCheckboxModule.decorators = [
+    { type: NgModule, args: [{
+                imports: [
+                    CommonModule,
+                    PipeModule
+                ],
+                declarations: [
+                    AnimatedCheckboxComponent
+                ],
+                exports: [
+                    AnimatedCheckboxComponent
+                ]
+            },] }
+];
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYW5pbWF0ZWQtY2hlY2tib3gubW9kdWxlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvdHJhbnNhY3Rpb24vc3JjL2xpYi9jb21wb25lbnQvYW5pbWF0ZWQtY2hlY2tib3gvYW5pbWF0ZWQtY2hlY2tib3gubW9kdWxlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBQyxRQUFRLEVBQUMsTUFBTSxlQUFlLENBQUM7QUFDdkMsT0FBTyxFQUFDLFlBQVksRUFBQyxNQUFNLGlCQUFpQixDQUFDO0FBQzdDLE9BQU8sRUFBQyx5QkFBeUIsRUFBQyxNQUFNLCtCQUErQixDQUFDO0FBQ3hFLE9BQU8sRUFBQyxVQUFVLEVBQUMsTUFBTSx3QkFBd0IsQ0FBQztBQWNsRCxNQUFNLE9BQU8sc0JBQXNCOzs7WUFabEMsUUFBUSxTQUFDO2dCQUNOLE9BQU8sRUFBRTtvQkFDTCxZQUFZO29CQUNaLFVBQVU7aUJBQ2I7Z0JBQ0gsWUFBWSxFQUFFO29CQUNaLHlCQUF5QjtpQkFDMUI7Z0JBQ0QsT0FBTyxFQUFFO29CQUNQLHlCQUF5QjtpQkFDMUI7YUFDRiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7TmdNb2R1bGV9IGZyb20gXCJAYW5ndWxhci9jb3JlXCI7XHJcbmltcG9ydCB7Q29tbW9uTW9kdWxlfSBmcm9tIFwiQGFuZ3VsYXIvY29tbW9uXCI7XHJcbmltcG9ydCB7QW5pbWF0ZWRDaGVja2JveENvbXBvbmVudH0gZnJvbSBcIi4vYW5pbWF0ZWQtY2hlY2tib3guY29tcG9uZW50XCI7XHJcbmltcG9ydCB7UGlwZU1vZHVsZX0gZnJvbSBcIi4uLy4uL3BpcGUvcGlwZS5tb2R1bGVcIjtcclxuXHJcbkBOZ01vZHVsZSh7XHJcbiAgICBpbXBvcnRzOiBbXHJcbiAgICAgICAgQ29tbW9uTW9kdWxlLFxyXG4gICAgICAgIFBpcGVNb2R1bGVcclxuICAgIF0sXHJcbiAgZGVjbGFyYXRpb25zOiBbXHJcbiAgICBBbmltYXRlZENoZWNrYm94Q29tcG9uZW50XHJcbiAgXSxcclxuICBleHBvcnRzOiBbXHJcbiAgICBBbmltYXRlZENoZWNrYm94Q29tcG9uZW50XHJcbiAgXVxyXG59KVxyXG5leHBvcnQgY2xhc3MgQW5pbWF0ZWRDaGVja2JveE1vZHVsZSB7XHJcbn1cclxuIl19