@rentman/rm-core 1.6.12 → 1.6.13-2

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

@@ -1,10 +1,9 @@
 import { CollectionEntryOptions, CollectionViewResource, PromiseInterface } from '../';
 import { BatchStatus, CollectionCache, CollectionEntryService, CollectionMatcher, ColumnExpansion, ColumnHandler, ColumnSet, ItemCache, ItemHandler, ItemRequestService, KeyService, QueryService } from '../classes';
-import { ENTRY_STATUS } from '../constants';
 import { BatchStatusFactory, CollectionCacheFactory, CollectionEntryFactory, CollectionMatcherFactory, ColumnSetFactory, QueryParserFactory } from '../factories';
 import { ErrorHandlerInterface, PromiseLibraryInterface } from '../interfaces';
 import { CollectionEntry, CollectionResource } from '../models';
-import { ApiRequestColumn, CollectionEntryParentIdMap, CollectionResourceParentIdMap, EntryStatus, ItemEntryParentIdMap, ItemId, ItemResourceItemIdMap, ItemType, QueryCallback } from '../types';
+import { ApiRequestColumn, CollectionEntryParentIdMap, CollectionResourceParentIdMap, ItemEntryParentIdMap, ItemId, ItemResourceItemIdMap, ItemType, QueryCallback } from '../types';
 export declare class CollectionHandler {
     private batchStatusFactory;
     private collectionCacheFactory;
@@ -44,12 +43,10 @@ export declare class CollectionHandler {
         items?: ItemEntryParentIdMap;
     }, localItems: ItemEntryParentIdMap): CollectionEntryParentIdMap;
     fetch(itemType: ItemType, options: CollectionEntryOptions, itemCache: ItemCache, localCollectionCache: CollectionCache, deferredCollectionCache: CollectionCache): PromiseInterface<CollectionEntry>;
-    getCachedEntryStatus(collectionEntry: CollectionEntry, options: any): ENTRY_STATUS;
-    getDeferredEntryStatus(itemType: ItemType, options: any, query: any, deferredEntries: CollectionCache): {
-        entry: CollectionEntry;
-        isDeferred: boolean;
-    };
-    getEntryStatus(itemType: ItemType, options: any, localEntries: CollectionCache, deferredEntries: CollectionCache): EntryStatus<CollectionEntry>;
+    private resolveCached;
+    private getCachedEntryStatus;
+    private getDeferredEntryStatus;
+    private getEntryStatus;
     resolveLocal(collectionEntry: CollectionEntry, itemCache: ItemCache): PromiseInterface<CollectionEntry>;
     resolveRemote(collectionEntry: CollectionEntry, itemCache: ItemCache): PromiseInterface<CollectionEntry>;
     isLocal(options: any): boolean;

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

@@ -1,14 +1,12 @@
-import { ColumnHandler, ColumnInfo, ColumnUtil, RequestColumnMergeResult } from '../classes';
-import { ColumnInfoFactory, ColumnSetFactory } from '../factories';
+import { ColumnInfo, ColumnUtil, RequestColumnMergeResult } from '../classes';
+import { ColumnSetFactory } from '../factories';
 import { ApiRequestColumns, ColumnExpansionResult, ItemType, ResponseColumnMap } from '../types';
 export declare class ColumnSet {
-    private columnHandler;
     private columnUtil;
-    private columnInfoFactory;
     private columnSetFactory;
     itemType: ItemType;
-    request: ApiRequestColumns;
     id: number;
+    request: ApiRequestColumns;
     requestColumnsTrue: boolean;
     response: ResponseColumnMap;
     link: ColumnInfo | null;
@@ -25,19 +23,14 @@ export declare class ColumnSet {
     searchable: ColumnInfo[];
     item: ColumnInfo[];
     notItem: ColumnInfo[];
-    constructor(columnHandler: ColumnHandler, columnUtil: ColumnUtil, columnInfoFactory: ColumnInfoFactory, columnSetFactory: ColumnSetFactory, itemType: ItemType, request: ApiRequestColumns);
+    constructor(columnUtil: ColumnUtil, columnSetFactory: ColumnSetFactory, itemType: ItemType);
+    groupColumnInfo(columnInfo: ColumnInfo): void;
     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,8 +1,8 @@
-import { CollectionCache, CollectionHandler, CollectionMatcher, ItemCache, ItemHandler, ItemRequestService, KeyService, LocalCache, ModuleChangesCompilationResult, QueryService } from '../classes';
+import { CollectionCache, CollectionHandler, CollectionMatcher, ItemCache, ItemHandler, ItemRequestService, KeyService, LocalCache, LocalCacheCallbackCondition, LocalCacheCallbackType, ModuleChangesCompilationResult, QueryService } from '../classes';
 import { CollectionMatcherFactory, ColumnSetFactory, LocalCacheFactory, 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, LocalCacheCallbackCondition, OnSaveCallback, PromiseInterface } from '../types';
+import { ApiQuery, CollectionDefinition, CollectionOptionsInterface, CollectionResourceParentIdMap, ConversionMap, CreateRequestParameterMap, ItemId, ItemIdConversionMap, ItemOptionsInterface, ItemResourcesItemTypeMap, ItemType, LinkCollectionDefinition, LinkedItemEntryMap, PromiseInterface } from '../types';
 export declare class ItemAdministrator {
     private apiRequestService;
     private authInterface;
@@ -236,6 +236,6 @@ export declare class ItemAdministrator {
         remote: true;
     }, isRoot: boolean): RemoteViewResource;
     createItemResource(itemEntry: ItemEntry, options: ItemResourceOptionsInterface, isRoot: boolean): LocalViewResource;
-    onBeforeSave(key: string, callback: (localCache: LocalCache) => any, condition?: LocalCacheCallbackCondition): () => void;
-    onSaveSuccess(key: string, callback: OnSaveCallback, condition?: LocalCacheCallbackCondition): () => void;
+    onBeforeSave(key: string, callback: LocalCacheCallbackType['onBeforeSave'], condition?: LocalCacheCallbackCondition, priority?: number): () => void;
+    onSaveSuccess(key: string, callback: LocalCacheCallbackType['onSaveSuccess'], condition?: LocalCacheCallbackCondition, priority?: number): () => void;
 }

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

@@ -1,29 +1,26 @@
-import { CollectionCache, ItemCache, LockService } from '../classes';
+import { CollectionCache, ItemCache, LocalCacheCallbackCondition, LocalCacheCallbackType, LockService } from '../classes';
 import { ChangesProcessorFactory, 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, LocalCacheCallbackCondition, OnSaveCallback, PromiseInterface } from '../types';
+import { CollectionEntryParentIdMap, CollectionResourceParentIdMap, CreateRequestParameterMap, ItemIdConversionMap, ItemOptionsInterface, PromiseInterface } from '../types';
 export declare class LocalCache {
     private changesProcessorFactory;
-    private collectionCacheFactory;
     private collectionResourceFactory;
     private errorHandler;
-    private exceptionHandler;
-    private itemCacheFactory;
     private itemResourceFactory;
     private lockService;
     private promiseService;
-    id: string;
+    id?: string | undefined;
     readonly items: ItemCache;
     readonly collections: CollectionCache;
     readonly deferredCollections: CollectionCache;
     rootItem: ItemEntry | undefined;
     tabRequestParameters: {};
     isSaving: boolean;
-    private callbacks;
     private changesInterval;
     hasChanges: boolean;
-    constructor(changesProcessorFactory: ChangesProcessorFactory, collectionCacheFactory: CollectionCacheFactory, collectionResourceFactory: CollectionResourceFactory, errorHandler: ErrorHandlerInterface, exceptionHandler: ExceptionHandlerInterface, itemCacheFactory: ItemCacheFactory, itemResourceFactory: ItemResourceFactory, lockService: LockService, promiseService: PromiseLibraryInterface, id?: string);
+    private eventHandler;
+    constructor(exceptionHandler: ExceptionHandlerInterface, collectionCacheFactory: CollectionCacheFactory, itemCacheFactory: ItemCacheFactory, changesProcessorFactory: ChangesProcessorFactory, collectionResourceFactory: CollectionResourceFactory, errorHandler: ErrorHandlerInterface, itemResourceFactory: ItemResourceFactory, lockService: LockService, promiseService: PromiseLibraryInterface, id?: string | undefined);
     createItemResource(itemEntry: ItemEntry, options: ItemOptionsInterface & {
         edit: true;
     }, isRoot?: boolean, isNew?: boolean): EditResource;
@@ -85,10 +82,8 @@ 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: (localCache: LocalCache) => any, condition?: LocalCacheCallbackCondition): () => void;
-    onSaveSuccess(key: string, callback: OnSaveCallback, condition?: LocalCacheCallbackCondition): () => void;
-    private executeCallbackEvent;
-    private executeCallbacks;
+    onBeforeSave(key: string, callback: LocalCacheCallbackType['onBeforeSave'], condition?: LocalCacheCallbackCondition, priority?: number): () => void;
+    onSaveSuccess(key: string, callback: LocalCacheCallbackType['onSaveSuccess'], condition?: LocalCacheCallbackCondition, priority?: number): () => void;
     enableChangesWatcher(): void;
     disableChangesWatcher(): void;
     onDeactivateItem(itemEntry: ItemEntry): void;

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

@@ -0,0 +1,19 @@
+import { LocalCache } from '../classes';
+import { ErrorHandlerInterface, ExceptionHandlerInterface, PromiseLibraryInterface } from '../interfaces';
+import { ItemIdConversionMap, PromiseInterface } from '../types';
+export declare type LocalCacheCallbackCondition = 'always' | 'onClose' | 'skipOnClose';
+export declare type LocalCacheCallbackType = {
+    onBeforeSave: (localCache: LocalCache) => any;
+    onSaveSuccess: (localCache: LocalCache, conversionMap: ItemIdConversionMap) => any;
+};
+export declare class LocalCacheEventHandler {
+    private errorHandler;
+    private exceptionHandler;
+    private promiseService;
+    private callbacks;
+    constructor(errorHandler: ErrorHandlerInterface, exceptionHandler: ExceptionHandlerInterface, promiseService: PromiseLibraryInterface);
+    registerCallback<T extends keyof LocalCacheCallbackType>(type: T, key: string, callback: LocalCacheCallbackType[T], condition?: LocalCacheCallbackCondition, priority?: number): () => void;
+    executeCallbacks<T extends keyof LocalCacheCallbackType>(type: T, execute: (callback: LocalCacheCallbackType[T]) => any, closeTab: boolean): PromiseInterface<any>;
+    private getPriorityLevel;
+    private executeCallbacksPriorityLevel;
+}

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

@@ -24,6 +24,7 @@ export * from './ItemHandler';
 export * from './ItemRequestService';
 export * from './KeyService';
 export * from './LocalCache';
+export * from './LocalCacheEventHandler';
 export * from './LockService';
 export * from './ModuleChangesCompilation';
 export * from './QueryMatcher';

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

@@ -7,5 +7,11 @@ export declare class ColumnSetFactory {
     private columnInfoFactory;
     constructor(columnHandler: ColumnHandler, columnUtil: ColumnUtil, columnInfoFactory: ColumnInfoFactory);
     constructStub(itemType: ItemType, requestColumns: ApiRequestColumns): ColumnSet;
+    resolveStub(columnSet: ColumnSet, responseColumns: ResponseColumnMap, enableCaching?: boolean, includeIdColumn?: boolean): ColumnSet;
     construct(itemType: ItemType, requestColumns: ApiRequestColumns, responseColumns: ResponseColumnMap, enableCaching?: boolean, includeIdColumn?: boolean): ColumnSet;
+    constructFromResponse(itemType: ItemType, responseColumns: ResponseColumnMap, enableCaching?: boolean): ColumnSet;
+    private processResponseColumns;
+    private processRequestColumns;
+    private processColumnInfo;
+    private expandRootColumnMap;
 }

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

@@ -1,7 +1,6 @@
 import { LocalCache, LockService } from '../classes';
 import { ChangesProcessorFactory, CollectionCacheFactory, CollectionResourceFactory, ItemCacheFactory, ItemResourceFactory } from '../factories';
-import { ErrorHandlerInterface, PromiseLibraryInterface } from '../interfaces';
-import { ExceptionHandlerInterface } from '../interfaces/ExceptionHandlerInterface';
+import { ErrorHandlerInterface, ExceptionHandlerInterface, PromiseLibraryInterface } from '../interfaces';
 export declare class LocalCacheFactory {
     private changesProcessorFactory;
     private collectionCacheFactory;

package/dist/src/types/ItemTypesCollection.d.ts

@@ -1,4 +1,4 @@
-import { ApiResponseProcessor, CollectionMatcher, ColumnSet, LocalCache, RequestColumnExpansion } from '../classes';
+import { ApiResponseProcessor, CollectionMatcher, ColumnSet, RequestColumnExpansion } from '../classes';
 import { ENTRY_STATUS } from '../constants';
 import { CollectionEntry, CollectionEntryOptions, CollectionEntryOptionsInterface, CollectionResource, CollectionResourceOptions, CollectionResourceOptionsInterface, ItemEntry, ItemEntryOptionsInterface, ItemResource, ItemResourceOptionsInterface } from '../models';
 export declare type EntryParent = {
@@ -31,23 +31,6 @@ export declare type StateKey = {
     template?: string;
     itemId?: number;
 };
-export declare type OnSaveCallback = (localCache: LocalCache, conversionMap: ItemIdConversionMap) => any;
-export declare enum LocalCacheCallbackCondition {
-    Always = "always",
-    OnClose = "onClose",
-    SkipOnClose = "skipOnClose"
-}
-export declare type LocalCacheCallbacks<T> = {
-    always: {
-        [key: string]: T;
-    };
-    onClose: {
-        [key: string]: T;
-    };
-    skipOnClose: {
-        [key: string]: T;
-    };
-};
 export declare type SocketMessageType = 'event' | 'notification';
 export interface SocketMessage {
     header: {

package/package.json

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