nuxeo-development-framework 0.0.0-watch

package/esm2015/lib/components/vocabulary/translated-vocabulary-select/translated-vocabulary-select.component.js

@@ -0,0 +1,217 @@
+import { Component, EventEmitter, Input, Optional, Output, Self, ViewChild } from '@angular/core';
+import { NgSelectComponent } from '@ng-select/ng-select';
+import { Subject } from 'rxjs';
+import { map, takeUntil } from 'rxjs/operators';
+import * as i0 from "@angular/core";
+import * as i1 from "@ngx-translate/core";
+import * as i2 from "../../../core/services/translation/translation.service";
+import * as i3 from "../services/vocabulary-api.service";
+import * as i4 from "@angular/forms";
+import * as i5 from "@ng-select/ng-select";
+import * as i6 from "@angular/common";
+export class TranslatedVocabularySelectComponent {
+    constructor(translate, translationService, vocabularyApiServ, control) {
+        this.translate = translate;
+        this.translationService = translationService;
+        this.vocabularyApiServ = vocabularyApiServ;
+        this.control = control;
+        /** can select multiple */
+        this.multiple = false;
+        /** is searchable */
+        this.searchable = false;
+        /** should close on select */
+        this.closeOnSelect = true;
+        /** should hide selected items */
+        this.hideSelectedItems = false;
+        /** is disabled */
+        this.disabled = false;
+        /** should show clear action */
+        this.clear = true;
+        /** flage to indicate if call api without filter or wait untile there is filter and then call api*/
+        this.useFilter = true;
+        /** Should show loading indicator */
+        this.loading = false;
+        this.mapingResponse = false;
+        this.params = {};
+        this.getByDirectorySuggestion = true;
+        /** event emitted with selected items */
+        this.onSelectItems = new EventEmitter();
+        this.selection = [];
+        this.data = [];
+        this.buffer = [];
+        this.bufferSize = 50;
+        this.numberOfItemsFromEndBeforeFetchingMore = 10;
+        this._unsubscribeAll = new Subject();
+        this.isArabic = false;
+        this.propagateChange = () => { };
+        this.validateFn = () => { };
+        this.onTouched = () => {
+            /*Empty*/
+        };
+        if (this.control) {
+            this.control.valueAccessor = this;
+        }
+    }
+    get invalid() {
+        return this.control ? this.control.invalid : false;
+    }
+    get showError() {
+        if (!this.control) {
+            return false;
+        }
+        const { dirty, touched } = this.control;
+        return this.invalid ? dirty || touched : false;
+    }
+    ngOnInit() {
+        this.translationService.isArabic
+            .pipe(takeUntil(this._unsubscribeAll))
+            .subscribe((res) => {
+            this.isArabic = res;
+            this.bindLabel = this.isArabic
+                ? this.arbBindLabel
+                : this.engBindLabel;
+        });
+        if (!this.useFilter) {
+            this.getlistOfVocabulary();
+        }
+    }
+    getlistOfVocabulary() {
+        this.loading = true;
+        if (this.vocbularyId) {
+            const observable = (this.getByDirectorySuggestion) ? this.vocabularyApiServ
+                .getVocabularyListByFilters(this.vocbularyId, this.params, this.filter).pipe(map(res => {
+                let tempArr = [];
+                if (this.mapingResponse) {
+                    res.forEach((element) => {
+                        tempArr.push({
+                            label_ar: element.displayLabel,
+                            label_en: element.displayLabel,
+                        });
+                    });
+                }
+                else {
+                    tempArr = res;
+                }
+                return tempArr;
+            }))
+                : this.vocabularyApiServ.getVocListByVocName(this.vocbularyId).pipe(map((res) => {
+                    return res.entries.map(elem => elem.properties);
+                }));
+            observable.subscribe((res) => {
+                this.data = res;
+                this.buffer = (this.data || []).slice(0, this.bufferSize);
+                this.loading = false;
+            }, err => {
+                this.loading = false;
+            });
+        }
+    }
+    ngOnChanges(changes) {
+        if (this.useFilter && changes.filter && changes.filter.currentValue) {
+            this.getlistOfVocabulary();
+        }
+    }
+    emitSelection(event) {
+        this.propagateChange(this.selection);
+        this.onSelectItems.emit(event);
+    }
+    onScrollToEnd() {
+        this.fetchMore();
+    }
+    fetchMore() {
+        this.loading = true;
+        const len = this.buffer.length;
+        const more = this.data.slice(len, this.bufferSize + len);
+        this.buffer = this.data.concat(more);
+        this.loading = false;
+    }
+    writeValue(value) {
+        if (value) {
+            this.selection = value;
+        }
+        else {
+            //added to allow reseting ui when resetting form
+            this.selection = [];
+        }
+    }
+    registerOnChange(fn) {
+        this.propagateChange = fn;
+    }
+    registerOnTouched(fn) {
+        this.onTouched = fn;
+    }
+    validate(c) {
+        return this.validateFn(c);
+    }
+    isRequired() {
+        if (!this.control || !this.control.control.validator) {
+            return false;
+        }
+        const validator = this.control.control.validator({});
+        return validator && validator.required;
+    }
+    hasErrors() {
+        return this.showError;
+    }
+    reset() {
+        this.ngSelectComponent.handleClearClick();
+    }
+    ngOnDestroy() {
+        this._unsubscribeAll.next();
+        this._unsubscribeAll.complete();
+    }
+}
+TranslatedVocabularySelectComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: TranslatedVocabularySelectComponent, deps: [{ token: i1.TranslateService }, { token: i2.TranslationService }, { token: i3.VocabularyApiService }, { token: i4.NgControl, optional: true, self: true }], target: i0.ɵɵFactoryTarget.Component });
+TranslatedVocabularySelectComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "12.2.17", type: TranslatedVocabularySelectComponent, selector: "app-translated-vocabulary-select", inputs: { label: "label", bindValue: "bindValue", arbBindLabel: "arbBindLabel", engBindLabel: "engBindLabel", placeholder: "placeholder", multiple: "multiple", searchable: "searchable", closeOnSelect: "closeOnSelect", hideSelectedItems: "hideSelectedItems", disabled: "disabled", clear: "clear", filter: "filter", useFilter: "useFilter", vocbularyId: "vocbularyId", mapingResponse: "mapingResponse", params: "params", getByDirectorySuggestion: "getByDirectorySuggestion" }, outputs: { onSelectItems: "onSelectItems" }, viewQueries: [{ propertyName: "ngSelectComponent", first: true, predicate: NgSelectComponent, descendants: true }], usesOnChanges: true, ngImport: i0, template: "<div class=\"translated-vocbulary-wrapper\" [ngClass]=\"{'rtl-translated-vocbulary-wrapper' : isArabic === true}\">\r\n        <div class=\"vocabulary-title text-base font-bold text-accent-900 mb-0\">\r\n            {{label | translate}}\r\n            <span *ngIf=\"isRequired()\" class=\"required-flage\">*</span>\r\n        </div>\r\n        <ng-select\r\n            [bindLabel]=\"bindLabel\"\r\n            [bindValue]=\"bindValue\"\r\n            [placeholder]=\"placeholder\"\r\n            [multiple]=\"multiple\"\r\n            [clearable]=\"clear\"\r\n            [searchable]=\"searchable\"\r\n            [closeOnSelect]=\"closeOnSelect\"\r\n            [hideSelected]=\"hideSelectedItems\"\r\n            [loading]=\"loading\"\r\n            (scrollToEnd)=\"onScrollToEnd()\"\r\n            (change)=\"emitSelection($event)\"\r\n            [disabled]=\"disabled\"\r\n            [(ngModel)]=\"selection\"\r\n        >\r\n        <ng-option *ngFor=\"let option of buffer\" [value]=\"option[bindValue]\">{{isArabic ? option[bindLabel] : option[bindLabel]}}</ng-option>\r\n        </ng-select>\r\n</div>\r\n", styles: [".translated-vocbulary-wrapper .vocabulary-title .required-flage{color:#ef4444}.rtl-translated-vocbulary-wrapper{direction:rtl}\n"], components: [{ type: i5.NgSelectComponent, selector: "ng-select", inputs: ["markFirst", "dropdownPosition", "loading", "closeOnSelect", "hideSelected", "selectOnTab", "bufferAmount", "selectableGroup", "selectableGroupAsModel", "searchFn", "trackByFn", "clearOnBackspace", "labelForId", "inputAttrs", "readonly", "searchWhileComposing", "minTermLength", "editableSearchTerm", "keyDownFn", "multiple", "addTag", "searchable", "clearable", "isOpen", "items", "compareWith", "clearSearchOnAdd", "bindLabel", "placeholder", "notFoundText", "typeToSearchText", "addTagText", "loadingText", "clearAllText", "virtualScroll", "openOnEnter", "appendTo", "bindValue", "appearance", "maxSelectedItems", "groupBy", "groupValue", "tabIndex", "typeahead"], outputs: ["blur", "focus", "change", "open", "close", "search", "clear", "add", "remove", "scroll", "scrollToEnd"] }, { type: i5.ɵr, selector: "ng-option", inputs: ["disabled", "value"] }], directives: [{ type: i6.NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }, { type: i6.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { type: i4.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { type: i4.NgModel, selector: "[ngModel]:not([formControlName]):not([formControl])", inputs: ["name", "disabled", "ngModel", "ngModelOptions"], outputs: ["ngModelChange"], exportAs: ["ngModel"] }, { type: i6.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }], pipes: { "translate": i1.TranslatePipe } });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: TranslatedVocabularySelectComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'app-translated-vocabulary-select',
+                    templateUrl: './translated-vocabulary-select.component.html',
+                    styleUrls: ['./translated-vocabulary-select.component.scss'],
+                }]
+        }], ctorParameters: function () { return [{ type: i1.TranslateService }, { type: i2.TranslationService }, { type: i3.VocabularyApiService }, { type: i4.NgControl, decorators: [{
+                    type: Self
+                }, {
+                    type: Optional
+                }] }]; }, propDecorators: { ngSelectComponent: [{
+                type: ViewChild,
+                args: [NgSelectComponent]
+            }], label: [{
+                type: Input
+            }], bindValue: [{
+                type: Input
+            }], arbBindLabel: [{
+                type: Input
+            }], engBindLabel: [{
+                type: Input
+            }], placeholder: [{
+                type: Input
+            }], multiple: [{
+                type: Input
+            }], searchable: [{
+                type: Input
+            }], closeOnSelect: [{
+                type: Input
+            }], hideSelectedItems: [{
+                type: Input
+            }], disabled: [{
+                type: Input
+            }], clear: [{
+                type: Input
+            }], filter: [{
+                type: Input
+            }], useFilter: [{
+                type: Input
+            }], vocbularyId: [{
+                type: Input
+            }], mapingResponse: [{
+                type: Input
+            }], params: [{
+                type: Input
+            }], getByDirectorySuggestion: [{
+                type: Input
+            }], onSelectItems: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"translated-vocabulary-select.component.js","sourceRoot":"","sources":["../../../../../../../projects/nuxeo-development-framework/src/lib/components/vocabulary/translated-vocabulary-select/translated-vocabulary-select.component.ts","../../../../../../../projects/nuxeo-development-framework/src/lib/components/vocabulary/translated-vocabulary-select/translated-vocabulary-select.component.html"],"names":[],"mappings":"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","sourcesContent":["import { Component, EventEmitter, Input, OnChanges, OnDestroy, Optional, Output, Self, ViewChild } from '@angular/core';\r\nimport { AbstractControl, ControlValueAccessor, FormControl, NgControl } from '@angular/forms';\r\nimport { NgSelectComponent } from '@ng-select/ng-select';\r\nimport { TranslateService } from '@ngx-translate/core';\r\nimport { Observable, Subject } from 'rxjs';\r\nimport { map, takeUntil } from 'rxjs/operators';\r\n\r\nimport { TranslationService } from '../../../core/services/translation/translation.service';\r\nimport { VocabularyApiService } from '../services/vocabulary-api.service';\r\nimport { filter } from 'lodash';\r\n\r\n@Component({\r\n    selector: 'app-translated-vocabulary-select',\r\n    templateUrl: './translated-vocabulary-select.component.html',\r\n    styleUrls: ['./translated-vocabulary-select.component.scss'],\r\n})\r\nexport class TranslatedVocabularySelectComponent\r\n    implements OnChanges, OnDestroy, ControlValueAccessor {\r\n    @ViewChild(NgSelectComponent) ngSelectComponent: NgSelectComponent;\r\n    /** Field Label */\r\n    @Input() label: string;\r\n    /** Property name to bind value to */\r\n    @Input() bindValue;\r\n    /** Property name to bind label to */\r\n    @Input() arbBindLabel;\r\n    /** Property name to bind label to */\r\n    @Input() engBindLabel;\r\n    /** Items array */\r\n    // @Input() data;\r\n    /** Placeholder string */\r\n    @Input() placeholder;\r\n    /** can select multiple */\r\n    @Input() multiple = false;\r\n    /** is searchable */\r\n    @Input() searchable = false;\r\n    /** should close on select */\r\n    @Input() closeOnSelect = true;\r\n    /** should hide selected items */\r\n    @Input() hideSelectedItems = false;\r\n    /** is disabled */\r\n    @Input() disabled = false;\r\n    /** should show clear action */\r\n    @Input() clear = true;\r\n    /** filter to be sent from out side to send it in api to filter the vocabulary items */\r\n    @Input() filter;\r\n    /** flage to indicate if call api without filter or wait untile there is filter and then call api*/\r\n    @Input() useFilter = true;\r\n\r\n    /** is vocabulary select */\r\n    // @Input() voc = false;\r\n    /** vocabulary id for translation (for vocabulary select only) */\r\n    @Input() vocbularyId: string;\r\n    /** Should show loading indicator */\r\n    loading = false;\r\n    @Input() mapingResponse = false;\r\n\r\n    @Input() params = {};\r\n    @Input() getByDirectorySuggestion: boolean = true;\r\n    /** event emitted with selected items */\r\n    @Output() onSelectItems = new EventEmitter();\r\n\r\n    bindLabel;\r\n    selection = [];\r\n    data = [];\r\n    buffer = [];\r\n    bufferSize = 50;\r\n    numberOfItemsFromEndBeforeFetchingMore = 10;\r\n    private _unsubscribeAll: Subject<any> = new Subject<any>();\r\n    isArabic = false;\r\n    propagateChange: any = () => { };\r\n    validateFn: any = () => { };\r\n\r\n    public onTouched: any = () => {\r\n        /*Empty*/\r\n    };\r\n    public get invalid(): boolean {\r\n        return this.control ? this.control.invalid : false;\r\n    }\r\n\r\n    public get showError(): boolean {\r\n        if (!this.control) {\r\n            return false;\r\n        }\r\n\r\n        const { dirty, touched } = this.control;\r\n\r\n        return this.invalid ? dirty || touched : false;\r\n    }\r\n    constructor(\r\n        public translate: TranslateService,\r\n        private translationService: TranslationService,\r\n        private vocabularyApiServ: VocabularyApiService,\r\n        @Self() @Optional() public control: NgControl\r\n    ) {\r\n        if (this.control) {\r\n            this.control.valueAccessor = this;\r\n        }\r\n    }\r\n\r\n    ngOnInit() {\r\n        this.translationService.isArabic\r\n            .pipe(takeUntil(this._unsubscribeAll))\r\n            .subscribe((res) => {\r\n                this.isArabic = res;\r\n                this.bindLabel = this.isArabic\r\n                    ? this.arbBindLabel\r\n                    : this.engBindLabel;\r\n            });\r\n        if (!this.useFilter) {\r\n            this.getlistOfVocabulary();\r\n        }\r\n    }\r\n\r\n    getlistOfVocabulary() {\r\n        this.loading = true;\r\n        if (this.vocbularyId) {\r\n            const observable: Observable<any> = (this.getByDirectorySuggestion) ? this.vocabularyApiServ\r\n                .getVocabularyListByFilters(this.vocbularyId, this.params, this.filter).pipe(map(res => {\r\n                    let tempArr = [];\r\n                    if (this.mapingResponse) {\r\n                        res.forEach((element) => {\r\n                            tempArr.push({\r\n                                label_ar: element.displayLabel,\r\n                                label_en: element.displayLabel,\r\n                            });\r\n                        });\r\n                    } else {\r\n                        tempArr = res;\r\n                    }\r\n                    return tempArr;\r\n                }))\r\n                : this.vocabularyApiServ.getVocListByVocName(this.vocbularyId).pipe(map((res: { entries: Array<Record<string, any>> }) => {\r\n                    return res.entries.map(elem => elem.properties);\r\n                }))\r\n            observable.subscribe((res) => {\r\n                this.data = res;\r\n                this.buffer = (this.data || []).slice(0, this.bufferSize);\r\n                this.loading = false;\r\n            }, err => {\r\n                this.loading = false;\r\n            });\r\n        }\r\n    }\r\n\r\n    ngOnChanges(changes): void {\r\n        if (this.useFilter && changes.filter && changes.filter.currentValue) {\r\n            this.getlistOfVocabulary();\r\n        }\r\n    }\r\n\r\n    emitSelection(event) {\r\n        this.propagateChange(this.selection);\r\n        this.onSelectItems.emit(event);\r\n    }\r\n\r\n    onScrollToEnd() {\r\n        this.fetchMore();\r\n    }\r\n\r\n    private fetchMore() {\r\n        this.loading = true;\r\n        const len = this.buffer.length;\r\n        const more = this.data.slice(len, this.bufferSize + len);\r\n        this.buffer = this.data.concat(more);\r\n        this.loading = false;\r\n    }\r\n\r\n    writeValue(value) {\r\n        if (value) {\r\n            this.selection = value;\r\n        } else {\r\n            //added to allow reseting ui when resetting form\r\n            this.selection = [];\r\n        }\r\n    }\r\n\r\n    registerOnChange(fn) {\r\n        this.propagateChange = fn;\r\n    }\r\n\r\n    registerOnTouched(fn: any) {\r\n        this.onTouched = fn;\r\n    }\r\n\r\n    validate(c: FormControl) {\r\n        return this.validateFn(c);\r\n    }\r\n\r\n    isRequired() {\r\n        if (!this.control || !this.control.control.validator) {\r\n            return false;\r\n        }\r\n\r\n        const validator = this.control.control.validator({} as AbstractControl);\r\n        return validator && validator.required;\r\n    }\r\n\r\n    hasErrors(): boolean {\r\n        return this.showError;\r\n    }\r\n    reset() {\r\n        this.ngSelectComponent.handleClearClick();\r\n    }\r\n\r\n    ngOnDestroy(): void {\r\n        this._unsubscribeAll.next();\r\n        this._unsubscribeAll.complete();\r\n    }\r\n    // onSearch =  (term: string, item: any) => {\r\n    //   let key = '';\r\n    //   this.voc ? key =  \"vocabulary.\" + this.vocId + \".\" + item.id : key = item.label;\r\n    //   let value = this.translate.instant(key);\r\n    //     if(value){\r\n    //       return value.toLowerCase().includes(term);\r\n    //     }else{\r\n    //       return item.label.includes(term);\r\n    //     }\r\n\r\n    // }\r\n}\r\n","<div class=\"translated-vocbulary-wrapper\" [ngClass]=\"{'rtl-translated-vocbulary-wrapper' : isArabic === true}\">\r\n        <div class=\"vocabulary-title text-base font-bold text-accent-900 mb-0\">\r\n            {{label | translate}}\r\n            <span *ngIf=\"isRequired()\" class=\"required-flage\">*</span>\r\n        </div>\r\n        <ng-select\r\n            [bindLabel]=\"bindLabel\"\r\n            [bindValue]=\"bindValue\"\r\n            [placeholder]=\"placeholder\"\r\n            [multiple]=\"multiple\"\r\n            [clearable]=\"clear\"\r\n            [searchable]=\"searchable\"\r\n            [closeOnSelect]=\"closeOnSelect\"\r\n            [hideSelected]=\"hideSelectedItems\"\r\n            [loading]=\"loading\"\r\n            (scrollToEnd)=\"onScrollToEnd()\"\r\n            (change)=\"emitSelection($event)\"\r\n            [disabled]=\"disabled\"\r\n            [(ngModel)]=\"selection\"\r\n        >\r\n        <ng-option *ngFor=\"let option of buffer\" [value]=\"option[bindValue]\">{{isArabic ? option[bindLabel] : option[bindLabel]}}</ng-option>\r\n        </ng-select>\r\n</div>\r\n"]}

package/esm2015/lib/components/vocabulary/vocabulary/vocabulary.component.js

@@ -0,0 +1,106 @@
+import { Component, EventEmitter, forwardRef, Input, Output } from '@angular/core';
+import { NG_VALUE_ACCESSOR } from '@angular/forms';
+import * as i0 from "@angular/core";
+import * as i1 from "../services/vocabulary-api.service";
+import * as i2 from "../../dynamic-form/components/dynamic-form-selectitem/dynamic-form-selectitem.component";
+export class VocabularyComponent {
+    constructor(vocabularyApi) {
+        this.vocabularyApi = vocabularyApi;
+        this.data = [];
+        this.multiple = false;
+        this.searchable = true;
+        this.closeOnSelect = true;
+        this.hideSelectedItems = false;
+        this.isAsync = false;
+        this.attachSource = false;
+        this.hideLoaded = false;
+        this.vocabularyType = '';
+        this.onSelecting = new EventEmitter();
+        this.loading = false;
+        this.selection = [];
+        // function related to value accessor
+        this.propagateChange = () => { };
+        this.validateFn = () => { };
+        this.onTouched = () => { };
+    }
+    ngOnInit() {
+        if (this.vocabularyType) {
+            this.getLisOfOptions(this.vocabularyType);
+        }
+    }
+    getLisOfOptions(type) {
+        this.loading = true;
+        this.vocabularyApi.getVocabularyList(type).subscribe(res => {
+            this.loading = false;
+            this.data = res;
+        });
+    }
+    getSelecteditems(selectedItems) {
+        this.propagateChange(selectedItems);
+        this.onSelecting.emit(selectedItems);
+    }
+    writeValue(value) {
+        if (value) {
+            this.selection = value;
+        }
+    }
+    registerOnChange(fn) {
+        this.propagateChange = fn;
+    }
+    registerOnTouched(fn) {
+        this.onTouched = fn;
+    }
+    validate(c) {
+        return this.validateFn(c);
+    }
+}
+VocabularyComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: VocabularyComponent, deps: [{ token: i1.VocabularyApiService }], target: i0.ɵɵFactoryTarget.Component });
+VocabularyComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "12.2.17", type: VocabularyComponent, selector: "cts-vocabulary", inputs: { bindValue: "bindValue", bindLabel: "bindLabel", placeholder: "placeholder", multiple: "multiple", searchable: "searchable", closeOnSelect: "closeOnSelect", hideSelectedItems: "hideSelectedItems", isAsync: "isAsync", attachSource: "attachSource", source$: "source$", hideLoaded: "hideLoaded", vocabularyType: "vocabularyType" }, outputs: { onSelecting: "onSelecting" }, providers: [
+        {
+            provide: NG_VALUE_ACCESSOR,
+            useExisting: forwardRef(() => VocabularyComponent),
+            multi: true
+        }
+    ], ngImport: i0, template: "<app-dynamic-form-selectitem\r\n  [data]=\"data\"\r\n  [bindLabel]=\"bindLabel\"\r\n  [bindValue]=\"bindValue\"\r\n  [placeholder]=\"placeholder\"\r\n  [multiple]=\"multiple\"\r\n  [searchable]=\"searchable\"\r\n  [closeOnSelect]=\"closeOnSelect\"\r\n  [hideSelectedItems]=\"hideSelectedItems\"\r\n  [loading]=\"loading\"\r\n  (onSelectItems)=\"getSelecteditems($event)\"\r\n></app-dynamic-form-selectitem>\r\n", styles: [""], components: [{ type: i2.DynamicFormSelectItemComponent, selector: "app-dynamic-form-selectitem", inputs: ["label", "bindValue", "bindLabel", "data", "placeholder", "multiple", "searchable", "closeOnSelect", "hideSelectedItems", "disabled", "clear", "voc", "vocId", "loading"], outputs: ["onSelectItems"] }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: VocabularyComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'cts-vocabulary',
+                    templateUrl: './vocabulary.component.html',
+                    styleUrls: ['./vocabulary.component.scss'],
+                    providers: [
+                        {
+                            provide: NG_VALUE_ACCESSOR,
+                            useExisting: forwardRef(() => VocabularyComponent),
+                            multi: true
+                        }
+                    ]
+                }]
+        }], ctorParameters: function () { return [{ type: i1.VocabularyApiService }]; }, propDecorators: { bindValue: [{
+                type: Input
+            }], bindLabel: [{
+                type: Input
+            }], placeholder: [{
+                type: Input
+            }], multiple: [{
+                type: Input
+            }], searchable: [{
+                type: Input
+            }], closeOnSelect: [{
+                type: Input
+            }], hideSelectedItems: [{
+                type: Input
+            }], isAsync: [{
+                type: Input
+            }], attachSource: [{
+                type: Input
+            }], source$: [{
+                type: Input
+            }], hideLoaded: [{
+                type: Input
+            }], vocabularyType: [{
+                type: Input
+            }], onSelecting: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/components/vocabulary/vocabulary.module.js

@@ -0,0 +1,41 @@
+import { NgModule } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { VocabularyComponent } from './vocabulary/vocabulary.component';
+import { SelectModule } from '../select/select.module';
+import { DynamicFormModule } from '../dynamic-form/dynamic-form.module';
+import { TranslatedVocabularySelectComponent } from './translated-vocabulary-select/translated-vocabulary-select.component';
+import { FormsModule } from '@angular/forms';
+import * as i0 from "@angular/core";
+// import { CoreModule } from '../../core/core.module';
+/** @ignore */
+export class VocabularyModule {
+}
+VocabularyModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: VocabularyModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+VocabularyModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: VocabularyModule, declarations: [VocabularyComponent, TranslatedVocabularySelectComponent], imports: [CommonModule,
+        SelectModule,
+        DynamicFormModule,
+        FormsModule], exports: [VocabularyComponent,
+        TranslatedVocabularySelectComponent] });
+VocabularyModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: VocabularyModule, imports: [[
+            CommonModule,
+            SelectModule,
+            DynamicFormModule,
+            FormsModule,
+        ]] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: VocabularyModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [VocabularyComponent, TranslatedVocabularySelectComponent],
+                    imports: [
+                        CommonModule,
+                        SelectModule,
+                        DynamicFormModule,
+                        FormsModule,
+                    ],
+                    exports: [
+                        VocabularyComponent,
+                        TranslatedVocabularySelectComponent
+                    ]
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/configuration/app-config.service.js

@@ -0,0 +1,31 @@
+import { Injectable } from "@angular/core";
+import { combineLatest, iif, of, ReplaySubject } from "rxjs";
+import { EnvManager } from '../core/env';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+export class AppConfigService {
+    constructor(http) {
+        this.http = http;
+        this.configLoaded = new ReplaySubject(1);
+    }
+    // load my config file from my assets
+    load() {
+        iif(() => !!EnvManager.conditons, of([EnvManager.configuration, EnvManager.conditons]), combineLatest([
+            this.http.get('assets/configs/configuration.json'),
+            this.http.get('assets/configs/conditions.json')
+        ])).subscribe((res) => {
+            this.conditons = res[1];
+            this.myConfiguration = res[0];
+            this.configLoaded.next(true);
+        });
+    }
+}
+AppConfigService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: AppConfigService, deps: [{ token: i1.HttpClient }], target: i0.ɵɵFactoryTarget.Injectable });
+AppConfigService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: AppConfigService, providedIn: "root" });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: AppConfigService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: "root",
+                }]
+        }], ctorParameters: function () { return [{ type: i1.HttpClient }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/configuration/helpers/app-initializer.js

@@ -0,0 +1,4 @@
+export function appInitializer(appConfigService) {
+    return () => appConfigService.load();
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXBwLWluaXRpYWxpemVyLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvbnV4ZW8tZGV2ZWxvcG1lbnQtZnJhbWV3b3JrL3NyYy9saWIvY29uZmlndXJhdGlvbi9oZWxwZXJzL2FwcC1pbml0aWFsaXplci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFFQSxNQUFNLFVBQVUsY0FBYyxDQUFDLGdCQUFtQztJQUNoRSxPQUFPLEdBQUcsRUFBRSxDQUFDLGdCQUFnQixDQUFDLElBQUksRUFBRSxDQUFDO0FBQ3ZDLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBBcHBDb25maWdTZXJ2aWNlIH0gZnJvbSAnLi4vYXBwLWNvbmZpZy5zZXJ2aWNlJztcclxuXHJcbmV4cG9ydCBmdW5jdGlvbiBhcHBJbml0aWFsaXplcihhcHBDb25maWdTZXJ2aWNlIDogQXBwQ29uZmlnU2VydmljZSkgOiBGdW5jdGlvbiB7XHJcbiAgcmV0dXJuICgpID0+IGFwcENvbmZpZ1NlcnZpY2UubG9hZCgpO1xyXG59XHJcbiJdfQ==

package/esm2015/lib/core/adapters/adapter.service.js

@@ -0,0 +1,50 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "../utilities/utility.service";
+export class AdapterService {
+    constructor(utiliService) {
+        this.utiliService = utiliService;
+    }
+    filterNullValues(formValue) {
+        const filtered = {};
+        for (let key in formValue) {
+            if (formValue[key] !== null) {
+                filtered[key] =
+                    !Array.isArray(formValue[key]) && typeof formValue[key] === 'object'
+                        ? Object.assign({}, this.filterNullValues(formValue[key])) : formValue[key];
+            }
+        }
+        return filtered;
+    }
+    adaptIn(item, fieldsobj) {
+        const fields = this.utiliService.objectFlip(fieldsobj);
+        const properties = Object.assign({}, item.properties);
+        Object.keys(fields).forEach((key) => {
+            properties[fields[key]] = item.properties[key];
+            delete properties[key];
+        });
+        item.properties = properties;
+        return item;
+    }
+    adaptOut(item, fieldsobj) {
+        const fields = fieldsobj;
+        let properties = Object.assign({}, item);
+        Object.keys(fields).forEach((key) => {
+            if (key) {
+                properties[fields[key]] = item[key];
+                delete properties[key];
+            }
+        });
+        properties = Object.assign({}, this.filterNullValues(properties));
+        return properties;
+    }
+}
+AdapterService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: AdapterService, deps: [{ token: i1.UtilityService }], target: i0.ɵɵFactoryTarget.Injectable });
+AdapterService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: AdapterService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: AdapterService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return [{ type: i1.UtilityService }]; } });
+//# sourceMappingURL=data:application/json;base64,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