@rentman/rm-core 1.5.9 → 1.6.0

package/dist/src/classes/LocalCache.d.ts

@@ -1,16 +1,17 @@
 import { CollectionCache, ItemCache, LockService } from '../classes';
 import { ChangesProcessorFactory, CollectionCacheFactory, CollectionResourceFactory, ItemCacheFactory, ItemResourceFactory } from '../factories';
-import { ErrorHandlerInterface, PromiseLibraryInterface } from '../interfaces';
+import { ErrorHandlerInterface, ExceptionHandlerInterface, PromiseLibraryInterface } from '../interfaces';
 import { CollectionEditResource, CollectionEntry, CollectionResource, CollectionResourceOptionsInterface, CollectionViewResource, EditResource, ItemEntry, ItemResource, LocalViewResource, RemoteViewResource } from '../models';
 import { CollectionEntryParentIdMap, CollectionResourceParentIdMap, CreateRequestParameterMap, ItemIdConversionMap, ItemOptionsInterface, LocalCacheCallbackCondition, OnSaveCallback, PromiseInterface } from '../types';
 export declare class LocalCache {
-    private errorHandler;
-    private lockService;
-    private itemResourceFactory;
-    private collectionCacheFactory;
     private changesProcessorFactory;
-    private itemCacheFactory;
+    private collectionCacheFactory;
     private collectionResourceFactory;
+    private errorHandler;
+    private exceptionHandler;
+    private itemCacheFactory;
+    private itemResourceFactory;
+    private lockService;
     private promiseService;
     id: string;
     items: ItemCache;
@@ -22,7 +23,7 @@ export declare class LocalCache {
     private callbacks;
     private changesInterval;
     hasChanges: boolean;
-    constructor(errorHandler: ErrorHandlerInterface, lockService: LockService, itemResourceFactory: ItemResourceFactory, collectionCacheFactory: CollectionCacheFactory, changesProcessorFactory: ChangesProcessorFactory, itemCacheFactory: ItemCacheFactory, collectionResourceFactory: CollectionResourceFactory, promiseService: PromiseLibraryInterface, id?: string);
+    constructor(changesProcessorFactory: ChangesProcessorFactory, collectionCacheFactory: CollectionCacheFactory, collectionResourceFactory: CollectionResourceFactory, errorHandler: ErrorHandlerInterface, exceptionHandler: ExceptionHandlerInterface, itemCacheFactory: ItemCacheFactory, itemResourceFactory: ItemResourceFactory, lockService: LockService, promiseService: PromiseLibraryInterface, id?: string);
     createItemResource(itemEntry: ItemEntry, options: ItemOptionsInterface & {
         edit: true;
     }, isRoot?: boolean, isNew?: boolean): EditResource;

package/dist/src/core.d.ts

@@ -1,6 +1,6 @@
 import { ApiFormatter, ApiRequestService, CollectionEntryService, CollectionHandler, CollectionResourceService, ColumnCache, ColumnHandler, ColumnUtil, ItemAdministrator, ItemEntryService, ItemHandler, ItemRequestService, KeyService, LockService, QueryService, SocketMessageHandler } from './classes';
 import { ApiResponseProcessorFactory, BatchStatusFactory, ChangesCompilationFactory, ChangesProcessorFactory, CollectionCacheFactory, CollectionEntryFactory, CollectionMatcherFactory, CollectionResourceFactory, ColumnExpansionFactory, ColumnInfoFactory, ColumnSetFactory, ColumnSubsetCacheFactory, CreateRequestFactory, ItemCacheFactory, ItemEntryFactory, ItemResourceFactory, LocalCacheFactory, ModuleChangesCompilationFactory, QueryMatcherFactory, QueryParserFactory, RequestColumnExpansionFactory, TemplateFactory } from './factories';
-import { ApiRequestServiceInterface, AuthInterface, ErrorHandlerInterface, LocalCacheManagerInterface, PromiseLibraryInterface } from './interfaces';
+import { ApiRequestServiceInterface, AuthInterface, ErrorHandlerInterface, ExceptionHandlerInterface, LocalCacheManagerInterface, PromiseLibraryInterface } from './interfaces';
 export declare class RmCore {
     version: string;
     noop: typeof noop;
@@ -42,7 +42,7 @@ export declare class RmCore {
     requestColumnExpansionFactory: RequestColumnExpansionFactory;
     socketMessageHandler: SocketMessageHandler;
     templateFactory: TemplateFactory;
-    constructor(externalApiRequestService: ApiRequestServiceInterface, localCacheManager: LocalCacheManagerInterface, authInterface: AuthInterface, errorHandlerInterface: ErrorHandlerInterface, promiseLibraryInterface: PromiseLibraryInterface);
+    constructor(apiRequestServiceInterface: ApiRequestServiceInterface, authInterface: AuthInterface, errorHandlerInterface: ErrorHandlerInterface, exceptionHandlerInterface: ExceptionHandlerInterface, localCacheManager: LocalCacheManagerInterface, promiseLibraryInterface: PromiseLibraryInterface);
 }
 export declare function noop(): void;
 export declare function identity(value: any): any;

package/dist/src/factories/CollectionEntryFactory.d.ts

@@ -1,6 +1,6 @@
 import { CollectionEntryService, ColumnHandler, ItemEntryService, ItemHandler, ItemRequestService, KeyService, QueryService } from '../classes/';
 import { ColumnExpansionFactory, ColumnSetFactory, ItemEntryFactory } from '../factories/';
-import { ErrorHandlerInterface, PromiseLibraryInterface } from '../interfaces/';
+import { ErrorHandlerInterface, ExceptionHandlerInterface, PromiseLibraryInterface } from '../interfaces/';
 import { CollectionEntry, CollectionEntryOptionsInterface } from '../models/';
 import { ItemType } from '../types/';
 export declare class CollectionEntryFactory {
@@ -9,6 +9,7 @@ export declare class CollectionEntryFactory {
     columnExpansionFactory: ColumnExpansionFactory;
     columnSetFactory: ColumnSetFactory;
     errorHandler: ErrorHandlerInterface;
+    exceptionHandler: ExceptionHandlerInterface;
     itemEntryFactory: ItemEntryFactory;
     itemEntryService: ItemEntryService;
     itemHandler: ItemHandler;
@@ -16,6 +17,6 @@ export declare class CollectionEntryFactory {
     keyService: KeyService;
     promiseService: PromiseLibraryInterface;
     queryService: QueryService;
-    constructor(collectionEntryService: CollectionEntryService, columnHandler: ColumnHandler, columnExpansionFactory: ColumnExpansionFactory, columnSetFactory: ColumnSetFactory, errorHandler: ErrorHandlerInterface, itemEntryFactory: ItemEntryFactory, itemEntryService: ItemEntryService, itemHandler: ItemHandler, itemRequestService: ItemRequestService, keyService: KeyService, promiseService: PromiseLibraryInterface, queryService: QueryService);
+    constructor(collectionEntryService: CollectionEntryService, columnHandler: ColumnHandler, columnExpansionFactory: ColumnExpansionFactory, columnSetFactory: ColumnSetFactory, errorHandler: ErrorHandlerInterface, exceptionHandler: ExceptionHandlerInterface, itemEntryFactory: ItemEntryFactory, itemEntryService: ItemEntryService, itemHandler: ItemHandler, itemRequestService: ItemRequestService, keyService: KeyService, promiseService: PromiseLibraryInterface, queryService: QueryService);
     construct(itemType: ItemType, options: CollectionEntryOptionsInterface): CollectionEntry;
 }

package/dist/src/factories/CollectionResourceFactory.d.ts

@@ -1,14 +1,15 @@
 import { KeyService, LocalCache } from '../classes';
 import { ChangesProcessorFactory, ItemResourceFactory } from '../factories';
-import { ErrorHandlerInterface, PromiseLibraryInterface } from '../interfaces';
+import { ErrorHandlerInterface, ExceptionHandlerInterface, PromiseLibraryInterface } from '../interfaces';
 import { CollectionEditResource, CollectionEntry, CollectionResourceOptionsInterface, CollectionViewResource, EditResource, LocalViewResource, RemoteViewResource } from '../models';
 export declare class CollectionResourceFactory {
     errorHandler: ErrorHandlerInterface;
+    exceptionHandler: ExceptionHandlerInterface;
     itemResourceFactory: ItemResourceFactory;
     changesProcessorFactory: ChangesProcessorFactory;
     keyService: KeyService;
     promiseService: PromiseLibraryInterface;
-    constructor(errorHandler: ErrorHandlerInterface, itemResourceFactory: ItemResourceFactory, changesProcessorFactory: ChangesProcessorFactory, keyService: KeyService, promiseService: PromiseLibraryInterface);
+    constructor(errorHandler: ErrorHandlerInterface, exceptionHandler: ExceptionHandlerInterface, itemResourceFactory: ItemResourceFactory, changesProcessorFactory: ChangesProcessorFactory, keyService: KeyService, promiseService: PromiseLibraryInterface);
     construct(collectionEntry: CollectionEntry, options: CollectionResourceOptionsInterface & {
         editItems: true;
         editCollection: true;

package/dist/src/factories/ItemEntryFactory.d.ts

@@ -1,16 +1,17 @@
 import { ApiFormatter, ColumnSet, ItemEntryService, KeyService } from '../classes';
 import { ColumnSetFactory } from '../factories';
-import { AuthInterface, PromiseLibraryInterface } from '../interfaces';
+import { ExceptionHandlerInterface, AuthInterface, PromiseLibraryInterface } from '../interfaces';
 import { ItemEntry, Template } from '../models';
 import { ApiRequestColumns, EntryParentNull, FieldMap, ItemId, ItemIdConversionMap, ItemType } from '../types';
 export declare class ItemEntryFactory {
     authInterface: AuthInterface;
     apiFormatter: ApiFormatter;
     columnSetFactory: ColumnSetFactory;
+    exceptionHandler: ExceptionHandlerInterface;
     itemEntryService: ItemEntryService;
     keyService: KeyService;
     promiseService: PromiseLibraryInterface;
-    constructor(authInterface: AuthInterface, apiFormatter: ApiFormatter, columnSetFactory: ColumnSetFactory, itemEntryService: ItemEntryService, keyService: KeyService, promiseService: PromiseLibraryInterface);
+    constructor(authInterface: AuthInterface, apiFormatter: ApiFormatter, columnSetFactory: ColumnSetFactory, exceptionHandler: ExceptionHandlerInterface, itemEntryService: ItemEntryService, keyService: KeyService, promiseService: PromiseLibraryInterface);
     constructStub(itemType: ItemType, itemId: ItemId, columnSetStub: ColumnSet): ItemEntry;
     constructLocalLinked(itemType: ItemType, itemId: ItemId, initial: FieldMap, parent: EntryParentNull, columnSet: ColumnSet, conversionMap: ItemIdConversionMap): ItemEntry;
     constructLocal(itemId: ItemId, template: Template, modified: FieldMap, derived: FieldMap, parent?: EntryParentNull, columnSet?: ColumnSet, conversionMap?: ItemIdConversionMap): ItemEntry;

package/dist/src/factories/LocalCacheFactory.d.ts

@@ -1,15 +1,16 @@
 import { LocalCache, LockService } from '../classes';
 import { ChangesProcessorFactory, CollectionCacheFactory, CollectionResourceFactory, ItemCacheFactory, ItemResourceFactory } from '../factories';
-import { ErrorHandlerInterface, PromiseLibraryInterface } from '../interfaces';
+import { ErrorHandlerInterface, ExceptionHandlerInterface, PromiseLibraryInterface } from '../interfaces';
 export declare class LocalCacheFactory {
-    private errorHandler;
-    private lockService;
-    private itemResourceFactory;
-    private collectionCacheFactory;
     private changesProcessorFactory;
-    private itemCacheFactory;
+    private collectionCacheFactory;
     private collectionResourceFactory;
+    private errorHandler;
+    private exceptionHandler;
+    private itemCacheFactory;
+    private itemResourceFactory;
+    private lockService;
     private promiseService;
-    constructor(errorHandler: ErrorHandlerInterface, lockService: LockService, itemResourceFactory: ItemResourceFactory, collectionCacheFactory: CollectionCacheFactory, changesProcessorFactory: ChangesProcessorFactory, itemCacheFactory: ItemCacheFactory, collectionResourceFactory: CollectionResourceFactory, promiseService: PromiseLibraryInterface);
+    constructor(changesProcessorFactory: ChangesProcessorFactory, collectionCacheFactory: CollectionCacheFactory, collectionResourceFactory: CollectionResourceFactory, errorHandler: ErrorHandlerInterface, exceptionHandler: ExceptionHandlerInterface, itemCacheFactory: ItemCacheFactory, itemResourceFactory: ItemResourceFactory, lockService: LockService, promiseService: PromiseLibraryInterface);
     construct(id?: string): LocalCache;
 }

package/dist/src/interfaces/ExceptionHandlerInterface.d.ts

@@ -0,0 +1,3 @@
+export interface ExceptionHandlerInterface {
+    (exception: any): void;
+}

package/dist/src/interfaces/index.d.ts

@@ -1,6 +1,7 @@
 export * from './PromiseLibraryInterface';
 export * from './LocalCacheManagerInterface';
 export * from './ErrorHandlerInterface';
+export * from './ExceptionHandlerInterface';
 export * from './AuthInterface';
 export * from './ApiRequestServiceInterface';
 export * from './SocketMessageInterface';

package/dist/src/models/CollectionEditResource.d.ts

@@ -3,7 +3,6 @@ import { CollectionResourceFactory } from '../factories';
 import { CollectionEntry, CollectionResource, CollectionResourceOptions, ItemResource, LocalViewResource } from '../models';
 import { FieldMap, ItemId, ItemIdConversionMap, PromiseInterface } from '../types';
 export declare class CollectionEditResource<T extends ItemResource = LocalViewResource> extends CollectionResource<T> {
-    private factory;
     constructor(factory: CollectionResourceFactory, collectionEntry: CollectionEntry, options: CollectionResourceOptions, localCache: LocalCache);
     save(): PromiseInterface<ItemIdConversionMap>;
     moveItems(idArray: ItemId[], destination: CollectionResource, enableCallbacks?: boolean): T[];

package/dist/src/models/CollectionEntry.d.ts

@@ -74,6 +74,8 @@ export declare class CollectionEntry {
      */
     revertChanges(): void;
     onItemsCreated(conversionMap: ConversionMap): void;
+    private onAddInitial;
+    private onRemoveInitial;
     getUpdatedItemColumns(conversionMap: ItemIdConversionMap): {
         [columnId: string]: ColumnInfo;
     };

package/dist/src/models/CollectionResource.d.ts

@@ -1,16 +1,16 @@
 import { LocalCache } from '../classes';
-import { ItemResourceFactory } from '../factories';
+import { CollectionResourceFactory } from '../factories';
 import { CollectionEntry, CollectionResourceOptions, ItemEntry, ItemResource, LocalViewResource } from '../models';
 import { ItemResourceItemIdMap, PromiseInterface, QueryCallback, ResponseColumnMap } from '../types';
 export declare abstract class CollectionResource<T extends ItemResource = LocalViewResource> {
-    private itemResourceFactory;
+    protected factory: CollectionResourceFactory;
     entry: CollectionEntry;
     options: CollectionResourceOptions;
     localCache: LocalCache;
     items: T[];
     itemIdMap: ItemResourceItemIdMap<T>;
     columns: ResponseColumnMap;
-    protected constructor(itemResourceFactory: ItemResourceFactory, entry: CollectionEntry, options: CollectionResourceOptions, localCache: LocalCache);
+    protected constructor(factory: CollectionResourceFactory, entry: CollectionEntry, options: CollectionResourceOptions, localCache: LocalCache);
     getItemById(itemId: number): T;
     rebuildMap(): void;
     addItemResources(itemEntries: ItemEntry[]): T[];
@@ -22,8 +22,8 @@ export declare abstract class CollectionResource<T extends ItemResource = LocalV
      * Filters on ItemResource.entry === ItemEntry
      */
     removeItemResources(itemEntries: ItemEntry[]): T[];
-    callOnAdd(itemResources: this['items']): void;
-    callOnRemove(itemResources: this['items']): void;
+    callOnAdd(itemResources: T[]): void;
+    callOnRemove(itemResources: T[]): void;
     forEach(callback: (itemResource: T) => void): void;
     filter(callback: (itemResource: T) => boolean): T[];
     first(callback: (itemResource: T) => boolean): T | null;
@@ -33,7 +33,7 @@ export declare abstract class CollectionResource<T extends ItemResource = LocalV
     };
     map<U>(argument: string | ((itemResource: T) => U)): U[];
     reduce<U>(callback: (itemResource: T, value: U) => U, value: U): U;
-    extend(queryCallback: QueryCallback, returnAllItems?: boolean, callOnAdd?: boolean): PromiseInterface<this['items']>;
+    extend(queryCallback: QueryCallback, returnAllItems?: boolean, callOnAdd?: boolean): PromiseInterface<T[]>;
     deactivate(): void;
     clearResource(): void;
 }

package/dist/src/models/CollectionViewResource.d.ts

@@ -1,6 +1,6 @@
 import { LocalCache } from '../classes';
-import { ItemResourceFactory } from '../factories';
+import { CollectionResourceFactory } from '../factories';
 import { CollectionEntry, CollectionResource, CollectionResourceOptions, ItemResource, LocalViewResource } from '../models';
 export declare class CollectionViewResource<T extends ItemResource = LocalViewResource> extends CollectionResource<T> {
-    constructor(itemResourceFactory: ItemResourceFactory, collectionEntry: CollectionEntry, options: CollectionResourceOptions, localCache: LocalCache);
+    constructor(collectionResourceFactory: CollectionResourceFactory, collectionEntry: CollectionEntry, options: CollectionResourceOptions, localCache: LocalCache);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rentman/rm-core",
-  "version": "1.5.9",
+  "version": "1.6.0",
   "description": "Rentman core functionalities",
   "main": "./dist/rm-core.js",
   "types": "./dist/src/index.d.ts",