@fundamental-ngx/cdk 0.38.3-rc.4

package/esm2020/data-source/data-source.directive.mjs

@@ -0,0 +1,96 @@
+import { Directive, EventEmitter, Inject, Input, Output } from '@angular/core';
+import { DestroyedService } from '@fundamental-ngx/cdk/utils';
+import { BehaviorSubject, Subscription } from 'rxjs';
+import { takeUntil } from 'rxjs/operators';
+import { isDataSource } from './helpers/is-datasource';
+import { FD_DATA_SOURCE_TRANSFORMER } from './tokens';
+import * as i0 from "@angular/core";
+import * as i1 from "@fundamental-ngx/cdk/utils";
+export class DataSourceDirective {
+    /** @hidden */
+    constructor(_destroyed$, _dataSourceTransformer) {
+        this._destroyed$ = _destroyed$;
+        this._dataSourceTransformer = _dataSourceTransformer;
+        /** @hidden */
+        this._dsSubscription = new Subscription();
+        /**
+         * Data stream. Emits when new data retrieved.
+         */
+        this.dataChanged$ = new BehaviorSubject([]);
+        /**
+         * Emits when the data source object has been changed.
+         */
+        this.dataSourceChanged = new EventEmitter();
+        /**
+         * Event emitted when datasource content has been changed.
+         */
+        this.dataChanged = new EventEmitter();
+        /**
+         * Event emitted when data provider loading state has been changed.
+         */
+        this.isLoading = new EventEmitter();
+    }
+    /**
+     * Data source.
+     * @param source
+     */
+    set dataSource(source) {
+        this._dataSource = source;
+        this.dataSourceChanged.next();
+        this._initializeDataSource();
+    }
+    get dataSource() {
+        return this._dataSource;
+    }
+    /** @hidden */
+    _initializeDataSource() {
+        if (isDataSource(this.dataSource)) {
+            this.dataSourceProvider?.unsubscribe();
+            this._dsSubscription?.unsubscribe();
+        }
+        // Convert whatever comes in as DataSource, so we can work with it identically
+        this.dataSourceProvider = this._toDataStream(this.dataSource);
+        if (!this.dataSourceProvider) {
+            return;
+        }
+        this._dsSubscription = new Subscription();
+        this._dsSubscription.add(this.dataSourceProvider.dataLoading
+            .pipe(takeUntil(this._destroyed$))
+            .subscribe((isLoading) => this.isLoading.emit(isLoading)));
+        this._dsSubscription.add(this.dataSourceProvider.dataChanges.pipe(takeUntil(this._destroyed$)).subscribe((data) => {
+            this.dataChanged.emit(data);
+            this.dataChanged$.next(data);
+        }));
+    }
+    /** @hidden */
+    ngOnDestroy() {
+        this.dataSourceProvider?.unsubscribe();
+        this._dsSubscription?.unsubscribe();
+    }
+    /** @Hidden */
+    _toDataStream(source) {
+        return this._dataSourceTransformer ? this._dataSourceTransformer.parse(source) : undefined;
+    }
+}
+DataSourceDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.0.2", ngImport: i0, type: DataSourceDirective, deps: [{ token: i1.DestroyedService }, { token: FD_DATA_SOURCE_TRANSFORMER }], target: i0.ɵɵFactoryTarget.Directive });
+DataSourceDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "15.0.2", type: DataSourceDirective, isStandalone: true, selector: "[fdkDataSource]", inputs: { dataSource: "dataSource" }, outputs: { dataSourceChanged: "dataSourceChanged", dataChanged: "dataChanged", isLoading: "isLoading" }, providers: [DestroyedService], ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.0.2", ngImport: i0, type: DataSourceDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[fdkDataSource]',
+                    standalone: true,
+                    providers: [DestroyedService]
+                }]
+        }], ctorParameters: function () { return [{ type: i1.DestroyedService }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [FD_DATA_SOURCE_TRANSFORMER]
+                }] }]; }, propDecorators: { dataSource: [{
+                type: Input
+            }], dataSourceChanged: [{
+                type: Output
+            }], dataChanged: [{
+                type: Output
+            }], isLoading: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/data-source/data-source.module.mjs

@@ -0,0 +1,16 @@
+import { NgModule } from '@angular/core';
+import { DataSourceDirective } from './data-source.directive';
+import * as i0 from "@angular/core";
+export class DataSourceModule {
+}
+DataSourceModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.0.2", ngImport: i0, type: DataSourceModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+DataSourceModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "15.0.2", ngImport: i0, type: DataSourceModule, imports: [DataSourceDirective], exports: [DataSourceDirective] });
+DataSourceModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "15.0.2", ngImport: i0, type: DataSourceModule });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.0.2", ngImport: i0, type: DataSourceModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [DataSourceDirective],
+                    exports: [DataSourceDirective]
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGF0YS1zb3VyY2UubW9kdWxlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vbGlicy9jZGsvc3JjL2xpYi9kYXRhLXNvdXJjZS9kYXRhLXNvdXJjZS5tb2R1bGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFFBQVEsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUN6QyxPQUFPLEVBQUUsbUJBQW1CLEVBQUUsTUFBTSx5QkFBeUIsQ0FBQzs7QUFNOUQsTUFBTSxPQUFPLGdCQUFnQjs7NkdBQWhCLGdCQUFnQjs4R0FBaEIsZ0JBQWdCLFlBSGYsbUJBQW1CLGFBQ25CLG1CQUFtQjs4R0FFcEIsZ0JBQWdCOzJGQUFoQixnQkFBZ0I7a0JBSjVCLFFBQVE7bUJBQUM7b0JBQ04sT0FBTyxFQUFFLENBQUMsbUJBQW1CLENBQUM7b0JBQzlCLE9BQU8sRUFBRSxDQUFDLG1CQUFtQixDQUFDO2lCQUNqQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IE5nTW9kdWxlIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQgeyBEYXRhU291cmNlRGlyZWN0aXZlIH0gZnJvbSAnLi9kYXRhLXNvdXJjZS5kaXJlY3RpdmUnO1xuXG5ATmdNb2R1bGUoe1xuICAgIGltcG9ydHM6IFtEYXRhU291cmNlRGlyZWN0aXZlXSxcbiAgICBleHBvcnRzOiBbRGF0YVNvdXJjZURpcmVjdGl2ZV1cbn0pXG5leHBvcnQgY2xhc3MgRGF0YVNvdXJjZU1vZHVsZSB7fVxuIl19

package/esm2020/data-source/fundamental-ngx-cdk-data-source.mjs

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './index';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZnVuZGFtZW50YWwtbmd4LWNkay1kYXRhLXNvdXJjZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL2xpYnMvY2RrL3NyYy9saWIvZGF0YS1zb3VyY2UvZnVuZGFtZW50YWwtbmd4LWNkay1kYXRhLXNvdXJjZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7R0FFRztBQUVILGNBQWMsU0FBUyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBHZW5lcmF0ZWQgYnVuZGxlIGluZGV4LiBEbyBub3QgZWRpdC5cbiAqL1xuXG5leHBvcnQgKiBmcm9tICcuL2luZGV4JztcbiJdfQ==

package/esm2020/data-source/helpers/apply-datasource-directive.mjs

@@ -0,0 +1,7 @@
+import { DataSourceDirective } from '../data-source.directive';
+export const applyDatasourceDirective = {
+    directive: DataSourceDirective,
+    inputs: ['dataSource'],
+    outputs: ['dataChanged']
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXBwbHktZGF0YXNvdXJjZS1kaXJlY3RpdmUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9saWJzL2Nkay9zcmMvbGliL2RhdGEtc291cmNlL2hlbHBlcnMvYXBwbHktZGF0YXNvdXJjZS1kaXJlY3RpdmUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQ0EsT0FBTyxFQUFFLG1CQUFtQixFQUFFLE1BQU0sMEJBQTBCLENBQUM7QUFFL0QsTUFBTSxDQUFDLE1BQU0sd0JBQXdCLEdBTTNCO0lBQ04sU0FBUyxFQUFFLG1CQUFtQjtJQUM5QixNQUFNLEVBQUUsQ0FBQyxZQUFZLENBQUM7SUFDdEIsT0FBTyxFQUFFLENBQUMsYUFBYSxDQUFDO0NBQzNCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBUeXBlIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQgeyBEYXRhU291cmNlRGlyZWN0aXZlIH0gZnJvbSAnLi4vZGF0YS1zb3VyY2UuZGlyZWN0aXZlJztcblxuZXhwb3J0IGNvbnN0IGFwcGx5RGF0YXNvdXJjZURpcmVjdGl2ZTpcbiAgICB8IFR5cGU8dW5rbm93bj5cbiAgICB8IHtcbiAgICAgICAgICBkaXJlY3RpdmU6IFR5cGU8dW5rbm93bj47XG4gICAgICAgICAgaW5wdXRzPzogc3RyaW5nW107XG4gICAgICAgICAgb3V0cHV0cz86IHN0cmluZ1tdO1xuICAgICAgfSA9IHtcbiAgICBkaXJlY3RpdmU6IERhdGFTb3VyY2VEaXJlY3RpdmUsXG4gICAgaW5wdXRzOiBbJ2RhdGFTb3VyY2UnXSxcbiAgICBvdXRwdXRzOiBbJ2RhdGFDaGFuZ2VkJ11cbn07XG4iXX0=

package/esm2020/data-source/helpers/common.mjs

@@ -0,0 +1,17 @@
+import { isBlank, isStringMap, isType } from '@fundamental-ngx/cdk/utils';
+/** @Hidden */
+export function getMatchingStrategyStartsWithPerTermReqexp(value) {
+    return new RegExp(`(\\s|^)(${value})`, 'gi');
+}
+/** @hidden */
+export function objectValues(obj) {
+    return Object.keys(obj).map((key) => obj[key]);
+}
+/** @hidden */
+export function objectToName(target) {
+    if (isBlank(target) || (!isStringMap(target) && !isType(target))) {
+        throw new Error(' Cannot convert. Uknown object');
+    }
+    return isType(target) ? target.prototype.constructor.name : target.constructor.name;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/data-source/helpers/is-datasource.mjs

@@ -0,0 +1,7 @@
+/**
+ * Checks whether passed value is a valid data source.
+ */
+export function isDataSource(value) {
+    return value && typeof value.unsubscribe === 'function' && value.dataChanges;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaXMtZGF0YXNvdXJjZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL2xpYnMvY2RrL3NyYy9saWIvZGF0YS1zb3VyY2UvaGVscGVycy9pcy1kYXRhc291cmNlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUVBOztHQUVHO0FBQ0gsTUFBTSxVQUFVLFlBQVksQ0FBVSxLQUFVO0lBQzVDLE9BQU8sS0FBSyxJQUFJLE9BQU8sS0FBSyxDQUFDLFdBQVcsS0FBSyxVQUFVLElBQUksS0FBSyxDQUFDLFdBQVcsQ0FBQztBQUNqRixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgRGF0YVNvdXJjZVByb3ZpZGVyIH0gZnJvbSAnLi4vbW9kZWxzL2RhdGEtc291cmNlLXByb3ZpZGVyJztcblxuLyoqXG4gKiBDaGVja3Mgd2hldGhlciBwYXNzZWQgdmFsdWUgaXMgYSB2YWxpZCBkYXRhIHNvdXJjZS5cbiAqL1xuZXhwb3J0IGZ1bmN0aW9uIGlzRGF0YVNvdXJjZTxUID0gYW55Pih2YWx1ZTogYW55KTogdmFsdWUgaXMgRGF0YVNvdXJjZVByb3ZpZGVyPFQ+IHtcbiAgICByZXR1cm4gdmFsdWUgJiYgdHlwZW9mIHZhbHVlLnVuc3Vic2NyaWJlID09PSAnZnVuY3Rpb24nICYmIHZhbHVlLmRhdGFDaGFuZ2VzO1xufVxuIl19

package/esm2020/data-source/index.mjs

@@ -0,0 +1,9 @@
+export * from './data-source.module';
+export * from './data-source.directive';
+export * from './models';
+export * from './base/base-data-source.class';
+export * from './base/abstract-data-provider.class';
+export * from './tokens';
+export * from './helpers/apply-datasource-directive';
+export * from './helpers/is-datasource';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9saWJzL2Nkay9zcmMvbGliL2RhdGEtc291cmNlL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsc0JBQXNCLENBQUM7QUFFckMsY0FBYyx5QkFBeUIsQ0FBQztBQUN4QyxjQUFjLFVBQVUsQ0FBQztBQUN6QixjQUFjLCtCQUErQixDQUFDO0FBQzlDLGNBQWMscUNBQXFDLENBQUM7QUFDcEQsY0FBYyxVQUFVLENBQUM7QUFDekIsY0FBYyxzQ0FBc0MsQ0FBQztBQUNyRCxjQUFjLHlCQUF5QixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9kYXRhLXNvdXJjZS5tb2R1bGUnO1xuXG5leHBvcnQgKiBmcm9tICcuL2RhdGEtc291cmNlLmRpcmVjdGl2ZSc7XG5leHBvcnQgKiBmcm9tICcuL21vZGVscyc7XG5leHBvcnQgKiBmcm9tICcuL2Jhc2UvYmFzZS1kYXRhLXNvdXJjZS5jbGFzcyc7XG5leHBvcnQgKiBmcm9tICcuL2Jhc2UvYWJzdHJhY3QtZGF0YS1wcm92aWRlci5jbGFzcyc7XG5leHBvcnQgKiBmcm9tICcuL3Rva2Vucyc7XG5leHBvcnQgKiBmcm9tICcuL2hlbHBlcnMvYXBwbHktZGF0YXNvdXJjZS1kaXJlY3RpdmUnO1xuZXhwb3J0ICogZnJvbSAnLi9oZWxwZXJzL2lzLWRhdGFzb3VyY2UnO1xuIl19

package/esm2020/data-source/models/data-source-provider.mjs

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

package/esm2020/data-source/models/data-source.mjs

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

package/esm2020/data-source/models/index.mjs

@@ -0,0 +1,4 @@
+export * from './data-source';
+export * from './data-source-provider';
+export * from './matching-strategy';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9saWJzL2Nkay9zcmMvbGliL2RhdGEtc291cmNlL21vZGVscy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLGVBQWUsQ0FBQztBQUM5QixjQUFjLHdCQUF3QixDQUFDO0FBQ3ZDLGNBQWMscUJBQXFCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL2RhdGEtc291cmNlJztcbmV4cG9ydCAqIGZyb20gJy4vZGF0YS1zb3VyY2UtcHJvdmlkZXInO1xuZXhwb3J0ICogZnJvbSAnLi9tYXRjaGluZy1zdHJhdGVneSc7XG4iXX0=

package/esm2020/data-source/models/matching-strategy.mjs

@@ -0,0 +1,7 @@
+export var MatchingStrategy;
+(function (MatchingStrategy) {
+    MatchingStrategy["STARTS_WITH_PER_TERM"] = "starts with per term";
+    MatchingStrategy["STARTS_WITH"] = "starts with";
+    MatchingStrategy["CONTAINS"] = "contains";
+})(MatchingStrategy || (MatchingStrategy = {}));
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibWF0Y2hpbmctc3RyYXRlZ3kuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9saWJzL2Nkay9zcmMvbGliL2RhdGEtc291cmNlL21vZGVscy9tYXRjaGluZy1zdHJhdGVneS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxNQUFNLENBQU4sSUFBWSxnQkFJWDtBQUpELFdBQVksZ0JBQWdCO0lBQ3hCLGlFQUE2QyxDQUFBO0lBQzdDLCtDQUEyQixDQUFBO0lBQzNCLHlDQUFxQixDQUFBO0FBQ3pCLENBQUMsRUFKVyxnQkFBZ0IsS0FBaEIsZ0JBQWdCLFFBSTNCIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IGVudW0gTWF0Y2hpbmdTdHJhdGVneSB7XG4gICAgU1RBUlRTX1dJVEhfUEVSX1RFUk0gPSAnc3RhcnRzIHdpdGggcGVyIHRlcm0nLFxuICAgIFNUQVJUU19XSVRIID0gJ3N0YXJ0cyB3aXRoJyxcbiAgICBDT05UQUlOUyA9ICdjb250YWlucydcbn1cblxuZXhwb3J0IHR5cGUgTWF0Y2hCeSA9IChpdGVtOiBhbnkpID0+IGFueTtcblxuZXhwb3J0IGludGVyZmFjZSBNYXRjaGluZ0J5IHtcbiAgICBmaXJzdEJ5OiBNYXRjaEJ5O1xuICAgIHNlY29uZGFyeUJ5PzogTWF0Y2hCeTtcbn1cbiJdfQ==

package/esm2020/data-source/tokens.mjs

@@ -0,0 +1,6 @@
+import { InjectionToken } from '@angular/core';
+/**
+ * Injection token used for passing custom datasource transformer into DataSourceProvider.
+ */
+export const FD_DATA_SOURCE_TRANSFORMER = new InjectionToken('FdDataSourceTransformer');
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidG9rZW5zLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vbGlicy9jZGsvc3JjL2xpYi9kYXRhLXNvdXJjZS90b2tlbnMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLGNBQWMsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUcvQzs7R0FFRztBQUNILE1BQU0sQ0FBQyxNQUFNLDBCQUEwQixHQUFHLElBQUksY0FBYyxDQUFtQix5QkFBeUIsQ0FBQyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgSW5qZWN0aW9uVG9rZW4gfSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB7IERhdGFTb3VyY2VQYXJzZXIgfSBmcm9tICcuL21vZGVscy9kYXRhLXNvdXJjZSc7XG5cbi8qKlxuICogSW5qZWN0aW9uIHRva2VuIHVzZWQgZm9yIHBhc3NpbmcgY3VzdG9tIGRhdGFzb3VyY2UgdHJhbnNmb3JtZXIgaW50byBEYXRhU291cmNlUHJvdmlkZXIuXG4gKi9cbmV4cG9ydCBjb25zdCBGRF9EQVRBX1NPVVJDRV9UUkFOU0ZPUk1FUiA9IG5ldyBJbmplY3Rpb25Ub2tlbjxEYXRhU291cmNlUGFyc2VyPignRmREYXRhU291cmNlVHJhbnNmb3JtZXInKTtcbiJdfQ==

package/esm2020/forms/cva/cva-control.class.mjs

@@ -0,0 +1,43 @@
+import { ChangeDetectorRef, inject, Injectable } from '@angular/core';
+import { takeUntil } from 'rxjs';
+import { CvaDirective } from './cva.directive';
+import { DestroyedService } from '@fundamental-ngx/cdk/utils';
+import * as i0 from "@angular/core";
+/**
+ * Base ControlValueAccessor control class.
+ * Used in conjunction with CvaDirective.
+ *
+ * This class performs generic change detection based on `CvaDirective` outputs.
+ */
+export class CvaControl {
+    constructor() {
+        /**
+         * Control value accessor directive instance.
+         */
+        this.cvaDirective = inject((CvaDirective), {
+            self: true,
+            optional: true
+        });
+        /**
+         * Change detector instance.
+         */
+        this._changeDetector = inject(ChangeDetectorRef);
+        /** @Hidden */
+        this._destroy$ = inject(DestroyedService);
+    }
+    /** @hidden */
+    listenToChanges() {
+        this.cvaDirective?.markForCheck.pipe(takeUntil(this._destroy$)).subscribe(() => {
+            this._changeDetector.detectChanges();
+        });
+        this.cvaDirective?.detectChanges.pipe(takeUntil(this._destroy$)).subscribe(() => {
+            this._changeDetector.detectChanges();
+        });
+    }
+}
+CvaControl.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.0.2", ngImport: i0, type: CvaControl, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+CvaControl.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.0.2", ngImport: i0, type: CvaControl });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.0.2", ngImport: i0, type: CvaControl, decorators: [{
+            type: Injectable
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/forms/cva/cva.directive.mjs

@@ -0,0 +1,309 @@
+import { Directive, ElementRef, EventEmitter, inject, Input, isDevMode, Output, ViewChild } from '@angular/core';
+import { ControlContainer, NgControl, NgForm } from '@angular/forms';
+import { coerceBooleanProperty } from '@angular/cdk/coercion';
+import { Subject, Subscription } from 'rxjs';
+import { isValidControlState } from '../helpers/state';
+import { FD_FORM_FIELD } from '../tokens/form-field.token';
+import { DestroyedService } from '@fundamental-ngx/cdk/utils';
+import * as i0 from "@angular/core";
+let randomId = 0;
+export class CvaDirective {
+    /** @hidden */
+    constructor() {
+        /**
+         * NgControl instance.
+         */
+        this.ngControl = inject(NgControl, {
+            optional: true
+        });
+        /**
+         * Form container instance. Usually ngForm or FormGroup directives.
+         */
+        this.controlContainer = inject(ControlContainer, {
+            optional: true,
+            skipSelf: true
+        });
+        /**
+         * Separate NgForm instance. For cases when formGroup is used with the form itself.
+         */
+        this.ngForm = inject(NgForm, {
+            optional: true,
+            skipSelf: true
+        });
+        /**
+         * Element reference.
+         */
+        this.elementRef = inject(ElementRef);
+        /** @hidden */
+        this._defaultId = `fd-input-id-${randomId++}`;
+        /** @hidden */
+        this._editable = true;
+        /** @hidden */
+        this._destroyed = new Subject();
+        /** ID for the Element */
+        this.id = this._defaultId;
+        /**
+         * Emits when change detection is needed.
+         */
+        this.detectChanges = new EventEmitter();
+        /**
+         * Emits when mark for changes detection is needed.
+         */
+        this.markForCheck = new EventEmitter();
+        /** @hidden */
+        this._subscriptions = new Subscription();
+        /**
+         * See @FormFieldControl
+         */
+        this.focused = false;
+        /**
+         * @hidden
+         */
+        this._controlInvalid = false;
+        /**
+         * See @FormFieldControl
+         */
+        this.stateChanges = new Subject();
+        /** @hidden */
+        this.formField = inject(FD_FORM_FIELD, {
+            skipSelf: true,
+            optional: true
+        });
+        /** @hidden */
+        this.onChange = () => { };
+        /** @hidden */
+        this.onTouched = () => { };
+        if (this.ngControl) {
+            this.ngControl.valueAccessor = this;
+        }
+    }
+    /**
+     *  The state of the form control - applies css classes.
+     *  Can be 'success', 'error', 'warning', 'default', 'information'.
+     *
+     * @default 'default'
+     */
+    set state(state) {
+        if (!state || isValidControlState(state)) {
+            this._state = state;
+        }
+        else if (isDevMode()) {
+            console.warn(`Provided value "${state}" is not a valid option for FormStates type`);
+        }
+    }
+    get state() {
+        if (this._state) {
+            return this._state;
+        }
+        if (!this.controlInvalid) {
+            return 'default';
+        }
+        return this.formField?.getPriorityState() || 'error';
+    }
+    /** Whether the input is disabled */
+    set disabled(value) {
+        this.setDisabledState(value);
+    }
+    get disabled() {
+        if (this.ngControl && this.ngControl.disabled !== null) {
+            return this.ngControl.disabled;
+        }
+        return this._disabled;
+    }
+    /**
+     * Tell the component if we are in editing mode.
+     */
+    set editable(value) {
+        const newVal = coerceBooleanProperty(value);
+        if (this._editable !== newVal) {
+            this._editable = newVal;
+            this._markForCheck();
+            this.stateChanges.next('editable');
+        }
+    }
+    get editable() {
+        return this._editable;
+    }
+    /** Whether control has errors */
+    get controlInvalid() {
+        return this._controlInvalid;
+    }
+    /** @hidden */
+    ngOnInit() {
+        this.formField?.registerFormFieldControl(this);
+    }
+    /**
+     * Re-validate and emit event to parent container on every CD cycle as they are some errors
+     * that we can't subscribe to.
+     */
+    ngDoCheck() {
+        if (this.ngControl) {
+            this.updateErrorState();
+        }
+    }
+    /** @hidden */
+    ngAfterViewInit() {
+        if (this.ngControl) {
+            this._subscriptions.add(this.ngControl.statusChanges?.subscribe(() => {
+                this._markForCheck();
+            }));
+        }
+        const labelAndHelpId = `fdp-form-label-content-${this.id}`;
+        // if not specified, associate label and inline help ids with the input,
+        // else add these ids to the specified ones
+        if (!this.ariaLabelledBy) {
+            this.ariaLabelledBy = labelAndHelpId;
+        }
+        else {
+            this.ariaLabelledBy += ' ' + labelAndHelpId;
+        }
+        this._markForCheck();
+    }
+    /** @hidden */
+    registerOnChange(fn) {
+        this.onChange = fn;
+    }
+    /** @hidden */
+    registerOnTouched(fn) {
+        this.onTouched = fn;
+    }
+    /** @hidden */
+    ngOnDestroy() {
+        this._subscriptions.unsubscribe();
+        this.stateChanges.complete();
+        this._destroyed.next();
+        this._destroyed.complete();
+        this.formField?.unregisterFormFieldControl(this);
+    }
+    /** @hidden */
+    setDisabledState(isDisabled) {
+        const newState = coerceBooleanProperty(isDisabled);
+        this._markForCheck();
+        if (newState !== this._disabled) {
+            this._disabled = newState;
+            this.stateChanges.next('setDisabledState');
+        }
+    }
+    /**
+     * Method for setting the value
+     * @param value
+     */
+    writeValue(value) {
+        this.value = value;
+        this.stateChanges.next('writeValue');
+        this._markForCheck();
+    }
+    /**
+     *
+     * Keeps track of element focus
+     */
+    _onFocusChanged(isFocused) {
+        if (isFocused !== this.focused && (!this.disabled || !isFocused)) {
+            this.focused = isFocused;
+            this.stateChanges.next('_onFocusChanged');
+        }
+        if (!isFocused) {
+            this.onTouched();
+        }
+    }
+    /**
+     * Handles even when we click on parent container which is the FormField Wrapping this
+     * control
+     */
+    onContainerClick(event) {
+        this.focus(event);
+    }
+    /**
+     * In most of the cases when working with input element directly you should be just find to assign
+     * variable to this element
+     *
+     * ```
+     * <input #inputElementRef fd-form-control ...>
+     * ```
+     *
+     * and this default behavior used. For other cases implement focus.
+     *
+     */
+    focus(event) {
+        if (this._elementRef && !this.focused) {
+            this._elementRef.nativeElement.focus(event);
+        }
+    }
+    /**
+     *  Need re-validates errors on every CD iteration to make sure we are also
+     *  covering non-control errors, errors that happens outside of this control
+     */
+    updateErrorState() {
+        const parent = this.ngForm;
+        const parentControlContainer = this.controlContainer;
+        const control = this.ngControl ? this.ngControl.control : null;
+        const newStatusIsError = !!(control?.invalid &&
+            (control.dirty || control.touched || parent?.submitted || parentControlContainer?.submitted));
+        if (newStatusIsError !== this.controlInvalid) {
+            this._controlInvalid = newStatusIsError;
+            this.stateChanges.next('updateErrorState');
+            this._markForCheck();
+        }
+    }
+    /**
+     * Used to change the value of a control.
+     * @param value the value to be applied
+     * @param emitOnChange whether to emit "onChange" event.
+     * Should be "false", if the change is made programmatically (internally) by the control, "true" otherwise
+     */
+    setValue(value, emitOnChange = true) {
+        if (value !== this.value) {
+            this.writeValue(value);
+            if (emitOnChange) {
+                this.onChange(value);
+            }
+            this._markForCheck();
+        }
+    }
+    /** @hidden */
+    _markForCheck() {
+        this.markForCheck.emit();
+    }
+    /** @hidden */
+    _detectChanges() {
+        this.detectChanges.emit();
+    }
+}
+CvaDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.0.2", ngImport: i0, type: CvaDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+CvaDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "15.0.2", type: CvaDirective, isStandalone: true, selector: "[fdkCva]", inputs: { id: "id", placeholder: "placeholder", state: "state", stateMessage: "stateMessage", disabled: "disabled", readonly: "readonly", ariaLabelledBy: "ariaLabelledBy", ariaLabel: "ariaLabel", editable: "editable", name: "name" }, outputs: { detectChanges: "detectChanges", markForCheck: "markForCheck" }, providers: [DestroyedService], viewQueries: [{ propertyName: "_elementRef", first: true, predicate: ["inputElementRef"], descendants: true, read: ElementRef, static: true }], ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.0.2", ngImport: i0, type: CvaDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[fdkCva]',
+                    standalone: true,
+                    providers: [DestroyedService]
+                }]
+        }], ctorParameters: function () { return []; }, propDecorators: { id: [{
+                type: Input
+            }], placeholder: [{
+                type: Input
+            }], state: [{
+                type: Input
+            }], stateMessage: [{
+                type: Input
+            }], disabled: [{
+                type: Input
+            }], readonly: [{
+                type: Input
+            }], ariaLabelledBy: [{
+                type: Input
+            }], ariaLabel: [{
+                type: Input
+            }], editable: [{
+                type: Input
+            }], name: [{
+                type: Input
+            }], detectChanges: [{
+                type: Output
+            }], markForCheck: [{
+                type: Output
+            }], _elementRef: [{
+                type: ViewChild,
+                args: ['inputElementRef', { static: true, read: ElementRef }]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cva.directive.js","sourceRoot":"","sources":["../../../../../../libs/cdk/src/lib/forms/cva/cva.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n    AfterViewInit,\n    Directive,\n    DoCheck,\n    ElementRef,\n    EventEmitter,\n    inject,\n    Input,\n    isDevMode,\n    OnDestroy,\n    OnInit,\n    Output,\n    ViewChild\n} from '@angular/core';\nimport { ControlContainer, ControlValueAccessor, FormControl, NgControl, NgForm } from '@angular/forms';\nimport { BooleanInput, coerceBooleanProperty } from '@angular/cdk/coercion';\nimport { Subject, Subscription } from 'rxjs';\nimport { BaseCVA } from '../models/cva';\nimport { isValidControlState } from '../helpers/state';\nimport { FormStates } from '../models/form-state';\nimport { FormField } from '../models/form-field';\nimport { FormFieldControl } from '../models/form-field-control';\nimport { FD_FORM_FIELD } from '../tokens/form-field.token';\nimport { DestroyedService, Nullable } from '@fundamental-ngx/cdk/utils';\n\nlet randomId = 0;\n\n@Directive({\n    selector: '[fdkCva]',\n    standalone: true,\n    providers: [DestroyedService]\n})\nexport class CvaDirective<T = any>\n    implements BaseCVA, FormFieldControl, OnInit, DoCheck, AfterViewInit, OnDestroy, ControlValueAccessor\n{\n    /**\n     * NgControl instance.\n     */\n    readonly ngControl = inject(NgControl, {\n        optional: true\n    });\n\n    /**\n     * Form container instance. Usually ngForm or FormGroup directives.\n     */\n    readonly controlContainer = inject(ControlContainer, {\n        optional: true,\n        skipSelf: true\n    });\n\n    /**\n     * Separate NgForm instance. For cases when formGroup is used with the form itself.\n     */\n    readonly ngForm = inject(NgForm, {\n        optional: true,\n        skipSelf: true\n    });\n\n    /**\n     * Element reference.\n     */\n    readonly elementRef = inject(ElementRef);\n\n    /** @hidden */\n    value: T;\n\n    /** @hidden */\n    constructor() {\n        if (this.ngControl) {\n            this.ngControl.valueAccessor = this;\n        }\n    }\n\n    /** @hidden */\n    private _defaultId = `fd-input-id-${randomId++}`;\n    /** @hidden */\n    private _disabled: boolean;\n    /** @hidden */\n    private _editable = true;\n    /** @hidden */\n    private _destroyed = new Subject<void>();\n\n    /** ID for the Element */\n    @Input()\n    id: string = this._defaultId;\n\n    /** Input placeholder */\n    @Input()\n    placeholder: string;\n\n    /**\n     *  The state of the form control - applies css classes.\n     *  Can be 'success', 'error', 'warning', 'default', 'information'.\n     *\n     * @default 'default'\n     */\n    @Input()\n    set state(state: FormStates | undefined) {\n        if (!state || isValidControlState(state)) {\n            this._state = state;\n        } else if (isDevMode()) {\n            console.warn(`Provided value \"${state}\" is not a valid option for FormStates type`);\n        }\n    }\n    get state(): FormStates {\n        if (this._state) {\n            return this._state;\n        }\n\n        if (!this.controlInvalid) {\n            return 'default';\n        }\n\n        return this.formField?.getPriorityState() || 'error';\n    }\n\n    /** Holds the message with respect to state */\n    @Input()\n    stateMessage: Nullable<string>;\n\n    /**\n     * @hidden\n     * The state of the form control - applies css classes.\n     * Can be `success`, `error`, `warning`, `information` or 'default'\n     */\n    private _state: FormStates | undefined;\n\n    /** Whether the input is disabled */\n    @Input()\n    set disabled(value: boolean) {\n        this.setDisabledState(value);\n    }\n    get disabled(): boolean {\n        if (this.ngControl && this.ngControl.disabled !== null) {\n            return this.ngControl.disabled;\n        }\n        return this._disabled;\n    }\n\n    /**\n     * readOnly Value to Mark component read only\n     */\n    @Input()\n    readonly: boolean;\n\n    /** Binds to control aria-labelledBy attribute */\n    @Input()\n    ariaLabelledBy: Nullable<string>;\n\n    /** Sets control aria-label attribute value */\n    @Input()\n    ariaLabel: Nullable<string>;\n\n    /**\n     * Tell the component if we are in editing mode.\n     */\n    @Input()\n    set editable(value: BooleanInput) {\n        const newVal = coerceBooleanProperty(value);\n        if (this._editable !== newVal) {\n            this._editable = newVal;\n            this._markForCheck();\n            this.stateChanges.next('editable');\n        }\n    }\n    get editable(): boolean {\n        return this._editable;\n    }\n\n    /**\n     * Name of the control.\n     */\n    @Input()\n    name: string;\n\n    /**\n     * Emits when change detection is needed.\n     */\n    @Output()\n    detectChanges = new EventEmitter<void>();\n\n    /**\n     * Emits when mark for changes detection is needed.\n     */\n    @Output()\n    markForCheck = new EventEmitter<void>();\n\n    /** @hidden */\n    protected _subscriptions = new Subscription();\n\n    /**\n     * Reference to internal Input element\n     */\n    @ViewChild('inputElementRef', { static: true, read: ElementRef })\n    protected _elementRef: ElementRef;\n\n    /**\n     * See @FormFieldControl\n     */\n    focused = false;\n\n    /** Whether control has errors */\n    get controlInvalid(): boolean {\n        return this._controlInvalid;\n    }\n\n    /**\n     * @hidden\n     */\n    private _controlInvalid = false;\n    /**\n     * See @FormFieldControl\n     */\n    readonly stateChanges: Subject<any> = new Subject<any>();\n\n    /** @hidden */\n    readonly formField: FormField | null = inject(FD_FORM_FIELD, {\n        skipSelf: true,\n        optional: true\n    });\n\n    /** set when input field is mandatory form field */\n    required: boolean;\n\n    /** @hidden */\n    onChange: (value: any) => void = () => {};\n\n    /** @hidden */\n    onTouched = (): void => {};\n\n    /** @hidden */\n    ngOnInit(): void {\n        this.formField?.registerFormFieldControl(this);\n    }\n\n    /**\n     * Re-validate and emit event to parent container on every CD cycle as they are some errors\n     * that we can't subscribe to.\n     */\n    ngDoCheck(): void {\n        if (this.ngControl) {\n            this.updateErrorState();\n        }\n    }\n\n    /** @hidden */\n    ngAfterViewInit(): void {\n        if (this.ngControl) {\n            this._subscriptions.add(\n                this.ngControl.statusChanges?.subscribe(() => {\n                    this._markForCheck();\n                })\n            );\n        }\n\n        const labelAndHelpId = `fdp-form-label-content-${this.id}`;\n        // if not specified, associate label and inline help ids with the input,\n        // else add these ids to the specified ones\n        if (!this.ariaLabelledBy) {\n            this.ariaLabelledBy = labelAndHelpId;\n        } else {\n            this.ariaLabelledBy += ' ' + labelAndHelpId;\n        }\n        this._markForCheck();\n    }\n\n    /** @hidden */\n    registerOnChange(fn: (_: any) => void): void {\n        this.onChange = fn;\n    }\n\n    /** @hidden */\n    registerOnTouched(fn: () => void): void {\n        this.onTouched = fn;\n    }\n\n    /** @hidden */\n    ngOnDestroy(): void {\n        this._subscriptions.unsubscribe();\n        this.stateChanges.complete();\n        this._destroyed.next();\n        this._destroyed.complete();\n        this.formField?.unregisterFormFieldControl(this);\n    }\n\n    /** @hidden */\n    setDisabledState(isDisabled: BooleanInput): void {\n        const newState = coerceBooleanProperty(isDisabled);\n        this._markForCheck();\n        if (newState !== this._disabled) {\n            this._disabled = newState;\n            this.stateChanges.next('setDisabledState');\n        }\n    }\n\n    /**\n     * Method for setting the value\n     * @param value\n     */\n    writeValue(value: T): void {\n        this.value = value;\n        this.stateChanges.next('writeValue');\n        this._markForCheck();\n    }\n\n    /**\n     *\n     * Keeps track of element focus\n     */\n    _onFocusChanged(isFocused: boolean): void {\n        if (isFocused !== this.focused && (!this.disabled || !isFocused)) {\n            this.focused = isFocused;\n            this.stateChanges.next('_onFocusChanged');\n        }\n\n        if (!isFocused) {\n            this.onTouched();\n        }\n    }\n\n    /**\n     * Handles even when we click on parent container which is the FormField Wrapping this\n     * control\n     */\n    onContainerClick(event: MouseEvent): void {\n        this.focus(event);\n    }\n\n    /**\n     * In most of the cases when working with input element directly you should be just find to assign\n     * variable to this element\n     *\n     * ```\n     * <input #inputElementRef fd-form-control ...>\n     * ```\n     *\n     * and this default behavior used. For other cases implement focus.\n     *\n     */\n    focus(event?: MouseEvent): void {\n        if (this._elementRef && !this.focused) {\n            this._elementRef.nativeElement.focus(event);\n        }\n    }\n\n    /**\n     *  Need re-validates errors on every CD iteration to make sure we are also\n     *  covering non-control errors, errors that happens outside of this control\n     */\n    updateErrorState(): void {\n        const parent = this.ngForm;\n        const parentControlContainer = this.controlContainer;\n        const control = this.ngControl ? (this.ngControl.control as FormControl) : null;\n        const newStatusIsError = !!(\n            control?.invalid &&\n            (control.dirty || control.touched || parent?.submitted || (parentControlContainer as any)?.submitted)\n        );\n\n        if (newStatusIsError !== this.controlInvalid) {\n            this._controlInvalid = newStatusIsError;\n            this.stateChanges.next('updateErrorState');\n            this._markForCheck();\n        }\n    }\n\n    /**\n     * Used to change the value of a control.\n     * @param value the value to be applied\n     * @param emitOnChange whether to emit \"onChange\" event.\n     * Should be \"false\", if the change is made programmatically (internally) by the control, \"true\" otherwise\n     */\n    setValue(value: T, emitOnChange = true): void {\n        if (value !== this.value) {\n            this.writeValue(value);\n            if (emitOnChange) {\n                this.onChange(value);\n            }\n            this._markForCheck();\n        }\n    }\n\n    /** @hidden */\n    private _markForCheck(): void {\n        this.markForCheck.emit();\n    }\n\n    /** @hidden */\n    private _detectChanges(): void {\n        this.detectChanges.emit();\n    }\n}\n"]}