@rentman/rm-core 1.0.21 → 1.0.23

package/changelog.md

@@ -0,0 +1,20 @@
+#Changelog
+Contains new features, breaking changes and their reasoning
+
+##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

@@ -1,16 +1,17 @@
 import ApiResponseProcessorFactory from '../factories/ApiResponseProcessorFactory';
 import ApiRequestServiceInterface from '../interfaces/ApiRequestServiceInterface';
+import ApiResponseProcessor from './ApiResponseProcessor';
 export default class ApiRequestService {
     private externalApiRequestService;
     private apiResponseProcessorFactory;
     constructor(externalApiRequestService: ApiRequestServiceInterface, apiResponseProcessorFactory: ApiResponseProcessorFactory);
-    template(itemType: string, params: any): Promise<any>;
-    create(itemType: string, itemId: number, values: any, parentType?: string, parentId?: number): Promise<any>;
-    delete(itemType: string, itemIds: number[]): Promise<any>;
-    updateItems(itemType: string, items: object, columns: any): Promise<any>;
-    requestSkeleton(params: any, requestCanceler?: Promise<any>): Promise<any>;
-    moveItems(parentType: string, parentId: number, items: object): Promise<any>;
-    columns(itemType: string, columns: object, params?: any): Promise<any>;
-    query(itemType: string, query: object, columns: object, allLinks?: boolean, limit?: object): Promise<any>;
-    processResponse(request: any): any;
+    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>;
 }

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

@@ -1,10 +1,11 @@
 import ApiFormatter from './ApiFormatter';
+import { ItemTypeMap } from '../types/ItemTypesCollection';
 export default class ApiResponseProcessor {
     apiFormatter: ApiFormatter;
     response: any;
-    columns: any[];
-    items: any[];
-    links: any[];
+    columns: ItemTypeMap;
+    items: ItemTypeMap;
+    links: ItemTypeMap;
     cacheable: boolean;
     map: any;
     columnIndexMap: any;

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

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

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

@@ -1,26 +1,28 @@
 import QueryMatcherFactory from "../factories/QueryMatcherFactory";
 import CollectionEntry from "../models/CollectionEntry";
+import CollectionResource from '../models/CollectionResource';
+import { CollectionEntryItemTypeMap } from '../types/ItemTypesCollection';
 export default class CollectionCache {
     private queryMatcherFactory;
-    entries: {};
+    entries: CollectionEntryItemTypeMap;
     constructor(queryMatcherFactory: QueryMatcherFactory);
-    contains(collectionEntry: any): boolean;
-    some(callback: any): boolean;
-    forEach(callback: any): void;
-    toArray(): any[];
+    contains(collectionEntry: CollectionEntry): boolean;
+    some(callback: (entry: CollectionEntry) => void): boolean;
+    forEach(callback: (entry: CollectionEntry) => void): void;
+    toArray(): CollectionEntry[];
     add(collectionEntry: CollectionEntry): CollectionEntry;
     clear(collectionEntry?: CollectionEntry): boolean;
-    getByItemType(itemType: any): any;
-    getByParent(parentType: any, parentId: any, itemType: any): any;
-    getResourceByParent(parentType: any, parentId: any, itemType: any): any;
-    getCollectionsByParent(parentType: any, parentId: any): any[];
+    getByItemType(itemType: string): CollectionEntry[];
+    getByParent(parentType: any, parentId: any, itemType: any): CollectionEntry | null;
+    getResourceByParent(parentType: any, parentId: any, itemType: any): CollectionResource;
+    getCollectionsByParent(parentType: any, parentId: any): CollectionEntry[];
     /**
      * Only resources
      * @param {String} itemType
      * @param {String|Integer} itemId
      * @returns {Object} Array of collections.
      */
-    getByContainingItem(itemType: any, itemId: any): any[];
+    getByContainingItem(itemType: any, itemId: any): CollectionEntry[];
     /**
      * Returns an array of collections the item 'belongs' in.
      * @param {String} parentType
@@ -33,7 +35,7 @@ export default class CollectionCache {
         notfitting: any[];
         maybe: any[];
     };
-    getByQuery(itemType: any, query: any): any;
-    getByKey(itemType: any, entryKey: any): any[];
+    getByQuery(itemType: any, query: any): CollectionEntry;
+    getByKey(itemType: any, entryKey: any): CollectionEntry[];
     getResourceByKey(itemType: any, resourceKey: any): any[];
 }

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

@@ -10,6 +10,14 @@ export default class CollectionEntryService {
         object: any;
         string: any;
     };
-    getIdArray(itemEntries: ItemEntry[], accumulator: any): any;
-    filterArray(itemEntries: ItemEntry[], callback: any): any[];
+    getIdArray(itemEntries: ItemEntry[], accumulator: any): number[];
+    /**
+     * @param {ItemEntry[]} itemEntries
+     * @param {(itemEntry: ItemEntry) => boolean} callback
+     * @returns {ItemEntry[]}
+     *
+     * filter an array according to the callback function. Return the entries that failed the condition
+     * Replace the given array with the entries that didn't fail the condition.
+     */
+    filterArray(itemEntries: ItemEntry[], callback: (itemEntry: ItemEntry) => boolean): ItemEntry[];
 }

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

@@ -18,6 +18,7 @@ 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 {
     private errorHandler;
     private itemRequestService;
@@ -35,37 +36,28 @@ export default class CollectionHandler {
     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);
-    getPromises(statusResource: any): any[];
+    getPromises(statusResource: CollectionEntryBatchStatusMap): any[];
     getRequestIds(statusResource: any): any[];
     removeFromAndAddToCollections(collectionMap: any, updateInitial?: any): void;
     removeFromCollections(collectionMap: any, updateInitial?: any, resultResource?: CollectionResource | null): any;
     /**
      * @deprecated
      */
-    addItemsToCollections(itemEntries: ItemEntry[]): any;
-    addToCollections(collectionMap: any, updateInitial: boolean, resultResource?: ItemResource | null): any;
-    batchExpand(parentType: string, itemType: string, collections: CollectionResource[], newColumns: any): any;
-    batchExtend(parentType: string, itemType: string, options: any, queryCallback: any, collections: CollectionResource[], returnAllItems?: boolean): {};
-    batchFetch(parentType: string, parentIdArray: number[], itemType: string, options: any, deferredCollectionCache: CollectionCache): any;
+    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>;
     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): {};
+    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): any;
-    getDeferredEntryStatus(collectionEntry: CollectionEntry, options: any): {
-        entry: CollectionEntry;
-        status: string;
-    };
-    getEntryStatus(itemType: string, options: any, deferredEntries: CollectionCache): {
-        entry: any;
-        status: string;
-    };
-    getNewEntryStatus(itemType: string, query: any, options: any, deferredEntries: CollectionCache): {
-        entry: any;
-        status: string;
-    };
-    handleBatchResponse(statusResource: any, itemEntryResource: any): {};
+    fetch(itemType: string, options: any, itemCache: ItemCache, deferredCollectionCache: CollectionCache): PromiseLike<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>;
+    handleBatchResponse(statusResource: any, itemEntryResource: any): CollectionEntryParentIdMap;
     /**
      * @deprecated
      */
@@ -74,6 +66,6 @@ export default class CollectionHandler {
      * @deprecated
      */
     removeItemsFromCollections(itemEntries: ItemEntry[]): any;
-    resolveLocal(collectionEntry: CollectionEntry, itemCache: any): Promise<any>;
-    resolveRemote(collectionEntry: any, itemCache: any): Promise<any>;
+    resolveLocal(collectionEntry: CollectionEntry, itemCache: any): PromiseLike<CollectionEntry>;
+    resolveRemote(collectionEntry: any, itemCache: any): PromiseLike<CollectionEntry>;
 }

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

@@ -13,7 +13,7 @@ export default class ColumnHandler {
     setColumn(itemType: any, responseColumn: any): any;
     setColumns(itemType: any, requestColumns: any, responseColumns: any): {};
     fetchItemTypeTranslations(itemTypes: any): Promise<any>;
-    request(itemType: any, columns: any, params?: {}): Promise<any>;
-    fetch(itemType: any, requestColumns: any, params?: {}): Promise<any>;
-    fetchAll(itemType: any): Promise<any>;
+    request(itemType: any, columns: any, params?: {}): PromiseLike<any>;
+    fetch(itemType: any, requestColumns: any, params?: {}): PromiseLike<any>;
+    fetchAll(itemType: any): PromiseLike<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,35 +17,57 @@ 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;
         itemId: any;
     };
     createCollectionMap(itemEntries: any[], addToTab: boolean): {};
-    getItemById(itemType: string, itemId: number, options: any): any;
-    getItemsById(itemType: string, itemIds: number[], options: any): any;
-    getItemsByQuery(itemType: string, query: any, options: any): Promise<any>;
-    getDuplicateById(itemType: string, duplicateId: number, options: any): any;
-    getNewResource(itemType: string, options: any, returnLinks: boolean, isRoot: boolean): any;
+    /**
+     *
+     * @param {string} itemType
+     * @param {number} itemId
+     * @param options
+     * @returns {PromiseLike<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>;
+    /**
+     * 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
+     *
+     * @param {string} itemType
+     * @param options
+     * @param {boolean} returnLinks
+     * @param {boolean} isRoot
+     * @returns {PromiseLike<ItemResource> | PromiseLike<TemplateResponseItemEntryMap>}
+     */
+    getNewResource(itemType: string, options: any, returnLinks: boolean, isRoot: boolean): PromiseLike<ItemResource> | PromiseLike<TemplateResponseItemEntryMap>;
     getCollectionDef(itemType: string, options: any): {
         itemType: string;
         options: {
@@ -63,22 +85,16 @@ export default class ItemAdministrator {
             resource: any;
         };
     };
-    /** @deprecated */
-    getCollection(itemType: string, query: any, options: any): any;
-    _getCollection(itemType: string, options: any): any;
-    getCollectionFromDef(definition: any): any;
-    getLinkCollection(linkType: string, linkId: number, itemType: string, options: any): any;
-    getLinkCollections(linkType: string, linkIdArray: number[], itemType: string, options: any): any;
-    getLinkCollectionsFromDef(definition: any): any;
-    getAllLinkCollections(linkType: string, itemType: string, options: any): Promise<any>;
-    getItemByDef(definition: any, isRoot: boolean): 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>;
     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(): {
@@ -86,37 +102,20 @@ export default class ItemAdministrator {
         itemId: number;
         items: any;
     };
-    addSingleItem(itemEntry: any, options: any, isRoot?: boolean): ItemResource;
-    addSingleItems(itemEntries: any[], options: any): any[];
+    addSingleItem(itemEntry: ItemEntry, options: any, isRoot?: boolean): ItemResource;
+    addSingleItems(itemEntries: ItemEntry[], options: any): ItemResource[];
     addCollection(collectionEntry: any, resourceOptions: any, processOptions?: any): CollectionResource;
-    addCollections(collectionEntries: any[], resourceOptions: any): {};
-    processLinkedItems(linkedEntries: any[], options: any, addToCollections: boolean): {};
-    /**
-     * @deprecated
-     */
-    getTabEntry(): ResourceCache;
-    getResourceCache(): ResourceCache;
-    /**
-     * @deprecated
-     */
-    resetTabEntry(): void;
-    resetResourceCache(): void;
-    addToCollections(itemEntries: any[], resultCollectionResource: any): any;
+    addCollections(collectionEntries: CollectionEntryParentIdMap, resourceOptions: any): CollectionResourceParentIdMap;
+    processLinkedItems(linkedEntries: any[], options: any, addToCollections: boolean): ItemResourceItemTypeMap;
+    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): any[];
-    /**
-     * @deprecated
-     */
+    createItemResources(itemEntries: any[], options: any): ItemResource[];
     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,7 @@
 import ApiFormatter from './ApiFormatter';
 import KeyService from './KeyService';
 import PromiseService from "./PromiseService";
+import ItemEntry from '../models/ItemEntry';
 export default class ItemEntryService {
     private apiFormatter;
     private keyService;
@@ -9,9 +10,9 @@ export default class ItemEntryService {
     ALL_PERMISSIONS: number;
     constructor(apiFormatter: ApiFormatter, keyService: KeyService, promiseService: PromiseService);
     resetDerived(itemEntry: any, columnIds: any): void;
-    defer(itemEntry: any, deferRequest: any): any;
-    resolve(itemEntry: any): any;
-    reject(itemEntry: any, error?: string): any;
+    defer(itemEntry: ItemEntry, deferRequest: any): ItemEntry;
+    resolve(itemEntry: any): ItemEntry;
+    reject(itemEntry: any, error?: string): ItemEntry;
     clearResources(itemEntry: any): void;
     deactivateResources(itemEntry: any): void;
     getFields(itemEntry: any): any;

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

@@ -1,3 +1,4 @@
+import { ENTRY_STATUS } from "../constants";
 import BatchStatusFactory from "../factories/BatchStatusFactory";
 import ColumnExpansionFactory from "../factories/ColumnExpansionFactory";
 import ColumnSetFactory from "../factories/ColumnSetFactory";
@@ -14,6 +15,9 @@ 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';
 export default class ItemHandler {
     private apiRequestService;
     private authInterface;
@@ -30,41 +34,56 @@ export default class ItemHandler {
     private promiseService;
     private columnUtil;
     entries: ItemCache;
-    templates: {};
+    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);
     getItemId(itemEntry: ItemEntry): number;
     getPromise(itemEntry: ItemEntry): any;
-    fetchItem(itemType: string, itemId: number, options: any): any;
-    fetchItems(itemType: any, itemIds: any, options: any): any;
-    resolveCached(itemEntry: ItemEntry, status: any, options: any): any;
-    resolveLocal(itemEntry: ItemEntry, parent: any, template: any): {
-        main: ItemEntry;
-        linked: any[];
-    };
-    resolveExpansion(itemEntry: any, columnExpansion: any, response: any): any;
-    resolveRemote(itemEntry: any, columnInfo: any, response: any): any;
+    fetchItem(itemType: string, itemId: number, options: any): PromiseLike<ItemEntry | TemplateResponseItemEntryMap>;
+    /**
+     *
+     * @param itemType
+     * @param itemIds
+     * @param options
+     * @returns {PromiseLike<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>;
+    resolveLocal(itemEntry: ItemEntry, parent: any, template: any): TemplateResponseItemEntryMap;
+    resolveExpansion(itemEntry: any, columnExpansion: any, response: any): ItemEntry;
+    resolveRemote(itemEntry: any, columnInfo: any, response: any): ItemEntry;
     fetchTemplate(itemType: string, templateOptions?: any, templateColumns?: any): Promise<any>;
-    getEntryStatus(itemType: string, itemId: number, options: any): {
-        entry: any;
-        status: string;
-    };
-    getCachedEntryStatus(itemEntry: ItemEntry, options: any): string;
-    createDeferredEntry(itemType: string, itemId: number, requestColumns: any, deferRequest: any): any;
+    getEntryStatus(itemType: string, itemId: number, options: any): EntryStatus<ItemEntry>;
+    getCachedEntryStatus(itemEntry: ItemEntry, options: any): ENTRY_STATUS;
+    createDeferredEntry(itemType: string, itemId: number, requestColumns: any, deferRequest: any): ItemEntry;
     createEntryStub(itemType: string, itemId: number): ItemEntry;
-    createEntry(itemId: number, initial: any, derived: any, columnInfo: any): any;
-    resolveDeferredEntry(itemEntry: any, initial: any, derived: any, columns: any): any;
-    batchResolve(itemType: any, batchStatus: any, requestColumns: any, resolved: any): any;
+    createEntry(itemId: number, initial: any, derived: any, columnInfo: any): ItemEntry;
+    resolveDeferredEntry(itemEntry: any, initial: any, derived: any, columns: any): ItemEntry;
+    /**
+     *
+     * @param itemType
+     * @param {BatchStatus} batchStatus
+     * @param requestColumns
+     * @param resolved
+     * @returns {ItemEntry[]}
+     *
+     * 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>;
     cloneItem(newItemId: any, itemEntry: any, conversionMap?: any): any;
     createConversionMap(itemType: string, itemId: number, extend: boolean, response: any): {
         [x: string]: {
             [x: number]: number;
         };
     };
-    createLocalEntries(parentType: string, localParentId: number, template: any, conversionMap: any): any[];
+    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): any;
-    requestItem(itemType: string, itemId: number | number[], columns: any): Promise<any>;
+    fetchTitle(itemType: string, itemId: number, deferRequest?: boolean): PromiseLike<any>;
+    requestItem(itemType: string, itemId: number | number[], columns: any): PromiseLike<ApiResponseProcessor>;
     updateItemId(itemEntry: any, itemId: any): ItemEntry;
     private setCreator(itemEntry);
 }

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

@@ -10,6 +10,7 @@ import ItemEntryService from "./ItemEntryService";
 import ItemHandler from "./ItemHandler";
 import PromiseService from "./PromiseService";
 import QueryService from "./QueryService";
+import ApiResponseProcessor from './ApiResponseProcessor';
 export default class ItemRequestService {
     private apiRequestService;
     private errorHandler;
@@ -21,11 +22,11 @@ export default class ItemRequestService {
     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): Promise<any>;
-    requestItems(collectionEntry: CollectionEntry, query?: any, columns?: any): Promise<any>;
-    requestLinkItems(parentType: any, parentIdArray: any, itemType: any, query: any, columns: any): Promise<any>;
+    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>;
     processExpansion(requestColumns: any, response: any, itemType: string, itemEntries: ItemEntry[]): ColumnExpansion;
-    processResponse(response: any, idArray: any, parent: any, columnInfo: any, columnExpansion?: any): Promise<ItemEntry[]>;
+    processResponse(response: any, idArray: any, parent: any, columnInfo: any, columnExpansion?: any): PromiseLike<ItemEntry[]>;
     handleCachedItem(itemEntry: any, response: any, columnExpansion: ColumnExpansion): any;
     processLinkResponse(response: any, parentType: any, parentIdArray: any, itemType: any, options: any): any;
 }

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

@@ -1,8 +1,7 @@
-import ItemEntryService from "./ItemEntryService";
+import { EditResource } from '../models/EditResource';
 export default class ItemResourceService {
-    private itemEntryService;
-    constructor(itemEntryService: ItemEntryService);
+    constructor();
     processOptions(options: any): any;
     compareOptions(first: any, second: any): boolean;
-    isNew(resource: any): boolean;
+    isNewResource(resource: EditResource): boolean;
 }

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

@@ -18,7 +18,7 @@ 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,7 +44,7 @@ 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);
     addSingleItem(itemEntry: ItemEntry, options: any, isRoot: any): ItemResource;
@@ -53,9 +53,9 @@ export default class ResourceCache {
     clearItem(itemResource: ItemResource): void;
     clearResources(isSubTabChange?: boolean): void;
     updateSingleItems(conversionMap: any): void;
-    revertChanges(): void;
+    revertChanges(): any;
     resetCollection(collectionEntry: CollectionEntry): void;
-    hasChanges(): boolean;
+    _hasChanges(): boolean;
     detectChanges(): boolean;
     collectionHasChanges(collectionEntry: CollectionEntry): boolean;
     isLockable(): boolean;
@@ -71,8 +71,5 @@ export default class ResourceCache {
      * @deprecated
      */
     disableWatcher(): void;
-    /**
-     * @deprecated
-     */
     registerCallback(event: string, key: string, callback: any): () => void;
 }

package/dist/definitions/src/constants.d.ts

@@ -1,10 +1,10 @@
-export declare const ENTRY_STATUS: {
-    CACHED: string;
-    PROMISED: string;
-    EXPAND: string;
-    PROMISED_EXPAND: string;
-    RESOLVE: string;
-    LOCAL: string;
-};
+export declare enum ENTRY_STATUS {
+    CACHED = "cached",
+    PROMISED = "promised",
+    EXPAND = "expand",
+    PROMISED_EXPAND = "promised-expand",
+    RESOLVE = "resolve",
+    LOCAL = "local",
+}
 export declare const COLUMN_SEPERATOR = ">";
 export declare const RENDER_AS_SEPERATOR = ":";

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

@@ -1,3 +1,4 @@
+import CollectionResourceService from '../classes/CollectionResourceService';
 import ItemHandler from "../classes/ItemHandler";
 import KeyService from '../classes/KeyService';
 import PromiseService from '../classes/PromiseService';
@@ -13,6 +14,7 @@ export default class CollectionResourceFactory {
     private changesProcessorFactory;
     private keyService;
     private promiseService;
-    constructor(errorHandler: ErrorHandlerInterface, itemHandler: ItemHandler, itemResourceFactory: ItemResourceFactory, changesProcessorFactory: ChangesProcessorFactory, keyService: KeyService, promiseService: PromiseService);
+    private collectionResourceService;
+    constructor(errorHandler: ErrorHandlerInterface, itemHandler: ItemHandler, itemResourceFactory: ItemResourceFactory, changesProcessorFactory: ChangesProcessorFactory, keyService: KeyService, promiseService: PromiseService, collectionResourceService: CollectionResourceService);
     construct(collectionEntry: CollectionEntry, options: any): CollectionResource;
 }