angular-odata 0.78.1 → 0.95.0

package/esm2020/lib/schema/element.mjs

@@ -0,0 +1,51 @@
+import { Strings } from '../utils';
+import { ODataAnnotatable } from './annotation';
+export class ODataSchemaElement extends ODataAnnotatable {
+    constructor(config, schema) {
+        super(config);
+        this.schema = schema;
+        this.name = config.name;
+    }
+    get api() {
+        return this.schema.api;
+    }
+    /**
+     * Create a nicer looking title.
+     * Titleize is meant for creating pretty output.
+     * @param term The term of the annotation to find.
+     * @returns The titleized string.
+     */
+    titleize(term) {
+        return (term && this.annotatedValue(term)) || Strings.titleCase(this.name);
+    }
+    /**
+     * Returns a full type of the structured type including the namespace/alias.
+     * @param alias Use the alias of the namespace instead of the namespace.
+     * @returns The string representation of the type.
+     */
+    type({ alias = false } = {}) {
+        return `${alias ? this.schema.alias : this.schema.namespace}.${this.name}`;
+    }
+    /**
+     * Returns a boolean indicating if the structured type is of the given type.
+     * @param type String representation of the type
+     * @returns True if the callable is type of the given type
+     */
+    isTypeOf(type) {
+        var names = [`${this.schema.namespace}.${this.name}`];
+        if (this.schema.alias)
+            names.push(`${this.schema.alias}.${this.name}`);
+        return names.indexOf(type) !== -1;
+    }
+    /**
+     * Returns a boolean indicating if the structured type is a sub type of the given type.
+     * @param type String representation of the type
+     * @returns True if the callable is type of the given type
+     */
+    isSubtypeOf(schema) {
+        if (this.isTypeOf(schema.type()))
+            return true;
+        return false;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZWxlbWVudC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2FuZ3VsYXItb2RhdGEvc3JjL2xpYi9zY2hlbWEvZWxlbWVudC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFDQSxPQUFPLEVBQUUsT0FBTyxFQUFFLE1BQU0sVUFBVSxDQUFDO0FBQ25DLE9BQU8sRUFBRSxnQkFBZ0IsRUFBRSxNQUFNLGNBQWMsQ0FBQztBQUdoRCxNQUFNLE9BQU8sa0JBQW1CLFNBQVEsZ0JBQWdCO0lBSXRELFlBQ0UsTUFBMEQsRUFDMUQsTUFBbUI7UUFFbkIsS0FBSyxDQUFDLE1BQU0sQ0FBQyxDQUFDO1FBQ2QsSUFBSSxDQUFDLE1BQU0sR0FBRyxNQUFNLENBQUM7UUFDckIsSUFBSSxDQUFDLElBQUksR0FBRyxNQUFNLENBQUMsSUFBSSxDQUFDO0lBQzFCLENBQUM7SUFFRCxJQUFJLEdBQUc7UUFDTCxPQUFPLElBQUksQ0FBQyxNQUFNLENBQUMsR0FBRyxDQUFDO0lBQ3pCLENBQUM7SUFFRDs7Ozs7T0FLRztJQUNILFFBQVEsQ0FBQyxJQUFzQjtRQUM3QixPQUFPLENBQUMsSUFBSSxJQUFJLElBQUksQ0FBQyxjQUFjLENBQUMsSUFBSSxDQUFDLENBQUMsSUFBSSxPQUFPLENBQUMsU0FBUyxDQUFDLElBQUksQ0FBQyxJQUFJLENBQUMsQ0FBQztJQUM3RSxDQUFDO0lBRUQ7Ozs7T0FJRztJQUNILElBQUksQ0FBQyxFQUFFLEtBQUssR0FBRyxLQUFLLEtBQTBCLEVBQUU7UUFDOUMsT0FBTyxHQUFHLEtBQUssQ0FBQyxDQUFDLENBQUMsSUFBSSxDQUFDLE1BQU0sQ0FBQyxLQUFLLENBQUMsQ0FBQyxDQUFDLElBQUksQ0FBQyxNQUFNLENBQUMsU0FBUyxJQUFJLElBQUksQ0FBQyxJQUFJLEVBQUUsQ0FBQztJQUM3RSxDQUFDO0lBRUQ7Ozs7T0FJRztJQUNILFFBQVEsQ0FBQyxJQUFZO1FBQ25CLElBQUksS0FBSyxHQUFHLENBQUMsR0FBRyxJQUFJLENBQUMsTUFBTSxDQUFDLFNBQVMsSUFBSSxJQUFJLENBQUMsSUFBSSxFQUFFLENBQUMsQ0FBQztRQUN0RCxJQUFJLElBQUksQ0FBQyxNQUFNLENBQUMsS0FBSztZQUFFLEtBQUssQ0FBQyxJQUFJLENBQUMsR0FBRyxJQUFJLENBQUMsTUFBTSxDQUFDLEtBQUssSUFBSSxJQUFJLENBQUMsSUFBSSxFQUFFLENBQUMsQ0FBQztRQUN2RSxPQUFPLEtBQUssQ0FBQyxPQUFPLENBQUMsSUFBSSxDQUFDLEtBQUssQ0FBQyxDQUFDLENBQUM7SUFDcEMsQ0FBQztJQUVEOzs7O09BSUc7SUFDSCxXQUFXLENBQUMsTUFBMEI7UUFDcEMsSUFBSSxJQUFJLENBQUMsUUFBUSxDQUFDLE1BQU0sQ0FBQyxJQUFJLEVBQUUsQ0FBQztZQUFFLE9BQU8sSUFBSSxDQUFDO1FBQzlDLE9BQU8sS0FBSyxDQUFDO0lBQ2YsQ0FBQztDQUNGIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgQW5ub3RhdGlvbkNvbmZpZyB9IGZyb20gJy4uL3R5cGVzJztcbmltcG9ydCB7IFN0cmluZ3MgfSBmcm9tICcuLi91dGlscyc7XG5pbXBvcnQgeyBPRGF0YUFubm90YXRhYmxlIH0gZnJvbSAnLi9hbm5vdGF0aW9uJztcbmltcG9ydCB7IE9EYXRhU2NoZW1hIH0gZnJvbSAnLi9zY2hlbWEnO1xuXG5leHBvcnQgY2xhc3MgT0RhdGFTY2hlbWFFbGVtZW50IGV4dGVuZHMgT0RhdGFBbm5vdGF0YWJsZSB7XG4gIG5hbWU6IHN0cmluZztcbiAgc2NoZW1hOiBPRGF0YVNjaGVtYTtcblxuICBjb25zdHJ1Y3RvcihcbiAgICBjb25maWc6IHsgYW5ub3RhdGlvbnM/OiBBbm5vdGF0aW9uQ29uZmlnW107IG5hbWU6IHN0cmluZyB9LFxuICAgIHNjaGVtYTogT0RhdGFTY2hlbWFcbiAgKSB7XG4gICAgc3VwZXIoY29uZmlnKTtcbiAgICB0aGlzLnNjaGVtYSA9IHNjaGVtYTtcbiAgICB0aGlzLm5hbWUgPSBjb25maWcubmFtZTtcbiAgfVxuXG4gIGdldCBhcGkoKSB7XG4gICAgcmV0dXJuIHRoaXMuc2NoZW1hLmFwaTtcbiAgfVxuXG4gIC8qKlxuICAgKiBDcmVhdGUgYSBuaWNlciBsb29raW5nIHRpdGxlLlxuICAgKiBUaXRsZWl6ZSBpcyBtZWFudCBmb3IgY3JlYXRpbmcgcHJldHR5IG91dHB1dC5cbiAgICogQHBhcmFtIHRlcm0gVGhlIHRlcm0gb2YgdGhlIGFubm90YXRpb24gdG8gZmluZC5cbiAgICogQHJldHVybnMgVGhlIHRpdGxlaXplZCBzdHJpbmcuXG4gICAqL1xuICB0aXRsZWl6ZSh0ZXJtPzogc3RyaW5nIHwgUmVnRXhwKTogc3RyaW5nIHtcbiAgICByZXR1cm4gKHRlcm0gJiYgdGhpcy5hbm5vdGF0ZWRWYWx1ZSh0ZXJtKSkgfHwgU3RyaW5ncy50aXRsZUNhc2UodGhpcy5uYW1lKTtcbiAgfVxuXG4gIC8qKlxuICAgKiBSZXR1cm5zIGEgZnVsbCB0eXBlIG9mIHRoZSBzdHJ1Y3R1cmVkIHR5cGUgaW5jbHVkaW5nIHRoZSBuYW1lc3BhY2UvYWxpYXMuXG4gICAqIEBwYXJhbSBhbGlhcyBVc2UgdGhlIGFsaWFzIG9mIHRoZSBuYW1lc3BhY2UgaW5zdGVhZCBvZiB0aGUgbmFtZXNwYWNlLlxuICAgKiBAcmV0dXJucyBUaGUgc3RyaW5nIHJlcHJlc2VudGF0aW9uIG9mIHRoZSB0eXBlLlxuICAgKi9cbiAgdHlwZSh7IGFsaWFzID0gZmFsc2UgfTogeyBhbGlhcz86IGJvb2xlYW4gfSA9IHt9KSB7XG4gICAgcmV0dXJuIGAke2FsaWFzID8gdGhpcy5zY2hlbWEuYWxpYXMgOiB0aGlzLnNjaGVtYS5uYW1lc3BhY2V9LiR7dGhpcy5uYW1lfWA7XG4gIH1cblxuICAvKipcbiAgICogUmV0dXJucyBhIGJvb2xlYW4gaW5kaWNhdGluZyBpZiB0aGUgc3RydWN0dXJlZCB0eXBlIGlzIG9mIHRoZSBnaXZlbiB0eXBlLlxuICAgKiBAcGFyYW0gdHlwZSBTdHJpbmcgcmVwcmVzZW50YXRpb24gb2YgdGhlIHR5cGVcbiAgICogQHJldHVybnMgVHJ1ZSBpZiB0aGUgY2FsbGFibGUgaXMgdHlwZSBvZiB0aGUgZ2l2ZW4gdHlwZVxuICAgKi9cbiAgaXNUeXBlT2YodHlwZTogc3RyaW5nKTogYm9vbGVhbiB7XG4gICAgdmFyIG5hbWVzID0gW2Ake3RoaXMuc2NoZW1hLm5hbWVzcGFjZX0uJHt0aGlzLm5hbWV9YF07XG4gICAgaWYgKHRoaXMuc2NoZW1hLmFsaWFzKSBuYW1lcy5wdXNoKGAke3RoaXMuc2NoZW1hLmFsaWFzfS4ke3RoaXMubmFtZX1gKTtcbiAgICByZXR1cm4gbmFtZXMuaW5kZXhPZih0eXBlKSAhPT0gLTE7XG4gIH1cblxuICAvKipcbiAgICogUmV0dXJucyBhIGJvb2xlYW4gaW5kaWNhdGluZyBpZiB0aGUgc3RydWN0dXJlZCB0eXBlIGlzIGEgc3ViIHR5cGUgb2YgdGhlIGdpdmVuIHR5cGUuXG4gICAqIEBwYXJhbSB0eXBlIFN0cmluZyByZXByZXNlbnRhdGlvbiBvZiB0aGUgdHlwZVxuICAgKiBAcmV0dXJucyBUcnVlIGlmIHRoZSBjYWxsYWJsZSBpcyB0eXBlIG9mIHRoZSBnaXZlbiB0eXBlXG4gICAqL1xuICBpc1N1YnR5cGVPZihzY2hlbWE6IE9EYXRhU2NoZW1hRWxlbWVudCk6IGJvb2xlYW4ge1xuICAgIGlmICh0aGlzLmlzVHlwZU9mKHNjaGVtYS50eXBlKCkpKSByZXR1cm4gdHJ1ZTtcbiAgICByZXR1cm4gZmFsc2U7XG4gIH1cbn1cbiJdfQ==

package/esm2020/lib/schema/entity-container.mjs

@@ -0,0 +1,9 @@
+import { ODataSchemaElement } from './element';
+import { ODataEntitySet } from './entity-set';
+export class ODataEntityContainer extends ODataSchemaElement {
+    constructor(config, schema) {
+        super(config, schema);
+        this.entitySets = (config.entitySets || []).map((config) => new ODataEntitySet(config, schema));
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZW50aXR5LWNvbnRhaW5lci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2FuZ3VsYXItb2RhdGEvc3JjL2xpYi9zY2hlbWEvZW50aXR5LWNvbnRhaW5lci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFDQSxPQUFPLEVBQUUsa0JBQWtCLEVBQUUsTUFBTSxXQUFXLENBQUM7QUFDL0MsT0FBTyxFQUFFLGNBQWMsRUFBRSxNQUFNLGNBQWMsQ0FBQztBQUc5QyxNQUFNLE9BQU8sb0JBQXFCLFNBQVEsa0JBQWtCO0lBRzFELFlBQVksTUFBNkIsRUFBRSxNQUFtQjtRQUM1RCxLQUFLLENBQUMsTUFBTSxFQUFFLE1BQU0sQ0FBQyxDQUFDO1FBQ3RCLElBQUksQ0FBQyxVQUFVLEdBQUcsQ0FBQyxNQUFNLENBQUMsVUFBVSxJQUFJLEVBQUUsQ0FBQyxDQUFDLEdBQUcsQ0FDN0MsQ0FBQyxNQUFNLEVBQUUsRUFBRSxDQUFDLElBQUksY0FBYyxDQUFDLE1BQU0sRUFBRSxNQUFNLENBQUMsQ0FDL0MsQ0FBQztJQUNKLENBQUM7Q0FDRiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEVudGl0eUNvbnRhaW5lckNvbmZpZyB9IGZyb20gJy4uL3R5cGVzJztcbmltcG9ydCB7IE9EYXRhU2NoZW1hRWxlbWVudCB9IGZyb20gJy4vZWxlbWVudCc7XG5pbXBvcnQgeyBPRGF0YUVudGl0eVNldCB9IGZyb20gJy4vZW50aXR5LXNldCc7XG5pbXBvcnQgeyBPRGF0YVNjaGVtYSB9IGZyb20gJy4vc2NoZW1hJztcblxuZXhwb3J0IGNsYXNzIE9EYXRhRW50aXR5Q29udGFpbmVyIGV4dGVuZHMgT0RhdGFTY2hlbWFFbGVtZW50IHtcbiAgZW50aXR5U2V0czogT0RhdGFFbnRpdHlTZXRbXTtcblxuICBjb25zdHJ1Y3Rvcihjb25maWc6IEVudGl0eUNvbnRhaW5lckNvbmZpZywgc2NoZW1hOiBPRGF0YVNjaGVtYSkge1xuICAgIHN1cGVyKGNvbmZpZywgc2NoZW1hKTtcbiAgICB0aGlzLmVudGl0eVNldHMgPSAoY29uZmlnLmVudGl0eVNldHMgfHwgW10pLm1hcChcbiAgICAgIChjb25maWcpID0+IG5ldyBPRGF0YUVudGl0eVNldChjb25maWcsIHNjaGVtYSlcbiAgICApO1xuICB9XG59XG4iXX0=

package/esm2020/lib/schema/entity-set.mjs

@@ -0,0 +1,9 @@
+import { ODataSchemaElement } from './element';
+export class ODataEntitySet extends ODataSchemaElement {
+    constructor(config, schema) {
+        super(config, schema);
+        this.entityType = config.entityType;
+        this.service = config.service;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZW50aXR5LXNldC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2FuZ3VsYXItb2RhdGEvc3JjL2xpYi9zY2hlbWEvZW50aXR5LXNldC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFDQSxPQUFPLEVBQUUsa0JBQWtCLEVBQUUsTUFBTSxXQUFXLENBQUM7QUFHL0MsTUFBTSxPQUFPLGNBQWUsU0FBUSxrQkFBa0I7SUFHcEQsWUFBWSxNQUF1QixFQUFFLE1BQW1CO1FBQ3RELEtBQUssQ0FBQyxNQUFNLEVBQUUsTUFBTSxDQUFDLENBQUM7UUFDdEIsSUFBSSxDQUFDLFVBQVUsR0FBRyxNQUFNLENBQUMsVUFBVSxDQUFDO1FBQ3BDLElBQUksQ0FBQyxPQUFPLEdBQUcsTUFBTSxDQUFDLE9BQU8sQ0FBQztJQUNoQyxDQUFDO0NBQ0YiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBFbnRpdHlTZXRDb25maWcgfSBmcm9tICcuLi90eXBlcyc7XG5pbXBvcnQgeyBPRGF0YVNjaGVtYUVsZW1lbnQgfSBmcm9tICcuL2VsZW1lbnQnO1xuaW1wb3J0IHsgT0RhdGFTY2hlbWEgfSBmcm9tICcuL3NjaGVtYSc7XG5cbmV4cG9ydCBjbGFzcyBPRGF0YUVudGl0eVNldCBleHRlbmRzIE9EYXRhU2NoZW1hRWxlbWVudCB7XG4gIGVudGl0eVR5cGU6IHN0cmluZztcbiAgc2VydmljZTogeyBuZXcgKC4uLnBhcmFtczogYW55W10pOiBhbnkgfTtcbiAgY29uc3RydWN0b3IoY29uZmlnOiBFbnRpdHlTZXRDb25maWcsIHNjaGVtYTogT0RhdGFTY2hlbWEpIHtcbiAgICBzdXBlcihjb25maWcsIHNjaGVtYSk7XG4gICAgdGhpcy5lbnRpdHlUeXBlID0gY29uZmlnLmVudGl0eVR5cGU7XG4gICAgdGhpcy5zZXJ2aWNlID0gY29uZmlnLnNlcnZpY2U7XG4gIH1cbn1cbiJdfQ==

package/esm2020/lib/schema/enum-type.mjs

@@ -0,0 +1,71 @@
+import { ODataSchemaElement } from './element';
+import { ODataEnumTypeParser } from './parsers';
+export class ODataEnumType extends ODataSchemaElement {
+    constructor(config, schema) {
+        super(config, schema);
+        this.members = config.members;
+        this.parser = new ODataEnumTypeParser(config, schema.namespace, schema.alias);
+    }
+    configure() {
+        this.parser.configure({ options: this.api.options });
+    }
+    /**
+     * Returns the fields of the enum type.
+     * @returns The fields of the enum type.
+     */
+    fields() {
+        return this.parser.fields;
+    }
+    /**
+     * Find a field by name.
+     * @param name The name of the field
+     * @returns The field with the given name
+     */
+    findFieldByName(name) {
+        return this.fields().find((f) => f.name === name);
+    }
+    /**
+     * Find a field by value.
+     * @param value The value of the field
+     * @returns The field with the given value
+     */
+    findFieldByValue(value) {
+        return this.fields().find((f) => f.value === value);
+    }
+    /**
+     * Map the fields of the enum type.
+     * @param mapper Function that maps the value to the new value
+     * @returns The fields mapped by the mapper
+     */
+    mapFields(mapper) {
+        return this.fields().map(mapper);
+    }
+    /**
+     * Deseialize the given value from the enum type.
+     * @param value Value to deserialize
+     * @param options Options for deserialization
+     * @returns Deserialized value
+     */
+    deserialize(value, options) {
+        return this.parser.deserialize(value, options);
+    }
+    /**
+     * Serialize the given value for the enum type.
+     * @param value Value to serialize
+     * @param options Options for serialization
+     * @returns Serialized value
+     */
+    serialize(value, options) {
+        return this.parser.serialize(value, options);
+    }
+    /**
+     * Encode the given value for the enum type.
+     * @param value Value to encode
+     * @param options Options for encoding
+     * @returns Encoded value
+     */
+    encode(value, options) {
+        return this.parser.encode(value, options);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/{esm2015/lib/schema/index.js → esm2020/lib/schema/index.mjs}

@@ -4,4 +4,5 @@ export * from './callable';
 export * from './enum-type';
 export * from './structured-type';
 export * from './entity-set';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9hbmd1bGFyLW9kYXRhL3NyYy9saWIvc2NoZW1hL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsVUFBVSxDQUFDO0FBQ3pCLGNBQWMsb0JBQW9CLENBQUM7QUFDbkMsY0FBYyxZQUFZLENBQUM7QUFDM0IsY0FBYyxhQUFhLENBQUM7QUFDNUIsY0FBYyxtQkFBbUIsQ0FBQztBQUNsQyxjQUFjLGNBQWMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vc2NoZW1hJztcbmV4cG9ydCAqIGZyb20gJy4vZW50aXR5LWNvbnRhaW5lcic7XG5leHBvcnQgKiBmcm9tICcuL2NhbGxhYmxlJztcbmV4cG9ydCAqIGZyb20gJy4vZW51bS10eXBlJztcbmV4cG9ydCAqIGZyb20gJy4vc3RydWN0dXJlZC10eXBlJztcbmV4cG9ydCAqIGZyb20gJy4vZW50aXR5LXNldCc7XG4iXX0=
+export * from './parsers';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9hbmd1bGFyLW9kYXRhL3NyYy9saWIvc2NoZW1hL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsVUFBVSxDQUFDO0FBQ3pCLGNBQWMsb0JBQW9CLENBQUM7QUFDbkMsY0FBYyxZQUFZLENBQUM7QUFDM0IsY0FBYyxhQUFhLENBQUM7QUFDNUIsY0FBYyxtQkFBbUIsQ0FBQztBQUNsQyxjQUFjLGNBQWMsQ0FBQztBQUM3QixjQUFjLFdBQVcsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vc2NoZW1hJztcbmV4cG9ydCAqIGZyb20gJy4vZW50aXR5LWNvbnRhaW5lcic7XG5leHBvcnQgKiBmcm9tICcuL2NhbGxhYmxlJztcbmV4cG9ydCAqIGZyb20gJy4vZW51bS10eXBlJztcbmV4cG9ydCAqIGZyb20gJy4vc3RydWN0dXJlZC10eXBlJztcbmV4cG9ydCAqIGZyb20gJy4vZW50aXR5LXNldCc7XG5leHBvcnQgKiBmcm9tICcuL3BhcnNlcnMnO1xuIl19

package/esm2020/lib/schema/parsers/callable.mjs

@@ -0,0 +1,113 @@
+import { CALLABLE_BINDING_PARAMETER } from '../../constants';
+import { ODataParserOptions } from '../../options';
+import { NONE_PARSER, } from '../../types';
+import { ODataEnumTypeParser } from './enum-type';
+import { ODataStructuredTypeParser } from './structured-type';
+export class ODataParameterParser {
+    constructor(name, parameter) {
+        this.name = name;
+        this.type = parameter.type;
+        this.parser = NONE_PARSER;
+        this.nullable = parameter.nullable;
+        this.collection = parameter.collection;
+    }
+    serialize(value, options) {
+        const parserOptions = options !== undefined
+            ? new ODataParserOptions(options)
+            : this.optionsHelper;
+        return Array.isArray(value)
+            ? value.map((v) => this.parser.serialize(v, parserOptions))
+            : this.parser.serialize(value, parserOptions);
+    }
+    //Encode
+    encode(value, options) {
+        const parserOptions = options !== undefined
+            ? new ODataParserOptions(options)
+            : this.optionsHelper;
+        return Array.isArray(value)
+            ? value.map((v) => this.parser.encode(v, parserOptions))
+            : this.parser.encode(value, parserOptions);
+    }
+    configure({ parserForType, options, }) {
+        this.optionsHelper = options;
+        this.parser = parserForType(this.type);
+    }
+    isEdmType() {
+        return this.type.startsWith('Edm.');
+    }
+    isEnumType() {
+        return this.parser instanceof ODataEnumTypeParser;
+    }
+    enum() {
+        if (!this.isEnumType())
+            throw new Error('Field are not EnumType');
+        return this.parser;
+    }
+    isStructuredType() {
+        return this.parser instanceof ODataStructuredTypeParser;
+    }
+    structured() {
+        if (!this.isStructuredType())
+            throw new Error('Field are not StrucuturedType');
+        return this.parser;
+    }
+}
+export class ODataCallableParser {
+    constructor(config, namespace, alias) {
+        this.name = config.name;
+        this.namespace = namespace;
+        this.alias = alias;
+        this.return = config.return;
+        this.parser = NONE_PARSER;
+        this.parameters = Object.entries(config.parameters || []).map(([name, p]) => new ODataParameterParser(name, p));
+    }
+    isTypeOf(type) {
+        var names = [`${this.namespace}.${this.name}`];
+        if (this.alias)
+            names.push(`${this.alias}.${this.name}`);
+        return names.indexOf(type) !== -1;
+    }
+    // Deserialize
+    deserialize(value, options) {
+        const parserOptions = options !== undefined
+            ? new ODataParserOptions(options)
+            : this.optionsHelper;
+        return this.parser.deserialize(value, parserOptions);
+    }
+    // Serialize
+    serialize(params, options) {
+        const parserOptions = options !== undefined
+            ? new ODataParserOptions(options)
+            : this.optionsHelper;
+        const parameters = this.parameters
+            .filter((p) => p.name !== CALLABLE_BINDING_PARAMETER)
+            .filter((p) => p.name in params && params[p.name] !== undefined);
+        return parameters.reduce((acc, p) => ({
+            ...acc,
+            [p.name]: p.serialize(params[p.name], parserOptions),
+        }), {});
+    }
+    //Encode
+    encode(params, options) {
+        const parserOptions = options !== undefined
+            ? new ODataParserOptions(options)
+            : this.optionsHelper;
+        const parameters = this.parameters
+            .filter((p) => p.name !== CALLABLE_BINDING_PARAMETER)
+            .filter((p) => p.name in params && params[p.name] !== undefined);
+        return parameters.reduce((acc, p) => ({
+            ...acc,
+            [p.name]: p.encode(params[p.name], parserOptions),
+        }), {});
+    }
+    configure({ parserForType, options, }) {
+        this.optionsHelper = options;
+        if (this.return)
+            this.parser = parserForType(this.return.type) || NONE_PARSER;
+        this.parameters.forEach((p) => p.configure({ parserForType, options }));
+    }
+    binding() {
+        return this.parameters.find((p) => p.name === CALLABLE_BINDING_PARAMETER);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"callable.js","sourceRoot":"","sources":["../../../../../../projects/angular-odata/src/lib/schema/parsers/callable.ts"],"names":[],"mappings":"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","sourcesContent":["import { CALLABLE_BINDING_PARAMETER } from '../../constants';\nimport { ODataParserOptions } from '../../options';\nimport {\n  CallableConfig,\n  NONE_PARSER,\n  Options,\n  OptionsHelper,\n  Parameter,\n  Parser,\n} from '../../types';\nimport { ODataEnumTypeParser } from './enum-type';\nimport { ODataStructuredTypeParser } from './structured-type';\n\nexport class ODataParameterParser<T> {\n  name: string;\n  type: string;\n  private parser: Parser<T>;\n  collection?: boolean;\n  nullable?: boolean;\n  optionsHelper?: OptionsHelper;\n\n  constructor(name: string, parameter: Parameter) {\n    this.name = name;\n    this.type = parameter.type;\n    this.parser = NONE_PARSER;\n    this.nullable = parameter.nullable;\n    this.collection = parameter.collection;\n  }\n\n  serialize(value: T, options?: Options): any {\n    const parserOptions =\n      options !== undefined\n        ? new ODataParserOptions(options)\n        : this.optionsHelper;\n    return Array.isArray(value)\n      ? value.map((v) => this.parser.serialize(v, parserOptions))\n      : this.parser.serialize(value, parserOptions);\n  }\n\n  //Encode\n  encode(value: any, options?: Options): string {\n    const parserOptions =\n      options !== undefined\n        ? new ODataParserOptions(options)\n        : this.optionsHelper;\n    return Array.isArray(value)\n      ? value.map((v) => this.parser.encode(v, parserOptions))\n      : this.parser.encode(value, parserOptions);\n  }\n\n  configure({\n    parserForType,\n    options,\n  }: {\n    parserForType: (type: string) => Parser<any>;\n    options: OptionsHelper;\n  }) {\n    this.optionsHelper = options;\n    this.parser = parserForType(this.type);\n  }\n\n  isEdmType() {\n    return this.type.startsWith('Edm.');\n  }\n\n  isEnumType() {\n    return this.parser instanceof ODataEnumTypeParser;\n  }\n\n  enum() {\n    if (!this.isEnumType()) throw new Error('Field are not EnumType');\n    return this.parser as ODataEnumTypeParser<T>;\n  }\n\n  isStructuredType() {\n    return this.parser instanceof ODataStructuredTypeParser;\n  }\n\n  structured() {\n    if (!this.isStructuredType())\n      throw new Error('Field are not StrucuturedType');\n    return this.parser as ODataStructuredTypeParser<T>;\n  }\n}\n\nexport class ODataCallableParser<R> implements Parser<R> {\n  name: string;\n  namespace: string;\n  alias?: string;\n  return?: { type: string; collection?: boolean };\n  parser: Parser<any>;\n  parameters: ODataParameterParser<any>[];\n  optionsHelper?: OptionsHelper;\n\n  constructor(config: CallableConfig, namespace: string, alias?: string) {\n    this.name = config.name;\n    this.namespace = namespace;\n    this.alias = alias;\n    this.return = config.return;\n    this.parser = NONE_PARSER;\n    this.parameters = Object.entries(config.parameters || []).map(\n      ([name, p]) => new ODataParameterParser(name, p as Parameter)\n    );\n  }\n\n  isTypeOf(type: string) {\n    var names = [`${this.namespace}.${this.name}`];\n    if (this.alias) names.push(`${this.alias}.${this.name}`);\n    return names.indexOf(type) !== -1;\n  }\n\n  // Deserialize\n  deserialize(value: any, options?: Options): R {\n    const parserOptions =\n      options !== undefined\n        ? new ODataParserOptions(options)\n        : this.optionsHelper;\n    return this.parser.deserialize(value, parserOptions);\n  }\n\n  // Serialize\n  serialize(params: any, options?: Options): any {\n    const parserOptions =\n      options !== undefined\n        ? new ODataParserOptions(options)\n        : this.optionsHelper;\n    const parameters = this.parameters\n      .filter((p) => p.name !== CALLABLE_BINDING_PARAMETER)\n      .filter((p) => p.name in params && params[p.name] !== undefined);\n    return parameters.reduce(\n      (acc, p) => ({\n        ...acc,\n        [p.name]: p.serialize(params[p.name], parserOptions),\n      }),\n      {}\n    );\n  }\n\n  //Encode\n  encode(params: any, options?: Options): any {\n    const parserOptions =\n      options !== undefined\n        ? new ODataParserOptions(options)\n        : this.optionsHelper;\n    const parameters = this.parameters\n      .filter((p) => p.name !== CALLABLE_BINDING_PARAMETER)\n      .filter((p) => p.name in params && params[p.name] !== undefined);\n    return parameters.reduce(\n      (acc, p) => ({\n        ...acc,\n        [p.name]: p.encode(params[p.name], parserOptions),\n      }),\n      {}\n    );\n  }\n\n  configure({\n    parserForType,\n    options,\n  }: {\n    parserForType: (type: string) => Parser<any>;\n    options: OptionsHelper;\n  }) {\n    this.optionsHelper = options;\n    if (this.return)\n      this.parser = parserForType(this.return.type) || NONE_PARSER;\n    this.parameters.forEach((p) => p.configure({ parserForType, options }));\n  }\n\n  binding() {\n    return this.parameters.find((p) => p.name === CALLABLE_BINDING_PARAMETER);\n  }\n}\n"]}

package/esm2020/lib/schema/parsers/edm.mjs

@@ -0,0 +1,95 @@
+import { raw } from '../../resources/query';
+import { ArrayBuffers } from '../../utils/arraybuffers';
+import { Durations } from '../../utils/durations';
+// Core EdmTypeParserBuilder
+const EdmParser = (_d, _s, _e) => ({
+    deserialize(value, options) {
+        return Array.isArray(value)
+            ? value.map((v) => _d(v, options))
+            : _d(value, options);
+    },
+    serialize(value, options) {
+        return Array.isArray(value)
+            ? value.map((v) => _s(v, options))
+            : _s(value, options);
+    },
+    encode(value, options) {
+        return Array.isArray(value)
+            ? value.map((v) => _e(v, options))
+            : _e(value, options);
+    },
+});
+const Identity = (v) => v;
+const toNumber = (v) => Number(v);
+const toString = (v) => v.toString();
+const toBoolean = (v) => Boolean(v);
+const toDate = (v) => new Date(v);
+export const EDM_PARSERS = {
+    //Edm.Guid 16-byte (128-bit) unique identifier
+    'Edm.Guid': EdmParser(Identity, Identity, (v) => raw(v)),
+    //Edm.Int16 Signed 16-bit integer
+    'Edm.Int16': EdmParser(toNumber, toNumber, toNumber),
+    //Edm.String Sequence of UTF-8 characters
+    'Edm.String': EdmParser(toString, toString, toString),
+    //Edm.Boolean Binary-valued logic
+    'Edm.Boolean': EdmParser(toBoolean, toBoolean, toBoolean),
+    //Edm.Byte Unsigned 8-bit integer
+    'Edm.Byte': EdmParser(toNumber, toNumber, toNumber),
+    //Edm.SByte Signed 8-bit integer
+    'Edm.SByte': EdmParser(toNumber, toNumber, toNumber),
+    //Edm.Int32 Signed 16-bit integer
+    'Edm.Int32': EdmParser(toNumber, toNumber, toNumber),
+    //Edm.Int64 Signed 16-bit integer
+    'Edm.Int64': EdmParser(toNumber, toNumber, toNumber),
+    //Edm.Date Date without a time-zone offset
+    'Edm.Date': EdmParser((v) => new Date(`${v}T00:00:00.000Z`), (v) => toDate(v).toISOString().substring(0, 10), (v) => toDate(v).toISOString().substring(0, 10)),
+    //Edm.TimeOfDay Clock time 00:00-23:59:59.999999999999
+    'Edm.TimeOfDay': EdmParser((v) => new Date(`1970-01-01T${v}Z`), (v) => toDate(v).toISOString().substring(11, 23), (v) => toDate(v).toISOString().substring(11, 23)),
+    //Edm.DateTimeOffset Date and time with a time-zone offset, no leap seconds
+    'Edm.DateTimeOffset': EdmParser(toDate, (v) => toDate(v).toISOString(), (v) => toDate(v).toISOString()),
+    //Edm.Duration Signed duration in days, hours, minutes, and (sub)seconds
+    'Edm.Duration': EdmParser((v) => Durations.toDuration(v), (v) => Durations.toString(v), (v) => Durations.toString(v)),
+    //Edm.Decimal Numeric values with fixed precision and scale
+    'Edm.Decimal': EdmParser((v, o) => {
+        if (typeof v === 'string' && o.ieee754Compatible) {
+            return parseFloat(v);
+        }
+        return v;
+    }, (v, o) => {
+        if (o.ieee754Compatible) {
+            return parseFloat(v.toPrecision(o.field.precision)).toFixed(o.field.scale);
+        }
+        return v;
+    }, (v, o) => {
+        if (o.ieee754Compatible) {
+            return parseFloat(v.toPrecision(o.field.precision)).toFixed(o.field.scale);
+        }
+        return v;
+    }),
+    //Edm.Double IEEE 754 binary64 floating-point number (15-17 decimal digits)
+    'Edm.Double': EdmParser((v) => (v === 'INF' ? Infinity : v), (v) => (v === Infinity ? 'INF' : v), (v) => (v === Infinity ? 'INF' : v)),
+    //Edm.Single IEEE 754 binary32 floating-point number (6-9 decimal digits)
+    'Edm.Single': EdmParser((v) => (v === 'INF' ? Infinity : v), (v) => (v === Infinity ? 'INF' : v), (v) => (v === Infinity ? 'INF' : v)),
+    //Edm.Binary Binary data
+    'Edm.Binary': EdmParser((v) => ArrayBuffers.toArrayBuffer(v), (v) => ArrayBuffers.toString(v), (v) => ArrayBuffers.toString(v)),
+};
+/*
+Edm.Stream Binary data stream
+Edm.Geography Abstract base type for all Geography types
+Edm.GeographyPoint A point in a round-earth coordinate system
+Edm.GeographyLineString Line string in a round-earth coordinate system
+Edm.GeographyPolygon Polygon in a round-earth coordinate system
+Edm.GeographyMultiPoint Collection of points in a round-earth coordinate system
+Edm.GeographyMultiLineString Collection of line strings in a round-earth coordinate system
+Edm.GeographyMultiPolygon Collection of polygons in a round-earth coordinate system
+Edm.GeographyCollection Collection of arbitrary Geography values
+Edm.Geometry Abstract base type for all Geometry types
+Edm.GeometryPoint Point in a flat-earth coordinate system
+Edm.GeometryLineString Line string in a flat-earth coordinate system
+Edm.GeometryPolygon Polygon in a flat-earth coordinate system
+Edm.GeometryMultiPoint Collection of points in a flat-earth coordinate system
+Edm.GeometryMultiLineString Collection of line strings in a flat-earth coordinate system
+Edm.GeometryMultiPolygon Collection of polygons in a flat-earth coordinate system
+Edm.GeometryCollection Collection of arbitrary Geometry values
+*/
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"edm.js","sourceRoot":"","sources":["../../../../../../projects/angular-odata/src/lib/schema/parsers/edm.ts"],"names":[],"mappings":"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","sourcesContent":["import { raw } from '../../resources/query';\nimport { Parser, StructuredTypeFieldOptions } from '../../types';\nimport { ArrayBuffers } from '../../utils/arraybuffers';\nimport { Duration, Durations } from '../../utils/durations';\n\n// Core EdmTypeParserBuilder\nconst EdmParser = <T>(\n  _d: (v: any, o: StructuredTypeFieldOptions) => T,\n  _s: (v: any, o: StructuredTypeFieldOptions) => any,\n  _e: (v: any, o: StructuredTypeFieldOptions) => any\n): Parser<T | T[]> => ({\n  deserialize(value: any, options: StructuredTypeFieldOptions): T | T[] {\n    return Array.isArray(value)\n      ? value.map((v) => _d(v, options))\n      : _d(value, options);\n  },\n  serialize(value: any, options: StructuredTypeFieldOptions): any {\n    return Array.isArray(value)\n      ? value.map((v) => _s(v, options))\n      : _s(value, options);\n  },\n  encode(value: any, options: StructuredTypeFieldOptions): any {\n    return Array.isArray(value)\n      ? value.map((v) => _e(v, options))\n      : _e(value, options);\n  },\n});\n\nconst Identity = (v: any) => v;\nconst toNumber = (v: any) => Number(v);\nconst toString = (v: any) => v.toString();\nconst toBoolean = (v: any) => Boolean(v);\nconst toDate = (v: any) => new Date(v);\n\nexport const EDM_PARSERS: { [type: string]: Parser<any> } = {\n  //Edm.Guid 16-byte (128-bit) unique identifier\n  'Edm.Guid': EdmParser<string>(Identity, Identity, (v: string) => raw(v)),\n  //Edm.Int16 Signed 16-bit integer\n  'Edm.Int16': EdmParser<number>(toNumber, toNumber, toNumber),\n  //Edm.String Sequence of UTF-8 characters\n  'Edm.String': EdmParser<string>(toString, toString, toString),\n  //Edm.Boolean Binary-valued logic\n  'Edm.Boolean': EdmParser<boolean>(toBoolean, toBoolean, toBoolean),\n  //Edm.Byte Unsigned 8-bit integer\n  'Edm.Byte': EdmParser<number>(toNumber, toNumber, toNumber),\n  //Edm.SByte Signed 8-bit integer\n  'Edm.SByte': EdmParser<number>(toNumber, toNumber, toNumber),\n  //Edm.Int32 Signed 16-bit integer\n  'Edm.Int32': EdmParser<number>(toNumber, toNumber, toNumber),\n  //Edm.Int64 Signed 16-bit integer\n  'Edm.Int64': EdmParser<number>(toNumber, toNumber, toNumber),\n  //Edm.Date Date without a time-zone offset\n  'Edm.Date': EdmParser<Date>(\n    (v: any) => new Date(`${v}T00:00:00.000Z`),\n    (v: any) => toDate(v).toISOString().substring(0, 10),\n    (v: any) => toDate(v).toISOString().substring(0, 10)\n  ),\n  //Edm.TimeOfDay Clock time 00:00-23:59:59.999999999999\n  'Edm.TimeOfDay': EdmParser<Date>(\n    (v: any) => new Date(`1970-01-01T${v}Z`),\n    (v: any) => toDate(v).toISOString().substring(11, 23),\n    (v: any) => toDate(v).toISOString().substring(11, 23)\n  ),\n  //Edm.DateTimeOffset Date and time with a time-zone offset, no leap seconds\n  'Edm.DateTimeOffset': EdmParser<Date>(\n    toDate,\n    (v: any) => toDate(v).toISOString(),\n    (v: any) => toDate(v).toISOString()\n  ),\n  //Edm.Duration Signed duration in days, hours, minutes, and (sub)seconds\n  'Edm.Duration': EdmParser<Duration>(\n    (v: any) => Durations.toDuration(v),\n    (v: Duration) => Durations.toString(v),\n    (v: Duration) => Durations.toString(v)\n  ),\n  //Edm.Decimal Numeric values with fixed precision and scale\n  'Edm.Decimal': EdmParser<number>(\n    (v: any, o: StructuredTypeFieldOptions) => {\n      if (typeof v === 'string' && o.ieee754Compatible) {\n        return parseFloat(v);\n      }\n      return v;\n    },\n    (v: number, o: StructuredTypeFieldOptions) => {\n      if (o.ieee754Compatible) {\n        return parseFloat(v.toPrecision(o.field.precision)).toFixed(\n          o.field.scale\n        );\n      }\n      return v;\n    },\n    (v: number, o: StructuredTypeFieldOptions) => {\n      if (o.ieee754Compatible) {\n        return parseFloat(v.toPrecision(o.field.precision)).toFixed(\n          o.field.scale\n        );\n      }\n      return v;\n    }\n  ),\n  //Edm.Double IEEE 754 binary64 floating-point number (15-17 decimal digits)\n  'Edm.Double': EdmParser<number>(\n    (v: any) => (v === 'INF' ? Infinity : (v as number)),\n    (v: number) => (v === Infinity ? 'INF' : v),\n    (v: number) => (v === Infinity ? 'INF' : v)\n  ),\n  //Edm.Single IEEE 754 binary32 floating-point number (6-9 decimal digits)\n  'Edm.Single': EdmParser<number>(\n    (v: any) => (v === 'INF' ? Infinity : (v as number)),\n    (v: number) => (v === Infinity ? 'INF' : v),\n    (v: number) => (v === Infinity ? 'INF' : v)\n  ),\n  //Edm.Binary Binary data\n  'Edm.Binary': EdmParser<ArrayBuffer>(\n    (v: string) => ArrayBuffers.toArrayBuffer(v),\n    (v: ArrayBuffer) => ArrayBuffers.toString(v),\n    (v: ArrayBuffer) => ArrayBuffers.toString(v)\n  ),\n};\n\n/*\nEdm.Stream Binary data stream\nEdm.Geography Abstract base type for all Geography types\nEdm.GeographyPoint A point in a round-earth coordinate system\nEdm.GeographyLineString Line string in a round-earth coordinate system\nEdm.GeographyPolygon Polygon in a round-earth coordinate system\nEdm.GeographyMultiPoint Collection of points in a round-earth coordinate system\nEdm.GeographyMultiLineString Collection of line strings in a round-earth coordinate system\nEdm.GeographyMultiPolygon Collection of polygons in a round-earth coordinate system\nEdm.GeographyCollection Collection of arbitrary Geography values\nEdm.Geometry Abstract base type for all Geometry types\nEdm.GeometryPoint Point in a flat-earth coordinate system\nEdm.GeometryLineString Line string in a flat-earth coordinate system\nEdm.GeometryPolygon Polygon in a flat-earth coordinate system\nEdm.GeometryMultiPoint Collection of points in a flat-earth coordinate system\nEdm.GeometryMultiLineString Collection of line strings in a flat-earth coordinate system\nEdm.GeometryMultiPolygon Collection of polygons in a flat-earth coordinate system\nEdm.GeometryCollection Collection of arbitrary Geometry values\n*/\n"]}

package/esm2020/lib/schema/parsers/enum-type.mjs

@@ -0,0 +1,107 @@
+import { ODataParserOptions } from '../../options';
+import { raw } from '../../resources/query';
+import { Enums, Strings } from '../../utils';
+import { ODataAnnotatable } from '../annotation';
+export class ODataEnumTypeFieldParser extends ODataAnnotatable {
+    constructor(name, field) {
+        super(field);
+        this.name = name;
+        this.value = field.value;
+    }
+    titleize(term) {
+        return (term && this.annotatedValue(term)) || this.name;
+    }
+}
+export class ODataEnumTypeParser extends ODataAnnotatable {
+    constructor(config, namespace, alias) {
+        super(config);
+        this.name = config.name;
+        this.namespace = namespace;
+        this.alias = alias;
+        this.flags = config.flags;
+        this.members = config.members;
+        this.fields = Object.entries(config.fields).map(([name, f]) => new ODataEnumTypeFieldParser(name, f));
+    }
+    /**
+     * Create a nicer looking title.
+     * Titleize is meant for creating pretty output.
+     * @param term The term of the annotation to find.
+     * @returns The titleized string.
+     */
+    ttitelize(term) {
+        return (term && this.annotatedValue(term)) || Strings.titleCase(this.name);
+    }
+    configure({ options }) {
+        this.optionsHelper = options;
+    }
+    isTypeOf(type) {
+        var names = [`${this.namespace}.${this.name}`];
+        if (this.alias)
+            names.push(`${this.alias}.${this.name}`);
+        return names.indexOf(type) !== -1;
+    }
+    // Deserialize
+    deserialize(value, options) {
+        // string -> number
+        const parserOptions = options !== undefined
+            ? new ODataParserOptions(options)
+            : this.optionsHelper;
+        if (this.flags) {
+            return Enums.toValues(this.members, value).reduce((acc, v) => acc | v, 0);
+        }
+        else {
+            return Enums.toValue(this.members, value);
+        }
+    }
+    // Serialize
+    serialize(value, options) {
+        // Enum are string | number
+        // string | number -> string
+        const parserOptions = options !== undefined
+            ? new ODataParserOptions(options)
+            : this.optionsHelper;
+        if (this.flags) {
+            const names = Enums.toNames(this.members, value);
+            return !parserOptions?.stringAsEnum
+                ? `${this.namespace}.${this.name}'${names.join(', ')}'`
+                : names.join(', ');
+        }
+        else {
+            const name = Enums.toName(this.members, value);
+            return !parserOptions?.stringAsEnum
+                ? `${this.namespace}.${this.name}'${name}'`
+                : name;
+        }
+    }
+    //Encode
+    encode(value, options) {
+        const parserOptions = options !== undefined
+            ? new ODataParserOptions(options)
+            : this.optionsHelper;
+        const serialized = this.serialize(value, parserOptions);
+        return parserOptions?.stringAsEnum
+            ? raw(`'${serialized}'`)
+            : raw(serialized);
+    }
+    // Json Schema
+    toJsonSchema() {
+        let property = {
+            title: this.name,
+            type: 'string',
+        };
+        property.enum = this.fields.map((f) => f.name);
+        return property;
+    }
+    validate(member, { method, navigation = false, } = {}) {
+        if (this.flags) {
+            let members = Enums.toValues(this.members, member);
+            return members.some((member) => !(member in this.members))
+                ? ['mismatch']
+                : undefined;
+        }
+        else {
+            return !(member in this.members) ? ['mismatch'] : undefined;
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"enum-type.js","sourceRoot":"","sources":["../../../../../../projects/angular-odata/src/lib/schema/parsers/enum-type.ts"],"names":[],"mappings":"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","sourcesContent":["import { ODataParserOptions } from '../../options';\nimport { raw } from '../../resources/query';\nimport {\n  EnumTypeConfig,\n  EnumTypeFieldConfig,\n  Options,\n  OptionsHelper,\n  Parser,\n} from '../../types';\nimport { Enums, Strings } from '../../utils';\nimport { ODataAnnotatable } from '../annotation';\n\nexport class ODataEnumTypeFieldParser extends ODataAnnotatable {\n  name: string;\n  value: number;\n\n  constructor(name: string, field: EnumTypeFieldConfig) {\n    super(field);\n    this.name = name;\n    this.value = field.value;\n  }\n\n  titleize(term?: string | RegExp): string {\n    return (term && this.annotatedValue(term)) || this.name;\n  }\n}\n\nexport class ODataEnumTypeParser<T>\n  extends ODataAnnotatable\n  implements Parser<T>\n{\n  name: string;\n  namespace: string;\n  alias?: string;\n  flags?: boolean;\n  members: { [name: string]: number } | { [value: number]: string };\n  fields: ODataEnumTypeFieldParser[];\n  optionsHelper?: OptionsHelper;\n\n  constructor(config: EnumTypeConfig<T>, namespace: string, alias?: string) {\n    super(config);\n    this.name = config.name;\n    this.namespace = namespace;\n    this.alias = alias;\n    this.flags = config.flags;\n    this.members = config.members;\n    this.fields = Object.entries(config.fields).map(\n      ([name, f]) => new ODataEnumTypeFieldParser(name, f)\n    );\n  }\n\n  /**\n   * Create a nicer looking title.\n   * Titleize is meant for creating pretty output.\n   * @param term The term of the annotation to find.\n   * @returns The titleized string.\n   */\n  ttitelize(term?: string | RegExp): string {\n    return (term && this.annotatedValue(term)) || Strings.titleCase(this.name);\n  }\n\n  configure({ options }: { options: OptionsHelper }) {\n    this.optionsHelper = options;\n  }\n\n  isTypeOf(type: string) {\n    var names = [`${this.namespace}.${this.name}`];\n    if (this.alias) names.push(`${this.alias}.${this.name}`);\n    return names.indexOf(type) !== -1;\n  }\n\n  // Deserialize\n  deserialize(value: string, options?: Options): T {\n    // string -> number\n    const parserOptions =\n      options !== undefined\n        ? new ODataParserOptions(options)\n        : this.optionsHelper;\n    if (this.flags) {\n      return Enums.toValues(this.members, value).reduce(\n        (acc, v) => acc | v,\n        0\n      ) as any;\n    } else {\n      return Enums.toValue(this.members, value) as any;\n    }\n  }\n\n  // Serialize\n  serialize(value: T, options?: Options): string {\n    // Enum are string | number\n    // string | number -> string\n    const parserOptions =\n      options !== undefined\n        ? new ODataParserOptions(options)\n        : this.optionsHelper;\n    if (this.flags) {\n      const names = Enums.toNames(this.members, value);\n      return !parserOptions?.stringAsEnum\n        ? `${this.namespace}.${this.name}'${names.join(', ')}'`\n        : names.join(', ');\n    } else {\n      const name = Enums.toName(this.members, value);\n      return !parserOptions?.stringAsEnum\n        ? `${this.namespace}.${this.name}'${name}'`\n        : name;\n    }\n  }\n\n  //Encode\n  encode(value: T, options?: Options): any {\n    const parserOptions =\n      options !== undefined\n        ? new ODataParserOptions(options)\n        : this.optionsHelper;\n    const serialized = this.serialize(value, parserOptions);\n    return parserOptions?.stringAsEnum\n      ? raw(`'${serialized}'`)\n      : raw(serialized);\n  }\n\n  // Json Schema\n  toJsonSchema() {\n    let property = <any>{\n      title: this.name,\n      type: 'string',\n    };\n    property.enum = this.fields.map((f) => f.name);\n    return property;\n  }\n\n  validate(\n    member: string | number,\n    {\n      method,\n      navigation = false,\n    }: {\n      method?: 'create' | 'update' | 'modify';\n      navigation?: boolean;\n    } = {}\n  ): string[] | undefined {\n    if (this.flags) {\n      let members = Enums.toValues(this.members, member);\n      return members.some((member) => !(member in this.members))\n        ? ['mismatch']\n        : undefined;\n    } else {\n      return !(member in this.members) ? ['mismatch'] : undefined;\n    }\n  }\n}\n"]}

package/esm2020/lib/schema/parsers/index.mjs

@@ -0,0 +1,5 @@
+export * from './edm';
+export * from './enum-type';
+export * from './structured-type';
+export * from './callable';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9hbmd1bGFyLW9kYXRhL3NyYy9saWIvc2NoZW1hL3BhcnNlcnMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxPQUFPLENBQUM7QUFDdEIsY0FBYyxhQUFhLENBQUM7QUFDNUIsY0FBYyxtQkFBbUIsQ0FBQztBQUNsQyxjQUFjLFlBQVksQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vZWRtJztcbmV4cG9ydCAqIGZyb20gJy4vZW51bS10eXBlJztcbmV4cG9ydCAqIGZyb20gJy4vc3RydWN0dXJlZC10eXBlJztcbmV4cG9ydCAqIGZyb20gJy4vY2FsbGFibGUnO1xuIl19