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

package/esm2022/lib/RestVirtualDataSourceDataProviderWorkerSettings.d.ts

@@ -0,0 +1,93 @@
+import { AsyncVirtualDataSourceDataProviderWorkerSettings } from "igniteui-webcomponents-core";
+import { SortDescriptionCollection } from "igniteui-webcomponents-core";
+import { FilterExpressionCollection } from "igniteui-webcomponents-core";
+import { Type } from "igniteui-webcomponents-core";
+import { SummaryDescriptionCollection } from "igniteui-webcomponents-core";
+import { DataSourceSummaryScope } from "igniteui-webcomponents-core";
+export declare class RestVirtualDataSourceDataProviderWorkerSettings extends AsyncVirtualDataSourceDataProviderWorkerSettings {
+    static $t: Type;
+    private _baseUri;
+    get baseUri(): string;
+    set baseUri(value: string);
+    private _entitySet;
+    get entitySet(): string;
+    set entitySet(value: string);
+    private _sortDescriptions;
+    get sortDescriptions(): SortDescriptionCollection;
+    set sortDescriptions(value: SortDescriptionCollection);
+    private _filterExpressions;
+    get filterExpressions(): FilterExpressionCollection;
+    set filterExpressions(value: FilterExpressionCollection);
+    private _propertiesRequested;
+    get propertiesRequested(): string[];
+    set propertiesRequested(value: string[]);
+    private _schemaIncludedProperties;
+    get schemaIncludedProperties(): string[];
+    set schemaIncludedProperties(value: string[]);
+    private _groupDescriptions;
+    get groupDescriptions(): SortDescriptionCollection;
+    set groupDescriptions(value: SortDescriptionCollection);
+    private _summaryDescriptions;
+    get summaryDescriptions(): SummaryDescriptionCollection;
+    set summaryDescriptions(value: SummaryDescriptionCollection);
+    private _summaryscope;
+    get summaryScope(): DataSourceSummaryScope;
+    set summaryScope(value: DataSourceSummaryScope);
+    private _enableJsonp;
+    get enableJsonp(): boolean;
+    set enableJsonp(isEnabled: boolean);
+    private _isAggregationSupported;
+    get isAggregationSupported(): boolean;
+    set isAggregationSupported(isSupported: boolean);
+    private _fixedFullCount;
+    get fixedFullCount(): number;
+    set fixedFullCount(value: number);
+    private _provideFullCount;
+    get provideFullCount(): (page: any) => number;
+    set provideFullCount(value: (page: any) => number);
+    private _provideOrderByParameter;
+    get provideOrderByParameter(): (args: any[], orderByString: string, orderBy: SortDescriptionCollection) => any;
+    set provideOrderByParameter(value: (args: any[], orderByString: string, orderBy: SortDescriptionCollection) => any);
+    private _provideFilterParameter;
+    get provideFilterParameter(): (args: any[], filterString: string, filterExpressions: FilterExpressionCollection) => any;
+    set provideFilterParameter(value: (args: any[], filterString: string, filterExpressions: FilterExpressionCollection) => any);
+    private _provideAggregationParameter;
+    get provideAggregationParameter(): (args: any[], fetchCountOnly: boolean, groupByString: string, groupBy: SortDescriptionCollection, summaryString: string, summary: SummaryDescriptionCollection) => any;
+    set provideAggregationParameter(value: (args: any[], fetchCountOnly: boolean, groupByString: string, groupBy: SortDescriptionCollection, summaryString: string, summary: SummaryDescriptionCollection) => any);
+    private _provideAggregatedCount;
+    get provideAggregatedCount(): (item: any) => number;
+    set provideAggregatedCount(value: (item: any) => number);
+    private _provideUri;
+    get provideUri(): (baseUri: string, entitySet: string, args: {
+        name: string;
+        value: any;
+    }[]) => string;
+    set provideUri(value: (baseUri: string, entitySet: string, args: {
+        name: string;
+        value: any;
+    }[]) => string);
+    private _providePagingParameter;
+    get providePagingParameter(): (args: any[], skip: number, take: number) => void;
+    set providePagingParameter(value: (args: any[], skip: number, take: number) => void);
+    private _provideDesiredPropertiesParameter;
+    get provideDesiredPropertiesParameter(): (args: any[], selectString: string, desiredProperties: string[]) => void;
+    set provideDesiredPropertiesParameter(value: (args: any[], selectString: string, desiredProperties: string[]) => void);
+    private _provideItems;
+    get provideItems(): (result: any) => any[];
+    set provideItems(value: (result: any) => any[]);
+    private _performFetch;
+    get performFetch(): (request: {
+        requestUri: string;
+        enableJsonpCallback: boolean;
+        method: 'GET';
+        headers: any;
+        data: null;
+    }, success: (data: any, response: any) => void, failure: (err: any) => void) => void;
+    set performFetch(value: (request: {
+        requestUri: string;
+        enableJsonpCallback: boolean;
+        method: 'GET';
+        headers: any;
+        data: null;
+    }, success: (data: any, response: any) => void, failure: (err: any) => void) => void);
+}

package/esm2022/lib/RestVirtualDataSourceDataProviderWorkerSettings.js

@@ -0,0 +1,159 @@
+import { AsyncVirtualDataSourceDataProviderWorkerSettings } from "igniteui-webcomponents-core";
+import { markType } from "igniteui-webcomponents-core";
+class RestVirtualDataSourceDataProviderWorkerSettings extends AsyncVirtualDataSourceDataProviderWorkerSettings {
+    constructor() {
+        super(...arguments);
+        this._baseUri = null;
+        this._entitySet = null;
+        this._sortDescriptions = null;
+        this._filterExpressions = null;
+        this._propertiesRequested = null;
+        this._schemaIncludedProperties = null;
+        this._groupDescriptions = null;
+        this._summaryDescriptions = null;
+        this._fixedFullCount = -1;
+        this._provideFullCount = null;
+        this._provideOrderByParameter = null;
+        this._provideFilterParameter = null;
+        this._provideAggregationParameter = null;
+        this._provideAggregatedCount = null;
+        this._provideUri = null;
+        this._providePagingParameter = null;
+        this._provideDesiredPropertiesParameter = null;
+        this._performFetch = null;
+    }
+    static { this.$t = markType(RestVirtualDataSourceDataProviderWorkerSettings, 'RestVirtualDataSourceDataProviderWorkerSettings', AsyncVirtualDataSourceDataProviderWorkerSettings.$type); }
+    get baseUri() {
+        return this._baseUri;
+    }
+    set baseUri(value) {
+        this._baseUri = value;
+    }
+    get entitySet() {
+        return this._entitySet;
+    }
+    set entitySet(value) {
+        this._entitySet = value;
+    }
+    get sortDescriptions() {
+        return this._sortDescriptions;
+    }
+    set sortDescriptions(value) {
+        this._sortDescriptions = value;
+    }
+    get filterExpressions() {
+        return this._filterExpressions;
+    }
+    set filterExpressions(value) {
+        this._filterExpressions = value;
+    }
+    get propertiesRequested() {
+        return this._propertiesRequested;
+    }
+    set propertiesRequested(value) {
+        this._propertiesRequested = value;
+    }
+    get schemaIncludedProperties() {
+        return this._schemaIncludedProperties;
+    }
+    set schemaIncludedProperties(value) {
+        this._schemaIncludedProperties = value;
+    }
+    get groupDescriptions() {
+        return this._groupDescriptions;
+    }
+    set groupDescriptions(value) {
+        this._groupDescriptions = value;
+    }
+    get summaryDescriptions() {
+        return this._summaryDescriptions;
+    }
+    set summaryDescriptions(value) {
+        this._summaryDescriptions = value;
+    }
+    get summaryScope() {
+        return this._summaryscope;
+    }
+    set summaryScope(value) {
+        this._summaryscope = value;
+    }
+    get enableJsonp() {
+        return this._enableJsonp;
+    }
+    set enableJsonp(isEnabled) {
+        this._enableJsonp = isEnabled;
+    }
+    get isAggregationSupported() {
+        return this._isAggregationSupported;
+    }
+    set isAggregationSupported(isSupported) {
+        this._isAggregationSupported = isSupported;
+    }
+    get fixedFullCount() {
+        return this._fixedFullCount;
+    }
+    set fixedFullCount(value) {
+        this._fixedFullCount = value;
+    }
+    get provideFullCount() {
+        return this._provideFullCount;
+    }
+    set provideFullCount(value) {
+        this._provideFullCount = value;
+    }
+    get provideOrderByParameter() {
+        return this._provideOrderByParameter;
+    }
+    set provideOrderByParameter(value) {
+        this._provideOrderByParameter = value;
+    }
+    get provideFilterParameter() {
+        return this._provideFilterParameter;
+    }
+    set provideFilterParameter(value) {
+        this._provideFilterParameter = value;
+    }
+    get provideAggregationParameter() {
+        return this._provideAggregationParameter;
+    }
+    set provideAggregationParameter(value) {
+        this._provideAggregationParameter = value;
+    }
+    get provideAggregatedCount() {
+        return this._provideAggregatedCount;
+    }
+    set provideAggregatedCount(value) {
+        this._provideAggregatedCount = value;
+    }
+    get provideUri() {
+        return this._provideUri;
+    }
+    set provideUri(value) {
+        this._provideUri = value;
+    }
+    get providePagingParameter() {
+        return this._providePagingParameter;
+    }
+    set providePagingParameter(value) {
+        this._providePagingParameter = value;
+    }
+    get provideDesiredPropertiesParameter() {
+        return this._provideDesiredPropertiesParameter;
+    }
+    set provideDesiredPropertiesParameter(value) {
+        this._provideDesiredPropertiesParameter = value;
+    }
+    get provideItems() {
+        return this._provideItems;
+    }
+    set provideItems(value) {
+        this._provideItems = value;
+    }
+    get performFetch() {
+        return this._performFetch;
+    }
+    set performFetch(value) {
+        this._performFetch = value;
+    }
+}
+export { RestVirtualDataSourceDataProviderWorkerSettings };

package/esm2022/lib/RestVirtualDataSourcePage.d.ts

@@ -0,0 +1,19 @@
+import { IDataSourcePage } from "igniteui-webcomponents-core";
+import { IDataSourceSchema } from "igniteui-webcomponents-core";
+import { ISectionInformation } from "igniteui-webcomponents-core";
+import { ISummaryResult } from "igniteui-webcomponents-core";
+export declare class RestVirtualDataSourcePage implements IDataSourcePage {
+    private _actualData;
+    private _schema;
+    private _pageIndex;
+    private _groupInformation;
+    private _summaryInformation;
+    constructor(sourceData_: any, schema: IDataSourceSchema, groupInformation: ISectionInformation[], summaryInformation: ISummaryResult[], pageIndex: number);
+    count(): number;
+    getItemAtIndex(index: number): any;
+    getItemValueAtIndex(index: number, valueName: string): any;
+    pageIndex(): number;
+    schema(): IDataSourceSchema;
+    getGroupInformation(): ISectionInformation[];
+    getSummaryInformation(): ISummaryResult[];
+}

package/esm2022/lib/RestVirtualDataSourcePage.js

@@ -0,0 +1,67 @@
+import { DataSourceSchemaPropertyType } from "igniteui-webcomponents-core";
+export class RestVirtualDataSourcePage {
+    constructor(sourceData_, schema, groupInformation, summaryInformation, pageIndex) {
+        this._actualData = null;
+        this._schema = null;
+        this._pageIndex = 0;
+        this._groupInformation = null;
+        this._summaryInformation = null;
+        if (sourceData_ == null) {
+            this._actualData = null;
+        }
+        else {
+            let count = (sourceData_.items.length);
+            this._actualData = [];
+            let dateProps = new Set();
+            for (let i = 0; i < schema.propertyNames.length; i++) {
+                if (schema.propertyTypes[i] == DataSourceSchemaPropertyType.DateTimeValue || schema.propertyTypes[i] == DataSourceSchemaPropertyType.DateTimeOffsetValue) {
+                    dateProps.add(schema.propertyNames[i]);
+                }
+            }
+            let value_;
+            for (let i_ = 0; i_ < count; i_++) {
+                let currItem_ = sourceData_.items[i_];
+                let dict = new Map();
+                let properties = Array.from(Object.keys(currItem_));
+                let values = (properties.map((k) => currItem_[k]));
+                for (let i1 = 0; i1 < properties.length; i1++) {
+                    value_ = values[i1];
+                    if (dateProps.has(properties[i1])) {
+                        value_ = new Date(value_);
+                    }
+                    dict.set(properties[i1], value_);
+                }
+                this._actualData[i_] = dict;
+            }
+        }
+        this._schema = schema;
+        this._groupInformation = groupInformation;
+        this._summaryInformation = summaryInformation;
+        this._pageIndex = pageIndex;
+    }
+    count() {
+        return this._actualData.length;
+    }
+    getItemAtIndex(index) {
+        return this._actualData[index];
+    }
+    getItemValueAtIndex(index, valueName) {
+        let item = this._actualData[index];
+        if (!item.has(valueName)) {
+            return null;
+        }
+        return item.get(valueName);
+    }
+    pageIndex() {
+        return this._pageIndex;
+    }
+    schema() {
+        return this._schema;
+    }
+    getGroupInformation() {
+        return this._groupInformation;
+    }
+    getSummaryInformation() {
+        return this._summaryInformation;
+    }
+}

package/esm2022/lib/RestVirtualDataSourceProviderTaskDataHolder.d.ts

@@ -0,0 +1,5 @@
+import { AsyncVirtualDataSourceProviderTaskDataHolder } from "igniteui-webcomponents-core";
+import { Type } from "igniteui-webcomponents-core";
+export declare class RestVirtualDataSourceProviderTaskDataHolder extends AsyncVirtualDataSourceProviderTaskDataHolder {
+    static $t: Type;
+}

package/esm2022/lib/RestVirtualDataSourceProviderTaskDataHolder.js

@@ -0,0 +1,6 @@
+import { AsyncVirtualDataSourceProviderTaskDataHolder } from "igniteui-webcomponents-core";
+import { markType } from "igniteui-webcomponents-core";
+class RestVirtualDataSourceProviderTaskDataHolder extends AsyncVirtualDataSourceProviderTaskDataHolder {
+    static { this.$t = markType(RestVirtualDataSourceProviderTaskDataHolder, 'ODataVirtualDataSourceProviderTaskDataHolder', AsyncVirtualDataSourceProviderTaskDataHolder.$type); }
+}
+export { RestVirtualDataSourceProviderTaskDataHolder };

package/esm2022/lib/Schema.d.ts

@@ -0,0 +1,15 @@
+import { Entity } from "./Entity";
+import { EntitySet } from "./EntitySet";
+import { XElement } from "igniteui-webcomponents-core";
+export declare class Schema {
+    private _entities;
+    private _entitySets;
+    constructor(namespace: string, entityTypeElements: XElement[], entitySetElements: XElement[]);
+    get entities(): Map<string, Entity>;
+    get entitySets(): Map<string, EntitySet>;
+    private _namespace;
+    get namespace(): string;
+    set namespace(value: string);
+    private loadEntities;
+    private loadEntitySets;
+}

package/esm2022/lib/Schema.js

@@ -0,0 +1,54 @@
+import { Entity } from "./Entity";
+import { EntitySet } from "./EntitySet";
+import { XName } from "igniteui-webcomponents-core";
+export class Schema {
+    constructor(namespace, entityTypeElements, entitySetElements) {
+        this._entities = null;
+        this._entitySets = null;
+        this._namespace = null;
+        this.namespace = namespace;
+        this.loadEntities(entityTypeElements);
+        this.loadEntitySets(entitySetElements);
+    }
+    get entities() {
+        if (null == this._entities) {
+            this._entities = new Map();
+        }
+        return this._entities;
+    }
+    get entitySets() {
+        if (null == this._entitySets) {
+            this._entitySets = new Map();
+        }
+        return this._entitySets;
+    }
+    get namespace() {
+        return this._namespace;
+    }
+    set namespace(value) {
+        this._namespace = value;
+    }
+    loadEntities(entityTypeElements) {
+        let list = entityTypeElements;
+        let elementCount = list.length;
+        let name = XName.get("Name", "");
+        for (let i = 0; i < elementCount; i++) {
+            let node = list[i];
+            let entity = new Entity(node.attribute(name).value, node);
+            this.entities.set(entity.name, entity);
+        }
+        ;
+    }
+    loadEntitySets(entitySetElements) {
+        let list = entitySetElements;
+        let elementCount = list.length;
+        let nameAttr = XName.get("Name", "");
+        let entityType = XName.get("EntityType", "");
+        for (let i = 0; i < elementCount; i++) {
+            let node = list[i];
+            let entitySet = new EntitySet(node.attribute(nameAttr).value, node.attribute(entityType).value);
+            this.entitySets.set(entitySet.name, entitySet);
+        }
+        ;
+    }
+}

package/esm2022/lib/util.d.ts

@@ -0,0 +1,27 @@
+export declare function toArray<T>(en: any): T[];
+export declare function first<T>(iter: Iterable<T>): T;
+export declare class LinkedList<T> {
+    private _first;
+    get first(): LinkedListNode<T>;
+    private _last;
+    get last(): LinkedListNode<T>;
+    addFirst(item: T): void;
+    addLast(item: T): void;
+    removeFirst(): void;
+    clear(): void;
+    contains(value: T): boolean;
+    removeValue(value: T): void;
+    remove(node: LinkedListNode<T>): void;
+}
+export declare class LinkedListNode<T> {
+    private _value;
+    get value(): T;
+    set value(value: T);
+    private _prev;
+    get prev(): LinkedListNode<T>;
+    set prev(value: LinkedListNode<T>);
+    private _next;
+    get next(): LinkedListNode<T>;
+    set next(value: LinkedListNode<T>);
+    constructor(item?: T);
+}

package/esm2022/lib/util.js

@@ -0,0 +1,116 @@
+import { fromEnum } from "igniteui-webcomponents-core";
+export function toArray(en) {
+    return Array.from(fromEnum(en));
+}
+export function first(iter) {
+    for (let v of iter) {
+        return v;
+    }
+    throw new Error("Iterable contained no elements, expected at least one");
+}
+export class LinkedList {
+    get first() {
+        return this._first;
+    }
+    get last() {
+        return this._last;
+    }
+    addFirst(item) {
+        if (this._first == null) {
+            this._first = new LinkedListNode(item);
+            this._last = this._first;
+        }
+        else {
+            var oldFirst = this._first;
+            this._first = new LinkedListNode(item);
+            this._first.next = oldFirst;
+            oldFirst.prev = this._first;
+        }
+    }
+    addLast(item) {
+        if (this._last == null) {
+            this._first = new LinkedListNode(item);
+            this._last = this._first;
+        }
+        else {
+            var oldLast = this._last;
+            this._last = new LinkedListNode(item);
+            this._last.prev = oldLast;
+            oldLast.next = this._last;
+        }
+    }
+    removeFirst() {
+        this.remove(this.first);
+    }
+    clear() {
+        this._first = null;
+        this._last = null;
+    }
+    contains(value) {
+        let curr = this.first;
+        while (curr != null) {
+            if (curr.value === value) {
+                return true;
+            }
+            curr = curr.next;
+        }
+        return false;
+    }
+    removeValue(value) {
+        let curr = this.first;
+        while (curr != null) {
+            if (curr.value === value) {
+                this.remove(curr);
+                return;
+            }
+            curr = curr.next;
+        }
+    }
+    remove(node) {
+        if (this._first == node) {
+            this._first = node.next;
+            if (node.next != null) {
+                node.next.prev = null;
+            }
+        }
+        if (this._last == node) {
+            this._last = node.prev;
+            if (node.prev != null) {
+                node.prev.next = null;
+            }
+        }
+        if (node.prev != null) {
+            node.prev.next = node.next;
+        }
+        if (node.next != null) {
+            node.next.prev = node.prev;
+        }
+        node.next = null;
+        node.prev = null;
+    }
+}
+export class LinkedListNode {
+    get value() {
+        return this._value;
+    }
+    set value(value) {
+        this._value = value;
+    }
+    get prev() {
+        return this._prev;
+    }
+    set prev(value) {
+        this._prev = value;
+    }
+    get next() {
+        return this._next;
+    }
+    set next(value) {
+        this._next = value;
+    }
+    constructor(item) {
+        if (item !== undefined) {
+            this.value = item;
+        }
+    }
+}

package/esm2022/public_api.d.ts

@@ -0,0 +1,18 @@
+export * from './lib/Entity';
+export * from './lib/EntityProperty';
+export * from './lib/EntitySet';
+export * from './lib/ODataDataSourcePage';
+export * from './lib/ODataSchemaProvider';
+export * from './lib/ODataVirtualDataSource';
+export * from './lib/ODataVirtualDataSourceDataProvider';
+export * from './lib/ODataVirtualDataSourceDataProviderWorker';
+export * from './lib/ODataVirtualDataSourceDataProviderWorkerSettings';
+export * from './lib/ODataVirtualDataSourceProviderTaskDataHolder';
+export * from './lib/RestVirtualDataSource';
+export * from './lib/RestVirtualDataSourceDataProvider';
+export * from './lib/RestVirtualDataSourceDataProviderWorker';
+export * from './lib/RestVirtualDataSourceDataProviderWorkerSettings';
+export * from './lib/RestVirtualDataSourcePage';
+export * from './lib/RestVirtualDataSourceProviderTaskDataHolder';
+export * from './lib/Schema';
+export * from './lib/util';

package/esm2022/public_api.js

@@ -0,0 +1,18 @@
+export * from './lib/Entity';
+export * from './lib/EntityProperty';
+export * from './lib/EntitySet';
+export * from './lib/ODataDataSourcePage';
+export * from './lib/ODataSchemaProvider';
+export * from './lib/ODataVirtualDataSource';
+export * from './lib/ODataVirtualDataSourceDataProvider';
+export * from './lib/ODataVirtualDataSourceDataProviderWorker';
+export * from './lib/ODataVirtualDataSourceDataProviderWorkerSettings';
+export * from './lib/ODataVirtualDataSourceProviderTaskDataHolder';
+export * from './lib/RestVirtualDataSource';
+export * from './lib/RestVirtualDataSourceDataProvider';
+export * from './lib/RestVirtualDataSourceDataProviderWorker';
+export * from './lib/RestVirtualDataSourceDataProviderWorkerSettings';
+export * from './lib/RestVirtualDataSourcePage';
+export * from './lib/RestVirtualDataSourceProviderTaskDataHolder';
+export * from './lib/Schema';
+export * from './lib/util';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "igniteui-webcomponents-datasources",
-  "version": "7.1.1-beta.2",
+  "version": "7.1.1-beta.3",
   "description": "Reference custom data providers for the Ignite UI Web Components data source.",
   "homepage": "https://github.com/IgniteUI/igniteui-webcomponents-datasources",
   "keywords": [
@@ -18,19 +18,19 @@
     "tslib": "^2.3.1"
   },
   "peerDependencies": {
-    "igniteui-webcomponents-core": "7.1.1-beta.2"
+    "igniteui-webcomponents-core": "7.1.1-beta.3"
   },
-  "type": "module",
   "sideEffects": false,
-  "module": "fesm2022/igniteui-webcomponents-datasources.mjs",
-  "typings": "igniteui-webcomponents-datasources.d.ts",
+  "main": "esm2022/public_api.js",
+  "module": "esm2022/public_api.js",
+  "typings": "esm2022/public_api.d.ts",
   "exports": {
     "./package.json": {
       "default": "./package.json"
     },
     ".": {
-      "types": "./igniteui-webcomponents-datasources.d.ts",
-      "default": "./fesm2022/igniteui-webcomponents-datasources.mjs"
+      "types": "./esm2022/public_api.d.ts",
+      "default": "./esm2022/public_api.js"
     }
   },
   "maintainers": [