angular-odata 0.90.0 → 0.99.2

package/lib/{parsers → schema/parsers}/enum-type.d.ts

@@ -1,18 +1,12 @@
-import { ODataAnnotation } from '../schema/annotation';
-import { EnumTypeConfig, Parser, OptionsHelper, EnumTypeFieldConfig, Options } from '../types';
-export declare class ODataEnumTypeFieldParser {
+import { EnumTypeConfig, EnumTypeFieldConfig, Options, OptionsHelper, Parser } from '../../types';
+import { ODataAnnotatable } from '../annotation';
+export declare class ODataEnumTypeFieldParser extends ODataAnnotatable {
     name: string;
     value: number;
-    annotations: ODataAnnotation[];
     constructor(name: string, field: EnumTypeFieldConfig);
-    /**
-     * Find an annotation inside the enum field.
-     * @param predicate Function that returns true if the annotation match.
-     * @returns The annotation that matches the predicate.
-     */
-    findAnnotation(predicate: (annot: ODataAnnotation) => boolean): ODataAnnotation | undefined;
+    titleize(term?: string | RegExp): string;
 }
-export declare class ODataEnumTypeParser<T> implements Parser<T> {
+export declare class ODataEnumTypeParser<T> extends ODataAnnotatable implements Parser<T> {
     name: string;
     namespace: string;
     alias?: string;
@@ -25,6 +19,13 @@ export declare class ODataEnumTypeParser<T> implements Parser<T> {
     fields: ODataEnumTypeFieldParser[];
     optionsHelper?: OptionsHelper;
     constructor(config: EnumTypeConfig<T>, namespace: string, alias?: string);
+    /**
+     * 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?: string | RegExp): string;
     configure({ options }: {
         options: OptionsHelper;
     }): void;

package/lib/{parsers → schema/parsers}/structured-type.d.ts

@@ -1,6 +1,6 @@
-import { Parser, StructuredTypeFieldConfig, StructuredTypeConfig, OptionsHelper, Options } from '../types';
+import { Options, OptionsHelper, Parser, StructuredTypeConfig, StructuredTypeFieldConfig } from '../../types';
+import { ODataAnnotatable } from '../annotation';
 import { ODataEnumTypeParser } from './enum-type';
-import { ODataAnnotation } from '../schema/annotation';
 declare type JsonSchemaSelect<T> = Array<keyof T>;
 declare type JsonSchemaCustom<T> = {
     [P in keyof T]?: (schema: any, field: ODataStructuredTypeFieldParser<T[P]>) => any;
@@ -33,7 +33,7 @@ export declare class ODataReferential {
         referencedProperty: string;
     });
 }
-export declare class ODataStructuredTypeFieldParser<T> implements Parser<T> {
+export declare class ODataStructuredTypeFieldParser<T> extends ODataAnnotatable implements Parser<T> {
     name: string;
     private structuredType;
     type: string;
@@ -46,15 +46,8 @@ export declare class ODataStructuredTypeFieldParser<T> implements Parser<T> {
     precision?: number;
     scale?: number;
     referentials: ODataReferential[];
-    annotations: ODataAnnotation[];
     optionsHelper?: OptionsHelper;
     constructor(name: string, structuredType: ODataStructuredTypeParser<any>, field: StructuredTypeFieldConfig);
-    /**
-     * Find an annotation inside the structured field type.
-     * @param predicate Function that returns true if the annotation match.
-     * @returns The annotation that matches the predicate.
-     */
-    findAnnotation(predicate: (annot: ODataAnnotation) => boolean): ODataAnnotation | undefined;
     validate(value: any, { method, navigation, }?: {
         method?: 'create' | 'update' | 'modify';
         navigation?: boolean;
@@ -81,7 +74,7 @@ export declare class ODataStructuredTypeFieldParser<T> implements Parser<T> {
     isStructuredType(): boolean;
     structured(): ODataStructuredTypeParser<T>;
 }
-export declare class ODataStructuredTypeParser<T> implements Parser<T> {
+export declare class ODataStructuredTypeParser<T> extends ODataAnnotatable implements Parser<T> {
     name: string;
     namespace: string;
     open: boolean;
@@ -93,8 +86,15 @@ export declare class ODataStructuredTypeParser<T> implements Parser<T> {
     fields: ODataStructuredTypeFieldParser<any>[];
     optionsHelper?: OptionsHelper;
     constructor(config: StructuredTypeConfig<T>, namespace: string, alias?: string);
+    /**
+     * 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?: string | RegExp): string;
     isTypeOf(type: string): boolean;
-    typeFor(name: string): string | undefined;
+    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?: Options): T;

package/lib/schema/schema.d.ts

@@ -1,12 +1,12 @@
-import { Parser, SchemaConfig } from '../types';
-import { ODataAnnotation } from './annotation';
 import { ODataApi } from '../api';
+import { Parser, SchemaConfig } from '../types';
+import { ODataAnnotatable } from './annotation';
 import { ODataCallable } from './callable';
 import { ODataEntityContainer } from './entity-container';
 import { ODataEntitySet } from './entity-set';
 import { ODataEnumType } from './enum-type';
 import { ODataStructuredType } from './structured-type';
-export declare class ODataSchema {
+export declare class ODataSchema extends ODataAnnotatable {
     api: ODataApi;
     namespace: string;
     alias?: string;
@@ -14,16 +14,9 @@ export declare class ODataSchema {
     entities: ODataStructuredType<any>[];
     callables: ODataCallable<any>[];
     containers: ODataEntityContainer[];
-    annotations: ODataAnnotation[];
     constructor(config: SchemaConfig, api: ODataApi);
     isNamespaceOf(type: string): boolean | "" | undefined;
     get entitySets(): ODataEntitySet[];
-    /**
-     * Find an annotation inside the schema.
-     * @param predicate Function that returns true if the annotation match.
-     * @returns The annotation that matches the predicate.
-     */
-    findAnnotation(predicate: (annot: ODataAnnotation) => boolean): ODataAnnotation | undefined;
     findEnumTypeForType<T>(type: string): ODataEnumType<T> | undefined;
     findStructuredTypeForType<T>(type: string): ODataStructuredType<T> | undefined;
     findCallableForType<T>(type: string, bindingType?: string): ODataCallable<T> | undefined;

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,23 @@ 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.
+     * Returns a boolean indicating if the structured type is a subtype of the given type.
+     * @param type String representation of the type
+     * @returns True if the callable is type of the given type
      */
-    type({ alias }?: {
-        alias?: boolean;
-    }): string;
+    isSubtypeOf(schema: ODataStructuredType<any>): boolean;
     /**
-     * Returns a boolean indicating if the structured type is of the given type.
+     * Returns a boolean indicating if the structured type is a supertype 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;
+    isSupertypeOf(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
@@ -45,18 +39,12 @@ export declare class ODataStructuredType<T> {
      * @returns True if the structured type has a compound key.
      */
     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.
-     */
-    findAnnotation(predicate: (annot: ODataAnnotation) => boolean): ODataAnnotation | undefined;
     /**
      * Find the field parser for the given field name.
      * @param name Name of the field
      * @returns The field parser
      */
-    findFieldByName(name: keyof T): ODataStructuredTypeFieldParser<any> | undefined;
+    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.
@@ -68,7 +56,7 @@ export declare class ODataStructuredType<T> {
      * @param field Field that belongs to the structured type
      * @returns The schema of the field
      */
-    findSchemaForField(field: ODataStructuredTypeFieldParser<any>): ODataStructuredType<any> | undefined;
+    findSchemaForField<E>(field: ODataStructuredTypeFieldParser<any>): ODataStructuredType<E>;
     /**
      * Returns all fields of the structured type.
      * @param include_navigation Include navigation properties in the result.

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.

package/lib/services/entity.d.ts

@@ -1,6 +1,6 @@
+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;

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

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/strings.d.ts

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "angular-odata",
-  "version": "0.90.0",
+  "version": "0.99.2",
   "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
 }