@rentman/rm-core 3.0.1 → 4.0.0

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

@@ -14,6 +14,7 @@ export * from './ColumnInfo';
 export * from './ColumnSet';
 export * from './ColumnSubsetCache';
 export * from './ColumnUtil';
+export * from './ConversionMapService';
 export * from './CreateRequest';
 export * from './ItemCache';
 export * from './ItemEntryService';
@@ -42,3 +43,4 @@ export * from './InternalChangesDelta';
 export * from './RequestBufferManager';
 export * from './RequestBuffer';
 export * from './ItemCreateService';
+export * from './CreatedChangesDelta';

package/dist/types/core.d.ts

@@ -1,4 +1,4 @@
-import { ApiFormatter, ApiRequestService, CollectionEntryService, CollectionResourceService, ColumnCache, ColumnHandler, ColumnUtil, ItemEntryService, KeyService, LockService, QueryService, SocketMessageHandler } from './classes';
+import { ApiFormatter, ApiRequestService, CollectionEntryService, CollectionResourceService, ColumnCache, ColumnHandler, ColumnUtil, ConversionMapService, ItemEntryService, KeyService, LockService, QueryService, SocketMessageHandler } from './classes';
 import { ItemCreateService } from './classes/ItemCreateService';
 import { TemplateCache } from './classes/TemplateCache';
 import { ApiResponseProcessorFactory, ChangesCompilationFactory, CollectionCacheFactory, CollectionEntryFactory, CollectionMatcherFactory, CollectionResourceFactory, ColumnExpansionFactory, ColumnInfoFactory, ColumnSetFactory, ColumnSubsetCacheFactory, CreateRequestFactory, ItemCacheFactory, ItemEntryFactory, ItemResourceFactory, ModuleChangesCompilationFactory, QueryMatcherFactory, QueryParserFactory, RequestColumnExpansionFactory, TemplateFactory, TransactionCacheFactory } from './factories';
@@ -13,6 +13,7 @@ export declare class RmCore {
     apiRequestService: ApiRequestService;
     apiResponseProcessorFactory: ApiResponseProcessorFactory;
     changesCompilationFactory: ChangesCompilationFactory;
+    changesDeltaFactory: ChangesDeltaFactory;
     changesProcessorFactory: ChangesProcessorFactory;
     collectionCacheFactory: CollectionCacheFactory;
     collectionEntryFactory: CollectionEntryFactory;
@@ -27,6 +28,7 @@ export declare class RmCore {
     columnSetFactory: ColumnSetFactory;
     columnSubsetCacheFactory: ColumnSubsetCacheFactory;
     columnUtil: ColumnUtil;
+    conversionMapService: ConversionMapService;
     createRequestFactory: CreateRequestFactory;
     itemCacheFactory: ItemCacheFactory;
     itemCreateService: ItemCreateService;
@@ -34,7 +36,6 @@ export declare class RmCore {
     itemEntryService: ItemEntryService;
     itemResourceFactory: ItemResourceFactory;
     keyService: KeyService;
-    transactionCacheFactory: TransactionCacheFactory;
     lockService: LockService;
     moduleChangesCompilationFactory: ModuleChangesCompilationFactory;
     queryMatcherFactory: QueryMatcherFactory;
@@ -42,9 +43,9 @@ export declare class RmCore {
     queryService: QueryService;
     requestColumnExpansionFactory: RequestColumnExpansionFactory;
     socketMessageHandler: SocketMessageHandler;
-    templateFactory: TemplateFactory;
-    changesDeltaFactory: ChangesDeltaFactory;
     templateCache: TemplateCache;
+    templateFactory: TemplateFactory;
+    transactionCacheFactory: TransactionCacheFactory;
     constructor(_apiRequestService: ApiRequestServiceInterface, authInterface: AuthInterface, errorHandler: ErrorHandlerInterface, exceptionHandler: ExceptionHandlerInterface, promiseLibrary: PromiseLibraryInterface, linkTreeService: LinkTreeServiceInterface);
 }
 export declare function noop(): void;

package/dist/types/factories/ItemResourceFactory.d.ts

@@ -2,8 +2,7 @@ import { ApiFormatter, ColumnUtil } from '../classes';
 import { TransactionCache } from '../classes/cache/transaction/TransactionCache';
 import { ErrorHandlerInterface, ExceptionHandlerInterface, PromiseLibraryInterface } from '../interfaces';
 import { ItemEntry, ItemResource } from '../models';
-import { ItemOptionsInterface, ItemType } from '../types';
-export declare type ResourceConstructor<ItemTypeType extends ItemType> = (itemEntry: ItemEntry<ItemTypeType>) => ItemResource<ItemTypeType>;
+import { ItemType } from '../types';
 export declare class ItemResourceFactory {
     apiFormatter: ApiFormatter;
     errorHandler: ErrorHandlerInterface;
@@ -11,7 +10,5 @@ export declare class ItemResourceFactory {
     exceptionHandler: ExceptionHandlerInterface;
     columnUtil: ColumnUtil;
     constructor(apiFormatter: ApiFormatter, errorHandler: ErrorHandlerInterface, promiseService: PromiseLibraryInterface, exceptionHandler: ExceptionHandlerInterface, columnUtil: ColumnUtil);
-    getConstructor<ItemTypeType extends ItemType>(options: ItemOptionsInterface, transaction: TransactionCache): ResourceConstructor<ItemTypeType>;
-    construct<ItemTypeType extends ItemType>(itemEntry: ItemEntry<ItemTypeType>, options: ItemOptionsInterface<ItemTypeType>, transaction: TransactionCache, isNew?: boolean): ItemResource<ItemTypeType>;
-    private constructWithOptions;
+    construct<ItemTypeType extends ItemType>(itemEntry: ItemEntry<ItemTypeType>, transaction: TransactionCache, isNew?: boolean): ItemResource<ItemTypeType>;
 }

package/dist/types/factories/TransactionCacheFactory.d.ts

@@ -1,54 +1,11 @@
-import { ApiFormatter, ApiRequestService, CollectionEntryService, ColumnCache, ColumnHandler, ColumnUtil, ItemEntryService, KeyService, LockService, QueryService } from '../classes';
-import { ServerCache } from '../classes/cache/server/ServerCache';
-import { TransactionCache } from '../classes/cache/transaction/TransactionCache';
-import { TransactionValidatorFactory } from '../classes/cache/transaction/TransactionValidator';
-import { ItemCreateService } from '../classes/ItemCreateService';
-import { RequestBufferManager } from '../classes/RequestBufferManager';
-import { TemplateCache } from '../classes/TemplateCache';
+import { ServerCache, TransactionCache, TransactionValidatorFactory } from '../classes';
 import { RmCore } from '../core';
-import { CollectionCacheFactory, CollectionEntryFactory, CollectionMatcherFactory, CollectionResourceFactory, ColumnExpansionFactory, ColumnSetFactory, ColumnSubsetCacheFactory, ItemCacheFactory, ItemEntryFactory, ItemResourceFactory, ModuleChangesCompilationFactory, QueryMatcherFactory, QueryParserFactory, RequestColumnExpansionFactory } from '../factories';
-import { AuthInterface, ErrorHandlerInterface, ExceptionHandlerInterface, PromiseLibraryInterface } from '../interfaces';
-import { LinkTreeServiceInterface } from '../interfaces/LinkTreeServiceInterface';
-import { ChangesDeltaFactory } from './ChangesDeltaFactory';
-import { ChangesProcessorFactory } from './ChangesProcessorFactory';
+import { ServerCacheDependencyInterface } from '../interfaces';
 export declare class TransactionCacheFactory {
+    private dependencies;
     private core;
-    private columnCache;
-    private requestBufferManager;
-    private requestColumnExpansionFactory;
-    private queryMatcherFactory;
-    private authInterface;
-    private changesDeltaFactory;
-    private changesProcessorFactory;
-    private lockService;
-    private moduleChangesCompilationFactory;
-    private collectionResourceFactory;
-    private itemResourceFactory;
-    private templateCache;
-    private itemCacheFactory;
-    private collectionCacheFactory;
-    private errorHandler;
-    private exceptionHandler;
-    private promiseService;
-    private apiFormatter;
-    private apiRequestService;
-    private columnExpansionFactory;
-    private columnHandler;
-    private columnSetFactory;
-    private columnSubsetCacheFactory;
-    private columnUtil;
-    private itemEntryFactory;
-    private itemEntryService;
-    private keyService;
-    private collectionEntryFactory;
-    private collectionEntryService;
-    private collectionMatcherFactory;
-    private queryParserFactory;
-    private queryService;
-    private linkTreeService;
-    private changesDeltaService;
     private readonly serverCache;
-    constructor(core: RmCore, columnCache: ColumnCache, requestBufferManager: RequestBufferManager, requestColumnExpansionFactory: RequestColumnExpansionFactory, queryMatcherFactory: QueryMatcherFactory, authInterface: AuthInterface, changesDeltaFactory: ChangesDeltaFactory, changesProcessorFactory: ChangesProcessorFactory, lockService: LockService, moduleChangesCompilationFactory: ModuleChangesCompilationFactory, collectionResourceFactory: CollectionResourceFactory, itemResourceFactory: ItemResourceFactory, templateCache: TemplateCache, itemCacheFactory: ItemCacheFactory, collectionCacheFactory: CollectionCacheFactory, errorHandler: ErrorHandlerInterface, exceptionHandler: ExceptionHandlerInterface, promiseService: PromiseLibraryInterface, apiFormatter: ApiFormatter, apiRequestService: ApiRequestService, columnExpansionFactory: ColumnExpansionFactory, columnHandler: ColumnHandler, columnSetFactory: ColumnSetFactory, columnSubsetCacheFactory: ColumnSubsetCacheFactory, columnUtil: ColumnUtil, itemEntryFactory: ItemEntryFactory, itemEntryService: ItemEntryService, keyService: KeyService, collectionEntryFactory: CollectionEntryFactory, collectionEntryService: CollectionEntryService, collectionMatcherFactory: CollectionMatcherFactory, queryParserFactory: QueryParserFactory, queryService: QueryService, linkTreeService: LinkTreeServiceInterface, changesDeltaService: ItemCreateService);
+    constructor(dependencies: ServerCacheDependencyInterface, core: RmCore);
     /**
      * Todo[cache] Store a map of all transactions by transaction id ?
      */

package/dist/types/interfaces/AbstractCacheDependencyInterface.d.ts

@@ -0,0 +1,44 @@
+import { ApiFormatter, ApiRequestService, CollectionEntryService, ColumnCache, ColumnHandler, ColumnUtil, ConversionMapService, ItemCreateService, ItemEntryService, KeyService, LockService, QueryService, RequestBufferManager } from '../classes';
+import { TemplateCache } from '../classes/TemplateCache';
+import { ChangesDeltaFactory, CollectionCacheFactory, CollectionEntryFactory, CollectionMatcherFactory, CollectionResourceFactory, ColumnExpansionFactory, ColumnSetFactory, ColumnSubsetCacheFactory, ItemCacheFactory, ItemEntryFactory, ItemResourceFactory, ModuleChangesCompilationFactory, QueryMatcherFactory, QueryParserFactory, RequestColumnExpansionFactory } from '../factories';
+import { AuthInterface } from './AuthInterface';
+import { ErrorHandlerInterface } from './ErrorHandlerInterface';
+import { ExceptionHandlerInterface } from './ExceptionHandlerInterface';
+import { LinkTreeServiceInterface } from './LinkTreeServiceInterface';
+import { PromiseLibraryInterface } from './PromiseLibraryInterface';
+export interface AbstractCacheDependencyInterface {
+    apiFormatter: ApiFormatter;
+    apiRequestService: ApiRequestService;
+    authInterface: AuthInterface;
+    changesDeltaFactory: ChangesDeltaFactory;
+    collectionCacheFactory: CollectionCacheFactory;
+    collectionEntryFactory: CollectionEntryFactory;
+    collectionEntryService: CollectionEntryService;
+    collectionMatcherFactory: CollectionMatcherFactory;
+    collectionResourceFactory: CollectionResourceFactory;
+    columnCache: ColumnCache;
+    columnExpansionFactory: ColumnExpansionFactory;
+    columnHandler: ColumnHandler;
+    columnSetFactory: ColumnSetFactory;
+    columnSubsetCacheFactory: ColumnSubsetCacheFactory;
+    columnUtil: ColumnUtil;
+    conversionMapService: ConversionMapService;
+    errorHandler: ErrorHandlerInterface;
+    exceptionHandler: ExceptionHandlerInterface;
+    itemCacheFactory: ItemCacheFactory;
+    itemCreateService: ItemCreateService;
+    itemEntryFactory: ItemEntryFactory;
+    itemEntryService: ItemEntryService;
+    itemResourceFactory: ItemResourceFactory;
+    keyService: KeyService;
+    linkTreeService: LinkTreeServiceInterface;
+    lockService: LockService;
+    moduleChangesCompilationFactory: ModuleChangesCompilationFactory;
+    promiseService: PromiseLibraryInterface;
+    queryMatcherFactory: QueryMatcherFactory;
+    queryParserFactory: QueryParserFactory;
+    queryService: QueryService;
+    requestBufferManager: RequestBufferManager;
+    requestColumnExpansionFactory: RequestColumnExpansionFactory;
+    templateCache: TemplateCache;
+}

package/dist/types/interfaces/ServerCacheDependencyInterface.d.ts

@@ -0,0 +1,7 @@
+import { ItemCreateService } from '../classes';
+import { ChangesProcessorFactory } from '../factories';
+import { AbstractCacheDependencyInterface } from './AbstractCacheDependencyInterface';
+export interface ServerCacheDependencyInterface extends AbstractCacheDependencyInterface {
+    changesProcessorFactory: ChangesProcessorFactory;
+    itemCreateService: ItemCreateService;
+}

package/dist/types/interfaces/TransactionCollectionHandlerDependencyInterface.d.ts

@@ -0,0 +1,20 @@
+import { CollectionEntryService, ColumnHandler, ColumnUtil, KeyService } from '../classes';
+import { ChangesDeltaFactory, CollectionCacheFactory, CollectionMatcherFactory, ColumnExpansionFactory, ColumnSubsetCacheFactory, RequestColumnExpansionFactory } from '../factories';
+import { ErrorHandlerInterface } from './ErrorHandlerInterface';
+import { ExceptionHandlerInterface } from './ExceptionHandlerInterface';
+import { PromiseLibraryInterface } from './PromiseLibraryInterface';
+export interface TransactionCollectionHandlerDependencyInterface {
+    requestColumnExpansionFactory: RequestColumnExpansionFactory;
+    columnUtil: ColumnUtil;
+    columnSubsetCacheFactory: ColumnSubsetCacheFactory;
+    columnExpansionFactory: ColumnExpansionFactory;
+    changesDeltaFactory: ChangesDeltaFactory;
+    collectionCacheFactory: CollectionCacheFactory;
+    collectionEntryService: CollectionEntryService;
+    collectionMatcherFactory: CollectionMatcherFactory;
+    columnHandler: ColumnHandler;
+    errorHandler: ErrorHandlerInterface;
+    keyService: KeyService;
+    promiseService: PromiseLibraryInterface;
+    exceptionHandler: ExceptionHandlerInterface;
+}

package/dist/types/interfaces/TransactionItemHandlerDependencyInterface.d.ts

@@ -0,0 +1,26 @@
+import { ApiFormatter, ColumnHandler, ColumnUtil, ConversionMapService, ItemCreateService, ItemEntryService, KeyService } from '../classes';
+import { TemplateCache } from '../classes/TemplateCache';
+import { ChangesDeltaFactory, ColumnExpansionFactory, ColumnSetFactory, ColumnSubsetCacheFactory, ItemCacheFactory, ItemEntryFactory, RequestColumnExpansionFactory } from '../factories';
+import { ErrorHandlerInterface } from './ErrorHandlerInterface';
+import { ExceptionHandlerInterface } from './ExceptionHandlerInterface';
+import { PromiseLibraryInterface } from './PromiseLibraryInterface';
+export interface TransactionItemHandlerDependencyInterface {
+    apiFormatter: ApiFormatter;
+    changesDeltaFactory: ChangesDeltaFactory;
+    columnExpansionFactory: ColumnExpansionFactory;
+    columnHandler: ColumnHandler;
+    columnSetFactory: ColumnSetFactory;
+    columnSubsetCacheFactory: ColumnSubsetCacheFactory;
+    columnUtil: ColumnUtil;
+    conversionMapService: ConversionMapService;
+    errorHandler: ErrorHandlerInterface;
+    exceptionHandler: ExceptionHandlerInterface;
+    itemCacheFactory: ItemCacheFactory;
+    itemCreateService: ItemCreateService;
+    itemEntryFactory: ItemEntryFactory;
+    itemEntryService: ItemEntryService;
+    keyService: KeyService;
+    promiseService: PromiseLibraryInterface;
+    requestColumnExpansionFactory: RequestColumnExpansionFactory;
+    templateCache: TemplateCache;
+}

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

@@ -5,3 +5,7 @@ export * from './AuthInterface';
 export * from './ApiRequestServiceInterface';
 export * from './SocketMessageInterface';
 export * from './LinkTreeServiceInterface';
+export * from './AbstractCacheDependencyInterface';
+export * from './TransactionItemHandlerDependencyInterface';
+export * from './TransactionCollectionHandlerDependencyInterface';
+export * from './ServerCacheDependencyInterface';

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

@@ -11,6 +11,7 @@ export declare class CollectionResource<ItemTypeType extends ItemType = any> {
     items: Array<ItemResource<ItemTypeType>>;
     columns: ResponseColumnItemTypeMap;
     protected itemIdMap: ItemResourceItemIdMap<ItemResource<ItemTypeType>>;
+    private fieldChangeDeregFns;
     private readonly onChange;
     constructor(factory: CollectionResourceFactory, entry: CollectionEntry<ItemTypeType>, options: CollectionResourceOptions<ItemTypeType>, transaction: TransactionCache);
     onConstruct(): void;
@@ -58,5 +59,5 @@ export declare class CollectionResource<ItemTypeType extends ItemType = any> {
      * @remarks
      * - Doesn't revert changes on the items themselves
      */
-    clearResource(clearItems?: boolean): void;
+    clearResource(): void;
 }

package/dist/types/models/CollectionResourceOptions.d.ts

@@ -1,5 +1,5 @@
 import { CollectionEntry, CollectionResource, ItemEntry, ItemResource } from '../models';
-import { ConversionMap, ItemType, OnChangeFunction } from '../types';
+import { ConversionMap, FieldChangeCallback, ItemType } from '../types';
 export declare type CollectionResourceCallback<ItemTypeType extends ItemType> = (itemResources: Array<ItemResource<ItemTypeType>>, collectionResource: CollectionResource<ItemTypeType>) => void;
 export declare type CollectionResourceOnAddCallback<ItemTypeType extends ItemType> = (itemResources: Array<ItemResource<ItemTypeType>>, collectionResource: CollectionResource<ItemTypeType>, isInitialCall: boolean) => void;
 export declare type CollectionResourceInitialCallback<ItemTypeType extends ItemType> = (itemEntries: Array<ItemEntry<ItemTypeType>>, collectionEntry: CollectionEntry<ItemTypeType>) => void;
@@ -9,12 +9,12 @@ export declare class CollectionResourceOptions<ItemTypeType extends ItemType> {
     callOnAddWithInitialItems: boolean;
     /**
      * @deprecated
-     * You should use itemResource.onChange and compare previous.id with fields.id
+     * You should use register a {@link TransactionCache.registerFieldChangeCallback field change callback} and compare previous.id with fields.id
      */
     onItemsCreated: OnItemsCreatedCallback;
-    onChange: OnChangeFunction;
     onAdd: CollectionResourceOnAddCallback<ItemTypeType>;
     onRemove: CollectionResourceCallback<ItemTypeType>;
+    onChange: FieldChangeCallback;
     onAddInitial: CollectionResourceInitialCallback<ItemTypeType>;
     onRemoveInitial: CollectionResourceInitialCallback<ItemTypeType>;
     resourceKey: string | null;

package/dist/types/models/ItemResource.d.ts

@@ -1,11 +1,10 @@
 import { TransactionCache } from '../classes';
 import { ItemResourceFactory } from '../factories';
-import { ItemEntry, ItemResourceOptions } from '../models';
+import { ItemEntry } from '../models';
 import { EntryParentNull, FieldMap, ItemType, PromiseInterface, ResponseColumn } from '../types';
 export declare class ItemResource<ItemTypeType extends ItemType = any> {
     protected readonly factory: ItemResourceFactory;
     readonly entry: ItemEntry<ItemTypeType>;
-    readonly options: ItemResourceOptions<ItemTypeType>;
     protected readonly _isNew: boolean;
     protected readonly transaction: TransactionCache;
     columns: {
@@ -13,7 +12,7 @@ export declare class ItemResource<ItemTypeType extends ItemType = any> {
     };
     fields: FieldMap<ItemTypeType>;
     initial: Readonly<FieldMap<ItemTypeType>>;
-    constructor(factory: ItemResourceFactory, entry: ItemEntry<ItemTypeType>, options: ItemResourceOptions<ItemTypeType>, _isNew: boolean, transaction: TransactionCache);
+    constructor(factory: ItemResourceFactory, entry: ItemEntry<ItemTypeType>, _isNew: boolean, transaction: TransactionCache);
     onConstruct(): void;
     /**
      * @description
@@ -34,7 +33,7 @@ export declare class ItemResource<ItemTypeType extends ItemType = any> {
      * @deprecated
      * Use {@link TransactionCache.applyChangesDelta transaction.applyChangesDelta} instead
      */
-    callOnChange(previous: FieldMap<ItemTypeType>): void;
+    callOnChange(): void;
     /**
      * @description
      * Utility function to easily check if a field is changed.
@@ -60,14 +59,6 @@ export declare class ItemResource<ItemTypeType extends ItemType = any> {
      */
     isNew(): boolean;
     isLocal(): boolean;
-    /**
-     * @description
-     * Removes the reference to the {@link ItemResource ItemResource} from the {@link TransactionCache TransactionCache}, so that the OnChange callback won't be called anymore.
-     *
-     * Warning:
-     * This doesn't revert any changes made to the item, in order to revert the changes you should use {@link TransactionItemHandler.clearItemEntry TransactionItemHandler.clearItemEntry}
-     */
-    clearResource(): void;
     toJSON(): {
         columns: string[];
         fields: FieldMap<ItemTypeType>;

package/dist/types/models/Template.d.ts

@@ -4,8 +4,8 @@ import { ApiRequestColumnMap, ApiResponse, FieldMap, ItemType, ResponseColumnIte
 export declare class Template<ItemTypeType extends ItemType = any> {
     itemType: ItemTypeType;
     response: ApiResponse;
-    fields: FieldMap<ItemTypeType>;
     responseColumns: ResponseColumnItemTypeMap;
     columns: ColumnSet<ItemTypeType>;
     constructor(factory: TemplateFactory, itemType: ItemTypeType, response: ApiResponse, additionalRequestColumns: ApiRequestColumnMap, additionalResponseColumns: ResponseColumnItemTypeMap);
+    getFields(): FieldMap<ItemTypeType>;
 }

package/dist/types/models/index.d.ts

@@ -1,5 +1,4 @@
 export * from './ItemEntryOptions';
-export * from './ItemResourceOptions';
 export * from './ItemEntry';
 export * from './ItemResource';
 export * from './CollectionEntryOptions';

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

@@ -1,5 +1,5 @@
 import { ApiResponseProcessor, CollectionMatcher, ColumnSet, RequestColumnExpansion } from '../classes';
-import { CollectionEntry, CollectionEntryOptions, CollectionEntryOptionsInterface, CollectionResource, CollectionResourceOptions, CollectionResourceOptionsInterface, ItemEntry, ItemEntryOptionsInterface, ItemResource, ItemResourceOptionsInterface } from '../models';
+import { CollectionEntry, CollectionEntryOptions, CollectionEntryOptionsInterface, CollectionResource, CollectionResourceOptions, CollectionResourceOptionsInterface, ItemEntry, ItemEntryOptionsInterface, ItemResource } from '../models';
 export declare type EntryParent = {
     itemType: string;
     itemId: number;
@@ -12,7 +12,7 @@ export declare type EntryParentNull = EntryParent | null;
 export declare type FieldMap<_ItemTypeType extends ItemType = any> = {
     [key: string]: any;
 };
-export declare type ItemOptionsInterface<ItemTypeType extends ItemType = any> = ItemEntryOptionsInterface & ItemResourceOptionsInterface<ItemTypeType>;
+export declare type ItemOptionsInterface = ItemEntryOptionsInterface;
 export declare type CollectionOptionsInterface<ItemTypeType extends ItemType = any> = CollectionEntryOptionsInterface & CollectionResourceOptionsInterface<ItemTypeType>;
 export interface CollectionDefinition<ItemTypeType extends ItemType = any> {
     itemType: ItemTypeType;
@@ -24,12 +24,6 @@ export interface CollectionDefinition<ItemTypeType extends ItemType = any> {
 export interface LinkCollectionDefinition<ItemTypeType extends ItemType = any> extends CollectionDefinition<ItemTypeType> {
     linkField: string;
 }
-export declare type OnChangeFunction<ItemTypeType extends ItemType = any> = (itemResource: ItemResource<ItemTypeType>, previous: FieldMap<ItemTypeType>, 
-/**
- * @description
- * Returns 'false' if the field changed
- */
-compareField: (field: keyof FieldMap<ItemTypeType>) => boolean, isCalledAfterSocketUpdate: boolean) => void;
 export declare enum StateKeyType {
     New = "new",
     Duplicate = "duplicate"
@@ -260,3 +254,10 @@ export declare type ApiLinkTree = {
  */
 export declare type FilterItemEntryCallback = <ItemTypeType extends ItemType>(itemType: ItemTypeType, fields: FieldMap<ItemTypeType>) => boolean;
 export declare type ModifyFieldsCallback = <ItemTypeType extends ItemType>(itemType: ItemTypeType, fields: FieldMap<ItemTypeType>, itemIdConversionMap?: ItemIdConversionMap) => void;
+/**
+ * @description
+ * Returns 'false' if the field changed
+ */
+export declare type CompareFieldCallback<ItemTypeType extends ItemType = any> = (field: keyof FieldMap<ItemTypeType>) => boolean;
+export declare type FieldChangeCallback<ItemTypeType extends ItemType = any> = (itemEntry: ItemEntry<ItemTypeType>, compareField: CompareFieldCallback, fields: FieldMap<ItemTypeType>, isCalledAfterSocketUpdate: boolean, previous: FieldMap<ItemTypeType>) => void;
+export declare type DeregFunction = () => void;

package/package.json

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

package/dist/types/models/ItemResourceOptions.d.ts

@@ -1,6 +0,0 @@
-import { ItemType, OnChangeFunction } from '../types';
-export declare type ItemResourceOptionsInterface<ItemTypeType extends ItemType = any> = Partial<ItemResourceOptions<ItemTypeType>>;
-export declare class ItemResourceOptions<ItemTypeType extends ItemType = any> {
-    onChange: OnChangeFunction<ItemTypeType>;
-    constructor(values: ItemResourceOptionsInterface<ItemTypeType>);
-}