zek 15.2.1 → 16.0.0

package/README.md

@@ -1,6 +1,6 @@
 # Zek
 
-This library was generated with [Angular CLI](https://github.com/angular/angular-cli) version 15.2.0.
+This library was generated with [Angular CLI](https://github.com/angular/angular-cli) version 16.0.0.
 
 ## Code scaffolding
 

package/{esm2020 → esm2022}/lib/components/args.mjs

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

package/esm2022/lib/components/base.component.mjs

@@ -0,0 +1,97 @@
+import { Input, Directive } from '@angular/core';
+import { PRIMARY_OUTLET } from '@angular/router';
+import { AppBaseModule } from '../zek.module';
+import { PrintType } from '../models/print.model';
+import { WebApiClient } from '../services';
+import { CoreComponent } from './core.component';
+import { Convert, UrlHelper } from '../utils';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/router";
+class BaseComponent extends CoreComponent {
+    constructor(route, router) {
+        super();
+        this.route = route;
+        this.router = router;
+        this._readOnly = false;
+        this._url = null;
+    }
+    get readOnly() {
+        return this._readOnly;
+    }
+    set readOnly(v) {
+        this._readOnly = Convert.toBooleanProperty(v);
+    }
+    get url() {
+        if (!this._url)
+            this._url = UrlHelper.getNoParam(this.router.url);
+        return this._url;
+    }
+    getParam(name) {
+        return this.route.snapshot.paramMap.get(name);
+    }
+    getQueryParam(name) {
+        return this.route.snapshot.queryParamMap.get(name);
+    }
+    navigateReturnUrl() {
+        const returnUrl = this.getQueryParam('returnUrl') || this.getParam('returnUrl');
+        if (returnUrl) {
+            let urlTree = this.router.parseUrl(returnUrl);
+            const urlWithoutParams = urlTree.root.children[PRIMARY_OUTLET].segments.map(it => it.path).join('/');
+            this.router.navigate([urlWithoutParams, urlTree.root.children[PRIMARY_OUTLET].segments[urlTree.root.children[PRIMARY_OUTLET].segments.length - 1].parameters]);
+            return;
+        }
+        this.router.navigate([this.router.url.substring(0, this.router.url.lastIndexOf('/'))]);
+    }
+    cancel() {
+        this.navigateReturnUrl();
+    }
+    downloadFile(blob, fileName, type) {
+        if (!blob)
+            return;
+        const nav = window.navigator;
+        if (nav && nav.msSaveOrOpenBlob) {
+            nav.msSaveOrOpenBlob(blob, fileName);
+        }
+        else {
+            let a = document.createElement('a');
+            a.href = URL.createObjectURL(blob);
+            a.download = fileName;
+            document.body.appendChild(a);
+            a.click();
+            document.body.removeChild(a);
+        }
+    }
+    print(id, printType) {
+        const split = this.url.split('/');
+        if (split.length < 2) {
+            return;
+        }
+        const template = split[1];
+        let api = AppBaseModule.injector.get(WebApiClient);
+        let actionName;
+        switch (printType) {
+            case PrintType.Pdf:
+                actionName = 'PrintPdfIdLink';
+                break;
+            default:
+                actionName = 'ShowIdLink';
+                break;
+        }
+        api.getString(`api/Reports/${actionName}`, { template, id }).subscribe(url => {
+            if (url) {
+                window.open(url, '_blank');
+            }
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.1", ngImport: i0, type: BaseComponent, deps: [{ token: i1.ActivatedRoute }, { token: i1.Router }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.0.1", type: BaseComponent, inputs: { readOnly: "readOnly", model: "model" }, usesInheritance: true, ngImport: i0 }); }
+}
+export { BaseComponent };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.1", ngImport: i0, type: BaseComponent, decorators: [{
+            type: Directive
+        }], ctorParameters: function () { return [{ type: i1.ActivatedRoute }, { type: i1.Router }]; }, propDecorators: { readOnly: [{
+                type: Input
+            }], model: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"base.component.js","sourceRoot":"","sources":["../../../../../projects/zek/src/lib/components/base.component.ts"],"names":[],"mappings":"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","sourcesContent":["import { Input, Directive, Type } from '@angular/core';\r\nimport { ActivatedRoute, Router, PRIMARY_OUTLET } from '@angular/router';\r\nimport { AppBaseModule } from '../zek.module';\r\n\r\nimport { PrintType } from '../models/print.model';\r\nimport { WebApiClient } from '../services';\r\nimport { CoreComponent } from './core.component';\r\nimport { BooleanInput } from './types';\r\nimport { Convert, UrlHelper } from '../utils';\r\n\r\n@Directive()\r\nexport class BaseComponent<TModel = any> extends CoreComponent {\r\n    constructor(\r\n        protected readonly route: ActivatedRoute,\r\n        protected readonly router: Router\r\n    ) {\r\n        super();\r\n    }\r\n\r\n\r\n    private _readOnly = false;\r\n    @Input()\r\n    get readOnly() {\r\n        return this._readOnly;\r\n    }\r\n    set readOnly(v: BooleanInput) {\r\n        this._readOnly = Convert.toBooleanProperty(v);\r\n    }\r\n\r\n    private _url: string | null = null;\r\n    protected get url(): string {\r\n        if (!this._url)\r\n            this._url = UrlHelper.getNoParam(this.router.url);\r\n        return this._url;\r\n    }\r\n\r\n    @Input() model?: TModel | null;\r\n\r\n\r\n\r\n    protected getParam(name: string) {\r\n        return this.route.snapshot.paramMap.get(name);\r\n    }\r\n    protected getQueryParam(name: string) {\r\n        return this.route.snapshot.queryParamMap.get(name);\r\n    }\r\n\r\n\r\n    protected navigateReturnUrl() {\r\n        const returnUrl = this.getQueryParam('returnUrl') || this.getParam('returnUrl');\r\n        if (returnUrl) {\r\n            let urlTree = this.router.parseUrl(returnUrl);\r\n            const urlWithoutParams = urlTree.root.children[PRIMARY_OUTLET].segments.map(it => it.path).join('/')\r\n            this.router.navigate([urlWithoutParams, urlTree.root.children[PRIMARY_OUTLET].segments[urlTree.root.children[PRIMARY_OUTLET].segments.length - 1].parameters]);\r\n            return;\r\n        }\r\n\r\n        this.router.navigate([this.router.url.substring(0, this.router.url.lastIndexOf('/'))]);\r\n    }\r\n\r\n\r\n    cancel() {\r\n        this.navigateReturnUrl();\r\n    }\r\n\r\n    downloadFile(blob: Blob | null, fileName: string, type: string) {\r\n        if (!blob) return;\r\n\r\n        const nav = (window.navigator as any);\r\n        if (nav && nav.msSaveOrOpenBlob) {\r\n            nav.msSaveOrOpenBlob(blob, fileName);\r\n        } else {\r\n            let a = document.createElement('a');\r\n            a.href = URL.createObjectURL(blob);\r\n            a.download = fileName;\r\n            document.body.appendChild(a);\r\n            a.click();\r\n            document.body.removeChild(a);\r\n        }\r\n    }\r\n    print(id?: number | null, printType?: PrintType) {\r\n        const split = this.url.split('/');\r\n        if (split.length < 2) {\r\n            return;\r\n        }\r\n        const template = split[1];\r\n        let api = AppBaseModule.injector.get<WebApiClient>(WebApiClient as Type<WebApiClient>);\r\n\r\n        let actionName: string;\r\n\r\n\r\n        switch (printType) {\r\n            case PrintType.Pdf:\r\n                actionName = 'PrintPdfIdLink';\r\n                break;\r\n\r\n            default:\r\n                actionName = 'ShowIdLink'\r\n                break;\r\n        }\r\n        api.getString(`api/Reports/${actionName}`, { template, id }).subscribe(url => {\r\n            if (url) {\r\n                window.open(url, '_blank');\r\n            }\r\n        });\r\n    }\r\n}\r\n"]}

package/esm2022/lib/components/core-ui.component.mjs

@@ -0,0 +1,195 @@
+import { Directive, EventEmitter, Input, Output } from "@angular/core";
+import { Convert } from "../utils";
+import { CoreComponent } from "./core.component";
+import * as i0 from "@angular/core";
+let uniqueId = 0;
+class CoreUiComponent extends CoreComponent {
+    constructor(_renderer, _elementRef
+    //private _changeDetector: ChangeDetectorRef
+    ) {
+        super();
+        this._renderer = _renderer;
+        this._elementRef = _elementRef;
+        /** The method to be called in order to update ngModel */
+        this._onChange = () => { };
+        /**
+         * onTouch function registered via registerOnTouch (ControlValueAccessor).
+         * @docs-private
+         */
+        this._onTouched = () => { };
+        this.change = new EventEmitter();
+        this.changing = new EventEmitter();
+        this._name = `zek-${++uniqueId}`;
+        this._isInitialized = false;
+        this._value = null;
+        this._readonly = false;
+        this._disabled = false;
+        this._required = false;
+    }
+    /**
+   * Helper method that sets a property on a target element using the current Renderer
+   * implementation.
+   * @nodoc
+   */
+    setProperty(key, value) {
+        this._renderer.setProperty(this._elementRef.nativeElement, key, value);
+    }
+    get name() {
+        return this._name;
+    }
+    set name(value) {
+        if (this._name !== value) {
+            this._name = value;
+            this.onNameChanged();
+        }
+    }
+    onNameChanged() { }
+    get isInitialized() {
+        return this._isInitialized;
+    }
+    get value() {
+        return this._value;
+    }
+    set value(newValue) {
+        if (this._value !== newValue) {
+            let cancelEventArgs = {
+                oldValue: this._value,
+                newValue: newValue
+            };
+            this.onValueChanging(cancelEventArgs);
+            if (cancelEventArgs.cancel === true)
+                return;
+            // Set this before proceeding to ensure no circular loop occurs with selection.
+            this._value = newValue;
+            this.onValueChanged();
+        }
+    }
+    onValueChanging(e) {
+        this.changing.emit(e);
+    }
+    onValueChanged() { }
+    /**
+     * Use this method for client side change
+     * @param newValue
+     */
+    setNgModel(newValue) {
+        if (!this.disabled) {
+            if (this._value !== newValue) {
+                this.value = newValue;
+                this._emitChangeEvent();
+                this._onChange(this._value); //write value to NgModel
+            }
+        }
+    }
+    /** Whether the component is disabled */
+    get readonly() {
+        return this._readonly;
+    }
+    set readonly(value) {
+        let v = Convert.toBooleanProperty(value);
+        if (this._readonly !== v) {
+            this._readonly = v;
+            this.onReadOnlyChanged();
+        }
+    }
+    onReadOnlyChanged() { }
+    /** Whether the component is disabled */
+    get disabled() {
+        return this._disabled;
+    }
+    set disabled(value) {
+        let v = Convert.toBooleanProperty(value);
+        if (this._disabled !== v) {
+            this._disabled = v;
+            this.onDisabledChanged();
+        }
+    }
+    onDisabledChanged() { }
+    /** Whether the component is required */
+    get required() {
+        return this._required;
+    }
+    set required(value) {
+        let v = Convert.toBooleanProperty(value);
+        if (this._required !== v) {
+            this._required = v;
+            this.onRequiredChanged();
+        }
+    }
+    onRequiredChanged() { }
+    _onInputInteraction(event) {
+        // We always have to stop propagation on the change event.
+        // Otherwise the change event, from the input element, will bubble up and
+        // emit its event object to the `change` output.
+        event.stopPropagation();
+        this.setNgModel(event.target.value);
+    }
+    /** Dispatch change event with current value. */
+    _emitChangeEvent() {
+        if (this._isInitialized) {
+            this.change.emit(this._value);
+        }
+    }
+    ngAfterContentInit() {
+        // Mark this component as initialized in AfterContentInit because the initial value can
+        // possibly be set by NgModel on component, and it is possible that the OnInit of the
+        // NgModel occurs *after* the OnInit of the component.
+        this._isInitialized = true;
+    }
+    /**
+     * Sets the model value. Implemented as part of ControlValueAccessor.
+     * (write from model to el.nativeElement)
+     * @param value
+     */
+    writeValue(value) {
+        this.value = value;
+        //this._changeDetector.markForCheck();
+        //this._renderer.setProperty(this._elementRef.nativeElement, 'value', value);
+    }
+    /**
+     * Registers a callback to be triggered when the model value changes.
+     * Implemented as part of ControlValueAccessor.
+     * @param fn Callback to be registered.
+     */
+    registerOnChange(fn) {
+        this._onChange = fn;
+    }
+    /**
+     * Registers a callback to be triggered when the control is touched.
+     * Implemented as part of ControlValueAccessor.
+     * @param fn Callback to be registered.
+     */
+    registerOnTouched(fn) {
+        this._onTouched = fn;
+    }
+    /**
+     * Sets the disabled state of the control. Implemented as a part of ControlValueAccessor.
+     * @param isDisabled Whether the control should be disabled.
+     */
+    setDisabledState(isDisabled) {
+        this.disabled = isDisabled;
+        //this._changeDetector.markForCheck();
+        //this._renderer.setProperty(this._elementRef.nativeElement, 'disabled', isDisabled);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.1", ngImport: i0, type: CoreUiComponent, deps: [{ token: i0.Renderer2 }, { token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.0.1", type: CoreUiComponent, inputs: { name: "name", value: "value", readonly: "readonly", disabled: "disabled", required: "required" }, outputs: { change: "change", changing: "changing" }, usesInheritance: true, ngImport: i0 }); }
+}
+export { CoreUiComponent };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.1", ngImport: i0, type: CoreUiComponent, decorators: [{
+            type: Directive
+        }], ctorParameters: function () { return [{ type: i0.Renderer2 }, { type: i0.ElementRef }]; }, propDecorators: { change: [{
+                type: Output
+            }], changing: [{
+                type: Output
+            }], name: [{
+                type: Input
+            }], value: [{
+                type: Input
+            }], readonly: [{
+                type: Input
+            }], disabled: [{
+                type: Input
+            }], required: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"core-ui.component.js","sourceRoot":"","sources":["../../../../../projects/zek/src/lib/components/core-ui.component.ts"],"names":[],"mappings":"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","sourcesContent":["import { AfterContentInit, ChangeDetectorRef, Directive, ElementRef, EventEmitter, Input, Output, Renderer2 } from \"@angular/core\";\r\nimport { ControlValueAccessor } from \"@angular/forms\";\r\nimport { Convert } from \"../utils\";\r\nimport { CancelArgs } from \"./args\";\r\nimport { CoreComponent } from \"./core.component\";\r\nimport { BooleanInput } from \"./types\";\r\n\r\nlet uniqueId = 0;\r\n\r\n@Directive()\r\nexport class CoreUiComponent extends CoreComponent\r\n    implements AfterContentInit, ControlValueAccessor {\r\n    constructor(\r\n        protected _renderer: Renderer2,\r\n        protected _elementRef: ElementRef\r\n        //private _changeDetector: ChangeDetectorRef\r\n    ) {\r\n        super();\r\n    }\r\n\r\n    /** The method to be called in order to update ngModel */\r\n    _onChange: (value: any) => void = () => { };\r\n\r\n    /**\r\n     * onTouch function registered via registerOnTouch (ControlValueAccessor).\r\n     * @docs-private\r\n     */\r\n    _onTouched: () => any = () => { };\r\n\r\n\r\n    /**\r\n   * Helper method that sets a property on a target element using the current Renderer\r\n   * implementation.\r\n   * @nodoc\r\n   */\r\n    protected setProperty(key: string, value: any): void {\r\n        this._renderer.setProperty(this._elementRef.nativeElement, key, value);\r\n    }\r\n\r\n    @Output() readonly change: EventEmitter<any> = new EventEmitter<any>();\r\n    @Output() readonly changing: EventEmitter<CancelArgs> = new EventEmitter<CancelArgs>();\r\n\r\n    private _name: string = `zek-${++uniqueId}`;\r\n    get name(): string {\r\n        return this._name;\r\n    }\r\n    @Input()\r\n    set name(value: string) {\r\n        if (this._name !== value) {\r\n            this._name = value;\r\n            this.onNameChanged();\r\n        }\r\n    }\r\n    onNameChanged() { }\r\n\r\n\r\n    private _isInitialized: boolean = false;\r\n    get isInitialized(): boolean {\r\n        return this._isInitialized;\r\n    }\r\n\r\n    protected _value: any = null;\r\n    get value(): any {\r\n        return this._value;\r\n    }\r\n    @Input()\r\n    set value(newValue: any) {\r\n        if (this._value !== newValue) {\r\n            let cancelEventArgs: CancelArgs = {\r\n                oldValue: this._value,\r\n                newValue: newValue\r\n            };\r\n\r\n            this.onValueChanging(cancelEventArgs);\r\n            if (cancelEventArgs.cancel === true)\r\n                return;\r\n\r\n            // Set this before proceeding to ensure no circular loop occurs with selection.\r\n            this._value = newValue;\r\n            this.onValueChanged();\r\n        }\r\n    }\r\n    onValueChanging(e: CancelArgs) {\r\n        this.changing.emit(e);\r\n    }\r\n    onValueChanged() { }\r\n\r\n    /**\r\n     * Use this method for client side change\r\n     * @param newValue \r\n     */\r\n    setNgModel(newValue: any) {\r\n        if (!this.disabled) {\r\n            if (this._value !== newValue) {\r\n                this.value = newValue;\r\n                this._emitChangeEvent();\r\n                this._onChange(this._value);//write value to NgModel\r\n            }\r\n        }\r\n    }\r\n\r\n    private _readonly: boolean = false;\r\n    /** Whether the component is disabled */\r\n    get readonly(): boolean {\r\n        return this._readonly;\r\n    }\r\n    @Input()\r\n    set readonly(value: BooleanInput) {\r\n        let v = Convert.toBooleanProperty(value);\r\n        if (this._readonly !== v) {\r\n            this._readonly = v;\r\n            this.onReadOnlyChanged();\r\n        }\r\n    }\r\n    onReadOnlyChanged() { }\r\n\r\n\r\n    private _disabled: boolean = false;\r\n    /** Whether the component is disabled */\r\n    get disabled(): boolean {\r\n        return this._disabled;\r\n    }\r\n    @Input()\r\n    set disabled(value: BooleanInput) {\r\n        let v = Convert.toBooleanProperty(value);\r\n        if (this._disabled !== v) {\r\n            this._disabled = v;\r\n            this.onDisabledChanged();\r\n        }\r\n    }\r\n    onDisabledChanged() { }\r\n\r\n\r\n    private _required: boolean = false;\r\n    /** Whether the component is required */\r\n    get required(): boolean {\r\n        return this._required;\r\n    }\r\n    @Input()\r\n    set required(value: BooleanInput) {\r\n        let v = Convert.toBooleanProperty(value);\r\n        if (this._required !== v) {\r\n            this._required = v;\r\n            this.onRequiredChanged();\r\n        }\r\n    }\r\n    onRequiredChanged() { }\r\n\r\n\r\n    _onInputInteraction(event: Event) {\r\n        // We always have to stop propagation on the change event.\r\n        // Otherwise the change event, from the input element, will bubble up and\r\n        // emit its event object to the `change` output.\r\n        event.stopPropagation();\r\n        this.setNgModel((event.target as any).value);\r\n    }\r\n\r\n    /** Dispatch change event with current value. */\r\n    _emitChangeEvent(): void {\r\n        if (this._isInitialized) {\r\n            this.change.emit(this._value);\r\n        }\r\n    }\r\n\r\n\r\n    ngAfterContentInit() {\r\n        // Mark this component as initialized in AfterContentInit because the initial value can\r\n        // possibly be set by NgModel on component, and it is possible that the OnInit of the\r\n        // NgModel occurs *after* the OnInit of the component.\r\n        this._isInitialized = true;\r\n    }\r\n\r\n\r\n    /**\r\n     * Sets the model value. Implemented as part of ControlValueAccessor.\r\n     * (write from model to el.nativeElement)\r\n     * @param value\r\n     */\r\n    writeValue(value: any) {\r\n        this.value = value;\r\n        //this._changeDetector.markForCheck();\r\n        //this._renderer.setProperty(this._elementRef.nativeElement, 'value', value);\r\n    }\r\n\r\n    /**\r\n     * Registers a callback to be triggered when the model value changes.\r\n     * Implemented as part of ControlValueAccessor.\r\n     * @param fn Callback to be registered.\r\n     */\r\n    registerOnChange(fn: (_: any) => void): void {\r\n        this._onChange = fn;\r\n    }\r\n\r\n    /**\r\n     * Registers a callback to be triggered when the control is touched.\r\n     * Implemented as part of ControlValueAccessor.\r\n     * @param fn Callback to be registered.\r\n     */\r\n    registerOnTouched(fn: any) {\r\n        this._onTouched = fn;\r\n    }\r\n\r\n\r\n    /**\r\n     * Sets the disabled state of the control. Implemented as a part of ControlValueAccessor.\r\n     * @param isDisabled Whether the control should be disabled.\r\n     */\r\n    setDisabledState(isDisabled: boolean) {\r\n        this.disabled = isDisabled;\r\n        //this._changeDetector.markForCheck();\r\n        //this._renderer.setProperty(this._elementRef.nativeElement, 'disabled', isDisabled);\r\n    }\r\n}"]}

package/esm2022/lib/components/core.component.mjs

@@ -0,0 +1,40 @@
+import { Directive } from '@angular/core';
+import * as i0 from "@angular/core";
+class CoreComponent {
+    constructor() {
+        this.loading = false;
+    }
+    ngOnInit() {
+        this.load();
+    }
+    ngOnDestroy() {
+        this.destroy();
+    }
+    async load() {
+        try {
+            if (this.loading)
+                return;
+            this.loading = true;
+            await this.init();
+            await this.bindModel();
+            await this.bindDictionary();
+            await this.onBound();
+        }
+        finally {
+            this.loading = false;
+        }
+    }
+    init() { }
+    bindModel() { }
+    bindDictionary() { }
+    onBound() { }
+    async destroy() {
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.1", ngImport: i0, type: CoreComponent, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.0.1", type: CoreComponent, ngImport: i0 }); }
+}
+export { CoreComponent };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.1", ngImport: i0, type: CoreComponent, decorators: [{
+            type: Directive
+        }] });
+//# sourceMappingURL=data:application/json;base64,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