igniteui-webcomponents-datasources 7.1.1-beta.2 → 7.1.1-beta.3

package/esm2022/lib/ODataVirtualDataSourceDataProvider.d.ts

@@ -0,0 +1,120 @@
+import { Base, Type } from "igniteui-webcomponents-core";
+import { IDataSourceVirtualDataProvider } from "igniteui-webcomponents-core";
+import { IDataSourcePage } from "igniteui-webcomponents-core";
+import { IDataSourceSchema } from "igniteui-webcomponents-core";
+import { IDataSourceExecutionContext } from "igniteui-webcomponents-core";
+import { IDataSourceDataProviderUpdateNotifier } from "igniteui-webcomponents-core";
+import { SortDescriptionCollection } from "igniteui-webcomponents-core";
+import { FilterExpressionCollection } from "igniteui-webcomponents-core";
+import { DataSourcePageRequestPriority } from "igniteui-webcomponents-core";
+import { DataSourceDataProviderSchemaChangedEventArgs } from "igniteui-webcomponents-core";
+import { DataSourceSchemaPropertyType } from "igniteui-webcomponents-core";
+import { SummaryDescriptionCollection } from "igniteui-webcomponents-core";
+import { DataSourceSummaryScope } from "igniteui-webcomponents-core";
+import { TransactionState } from "igniteui-webcomponents-core";
+export declare class ODataVirtualDataSourceDataProvider extends Base implements IDataSourceVirtualDataProvider {
+    static $t: Type;
+    private _worker;
+    private _requests;
+    private _callback;
+    constructor();
+    private filterExpressions_CollectionChanged;
+    private sortDescriptions_CollectionChanged;
+    private groupDescriptions_CollectionChanged;
+    private summaryDescriptions_CollectionChanged;
+    addPageRequest(pageIndex: number, priority: DataSourcePageRequestPriority): void;
+    private createWorker;
+    private valid;
+    private getWorkerSettings;
+    removePageRequest(pageIndex: number): void;
+    removeAllPageRequests(): void;
+    close(): void;
+    private _pageLoaded;
+    get pageLoaded(): (page: IDataSourcePage, currentFullCount: number, actualPageSize: number) => void;
+    set pageLoaded(value: (page: IDataSourcePage, currentFullCount: number, actualPageSize: number) => void);
+    private raisePageLoaded;
+    private killWorker;
+    private _pageSizeRequested;
+    get pageSizeRequested(): number;
+    set pageSizeRequested(value: number);
+    private _baseUri;
+    get baseUri(): string;
+    set baseUri(value: string);
+    private _entitySet;
+    get entitySet(): string;
+    set entitySet(value: string);
+    private _timeoutMilliseconds;
+    get timeoutMilliseconds(): number;
+    set timeoutMilliseconds(value: number);
+    getItemValue(item: any, valueName: string): any;
+    setItemValue(item: any, valueName: string, value: any): void;
+    removeItem(item: any): void;
+    addItem(item: any): void;
+    schemaChanged: (sender: any, args: DataSourceDataProviderSchemaChangedEventArgs) => void;
+    private _currentFullCount;
+    private _currentSchema;
+    get actualCount(): number;
+    get actualSchema(): IDataSourceSchema;
+    private _executionContext;
+    get executionContext(): IDataSourceExecutionContext;
+    set executionContext(value: IDataSourceExecutionContext);
+    private _updateNotifier;
+    get updateNotifier(): IDataSourceDataProviderUpdateNotifier;
+    set updateNotifier(value: IDataSourceDataProviderUpdateNotifier);
+    private _deferAutoRefresh;
+    get deferAutoRefresh(): boolean;
+    set deferAutoRefresh(value: boolean);
+    get isSortingSupported(): boolean;
+    get isGroupingSupported(): boolean;
+    get isFilteringSupported(): boolean;
+    private _isAggregationSupported;
+    get isAggregationSupported(): boolean;
+    set isAggregationSupported(isSupported: boolean);
+    private _sortDescriptions;
+    get sortDescriptions(): SortDescriptionCollection;
+    private _groupDescriptions;
+    get groupDescriptions(): SortDescriptionCollection;
+    private _propertiesRequested;
+    get propertiesRequested(): string[];
+    set propertiesRequested(value: string[]);
+    private _schemaIncludedProperties;
+    get schemaIncludedProperties(): string[];
+    set schemaIncludedProperties(value: string[]);
+    private _filterExpressions;
+    get filterExpressions(): FilterExpressionCollection;
+    private _summaryDescriptions;
+    get summaryDescriptions(): SummaryDescriptionCollection;
+    private _summaryScope;
+    get summaryScope(): DataSourceSummaryScope;
+    set summaryScope(value: DataSourceSummaryScope);
+    private _enableJsonp;
+    get enableJsonp(): boolean;
+    set enableJsonp(isEnabled: boolean);
+    get notifyUsingSourceIndexes(): boolean;
+    get isItemIndexLookupSupported(): boolean;
+    get isKeyIndexLookupSupported(): boolean;
+    notifySetItem(index: number, oldItem: any, newItem: any): void;
+    notifyClearItems(): void;
+    notifyInsertItem(index: number, newItem: any): void;
+    notifyRemoveItem(index: number, oldItem: any): void;
+    _schemaFetchQueued: boolean;
+    queueSchemaFetch(): void;
+    doSchemaFetchInternal(): void;
+    schemaFetchInternal(): void;
+    protected schemaFetchInternalOverride(): void;
+    private addSchemaRequest;
+    _autoRefreshQueued: boolean;
+    queueAutoRefresh(): void;
+    doRefreshInternal(): void;
+    refreshInternal(): void;
+    protected refreshInternalOverride(): void;
+    flushAutoRefresh(): void;
+    refresh(): void;
+    indexOfItem(item: any): number;
+    indexOfKey(key: any[]): number;
+    resolveSchemaPropertyType(propertyPath: string): DataSourceSchemaPropertyType;
+    createBatchRequest(changes: TransactionState[]): void;
+    private _batchCompleted;
+    get batchCompleted(): (success: boolean, requiresRefresh: boolean) => void;
+    set batchCompleted(value: (success: boolean, requiresRefresh: boolean) => void);
+}

package/esm2022/lib/ODataVirtualDataSourceDataProvider.js

@@ -0,0 +1,450 @@
+import { Base, runOn, markType } from "igniteui-webcomponents-core";
+import { IDataSourceVirtualDataProvider_$type } from "igniteui-webcomponents-core";
+import { SortDescriptionCollection } from "igniteui-webcomponents-core";
+import { FilterExpressionCollection } from "igniteui-webcomponents-core";
+import { LinkedList } from "./util";
+import { DataSourcePageRequestPriority } from "igniteui-webcomponents-core";
+import { ODataVirtualDataSourceDataProviderWorker } from "./ODataVirtualDataSourceDataProviderWorker";
+import { ODataVirtualDataSourceDataProviderWorkerSettings } from "./ODataVirtualDataSourceDataProviderWorkerSettings";
+import { DataSourceDataProviderSchemaChangedEventArgs } from "igniteui-webcomponents-core";
+import { DataSourceSchemaPropertyType } from "igniteui-webcomponents-core";
+import { stringContains } from "igniteui-webcomponents-core";
+import { SummaryDescriptionCollection } from "igniteui-webcomponents-core";
+class ODataVirtualDataSourceDataProvider extends Base {
+    static { this.$t = markType(ODataVirtualDataSourceDataProvider, 'ODataVirtualDataSourceDataProvider', Base.$type, [IDataSourceVirtualDataProvider_$type]); }
+    constructor() {
+        super();
+        this._worker = null;
+        this._requests = new LinkedList();
+        this._callback = null;
+        this._pageLoaded = null;
+        this._pageSizeRequested = 50;
+        this._baseUri = null;
+        this._entitySet = null;
+        this._timeoutMilliseconds = 10000;
+        this.schemaChanged = null;
+        this._currentFullCount = 0;
+        this._currentSchema = null;
+        this._executionContext = null;
+        this._updateNotifier = null;
+        this._deferAutoRefresh = false;
+        this._sortDescriptions = null;
+        this._groupDescriptions = null;
+        this._propertiesRequested = null;
+        this._schemaIncludedProperties = null;
+        this._filterExpressions = null;
+        this._summaryDescriptions = null;
+        this._enableJsonp = true;
+        this._schemaFetchQueued = false;
+        this._autoRefreshQueued = false;
+        this._batchCompleted = null;
+        this._sortDescriptions = new SortDescriptionCollection();
+        this._sortDescriptions.onChanged = () => this.sortDescriptions_CollectionChanged(null, null);
+        this._groupDescriptions = new SortDescriptionCollection();
+        this._groupDescriptions.onChanged = () => this.groupDescriptions_CollectionChanged(null, null);
+        this._filterExpressions = new FilterExpressionCollection();
+        this._filterExpressions.onChanged = () => this.filterExpressions_CollectionChanged(null, null);
+        this._summaryDescriptions = new SummaryDescriptionCollection();
+        this._summaryDescriptions.onChanged = () => this.summaryDescriptions_CollectionChanged(null, null);
+    }
+    filterExpressions_CollectionChanged(sender, e) {
+        this.queueAutoRefresh();
+    }
+    sortDescriptions_CollectionChanged(sender, e) {
+        this.queueAutoRefresh();
+    }
+    groupDescriptions_CollectionChanged(sender, e) {
+        this.queueAutoRefresh();
+    }
+    summaryDescriptions_CollectionChanged(sender, e) {
+        this.queueAutoRefresh();
+    }
+    addPageRequest(pageIndex, priority) {
+        if (this.deferAutoRefresh) {
+            return;
+        }
+        if (this._worker != null && this._worker.isShutdown) {
+            this._worker = null;
+            this._callback = null;
+        }
+        if (this._worker == null) {
+            this.createWorker();
+        }
+        if (priority == DataSourcePageRequestPriority.High) {
+            this._requests.addFirst(pageIndex);
+        }
+        else {
+            this._requests.addLast(pageIndex);
+        }
+        if (!this._worker.addPageRequest(pageIndex, priority)) {
+            this._worker = null;
+            this._callback = null;
+            this.addPageRequest(pageIndex, priority);
+        }
+    }
+    createWorker() {
+        if (!this.valid()) {
+            return;
+        }
+        this._callback = runOn(this, this.raisePageLoaded);
+        let settings = this.getWorkerSettings();
+        this._worker = new ODataVirtualDataSourceDataProviderWorker(settings);
+    }
+    valid() {
+        return this.entitySet != null && this.baseUri != null;
+    }
+    getWorkerSettings() {
+        return ((() => {
+            let $ret = new ODataVirtualDataSourceDataProviderWorkerSettings();
+            $ret.baseUri = this._baseUri;
+            $ret.entitySet = this._entitySet;
+            $ret.pageSizeRequested = this._pageSizeRequested;
+            $ret.timeoutMilliseconds = this._timeoutMilliseconds;
+            $ret.pageLoaded = this._callback;
+            $ret.batchCompleted = this._batchCompleted;
+            $ret.executionContext = this._executionContext;
+            $ret.sortDescriptions = this._sortDescriptions;
+            $ret.groupDescriptions = this._groupDescriptions;
+            $ret.filterExpressions = this._filterExpressions;
+            $ret.propertiesRequested = this._propertiesRequested;
+            $ret.schemaIncludedProperties = this._schemaIncludedProperties;
+            $ret.summaryDescriptions = this._summaryDescriptions;
+            $ret.summaryScope = this._summaryScope;
+            $ret.enableJsonp = this._enableJsonp;
+            $ret.isAggregationSupported = this.isAggregationSupported;
+            return $ret;
+        })());
+    }
+    removePageRequest(pageIndex) {
+        let current = this._requests.first;
+        while (current != null) {
+            if (current.value == pageIndex) {
+                this._requests.remove(current);
+            }
+            current = current.next;
+        }
+        if (this._worker == null) {
+            return;
+        }
+        this._worker.removePageRequest(pageIndex);
+    }
+    removeAllPageRequests() {
+        this._requests.clear();
+        if (this._worker == null) {
+            return;
+        }
+        this._worker.removeAllPageRequests();
+    }
+    close() {
+        if (this._worker != null) {
+            this._worker.shutdown();
+            this._worker = null;
+            this._callback = null;
+        }
+    }
+    get pageLoaded() {
+        return this._pageLoaded;
+    }
+    set pageLoaded(value) {
+        this._pageLoaded = value;
+        this.queueAutoRefresh();
+    }
+    raisePageLoaded(page, fullCount, actualPageSize) {
+        if (this._pageLoaded != null) {
+            this._currentFullCount = fullCount;
+            if (this._currentSchema == null) {
+                let currentSchema = null;
+                if (page != null) {
+                    currentSchema = page.schema();
+                }
+                this._currentSchema = currentSchema;
+                if (this.schemaChanged != null) {
+                    this.schemaChanged(this, new DataSourceDataProviderSchemaChangedEventArgs(this._currentSchema, this._currentFullCount));
+                }
+            }
+            if (page.pageIndex() != ODataVirtualDataSourceDataProviderWorker.schemaRequestIndex) {
+                this._pageLoaded(page, fullCount, actualPageSize);
+            }
+        }
+    }
+    killWorker() {
+        if (this._worker != null) {
+            this._worker.shutdown();
+            this._worker = null;
+            this._callback = null;
+        }
+    }
+    get pageSizeRequested() {
+        return this._pageSizeRequested;
+    }
+    set pageSizeRequested(value) {
+        this._pageSizeRequested = value;
+        this.queueAutoRefresh();
+    }
+    get baseUri() {
+        return this._baseUri;
+    }
+    set baseUri(value) {
+        let oldValue = this._baseUri;
+        this._baseUri = value;
+        if (oldValue != this._baseUri) {
+            this.queueAutoRefresh();
+            if (this.valid() && this.deferAutoRefresh) {
+                this.queueSchemaFetch();
+            }
+        }
+    }
+    get entitySet() {
+        return this._entitySet;
+    }
+    set entitySet(value) {
+        let oldValue = this._entitySet;
+        this._entitySet = value;
+        if (oldValue != this._entitySet) {
+            this.queueAutoRefresh();
+            if (this.valid() && this.deferAutoRefresh) {
+                this.queueSchemaFetch();
+            }
+        }
+    }
+    get timeoutMilliseconds() {
+        return this._timeoutMilliseconds;
+    }
+    set timeoutMilliseconds(value) {
+        this._timeoutMilliseconds = value;
+        this.queueAutoRefresh();
+    }
+    getItemValue(item, valueName) {
+        let dic = item;
+        if (dic.has(valueName)) {
+            return dic.get(valueName);
+        }
+        else {
+            return null;
+        }
+    }
+    setItemValue(item, valueName, value) {
+        // does nothing for virtual data.
+    }
+    removeItem(item) {
+        // does nothing for virtual data.
+    }
+    addItem(item) {
+        // does nothing for virtual data.
+    }
+    get actualCount() {
+        return this._currentFullCount;
+    }
+    get actualSchema() {
+        return this._currentSchema;
+    }
+    get executionContext() {
+        return this._executionContext;
+    }
+    set executionContext(value) {
+        this._executionContext = value;
+        this.queueAutoRefresh();
+    }
+    get updateNotifier() {
+        return this._updateNotifier;
+    }
+    set updateNotifier(value) {
+        this._updateNotifier = value;
+    }
+    get deferAutoRefresh() {
+        return this._deferAutoRefresh;
+    }
+    set deferAutoRefresh(value) {
+        this._deferAutoRefresh = value;
+        if (!this._deferAutoRefresh) {
+            this.queueAutoRefresh();
+        }
+        if (this._deferAutoRefresh && this.valid() && this._currentSchema == null) {
+            this.queueSchemaFetch();
+        }
+    }
+    get isSortingSupported() {
+        return true;
+    }
+    get isGroupingSupported() {
+        return this.isAggregationSupported;
+    }
+    get isFilteringSupported() {
+        return true;
+    }
+    get isAggregationSupported() {
+        return this._isAggregationSupported;
+    }
+    set isAggregationSupported(isSupported) {
+        this._isAggregationSupported = isSupported;
+    }
+    get sortDescriptions() {
+        return this._sortDescriptions;
+    }
+    get groupDescriptions() {
+        return this._groupDescriptions;
+    }
+    get propertiesRequested() {
+        return this._propertiesRequested;
+    }
+    set propertiesRequested(value) {
+        this._propertiesRequested = value;
+        this.queueAutoRefresh();
+    }
+    get schemaIncludedProperties() {
+        return this._schemaIncludedProperties;
+    }
+    set schemaIncludedProperties(value) {
+        this._schemaIncludedProperties = value;
+        this.queueAutoRefresh();
+    }
+    get filterExpressions() {
+        return this._filterExpressions;
+    }
+    get summaryDescriptions() {
+        return this._summaryDescriptions;
+    }
+    get summaryScope() {
+        return this._summaryScope;
+    }
+    set summaryScope(value) {
+        this._summaryScope = value;
+    }
+    get enableJsonp() {
+        return this._enableJsonp;
+    }
+    set enableJsonp(isEnabled) {
+        this._enableJsonp = isEnabled;
+    }
+    get notifyUsingSourceIndexes() {
+        return true;
+    }
+    get isItemIndexLookupSupported() {
+        return false;
+    }
+    get isKeyIndexLookupSupported() {
+        return false;
+    }
+    notifySetItem(index, oldItem, newItem) {
+        if (this.updateNotifier != null) {
+            this.updateNotifier.notifySetItem(index, oldItem, newItem);
+        }
+    }
+    notifyClearItems() {
+        if (this.updateNotifier != null) {
+            this.updateNotifier.notifyClearItems();
+        }
+    }
+    notifyInsertItem(index, newItem) {
+        if (this.updateNotifier != null) {
+            this.updateNotifier.notifyInsertItem(index, newItem);
+        }
+    }
+    notifyRemoveItem(index, oldItem) {
+        if (this.updateNotifier != null) {
+            this.updateNotifier.notifyRemoveItem(index, oldItem);
+        }
+    }
+    queueSchemaFetch() {
+        if (this._schemaFetchQueued) {
+            return;
+        }
+        if (this.executionContext != null) {
+            this._schemaFetchQueued = true;
+            this.executionContext.enqueueAction(runOn(this, this.doSchemaFetchInternal));
+        }
+    }
+    doSchemaFetchInternal() {
+        if (!this._schemaFetchQueued) {
+            return;
+        }
+        this._schemaFetchQueued = false;
+        this.schemaFetchInternal();
+    }
+    schemaFetchInternal() {
+        this.schemaFetchInternalOverride();
+    }
+    schemaFetchInternalOverride() {
+        if (!this.deferAutoRefresh) {
+            return;
+        }
+        this.removeAllPageRequests();
+        this.killWorker();
+        this.createWorker();
+        this.addSchemaRequest();
+    }
+    addSchemaRequest() {
+        this._worker.addPageRequest(ODataVirtualDataSourceDataProviderWorker.schemaRequestIndex, DataSourcePageRequestPriority.High);
+    }
+    queueAutoRefresh() {
+        if (this.deferAutoRefresh) {
+            return;
+        }
+        if (this._autoRefreshQueued) {
+            return;
+        }
+        if (this.executionContext != null) {
+            this._autoRefreshQueued = true;
+            this.executionContext.enqueueAction(runOn(this, this.doRefreshInternal));
+        }
+    }
+    doRefreshInternal() {
+        if (this.deferAutoRefresh) {
+            this._autoRefreshQueued = false;
+            return;
+        }
+        if (!this._autoRefreshQueued) {
+            return;
+        }
+        this._autoRefreshQueued = false;
+        this.refreshInternal();
+    }
+    refreshInternal() {
+        this.refreshInternalOverride();
+    }
+    refreshInternalOverride() {
+        this.removeAllPageRequests();
+        this.killWorker();
+        this.createWorker();
+        this._worker.addPageRequest(0, DataSourcePageRequestPriority.Normal);
+    }
+    flushAutoRefresh() {
+        this.doRefreshInternal();
+    }
+    refresh() {
+        this.refreshInternal();
+    }
+    indexOfItem(item) {
+        return -1;
+    }
+    indexOfKey(key) {
+        return -1;
+    }
+    resolveSchemaPropertyType(propertyPath) {
+        if (this.actualSchema == null) {
+            return DataSourceSchemaPropertyType.ObjectValue;
+        }
+        if (stringContains(propertyPath, ".")) {
+            return DataSourceSchemaPropertyType.ObjectValue;
+        }
+        for (let i = 0; i < this.actualSchema.propertyNames.length; i++) {
+            let name = this.actualSchema.propertyNames[i];
+            if (name == propertyPath) {
+                return this.actualSchema.propertyTypes[i];
+            }
+        }
+        return DataSourceSchemaPropertyType.ObjectValue;
+    }
+    createBatchRequest(changes) {
+        if (this._worker) {
+            this._worker.createBatchRequest(changes);
+        }
+    }
+    get batchCompleted() {
+        return this._batchCompleted;
+    }
+    set batchCompleted(value) {
+        this._batchCompleted = value;
+    }
+}
+export { ODataVirtualDataSourceDataProvider };

package/esm2022/lib/ODataVirtualDataSourceDataProviderWorker.d.ts

@@ -0,0 +1,57 @@
+import { AsyncVirtualDataSourceProviderWorker } from "igniteui-webcomponents-core";
+import { SortDescriptionCollection } from "igniteui-webcomponents-core";
+import { FilterExpressionCollection } from "igniteui-webcomponents-core";
+import { AsyncVirtualDataSourceProviderTaskDataHolder } from "igniteui-webcomponents-core";
+import { ODataVirtualDataSourceDataProviderWorkerSettings } from "./ODataVirtualDataSourceDataProviderWorkerSettings";
+import { AsyncDataSourcePageTaskHolder } from "igniteui-webcomponents-core";
+import { AsyncDataSourcePageRequest } from "igniteui-webcomponents-core";
+import { TransactionState } from "igniteui-webcomponents-core";
+export declare class ODataVirtualDataSourceDataProviderWorker extends AsyncVirtualDataSourceProviderWorker {
+    private _baseUri;
+    private _entitySet;
+    private _sortDescriptions;
+    private _groupDescriptions;
+    private _filterExpressions;
+    private _summaryDescriptions;
+    private _summaryScope;
+    private _desiredPropeties;
+    private _schemaIncludedProperties;
+    private _enableJsonp;
+    private _isAggregationSupported;
+    protected get sortDescriptions(): SortDescriptionCollection;
+    protected get filterExpressions(): FilterExpressionCollection;
+    protected get desiredProperties(): string[];
+    protected initialize(): void;
+    protected getTaskDataHolder(): AsyncVirtualDataSourceProviderTaskDataHolder;
+    protected getCompletedTaskData(holder: AsyncVirtualDataSourceProviderTaskDataHolder, completed: number): void;
+    protected removeCompletedTaskData(holder: AsyncVirtualDataSourceProviderTaskDataHolder, completed: number): void;
+    protected getTasksData(holder: AsyncVirtualDataSourceProviderTaskDataHolder): void;
+    private iter;
+    private iterFilter;
+    private iterSummaries;
+    constructor(settings: ODataVirtualDataSourceDataProviderWorkerSettings);
+    protected processCompletedTask(completedTask: AsyncDataSourcePageTaskHolder, currentDelay: number, pageIndex: number, taskDataHolder: AsyncVirtualDataSourceProviderTaskDataHolder): void;
+    private _groupInformation;
+    private _summaryInformation;
+    private finishProcessingCompletedTask;
+    private resolveGroupInformation;
+    private groupError;
+    private groupSuccess;
+    private addGroup;
+    private resolveSummaryInformation;
+    private summarySuccess;
+    private summaryError;
+    private getSummaryQueryParameters;
+    private createSummaryResults;
+    private resolveSchema;
+    private _filterString;
+    private _selectedString;
+    static readonly schemaRequestIndex: number;
+    protected makeTaskForRequest(request: AsyncDataSourcePageRequest, retryDelay: number): void;
+    private updateFilterString;
+    private executeRequest;
+    private success;
+    private error;
+    createBatchRequest(changes: TransactionState[]): void;
+    private getRequestUriWithKey;
+}