@rentman/rm-core 1.5.8 → 1.6.0-1

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

@@ -15,5 +15,4 @@ export declare class ColumnExpansion {
     run(columnSet: ColumnSet): ColumnExpansionResult | null;
     aggregateRootColumns(): ColumnInfo[];
     private expandRootColumnMap;
-    private processRootColumnMap;
 }

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

@@ -1,4 +1,4 @@
-import { ColumnHandler, ColumnInfo, ColumnUtil } from '../classes';
+import { ColumnHandler, ColumnInfo, ColumnUtil, RequestColumnMergeResult } from '../classes';
 import { ColumnInfoFactory, ColumnSetFactory } from '../factories';
 import { ApiRequestColumns, ColumnExpansionResult, ItemType, ResponseColumnMap } from '../types';
 export declare class ColumnSet {
@@ -25,7 +25,6 @@ export declare class ColumnSet {
     searchable: ColumnInfo[];
     item: ColumnInfo[];
     notItem: ColumnInfo[];
-    enableCaching: boolean;
     constructor(columnHandler: ColumnHandler, columnUtil: ColumnUtil, columnInfoFactory: ColumnInfoFactory, columnSetFactory: ColumnSetFactory, itemType: ItemType, request: ApiRequestColumns);
     toJSON(): {
         main: string[];
@@ -35,12 +34,13 @@ export declare class ColumnSet {
     expandRequestColumns(columns: ApiRequestColumns): void;
     isSupersetOf(columns: ApiRequestColumns): boolean;
     private processResponseColumns;
-    private requestColumnsIsTrue;
     private processRequestColumns;
-    private getRequestColumnInfo;
-    private getColumnInfo;
-    private getColumnSetExpansion;
+    private processColumnInfo;
+    private createRootColumnMap;
+    private groupColumnInfo;
     private getMergedColumnSet;
+    mergeRequestColumns(requestColumns: ApiRequestColumns): RequestColumnMergeResult;
+    mergeResponseColumns(responseColumns: ResponseColumnMap): ResponseColumnMap;
     merge(columnSet: ColumnSet): ColumnSet;
     expand(requestColumns: ApiRequestColumns, requestColumnsTrue: boolean, responseColumns: ResponseColumnMap): ColumnExpansionResult;
 }

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

@@ -1,4 +1,8 @@
 import { ApiRequestColumn, ApiRequestColumns, ItemType, ResponseColumn, ResponseColumnMap } from '../types';
+export declare type RequestColumnMergeResult<T extends ApiRequestColumns = ApiRequestColumns, U extends ApiRequestColumns = ApiRequestColumns> = {
+    merged: T;
+    difference: U;
+};
 export declare class ColumnUtil {
     constructor();
     getColumnPath(columns: ResponseColumn[], renderAs: null | string): string;
@@ -46,22 +50,10 @@ export declare class ColumnUtil {
      * @param {Array} second
      * @returns {Object} An object containing 'merged' and 'difference' properties
      */
-    mergeRequestColumns(first: true, second: ApiRequestColumns): {
-        merged: true;
-        difference: [];
-    };
-    mergeRequestColumns(first: ApiRequestColumn[], second: true): {
-        merged: true;
-        difference: true;
-    };
-    mergeRequestColumns(first: ApiRequestColumn[], second: ApiRequestColumn[]): {
-        merged: ApiRequestColumn[];
-        difference: ApiRequestColumn[];
-    };
-    mergeRequestColumns(first: ApiRequestColumns, second: ApiRequestColumns): {
-        merged: ApiRequestColumns;
-        difference: ApiRequestColumns;
-    };
+    mergeRequestColumns(first: true, second: ApiRequestColumns): RequestColumnMergeResult<true, []>;
+    mergeRequestColumns(first: ApiRequestColumn[], second: true): RequestColumnMergeResult<true, true>;
+    mergeRequestColumns(first: ApiRequestColumn[], second: ApiRequestColumn[]): RequestColumnMergeResult<ApiRequestColumn[], ApiRequestColumn[]>;
+    mergeRequestColumns(first: ApiRequestColumns, second: ApiRequestColumns): RequestColumnMergeResult;
     mergeRequestColumn(requestColumn: ApiRequestColumn, destination: ApiRequestColumn[]): string | {
         [columnId: string]: ApiRequestColumn[];
     } | null;

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

@@ -1,6 +1,7 @@
 import { ColumnInfo } from '../classes';
-import { ResponseColumn } from '../types';
+import { ResponseColumn, RootColumnMap } from '../types';
 export declare class ColumnInfoFactory {
     constructor();
     construct(apiColumn: ResponseColumn, parent: ColumnInfo | null): ColumnInfo;
+    constructFromRootMap(rootColumnMap: RootColumnMap, parent?: ColumnInfo | null): ColumnInfo[];
 }

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,17 @@
 import { LocalCache, LockService } from '../classes';
 import { ChangesProcessorFactory, CollectionCacheFactory, CollectionResourceFactory, ItemCacheFactory, ItemResourceFactory } from '../factories';
 import { ErrorHandlerInterface, PromiseLibraryInterface } from '../interfaces';
+import { ExceptionHandlerInterface } from '../interfaces/ExceptionHandlerInterface';
 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/PromiseLibraryInterface.d.ts

@@ -17,7 +17,7 @@ export interface PromiseLibraryInterface {
     all<TAll>(promises: Array<TAll | PromiseInterface<TAll>>): PromiseInterface<TAll[]>;
     all(iterable: Array<PromiseInterface<any> | any>): PromiseInterface<any[]>;
     all<T>(promises: {
-        [K in keyof T]: (PromiseInterface<T[K]> | T[K]);
+        [K in keyof T]: (PromiseInterface<T[K]> | T[K] | null);
     }): PromiseInterface<T>;
     when<T>(value?: PromiseInterface<T> | T): PromiseInterface<T>;
     reject(value?: any): PromiseInterface<any>;

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/dist/src/types/ItemTypesCollection.d.ts

@@ -153,13 +153,6 @@ export declare type ColumnExpansionResult = {
     merged: ColumnSet;
     difference: ColumnSet;
 };
-export declare type ColumnSetExpansion = {
-    request: {
-        merged: ApiRequestColumns;
-        difference: ApiRequestColumns;
-    };
-    response: ResponseColumnMap;
-};
 export declare type RootColumnMap = {
     [columnId: string]: {
         apiColumn: ResponseColumn;

package/package.json

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