@rentman/rm-core 1.6.13-3 → 1.7.1

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

@@ -1,14 +1,11 @@
-import { QueryMatcherFactory } from '../factories';
+import { CollectionResourceFactory, QueryMatcherFactory } from '../factories';
 import { CollectionEntry, CollectionResource } from '../models';
 import { CollectionMatchResult, CollectionQuery, EntryParentNull, FieldMap, ItemId, ItemType } from '../types';
 export declare class CollectionCache {
+    private collectionResourceFactory;
     private queryMatcherFactory;
-    entries: {
-        [itemType: string]: {
-            [collectionEntryId: number]: CollectionEntry;
-        };
-    };
-    constructor(queryMatcherFactory: QueryMatcherFactory);
+    private entries;
+    constructor(collectionResourceFactory: CollectionResourceFactory, queryMatcherFactory: QueryMatcherFactory);
     contains(collectionEntry: CollectionEntry): boolean;
     some(callback: (entry: CollectionEntry) => boolean): boolean;
     forEach(callback: (entry: CollectionEntry) => void): void;

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

@@ -1,12 +1,14 @@
-import { ColumnInfo, ColumnUtil, RequestColumnMergeResult } from '../classes';
-import { ColumnSetFactory } from '../factories';
+import { ColumnHandler, ColumnInfo, ColumnUtil, RequestColumnMergeResult } from '../classes';
+import { ColumnInfoFactory, ColumnSetFactory } from '../factories';
 import { ApiRequestColumns, ColumnExpansionResult, ItemType, ResponseColumnMap } from '../types';
 export declare class ColumnSet {
+    private columnHandler;
     private columnUtil;
+    private columnInfoFactory;
     private columnSetFactory;
     itemType: ItemType;
-    id: number;
     request: ApiRequestColumns;
+    id: number;
     requestColumnsTrue: boolean;
     response: ResponseColumnMap;
     link: ColumnInfo | null;
@@ -23,14 +25,19 @@ export declare class ColumnSet {
     searchable: ColumnInfo[];
     item: ColumnInfo[];
     notItem: ColumnInfo[];
-    constructor(columnUtil: ColumnUtil, columnSetFactory: ColumnSetFactory, itemType: ItemType);
-    groupColumnInfo(columnInfo: ColumnInfo): void;
+    constructor(columnHandler: ColumnHandler, columnUtil: ColumnUtil, columnInfoFactory: ColumnInfoFactory, columnSetFactory: ColumnSetFactory, itemType: ItemType, request: ApiRequestColumns);
     toJSON(): {
         main: string[];
         derived: string[];
     };
+    resolve(responseColumns: ResponseColumnMap, enableCaching?: boolean, includeIdColumn?: boolean): this;
     expandRequestColumns(columns: ApiRequestColumns): void;
     isSupersetOf(columns: ApiRequestColumns): boolean;
+    private processResponseColumns;
+    private processRequestColumns;
+    private processColumnInfo;
+    private createRootColumnMap;
+    private groupColumnInfo;
     private getMergedColumnSet;
     mergeRequestColumns(requestColumns: ApiRequestColumns): RequestColumnMergeResult;
     mergeResponseColumns(responseColumns: ResponseColumnMap): ResponseColumnMap;

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

@@ -1,210 +1,207 @@
-import { CollectionCache, CollectionHandler, CollectionMatcher, ItemCache, ItemHandler, ItemRequestService, KeyService, LocalCache, LocalCacheCallbackCondition, LocalCacheCallbackType, ModuleChangesCompilationResult, QueryService } from '../classes';
-import { CollectionMatcherFactory, ColumnSetFactory, LocalCacheFactory, ModuleChangesCompilationFactory } from '../factories';
+import { CollectionCache, CollectionHandler, CollectionMatcher, ItemCache, ItemHandler, ItemRequestService, KeyService, LocalCache, ModuleChangesCompilationResult, QueryService } from '../classes';
+import { CollectionMatcherFactory, CollectionResourceFactory, ColumnSetFactory, ItemResourceFactory, ModuleChangesCompilationFactory } from '../factories';
 import { ApiRequestServiceInterface, AuthInterface, ErrorHandlerInterface, LocalCacheManagerInterface, PromiseLibraryInterface } from '../interfaces';
 import { CollectionEditResource, CollectionEntry, CollectionResource, CollectionResourceOptionsInterface, CollectionViewResource, EditResource, ItemEntry, ItemResource, ItemResourceOptionsInterface, LocalViewResource, RemoteViewResource } from '../models';
-import { ApiQuery, CollectionDefinition, CollectionOptionsInterface, CollectionResourceParentIdMap, ConversionMap, CreateRequestParameterMap, ItemId, ItemIdConversionMap, ItemOptionsInterface, ItemResourcesItemTypeMap, ItemType, LinkCollectionDefinition, LinkedItemEntryMap, PromiseInterface } from '../types';
+import { ApiQuery, CollectionDefinition, CollectionOptionsInterface, CollectionResourceParentIdMap, ConversionMap, CreateRequestParameterMap, ItemId, ItemIdConversionMap, ItemOptionsInterface, ItemResourcesItemTypeMap, ItemType, LinkCollectionDefinition, LinkedItemEntryMap, LocalCacheCallbackCondition, OnSaveCallback, PromiseInterface } from '../types';
 export declare class ItemAdministrator {
     private apiRequestService;
     private authInterface;
     private collectionHandler;
     private collectionMatcherFactory;
+    private collectionResourceFactory;
     private columnSetFactory;
     private errorHandler;
     private itemHandler;
     private itemRequestService;
+    private itemResourceFactory;
     private keyService;
-    private localCacheFactory;
     private localCacheManager;
     private moduleChangesCompilationFactory;
     private promiseInterface;
     private queryService;
-    constructor(apiRequestService: ApiRequestServiceInterface, authInterface: AuthInterface, collectionHandler: CollectionHandler, collectionMatcherFactory: CollectionMatcherFactory, columnSetFactory: ColumnSetFactory, errorHandler: ErrorHandlerInterface, itemHandler: ItemHandler, itemRequestService: ItemRequestService, keyService: KeyService, localCacheFactory: LocalCacheFactory, localCacheManager: LocalCacheManagerInterface, moduleChangesCompilationFactory: ModuleChangesCompilationFactory, promiseInterface: PromiseLibraryInterface, queryService: QueryService);
+    constructor(apiRequestService: ApiRequestServiceInterface, authInterface: AuthInterface, collectionHandler: CollectionHandler, collectionMatcherFactory: CollectionMatcherFactory, collectionResourceFactory: CollectionResourceFactory, columnSetFactory: ColumnSetFactory, errorHandler: ErrorHandlerInterface, itemHandler: ItemHandler, itemRequestService: ItemRequestService, itemResourceFactory: ItemResourceFactory, keyService: KeyService, localCacheManager: LocalCacheManagerInterface, moduleChangesCompilationFactory: ModuleChangesCompilationFactory, promiseInterface: PromiseLibraryInterface, queryService: QueryService);
     invalidateCache(): void;
+    clearResources(level: number): void;
     getCollectionMatcher(itemEntries: ItemEntry[], addToTab?: boolean, callOnAdd?: boolean): CollectionMatcher;
     fetchTitle(itemType: ItemType, itemId: ItemId, deferRequest?: boolean): PromiseInterface<string>;
     getItemById(itemType: ItemType, itemId: ItemId, options: ItemOptionsInterface & {
         edit: true;
-    }, isRoot?: boolean): PromiseInterface<EditResource>;
+    }, level?: number, isRoot?: boolean): PromiseInterface<EditResource>;
     getItemById(itemType: ItemType, itemId: ItemId, options: ItemOptionsInterface & {
         remote: true;
-    }, isRoot?: boolean): PromiseInterface<RemoteViewResource>;
-    getItemById(itemType: ItemType, itemId: ItemId, options: ItemOptionsInterface, isRoot?: boolean): PromiseInterface<LocalViewResource>;
+    }, level?: number, isRoot?: boolean): PromiseInterface<RemoteViewResource>;
+    getItemById(itemType: ItemType, itemId: ItemId, options: ItemOptionsInterface, level?: number, isRoot?: boolean): PromiseInterface<LocalViewResource>;
     getItemsById(itemType: ItemType, itemIds: ItemId[], options: ItemOptionsInterface & {
         edit: true;
-    }): PromiseInterface<EditResource[]>;
+    }, level?: number): PromiseInterface<EditResource[]>;
     getItemsById(itemType: ItemType, itemIds: ItemId[], options: ItemOptionsInterface & {
         remote: true;
-    }): PromiseInterface<RemoteViewResource[]>;
-    getItemsById(itemType: ItemType, itemIds: ItemId[], options: ItemOptionsInterface): PromiseInterface<LocalViewResource[]>;
+    }, level?: number): PromiseInterface<RemoteViewResource[]>;
+    getItemsById(itemType: ItemType, itemIds: ItemId[], options: ItemOptionsInterface, level?: number): PromiseInterface<LocalViewResource[]>;
     getItemsByQuery(itemType: ItemType, query: ApiQuery, options: ItemOptionsInterface & {
         edit: true;
-    }): PromiseInterface<EditResource[]>;
+    }, level?: number): PromiseInterface<EditResource[]>;
     getItemsByQuery(itemType: ItemType, query: ApiQuery, options: ItemOptionsInterface & {
         remote: true;
-    }): PromiseInterface<RemoteViewResource[]>;
-    getItemsByQuery(itemType: ItemType, query: ApiQuery, options: ItemOptionsInterface): PromiseInterface<LocalViewResource[]>;
-    getNewResource(itemType: ItemType, options: ItemOptionsInterface, returnLinks: true, isRoot?: boolean): PromiseInterface<{
+    }, level?: number): PromiseInterface<RemoteViewResource[]>;
+    getItemsByQuery(itemType: ItemType, query: ApiQuery, options: ItemOptionsInterface, level?: number): PromiseInterface<LocalViewResource[]>;
+    getNewResource(itemType: ItemType, options: ItemOptionsInterface, returnLinks: true, level?: number, isRoot?: boolean): PromiseInterface<{
         main: EditResource;
         linked: ItemResourcesItemTypeMap;
     }>;
-    getNewResource(itemType: ItemType, options: ItemOptionsInterface, returnLinks?: boolean, isRoot?: boolean): PromiseInterface<EditResource>;
+    getNewResource(itemType: ItemType, options: ItemOptionsInterface, returnLinks?: boolean, level?: number, isRoot?: boolean): PromiseInterface<EditResource>;
     getDuplicateById(itemType: ItemType, duplicateId: ItemId, options: ItemOptionsInterface & {
         edit: true;
-    }, returnLinks?: boolean, isRoot?: boolean): PromiseInterface<EditResource>;
+    }, level?: number, returnLinks?: boolean, isRoot?: boolean): PromiseInterface<EditResource>;
     getDuplicateById(itemType: ItemType, duplicateId: ItemId, options: ItemOptionsInterface & {
         remote: true;
-    }, returnLinks?: boolean, isRoot?: boolean): PromiseInterface<RemoteViewResource>;
-    getDuplicateById(itemType: ItemType, duplicateId: ItemId, options: ItemOptionsInterface, returnLinks?: boolean, isRoot?: boolean): PromiseInterface<LocalViewResource>;
+    }, level?: number, returnLinks?: boolean, isRoot?: boolean): PromiseInterface<RemoteViewResource>;
+    getDuplicateById(itemType: ItemType, duplicateId: ItemId, options: ItemOptionsInterface, level?: number, returnLinks?: boolean, isRoot?: boolean): PromiseInterface<LocalViewResource>;
     getItemByState(itemType: ItemType, stateKey: ItemId | string, options: ItemOptionsInterface & {
         edit: true;
-    }, isRoot?: boolean): PromiseInterface<EditResource>;
+    }, level?: number, isRoot?: boolean): PromiseInterface<EditResource>;
     getItemByState(itemType: ItemType, stateKey: ItemId | string, options: ItemOptionsInterface & {
         remote: true;
-    }, isRoot?: boolean): PromiseInterface<RemoteViewResource>;
-    getItemByState(itemType: ItemType, stateKey: ItemId | string, options: ItemOptionsInterface, isRoot?: boolean): PromiseInterface<LocalViewResource>;
+    }, level?: number, isRoot?: boolean): PromiseInterface<RemoteViewResource>;
+    getItemByState(itemType: ItemType, stateKey: ItemId | string, options: ItemOptionsInterface, level?: number, isRoot?: boolean): PromiseInterface<LocalViewResource>;
     getCollectionDef(itemType: ItemType, options: CollectionOptionsInterface): CollectionDefinition;
     getLinkCollectionsDef(itemType: ItemType, linkField: string, options: CollectionOptionsInterface): LinkCollectionDefinition;
     getCollection(itemType: ItemType, options: CollectionOptionsInterface & {
         editCollection: true;
         editItems: true;
-    }): PromiseInterface<CollectionEditResource<EditResource>>;
+    }, level?: number): PromiseInterface<CollectionEditResource<EditResource>>;
     getCollection(itemType: ItemType, options: CollectionOptionsInterface & {
         editItems: true;
-    }): PromiseInterface<CollectionViewResource<EditResource>>;
+    }, level?: number): PromiseInterface<CollectionViewResource<EditResource>>;
     getCollection(itemType: ItemType, options: CollectionOptionsInterface & {
         editCollection: true;
         remoteItems: true;
-    }): PromiseInterface<CollectionEditResource<RemoteViewResource>>;
+    }, level?: number): PromiseInterface<CollectionEditResource<RemoteViewResource>>;
     getCollection(itemType: ItemType, options: CollectionOptionsInterface & {
         remoteItems: true;
-    }): PromiseInterface<CollectionViewResource<RemoteViewResource>>;
+    }, level?: number): PromiseInterface<CollectionViewResource<RemoteViewResource>>;
     getCollection(itemType: ItemType, options: CollectionOptionsInterface & {
         editCollection: true;
-    }): PromiseInterface<CollectionEditResource<LocalViewResource>>;
-    getCollection(itemType: ItemType, options: CollectionOptionsInterface): PromiseInterface<CollectionViewResource<LocalViewResource>>;
-    getCollectionFromDef(definition: CollectionDefinition): PromiseInterface<CollectionResource>;
-    /**
-     * @deprecated, use `parent` in options
-     */
-    getLinkCollection(linkType: ItemType, linkId: ItemId, itemType: ItemType, options?: CollectionOptionsInterface): PromiseInterface<CollectionResource>;
+    }, level?: number): PromiseInterface<CollectionEditResource<LocalViewResource>>;
+    getCollection(itemType: ItemType, options: CollectionOptionsInterface, level?: number): PromiseInterface<CollectionViewResource<LocalViewResource>>;
+    getCollectionFromDef(definition: CollectionDefinition, level?: number): PromiseInterface<CollectionResource>;
     getLinkCollections(linkType: ItemType, linkIdArray: ItemId[], itemType: ItemType, options: CollectionOptionsInterface & {
         editItems: true;
         editCollection: true;
-    }): PromiseInterface<CollectionResourceParentIdMap<CollectionEditResource<EditResource>>>;
+    }, level?: number): PromiseInterface<CollectionResourceParentIdMap<CollectionEditResource<EditResource>>>;
     getLinkCollections(linkType: ItemType, linkIdArray: ItemId[], itemType: ItemType, options: CollectionOptionsInterface & {
         remoteItems: true;
         editCollection: true;
-    }): PromiseInterface<CollectionResourceParentIdMap<CollectionEditResource<RemoteViewResource>>>;
+    }, level?: number): PromiseInterface<CollectionResourceParentIdMap<CollectionEditResource<RemoteViewResource>>>;
     getLinkCollections(linkType: ItemType, linkIdArray: ItemId[], itemType: ItemType, options: CollectionOptionsInterface & {
         editCollection: true;
-    }): PromiseInterface<CollectionResourceParentIdMap<CollectionEditResource<LocalViewResource>>>;
+    }, level?: number): PromiseInterface<CollectionResourceParentIdMap<CollectionEditResource<LocalViewResource>>>;
     getLinkCollections(linkType: ItemType, linkIdArray: ItemId[], itemType: ItemType, options: CollectionOptionsInterface & {
         editItems: true;
-    }): PromiseInterface<CollectionResourceParentIdMap<CollectionViewResource<EditResource>>>;
+    }, level?: number): PromiseInterface<CollectionResourceParentIdMap<CollectionViewResource<EditResource>>>;
     getLinkCollections(linkType: ItemType, linkIdArray: ItemId[], itemType: ItemType, options: CollectionOptionsInterface & {
         remoteItems: true;
-    }): PromiseInterface<CollectionResourceParentIdMap<CollectionViewResource<RemoteViewResource>>>;
-    getLinkCollections(linkType: ItemType, linkIdArray: ItemId[], itemType: ItemType, options: CollectionOptionsInterface): PromiseInterface<CollectionResourceParentIdMap<CollectionViewResource<LocalViewResource>>>;
-    getLinkCollectionsFromDef(linkType: ItemType, linkIdArray: ItemId[], definition: LinkCollectionDefinition): PromiseInterface<CollectionResourceParentIdMap>;
+    }, level?: number): PromiseInterface<CollectionResourceParentIdMap<CollectionViewResource<RemoteViewResource>>>;
+    getLinkCollections(linkType: ItemType, linkIdArray: ItemId[], itemType: ItemType, options: CollectionOptionsInterface, level?: number): PromiseInterface<CollectionResourceParentIdMap<CollectionViewResource<LocalViewResource>>>;
+    getLinkCollectionsFromDef(linkType: ItemType, linkIdArray: ItemId[], definition: LinkCollectionDefinition, level?: number): PromiseInterface<CollectionResourceParentIdMap>;
     getAllLinkCollections(linkType: ItemType, itemType: ItemType, options: CollectionOptionsInterface & {
         editItems: true;
         editCollection: true;
-    }): PromiseInterface<CollectionResourceParentIdMap<CollectionEditResource<EditResource>>>;
+    }, level?: number): PromiseInterface<CollectionResourceParentIdMap<CollectionEditResource<EditResource>>>;
     getAllLinkCollections(linkType: ItemType, itemType: ItemType, options: CollectionOptionsInterface & {
         remoteItems: true;
         editCollection: true;
-    }): PromiseInterface<CollectionResourceParentIdMap<CollectionEditResource<RemoteViewResource>>>;
+    }, level?: number): PromiseInterface<CollectionResourceParentIdMap<CollectionEditResource<RemoteViewResource>>>;
     getAllLinkCollections(linkType: ItemType, itemType: ItemType, options: CollectionOptionsInterface & {
         editCollection: true;
-    }): PromiseInterface<CollectionResourceParentIdMap<CollectionEditResource<LocalViewResource>>>;
+    }, level?: number): PromiseInterface<CollectionResourceParentIdMap<CollectionEditResource<LocalViewResource>>>;
     getAllLinkCollections(linkType: ItemType, itemType: ItemType, options: CollectionOptionsInterface & {
         editItems: true;
-    }): PromiseInterface<CollectionResourceParentIdMap<CollectionViewResource<EditResource>>>;
+    }, level?: number): PromiseInterface<CollectionResourceParentIdMap<CollectionViewResource<EditResource>>>;
     getAllLinkCollections(linkType: ItemType, itemType: ItemType, options: CollectionOptionsInterface & {
         remoteItems: true;
-    }): PromiseInterface<CollectionResourceParentIdMap<CollectionViewResource<RemoteViewResource>>>;
-    getAllLinkCollections(linkType: ItemType, itemType: ItemType, options: CollectionOptionsInterface): PromiseInterface<CollectionResourceParentIdMap<CollectionViewResource<LocalViewResource>>>;
+    }, level?: number): PromiseInterface<CollectionResourceParentIdMap<CollectionViewResource<RemoteViewResource>>>;
+    getAllLinkCollections(linkType: ItemType, itemType: ItemType, options: CollectionOptionsInterface, level?: number): PromiseInterface<CollectionResourceParentIdMap<CollectionViewResource<LocalViewResource>>>;
     cloneItem(itemResource: ItemResource, options: ItemOptionsInterface & {
         edit: true;
-    }): EditResource;
+    }, level?: number): EditResource;
     cloneItem(itemResource: ItemResource, options: ItemOptionsInterface & {
         remote: true;
-    }): RemoteViewResource;
-    cloneItem(itemResource: ItemResource, options: ItemOptionsInterface): LocalViewResource;
+    }, level?: number): RemoteViewResource;
+    cloneItem(itemResource: ItemResource, options: ItemOptionsInterface, level?: number): LocalViewResource;
     cloneCollection(collectionResource: CollectionResource, options: CollectionOptionsInterface & {
         editItems: true;
         editCollection: true;
-    }, conversionMap: ItemIdConversionMap): CollectionEditResource<EditResource>;
+    }, conversionMap: ItemIdConversionMap, level?: number): CollectionEditResource<EditResource>;
     cloneCollection(collectionResource: CollectionResource, options: CollectionOptionsInterface & {
         remoteItems: true;
         editCollection: true;
-    }, conversionMap: ItemIdConversionMap): CollectionEditResource<RemoteViewResource>;
+    }, conversionMap: ItemIdConversionMap, level?: number): CollectionEditResource<RemoteViewResource>;
     cloneCollection(collectionResource: CollectionResource, options: CollectionOptionsInterface & {
         editItems: true;
-    }, conversionMap: ItemIdConversionMap): CollectionViewResource<EditResource>;
+    }, conversionMap: ItemIdConversionMap, level?: number): CollectionViewResource<EditResource>;
     cloneCollection(collectionResource: CollectionResource, options: CollectionOptionsInterface & {
         remoteItems: true;
-    }, conversionMap: ItemIdConversionMap): CollectionViewResource<RemoteViewResource>;
+    }, conversionMap: ItemIdConversionMap, level?: number): CollectionViewResource<RemoteViewResource>;
     cloneCollection(collectionResource: CollectionResource, options: CollectionOptionsInterface & {
         editCollection: true;
-    }, conversionMap: ItemIdConversionMap): CollectionEditResource<LocalViewResource>;
-    cloneCollection(collectionResource: CollectionResource, options: CollectionOptionsInterface, conversionMap: ItemIdConversionMap): CollectionViewResource<LocalViewResource>;
+    }, conversionMap: ItemIdConversionMap, level?: number): CollectionEditResource<LocalViewResource>;
+    cloneCollection(collectionResource: CollectionResource, options: CollectionOptionsInterface, conversionMap: ItemIdConversionMap, level?: number): CollectionViewResource<LocalViewResource>;
     saveCurrentLocalCache(closeTab?: boolean, parameters?: CreateRequestParameterMap, breakupByParent?: boolean, onAfterCreateCallback?: (conversionMap: ItemIdConversionMap) => void): PromiseInterface<ItemIdConversionMap>;
     getCurrentCollections(): CollectionCache;
     getCurrentItems(): ItemCache;
     getModuleChanges(localCache?: LocalCache): ModuleChangesCompilationResult;
     addSingleItem(itemEntry: ItemEntry, options: ItemResourceOptionsInterface & {
         edit: true;
-    }, isRoot?: boolean, localCache?: LocalCache): EditResource;
+    }, level?: number, isRoot?: boolean, localCache?: LocalCache): EditResource;
     addSingleItem(itemEntry: ItemEntry, options: ItemResourceOptionsInterface & {
         remote: true;
-    }, isRoot?: boolean, localCache?: LocalCache): RemoteViewResource;
-    addSingleItem(itemEntry: ItemEntry, options: ItemResourceOptionsInterface, isRoot?: boolean, localCache?: LocalCache): LocalViewResource;
+    }, level?: number, isRoot?: boolean, localCache?: LocalCache): RemoteViewResource;
+    addSingleItem(itemEntry: ItemEntry, options: ItemResourceOptionsInterface, level?: number, isRoot?: boolean, localCache?: LocalCache): LocalViewResource;
     addSingleItems(itemEntries: ItemEntry[], options: ItemResourceOptionsInterface & {
         edit: true;
-    }): EditResource[];
+    }, level?: number): EditResource[];
     addSingleItems(itemEntries: ItemEntry[], options: ItemResourceOptionsInterface & {
         remote: true;
-    }): RemoteViewResource[];
-    addSingleItems(itemEntries: ItemEntry[], options: ItemResourceOptionsInterface): LocalViewResource[];
+    }, level?: number): RemoteViewResource[];
+    addSingleItems(itemEntries: ItemEntry[], options: ItemResourceOptionsInterface, level?: number): LocalViewResource[];
     addCollection(collectionEntry: CollectionEntry, options: CollectionResourceOptionsInterface & {
         editCollection: true;
         editItems: true;
-    }): CollectionEditResource<EditResource>;
+    }, level?: number): CollectionEditResource<EditResource>;
     addCollection(collectionEntry: CollectionEntry, options: CollectionResourceOptionsInterface & {
         editItems: true;
-    }): CollectionViewResource<EditResource>;
+    }, level?: number): CollectionViewResource<EditResource>;
     addCollection(collectionEntry: CollectionEntry, options: CollectionResourceOptionsInterface & {
         editCollection: true;
         remoteItems: true;
-    }): CollectionEditResource<RemoteViewResource>;
+    }, level?: number): CollectionEditResource<RemoteViewResource>;
     addCollection(collectionEntry: CollectionEntry, options: CollectionResourceOptionsInterface & {
         remoteItems: true;
-    }): CollectionViewResource<RemoteViewResource>;
+    }, level?: number): CollectionViewResource<RemoteViewResource>;
     addCollection(collectionEntry: CollectionEntry, options: CollectionResourceOptionsInterface & {
         editCollection: true;
-    }): CollectionEditResource<LocalViewResource>;
-    addCollection(collectionEntry: CollectionEntry, options: CollectionResourceOptionsInterface): CollectionViewResource<LocalViewResource>;
+    }, level?: number): CollectionEditResource<LocalViewResource>;
+    addCollection(collectionEntry: CollectionEntry, options: CollectionResourceOptionsInterface, level?: number): CollectionViewResource<LocalViewResource>;
     private createItemResources;
     processLinkedItems(linkedEntries: LinkedItemEntryMap[], options: ItemOptionsInterface & {
         edit: true;
-    }, addToCollections: boolean): ItemResourcesItemTypeMap<EditResource>;
+    }, level?: number, addToCollections?: boolean): ItemResourcesItemTypeMap<EditResource>;
     processLinkedItems(linkedEntries: LinkedItemEntryMap[], options: ItemOptionsInterface & {
         remote: true;
-    }, addToCollections: boolean): ItemResourcesItemTypeMap<RemoteViewResource>;
-    processLinkedItems(linkedEntries: LinkedItemEntryMap[], options: ItemOptionsInterface, addToCollections: boolean): ItemResourcesItemTypeMap<LocalViewResource>;
-    expandProcessLinkedItems(linkedEntries: LinkedItemEntryMap[], options: ItemOptionsInterface & {
+    }, level?: number, addToCollections?: boolean): ItemResourcesItemTypeMap<RemoteViewResource>;
+    processLinkedItems(linkedEntries: LinkedItemEntryMap[], options: ItemOptionsInterface, level?: number, addToCollections?: boolean): ItemResourcesItemTypeMap<LocalViewResource>;
+    expandProcessLinkedItems(linkedEntries: LinkedItemEntryMap[], level: number, options: ItemOptionsInterface & {
         edit: true;
     }): PromiseInterface<ItemResourcesItemTypeMap<EditResource>>;
-    expandProcessLinkedItems(linkedEntries: LinkedItemEntryMap[], options: ItemOptionsInterface & {
+    expandProcessLinkedItems(linkedEntries: LinkedItemEntryMap[], level: number, options: ItemOptionsInterface & {
         remote: true;
     }): PromiseInterface<ItemResourcesItemTypeMap<RemoteViewResource>>;
-    expandProcessLinkedItems(linkedEntries: LinkedItemEntryMap[], options: ItemOptionsInterface): PromiseInterface<ItemResourcesItemTypeMap<LocalViewResource>>;
+    expandProcessLinkedItems(linkedEntries: LinkedItemEntryMap[], level: number, options: ItemOptionsInterface): PromiseInterface<ItemResourcesItemTypeMap<LocalViewResource>>;
     private constructOnItemsExpanded;
     private expandAddToCollections;
     private getColumnSuperset;
     getLocalCache(): LocalCache;
-    resetLocalCache(): void;
     addToCollections<T extends CollectionResource = CollectionViewResource>(itemEntries: ItemEntry[], resultCollectionResource: T, callOnAdd?: boolean): T['items'];
     addToCollections(itemEntries: ItemEntry[], resultCollectionResource?: null, callOnAdd?: boolean): null;
     removeFromCollections<T extends CollectionResource = CollectionViewResource>(itemEntries: ItemEntry[], resultCollectionResource: T): T['items'];
@@ -214,28 +211,28 @@ export declare class ItemAdministrator {
     createCollectionResource(collectionEntry: CollectionEntry, resourceOptions: CollectionResourceOptionsInterface & {
         editItems: true;
         editCollection: true;
-    }): CollectionEditResource<EditResource>;
+    }, level?: number): CollectionEditResource<EditResource>;
     createCollectionResource(collectionEntry: CollectionEntry, resourceOptions: CollectionResourceOptionsInterface & {
         editItems: true;
-    }): CollectionViewResource<EditResource>;
+    }, level?: number): CollectionViewResource<EditResource>;
     createCollectionResource(collectionEntry: CollectionEntry, resourceOptions: CollectionResourceOptionsInterface & {
         remoteItems: true;
         editCollection: true;
-    }): CollectionEditResource<RemoteViewResource>;
+    }, level?: number): CollectionEditResource<RemoteViewResource>;
     createCollectionResource(collectionEntry: CollectionEntry, resourceOptions: CollectionResourceOptionsInterface & {
         remoteItems: true;
-    }): CollectionViewResource<RemoteViewResource>;
+    }, level?: number): CollectionViewResource<RemoteViewResource>;
     createCollectionResource(collectionEntry: CollectionEntry, resourceOptions: CollectionResourceOptionsInterface & {
         editCollection: true;
-    }): CollectionEditResource<LocalViewResource>;
-    createCollectionResource(collectionEntry: CollectionEntry, resourceOptions: CollectionResourceOptionsInterface): CollectionViewResource<LocalViewResource>;
+    }, level?: number): CollectionEditResource<LocalViewResource>;
+    createCollectionResource(collectionEntry: CollectionEntry, resourceOptions: CollectionResourceOptionsInterface, level?: number): CollectionViewResource<LocalViewResource>;
     createItemResource(itemEntry: ItemEntry, options: ItemResourceOptionsInterface & {
         edit: true;
-    }, isRoot: boolean): EditResource;
+    }, level?: number, isRoot?: boolean): EditResource;
     createItemResource(itemEntry: ItemEntry, options: ItemResourceOptionsInterface & {
         remote: true;
-    }, isRoot: boolean): RemoteViewResource;
-    createItemResource(itemEntry: ItemEntry, options: ItemResourceOptionsInterface, isRoot: boolean): LocalViewResource;
-    onBeforeSave(key: string, callback: LocalCacheCallbackType['onBeforeSave'], condition?: LocalCacheCallbackCondition, priority?: number): () => void;
-    onSaveSuccess(key: string, callback: LocalCacheCallbackType['onSaveSuccess'], condition?: LocalCacheCallbackCondition, priority?: number): () => void;
+    }, level?: number, isRoot?: boolean): RemoteViewResource;
+    createItemResource(itemEntry: ItemEntry, options: ItemResourceOptionsInterface, level?: number, isRoot?: boolean): LocalViewResource;
+    onBeforeSave(key: string, callback: (localCache: LocalCache) => any, condition?: LocalCacheCallbackCondition): () => void;
+    onSaveSuccess(key: string, callback: OnSaveCallback, condition?: LocalCacheCallbackCondition): () => void;
 }

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

@@ -1,80 +1,84 @@
-import { CollectionCache, ItemCache, LocalCacheCallbackCondition, LocalCacheCallbackType, LockService } from '../classes';
-import { ChangesProcessorFactory, CollectionCacheFactory, CollectionResourceFactory, ItemCacheFactory, ItemResourceFactory } from '../factories';
+import { ChangesProcessor, CollectionCache, ItemCache, LockService } from '../classes';
+import { CollectionCacheFactory, CollectionResourceFactory, ItemCacheFactory, ItemResourceFactory } from '../factories';
 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, PromiseInterface } from '../types';
+import { CollectionEntryParentIdMap, CollectionResourceParentIdMap, CreateRequestParameterMap, ItemIdConversionMap, ItemOptionsInterface, LocalCacheCallbackCondition, OnSaveCallback, PromiseInterface } from '../types';
 export declare class LocalCache {
-    private changesProcessorFactory;
+    private changesProcessor;
+    private collectionCacheFactory;
     private collectionResourceFactory;
     private errorHandler;
+    private exceptionHandler;
+    private itemCacheFactory;
     private itemResourceFactory;
     private lockService;
     private promiseService;
-    id?: string | undefined;
+    id: string;
+    readonly defaultResourceLevel: number;
     readonly items: ItemCache;
     readonly collections: CollectionCache;
     readonly deferredCollections: CollectionCache;
     rootItem: ItemEntry | undefined;
     tabRequestParameters: {};
     isSaving: boolean;
+    private callbacks;
     private changesInterval;
     hasChanges: boolean;
-    private eventHandler;
-    constructor(exceptionHandler: ExceptionHandlerInterface, collectionCacheFactory: CollectionCacheFactory, itemCacheFactory: ItemCacheFactory, changesProcessorFactory: ChangesProcessorFactory, collectionResourceFactory: CollectionResourceFactory, errorHandler: ErrorHandlerInterface, itemResourceFactory: ItemResourceFactory, lockService: LockService, promiseService: PromiseLibraryInterface, id?: string | undefined);
+    constructor(changesProcessor: ChangesProcessor, collectionCacheFactory: CollectionCacheFactory, collectionResourceFactory: CollectionResourceFactory, errorHandler: ErrorHandlerInterface, exceptionHandler: ExceptionHandlerInterface, itemCacheFactory: ItemCacheFactory, itemResourceFactory: ItemResourceFactory, lockService: LockService, promiseService: PromiseLibraryInterface, id: string, defaultResourceLevel: number);
     createItemResource(itemEntry: ItemEntry, options: ItemOptionsInterface & {
         edit: true;
-    }, isRoot?: boolean, isNew?: boolean): EditResource;
+    }, level?: number, isRoot?: boolean, isNew?: boolean): EditResource;
     createItemResource(itemEntry: ItemEntry, options: ItemOptionsInterface & {
         remote: true;
-    }, isRoot?: boolean, isNew?: boolean): RemoteViewResource;
-    createItemResource(itemEntry: ItemEntry, options: ItemOptionsInterface, isRoot?: boolean, isNew?: boolean): LocalViewResource;
+    }, level?: number, isRoot?: boolean, isNew?: boolean): RemoteViewResource;
+    createItemResource(itemEntry: ItemEntry, options: ItemOptionsInterface, level?: number, isRoot?: boolean, isNew?: boolean): LocalViewResource;
     createItemResources(itemEntries: ItemEntry[], options: ItemOptionsInterface & {
         edit: true;
-    }): EditResource[];
+    }, level?: number): EditResource[];
     createItemResources(itemEntries: ItemEntry[], options: ItemOptionsInterface & {
         remote: true;
-    }): RemoteViewResource[];
-    createItemResources(itemEntries: ItemEntry[], options: ItemOptionsInterface): LocalViewResource[];
+    }, level?: number): RemoteViewResource[];
+    createItemResources(itemEntries: ItemEntry[], options: ItemOptionsInterface, level?: number): LocalViewResource[];
     createCollectionResource(collectionEntry: CollectionEntry, resourceOptions: CollectionResourceOptionsInterface & {
         editItems: true;
         editCollection: true;
-    }): CollectionEditResource<EditResource>;
+    }, level?: number): CollectionEditResource<EditResource>;
     createCollectionResource(collectionEntry: CollectionEntry, resourceOptions: CollectionResourceOptionsInterface & {
         remoteItems: true;
         editCollection: true;
-    }): CollectionEditResource<RemoteViewResource>;
+    }, level?: number): CollectionEditResource<RemoteViewResource>;
     createCollectionResource(collectionEntry: CollectionEntry, resourceOptions: CollectionResourceOptionsInterface & {
         editCollection: true;
-    }): CollectionEditResource<LocalViewResource>;
+    }, level?: number): CollectionEditResource<LocalViewResource>;
     createCollectionResource(collectionEntry: CollectionEntry, resourceOptions: CollectionResourceOptionsInterface & {
         editItems: true;
-    }): CollectionViewResource<EditResource>;
+    }, level?: number): CollectionViewResource<EditResource>;
     createCollectionResource(collectionEntry: CollectionEntry, resourceOptions: CollectionResourceOptionsInterface & {
         remoteItems: true;
-    }): CollectionViewResource<RemoteViewResource>;
-    createCollectionResource(collectionEntry: CollectionEntry, resourceOptions: CollectionResourceOptionsInterface): CollectionViewResource<LocalViewResource>;
+    }, level?: number): CollectionViewResource<RemoteViewResource>;
+    createCollectionResource(collectionEntry: CollectionEntry, resourceOptions: CollectionResourceOptionsInterface, level?: number): CollectionViewResource<LocalViewResource>;
     createCollectionResources(collectionEntries: CollectionEntryParentIdMap, resourceOptions: CollectionResourceOptionsInterface & {
         editItems: true;
         editCollection: true;
-    }): CollectionResourceParentIdMap<CollectionEditResource<EditResource>>;
+    }, level?: number): CollectionResourceParentIdMap<CollectionEditResource<EditResource>>;
     createCollectionResources(collectionEntries: CollectionEntryParentIdMap, resourceOptions: CollectionResourceOptionsInterface & {
         remoteItems: true;
         editCollection: true;
-    }): CollectionResourceParentIdMap<CollectionEditResource<RemoteViewResource>>;
+    }, level?: number): CollectionResourceParentIdMap<CollectionEditResource<RemoteViewResource>>;
     createCollectionResources(collectionEntries: CollectionEntryParentIdMap, resourceOptions: CollectionResourceOptionsInterface & {
         editCollection: true;
-    }): CollectionResourceParentIdMap<CollectionEditResource<LocalViewResource>>;
+    }, level?: number): CollectionResourceParentIdMap<CollectionEditResource<LocalViewResource>>;
     createCollectionResources(collectionEntries: CollectionEntryParentIdMap, resourceOptions: CollectionResourceOptionsInterface & {
         editItems: true;
-    }): CollectionResourceParentIdMap<CollectionViewResource<EditResource>>;
+    }, level?: number): CollectionResourceParentIdMap<CollectionViewResource<EditResource>>;
     createCollectionResources(collectionEntries: CollectionEntryParentIdMap, resourceOptions: CollectionResourceOptionsInterface & {
         remoteItems: true;
-    }): CollectionResourceParentIdMap<CollectionViewResource<RemoteViewResource>>;
-    createCollectionResources(collectionEntries: CollectionEntryParentIdMap, resourceOptions: CollectionResourceOptionsInterface): CollectionResourceParentIdMap<CollectionViewResource<LocalViewResource>>;
+    }, level?: number): CollectionResourceParentIdMap<CollectionViewResource<RemoteViewResource>>;
+    createCollectionResources(collectionEntries: CollectionEntryParentIdMap, resourceOptions: CollectionResourceOptionsInterface, level?: number): CollectionResourceParentIdMap<CollectionViewResource<LocalViewResource>>;
     clearItem(itemResource: ItemResource): void;
     clearItemEntry(itemEntry: ItemEntry): void;
     clearCollection(collectionResource: CollectionResource): void;
-    clearResources(isSubTabChange?: boolean): void;
+    clearDeferredCollections(): void;
     updateSingleItems(conversionMap: ItemIdConversionMap): void;
     revertChanges(): PromiseInterface<void>;
     resetCollection(collectionEntry: CollectionEntry): void;
@@ -82,8 +86,10 @@ export declare class LocalCache {
     private collectionHasChanges;
     isLockable(): boolean;
     save(closeTab?: boolean, parameters?: CreateRequestParameterMap, breakUpByParent?: boolean, onAfterCreateCallback?: (conversionMap: ItemIdConversionMap) => void): PromiseInterface<ItemIdConversionMap>;
-    onBeforeSave(key: string, callback: LocalCacheCallbackType['onBeforeSave'], condition?: LocalCacheCallbackCondition, priority?: number): () => void;
-    onSaveSuccess(key: string, callback: LocalCacheCallbackType['onSaveSuccess'], condition?: LocalCacheCallbackCondition, priority?: number): () => void;
+    onBeforeSave(key: string, callback: (localCache: LocalCache) => any, condition?: LocalCacheCallbackCondition): () => void;
+    onSaveSuccess(key: string, callback: OnSaveCallback, condition?: LocalCacheCallbackCondition): () => void;
+    private executeCallbackEvent;
+    private executeCallbacks;
     enableChangesWatcher(): void;
     disableChangesWatcher(): void;
     onDeactivateItem(itemEntry: ItemEntry): void;

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

@@ -0,0 +1,25 @@
+import { CollectionResource, ItemResource } from '../models';
+declare type Resource = ItemResource | CollectionResource;
+export declare class ResourceCache<T extends Resource> {
+    private cache;
+    set<U extends T>(resource: U, level: number): U;
+    /**
+     * If an array of resources already exists for the specified level, return that. Otherwise insert a new tuple at the
+     * right place in the 'levels' array.
+     */
+    private getCacheLevel;
+    private createCacheLevel;
+    hasResources(entry: T['entry']): boolean;
+    get(entry: T['entry']): T[];
+    getLatest(entry: T['entry']): T | null;
+    /**
+     * Clears a specific resource.
+     */
+    clearResource(resource: T): boolean;
+    /**
+     * Removes all resources that have a level of 'level' or higher.
+     */
+    clearResources(level: number): void;
+    clearEntry(entry: T['entry']): void;
+}
+export {};

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

@@ -24,12 +24,12 @@ export * from './ItemHandler';
 export * from './ItemRequestService';
 export * from './KeyService';
 export * from './LocalCache';
-export * from './LocalCacheEventHandler';
 export * from './LockService';
 export * from './ModuleChangesCompilation';
 export * from './QueryMatcher';
 export * from './QueryParser';
 export * from './QueryService';
+export * from './ResourceCache';
 export * from './RequestColumnExpansion';
 export * from './SocketMessageHandler';
 export * from './Util';

package/dist/src/core.d.ts

@@ -1,5 +1,5 @@
-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 { ApiFormatter, ApiRequestService, ChangesProcessor, CollectionEntryService, CollectionHandler, CollectionResourceService, ColumnCache, ColumnHandler, ColumnUtil, ItemAdministrator, ItemEntryService, ItemHandler, ItemRequestService, KeyService, LockService, QueryService, SocketMessageHandler } from './classes';
+import { ApiResponseProcessorFactory, BatchStatusFactory, ChangesCompilationFactory, CollectionCacheFactory, CollectionEntryFactory, CollectionMatcherFactory, CollectionResourceFactory, ColumnExpansionFactory, ColumnInfoFactory, ColumnSetFactory, ColumnSubsetCacheFactory, CreateRequestFactory, ItemCacheFactory, ItemEntryFactory, ItemResourceFactory, LocalCacheFactory, ModuleChangesCompilationFactory, QueryMatcherFactory, QueryParserFactory, RequestColumnExpansionFactory, TemplateFactory } from './factories';
 import { ApiRequestServiceInterface, AuthInterface, ErrorHandlerInterface, ExceptionHandlerInterface, LocalCacheManagerInterface, PromiseLibraryInterface } from './interfaces';
 export declare class RmCore {
     version: string;
@@ -9,7 +9,7 @@ export declare class RmCore {
     apiResponseProcessorFactory: ApiResponseProcessorFactory;
     batchStatusFactory: BatchStatusFactory;
     changesCompilationFactory: ChangesCompilationFactory;
-    changesProcessorFactory: ChangesProcessorFactory;
+    changesProcessor: ChangesProcessor;
     collectionCacheFactory: CollectionCacheFactory;
     collectionEntryFactory: CollectionEntryFactory;
     collectionEntryService: CollectionEntryService;

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

@@ -1,7 +1,8 @@
 import { CollectionCache } from '../classes';
-import { QueryMatcherFactory } from '../factories';
+import { CollectionResourceFactory, QueryMatcherFactory } from '../factories';
 export declare class CollectionCacheFactory {
+    private collectionResourceFactory;
     private queryMatcherFactory;
-    constructor(queryMatcherFactory: QueryMatcherFactory);
+    constructor(collectionResourceFactory: CollectionResourceFactory, queryMatcherFactory: QueryMatcherFactory);
     construct(): CollectionCache;
 }

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

@@ -1,12 +1,13 @@
 import { CollectionEntryService, ColumnHandler, ItemEntryService, ItemHandler, ItemRequestService, KeyService, QueryService } from '../classes/';
-import { ColumnExpansionFactory, ColumnSetFactory, ItemEntryFactory } from '../factories/';
+import { CollectionResourceFactory, ColumnExpansionFactory, ColumnSetFactory, ItemEntryFactory } from '../factories/';
 import { ErrorHandlerInterface, ExceptionHandlerInterface, PromiseLibraryInterface } from '../interfaces/';
 import { CollectionEntry, CollectionEntryOptionsInterface } from '../models/';
 import { ItemType } from '../types/';
 export declare class CollectionEntryFactory {
     collectionEntryService: CollectionEntryService;
-    columnHandler: ColumnHandler;
+    collectionResourceFactory: CollectionResourceFactory;
     columnExpansionFactory: ColumnExpansionFactory;
+    columnHandler: ColumnHandler;
     columnSetFactory: ColumnSetFactory;
     errorHandler: ErrorHandlerInterface;
     exceptionHandler: ExceptionHandlerInterface;
@@ -17,6 +18,6 @@ export declare class CollectionEntryFactory {
     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);
+    constructor(collectionEntryService: CollectionEntryService, collectionResourceFactory: CollectionResourceFactory, columnExpansionFactory: ColumnExpansionFactory, columnHandler: ColumnHandler, 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;
 }