@fundamental-ngx/cdk 0.38.3-rc.4

package/README.md

@@ -0,0 +1,89 @@
+# @Fundamental-NGX/CDK
+
+[![npm version](https://badge.fury.io/js/%40fundamental-ngx%2Fcdk.svg)](//www.npmjs.com/package/@fundamental-ngx/cdk)
+![Build Status](https://github.com/SAP/fundamental-ngx/actions/workflows/on-push-or-pull.yml/badge.svg?branch=main)
+![npm](https://img.shields.io/npm/dm/@fundamental-ngx/cdk?label=npm%20downloads)
+[![Slack](https://img.shields.io/badge/slack-ui--fundamentals-blue.svg?logo=slack)](https://ui-fundamentals.slack.com)
+[![REUSE status](https://api.reuse.software/badge/github.com/SAP/fundamental-ngx)](https://api.reuse.software/info/github.com/SAP/fundamental-ngx)
+
+## Content
+
+-   [1. Description](#1)
+-   [2. Requirements](#2)
+-   [3. Versioning](#3)
+-   [4. Getting Started](#4)
+-   [5. Known Issues](#5)
+-   [6. Support](#6)
+-   [7. Contributing](#7)
+-   [8. License](https://github.com/SAP/fundamental-ngx/blob/main/LICENSE.txt)
+-   [9. Similar Projects](#8)
+
+## <a name="1"></a>1. Description
+
+The `@fundamental-ngx/cdk` library is a set of utilities and [Angular](https://angular.io/) directives aimed to help developers build custom UI components with common interaction patterns.
+
+It includes common behaviour for working with `DataSources` and `ControlValueAccessors`.
+Additionally, it contains injectable helpers to easily control the `rxjs` subscriptions in your components, focusable/selectable list helpers and many more.
+
+See [Component Documentation](https://sap.github.io/fundamental-ngx/docs/home) for examples and API details.
+
+## <a name="2"></a>2. Requirements
+
+To download and use Fundamental Library for Angular, you will first need to install the [node package manager](https://www.npmjs.com/get-npm).
+
+Fundamental Library for Angular is intended for use with Angular 15 or newer.
+
+Prior knowledge of Angular is recommended, to use the fundamental-ngx library.
+
+## <a name="3"></a>3. Versioning
+
+Check the [Breaking Changes](https://github.com/SAP/fundamental-ngx/wiki#breaking-changes) for the latest patches changes.
+
+## <a name="4"></a>4. Getting Started
+
+For an existing Angular CLI application,
+
+0. **Video tutorial**
+   [How to use the Fundamental Core Library](https://www.youtube.com/watch?v=i4VIiuzD2Fg)
+
+1. **Install Fundamental-NGX CDK.**
+   `ng add @fundamental-ngx/cdk`
+   For versions prior to 0.10 use `fundamental-ngx`
+
+    _If you do not use the Angular CLI or if this command does not work for you, please see the [full installation guide](https://github.com/SAP/fundamental-ngx/wiki/Full-Installation-Guide)._
+
+2. **Import the modules you want to use.**
+
+    To add the entire library, add the following import to your main application module.
+
+    ```typescript
+    import { FundamentalNgxCDKModule } from '@fundamental-ngx/cdk';
+
+    @NgModule({
+        ...
+        imports: [FundamentalNgxCDKModule],
+    })
+    export class DemoModule { }
+    ```
+
+    To include an individual Angular Fundamental component in your application, you only need to import the relevant module.
+
+    For example, to use Drag&Drop directive, add the following import to your main application module.
+
+    ```typescript
+    import { DragAndDropModule } from '@fundamental-ngx/cdk/utils';
+    ```
+
+## <a name="5"></a>5. Known Issues
+
+Please see [Issues](https://github.com/SAP/fundamental-ngx/issues).
+
+## <a name="6"></a>6. Support
+
+If you encounter an issue, you can [create a ticket](https://github.com/SAP/fundamental-ngx/issues).
+
+## <a name="7"></a>7. Contributing
+
+If you want to contribute, please check the [CONTRIBUTING.md](https://github.com/SAP/fundamental-ngx/blob/main/CONTRIBUTING.md) documentation for contribution guidelines. Please follow the [Angular commit message guidelines](https://github.com/angular/angular/blob/main/CONTRIBUTING.md#commit).
+
+Check out the [NEW_COMPONENT.md](https://github.com/SAP/fundamental-ngx/blob/main/NEW_COMPONENT.md) guide on building a new component for the library and creating the necessary documentation for your new component.

package/data-source/README.md

@@ -0,0 +1,7 @@
+# cdk-src-lib-data-source
+
+This library was generated with [Nx](https://nx.dev).
+
+## Running unit tests
+
+Run `nx test cdk-src-lib-data-source` to execute the unit tests.

package/data-source/base/abstract-data-provider.class.d.ts

@@ -0,0 +1,43 @@
+import { Observable } from 'rxjs';
+import { ProviderParams } from '../helpers/common';
+import { MatchBy, MatchingBy, MatchingStrategy } from '../models/matching-strategy';
+/**
+ * Base data provider class.
+ */
+export declare abstract class AbstractDataProvider<T> {
+    /** @hidden */
+    protected _keyPath: string;
+    /** @hidden */
+    protected _matchingStrategy: MatchingStrategy;
+    /** @hidden */
+    protected _matchingBy: MatchingBy | null;
+    abstract fetch(params: ProviderParams, start?: number, end?: number): Observable<T[]>;
+    /** @hidden */
+    setLookupKey(key: string): void;
+    /** @hidden */
+    setMatchingBy(matchingBy: MatchingBy): void;
+    /** @hidden */
+    setMatchingStrategy(strategy: MatchingStrategy): void;
+}
+/**
+ * Default data provider class used for other components to extend from.
+ */
+export declare class DataProvider<T> extends AbstractDataProvider<T> {
+    protected values: Observable<T[]> | T[];
+    /** @hidden */
+    constructor(values: Observable<T[]> | T[]);
+    /** @hidden */
+    fetch(params: Map<string, any>): Observable<T[]>;
+    /**
+     * Warning: If you don't supply search Key and you want fulltext search, and you use this
+     * default implementation be aware that it can  perform poorly as it is naive implementation
+     * that does not do deep compare.
+     */
+    matches(item: T, pattern: string): boolean;
+    /** @hidden */
+    matchesBy(item: any, pattern: string, matchingBy: MatchBy): boolean;
+    /** @hidden */
+    protected hasObjectValue(obj: any, pattern: string): boolean;
+    /** @hidden */
+    private withLimit;
+}

package/data-source/base/base-data-source.class.d.ts

@@ -0,0 +1,57 @@
+import { BehaviorSubject, Observable, Subject } from 'rxjs';
+import { DataSourceProvider } from '../models';
+import { AbstractDataProvider } from './abstract-data-provider.class';
+export declare abstract class BaseDataSource<T> implements DataSourceProvider<T> {
+    dataProvider: AbstractDataProvider<any>;
+    /**
+     * Max limit of items to be returned.
+     */
+    static readonly MaxLimit = 5;
+    /**
+     * Whether to enable limit of max items.
+     */
+    limitless: boolean;
+    /** @hidden */
+    protected readonly _dataChanges$: BehaviorSubject<T[]>;
+    /** @hidden */
+    protected readonly _dataRequested$: Subject<void>;
+    /** @hidden */
+    protected readonly _dataReceived$: Subject<void>;
+    /** @hidden */
+    protected readonly _destroy$: Subject<void>;
+    /** @hidden */
+    protected readonly _dataLoading$: BehaviorSubject<boolean>;
+    /**
+     * Emitted when new data has been requested.
+     * @returns Observable
+     */
+    get dataRequested(): Observable<void>;
+    /**
+     * Emitted when new data has been received.
+     * @returns Observable
+     */
+    get dataReceived(): Observable<void>;
+    /**
+     * Emitted when loading state has been changed.
+     * @returns Observable.
+     */
+    get dataLoading(): Observable<boolean>;
+    /**
+     * Emits when data from the provides has been changed.
+     * @returns Observable of data source objects.
+     */
+    get dataChanges(): Observable<T[]>;
+    /** @hidden */
+    protected constructor(dataProvider: AbstractDataProvider<any>);
+    /**
+     * Searches through the data source with defined parameters.
+     * @param predicate Search query.
+     * @param start start index.
+     * @param end end index.
+     */
+    match(predicate?: string | Map<string, string>, start?: number, end?: number): void;
+    /**
+     * Closes the stream
+     */
+    unsubscribe(): void;
+}

package/data-source/data-source.directive.d.ts

@@ -0,0 +1,47 @@
+import { EventEmitter, OnDestroy } from '@angular/core';
+import { DestroyedService } from '@fundamental-ngx/cdk/utils';
+import { BehaviorSubject } from 'rxjs';
+import { DataSource, DataSourceParser, DataSourceProvider } from './models';
+import * as i0 from "@angular/core";
+export declare class DataSourceDirective<T = any, P extends DataSourceProvider<T> = DataSourceProvider<T>> implements OnDestroy {
+    private readonly _destroyed$;
+    private readonly _dataSourceTransformer;
+    /**
+     * Data source.
+     * @param source
+     */
+    set dataSource(source: DataSource<T>);
+    get dataSource(): DataSource<T>;
+    /** @hidden */
+    private _dataSource;
+    /** @hidden */
+    dataSourceProvider: P | undefined;
+    /** @hidden */
+    private _dsSubscription;
+    /**
+     * Data stream. Emits when new data retrieved.
+     */
+    readonly dataChanged$: BehaviorSubject<T[]>;
+    /**
+     * Emits when the data source object has been changed.
+     */
+    readonly dataSourceChanged: EventEmitter<void>;
+    /**
+     * Event emitted when datasource content has been changed.
+     */
+    readonly dataChanged: EventEmitter<T[]>;
+    /**
+     * Event emitted when data provider loading state has been changed.
+     */
+    readonly isLoading: EventEmitter<boolean>;
+    /** @hidden */
+    constructor(_destroyed$: DestroyedService, _dataSourceTransformer: DataSourceParser<T, P>);
+    /** @hidden */
+    private _initializeDataSource;
+    /** @hidden */
+    ngOnDestroy(): void;
+    /** @Hidden */
+    private _toDataStream;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DataSourceDirective<any, any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DataSourceDirective<any, any>, "[fdkDataSource]", never, { "dataSource": "dataSource"; }, { "dataSourceChanged": "dataSourceChanged"; "dataChanged": "dataChanged"; "isLoading": "isLoading"; }, never, never, true, never>;
+}

package/data-source/data-source.module.d.ts

@@ -0,0 +1,7 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./data-source.directive";
+export declare class DataSourceModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<DataSourceModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<DataSourceModule, never, [typeof i1.DataSourceDirective], [typeof i1.DataSourceDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<DataSourceModule>;
+}

package/data-source/helpers/apply-datasource-directive.d.ts

@@ -0,0 +1,6 @@
+import { Type } from '@angular/core';
+export declare const applyDatasourceDirective: Type<unknown> | {
+    directive: Type<unknown>;
+    inputs?: string[];
+    outputs?: string[];
+};

package/data-source/helpers/common.d.ts

@@ -0,0 +1,7 @@
+export declare type ProviderParams = ReadonlyMap<string, any>;
+/** @Hidden */
+export declare function getMatchingStrategyStartsWithPerTermReqexp(value: string): RegExp;
+/** @hidden */
+export declare function objectValues(obj: any): any[];
+/** @hidden */
+export declare function objectToName(target: any): string;

package/data-source/helpers/is-datasource.d.ts

@@ -0,0 +1,5 @@
+import { DataSourceProvider } from '../models/data-source-provider';
+/**
+ * Checks whether passed value is a valid data source.
+ */
+export declare function isDataSource<T = any>(value: any): value is DataSourceProvider<T>;

package/data-source/index.d.ts

@@ -0,0 +1,8 @@
+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';

package/data-source/models/data-source-provider.d.ts

@@ -0,0 +1,23 @@
+import { Observable } from 'rxjs';
+/**
+ * Data source provider class controls the data stream.
+ */
+export interface DataSourceProvider<T = any> {
+    /**
+     * Closes the data stream.
+     */
+    unsubscribe(): void;
+    /**
+     * Stream emits when new data has been requested.
+     */
+    dataRequested: Observable<void>;
+    /**
+     * Stream emits when new data has been loaded.
+     */
+    dataReceived: Observable<void>;
+    /**
+     * Stream emits when loading state has been changed.
+     */
+    dataLoading: Observable<boolean>;
+    dataChanges: Observable<T[]>;
+}

package/data-source/models/data-source.d.ts

@@ -0,0 +1,16 @@
+import { Observable } from 'rxjs';
+import { DataSourceProvider } from './data-source-provider';
+/**
+ * Acceptable data source types.
+ */
+export declare type DataSource<T = any> = DataSourceProvider<T> | Observable<T[]> | T[];
+/**
+ * Data source parser is a special class that parses incoming data into appropriate data source provider.
+ */
+export interface DataSourceParser<T = any, P extends DataSourceProvider<T> = DataSourceProvider<T>> {
+    /**
+     * Defines which data provider class to initiate.
+     * @param source data source to be parsed.
+     */
+    parse(source: DataSource<T>): P | undefined;
+}

package/data-source/models/index.d.ts

@@ -0,0 +1,3 @@
+export * from './data-source';
+export * from './data-source-provider';
+export * from './matching-strategy';

package/data-source/models/matching-strategy.d.ts

@@ -0,0 +1,10 @@
+export declare enum MatchingStrategy {
+    STARTS_WITH_PER_TERM = "starts with per term",
+    STARTS_WITH = "starts with",
+    CONTAINS = "contains"
+}
+export declare type MatchBy = (item: any) => any;
+export interface MatchingBy {
+    firstBy: MatchBy;
+    secondaryBy?: MatchBy;
+}

package/data-source/tokens.d.ts

@@ -0,0 +1,6 @@
+import { InjectionToken } from '@angular/core';
+import { DataSourceParser } from './models/data-source';
+/**
+ * Injection token used for passing custom datasource transformer into DataSourceProvider.
+ */
+export declare const FD_DATA_SOURCE_TRANSFORMER: InjectionToken<DataSourceParser<any, import("@fundamental-ngx/cdk/data-source").DataSourceProvider<any>>>;

package/esm2020/data-source/base/abstract-data-provider.class.mjs

@@ -0,0 +1,126 @@
+import { isFunction, isJsObject } from '@fundamental-ngx/cdk/utils';
+import { isObservable, of } from 'rxjs';
+import { map } from 'rxjs/operators';
+import { getMatchingStrategyStartsWithPerTermReqexp, objectToName, objectValues } from '../helpers/common';
+import { MatchingStrategy } from '../models/matching-strategy';
+/**
+ * Base data provider class.
+ */
+export class AbstractDataProvider {
+    constructor() {
+        /** @hidden */
+        this._matchingStrategy = MatchingStrategy.STARTS_WITH;
+        /** @hidden */
+        this._matchingBy = null;
+    }
+    /** @hidden */
+    setLookupKey(key) {
+        this._keyPath = key;
+    }
+    /** @hidden */
+    setMatchingBy(matchingBy) {
+        this._matchingBy = matchingBy;
+    }
+    /** @hidden */
+    setMatchingStrategy(strategy) {
+        this._matchingStrategy = strategy;
+    }
+}
+/**
+ * Default data provider class used for other components to extend from.
+ */
+export class DataProvider extends AbstractDataProvider {
+    /** @hidden */
+    constructor(values) {
+        super();
+        this.values = values;
+    }
+    /** @hidden */
+    fetch(params) {
+        const observable = isObservable(this.values) ? this.values : of(this.values);
+        const queryString = params.get('query');
+        const limit = params.get('limit') || 50;
+        if (!queryString || queryString === '*') {
+            return observable.pipe(map((items) => this.withLimit(items, limit)));
+        }
+        const toLowerPattern = queryString.toLowerCase();
+        return observable.pipe(map((items) => {
+            const result = [];
+            for (let i = 0; i < items.length; i++) {
+                const item = items[i];
+                if (this.matches(item, toLowerPattern)) {
+                    result.push(item);
+                    if (result.length >= limit) {
+                        break;
+                    }
+                }
+            }
+            return result;
+        }));
+    }
+    /**
+     * Warning: If you don't supply search Key and you want fulltext search, and you use this
+     * default implementation be aware that it can  perform poorly as it is naive implementation
+     * that does not do deep compare.
+     */
+    matches(item, pattern) {
+        if (!this._matchingBy) {
+            return false;
+        }
+        const { firstBy, secondaryBy } = this._matchingBy;
+        let matched = this.matchesBy(item, pattern, firstBy);
+        if (!matched && secondaryBy) {
+            matched = this.matchesBy(item, pattern, secondaryBy);
+        }
+        return matched;
+    }
+    /** @hidden */
+    matchesBy(item, pattern, matchingBy) {
+        const value = isJsObject(item) && matchingBy ? matchingBy(item) : item;
+        if (isFunction(value)) {
+            return value.call(item);
+        }
+        else if (isJsObject(value)) {
+            return this.hasObjectValue(item, pattern);
+        }
+        else if (this._matchingStrategy === MatchingStrategy.STARTS_WITH_PER_TERM) {
+            const reqexp = getMatchingStrategyStartsWithPerTermReqexp(pattern);
+            return !!pattern && !!value && !!value.match(reqexp);
+        }
+        else if (this._matchingStrategy === MatchingStrategy.STARTS_WITH) {
+            return !!pattern && !!value && value.toString().toLowerCase().startsWith(pattern.toLowerCase());
+        }
+        else if (this._matchingStrategy === MatchingStrategy.CONTAINS) {
+            return !!pattern && !!value && value.toString().toLowerCase().indexOf(pattern) > -1;
+        }
+        else {
+            return !!pattern && !!value && value.toString().toLowerCase() === pattern;
+        }
+    }
+    /** @hidden */
+    hasObjectValue(obj, pattern) {
+        const values = objectValues(obj);
+        const parentObj = objectToName(obj);
+        const length2 = values.filter((value) => {
+            if (!value || Array.isArray(value)) {
+                return false;
+            }
+            else if (!isJsObject(value) && !isFunction(value)) {
+                return value.toString().toLowerCase().indexOf(pattern) !== -1;
+            }
+            else if (isJsObject(value) && objectToName(value) !== parentObj) {
+                return this.hasObjectValue(value, pattern);
+            }
+            return false;
+        }).length;
+        return length2 > 0;
+    }
+    /** @hidden */
+    withLimit(data, limit) {
+        if (limit && data.length > limit) {
+            return data.slice(0, limit);
+        }
+        return data;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"abstract-data-provider.class.js","sourceRoot":"","sources":["../../../../../../libs/cdk/src/lib/data-source/base/abstract-data-provider.class.ts"],"names":[],"mappings":"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","sourcesContent":["import { isFunction, isJsObject } from '@fundamental-ngx/cdk/utils';\nimport { isObservable, Observable, of } from 'rxjs';\nimport { map } from 'rxjs/operators';\nimport {\n    getMatchingStrategyStartsWithPerTermReqexp,\n    objectToName,\n    objectValues,\n    ProviderParams\n} from '../helpers/common';\nimport { MatchBy, MatchingBy, MatchingStrategy } from '../models/matching-strategy';\n\n/**\n * Base data provider class.\n */\nexport abstract class AbstractDataProvider<T> {\n    /** @hidden */\n    protected _keyPath: string;\n\n    /** @hidden */\n    protected _matchingStrategy: MatchingStrategy = MatchingStrategy.STARTS_WITH;\n\n    /** @hidden */\n    protected _matchingBy: MatchingBy | null = null;\n\n    abstract fetch(params: ProviderParams, start?: number, end?: number): Observable<T[]>;\n\n    /** @hidden */\n    setLookupKey(key: string): void {\n        this._keyPath = key;\n    }\n\n    /** @hidden */\n    setMatchingBy(matchingBy: MatchingBy): void {\n        this._matchingBy = matchingBy;\n    }\n\n    /** @hidden */\n    setMatchingStrategy(strategy: MatchingStrategy): void {\n        this._matchingStrategy = strategy;\n    }\n}\n\n/**\n * Default data provider class used for other components to extend from.\n */\nexport class DataProvider<T> extends AbstractDataProvider<T> {\n    /** @hidden */\n    constructor(protected values: Observable<T[]> | T[]) {\n        super();\n    }\n\n    /** @hidden */\n    fetch(params: Map<string, any>): Observable<T[]> {\n        const observable = isObservable(this.values) ? this.values : of(this.values);\n\n        const queryString = params.get('query');\n        const limit = params.get('limit') || 50;\n\n        if (!queryString || queryString === '*') {\n            return observable.pipe(map((items) => this.withLimit(items, limit)));\n        }\n\n        const toLowerPattern = queryString.toLowerCase();\n\n        return observable.pipe(\n            map((items) => {\n                const result: any[] = [];\n\n                for (let i = 0; i < items.length; i++) {\n                    const item = items[i];\n                    if (this.matches(item, toLowerPattern)) {\n                        result.push(item);\n                        if (result.length >= limit) {\n                            break;\n                        }\n                    }\n                }\n\n                return result;\n            })\n        );\n    }\n\n    /**\n     * Warning: If you don't supply search Key and you want fulltext search, and you use this\n     * default implementation be aware that it can  perform poorly as it is naive implementation\n     * that does not do deep compare.\n     */\n    matches(item: T, pattern: string): boolean {\n        if (!this._matchingBy) {\n            return false;\n        }\n        const { firstBy, secondaryBy } = this._matchingBy;\n\n        let matched = this.matchesBy(item, pattern, firstBy);\n        if (!matched && secondaryBy) {\n            matched = this.matchesBy(item, pattern, secondaryBy);\n        }\n\n        return matched;\n    }\n\n    /** @hidden */\n    matchesBy(item: any, pattern: string, matchingBy: MatchBy): boolean {\n        const value = isJsObject(item) && matchingBy ? matchingBy(item) : item;\n\n        if (isFunction(value)) {\n            return value.call(item);\n        } else if (isJsObject(value)) {\n            return this.hasObjectValue(item, pattern);\n        } else if (this._matchingStrategy === MatchingStrategy.STARTS_WITH_PER_TERM) {\n            const reqexp = getMatchingStrategyStartsWithPerTermReqexp(pattern);\n            return !!pattern && !!value && !!value.match(reqexp);\n        } else if (this._matchingStrategy === MatchingStrategy.STARTS_WITH) {\n            return !!pattern && !!value && value.toString().toLowerCase().startsWith(pattern.toLowerCase());\n        } else if (this._matchingStrategy === MatchingStrategy.CONTAINS) {\n            return !!pattern && !!value && value.toString().toLowerCase().indexOf(pattern) > -1;\n        } else {\n            return !!pattern && !!value && value.toString().toLowerCase() === pattern;\n        }\n    }\n\n    /** @hidden */\n    protected hasObjectValue(obj: any, pattern: string): boolean {\n        const values = objectValues(obj);\n        const parentObj = objectToName(obj);\n        const length2 = values.filter((value: any) => {\n            if (!value || Array.isArray(value)) {\n                return false;\n            } else if (!isJsObject(value) && !isFunction(value)) {\n                return value.toString().toLowerCase().indexOf(pattern) !== -1;\n            } else if (isJsObject(value) && objectToName(value) !== parentObj) {\n                return this.hasObjectValue(value, pattern);\n            }\n\n            return false;\n        }).length;\n        return length2 > 0;\n    }\n\n    /** @hidden */\n    private withLimit(data: Array<T>, limit?: number): Array<T> {\n        if (limit && data.length > limit) {\n            return data.slice(0, limit);\n        }\n        return data;\n    }\n}\n"]}

package/esm2020/data-source/base/base-data-source.class.mjs

@@ -0,0 +1,99 @@
+import { BehaviorSubject, Subject } from 'rxjs';
+import { takeUntil } from 'rxjs/operators';
+export class BaseDataSource {
+    /** @hidden */
+    constructor(dataProvider) {
+        this.dataProvider = dataProvider;
+        /**
+         * Whether to enable limit of max items.
+         */
+        this.limitless = false;
+        /** @hidden */
+        this._dataChanges$ = new BehaviorSubject([]);
+        /** @hidden */
+        this._dataRequested$ = new Subject();
+        /** @hidden */
+        this._dataReceived$ = new Subject();
+        /** @hidden */
+        this._destroy$ = new Subject();
+        /** @hidden */
+        this._dataLoading$ = new BehaviorSubject(false);
+    }
+    /**
+     * Emitted when new data has been requested.
+     * @returns Observable
+     */
+    get dataRequested() {
+        return this._dataRequested$.asObservable();
+    }
+    /**
+     * Emitted when new data has been received.
+     * @returns Observable
+     */
+    get dataReceived() {
+        return this._dataReceived$.asObservable();
+    }
+    /**
+     * Emitted when loading state has been changed.
+     * @returns Observable.
+     */
+    get dataLoading() {
+        return this._dataLoading$.asObservable();
+    }
+    /**
+     * Emits when data from the provides has been changed.
+     * @returns Observable of data source objects.
+     */
+    get dataChanges() {
+        return this._dataChanges$.asObservable().pipe(takeUntil(this._destroy$));
+    }
+    /**
+     * Searches through the data source with defined parameters.
+     * @param predicate Search query.
+     * @param start start index.
+     * @param end end index.
+     */
+    match(predicate = new Map(), start = 0, end = Infinity) {
+        this._dataRequested$.next();
+        this._dataLoading$.next(true);
+        const searchParam = new Map();
+        if (typeof predicate === 'string') {
+            searchParam.set('query', predicate);
+        }
+        else if (predicate instanceof Map) {
+            predicate.forEach((v, k) => searchParam.set(k, v));
+        }
+        else {
+            throw new Error('DataSource.match() predicate can only accepts string and Map');
+        }
+        if (!searchParam.has('limit') && !this.limitless) {
+            searchParam.set('limit', BaseDataSource.MaxLimit);
+        }
+        this.dataProvider
+            .fetch(searchParam, start, end)
+            .pipe(takeUntil(this._destroy$))
+            .subscribe({
+            next: (result) => {
+                this._dataReceived$.next();
+                this._dataLoading$.next(false);
+                this._dataChanges$.next(result);
+            },
+            error: () => {
+                this._dataReceived$.next();
+                this._dataLoading$.next(false);
+            }
+        });
+    }
+    /**
+     * Closes the stream
+     */
+    unsubscribe() {
+        this._destroy$.next();
+        this._destroy$.complete();
+    }
+}
+/**
+ * Max limit of items to be returned.
+ */
+BaseDataSource.MaxLimit = 5;
+//# sourceMappingURL=data:application/json;base64,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