@rentman/rm-core 1.6.13-3 → 1.7.1

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

@@ -1,31 +1,32 @@
-import { KeyService, LocalCache } from '../classes';
-import { ChangesProcessorFactory, ItemResourceFactory } from '../factories';
+import { ChangesProcessor, KeyService, LocalCache, ResourceCache } from '../classes';
+import { ItemResourceFactory } from '../factories';
 import { ErrorHandlerInterface, ExceptionHandlerInterface, PromiseLibraryInterface } from '../interfaces';
-import { CollectionEditResource, CollectionEntry, CollectionResourceOptionsInterface, CollectionViewResource, EditResource, LocalViewResource, RemoteViewResource } from '../models';
+import { CollectionEditResource, CollectionEntry, CollectionResource, CollectionResourceOptionsInterface, CollectionViewResource, EditResource, LocalViewResource, RemoteViewResource } from '../models';
 export declare class CollectionResourceFactory {
     errorHandler: ErrorHandlerInterface;
     exceptionHandler: ExceptionHandlerInterface;
     itemResourceFactory: ItemResourceFactory;
-    changesProcessorFactory: ChangesProcessorFactory;
+    changesProcessor: ChangesProcessor;
     keyService: KeyService;
     promiseService: PromiseLibraryInterface;
-    constructor(errorHandler: ErrorHandlerInterface, exceptionHandler: ExceptionHandlerInterface, itemResourceFactory: ItemResourceFactory, changesProcessorFactory: ChangesProcessorFactory, keyService: KeyService, promiseService: PromiseLibraryInterface);
+    readonly cache: ResourceCache<CollectionResource>;
+    constructor(errorHandler: ErrorHandlerInterface, exceptionHandler: ExceptionHandlerInterface, itemResourceFactory: ItemResourceFactory, changesProcessor: ChangesProcessor, keyService: KeyService, promiseService: PromiseLibraryInterface);
     construct(collectionEntry: CollectionEntry, options: CollectionResourceOptionsInterface & {
         editItems: true;
         editCollection: true;
-    }, localCache: LocalCache): CollectionEditResource<EditResource>;
+    }, level: number, localCache: LocalCache | null): CollectionEditResource<EditResource>;
     construct(collectionEntry: CollectionEntry, options: CollectionResourceOptionsInterface & {
         remoteItems: true;
         editCollection: true;
-    }, localCache: LocalCache): CollectionEditResource<RemoteViewResource>;
+    }, level: number, localCache: LocalCache | null): CollectionEditResource<RemoteViewResource>;
     construct(collectionEntry: CollectionEntry, options: CollectionResourceOptionsInterface & {
         editCollection: true;
-    }, localCache: LocalCache): CollectionEditResource<LocalViewResource>;
+    }, level: number, localCache: LocalCache | null): CollectionEditResource<LocalViewResource>;
     construct(collectionEntry: CollectionEntry, options: CollectionResourceOptionsInterface & {
         editItems: true;
-    }, localCache: LocalCache): CollectionViewResource<EditResource>;
+    }, level: number, localCache: LocalCache | null): CollectionViewResource<EditResource>;
     construct(collectionEntry: CollectionEntry, options: CollectionResourceOptionsInterface & {
         remoteItems: true;
-    }, localCache: LocalCache): CollectionViewResource<RemoteViewResource>;
-    construct(collectionEntry: CollectionEntry, options: CollectionResourceOptionsInterface, localCache: LocalCache): CollectionViewResource<LocalViewResource>;
+    }, level: number, localCache: LocalCache | null): CollectionViewResource<RemoteViewResource>;
+    construct(collectionEntry: CollectionEntry, options: CollectionResourceOptionsInterface, level: number, localCache: LocalCache | null): CollectionViewResource<LocalViewResource>;
 }

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

@@ -7,11 +7,5 @@ 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/ItemEntryFactory.d.ts

@@ -1,6 +1,6 @@
 import { ApiFormatter, ColumnSet, ItemEntryService, KeyService } from '../classes';
-import { ColumnSetFactory } from '../factories';
-import { ExceptionHandlerInterface, AuthInterface, PromiseLibraryInterface } from '../interfaces';
+import { ColumnSetFactory, ItemResourceFactory } from '../factories';
+import { AuthInterface, ExceptionHandlerInterface, PromiseLibraryInterface } from '../interfaces';
 import { ItemEntry, Template } from '../models';
 import { ApiRequestColumns, EntryParentNull, FieldMap, ItemId, ItemIdConversionMap, ItemType } from '../types';
 export declare class ItemEntryFactory {
@@ -9,9 +9,10 @@ export declare class ItemEntryFactory {
     columnSetFactory: ColumnSetFactory;
     exceptionHandler: ExceptionHandlerInterface;
     itemEntryService: ItemEntryService;
+    itemResourceFactory: ItemResourceFactory;
     keyService: KeyService;
     promiseService: PromiseLibraryInterface;
-    constructor(authInterface: AuthInterface, apiFormatter: ApiFormatter, columnSetFactory: ColumnSetFactory, exceptionHandler: ExceptionHandlerInterface, itemEntryService: ItemEntryService, keyService: KeyService, promiseService: PromiseLibraryInterface);
+    constructor(authInterface: AuthInterface, apiFormatter: ApiFormatter, columnSetFactory: ColumnSetFactory, exceptionHandler: ExceptionHandlerInterface, itemEntryService: ItemEntryService, itemResourceFactory: ItemResourceFactory, keyService: KeyService, promiseService: PromiseLibraryInterface);
     constructStub(itemType: ItemType, itemId: ItemId, columnSetStub: ColumnSet): ItemEntry;
     constructLocalLinked(itemType: ItemType, itemId: ItemId, initial: FieldMap, parent: EntryParentNull, columnSet: ColumnSet, conversionMap: ItemIdConversionMap): ItemEntry;
     constructLocal(itemId: ItemId, template: Template, modified: FieldMap, derived: FieldMap, parent?: EntryParentNull, columnSet?: ColumnSet, conversionMap?: ItemIdConversionMap): ItemEntry;

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

@@ -1,26 +1,29 @@
-import { ApiFormatter, ChangesProcessor, LockService } from '../classes';
+import { ApiFormatter, ChangesProcessor, LocalCache, LockService, ResourceCache } from '../classes';
 import { ErrorHandlerInterface, PromiseLibraryInterface } from '../interfaces';
-import { EditResource, ItemEntry, LocalViewResource, RemoteViewResource } from '../models';
+import { EditResource, ItemEntry, ItemResource, LocalViewResource, RemoteViewResource } from '../models';
 import { ItemOptionsInterface } from '../types';
+export declare type ResourceConstructor<T extends ItemResource> = (itemEntry: ItemEntry) => T;
 export declare class ItemResourceFactory {
     apiFormatter: ApiFormatter;
     lockService: LockService;
     changesProcessor: ChangesProcessor;
     errorHandler: ErrorHandlerInterface;
     promiseService: PromiseLibraryInterface;
+    readonly cache: ResourceCache<ItemResource>;
     constructor(apiFormatter: ApiFormatter, lockService: LockService, changesProcessor: ChangesProcessor, errorHandler: ErrorHandlerInterface, promiseService: PromiseLibraryInterface);
     getConstructor(options: ItemOptionsInterface & {
         edit: true;
-    }): (itemEntry: ItemEntry) => EditResource;
+    }, level: number, localCache: LocalCache | null): ResourceConstructor<EditResource>;
     getConstructor(options: ItemOptionsInterface & {
         remote: true;
-    }): (itemEntry: ItemEntry) => RemoteViewResource;
-    getConstructor(options: ItemOptionsInterface): (itemEntry: ItemEntry) => LocalViewResource;
+    }, level: number, localCache: LocalCache | null): ResourceConstructor<RemoteViewResource>;
+    getConstructor(options: ItemOptionsInterface, level: number, localCache: LocalCache | null): ResourceConstructor<LocalViewResource>;
     construct(itemEntry: ItemEntry, options: ItemOptionsInterface & {
         edit: true;
-    }, isNew?: boolean): EditResource;
+    }, level: number, localCache?: LocalCache | null, isNew?: boolean): EditResource;
     construct(itemEntry: ItemEntry, options: ItemOptionsInterface & {
         remote: true;
-    }, isNew?: boolean): LocalViewResource;
-    construct(itemEntry: ItemEntry, options: ItemOptionsInterface, isNew?: boolean): RemoteViewResource;
+    }, level: number, localCache?: LocalCache | null, isNew?: boolean): LocalViewResource;
+    construct(itemEntry: ItemEntry, options: ItemOptionsInterface, level: number, localCache?: LocalCache | null, isNew?: boolean): RemoteViewResource;
+    private constructWithOptions;
 }

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

@@ -1,8 +1,8 @@
-import { LocalCache, LockService } from '../classes';
-import { ChangesProcessorFactory, CollectionCacheFactory, CollectionResourceFactory, ItemCacheFactory, ItemResourceFactory } from '../factories';
+import { ChangesProcessor, LocalCache, LockService } from '../classes';
+import { CollectionCacheFactory, CollectionResourceFactory, ItemCacheFactory, ItemResourceFactory } from '../factories';
 import { ErrorHandlerInterface, ExceptionHandlerInterface, PromiseLibraryInterface } from '../interfaces';
 export declare class LocalCacheFactory {
-    private changesProcessorFactory;
+    private changesProcessor;
     private collectionCacheFactory;
     private collectionResourceFactory;
     private errorHandler;
@@ -11,6 +11,6 @@ export declare class LocalCacheFactory {
     private itemResourceFactory;
     private lockService;
     private promiseService;
-    constructor(changesProcessorFactory: ChangesProcessorFactory, collectionCacheFactory: CollectionCacheFactory, collectionResourceFactory: CollectionResourceFactory, errorHandler: ErrorHandlerInterface, exceptionHandler: ExceptionHandlerInterface, itemCacheFactory: ItemCacheFactory, itemResourceFactory: ItemResourceFactory, lockService: LockService, promiseService: PromiseLibraryInterface);
-    construct(id?: string): LocalCache;
+    constructor(changesProcessor: ChangesProcessor, collectionCacheFactory: CollectionCacheFactory, collectionResourceFactory: CollectionResourceFactory, errorHandler: ErrorHandlerInterface, exceptionHandler: ExceptionHandlerInterface, itemCacheFactory: ItemCacheFactory, itemResourceFactory: ItemResourceFactory, lockService: LockService, promiseService: PromiseLibraryInterface);
+    construct(id: string, defaultResourceLevel: number): LocalCache;
 }

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

@@ -1,7 +1,6 @@
 export * from './ApiResponseProcessorFactory';
 export * from './BatchStatusFactory';
 export * from './ChangesCompilationFactory';
-export * from './ChangesProcessorFactory';
 export * from './CollectionCacheFactory';
 export * from './CollectionEntryFactory';
 export * from './CollectionMatcherFactory';

package/dist/src/interfaces/LocalCacheManagerInterface.d.ts

@@ -2,5 +2,4 @@ import { LocalCache } from '../classes';
 export interface LocalCacheManagerInterface {
     getCurrentLocalCache(userId: string): LocalCache;
     getAllLocalCaches(): LocalCache[];
-    setCurrentLocalCache(userId: string, entry: LocalCache): any;
 }

package/dist/src/models/CollectionEditResource.d.ts

@@ -3,7 +3,7 @@ import { CollectionResourceFactory } from '../factories';
 import { CollectionEntry, CollectionResource, CollectionResourceOptions, ItemResource, LocalViewResource } from '../models';
 import { FieldMap, ItemId, ItemIdConversionMap, PromiseInterface } from '../types';
 export declare class CollectionEditResource<T extends ItemResource = LocalViewResource> extends CollectionResource<T> {
-    constructor(factory: CollectionResourceFactory, collectionEntry: CollectionEntry, options: CollectionResourceOptions, localCache: LocalCache);
+    constructor(factory: CollectionResourceFactory, collectionEntry: CollectionEntry, options: CollectionResourceOptions, level: number, localCache: LocalCache | null);
     save(): PromiseInterface<ItemIdConversionMap>;
     moveItems(idArray: ItemId[], destination: CollectionResource, enableCallbacks?: boolean): T[];
     removeItems(idArray: ItemId[], callOnRemove?: boolean): PromiseInterface<T[]>;

package/dist/src/models/CollectionEntry.d.ts

@@ -8,19 +8,19 @@ export declare class CollectionEntry {
     itemType: ItemType;
     options: CollectionEntryOptions;
     id: number;
+    parent: EntryParentNull;
     query: CollectionQuery;
     columns: ColumnSet;
-    templateColumns: ColumnSet | null;
-    parent: EntryParentNull;
+    private templateColumns;
     initial: ItemEntry[];
     items: ItemEntry[];
-    resources: CollectionResource[];
     deferred?: Deferred<this>;
     promise: PromiseInterface<this>;
     reloadQueued: boolean;
     hasEditResources: boolean;
     hasItemEditResources: boolean;
     constructor(factory: CollectionEntryFactory, itemType: ItemType, options: CollectionEntryOptions);
+    private getResources;
     defer(): this;
     isDeferred(): boolean;
     _resolve(): this;
@@ -67,8 +67,6 @@ export declare class CollectionEntry {
     hasAddedItems(): boolean;
     hasRemovedItems(): boolean;
     hasUpdatedItems(): boolean;
-    getCurrentResource<T extends CollectionResource>(): T;
-    clearResources(isSubtabChange?: boolean): void;
     /**
      * @description
      * this doesn't revert updates

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

@@ -6,12 +6,13 @@ export declare abstract class CollectionResource<T extends ItemResource = LocalV
     protected factory: CollectionResourceFactory;
     entry: CollectionEntry;
     options: CollectionResourceOptions;
-    localCache: LocalCache;
+    level: number;
+    localCache: LocalCache | null;
     items: T[];
-    itemIdMap: ItemResourceItemIdMap<T>;
     columns: ResponseColumnMap;
+    protected itemIdMap: ItemResourceItemIdMap<T>;
     private readonly onChange;
-    protected constructor(factory: CollectionResourceFactory, entry: CollectionEntry, options: CollectionResourceOptions, localCache: LocalCache);
+    protected constructor(factory: CollectionResourceFactory, entry: CollectionEntry, options: CollectionResourceOptions, level: number, localCache: LocalCache | null);
     getItemById(itemId: number): T;
     rebuildMap(): void;
     addItemResources(itemEntries: ItemEntry[]): T[];
@@ -35,6 +36,6 @@ export declare abstract class CollectionResource<T extends ItemResource = LocalV
     map<U>(argument: string | ((itemResource: T) => U)): U[];
     reduce<U>(callback: (itemResource: T, value: U) => U, value: U): U;
     extend(queryCallback: QueryCallback, returnAllItems?: boolean, callOnAdd?: boolean): PromiseInterface<T[]>;
-    deactivate(): void;
     clearResource(): void;
+    deactivate(): void;
 }

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

@@ -17,8 +17,6 @@ export declare class CollectionResourceOptions {
     onAddInitial: CollectionResourceInitialCallback;
     onRemoveInitial: CollectionResourceInitialCallback;
     resourceKey: string | null;
-    clearOnTabChange: boolean;
-    clearOnSubTabChange: boolean;
     custom: any;
     constructor(values: CollectionResourceOptionsInterface);
 }

package/dist/src/models/CollectionViewResource.d.ts

@@ -2,5 +2,5 @@ import { LocalCache } from '../classes';
 import { CollectionResourceFactory } from '../factories';
 import { CollectionEntry, CollectionResource, CollectionResourceOptions, ItemResource, LocalViewResource } from '../models';
 export declare class CollectionViewResource<T extends ItemResource = LocalViewResource> extends CollectionResource<T> {
-    constructor(collectionResourceFactory: CollectionResourceFactory, collectionEntry: CollectionEntry, options: CollectionResourceOptions, localCache: LocalCache);
+    constructor(collectionResourceFactory: CollectionResourceFactory, collectionEntry: CollectionEntry, options: CollectionResourceOptions, level: number, localCache: LocalCache | null);
 }

package/dist/src/models/EditResource.d.ts

@@ -1,11 +1,11 @@
+import { LocalCache } from '../classes';
 import { ItemResourceFactory } from '../factories';
 import { ItemEntry, ItemResource, ItemResourceOptions } from '../models';
 import { FieldMap, PromiseInterface } from '../types';
 export declare class EditResource extends ItemResource {
-    private factory;
-    localCopies: FieldMap[];
-    transactions: number;
-    constructor(factory: ItemResourceFactory, entry: ItemEntry, options: ItemResourceOptions, isNew?: boolean);
+    protected localCopies: FieldMap[];
+    protected transactions: number;
+    constructor(factory: ItemResourceFactory, entry: ItemEntry, options: ItemResourceOptions, isNew: boolean, localCache: LocalCache | null);
     isNew(): boolean;
     start(): this;
     rollback(): this;

package/dist/src/models/ItemEntry.d.ts

@@ -1,8 +1,7 @@
 import { ColumnSet } from '../classes';
 import { ItemEntryFactory } from '../factories';
-import { ItemResource } from '../models';
-import { ColumnExpansionResult, EntryParentNull, FieldMap, ItemError, ItemId, ItemIdConversionMap, ItemType, PromiseInterface } from '../types';
 import { Deferred } from '../interfaces';
+import { ColumnExpansionResult, EntryParentNull, FieldMap, ItemError, ItemId, ItemIdConversionMap, ItemType, PromiseInterface } from '../types';
 export declare class ItemEntry {
     private factory;
     itemType: string;
@@ -16,8 +15,8 @@ export declare class ItemEntry {
     initial: FieldMap;
     modified: FieldMap;
     derived: FieldMap;
-    resources: ItemResource[];
     constructor(factory: ItemEntryFactory, itemType: string, itemId: ItemId, columns: ColumnSet);
+    private getResources;
     queueReload(): this;
     defer(deferRequest?: boolean): this;
     getPromise(): PromiseInterface<this>;
@@ -29,8 +28,6 @@ export declare class ItemEntry {
     setLocalFields(initialValues: FieldMap, conversionMap: ItemIdConversionMap, columns?: ColumnSet): this;
     clone(conversionMap?: ItemIdConversionMap): ItemEntry;
     resetDerived(columnIds: string[]): this;
-    clearResources(): this;
-    deactivateResources(): this;
     getFields(): FieldMap;
     expand(main: FieldMap, derived: FieldMap, columnExpansionResult: ColumnExpansionResult): this;
     expandLocal(columnExpansionResult: ColumnExpansionResult): this;

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

@@ -1,15 +1,19 @@
+import { LocalCache } from '../classes';
+import { ItemResourceFactory } from '../factories';
 import { ItemEntry, ItemResourceOptions } from '../models';
 import { FieldMap, ResponseColumn } from '../types';
 export declare abstract class ItemResource {
-    entry: ItemEntry;
-    options: ItemResourceOptions;
+    protected readonly factory: ItemResourceFactory;
+    readonly entry: ItemEntry;
+    readonly options: ItemResourceOptions;
     protected readonly _isNew: boolean;
+    protected readonly localCache: LocalCache | null;
     columns: {
         [columnId: string]: ResponseColumn;
     };
     fields: FieldMap;
     derived: FieldMap;
-    protected constructor(entry: ItemEntry, options: ItemResourceOptions, _isNew?: boolean);
+    protected constructor(factory: ItemResourceFactory, entry: ItemEntry, options: ItemResourceOptions, _isNew: boolean, localCache: LocalCache | null);
     isNew(): boolean;
     isLocal(): boolean;
     clearResource(): void;

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

@@ -1,10 +1,8 @@
-import { ItemEntry } from '../models';
 import { OnChangeFunction } from '../types';
 export declare type ItemResourceOptionsInterface = Partial<ItemResourceOptions>;
 export declare class ItemResourceOptions {
     edit: boolean;
     remote: boolean;
     onChange: OnChangeFunction;
-    onDeactivate: (itemEntry: ItemEntry) => void;
     constructor(values: ItemResourceOptionsInterface);
 }

package/dist/src/models/LocalViewResource.d.ts

@@ -1,4 +1,6 @@
+import { LocalCache } from '../classes';
+import { ItemResourceFactory } from '../factories';
 import { ItemEntry, ItemResourceOptions, ViewResource } from '../models';
 export declare class LocalViewResource extends ViewResource {
-    constructor(entry: ItemEntry, options: ItemResourceOptions, isNew?: boolean);
+    constructor(factory: ItemResourceFactory, entry: ItemEntry, options: ItemResourceOptions, isNew: boolean, localCache: LocalCache | null);
 }

package/dist/src/models/RemoteViewResource.d.ts

@@ -1,4 +1,6 @@
+import { LocalCache } from '../classes';
+import { ItemResourceFactory } from '../factories';
 import { ItemEntry, ItemResourceOptions, ViewResource } from '../models';
 export declare class RemoteViewResource extends ViewResource {
-    constructor(entry: ItemEntry, options: ItemResourceOptions, isNew?: boolean);
+    constructor(factory: ItemResourceFactory, entry: ItemEntry, options: ItemResourceOptions, isNew: boolean, localCache: LocalCache | null);
 }

package/dist/src/models/ViewResource.d.ts

@@ -1,6 +1,8 @@
+import { LocalCache } from '../classes';
+import { ItemResourceFactory } from '../factories';
 import { ItemEntry, ItemResource, ItemResourceOptions } from '../models';
 import { FieldMap } from '../types';
 export declare abstract class ViewResource extends ItemResource {
     fields: Readonly<FieldMap>;
-    protected constructor(entry: ItemEntry, options: ItemResourceOptions, isNew?: boolean);
+    protected constructor(factory: ItemResourceFactory, entry: ItemEntry, options: ItemResourceOptions, isNew: boolean, localCache: LocalCache | null);
 }

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

@@ -1,4 +1,4 @@
-import { ApiResponseProcessor, CollectionMatcher, ColumnSet, RequestColumnExpansion } from '../classes';
+import { ApiResponseProcessor, CollectionMatcher, ColumnSet, LocalCache, 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,6 +31,23 @@ 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,35 +1,36 @@
-{
-  "name": "@rentman/rm-core",
-  "version": "1.6.13-3",
-  "description": "Rentman core functionalities",
-  "main": "./dist/rm-core.js",
-  "types": "./dist/src/index.d.ts",
-  "dependencies": {},
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/rentmanpublic/frontend-core"
-  },
-  "devDependencies": {
-    "@types/moment": "^2.13.0",
-    "@types/q": "^1.5.0",
-    "clean-webpack-plugin": "^0.1.19",
-    "ts-loader": "^4.4.1",
-    "tslint": "^5.12.1",
-    "typescript": "3.3.3",
-    "uglifyjs-webpack-plugin": "^1.2.5",
-    "webpack": "^4.16.3",
-    "webpack-cli": "^3.0.6",
-    "webpack-merge": "^4.1.3"
-  },
-  "files": [
-    "dist"
-  ],
-  "scripts": {
-    "prepublishOnly": "npm run bundle",
-    "bundle-dev": "webpack --config webpack.dev.js",
-    "bundle": "webpack --config webpack.prod.js",
-    "type-check": "tsc --noEmit"
-  },
-  "author": "Martijn Welker <martijn@rentman.nl>",
-  "license": "UNLICENSED"
-}
+{
+  "name": "@rentman/rm-core",
+  "version": "1.7.1",
+  "description": "Rentman core functionalities",
+  "main": "./dist/rm-core.js",
+  "types": "./dist/src/index.d.ts",
+  "dependencies": {},
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/rentmanpublic/frontend-core"
+  },
+  "devDependencies": {
+    "@types/moment": "^2.13.0",
+    "@types/q": "^1.5.0",
+    "clean-webpack-plugin": "^0.1.19",
+    "ts-loader": "^4.4.1",
+    "tslint": "^5.12.1",
+    "typescript": "3.3.3",
+    "typescript-tslint-plugin": "^0.5.3",
+    "uglifyjs-webpack-plugin": "^1.2.5",
+    "webpack": "^4.16.3",
+    "webpack-cli": "^3.0.6",
+    "webpack-merge": "^4.1.3"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "prepublishOnly": "npm run bundle",
+    "bundle-dev": "webpack --config webpack.dev.js",
+    "bundle": "webpack --config webpack.prod.js",
+    "type-check": "tsc --noEmit"
+  },
+  "author": "Martijn Welker <martijn@rentman.nl>",
+  "license": "UNLICENSED"
+}

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

@@ -1,19 +0,0 @@
-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/factories/ChangesProcessorFactory.d.ts

@@ -1,18 +0,0 @@
-import { ApiFormatter, ChangesProcessor, CollectionEntryService, CollectionHandler, ItemHandler } from '../classes';
-import { ChangesCompilationFactory, ColumnExpansionFactory, CreateRequestFactory, RequestColumnExpansionFactory } from '../factories';
-import { ApiRequestServiceInterface, ErrorHandlerInterface, PromiseLibraryInterface } from '../interfaces';
-export declare class ChangesProcessorFactory {
-    private apiFormatter;
-    private apiRequestService;
-    private changesCompilationFactory;
-    private collectionEntryService;
-    private collectionHandler;
-    private columnExpansionFactory;
-    private createRequestFactory;
-    private errorHandler;
-    private itemHandler;
-    private promiseService;
-    private requestColumnExpansionFactory;
-    constructor(apiFormatter: ApiFormatter, apiRequestService: ApiRequestServiceInterface, changesCompilationFactory: ChangesCompilationFactory, collectionEntryService: CollectionEntryService, collectionHandler: CollectionHandler, columnExpansionFactory: ColumnExpansionFactory, createRequestFactory: CreateRequestFactory, errorHandler: ErrorHandlerInterface, itemHandler: ItemHandler, promiseService: PromiseLibraryInterface, requestColumnExpansionFactory: RequestColumnExpansionFactory);
-    construct(): ChangesProcessor;
-}