angular-odata 0.80.0 → 0.99.0

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

@@ -1,12 +1,10 @@
-import { JsonSchemaOptions, ODataEntityTypeKey, ODataStructuredTypeFieldParser, ODataStructuredTypeParser } from '../parsers';
-import { Options, StructuredTypeConfig } from '../types';
-import { ODataAnnotation } from './annotation';
 import { ODataCollection } from '../models';
 import { ODataModel } from '../models/model';
+import { Options, StructuredTypeConfig } from '../types';
+import { ODataSchemaElement } from './element';
+import { JsonSchemaOptions, ODataEntityTypeKey, ODataStructuredTypeFieldParser, ODataStructuredTypeParser } from './parsers';
 import { ODataSchema } from './schema';
-export declare class ODataStructuredType<T> {
-    name: string;
-    schema: ODataSchema;
+export declare class ODataStructuredType<T> extends ODataSchemaElement {
     base?: string;
     open: boolean;
     parent?: ODataStructuredType<any>;
@@ -14,27 +12,17 @@ export declare class ODataStructuredType<T> {
     model?: typeof ODataModel;
     collection?: typeof ODataCollection;
     parser: ODataStructuredTypeParser<T>;
-    annotations: ODataAnnotation[];
     constructor(config: StructuredTypeConfig<T>, schema: ODataSchema);
-    get api(): import("angular-odata").ODataApi;
     configure({ parserForType, findOptionsForType, }: {
         parserForType: (type: string) => any;
         findOptionsForType: (type: string) => any;
     }): void;
     /**
-     * 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 }?: {
-        alias?: boolean;
-    }): string;
-    /**
-     * Returns a boolean indicating if the structured type is of the given type.
+     * 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
      */
-    isTypeOf(type: string): boolean;
+    isSubtypeOf(schema: ODataStructuredType<any>): boolean;
     /**
      * Returns a boolean indicating if the structured type has a simple key.
      * @returns True if the structured type has a simple key
@@ -46,20 +34,50 @@ export declare class ODataStructuredType<T> {
      */
     isCompoundKey(): boolean;
     /**
-     * Find an annotation inside the structured type
-     * @param predicate Function that returns true if the annotation match.
-     * @returns The annotation that matches the predicate.
+     * Find the field parser for the given field name.
+     * @param name Name of the field
+     * @returns The field parser
      */
-    findAnnotation(predicate: (annot: ODataAnnotation) => boolean): ODataAnnotation | undefined;
-    field(name: keyof T): ODataStructuredTypeFieldParser<any> | undefined;
-    fields({ include_navigation, include_parents, }?: {
-        include_parents?: boolean;
-        include_navigation?: boolean;
+    findFieldByName<F>(name: keyof T): ODataStructuredTypeFieldParser<F> | undefined;
+    /**
+     * Find a parent schema of the structured type.
+     * @param predicate Function for evaluate the schemas in the hierarchy.
+     * @returns The schema that matches the predicate.
+     */
+    findParentSchema(predicate: (p: ODataStructuredType<any>) => boolean): ODataStructuredType<any> | undefined;
+    /**
+     * Find a parent schema of the structured type for the given field.
+     * @param field Field that belongs to the structured type
+     * @returns The schema of the field
+     */
+    findSchemaForField<E>(field: ODataStructuredTypeFieldParser<any>): ODataStructuredType<E>;
+    /**
+     * Returns all fields of the structured type.
+     * @param include_navigation Include navigation properties in the result.
+     * @param include_parents Include the parent types in the result.
+     * @returns All fields of the structured type.
+     */
+    fields({ include_navigation, include_parents, }: {
+        include_parents: boolean;
+        include_navigation: boolean;
     }): ODataStructuredTypeFieldParser<any>[];
+    /**
+     * Returns the keys of the structured type.
+     * @param include_parents Include the parent fields
+     * @returns The keys of the structured type
+     */
     keys({ include_parents, }?: {
         include_parents?: boolean;
     }): ODataEntityTypeKey[];
-    pick(value: {
+    /**
+     * Picks the fields from attributes.
+     * @param attrs
+     * @param include_parents Include the parent fields
+     * @param include_navigation Include the navigation fields
+     * @param include_etag Include the etag field
+     * @returns The picked fields
+     */
+    pick(attrs: {
         [name: string]: any;
     }, { include_parents, include_navigation, include_etag, }?: {
         include_parents?: boolean;
@@ -87,13 +105,33 @@ export declare class ODataStructuredType<T> {
      * @returns Encoded value
      */
     encode(value: T, options?: Options): any;
+    /**
+     * Resolve the key of the structured type for the given value.
+     * @param attrs Attributes of the value
+     * @returns Resolved key
+     */
     resolveKey(attrs: T | {
         [name: string]: any;
     }): any;
+    /**
+     * Returns the defaults values for the structured type.
+     * @returns Default values for the structured type
+     */
     defaults(): {
         [name: string]: any;
     };
+    /**
+     * Convert the structured type to json schema
+     * @param options Options for json schema
+     * @returns Json Schema
+     */
     toJsonSchema(options?: JsonSchemaOptions<T>): any;
+    /**
+     * Validate the given value against the structured type.
+     * @param attrs Attributes of the value
+     * @param method Method to use for the process validation
+     * @returns Object with the errors
+     */
     validate(attrs: Partial<T>, { method, navigation, }?: {
         method?: 'create' | 'update' | 'modify';
         navigation?: boolean;

package/lib/services/base.d.ts

@@ -1,6 +1,6 @@
-import { ODataActionResource, ODataEntities, ODataEntity, ODataFunctionResource, ODataNavigationPropertyResource, ODataProperty, ODataQueryArgumentsOptions } from '../resources';
-import { ODataClient } from '../client';
 import { Observable } from 'rxjs';
+import { ODataClient } from '../client';
+import { ODataActionResource, ODataEntities, ODataEntity, ODataFunctionResource, ODataNavigationPropertyResource, ODataProperty, ODataQueryArgumentsOptions } from '../resources';
 export declare abstract class ODataBaseService {
     protected client: ODataClient;
     protected name: string;

package/lib/services/entity-set.d.ts

@@ -1,8 +1,8 @@
-import { EntityKey, ODataEntities, ODataEntity, ODataEntityResource, ODataEntitySetResource, ODataOptions } from '../resources';
 import { Observable } from 'rxjs';
 import { ODataCollection } from '../models/collection';
-import { ODataEntityService } from './entity';
 import { ODataModel } from '../models/model';
+import { EntityKey, ODataEntities, ODataEntity, ODataEntityResource, ODataEntitySetResource, ODataOptions } from '../resources';
+import { ODataEntityService } from './entity';
 export declare class ODataEntitySetService<T> extends ODataEntityService<T> {
     /**
      * Get the entity set resource for this service.
@@ -19,6 +19,9 @@ export declare class ODataEntitySetService<T> extends ODataEntityService<T> {
      */
     attach<M extends ODataModel<T>>(model: M): void;
     attach<C extends ODataCollection<T, ODataModel<T>>>(model: C): void;
+    /**
+     * The schema for the entity set.
+     */
     get entitySetSchema(): import("angular-odata").ODataEntitySet | undefined;
     /**
      * Get all entities from the entity set.

package/lib/services/entity.d.ts

@@ -1,8 +1,11 @@
+import { ODataModel } from '../models/model';
 import { EntityKey, ODataResource } from '../resources';
 import { ODataBaseService } from './base';
-import { ODataModel } from '../models/model';
 export declare abstract class ODataEntityService<T> extends ODataBaseService {
     abstract entity(key?: EntityKey<T>): ODataResource<T>;
     abstract attach<M extends ODataModel<T>>(value: M): void;
+    /**
+     * The schema for the structured type.
+     */
     get structuredTypeSchema(): import("angular-odata").ODataStructuredType<T> | undefined;
 }

package/lib/services/singleton.d.ts

@@ -1,7 +1,7 @@
+import { Observable } from 'rxjs';
+import type { ODataModel } from '../models/model';
 import type { ODataEntity, ODataOptions, ODataSingletonResource } from '../resources';
 import { ODataEntityService } from './entity';
-import type { ODataModel } from '../models/model';
-import { Observable } from 'rxjs';
 /**
  * OData Singleton Service
  * www.odata.org/getting-started/advanced-tutorial/#singleton
@@ -17,6 +17,9 @@ export declare class ODataSingletonService<T> extends ODataEntityService<T> {
      * @param model The model to attach.
      */
     attach<M extends ODataModel<T>>(model: M): void;
+    /**
+     * The schema for the singleton.
+     */
     get singletonSchema(): import("angular-odata").ODataEntitySet | undefined;
     /**
      * Update the singleton entity

package/lib/settings.d.ts

@@ -1,10 +1,10 @@
-import { ApiConfig, Parser } from './types';
-import { ODataCallable, ODataEntitySet, ODataEnumType, ODataStructuredType } from './schema';
-import { ODataCollection, ODataModel } from './models';
+import { Observable } from 'rxjs';
 import { ODataApi } from './api';
-import { ODataEntityService } from './services/entity';
+import { ODataCollection, ODataModel } from './models';
 import { ODataRequest } from './resources';
-import { Observable } from 'rxjs';
+import { ODataCallable, ODataEntitySet, ODataEnumType, ODataStructuredType } from './schema';
+import { ODataEntityService } from './services/entity';
+import { ApiConfig, Parser } from './types';
 export declare class ODataSettings {
     apis: ODataApi[];
     constructor(...configs: ApiConfig[]);

package/lib/types.d.ts

@@ -63,6 +63,7 @@ export interface ApiOptions extends Options {
     stripMetadata?: ODataMetadataType;
     fetchPolicy?: FetchPolicy;
     bodyQueryOptions?: QueryOptionNames[];
+    deleteRefBy?: 'path' | 'id';
 }
 export interface OptionsHelper extends Options {
     helper: ODataVersionHelper;

package/lib/utils/arraybuffers.d.ts

@@ -0,0 +1,4 @@
+export declare const ArrayBuffers: {
+    toArrayBuffer(v: string): ArrayBuffer;
+    toString(v: ArrayBuffer): string;
+};

package/lib/{parsers/edm.d.ts → utils/durations.d.ts}

@@ -1,4 +1,3 @@
-import { Parser } from '../types';
 export declare type Duration = {
     sign?: 1 | -1;
     years?: number;
@@ -9,6 +8,7 @@ export declare type Duration = {
     minutes?: number;
     seconds?: number;
 };
-export declare const EDM_PARSERS: {
-    [type: string]: Parser<any>;
+export declare const Durations: {
+    toDuration(v: string): Duration;
+    toString(v: Duration): string;
 };

package/lib/utils/http.d.ts

@@ -7,6 +7,7 @@ export declare const Http: {
         [param: string]: string | string[];
     })[]): HttpParams;
     splitHttpParams(params: HttpParams, keys: string[]): [HttpParams, HttpParams];
+    withoutHttpParams(params: HttpParams, keys: string[]): HttpParams;
     resolveHeaderKey(headers: HttpHeaders | {
         [param: string]: string | string[];
     }, options: string[]): string | undefined;

package/lib/utils/index.d.ts

@@ -1,4 +1,5 @@
 export * from './dates';
+export * from './durations';
 export * from './enums';
 export * from './http';
 export * from './objects';

package/lib/utils/objects.d.ts

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

package/lib/utils/strings.d.ts

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

package/lib/utils/types.d.ts

@@ -1,8 +1,10 @@
 export declare const Types: {
+    rawType(value: any): string;
     isObject(value: any): boolean;
     isPlainObject(value: any): boolean;
     isFunction(value: any): boolean;
     isArray(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.80.0",
+  "version": "0.99.0",
   "license": "MIT",
   "description": "Client side OData typescript library for Angular",
   "repository": {
@@ -25,17 +25,30 @@
   "homepage": "https://github.com/diegomvh/angular-odata",
   "private": false,
   "peerDependencies": {
-    "@angular/common": "^12.2.0",
-    "@angular/core": "^12.2.0"
+    "@angular/common": "^13.1.0",
+    "@angular/core": "^13.1.0"
   },
   "dependencies": {
     "tslib": "^2.3.0"
   },
-  "main": "bundles/angular-odata.umd.js",
-  "module": "fesm2015/angular-odata.js",
-  "es2015": "fesm2015/angular-odata.js",
-  "esm2015": "esm2015/angular-odata.js",
-  "fesm2015": "fesm2015/angular-odata.js",
+  "module": "fesm2015/angular-odata.mjs",
+  "es2020": "fesm2020/angular-odata.mjs",
+  "esm2020": "esm2020/angular-odata.mjs",
+  "fesm2020": "fesm2020/angular-odata.mjs",
+  "fesm2015": "fesm2015/angular-odata.mjs",
   "typings": "angular-odata.d.ts",
+  "exports": {
+    "./package.json": {
+      "default": "./package.json"
+    },
+    ".": {
+      "types": "./angular-odata.d.ts",
+      "esm2020": "./esm2020/angular-odata.mjs",
+      "es2020": "./fesm2020/angular-odata.mjs",
+      "es2015": "./fesm2015/angular-odata.mjs",
+      "node": "./fesm2015/angular-odata.mjs",
+      "default": "./fesm2020/angular-odata.mjs"
+    }
+  },
   "sideEffects": false
 }