angular-odata 0.100.0 → 0.102.0

package/lib/schema/parsers/enum-type.d.ts

@@ -1,4 +1,4 @@
-import { EnumTypeConfig, EnumTypeFieldConfig, OptionsHelper, Parser } from '../../types';
+import { EnumTypeConfig, EnumTypeFieldConfig, ParserOptions, Parser } from '../../types';
 import { ODataAnnotatable } from '../annotation';
 export declare class ODataEnumTypeFieldParser extends ODataAnnotatable {
     name: string;
@@ -18,7 +18,7 @@ export declare class ODataEnumTypeParser<T> extends ODataAnnotatable implements
     };
     fields: ODataEnumTypeFieldParser[];
     stringAsEnum?: boolean;
-    optionsHelper?: OptionsHelper;
+    parserOptions?: ParserOptions;
     constructor(config: EnumTypeConfig<T>, namespace: string, alias?: string);
     /**
      * Create a nicer looking title.
@@ -27,14 +27,14 @@ export declare class ODataEnumTypeParser<T> extends ODataAnnotatable implements
      * @returns The titleized string.
      */
     ttitelize(term?: string | RegExp): string;
-    configure({ stringAsEnum, options }: {
+    configure({ stringAsEnum, options, }: {
         stringAsEnum: boolean;
-        options: OptionsHelper;
+        options: ParserOptions;
     }): void;
     isTypeOf(type: string): boolean;
-    deserialize(value: string, options?: OptionsHelper): T;
-    serialize(value: T, options?: OptionsHelper): string;
-    encode(value: T, options?: OptionsHelper): any;
+    deserialize(value: string, options?: ParserOptions): T;
+    serialize(value: T, options?: ParserOptions): string | undefined;
+    encode(value: T, options?: ParserOptions): any;
     toJsonSchema(): any;
     validate(member: string | number, { method, navigation, }?: {
         method?: 'create' | 'update' | 'modify';

package/lib/schema/parsers/structured-type.d.ts

@@ -1,4 +1,4 @@
-import { OptionsHelper, Parser, StructuredTypeConfig, StructuredTypeFieldConfig } from '../../types';
+import { ParserOptions, Parser, StructuredTypeConfig, StructuredTypeFieldConfig } from '../../types';
 import { ODataAnnotatable } from '../annotation';
 import { ODataEnumTypeParser } from './enum-type';
 declare type JsonSchemaSelect<T> = Array<keyof T>;
@@ -46,7 +46,7 @@ export declare class ODataStructuredTypeFieldParser<T> extends ODataAnnotatable
     precision?: number;
     scale?: number;
     referentials: ODataReferential[];
-    optionsHelper?: OptionsHelper;
+    parserOptions?: ParserOptions;
     constructor(name: string, structuredType: ODataStructuredTypeParser<any>, field: StructuredTypeFieldConfig);
     validate(value: any, { method, navigation, }?: {
         method?: 'create' | 'update' | 'modify';
@@ -57,13 +57,13 @@ export declare class ODataStructuredTypeFieldParser<T> extends ODataAnnotatable
         [name: string]: any;
     }[] | string[] | undefined;
     private parse;
-    deserialize(value: any, options?: OptionsHelper): T;
+    deserialize(value: any, options?: ParserOptions): T;
     private toJson;
-    serialize(value: T, options?: OptionsHelper): any;
-    encode(value: T, options?: OptionsHelper): string;
+    serialize(value: T, options?: ParserOptions): any;
+    encode(value: T, options?: ParserOptions): string;
     configure({ parserForType, options, }: {
         parserForType: (type: string) => Parser<any>;
-        options: OptionsHelper;
+        options: ParserOptions;
     }): void;
     toJsonSchema(options?: JsonSchemaOptions<T>): any;
     isKey(): boolean;
@@ -84,7 +84,7 @@ export declare class ODataStructuredTypeParser<T> extends ODataAnnotatable imple
     parent?: ODataStructuredTypeParser<any>;
     keys?: ODataEntityTypeKey[];
     fields: ODataStructuredTypeFieldParser<any>[];
-    optionsHelper?: OptionsHelper;
+    parserOptions?: ParserOptions;
     constructor(config: StructuredTypeConfig<T>, namespace: string, alias?: string);
     /**
      * Create a nicer looking title.
@@ -97,12 +97,12 @@ export declare class ODataStructuredTypeParser<T> extends ODataAnnotatable imple
     isSubtypeOf(type: string): boolean;
     findChildParser(predicate: (p: ODataStructuredTypeParser<any>) => boolean): ODataStructuredTypeParser<any> | undefined;
     childParser(predicate: (p: ODataStructuredTypeParser<any>) => boolean): Parser<any>;
-    deserialize(value: any, options?: OptionsHelper): T;
-    serialize(value: T, options?: OptionsHelper): any;
-    encode(value: T, options?: OptionsHelper): any;
+    deserialize(value: any, options?: ParserOptions): T;
+    serialize(value: T, options?: ParserOptions): any;
+    encode(value: T, options?: ParserOptions): any;
     configure({ parserForType, options, }: {
         parserForType: (type: string) => Parser<any>;
-        options: OptionsHelper;
+        options: ParserOptions;
     }): void;
     resolveKey(value: any): any;
     defaults(): {

package/lib/schema/structured-type.d.ts

@@ -1,6 +1,6 @@
 import { ODataCollection } from '../models';
 import { ODataModel } from '../models/model';
-import { OptionsHelper, StructuredTypeConfig } from '../types';
+import { ParserOptions, StructuredTypeConfig } from '../types';
 import { ODataSchemaElement } from './element';
 import { JsonSchemaOptions, ODataEntityTypeKey, ODataStructuredTypeFieldParser, ODataStructuredTypeParser } from './parsers';
 import { ODataSchema } from './schema';
@@ -96,21 +96,21 @@ export declare class ODataStructuredType<T> extends ODataSchemaElement {
      * @param options Options for deserialization
      * @returns Deserialized value
      */
-    deserialize(value: any, options?: OptionsHelper): T;
+    deserialize(value: any, options?: ParserOptions): T;
     /**
      * Serialize the given value for the structured type.
      * @param value Value to serialize
      * @param options Options for serialization
      * @returns Serialized value
      */
-    serialize(value: T, options?: OptionsHelper): any;
+    serialize(value: T, options?: ParserOptions): any;
     /**
      * Encode the given value for the structured type.
      * @param value Value to encode
      * @param options Options for encoding
      * @returns Encoded value
      */
-    encode(value: T, options?: OptionsHelper): any;
+    encode(value: T, options?: ParserOptions): any;
     /**
      * Resolve the key of the structured type for the given value.
      * @param attrs Attributes of the value

package/lib/services/base.d.ts

@@ -1,20 +1,20 @@
 import { Observable } from 'rxjs';
 import { ODataClient } from '../client';
-import { ODataActionResource, ODataEntities, ODataEntity, ODataFunctionResource, ODataNavigationPropertyResource, ODataProperty, ODataQueryArgumentsOptions } from '../resources';
+import { ODataActionOptions, ODataActionResource, ODataEntities, ODataEntity, ODataFunctionOptions, ODataFunctionResource, ODataNavigationPropertyResource, ODataProperty, ODataQueryArgumentsOptions } from '../resources';
 export declare abstract class ODataBaseService {
     protected client: ODataClient;
     protected name: string;
     protected apiNameOrEntityType?: string | undefined;
     constructor(client: ODataClient, name: string, apiNameOrEntityType?: string | undefined);
     get api(): import("angular-odata").ODataApi;
-    protected callFunction<P, R>(params: P | null, resource: ODataFunctionResource<P, R>, responseType: 'entity', options?: ODataQueryArgumentsOptions<R>): Observable<ODataEntity<R>>;
-    protected callFunction<P, R>(params: P | null, resource: ODataFunctionResource<P, R>, responseType: 'entities', options?: ODataQueryArgumentsOptions<R>): Observable<ODataEntities<R>>;
-    protected callFunction<P, R>(params: P | null, resource: ODataFunctionResource<P, R>, responseType: 'property', options?: ODataQueryArgumentsOptions<R>): Observable<ODataProperty<R>>;
-    protected callFunction<P, R>(params: P | null, resource: ODataFunctionResource<P, R>, responseType: 'none', options?: ODataQueryArgumentsOptions<R>): Observable<null>;
-    protected callAction<P, R>(params: P | null, resource: ODataActionResource<P, R>, responseType: 'entity', options?: ODataQueryArgumentsOptions<R>): Observable<ODataEntity<R>>;
-    protected callAction<P, R>(params: P | null, resource: ODataActionResource<P, R>, responseType: 'entities', options?: ODataQueryArgumentsOptions<R>): Observable<ODataEntities<R>>;
-    protected callAction<P, R>(params: P | null, resource: ODataActionResource<P, R>, responseType: 'property', options?: ODataQueryArgumentsOptions<R>): Observable<ODataProperty<R>>;
-    protected callAction<P, R>(params: P | null, resource: ODataActionResource<P, R>, responseType: 'none', options?: ODataQueryArgumentsOptions<R>): Observable<null>;
+    protected callFunction<P, R>(params: P | null, resource: ODataFunctionResource<P, R>, responseType: 'entity', options?: ODataFunctionOptions<R>): Observable<ODataEntity<R>>;
+    protected callFunction<P, R>(params: P | null, resource: ODataFunctionResource<P, R>, responseType: 'entities', options?: ODataFunctionOptions<R>): Observable<ODataEntities<R>>;
+    protected callFunction<P, R>(params: P | null, resource: ODataFunctionResource<P, R>, responseType: 'property', options?: ODataFunctionOptions<R>): Observable<ODataProperty<R>>;
+    protected callFunction<P, R>(params: P | null, resource: ODataFunctionResource<P, R>, responseType: 'none', options?: ODataFunctionOptions<R>): Observable<null>;
+    protected callAction<P, R>(params: P | null, resource: ODataActionResource<P, R>, responseType: 'entity', options?: ODataActionOptions<R>): Observable<ODataEntity<R>>;
+    protected callAction<P, R>(params: P | null, resource: ODataActionResource<P, R>, responseType: 'entities', options?: ODataActionOptions<R>): Observable<ODataEntities<R>>;
+    protected callAction<P, R>(params: P | null, resource: ODataActionResource<P, R>, responseType: 'property', options?: ODataActionOptions<R>): Observable<ODataProperty<R>>;
+    protected callAction<P, R>(params: P | null, resource: ODataActionResource<P, R>, responseType: 'none', options?: ODataActionOptions<R>): Observable<null>;
     protected fetchNavigationProperty<S>(resource: ODataNavigationPropertyResource<S>, responseType: 'entity', options?: ODataQueryArgumentsOptions<S>): Observable<ODataEntity<S>>;
     protected fetchNavigationProperty<S>(resource: ODataNavigationPropertyResource<S>, responseType: 'entities', options?: ODataQueryArgumentsOptions<S>): Observable<ODataEntities<S>>;
 }

package/lib/types.d.ts

@@ -1,4 +1,3 @@
-import { ODataVersionHelper } from './helper';
 import { Observable } from 'rxjs';
 export declare type ODataVersion = '2.0' | '3.0' | '4.0';
 export declare type FetchPolicy = 'cache-first' | 'cache-and-network' | 'network-only' | 'no-cache' | 'cache-only';
@@ -65,25 +64,24 @@ export interface ApiOptions {
     deleteRefBy?: 'path' | 'id';
     nonParenthesisForEmptyParameterFunction?: boolean;
 }
-export interface OptionsHelper {
+export interface ParserOptions {
     version?: ODataVersion;
-    helper: ODataVersionHelper;
     exponentialDecimals?: boolean;
     metadata?: ODataMetadataType;
     ieee754Compatible?: boolean;
     streaming?: boolean;
 }
-export interface ResponseOptions extends OptionsHelper {
+export interface ResponseOptions extends ParserOptions {
     cacheability?: CacheCacheability;
     maxAge?: number;
 }
-export interface StructuredTypeFieldOptions extends OptionsHelper {
+export interface StructuredTypeFieldOptions extends ParserOptions {
     field: StructuredTypeFieldConfig;
 }
 export interface Parser<T> {
-    deserialize(value: any, options?: OptionsHelper | StructuredTypeFieldOptions): T;
-    serialize(value: any, options?: OptionsHelper | StructuredTypeFieldOptions): any;
-    encode(value: any, options?: OptionsHelper | StructuredTypeFieldOptions): any;
+    deserialize(value: any, options?: ParserOptions | StructuredTypeFieldOptions): T;
+    serialize(value: any, options?: ParserOptions | StructuredTypeFieldOptions): any;
+    encode(value: any, options?: ParserOptions | StructuredTypeFieldOptions): any;
 }
 export declare const NONE_PARSER: Parser<any>;
 export interface Cache {

package/lib/utils/arrays.d.ts

@@ -0,0 +1,3 @@
+export declare const Arrays: {
+    zip: (...arrays: any[][]) => any[][];
+};

package/lib/utils/enums.d.ts

@@ -1,8 +1,8 @@
 export declare const Enums: {
     names<E>(Enum: E): string[];
     values<E_1>(Enum: E_1): number[];
-    toValue<E_2>(Enum: E_2, value: any): number;
+    toValue<E_2>(Enum: E_2, value: any): number | undefined;
     toValues<E_3>(Enum: E_3, value: any): number[];
-    toName<E_4>(Enum: E_4, value: any): string;
+    toName<E_4>(Enum: E_4, value: any): string | undefined;
     toNames<E_5>(Enum: E_5, value: any): string[];
 };

package/lib/utils/objects.d.ts

@@ -19,5 +19,5 @@ export declare const Objects: {
     resolveKey(key: any, { single }?: {
         single?: boolean | undefined;
     }): any;
-    clone(target: any, map?: WeakMap<object, any> | undefined): any;
+    clone(target: any, map?: WeakMap<object, any>): any;
 };

package/lib/utils/strings.d.ts

@@ -1,4 +1,4 @@
 export declare const Strings: {
-    uniqueId(prefix?: string | undefined, suffix?: string | undefined): string;
+    uniqueId(prefix?: string, suffix?: string): string;
     titleCase(text: string): string;
 };

package/lib/utils/types.d.ts

@@ -4,6 +4,7 @@ export declare const Types: {
     isPlainObject(value: any): boolean;
     isFunction(value: any): boolean;
     isArray(value: any): boolean;
+    isMap(value: any): boolean;
     isEmpty(value: any): boolean;
     isEqual(value1: any, value2: any): boolean;
     clone(target: any): any;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "angular-odata",
-  "version": "0.100.0",
+  "version": "0.102.0",
   "license": "MIT",
   "description": "Client side OData typescript library for Angular",
   "repository": {
@@ -25,8 +25,8 @@
   "homepage": "https://github.com/diegomvh/angular-odata",
   "private": false,
   "peerDependencies": {
-    "@angular/common": "^13.1.0",
-    "@angular/core": "^13.1.0"
+    "@angular/common": ">=13.0.0",
+    "@angular/core": ">=13.0.0"
   },
   "dependencies": {
     "tslib": "^2.3.0"
@@ -36,13 +36,13 @@
   "esm2020": "esm2020/angular-odata.mjs",
   "fesm2020": "fesm2020/angular-odata.mjs",
   "fesm2015": "fesm2015/angular-odata.mjs",
-  "typings": "angular-odata.d.ts",
+  "typings": "index.d.ts",
   "exports": {
     "./package.json": {
       "default": "./package.json"
     },
     ".": {
-      "types": "./angular-odata.d.ts",
+      "types": "./index.d.ts",
       "esm2020": "./esm2020/angular-odata.mjs",
       "es2020": "./fesm2020/angular-odata.mjs",
       "es2015": "./fesm2015/angular-odata.mjs",