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

package/esm2022/lib/Entity.d.ts

@@ -0,0 +1,14 @@
+import { EntityProperty } from "./EntityProperty";
+import { XElement } from "igniteui-webcomponents-core";
+export declare class Entity {
+    private _properties;
+    private _primaryKey;
+    constructor(name: string, entityNode: XElement);
+    private _name;
+    get name(): string;
+    set name(value: string);
+    get properties(): Map<string, EntityProperty>;
+    get primaryKey(): string[];
+    private loadProperties;
+    private loadPrimaryKey;
+}

package/esm2022/lib/Entity.js

@@ -0,0 +1,65 @@
+import { EntityProperty } from "./EntityProperty";
+import { XName } from "igniteui-webcomponents-core";
+import { toArray } from './util';
+export class Entity {
+    constructor(name, entityNode) {
+        this._properties = null;
+        this._primaryKey = null;
+        this._name = null;
+        this.name = name;
+        this.loadProperties(entityNode);
+        this.loadPrimaryKey(entityNode);
+    }
+    get name() {
+        return this._name;
+    }
+    set name(value) {
+        this._name = value;
+    }
+    get properties() {
+        if (null == this._properties) {
+            this._properties = new Map();
+        }
+        return this._properties;
+    }
+    get primaryKey() {
+        if (null == this._primaryKey) {
+            this._primaryKey = [];
+        }
+        return this._primaryKey;
+    }
+    loadProperties(entityNode) {
+        let children = toArray(entityNode.elements());
+        let elementCount = children.length;
+        let nameAttr = XName.get("Name", "");
+        let typeAttr = XName.get("Type", "");
+        for (let i = 0; i < elementCount; i++) {
+            let node = children[i];
+            if (node.name.localName == "Property") {
+                let name = node.attribute(nameAttr).value;
+                let type = node.attribute(typeAttr).value;
+                this.properties.set(name, new EntityProperty(name, type));
+            }
+        }
+        ;
+    }
+    loadPrimaryKey(entityNode) {
+        let children = toArray(entityNode.elements());
+        let elementCount = children.length;
+        let nameAttr = XName.get("Name", "");
+        for (let i = 0; i < elementCount; i++) {
+            let node = children[i];
+            if (node.name.localName == "Key") {
+                let subChildren = toArray(node.elements());
+                let keyNodeCOunt = subChildren.length;
+                for (let j = 0; j < keyNodeCOunt; j++) {
+                    let keyNode = subChildren[j];
+                    if (keyNode.name.localName == "PropertyRef") {
+                        this.primaryKey.push(keyNode.attribute(nameAttr).value);
+                    }
+                }
+            }
+        }
+        ;
+    }
+}

package/esm2022/lib/EntityProperty.d.ts

@@ -0,0 +1,12 @@
+export declare class EntityProperty {
+    constructor(name: string, schemaType: string);
+    private _name;
+    get name(): string;
+    set name(value: string);
+    private _isNullable;
+    get isNullable(): boolean;
+    set isNullable(value: boolean);
+    private _type;
+    get type(): string;
+    set type(value: string);
+}

package/esm2022/lib/EntityProperty.js

@@ -0,0 +1,27 @@
+export class EntityProperty {
+    constructor(name, schemaType) {
+        this._name = null;
+        this._isNullable = false;
+        this._type = null;
+        this.name = name;
+        this.type = schemaType;
+    }
+    get name() {
+        return this._name;
+    }
+    set name(value) {
+        this._name = value;
+    }
+    get isNullable() {
+        return this._isNullable;
+    }
+    set isNullable(value) {
+        this._isNullable = value;
+    }
+    get type() {
+        return this._type;
+    }
+    set type(value) {
+        this._type = value;
+    }
+}

package/esm2022/lib/EntitySet.d.ts

@@ -0,0 +1,15 @@
+export declare class EntitySet {
+    constructor(name: string, entityType: string);
+    private _entityName;
+    get entityName(): string;
+    set entityName(value: string);
+    private _entityNamespace;
+    get entityNamespace(): string;
+    set entityNamespace(value: string);
+    private _entityType;
+    get entityType(): string;
+    set entityType(value: string);
+    private _name;
+    get name(): string;
+    set name(value: string);
+}

package/esm2022/lib/EntitySet.js

@@ -0,0 +1,50 @@
+export class EntitySet {
+    constructor(name, entityType) {
+        this._entityName = null;
+        this._entityNamespace = null;
+        this._entityType = null;
+        this._name = null;
+        this.name = name;
+        this.entityType = entityType;
+        if (entityType.indexOf(".") >= 0) {
+            let parts = entityType.split('.');
+            if (parts.length == 2) {
+                this.entityNamespace = parts[0];
+                this.entityName = parts[1];
+            }
+            else {
+                let i = entityType.lastIndexOf('.');
+                this.entityNamespace = entityType.substr(0, i);
+                this.entityName = entityType.substr(i + 1);
+            }
+        }
+        else {
+            this.entityNamespace = entityType;
+            this.entityName = entityType;
+        }
+    }
+    get entityName() {
+        return this._entityName;
+    }
+    set entityName(value) {
+        this._entityName = value;
+    }
+    get entityNamespace() {
+        return this._entityNamespace;
+    }
+    set entityNamespace(value) {
+        this._entityNamespace = value;
+    }
+    get entityType() {
+        return this._entityType;
+    }
+    set entityType(value) {
+        this._entityType = value;
+    }
+    get name() {
+        return this._name;
+    }
+    set name(value) {
+        this._name = value;
+    }
+}

package/esm2022/lib/ODataDataSourcePage.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 ODataDataSourcePage 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/ODataDataSourcePage.js

@@ -0,0 +1,67 @@
+import { DataSourceSchemaPropertyType } from "igniteui-webcomponents-core";
+export class ODataDataSourcePage {
+    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_.value.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_.value[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/ODataSchemaProvider.d.ts

@@ -0,0 +1,12 @@
+import { XNamespace } from "igniteui-webcomponents-core";
+import { IDataSourceSchema } from "igniteui-webcomponents-core";
+export declare class ODataSchemaProvider {
+    private _entityTypeSchemaNamespace;
+    private _entitySetSchemaNamespace;
+    static nS: XNamespace;
+    constructor(metadataDocument: string);
+    private _schema;
+    private get schema();
+    private set schema(value);
+    getODataDataSourceSchema(entitySet: string): IDataSourceSchema;
+}

package/esm2022/lib/ODataSchemaProvider.js

@@ -0,0 +1,120 @@
+import { Schema } from "./Schema";
+import { XDocument } from "igniteui-webcomponents-core";
+import { XElement } from "igniteui-webcomponents-core";
+import { XName } from "igniteui-webcomponents-core";
+import { XNamespace } from "igniteui-webcomponents-core";
+import { DataSourceSchemaPropertyType } from "igniteui-webcomponents-core";
+import { ODataDataSourceSchema } from "igniteui-webcomponents-core";
+import { XmlNodeType } from "igniteui-webcomponents-core";
+import { toArray, first } from './util';
+import { fromEnum, typeCast } from "igniteui-webcomponents-core";
+class ODataSchemaProvider {
+    static { this.nS = XNamespace.get("http://docs.oasis-open.org/odata/ns/edm"); }
+    constructor(metadataDocument) {
+        this._entityTypeSchemaNamespace = null;
+        this._entitySetSchemaNamespace = null;
+        this._schema = null;
+        if (null == metadataDocument) {
+            return;
+        }
+        let xmlDoc = XDocument.parse(metadataDocument);
+        let schemaElements = toArray(first(fromEnum(first(fromEnum(xmlDoc.elements())).elements())).elements1(XName.get("Schema", ODataSchemaProvider.nS.namespaceName)));
+        if (null == schemaElements) {
+            return;
+        }
+        let entitySetElements = null;
+        let entityTypeElements = null;
+        let elementCount = schemaElements.length;
+        let entityContainer = XName.get("EntityContainer", ODataSchemaProvider.nS.namespaceName);
+        let entitySet = XName.get("EntitySet", ODataSchemaProvider.nS.namespaceName);
+        let namespaceAttribute = XName.get("Namespace", "");
+        let entityType = XName.get("EntityType", ODataSchemaProvider.nS.namespaceName);
+        for (let i = 0; i < elementCount; i++) {
+            let node = schemaElements[i];
+            if (node.nodeType != XmlNodeType.Element) {
+                continue;
+            }
+            let schemaElement = schemaElements[i];
+            if (null == entitySetElements) {
+                let nodes = toArray(schemaElement.elements1(entityContainer));
+                if (null != nodes && nodes.length > 0) {
+                    entitySetElements = toArray((typeCast(XElement.$type, nodes[0])).elements1(entitySet));
+                    if (null != entitySetElements) {
+                        this._entitySetSchemaNamespace = schemaElement.attribute(namespaceAttribute).value;
+                    }
+                }
+            }
+            if (null == entityTypeElements) {
+                entityTypeElements = toArray(schemaElement.elements1(entityType));
+                if (null != entityTypeElements) {
+                    this._entityTypeSchemaNamespace = schemaElement.attribute(namespaceAttribute).value;
+                }
+            }
+        }
+        if (null == entitySetElements || null == entityTypeElements) {
+            return;
+        }
+        this.schema = new Schema(this._entityTypeSchemaNamespace, entityTypeElements, entitySetElements);
+    }
+    get schema() {
+        return this._schema;
+    }
+    set schema(value) {
+        this._schema = value;
+    }
+    getODataDataSourceSchema(entitySet) {
+        if (this.schema == null) {
+            return null;
+        }
+        let valueNames = [];
+        let valueTypes = [];
+        let primaryKey = [];
+        let es = this.schema.entitySets.get(entitySet);
+        if (null != es) {
+            let entity = this.schema.entities.get(es.entityName);
+            if (null != entity) {
+                for (let property of entity.properties.values()) {
+                    valueNames.push(property.name);
+                    if (property.type == "Edm.String") {
+                        valueTypes.push(DataSourceSchemaPropertyType.StringValue);
+                    }
+                    else if (property.type == "Edm.Int16" || property.type == "Edm.Int32") {
+                        valueTypes.push(DataSourceSchemaPropertyType.IntValue);
+                    }
+                    else if (property.type == "Edm.Double") {
+                        valueTypes.push(DataSourceSchemaPropertyType.DoubleValue);
+                    }
+                    else if (property.type == "Edm.Single") {
+                        valueTypes.push(DataSourceSchemaPropertyType.SingleValue);
+                    }
+                    else if (property.type == "Edm.Boolean") {
+                        valueTypes.push(DataSourceSchemaPropertyType.BooleanValue);
+                    }
+                    else if (property.type == "Edm.Byte") {
+                        valueTypes.push(DataSourceSchemaPropertyType.ShortValue);
+                    }
+                    else if (property.type == "Edm.DateTime" || property.type == "Edm.DateTimeOffset") {
+                        valueTypes.push(DataSourceSchemaPropertyType.DateTimeValue);
+                    }
+                    else if (property.type == "Edm.Int64") {
+                        valueTypes.push(DataSourceSchemaPropertyType.LongValue);
+                    }
+                    else if (property.type == "Edm.Decimal") {
+                        valueTypes.push(DataSourceSchemaPropertyType.DecimalValue);
+                    }
+                    else if (property.type == "Edm.SByte") {
+                        valueTypes.push(DataSourceSchemaPropertyType.ShortValue);
+                    }
+                    else {
+                        valueTypes.push(DataSourceSchemaPropertyType.ObjectValue);
+                    }
+                }
+                for (let k of entity.primaryKey) {
+                    primaryKey.push(k);
+                }
+            }
+        }
+        return new ODataDataSourceSchema(valueNames, valueTypes, primaryKey);
+    }
+}
+export { ODataSchemaProvider };

package/esm2022/lib/ODataVirtualDataSource.d.ts

@@ -0,0 +1,28 @@
+import { VirtualDataSource } from "igniteui-webcomponents-core";
+import { IDataSource } from "igniteui-webcomponents-core";
+import { IExternalDataSource } from "igniteui-webcomponents-core";
+export declare class ODataVirtualDataSource extends VirtualDataSource implements IExternalDataSource {
+    constructor();
+    private onBaseUriChanged;
+    private _baseUri;
+    get baseUri(): string;
+    set baseUri(value: string);
+    private onEntitySetChanged;
+    private _entitySet;
+    get entitySet(): string;
+    set entitySet(value: string);
+    private onTimeoutMillisecondsChanged;
+    private _timeoutMilliseconds;
+    get timeoutMilliseconds(): number;
+    set timeoutMilliseconds(value: number);
+    get isSortingSupportedOverride(): boolean;
+    get isFilteringSupportedOverride(): boolean;
+    get isGroupingSupportedOverride(): boolean;
+    private _isAggregationSupportedByServer;
+    get isAggregationSupportedByServer(): boolean;
+    set isAggregationSupportedByServer(isSupported: boolean);
+    private _enableJsonp;
+    get enableJsonp(): boolean;
+    set enableJsonp(isEnabled: boolean);
+    clone(): IDataSource;
+}

package/esm2022/lib/ODataVirtualDataSource.js

@@ -0,0 +1,132 @@
+import { VirtualDataSource } from "igniteui-webcomponents-core";
+import { ODataVirtualDataSourceDataProvider } from "./ODataVirtualDataSourceDataProvider";
+import { typeCast } from "igniteui-webcomponents-core";
+export class ODataVirtualDataSource extends VirtualDataSource {
+    constructor() {
+        super();
+        this._baseUri = null;
+        this._entitySet = null;
+        this._timeoutMilliseconds = 10000;
+        this._isAggregationSupportedByServer = false;
+        this._enableJsonp = true;
+        this.dataProvider = ((() => {
+            let $ret = new ODataVirtualDataSourceDataProvider();
+            $ret.executionContext = this.executionContext;
+            $ret.enableJsonp = this.enableJsonp;
+            $ret.isAggregationSupported = this.isGroupingSupported;
+            return $ret;
+        })());
+        this.externalDataSource = this;
+    }
+    onBaseUriChanged(oldValue, newValue) {
+        if (typeCast(ODataVirtualDataSourceDataProvider.$type, this.actualDataProvider) !== null) {
+            this.actualDataProvider.baseUri = this.baseUri;
+        }
+        this.queueAutoRefresh();
+    }
+    get baseUri() {
+        return this._baseUri;
+    }
+    set baseUri(value) {
+        let oldValue = this._baseUri;
+        this._baseUri = value;
+        if (oldValue != this._baseUri) {
+            this.onBaseUriChanged(oldValue, this._baseUri);
+        }
+    }
+    onEntitySetChanged(oldValue, newValue) {
+        if (typeCast(ODataVirtualDataSourceDataProvider.$type, this.actualDataProvider) !== null) {
+            this.actualDataProvider.entitySet = this.entitySet;
+        }
+        this.queueAutoRefresh();
+    }
+    get entitySet() {
+        return this._entitySet;
+    }
+    set entitySet(value) {
+        let oldValue = this._entitySet;
+        this._entitySet = value;
+        if (this._entitySet != oldValue) {
+            this.onEntitySetChanged(oldValue, this._entitySet);
+        }
+    }
+    onTimeoutMillisecondsChanged(oldValue, newValue) {
+        if (typeCast(ODataVirtualDataSourceDataProvider.$type, this.actualDataProvider) !== null) {
+            this.actualDataProvider.timeoutMilliseconds = this.timeoutMilliseconds;
+        }
+    }
+    get timeoutMilliseconds() {
+        return this._timeoutMilliseconds;
+    }
+    set timeoutMilliseconds(value) {
+        let oldValue = this._timeoutMilliseconds;
+        this._timeoutMilliseconds = value;
+        if (oldValue != this._timeoutMilliseconds) {
+            this.onTimeoutMillisecondsChanged(oldValue, this._timeoutMilliseconds);
+        }
+    }
+    get isSortingSupportedOverride() {
+        return true;
+    }
+    get isFilteringSupportedOverride() {
+        return true;
+    }
+    get isGroupingSupportedOverride() {
+        return this.isAggregationSupportedByServer;
+    }
+    get isAggregationSupportedByServer() {
+        return this._isAggregationSupportedByServer;
+    }
+    set isAggregationSupportedByServer(isSupported) {
+        this._isAggregationSupportedByServer = isSupported;
+        if (typeCast(ODataVirtualDataSourceDataProvider.$type, this.actualDataProvider) !== null) {
+            this.actualDataProvider.isAggregationSupported = isSupported;
+        }
+    }
+    get enableJsonp() {
+        return this._enableJsonp;
+    }
+    set enableJsonp(isEnabled) {
+        this._enableJsonp = isEnabled;
+        if (typeCast(ODataVirtualDataSourceDataProvider.$type, this.actualDataProvider) !== null) {
+            this.actualDataProvider.enableJsonp = isEnabled;
+        }
+    }
+    clone() {
+        let dataSource = new ODataVirtualDataSource();
+        dataSource.executionContext = this.executionContext;
+        dataSource.includeSummaryRowsInSection = this.includeSummaryRowsInSection;
+        dataSource.isSectionCollapsable = this.isSectionCollapsable;
+        dataSource.isSectionExpandedDefault = this.isSectionExpandedDefault;
+        //dataSource.isSectionHeaderNormalRow = this.isSectionHeaderNormalRow;
+        dataSource.isSectionSummaryRowsAtBottom = this.isSectionSummaryRowsAtBottom;
+        //dataSource.isSectionContentVisible = this.isSectionContentVisible;
+        dataSource.primaryKey = this.primaryKey;
+        dataSource.propertiesRequested = this.propertiesRequested;
+        dataSource.sectionHeaderDisplayMode = this.sectionHeaderDisplayMode;
+        dataSource.shouldEmitSectionFooters = this.shouldEmitSectionFooters;
+        dataSource.shouldEmitSectionHeaders = this.shouldEmitSectionHeaders;
+        dataSource.shouldEmitShiftedRows = this.shouldEmitShiftedRows;
+        dataSource.summaryScope = this.summaryScope;
+        for (var i = 0; i < this.groupDescriptions.size(); i++) {
+            dataSource.groupDescriptions.add(this.groupDescriptions.get(i));
+        }
+        for (var i = 0; i < this.sortDescriptions.size(); i++) {
+            dataSource.sortDescriptions.add(this.sortDescriptions.get(i));
+        }
+        for (var i = 0; i < this.filterExpressions.size(); i++) {
+            dataSource.filterExpressions.add(this.filterExpressions.get(i));
+        }
+        for (var i = 0; i < this.summaryDescriptions.size(); i++) {
+            dataSource.summaryDescriptions.add(this.summaryDescriptions.get(i));
+        }
+        dataSource.pageSizeRequested = this.pageSizeRequested;
+        dataSource.maxCachedPages = this.maxCachedPages;
+        dataSource.baseUri = this.baseUri;
+        dataSource.entitySet = this.entitySet;
+        dataSource.timeoutMilliseconds = this.timeoutMilliseconds;
+        dataSource.isAggregationSupportedByServer = this.isAggregationSupportedByServer;
+        dataSource.enableJsonp = this.enableJsonp;
+        return dataSource;
+    }
+}