@rentman/rm-core 1.0.21 → 1.0.23

package/dist/definitions/src/factories/{ResourceCacheFactory.d.ts → LocalCacheFactory.d.ts}

@@ -5,7 +5,7 @@ import ItemHandler from "../classes/ItemHandler";
 import ItemResourceService from '../classes/ItemResourceService';
 import LockService from "../classes/LockService";
 import PromiseService from '../classes/PromiseService';
-import ResourceCache from "../classes/ResourceCache";
+import LocalCache from "../classes/LocalCache";
 import ApiRequestServiceInterface from '../interfaces/ApiRequestServiceInterface';
 import ErrorHandlerInterface from '../interfaces/ErrorHandlerInterface';
 import ChangesProcessorFactory from "./ChangesProcessorFactory";
@@ -13,7 +13,7 @@ import CollectionCacheFactory from "./CollectionCacheFactory";
 import CollectionResourceFactory from "./CollectionResourceFactory";
 import ItemCacheFactory from "./ItemCacheFactory";
 import ItemResourceFactory from "./ItemResourceFactory";
-export default class ResourceCacheFactory {
+export default class LocalCacheFactory {
     private apiRequestService;
     private errorHandler;
     private itemHandler;
@@ -29,5 +29,5 @@ export default class ResourceCacheFactory {
     private itemResourceService;
     private 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: PromiseService);
-    construct(): ResourceCache;
+    construct(): LocalCache;
 }

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

@@ -33,11 +33,11 @@ import ModuleChangesCompilerFactory from "./factories/ModuleChangesCompilerFacto
 import QueryMatcherFactory from "./factories/QueryMatcherFactory";
 import QueryParserFactory from "./factories/QueryParserFactory";
 import RequestColumnExpansionFactory from "./factories/RequestColumnExpansionFactory";
-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';
 export default class RmCore {
     version: string;
     promiseService: PromiseService;
@@ -70,14 +70,13 @@ export default class RmCore {
     columnSetFactory: ColumnSetFactory;
     createRequestFactory: CreateRequestFactory;
     itemResourceFactory: ItemResourceFactory;
-    resourceCacheFactory: ResourceCacheFactory;
+    localCacheFactory: LocalCacheFactory;
     moduleChangesCompilerFactory: ModuleChangesCompilerFactory;
     queryParserFactory: QueryParserFactory;
     batchStatusFactory: BatchStatusFactory;
     socketMessageHandler: SocketMessageHandler;
     apiRequestService: ApiRequestService;
-    destroy: () => void;
-    constructor(externalApiRequestService: ApiRequestServiceInterface, resourceCacheInterface: ResourceCacheInterface, authInterface: AuthInterface, errorHandlerInterface: ErrorHandlerInterface);
+    constructor(externalApiRequestService: ApiRequestServiceInterface, localCacheManager: LocalCacheManagerInterface, authInterface: AuthInterface, errorHandlerInterface: ErrorHandlerInterface);
 }
 export declare function noop(): void;
 export declare function identity(value: any): any;

package/dist/definitions/src/interfaces/ApiRequestServiceInterface.d.ts

@@ -1,10 +1,10 @@
 export default interface ApiRequestServiceInterface {
-    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>;
+    template(itemType: string, params: any): PromiseLike<any>;
+    create(itemType: string, itemId: number, values: any, parentType?: string, parentId?: number): PromiseLike<any>;
+    delete(itemType: string, itemIds: number[]): PromiseLike<any>;
+    updateItems(itemType: string, items: object, columns: any): PromiseLike<any>;
+    requestSkeleton(params: any, requestCanceler?: PromiseLike<any>): PromiseLike<any>;
+    moveItems(parentType: string, parentId: number, items: object): PromiseLike<any>;
+    columns(itemType: string, columns: object, params?: any): PromiseLike<any>;
+    query(itemType: string, query: object, columns: object, allLinks?: boolean, limit?: object): PromiseLike<any>;
 }

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

@@ -0,0 +1,6 @@
+import LocalCache from '../classes/LocalCache';
+export default interface LocalCacheManagerInterface {
+    updateTabParams(conversionMap: any, keepTabHeading: boolean): Promise<any>;
+    getCacheManager(userId: string): LocalCache;
+    setCacheManager(userId: string, entry: LocalCache): any;
+}

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

@@ -7,6 +7,7 @@ import QueryService from "../classes/QueryService";
 import ErrorHandlerInterface from '../interfaces/ErrorHandlerInterface';
 import CollectionResource from "./CollectionResource";
 import ItemEntry from "./ItemEntry";
+import ItemResource from './ItemResource';
 export default class CollectionEntry {
     private errorHandler;
     private collectionEntryService;
@@ -32,19 +33,19 @@ export default class CollectionEntry {
     reloadQueued: boolean;
     constructor(errorHandler: ErrorHandlerInterface, collectionEntryService: CollectionEntryService, itemRequestService: ItemRequestService, itemEntryService: ItemEntryService, keyService: KeyService, queryService: QueryService, promiseService: PromiseService, itemType: string, options: any);
     isDeferred(): boolean;
-    resolve(itemEntryResource: any): this;
+    resolve(itemEntryResource: any): CollectionEntry;
     isLocal(): boolean;
     matchParent(itemType: any, itemId: any): boolean;
-    forEach(callback: any): void;
+    forEach(callback: (itemEntry: ItemEntry) => void): void;
     getItemById(itemId: any): ItemEntry;
-    getIdArray(accumulator?: any[]): any;
-    addItems(itemEntries: any, resultResource: any, updateInitial?: boolean, enableCallback?: boolean): any;
+    getIdArray(accumulator?: any[]): number[];
+    addItems(itemEntries: any, resultResource: any, updateInitial?: boolean, enableCallback?: boolean): ItemResource[];
     removeItems(idArray: any, resultResource: any, updateInitial: any, enableCallback?: any): any;
     clear(resultResource: any, updateInitial: any, enableCallback?: any): any;
-    handleRemovedItems(filterFunction: any, resultResource: any, updateInitial: any, enableCallback: any): any;
+    handleRemovedItems(filterFunction: any, resultResource: any, updateInitial: any, enableCallback?: boolean): any;
     expand(newColumns: any): any;
     extendQuery(callback: any): any;
-    extend(queryCallback: any, collectionResource: any, enableCallback?: any, updateInitial?: any): Promise<any>;
+    extend(queryCallback: any, collectionResource: any, enableCallback?: any, updateInitial?: any): PromiseLike<any>;
     queueReload(): void;
     updateColumns(columnExpansion: any): void;
     getAddedItems(returnItemIds?: boolean): any[];

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

@@ -2,28 +2,36 @@ import ItemResourceFactory from "../factories/ItemResourceFactory";
 import CollectionEntry from './CollectionEntry';
 import ItemEntry from "./ItemEntry";
 import ItemResource from "./ItemResource";
+import { ItemResourceItemIdMap } from '../types/ItemTypesCollection';
 export default class CollectionResource {
     private itemResourceFactory;
     entry: CollectionEntry;
     options: any;
-    columns: any;
     items: ItemResource[];
-    itemIdMap: {};
+    itemIdMap: ItemResourceItemIdMap;
+    columns: any;
     constructor(itemResourceFactory: ItemResourceFactory, entry: CollectionEntry, options: any);
-    getItemById(itemId: any): any;
+    getItemById(itemId: number): ItemResource;
     rebuildMap(): void;
-    addItemResources(itemEntries: ItemEntry[]): any[];
-    removeItemResources(itemEntries: any): any[];
+    addItemResources(itemEntries: ItemEntry[]): ItemResource[];
+    /**
+     * @param itemEntries
+     * @returns {ItemResource[]}
+     *
+     * Returns the Itemresources that where removed Collection.
+     * Filters on ItemResource.entry === ItemEntry
+     */
+    removeItemResources(itemEntries: ItemEntry[]): ItemResource[];
     callOnAdd(itemResources: ItemResource[]): void;
     callOnRemove(itemResources: ItemResource[]): void;
-    forEach(callback: any): void;
-    filter(callback: any): any[];
-    first(callback: any): ItemResource;
-    some(callback: any): boolean;
+    forEach(callback: (itemResource: ItemResource) => void): void;
+    filter(callback: (itemResource: ItemResource) => boolean): any[];
+    first(callback: (itemResource: ItemResource) => boolean): ItemResource;
+    some(callback: (itemResource: ItemResource) => boolean): boolean;
     groupBy(argument: any): {};
     map(argument: any): any[];
-    reduce(callback: any, value: any): any;
-    extend(queryCallback: any, returnAllItems: any, enableCallbacks: any): Promise<any>;
+    reduce<T>(callback: (itemResource: ItemResource, value: T) => T, value: T): T;
+    extend(queryCallback: any, returnAllItems: any, enableCallbacks: any): PromiseLike<ItemResource[]>;
     deactivate(): void;
     clearResource(): void;
 }

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

@@ -14,7 +14,6 @@ export declare class EditResource extends ItemResource {
     private collectionHandler;
     private errorHandler;
     private promiseService;
-    fields: any;
     localCopies: any[];
     transactions: number;
     hasChanges: boolean;

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

@@ -2,6 +2,5 @@ import ItemEntryService from '../classes/ItemEntryService';
 import ItemEntry from "./ItemEntry";
 import ItemResource from "./ItemResource";
 export declare class ViewResource extends ItemResource {
-    fields: any;
     constructor(itemEntryService: ItemEntryService, entry: ItemEntry, options: any);
 }

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

@@ -0,0 +1,52 @@
+import ItemResource from '../models/ItemResource';
+import CollectionResource from '../models/CollectionResource';
+import ItemEntry from '../models/ItemEntry';
+import CollectionEntry from '../models/CollectionEntry';
+import { ENTRY_STATUS } from '../constants';
+export declare type ItemResourceItemIdMap = {
+    [itemId: number]: ItemResource;
+};
+export declare type ItemResourceItemTypeMap = {
+    [itemType: string]: ItemResource;
+};
+export declare type ItemEntryEntryStatusMap = {
+    [entryStatus: string]: ItemEntry[];
+};
+export declare type CollectionEntryBatchStatusMap = {
+    [status: string]: CollectionEntryParentIdMap;
+};
+export declare type CollectionEntryParentIdMap = {
+    [parentId: number]: CollectionEntry;
+};
+export declare type CollectionEntryItemTypeMap = {
+    [itemType: string]: CollectionEntry[];
+};
+export declare type CollectionResourceParentIdMap = {
+    [parentId: number]: CollectionResource;
+};
+export interface ApiTemplate {
+    fields: any;
+    columns: any;
+    response: any;
+    responseColumns: any;
+}
+export declare type TemplateResponseItemEntryMap = {
+    main: ItemEntry;
+    linked: TemplateResponseLinkedItemEntryMap[];
+};
+export declare type TemplateResponseLinkedItemEntryMap = {
+    itemType: string;
+    itemEntries: {
+        [itemType: string]: ItemEntry[];
+    };
+};
+export declare type ApiTemplateItemTypeMap = {
+    [itemType: string]: ApiTemplate;
+};
+export declare type ItemTypeMap = {
+    [itemType: string]: any;
+};
+export declare type EntryStatus<T> = {
+    entry: T;
+    status: ENTRY_STATUS;
+};