@rentman/rm-core 1.0.22 → 1.0.24

package/changelog.md

@@ -0,0 +1,33 @@
+#Changelog
+Contains new features, breaking changes and their reasoning
+
+- The core now expects a `promiseInterface` that should implement the provided `promiseInterface`
+> We need to be able to hook into the promises in order to call a digest cycle to update the ui in the frontend
+
+- Rename `ItemEntry.entryId` to `ItemEntry.id
+> It used to be called `id`, but it was changed in the seperation of the core.
+> You can use the `id` to uniquely identify an entry, since itemId can be updated (local to saved id)
+
+- Rename ItemResource `startTransaction` to `start`
+> Other functions are called `commit` and `rollback` so having 'transaction' only for start doesn't make much sense
+
+- `SocketMessageHandler.onMessageReceived` now returns a promise
+> You can now use the updated items or hook into the result to update the ui for example
+
+##v1.0.23
+- Rename ResourceCache to LocalCache
+> LocalCache only caches local items (name better reflects functionality)
+
+- Remove getter/setter for hasChanges
+> hasChanges is called in a digest loop in the frontend, so for performance reasons we don't want to recompute the value every time
+ 
+- Remove `_getCollection` from ItemAdministrator
+> `_getCollection` is now named `getCollection` and the old `getCollection` is removed. The query is part of the
+> options and should not be given as a separate argument. This was included to support the frontend
+
+- Remove `saveCurrentTab` from ItemAdministrator
+> `saveCurrentTab` makes no sense because the core has no concept of tabs, you should use `saveCurrentLocalCache` instead
+
+- Remove `getTabEntry` and `resetTabEntry` from ItemAdministrator
+> `getTabEntry` and `resetTabEntry` make no sense because the core has no concept of tabs, you should use `getLocalCache` and `resetLocalCache` instead
+

package/dist/definitions/src/classes/ApiRequestService.d.ts

@@ -5,13 +5,13 @@ export default class ApiRequestService {
     private externalApiRequestService;
     private apiResponseProcessorFactory;
     constructor(externalApiRequestService: ApiRequestServiceInterface, apiResponseProcessorFactory: ApiResponseProcessorFactory);
-    template(itemType: string, params: any): PromiseLike<ApiResponseProcessor>;
-    create(itemType: string, itemId: number, values: any, parentType?: string, parentId?: number): PromiseLike<ApiResponseProcessor>;
-    delete(itemType: string, itemIds: number[]): PromiseLike<ApiResponseProcessor>;
-    updateItems(itemType: string, items: object, columns: any): PromiseLike<ApiResponseProcessor>;
-    requestSkeleton(params: any, requestCanceler?: PromiseLike<any>): PromiseLike<ApiResponseProcessor>;
-    moveItems(parentType: string, parentId: number, items: object): PromiseLike<ApiResponseProcessor>;
-    columns(itemType: string, columns: object, params?: any): PromiseLike<ApiResponseProcessor>;
-    query(itemType: string, query: object, columns: object, allLinks?: boolean, limit?: object): PromiseLike<ApiResponseProcessor>;
-    processResponse(request: any): PromiseLike<ApiResponseProcessor>;
+    template(itemType: string, params: any): Promise<ApiResponseProcessor>;
+    create(itemType: string, itemId: number, values: any, parentType?: string, parentId?: number): Promise<ApiResponseProcessor>;
+    delete(itemType: string, itemIds: number[]): Promise<ApiResponseProcessor>;
+    updateItems(itemType: string, items: object, columns: any): Promise<ApiResponseProcessor>;
+    requestSkeleton(params: any, requestCanceler?: Promise<any>): Promise<ApiResponseProcessor>;
+    moveItems(parentType: string, parentId: number, items: object): Promise<ApiResponseProcessor>;
+    columns(itemType: string, columns: object, params?: any): Promise<ApiResponseProcessor>;
+    query(itemType: string, query: object, columns: object, allLinks?: boolean, limit?: object): Promise<ApiResponseProcessor>;
+    processResponse(request: any): Promise<ApiResponseProcessor>;
 }

package/dist/definitions/src/classes/BatchStatus.d.ts

@@ -1,6 +1,6 @@
 import { ENTRY_STATUS } from "../constants";
+import PromiseInterface from '../interfaces/PromiseInterface';
 import ItemEntry from "../models/ItemEntry";
-import PromiseService from "./PromiseService";
 import { EntryStatus } from '../types/ItemTypesCollection';
 import { ItemEntryEntryStatusMap } from '../types/ItemTypesCollection';
 export default class BatchStatus {
@@ -8,12 +8,12 @@ export default class BatchStatus {
     getItemId: (itemEntry: ItemEntry) => number;
     getPromise: (itemEntry: ItemEntry) => Promise<ItemEntry>;
     entries: ItemEntryEntryStatusMap;
-    constructor(promiseService: PromiseService, getItemId: (itemEntry: ItemEntry) => number, getPromise: (itemEntry: ItemEntry) => Promise<ItemEntry>);
+    constructor(promiseService: PromiseInterface, getItemId: (itemEntry: ItemEntry) => number, getPromise: (itemEntry: ItemEntry) => Promise<ItemEntry>);
     add(entryStatus: EntryStatus<ItemEntry>): void;
     hasEntries(statusArray: ENTRY_STATUS[]): boolean;
     hasRequests(): boolean;
     forEachEntry(statusArray: ENTRY_STATUS[], callback: (itemEntry: ItemEntry) => void): void;
-    getPromises(): PromiseLike<ItemEntry[]>;
+    getPromises(): Promise<ItemEntry[]>;
     getRequestIds(): number[];
     getArray(): ItemEntry[];
 }

package/dist/definitions/src/classes/ChangesProcessor.d.ts

@@ -4,13 +4,13 @@ import CreateRequestFactory from "../factories/CreateRequestFactory";
 import RequestColumnExpansionFactory from "../factories/RequestColumnExpansionFactory";
 import ApiRequestServiceInterface from '../interfaces/ApiRequestServiceInterface';
 import ErrorHandlerInterface from '../interfaces/ErrorHandlerInterface';
+import PromiseInterface from '../interfaces/PromiseInterface';
 import ApiFormatter from "./ApiFormatter";
 import CollectionEntryService from "./CollectionEntryService";
 import CollectionHandler from "./CollectionHandler";
 import ColumnHandler from "./ColumnHandler";
 import ItemEntryService from "./ItemEntryService";
 import ItemHandler from "./ItemHandler";
-import PromiseService from "./PromiseService";
 export default class ChangesProcessor {
     private apiRequestService;
     private itemHandler;
@@ -25,11 +25,11 @@ export default class ChangesProcessor {
     private itemEntryService;
     private apiFormatter;
     private promiseService;
-    constructor(apiRequestService: ApiRequestServiceInterface, itemHandler: ItemHandler, errorHandler: ErrorHandlerInterface, collectionHandler: CollectionHandler, columnHandler: ColumnHandler, changesCompilerFactory: ChangesCompilerFactory, createRequestFactory: CreateRequestFactory, columnExpansionFactory: ColumnExpansionFactory, requestColumnExpansionFactory: RequestColumnExpansionFactory, collectionEntryService: CollectionEntryService, itemEntryService: ItemEntryService, apiFormatter: ApiFormatter, promiseService: PromiseService);
+    constructor(apiRequestService: ApiRequestServiceInterface, itemHandler: ItemHandler, errorHandler: ErrorHandlerInterface, collectionHandler: CollectionHandler, columnHandler: ColumnHandler, changesCompilerFactory: ChangesCompilerFactory, createRequestFactory: CreateRequestFactory, columnExpansionFactory: ColumnExpansionFactory, requestColumnExpansionFactory: RequestColumnExpansionFactory, collectionEntryService: CollectionEntryService, itemEntryService: ItemEntryService, apiFormatter: ApiFormatter, promiseService: PromiseInterface);
     getItemTypeUpdatePriority(itemType: any): 0 | 1 | 2;
     buildMoveRequest(compilationEntries: any): {};
     getMapValue(itemType: any, itemId: any, map: any): any;
-    execute(singleItems: any, collections: any, breakupByParent?: boolean, parameters?: any, collectionOptions?: any, onAfterCreateCallback?: any): any;
+    execute(singleItems: any, collections: any, breakupByParent?: boolean, parameters?: any, collectionOptions?: any, onAfterCreateCallback?: any): Promise<any>;
     private executeCreateRequests(compilation, parameters, conversionMap, breakupByParent, onAfterCreateCallback);
     private executeCreateRequest(requestResource, conversionMap);
     private prioritizeUpdateRequests(compilation, parameters);

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

@@ -3,6 +3,7 @@ import CollectionEntryFactory from "../factories/CollectionEntryFactory";
 import ColumnSetFactory from "../factories/ColumnSetFactory";
 import QueryParserFactory from "../factories/QueryParserFactory";
 import ErrorHandlerInterface from '../interfaces/ErrorHandlerInterface';
+import PromiseInterface from '../interfaces/PromiseInterface';
 import CollectionEntry from "../models/CollectionEntry";
 import CollectionResource from "../models/CollectionResource";
 import ItemEntry from "../models/ItemEntry";
@@ -16,7 +17,6 @@ import ItemEntryService from "./ItemEntryService";
 import ItemHandler from "./ItemHandler";
 import ItemRequestService from "./ItemRequestService";
 import KeyService from "./KeyService";
-import PromiseService from "./PromiseService";
 import QueryService from "./QueryService";
 import { CollectionEntryBatchStatusMap, CollectionEntryParentIdMap, EntryStatus, ItemResourceItemIdMap } from '../types/ItemTypesCollection';
 export default class CollectionHandler {
@@ -35,7 +35,7 @@ export default class CollectionHandler {
     private queryService;
     private columnUtil;
     entries: CollectionCache;
-    constructor(errorHandler: ErrorHandlerInterface, itemRequestService: ItemRequestService, itemHandler: ItemHandler, columnHandler: ColumnHandler, collectionEntryFactory: CollectionEntryFactory, collectionCacheFactory: CollectionCacheFactory, queryParserFactory: QueryParserFactory, collectionEntryService: CollectionEntryService, columnSetFactory: ColumnSetFactory, itemEntryService: ItemEntryService, keyService: KeyService, promiseService: PromiseService, queryService: QueryService, columnUtil: ColumnUtil);
+    constructor(errorHandler: ErrorHandlerInterface, itemRequestService: ItemRequestService, itemHandler: ItemHandler, columnHandler: ColumnHandler, collectionEntryFactory: CollectionEntryFactory, collectionCacheFactory: CollectionCacheFactory, queryParserFactory: QueryParserFactory, collectionEntryService: CollectionEntryService, columnSetFactory: ColumnSetFactory, itemEntryService: ItemEntryService, keyService: KeyService, promiseService: PromiseInterface, queryService: QueryService, columnUtil: ColumnUtil);
     getPromises(statusResource: CollectionEntryBatchStatusMap): any[];
     getRequestIds(statusResource: any): any[];
     removeFromAndAddToCollections(collectionMap: any, updateInitial?: any): void;
@@ -45,15 +45,15 @@ export default class CollectionHandler {
      */
     addItemsToCollections(itemEntries: ItemEntry[]): ItemResource[];
     addToCollections(collectionMap: any, updateInitial: boolean, resultResource?: ItemResource | null): ItemResource[];
-    batchExpand(parentType: string, itemType: string, collections: CollectionResource[], newColumns: any): PromiseLike<CollectionResource[]>;
-    batchExtend(parentType: string, itemType: string, options: any, queryCallback: any, collections: CollectionResource[], returnAllItems?: boolean): PromiseLike<ItemResourceItemIdMap>;
-    batchFetch(parentType: string, parentIdArray: number[], itemType: string, options: any, deferredCollectionCache: CollectionCache): PromiseLike<CollectionEntryParentIdMap>;
+    batchExpand(parentType: string, itemType: string, collections: CollectionResource[], newColumns: any): Promise<CollectionResource[]>;
+    batchExtend(parentType: string, itemType: string, options: any, queryCallback: any, collections: CollectionResource[], returnAllItems?: boolean): Promise<ItemResourceItemIdMap>;
+    batchFetch(parentType: string, parentIdArray: number[], itemType: string, options: any, deferredCollectionCache: CollectionCache): Promise<CollectionEntryParentIdMap>;
     clone(collectionEntry: CollectionEntry, options: any, conversionMap?: {}): CollectionEntry;
     create(itemType: string, options: any, columns: any, items: ItemEntry[]): CollectionEntry;
     createCollectionMap(itemEntries: ItemEntry[]): {};
     createStatusResource(parentType: string, parentIdArray: number[], itemType: string, options: any, deferredCollectionCache: CollectionCache): CollectionEntryBatchStatusMap;
     expandCollectionMap(itemEntry: ItemEntry, accumulator: any, collectionCache?: CollectionCache): void;
-    fetch(itemType: string, options: any, itemCache: ItemCache, deferredCollectionCache: CollectionCache): PromiseLike<CollectionEntry>;
+    fetch(itemType: string, options: any, itemCache: ItemCache, deferredCollectionCache: CollectionCache): Promise<CollectionEntry>;
     getDeferredEntryStatus(collectionEntry: CollectionEntry, options: any): EntryStatus<CollectionEntry>;
     getEntryStatus(itemType: string, options: any, deferredEntries: CollectionCache): EntryStatus<CollectionEntry>;
     getNewEntryStatus(itemType: string, query: any, options: any, deferredEntries: CollectionCache): EntryStatus<CollectionEntry>;
@@ -66,6 +66,6 @@ export default class CollectionHandler {
      * @deprecated
      */
     removeItemsFromCollections(itemEntries: ItemEntry[]): any;
-    resolveLocal(collectionEntry: CollectionEntry, itemCache: any): PromiseLike<CollectionEntry>;
-    resolveRemote(collectionEntry: any, itemCache: any): PromiseLike<CollectionEntry>;
+    resolveLocal(collectionEntry: CollectionEntry, itemCache: any): Promise<CollectionEntry>;
+    resolveRemote(collectionEntry: any, itemCache: any): Promise<CollectionEntry>;
 }

package/dist/definitions/src/classes/ColumnHandler.d.ts

@@ -1,19 +1,19 @@
 import ApiRequestServiceInterface from '../interfaces/ApiRequestServiceInterface';
 import ErrorHandlerInterface from '../interfaces/ErrorHandlerInterface';
+import PromiseInterface from '../interfaces/PromiseInterface';
 import ColumnCache from './ColumnCache';
 import ColumnUtil from './ColumnUtil';
-import PromiseService from "./PromiseService";
 export default class ColumnHandler {
     private apiRequestService;
     private errorHandler;
     private promiseService;
     private cache;
     private columnUtil;
-    constructor(apiRequestService: ApiRequestServiceInterface, errorHandler: ErrorHandlerInterface, promiseService: PromiseService, cache: ColumnCache, columnUtil: ColumnUtil);
+    constructor(apiRequestService: ApiRequestServiceInterface, errorHandler: ErrorHandlerInterface, promiseService: PromiseInterface, cache: ColumnCache, columnUtil: ColumnUtil);
     setColumn(itemType: any, responseColumn: any): any;
     setColumns(itemType: any, requestColumns: any, responseColumns: any): {};
     fetchItemTypeTranslations(itemTypes: any): Promise<any>;
-    request(itemType: any, columns: any, params?: {}): PromiseLike<any>;
-    fetch(itemType: any, requestColumns: any, params?: {}): PromiseLike<any>;
-    fetchAll(itemType: any): PromiseLike<any>;
+    request(itemType: any, columns: any, params?: {}): Promise<any>;
+    fetch(itemType: any, requestColumns: any, params?: {}): Promise<any>;
+    fetchAll(itemType: any): Promise<any>;
 }

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

@@ -1,10 +1,10 @@
 import ColumnSetFactory from "../factories/ColumnSetFactory";
 import ModuleChangesCompilerFactory from "../factories/ModuleChangesCompilerFactory";
-import ResourceCacheFactory from "../factories/ResourceCacheFactory";
+import LocalCacheFactory from "../factories/LocalCacheFactory";
 import ApiRequestServiceInterface from '../interfaces/ApiRequestServiceInterface';
 import AuthInterface from '../interfaces/AuthInterface';
 import ErrorHandlerInterface from '../interfaces/ErrorHandlerInterface';
-import ResourceCacheInterface from '../interfaces/ResourceCacheInterface';
+import LocalCacheManagerInterface from '../interfaces/LocalCacheManagerInterface';
 import CollectionResource from '../models/CollectionResource';
 import ItemResource from '../models/ItemResource';
 import CollectionCache from './CollectionCache';
@@ -17,26 +17,26 @@ import ItemHandler from './ItemHandler';
 import ItemRequestService from "./ItemRequestService";
 import KeyService from "./KeyService";
 import QueryService from "./QueryService";
-import ResourceCache from "./ResourceCache";
+import LocalCache from "./LocalCache";
 import ItemEntry from '../models/ItemEntry';
 import { CollectionEntryParentIdMap, CollectionResourceParentIdMap, ItemResourceItemTypeMap, TemplateResponseItemEntryMap } from '../types/ItemTypesCollection';
 export default class ItemAdministrator {
     private apiRequestService;
-    private resourceCacheInterface;
+    private localCacheManager;
     private authInterface;
     private errorHandler;
     private itemHandler;
     private collectionHandler;
     private columnSetFactory;
     private itemRequestService;
-    private resourceCacheFactory;
+    private localCacheFactory;
     private moduleChangesCompilerFactory;
     private collectionEntryService;
     private collectionResourceService;
     private itemEntryService;
     private keyService;
     private queryService;
-    constructor(apiRequestService: ApiRequestServiceInterface, resourceCacheInterface: ResourceCacheInterface, authInterface: AuthInterface, errorHandler: ErrorHandlerInterface, itemHandler: ItemHandler, collectionHandler: CollectionHandler, columnSetFactory: ColumnSetFactory, itemRequestService: ItemRequestService, resourceCacheFactory: ResourceCacheFactory, moduleChangesCompilerFactory: ModuleChangesCompilerFactory, collectionEntryService: CollectionEntryService, collectionResourceService: CollectionResourceService, itemEntryService: ItemEntryService, keyService: KeyService, queryService: QueryService);
+    constructor(apiRequestService: ApiRequestServiceInterface, localCacheManager: LocalCacheManagerInterface, authInterface: AuthInterface, errorHandler: ErrorHandlerInterface, itemHandler: ItemHandler, collectionHandler: CollectionHandler, columnSetFactory: ColumnSetFactory, itemRequestService: ItemRequestService, localCacheFactory: LocalCacheFactory, moduleChangesCompilerFactory: ModuleChangesCompilerFactory, collectionEntryService: CollectionEntryService, collectionResourceService: CollectionResourceService, itemEntryService: ItemEntryService, keyService: KeyService, queryService: QueryService);
     getItemDefinition(itemType: string, itemId: any, options: any): {
         itemType: string;
         options: any;
@@ -48,15 +48,15 @@ export default class ItemAdministrator {
      * @param {string} itemType
      * @param {number} itemId
      * @param options
-     * @returns {PromiseLike<ItemResource>}
+     * @returns {Promise<ItemResource>}
      *
      * I expect not a template request from itemhandler.fetchItem because addSingleItem does not handle the
      * TemplateResponseItemEntryMap
      */
-    getItemById(itemType: string, itemId: number, options: any): PromiseLike<ItemResource>;
-    getItemsById(itemType: string, itemIds: number[], options: any): PromiseLike<ItemResource[]>;
-    getItemsByQuery(itemType: string, query: any, options: any): PromiseLike<ItemResource[]>;
-    getDuplicateById(itemType: string, duplicateId: number, options: any): PromiseLike<any>;
+    getItemById(itemType: string, itemId: number, options: any): Promise<ItemResource>;
+    getItemsById(itemType: string, itemIds: number[], options: any): Promise<ItemResource[]>;
+    getItemsByQuery(itemType: string, query: any, options: any): Promise<ItemResource[]>;
+    getDuplicateById(itemType: string, duplicateId: number, options: any): Promise<any>;
     /**
      * The return value is depended on the return links boolean. true returns the TemplateResponseItemEntryMap.
      * The type has to be asserted at use since you only know the type of the return value when the function is called
@@ -65,9 +65,9 @@ export default class ItemAdministrator {
      * @param options
      * @param {boolean} returnLinks
      * @param {boolean} isRoot
-     * @returns {PromiseLike<ItemResource> | PromiseLike<TemplateResponseItemEntryMap>}
+     * @returns {Promise<ItemResource> | Promise<TemplateResponseItemEntryMap>}
      */
-    getNewResource(itemType: string, options: any, returnLinks: boolean, isRoot: boolean): PromiseLike<ItemResource> | PromiseLike<TemplateResponseItemEntryMap>;
+    getNewResource(itemType: string, options: any, returnLinks: boolean, isRoot: boolean): Promise<ItemResource> | Promise<TemplateResponseItemEntryMap>;
     getCollectionDef(itemType: string, options: any): {
         itemType: string;
         options: {
@@ -85,22 +85,16 @@ export default class ItemAdministrator {
             resource: any;
         };
     };
-    /** @deprecated */
-    getCollection(itemType: string, query: any, options: any): PromiseLike<any>;
-    _getCollection(itemType: string, options: any): PromiseLike<CollectionResource>;
-    getCollectionFromDef(definition: any): PromiseLike<CollectionResource>;
-    getLinkCollection(linkType: string, linkId: number, itemType: string, options: any): PromiseLike<CollectionResource>;
-    getLinkCollections(linkType: string, linkIdArray: number[], itemType: string, options: any): PromiseLike<CollectionResourceParentIdMap>;
-    getLinkCollectionsFromDef(definition: any): PromiseLike<CollectionResourceParentIdMap>;
-    getAllLinkCollections(linkType: string, itemType: string, options: any): PromiseLike<CollectionEntryParentIdMap>;
-    getItemByDef(definition: any, isRoot: boolean): PromiseLike<any>;
+    getCollection(itemType: string, options: any): Promise<CollectionResource>;
+    getCollectionFromDef(definition: any): Promise<CollectionResource>;
+    getLinkCollection(linkType: string, linkId: number, itemType: string, options: any): Promise<CollectionResource>;
+    getLinkCollections(linkType: string, linkIdArray: number[], itemType: string, options: any): Promise<CollectionResourceParentIdMap>;
+    getLinkCollectionsFromDef(definition: any): Promise<CollectionResourceParentIdMap>;
+    getAllLinkCollections(linkType: string, itemType: string, options: any): Promise<CollectionEntryParentIdMap>;
+    getItemByDef(definition: any, isRoot: boolean): Promise<any>;
     cloneItem(newItemId: number, itemResource: any, options: any): ItemResource;
     cloneCollection(collectionResource: any, options: any, conversionMap: any): CollectionResource;
-    /**
-     * @deprecated
-     */
-    saveCurrentTab(closeTab: any, parameters: any, breakupByParent: any, onAfterCreateCallback: any, keepTabHeading: any): any;
-    saveCurrentResourceCache(closeTab: boolean, parameters: any, breakupByParent: boolean, onAfterCreateCallback: any, keepTabHeading?: boolean): any;
+    saveCurrentLocalCache(closeTab: boolean, parameters: any, breakupByParent: boolean, onAfterCreateCallback: any, keepTabHeading?: boolean): any;
     getCurrentCollections(): CollectionCache;
     getCurrentItems(): ItemCache;
     getCurrentChanges(): {
@@ -113,32 +107,15 @@ export default class ItemAdministrator {
     addCollection(collectionEntry: any, resourceOptions: any, processOptions?: any): CollectionResource;
     addCollections(collectionEntries: CollectionEntryParentIdMap, resourceOptions: any): CollectionResourceParentIdMap;
     processLinkedItems(linkedEntries: any[], options: any, addToCollections: boolean): ItemResourceItemTypeMap;
-    /**
-     * @deprecated
-     */
-    getTabEntry(): ResourceCache;
-    getResourceCache(): ResourceCache;
-    /**
-     * @deprecated
-     */
-    resetTabEntry(): void;
-    resetResourceCache(): void;
+    getLocalCache(): LocalCache;
+    resetLocalCache(): void;
     addToCollections(itemEntries: any[], resultCollectionResource: any): ItemResource[];
     removeFromCollections(itemEntries: any[], resultCollectionResource: any): any;
     updateItemIdMap(collectionMap: any, conversionMap: any): void;
     createCollectionResource(collectionEntry: any, resourceOptions: any, processOptions?: any): CollectionResource;
     createItemResource(itemEntry: any, options: any, isRoot: boolean): ItemResource;
     createItemResources(itemEntries: any[], options: any): ItemResource[];
-    /**
-     * @deprecated
-     */
     onBeforeSave(key: string, callback: any): () => void;
-    /**
-     * @deprecated
-     */
     onSaveSuccess(key: string, callback: any): () => void;
-    /**
-     * @deprecated
-     */
     onSaveWithoutClosing(key: string, callback: any): () => void;
 }

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

@@ -1,6 +1,6 @@
+import PromiseInterface from '../interfaces/PromiseInterface';
 import ApiFormatter from './ApiFormatter';
 import KeyService from './KeyService';
-import PromiseService from "./PromiseService";
 import ItemEntry from '../models/ItemEntry';
 export default class ItemEntryService {
     private apiFormatter;
@@ -8,7 +8,7 @@ export default class ItemEntryService {
     private promiseService;
     undefinedItemError: string;
     ALL_PERMISSIONS: number;
-    constructor(apiFormatter: ApiFormatter, keyService: KeyService, promiseService: PromiseService);
+    constructor(apiFormatter: ApiFormatter, keyService: KeyService, promiseService: PromiseInterface);
     resetDerived(itemEntry: any, columnIds: any): void;
     defer(itemEntry: ItemEntry, deferRequest: any): ItemEntry;
     resolve(itemEntry: any): ItemEntry;

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

@@ -7,6 +7,7 @@ import ItemEntryFactory from "../factories/ItemEntryFactory";
 import ApiRequestServiceInterface from '../interfaces/ApiRequestServiceInterface';
 import AuthInterface from '../interfaces/AuthInterface';
 import ErrorHandlerInterface from '../interfaces/ErrorHandlerInterface';
+import PromiseInterface from '../interfaces/PromiseInterface';
 import ItemEntry from "../models/ItemEntry";
 import ApiFormatter from "./ApiFormatter";
 import ColumnHandler from './ColumnHandler';
@@ -14,7 +15,6 @@ import ColumnUtil from './ColumnUtil';
 import ItemCache from "./ItemCache";
 import ItemEntryService from "./ItemEntryService";
 import KeyService from "./KeyService";
-import PromiseService from "./PromiseService";
 import BatchStatus from './BatchStatus';
 import ApiResponseProcessor from './ApiResponseProcessor';
 import { ApiTemplateItemTypeMap, EntryStatus, TemplateResponseItemEntryMap, TemplateResponseLinkedItemEntryMap } from '../types/ItemTypesCollection';
@@ -35,22 +35,22 @@ export default class ItemHandler {
     private columnUtil;
     entries: ItemCache;
     templates: ApiTemplateItemTypeMap;
-    constructor(apiRequestService: ApiRequestServiceInterface, authInterface: AuthInterface, errorHandler: ErrorHandlerInterface, itemEntryFactory: ItemEntryFactory, columnHandler: ColumnHandler, itemCacheFactory: ItemCacheFactory, batchStatusFactory: BatchStatusFactory, columnExpansionFactory: ColumnExpansionFactory, columnSetFactory: ColumnSetFactory, itemEntryService: ItemEntryService, apiFormatter: ApiFormatter, keyService: KeyService, promiseService: PromiseService, columnUtil: ColumnUtil);
+    constructor(apiRequestService: ApiRequestServiceInterface, authInterface: AuthInterface, errorHandler: ErrorHandlerInterface, itemEntryFactory: ItemEntryFactory, columnHandler: ColumnHandler, itemCacheFactory: ItemCacheFactory, batchStatusFactory: BatchStatusFactory, columnExpansionFactory: ColumnExpansionFactory, columnSetFactory: ColumnSetFactory, itemEntryService: ItemEntryService, apiFormatter: ApiFormatter, keyService: KeyService, promiseService: PromiseInterface, columnUtil: ColumnUtil);
     getItemId(itemEntry: ItemEntry): number;
     getPromise(itemEntry: ItemEntry): any;
-    fetchItem(itemType: string, itemId: number, options: any): PromiseLike<ItemEntry | TemplateResponseItemEntryMap>;
+    fetchItem(itemType: string, itemId: number, options: any): Promise<ItemEntry | TemplateResponseItemEntryMap>;
     /**
      *
      * @param itemType
      * @param itemIds
      * @param options
-     * @returns {PromiseLike<ItemEntry[]>}
+     * @returns {Promise<ItemEntry[]>}
      *
      * For every itemid find the status of the ItemEntry and resolve the promises so the result is
      * a usable ItemEntry
      */
-    fetchItems(itemType: any, itemIds: any, options: any): PromiseLike<ItemEntry[]>;
-    resolveCached(itemEntry: ItemEntry, status: ENTRY_STATUS, options: any): PromiseLike<ItemEntry>;
+    fetchItems(itemType: any, itemIds: any, options: any): Promise<ItemEntry[]>;
+    resolveCached(itemEntry: ItemEntry, status: ENTRY_STATUS, options: any): Promise<ItemEntry>;
     resolveLocal(itemEntry: ItemEntry, parent: any, template: any): TemplateResponseItemEntryMap;
     resolveExpansion(itemEntry: any, columnExpansion: any, response: any): ItemEntry;
     resolveRemote(itemEntry: any, columnInfo: any, response: any): ItemEntry;
@@ -72,7 +72,7 @@ export default class ItemHandler {
      * for every type of entry status there is in this batch request make sure the entries get resolved.
      * then return a array of the resulting ItemEntryArray
      */
-    batchResolve(itemType: any, batchStatus: BatchStatus, requestColumns: any, resolved: any): ItemEntry[] | PromiseLike<any>;
+    batchResolve(itemType: any, batchStatus: BatchStatus, requestColumns: any, resolved: any): ItemEntry[] | Promise<any>;
     cloneItem(newItemId: any, itemEntry: any, conversionMap?: any): any;
     createConversionMap(itemType: string, itemId: number, extend: boolean, response: any): {
         [x: string]: {
@@ -82,8 +82,8 @@ export default class ItemHandler {
     createLocalEntries(parentType: string, localParentId: number, template: any, conversionMap: any): TemplateResponseLinkedItemEntryMap[];
     createLocalEntry(itemId: number, template: any, modified: any, derived: any, parent?: any): ItemEntry;
     extendConversionMap(conversionMap: any, links: any, apiResponse: any): void;
-    fetchTitle(itemType: string, itemId: number, deferRequest?: boolean): PromiseLike<any>;
-    requestItem(itemType: string, itemId: number | number[], columns: any): PromiseLike<ApiResponseProcessor>;
+    fetchTitle(itemType: string, itemId: number, deferRequest?: boolean): Promise<any>;
+    requestItem(itemType: string, itemId: number | number[], columns: any): Promise<ApiResponseProcessor>;
     updateItemId(itemEntry: any, itemId: any): ItemEntry;
     private setCreator(itemEntry);
 }

package/dist/definitions/src/classes/ItemRequestService.d.ts

@@ -2,13 +2,13 @@ import ColumnExpansionFactory from "../factories/ColumnExpansionFactory";
 import ColumnSetFactory from "../factories/ColumnSetFactory";
 import ApiRequestServiceInterface from '../interfaces/ApiRequestServiceInterface';
 import ErrorHandlerInterface from '../interfaces/ErrorHandlerInterface';
+import PromiseInterface from '../interfaces/PromiseInterface';
 import CollectionEntry from "../models/CollectionEntry";
 import ItemEntry from "../models/ItemEntry";
 import ColumnExpansion from "./ColumnExpansion";
 import ColumnHandler from "./ColumnHandler";
 import ItemEntryService from "./ItemEntryService";
 import ItemHandler from "./ItemHandler";
-import PromiseService from "./PromiseService";
 import QueryService from "./QueryService";
 import ApiResponseProcessor from './ApiResponseProcessor';
 export default class ItemRequestService {
@@ -21,12 +21,12 @@ export default class ItemRequestService {
     private itemEntryService;
     private queryService;
     private promiseService;
-    constructor(apiRequestService: ApiRequestServiceInterface, errorHandler: ErrorHandlerInterface, itemHandler: ItemHandler, columnHandler: ColumnHandler, columnExpansionFactory: ColumnExpansionFactory, columnSetFactory: ColumnSetFactory, itemEntryService: ItemEntryService, queryService: QueryService, promiseService: PromiseService);
-    requestItem(itemType: any, itemId: any, columns: any): PromiseLike<ApiResponseProcessor>;
-    requestItems(collectionEntry: CollectionEntry, query?: any, columns?: any): PromiseLike<ApiResponseProcessor>;
-    requestLinkItems(parentType: any, parentIdArray: any, itemType: any, query: any, columns: any): PromiseLike<ApiResponseProcessor>;
+    constructor(apiRequestService: ApiRequestServiceInterface, errorHandler: ErrorHandlerInterface, itemHandler: ItemHandler, columnHandler: ColumnHandler, columnExpansionFactory: ColumnExpansionFactory, columnSetFactory: ColumnSetFactory, itemEntryService: ItemEntryService, queryService: QueryService, promiseService: PromiseInterface);
+    requestItem(itemType: any, itemId: any, columns: any): Promise<ApiResponseProcessor>;
+    requestItems(collectionEntry: CollectionEntry, query?: any, columns?: any): Promise<ApiResponseProcessor>;
+    requestLinkItems(parentType: any, parentIdArray: any, itemType: any, query: any, columns: any): Promise<ApiResponseProcessor>;
     processExpansion(requestColumns: any, response: any, itemType: string, itemEntries: ItemEntry[]): ColumnExpansion;
-    processResponse(response: any, idArray: any, parent: any, columnInfo: any, columnExpansion?: any): PromiseLike<ItemEntry[]>;
+    processResponse(response: any, idArray: any, parent: any, columnInfo: any, columnExpansion?: any): Promise<ItemEntry[]>;
     handleCachedItem(itemEntry: any, response: any, columnExpansion: ColumnExpansion): any;
-    processLinkResponse(response: any, parentType: any, parentIdArray: any, itemType: any, options: any): any;
+    processLinkResponse(response: any, parentType: any, parentIdArray: any, itemType: any, options: any): Promise<any>;
 }

package/dist/definitions/src/classes/{ResourceCache.d.ts → LocalCache.d.ts}

@@ -5,6 +5,7 @@ import ItemCacheFactory from "../factories/ItemCacheFactory";
 import ItemResourceFactory from "../factories/ItemResourceFactory";
 import ApiRequestServiceInterface from '../interfaces/ApiRequestServiceInterface';
 import ErrorHandlerInterface from '../interfaces/ErrorHandlerInterface';
+import PromiseInterface from '../interfaces/PromiseInterface';
 import CollectionEntry from "../models/CollectionEntry";
 import CollectionResource from "../models/CollectionResource";
 import ItemEntry from "../models/ItemEntry";
@@ -17,8 +18,7 @@ import ItemEntryService from './ItemEntryService';
 import ItemHandler from "./ItemHandler";
 import ItemResourceService from './ItemResourceService';
 import LockService from "./LockService";
-import PromiseService from "./PromiseService";
-export default class ResourceCache {
+export default class LocalCache {
     private apiRequestService;
     private errorHandler;
     private itemHandler;
@@ -44,9 +44,9 @@ export default class ResourceCache {
         onSaveWithoutClosing: {};
     };
     changesInterval: null | number;
-    _hasChanges: boolean;
+    hasChanges: boolean;
     rootItem: ItemEntry;
-    constructor(apiRequestService: ApiRequestServiceInterface, errorHandler: ErrorHandlerInterface, itemHandler: ItemHandler, collectionHandler: CollectionHandler, columnHandler: ColumnHandler, lockService: LockService, itemResourceFactory: ItemResourceFactory, collectionCacheFactory: CollectionCacheFactory, changesProcessorFactory: ChangesProcessorFactory, itemCacheFactory: ItemCacheFactory, collectionResourceFactory: CollectionResourceFactory, itemEntryService: ItemEntryService, itemResourceService: ItemResourceService, promiseService: PromiseService);
+    constructor(apiRequestService: ApiRequestServiceInterface, errorHandler: ErrorHandlerInterface, itemHandler: ItemHandler, collectionHandler: CollectionHandler, columnHandler: ColumnHandler, lockService: LockService, itemResourceFactory: ItemResourceFactory, collectionCacheFactory: CollectionCacheFactory, changesProcessorFactory: ChangesProcessorFactory, itemCacheFactory: ItemCacheFactory, collectionResourceFactory: CollectionResourceFactory, itemEntryService: ItemEntryService, itemResourceService: ItemResourceService, promiseService: PromiseInterface);
     addSingleItem(itemEntry: ItemEntry, options: any, isRoot: any): ItemResource;
     addCollection(collectionEntry: CollectionEntry, resourceOptions: any): CollectionResource;
     clearCollection(collectionResource: CollectionResource): void;
@@ -55,12 +55,12 @@ export default class ResourceCache {
     updateSingleItems(conversionMap: any): void;
     revertChanges(): any;
     resetCollection(collectionEntry: CollectionEntry): void;
-    hasChanges: boolean;
+    _hasChanges(): boolean;
     detectChanges(): boolean;
     collectionHasChanges(collectionEntry: CollectionEntry): boolean;
     isLockable(): boolean;
     save(closeTab: boolean, parameters: any, breakUpByParent: any, onAfterCreateCallback: any): any;
-    executeCallbacks(event: any, callbackParameter: any): any;
+    executeCallbacks(event: any, callbackParameter: any): Promise<any>;
     enableChangesWatcher(): void;
     /**
      * @deprecated
@@ -71,8 +71,5 @@ export default class ResourceCache {
      * @deprecated
      */
     disableWatcher(): void;
-    /**
-     * @deprecated
-     */
     registerCallback(event: string, key: string, callback: any): () => void;
 }

package/dist/definitions/src/classes/LockService.d.ts

@@ -1,8 +1,8 @@
 import ApiRequestServiceInterface from '../interfaces/ApiRequestServiceInterface';
 import ErrorHandlerInterface from '../interfaces/ErrorHandlerInterface';
+import PromiseInterface from '../interfaces/PromiseInterface';
 import ItemEntry from "../models/ItemEntry";
 import KeyService from "./KeyService";
-import PromiseService from "./PromiseService";
 export default class LockService {
     private apiRequestService;
     private errorHandler;
@@ -10,7 +10,7 @@ export default class LockService {
     private promiseService;
     lockItems: {};
     promises: {};
-    constructor(apiRequestService: ApiRequestServiceInterface, errorHandler: ErrorHandlerInterface, keyService: KeyService, promiseService: PromiseService);
+    constructor(apiRequestService: ApiRequestServiceInterface, errorHandler: ErrorHandlerInterface, keyService: KeyService, promiseService: PromiseInterface);
     getValue(itemEntry: ItemEntry, map: any): any;
     setValue(itemEntry: ItemEntry, value: any, map: any): any;
     getLocks(): {};

package/dist/definitions/src/classes/SocketMessageHandler.d.ts

@@ -3,11 +3,11 @@ import ColumnSetFactory from '../factories/ColumnSetFactory';
 import RequestColumnExpansionFactory from '../factories/RequestColumnExpansionFactory';
 import ApiRequestServiceInterface from '../interfaces/ApiRequestServiceInterface';
 import ErrorHandlerInterface from '../interfaces/ErrorHandlerInterface';
+import PromiseInterface from '../interfaces/PromiseInterface';
 import ApiFormatter from './ApiFormatter';
 import CollectionHandler from './CollectionHandler';
 import ItemEntryService from './ItemEntryService';
 import ItemHandler from './ItemHandler';
-import PromiseService from './PromiseService';
 export default class SocketMessageHandler {
     private promiseService;
     private apiRequestService;
@@ -19,18 +19,18 @@ export default class SocketMessageHandler {
     private requestColumnExpansionFactory;
     private apiFormatter;
     private errorHandler;
-    constructor(promiseService: PromiseService, apiRequestService: ApiRequestServiceInterface, itemHandler: ItemHandler, itemEntryService: ItemEntryService, collectionHandler: CollectionHandler, columnSetFactory: ColumnSetFactory, columnExpansionFactory: ColumnExpansionFactory, requestColumnExpansionFactory: RequestColumnExpansionFactory, apiFormatter: ApiFormatter, errorHandler: ErrorHandlerInterface);
-    onMessageReceived(message: any): void;
+    constructor(promiseService: PromiseInterface, apiRequestService: ApiRequestServiceInterface, itemHandler: ItemHandler, itemEntryService: ItemEntryService, collectionHandler: CollectionHandler, columnSetFactory: ColumnSetFactory, columnExpansionFactory: ColumnExpansionFactory, requestColumnExpansionFactory: RequestColumnExpansionFactory, apiFormatter: ApiFormatter, errorHandler: ErrorHandlerInterface);
+    onMessageReceived(message: any): any;
     formatMessageValues(values: any, columns: any): {};
     createCollectionMap(itemType: any, items: any, columns: any): {};
     groupByCollectionId(itemType: any, collectionMap: any): {};
     getRequestColumns(itemType: any, collectionMap: any): {};
     deferEntry(itemEntry: any): any;
-    processMessage(body: any): any;
-    processFunctionChangesResolve(body: any): any;
+    processMessage(body: any): Promise<any>;
+    processFunctionChangesResolve(body: any): Promise<any>;
     handleResponse(itemType: any, requestIds: any, requestColumns: any, response: any, collectionMap: any): {};
-    handleCreate(message: any): any;
-    handleUpdate(message: any): any;
-    handleDelete(message: any): void;
-    handleLinkMove(message: any): void;
+    handleCreate(message: any): Promise<any>;
+    handleUpdate(message: any): Promise<any>;
+    handleDelete(message: any): Promise<any>;
+    handleLinkMove(message: any): Promise<any>;
 }

package/dist/definitions/src/factories/BatchStatusFactory.d.ts

@@ -1,8 +1,8 @@
 import BatchStatus from "../classes/BatchStatus";
-import PromiseService from '../classes/PromiseService';
+import PromiseInterface from '../interfaces/PromiseInterface';
 import ItemEntry from "../models/ItemEntry";
 export default class BatchStatusFactory {
     private promiseService;
-    constructor(promiseService: PromiseService);
+    constructor(promiseService: PromiseInterface);
     construct(getItemId: (itemEntry: ItemEntry) => number, getPromise: (itemEntry: ItemEntry) => Promise<any>): BatchStatus;
 }

package/dist/definitions/src/factories/ChangesProcessorFactory.d.ts

@@ -5,9 +5,9 @@ import CollectionHandler from "../classes/CollectionHandler";
 import ColumnHandler from "../classes/ColumnHandler";
 import ItemEntryService from '../classes/ItemEntryService';
 import ItemHandler from "../classes/ItemHandler";
-import PromiseService from '../classes/PromiseService';
 import ApiRequestServiceInterface from '../interfaces/ApiRequestServiceInterface';
 import ErrorHandlerInterface from '../interfaces/ErrorHandlerInterface';
+import PromiseInterface from '../interfaces/PromiseInterface';
 import ChangesCompilerFactory from "./ChangesCompilerFactory";
 import ColumnExpansionFactory from "./ColumnExpansionFactory";
 import CreateRequestFactory from "./CreateRequestFactory";
@@ -26,6 +26,6 @@ export default class ChangesProcessorFactory {
     private itemEntryService;
     private apiFormatter;
     private promiseService;
-    constructor(apiRequestService: ApiRequestServiceInterface, errorHandler: ErrorHandlerInterface, itemHandler: ItemHandler, collectionHandler: CollectionHandler, columnHandler: ColumnHandler, changesCompilerFactory: ChangesCompilerFactory, createRequestFactory: CreateRequestFactory, columnExpansionFactory: ColumnExpansionFactory, requestColumnExpansionFactory: RequestColumnExpansionFactory, collectionEntryService: CollectionEntryService, itemEntryService: ItemEntryService, apiFormatter: ApiFormatter, promiseService: PromiseService);
+    constructor(apiRequestService: ApiRequestServiceInterface, errorHandler: ErrorHandlerInterface, itemHandler: ItemHandler, collectionHandler: CollectionHandler, columnHandler: ColumnHandler, changesCompilerFactory: ChangesCompilerFactory, createRequestFactory: CreateRequestFactory, columnExpansionFactory: ColumnExpansionFactory, requestColumnExpansionFactory: RequestColumnExpansionFactory, collectionEntryService: CollectionEntryService, itemEntryService: ItemEntryService, apiFormatter: ApiFormatter, promiseService: PromiseInterface);
     construct(): ChangesProcessor;
 }