@rentman/rm-core 1.7.5 → 1.7.6

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

@@ -1,8 +1,12 @@
-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, 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, LocalCacheCallbackCondition, OnSaveCallback, PromiseInterface } from '../types';
+import { ApiQuery, CollectionDefinition, CollectionOptionsInterface, CollectionResourceParentIdMap, ConversionMap, CreateRequestParameterMap, ItemId, ItemIdConversionMap, ItemOptionsInterface, ItemResourcesItemTypeMap, ItemType, LinkCollectionDefinition, LinkedItemEntryMap, PromiseInterface } from '../types';
+declare type EditResourceLinks<ItemTypeType extends ItemType> = {
+    main: EditResource<ItemTypeType>;
+    linked: ItemResourcesItemTypeMap;
+};
 export declare class ItemAdministrator {
     private apiRequestService;
     private authInterface;
@@ -45,18 +49,12 @@ export declare class ItemAdministrator {
         remote: true;
     }, level?: number): PromiseInterface<Array<RemoteViewResource<ItemTypeType>>>;
     getItemsByQuery<ItemTypeType extends ItemType>(itemType: ItemTypeType, query: ApiQuery, options: ItemOptionsInterface, level?: number): PromiseInterface<Array<LocalViewResource<ItemTypeType>>>;
-    getNewResource<ItemTypeType extends ItemType>(itemType: ItemTypeType, options: ItemOptionsInterface, returnLinks: true, level?: number, isRoot?: boolean): PromiseInterface<{
-        main: EditResource<ItemTypeType>;
-        linked: ItemResourcesItemTypeMap;
-    }>;
+    getNewResource<ItemTypeType extends ItemType>(itemType: ItemTypeType, options: ItemOptionsInterface, returnLinks: true, level?: number, isRoot?: boolean): PromiseInterface<EditResourceLinks<ItemTypeType>>;
     getNewResource<ItemTypeType extends ItemType>(itemType: ItemTypeType, options: ItemOptionsInterface, returnLinks?: boolean, level?: number, isRoot?: boolean): PromiseInterface<EditResource<ItemTypeType>>;
-    getDuplicateById<ItemTypeType extends ItemType>(itemType: ItemTypeType, duplicateId: ItemId, options: ItemOptionsInterface & {
-        edit: true;
-    }, level?: number, returnLinks?: boolean, isRoot?: boolean): PromiseInterface<EditResource<ItemTypeType>>;
-    getDuplicateById<ItemTypeType extends ItemType>(itemType: ItemTypeType, duplicateId: ItemId, options: ItemOptionsInterface & {
-        remote: true;
-    }, level?: number, returnLinks?: boolean, isRoot?: boolean): PromiseInterface<RemoteViewResource<ItemTypeType>>;
-    getDuplicateById<ItemTypeType extends ItemType>(itemType: ItemTypeType, duplicateId: ItemId, options: ItemOptionsInterface, level?: number, returnLinks?: boolean, isRoot?: boolean): PromiseInterface<LocalViewResource<ItemTypeType>>;
+    getNewResourceWithId<ItemTypeType extends ItemType>(itemType: ItemTypeType, itemId: ItemId, options: ItemOptionsInterface, returnLinks: true, level?: number, isRoot?: boolean): PromiseInterface<EditResourceLinks<ItemTypeType>>;
+    getNewResourceWithId<ItemTypeType extends ItemType>(itemType: ItemTypeType, itemId: ItemId, options: ItemOptionsInterface, returnLinks?: boolean, level?: number, isRoot?: boolean): PromiseInterface<EditResource<ItemTypeType>>;
+    getDuplicateById<ItemTypeType extends ItemType>(itemType: ItemTypeType, duplicateId: ItemId, options: ItemOptionsInterface, returnLinks: true, level?: number, isRoot?: boolean): PromiseInterface<EditResourceLinks<ItemTypeType>>;
+    getDuplicateById<ItemTypeType extends ItemType>(itemType: ItemTypeType, duplicateId: ItemId, options: ItemOptionsInterface, returnLinks?: boolean, level?: number, isRoot?: boolean): PromiseInterface<EditResource<ItemTypeType>>;
     getItemByState<ItemTypeType extends ItemType>(itemType: ItemTypeType, stateKey: ItemId | string, options: ItemOptionsInterface & {
         edit: true;
     }, level?: number, isRoot?: boolean): PromiseInterface<EditResource<ItemTypeType>>;
@@ -233,6 +231,7 @@ export declare class ItemAdministrator {
         remote: true;
     }, level?: number, isRoot?: boolean): RemoteViewResource<ItemTypeType>;
     createItemResource<ItemTypeType extends ItemType>(itemEntry: ItemEntry<ItemTypeType>, options: ItemResourceOptionsInterface, level?: number, isRoot?: boolean): LocalViewResource<ItemTypeType>;
-    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;
 }
+export {};

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

@@ -8,9 +8,8 @@ export declare class ItemEntryService {
     constructor(authInterface: AuthInterface, keyService: KeyService);
     processOptions(options: ItemOptionsInterface): ItemEntryOptions;
     createUnfoundRemoteItemError(): ItemError;
-    createUnfoundLocalItemError(itemType: ItemType): {
-        message: string;
-    };
+    createUnfoundLocalItemError(itemType: ItemType): ItemError;
+    createExistingLocalItemError(itemType: ItemType): ItemError;
     createLocalConversionMap(itemType: ItemType, itemId: ItemId, doExtend: boolean | undefined, apiResponse: ApiResponse): ItemIdConversionMap;
     expandLocalConversionMap(parentType: ItemType, parentId: ItemId, apiResponse: ApiResponse, conversionMap: ItemIdConversionMap): void;
     expandConversionMap(itemEntry: ItemEntry<any>, conversionMap: ItemIdConversionMap, newItemId?: ItemId): ItemId;

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

@@ -26,7 +26,7 @@ export declare class ItemHandler {
     };
     constructor(apiFormatter: ApiFormatter, apiRequestService: ApiRequestServiceInterface, batchStatusFactory: BatchStatusFactory, columnExpansionFactory: ColumnExpansionFactory, columnHandler: ColumnHandler, columnSetFactory: ColumnSetFactory, columnSubsetCacheFactory: ColumnSubsetCacheFactory, columnUtil: ColumnUtil, errorHandler: ErrorHandlerInterface, itemCacheFactory: ItemCacheFactory, itemEntryFactory: ItemEntryFactory, itemEntryService: ItemEntryService, keyService: KeyService, promiseService: PromiseLibraryInterface, templateFactory: TemplateFactory);
     fetchItem<ItemTypeType extends ItemType>(itemType: ItemTypeType, itemId: ItemId, options: ItemEntryOptions, localItemCache: ItemCache): PromiseInterface<ItemEntry<ItemTypeType>>;
-    fetchNewItem<ItemTypeType extends ItemType>(itemType: ItemTypeType, options: ItemEntryOptions, localItemCache: ItemCache): PromiseInterface<TemplateItemEntryMap<ItemTypeType>>;
+    fetchNewItem<ItemTypeType extends ItemType>(itemType: ItemTypeType, itemId: ItemId, options: ItemEntryOptions, localItemCache: ItemCache): PromiseInterface<TemplateItemEntryMap<ItemTypeType>>;
     createBatchStatus<ItemTypeType extends ItemType>(itemType: ItemTypeType, itemIds: ItemId[], parent: EntryParentNull, requestColumns: ApiRequestColumns, deferRequest: boolean, localItemCache: ItemCache, addToLocalCache: boolean): {
         batchStatus: BatchStatus<ItemTypeType, ItemEntry<ItemTypeType>>;
         success: boolean;

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

@@ -1,15 +1,12 @@
-import { ChangesProcessor, CollectionCache, ItemCache, LockService } from '../classes';
+import { ChangesProcessor, CollectionCache, ItemCache, LocalCacheCallbackCondition, LocalCacheCallbackType, 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, ItemType, LocalCacheCallbackCondition, OnSaveCallback, PromiseInterface } from '../types';
+import { CollectionEntryParentIdMap, CollectionResourceParentIdMap, CreateRequestParameterMap, ItemIdConversionMap, ItemOptionsInterface, ItemType, PromiseInterface } from '../types';
 export declare class LocalCache {
     private changesProcessor;
-    private collectionCacheFactory;
     private collectionResourceFactory;
     private errorHandler;
-    private exceptionHandler;
-    private itemCacheFactory;
     private itemResourceFactory;
     private lockService;
     private promiseService;
@@ -21,10 +18,10 @@ export declare class LocalCache {
     rootItem: ItemEntry<any> | undefined;
     tabRequestParameters: {};
     isSaving: boolean;
-    private callbacks;
     private changesInterval;
     hasChanges: boolean;
-    constructor(changesProcessor: ChangesProcessor, collectionCacheFactory: CollectionCacheFactory, collectionResourceFactory: CollectionResourceFactory, errorHandler: ErrorHandlerInterface, exceptionHandler: ExceptionHandlerInterface, itemCacheFactory: ItemCacheFactory, itemResourceFactory: ItemResourceFactory, lockService: LockService, promiseService: PromiseLibraryInterface, id: string, defaultResourceLevel: number);
+    private eventHandler;
+    constructor(exceptionHandler: ExceptionHandlerInterface, collectionCacheFactory: CollectionCacheFactory, itemCacheFactory: ItemCacheFactory, changesProcessor: ChangesProcessor, collectionResourceFactory: CollectionResourceFactory, errorHandler: ErrorHandlerInterface, itemResourceFactory: ItemResourceFactory, lockService: LockService, promiseService: PromiseLibraryInterface, id: string, defaultResourceLevel: number);
     createItemResource<ItemTypeType extends ItemType>(itemEntry: ItemEntry<ItemTypeType>, options: ItemOptionsInterface & {
         edit: true;
     }, level?: number, isRoot?: boolean, isNew?: boolean): EditResource<ItemTypeType>;
@@ -86,10 +83,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<any>): 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/models/ItemEntryOptions.d.ts

@@ -6,6 +6,5 @@ export declare class ItemEntryOptions {
     templateOptions: any;
     templateColumns: ApiRequestColumnMap;
     deferRequest: boolean;
-    isDuplicate: boolean;
     constructor(values: ItemEntryOptionsInterface);
 }

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.7.5",
+  "version": "1.7.6",
   "description": "Rentman core functionalities",
   "main": "./dist/rm-core.js",
   "types": "./dist/src/index.d.ts",