@rentman/rm-core 1.2.9 → 1.3.1

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

@@ -0,0 +1,15 @@
+import { PromiseInterface } from '../types';
+export interface PromiseLibraryInterface {
+    all(iterable: Array<PromiseInterface<any> | any>): PromiseInterface<any[]>;
+    all(iterable: {
+        [key: string]: PromiseInterface<any> | any;
+    }): PromiseInterface<{
+        [key: string]: any;
+    }>;
+    when<T>(value?: PromiseInterface<T> | T): PromiseInterface<T>;
+    reject(value?: any): PromiseInterface<any>;
+    defer(): {
+        (value?): any;
+        (value?): any;
+    };
+}

package/dist/{dist → src}/interfaces/index.d.ts

@@ -1,4 +1,4 @@
-export * from './PromiseInterface';
+export * from './PromiseLibraryInterface';
 export * from './LocalCacheManagerInterface';
 export * from './ErrorHandlerInterface';
 export * from './AuthInterface';

package/dist/{dist → src}/models/CollectionEditResource.d.ts

@@ -1,15 +1,15 @@
 import { LocalCache } from '../classes';
 import { CollectionResourceFactory } from '../factories';
 import { CollectionEntry, CollectionResource, ItemResource } from '../models';
-import { FieldMap, ItemId, ItemIdConversionMap } from '../types';
+import { FieldMap, ItemId, ItemIdConversionMap, PromiseInterface } from '../types';
 export declare class CollectionEditResource extends CollectionResource {
     private factory;
     constructor(factory: CollectionResourceFactory, collectionEntry: CollectionEntry, options: any, localCache: LocalCache);
-    save(): Promise<ItemIdConversionMap>;
+    save(): PromiseInterface<ItemIdConversionMap>;
     moveItems(idArray: ItemId[], destination: CollectionResource, enableCallbacks?: boolean): ItemResource[];
-    removeItems(idArray: ItemId[], callOnRemove?: boolean): Promise<ItemResource[]>;
-    removeItem(itemId: ItemId, callOnRemove?: boolean): Promise<ItemResource>;
-    addItems(valuesArray: FieldMap[], callOnAdd?: boolean, callOnActivate?: boolean): Promise<ItemResource[]>;
-    addItem(values: FieldMap, callOnAdd?: boolean, callOnActivate?: boolean): Promise<ItemResource>;
+    removeItems(idArray: ItemId[], callOnRemove?: boolean): PromiseInterface<ItemResource[]>;
+    removeItem(itemId: ItemId, callOnRemove?: boolean): PromiseInterface<ItemResource>;
+    addItems(valuesArray: FieldMap[], callOnAdd?: boolean, callOnActivate?: boolean): PromiseInterface<ItemResource[]>;
+    addItem(values: FieldMap, callOnAdd?: boolean, callOnActivate?: boolean): PromiseInterface<ItemResource>;
     clear(enableCallbacks: any): ItemResource[] | null;
 }

package/dist/{dist → src}/models/CollectionEntry.d.ts

@@ -1,7 +1,7 @@
 import { ColumnExpansion, ColumnInfo, ColumnSet, ItemCache } from '../classes';
 import { CollectionEntryFactory } from '../factories';
 import { CollectionResource, ItemEntry, ItemResource } from '../models';
-import { EntryParentNull, FieldMap, ItemId, ItemIdConversionMap, ItemType, RequestColumns } from '../types';
+import { EntryParentNull, FieldMap, ItemId, ItemIdConversionMap, ItemType, PromiseInterface, RequestColumns } from '../types';
 export declare class CollectionEntry {
     private factory;
     itemType: ItemType;
@@ -15,7 +15,7 @@ export declare class CollectionEntry {
     items: ItemEntry[];
     resources: CollectionResource[];
     deferred: any;
-    promise: Promise<CollectionEntry>;
+    promise: PromiseInterface<CollectionEntry>;
     reloadQueued: boolean;
     hasEditResources: boolean;
     hasItemEditResources: boolean;
@@ -32,17 +32,17 @@ export declare class CollectionEntry {
     forEach(callback: (itemEntry: ItemEntry) => void): void;
     getItemById(itemId: any): ItemEntry | undefined;
     getIdArray(accumulator?: ItemId[]): ItemId[];
-    createItems(valuesArray: FieldMap[]): Promise<ItemEntry[]>;
-    resolveDerivedValues(itemEntries: ItemEntry[], localItemCache: ItemCache): Promise<ItemEntry[]>;
+    createItems(valuesArray: FieldMap[]): PromiseInterface<ItemEntry[]>;
+    resolveDerivedValues(itemEntries: ItemEntry[], localItemCache: ItemCache): PromiseInterface<ItemEntry[]>;
     addItems(itemEntries: ItemEntry[], resultResource?: CollectionResource | null, updateInitial?: boolean, callOnAdd?: boolean, callOnActivate?: boolean): ItemResource[] | null;
     private handleAddedItemCallbacks(entriesAddedToInitial, entriesAddedToModified, resultResource?, callOnAdd?, callOnActivate?);
     removeItems(idArray: ItemId[], resultResource?: CollectionResource | null, updateInitial?: boolean, callOnRemove?: boolean): ItemResource[] | null;
     clear(resultResource?: CollectionResource | null, updateInitial?: boolean, callOnRemove?: boolean): ItemResource[] | null;
     handleRemovedItems(filterFunction: (itemEntry: ItemEntry) => boolean, resultResource?: CollectionResource | null, updateInitial?: boolean, callOnRemove?: boolean): ItemResource[] | null;
     private handleRemovedItemCallbacks(removedFromInitial, removedFromModified, resultResource?, callOnRemove?);
-    expand(newColumns: RequestColumns): Promise<this>;
+    expand(newColumns: RequestColumns): PromiseInterface<this>;
     extendQuery(callback: any): any;
-    extend(queryCallback: any, collectionResource: any, callOnAdd?: any, updateInitial?: any): Promise<any>;
+    extend(queryCallback: any, collectionResource: any, callOnAdd?: any, updateInitial?: any): PromiseInterface<ItemResource[] | null>;
     queueReload(): void;
     expandColumns(columnExpansion: ColumnExpansion): void;
     expandRequestColumns(requestColumns: RequestColumns): void;

package/dist/{dist → src}/models/CollectionResource.d.ts

@@ -1,7 +1,7 @@
 import { LocalCache } from '../classes';
 import { ItemResourceFactory } from '../factories';
 import { ItemEntry, ItemResource } from '../models';
-import { ItemResourceItemIdMap } from '../types';
+import { ItemResourceItemIdMap, PromiseInterface } from '../types';
 import { CollectionEntry } from './CollectionEntry';
 export declare class CollectionResource {
     private itemResourceFactory;
@@ -34,7 +34,7 @@ export declare class CollectionResource {
     };
     map<T>(argument: string | ((itemResource: ItemResource) => T)): T[];
     reduce<T>(callback: (itemResource: ItemResource, value: T) => T, value: T): T;
-    extend(queryCallback: any, returnAllItems?: boolean, callOnAdd?: boolean): Promise<ItemResource[]>;
+    extend(queryCallback: any, returnAllItems?: boolean, callOnAdd?: boolean): PromiseInterface<ItemResource[] | null>;
     deactivate(): void;
     clearResource(): void;
 }

package/dist/{dist → src}/models/EditResource.d.ts

@@ -1,5 +1,5 @@
 import { ItemResourceFactory } from '../factories';
-import { FieldMap } from '../types';
+import { FieldMap, PromiseInterface } from '../types';
 import { ItemEntry, ItemResource } from './';
 export declare class EditResource extends ItemResource {
     private factory;
@@ -14,5 +14,5 @@ export declare class EditResource extends ItemResource {
     copyFields(destination?: FieldMap): FieldMap;
     setFields(values: FieldMap, callOnChange?: boolean): this;
     callOnChange(previous: FieldMap): this;
-    save(parameters?: any): Promise<this>;
+    save(parameters?: any): PromiseInterface<this>;
 }

package/dist/{dist → src}/types/ItemTypesCollection.d.ts

@@ -74,6 +74,14 @@ export declare type CollectionMatchResult = {
     notfitting: CollectionEntry[];
     maybe: CollectionEntry[];
 };
+export interface ExtendedCollectionMatchResult extends CollectionMatchResult {
+    collection: CollectionResource;
+}
+export interface GroupedExtendedCollectionMatchResult {
+    [collectionId: number]: {
+        [status: string]: ExtendedCollectionMatchResult;
+    };
+}
 export declare type RequestColumn = string | object;
 export declare type RequestColumns = RequestColumn[] | true;
 export declare type ResponseColumn = any;
@@ -88,6 +96,10 @@ export declare type ColumnExpansionResult = {
     difference: ColumnSet;
 };
 export declare type ApiResponse = ApiResponseProcessor;
+export declare type TemplateItemResourceMap = {
+    main: ItemResource;
+    linked: ItemResourceItemTypeMap;
+};
 export declare type TemplateItemEntryMap = {
     main: ItemEntry;
     linked: TemplateLinkedItemEntryMap[];

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

@@ -0,0 +1,2 @@
+export interface PromiseInterface<T> extends Promise<T> {
+}

package/dist/{dist → src}/types/index.d.ts

@@ -1 +1,2 @@
 export * from './ItemTypesCollection';
+export * from './PromiseInterface';

package/package.json

@@ -1,9 +1,9 @@
 {
   "name": "@rentman/rm-core",
-  "version": "1.2.9",
+  "version": "1.3.1",
   "description": "Rentman core functionalities",
   "main": "./dist/rm-core.js",
-  "types": "./dist/dist/index.d.ts",
+  "types": "./dist/index.d.ts",
   "dependencies": {},
   "repository": {
     "type": "git",

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

@@ -1,9 +0,0 @@
-import { BatchStatus } from '../classes';
-import { PromiseInterface } from '../interfaces';
-import { ItemEntry } from '../models';
-import { ItemId } from '../types';
-export declare class BatchStatusFactory {
-    private promiseService;
-    constructor(promiseService: PromiseInterface);
-    construct(getItemId: (itemEntry: ItemEntry) => ItemId, getPromise: (itemEntry: ItemEntry) => Promise<ItemEntry>): BatchStatus;
-}

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

@@ -1,11 +0,0 @@
-import { ItemId, ItemType } from '../types';
-export interface ApiRequestServiceInterface {
-    template(itemType: string, params: any): Promise<any>;
-    create(itemType: ItemType, itemId: ItemId, values: any, parentType?: ItemType, parentId?: ItemId): Promise<any>;
-    delete(itemType: ItemType, itemIds: ItemId[]): Promise<any>;
-    updateItems(itemType: ItemType, items: object, columns: any): Promise<any>;
-    requestSkeleton(params: any, requestCanceler?: Promise<any>): Promise<any>;
-    moveItems(parentType: ItemType, parentId: ItemId, items: object): Promise<any>;
-    columns(itemType: ItemType, columns: object, params?: any): Promise<any>;
-    query(itemType: ItemType, query: object, columns: object, limit?: object): Promise<any>;
-}

package/dist/dist/interfaces/ErrorHandlerInterface.d.ts

@@ -1,4 +0,0 @@
-export interface ErrorHandlerInterface {
-    reject(error?: object): Promise<any>;
-    notifyError(error?: any): Promise<any>;
-}

package/dist/dist/interfaces/PromiseInterface.d.ts

@@ -1,14 +0,0 @@
-export interface PromiseInterface {
-    all(iterable: Array<Promise<any> | any>): Promise<any[]>;
-    all(iterable: {
-        [key: string]: Promise<any> | any;
-    }): Promise<{
-        [key: string]: any;
-    }>;
-    when<T>(value?: T): Promise<T>;
-    reject(value?: any): Promise<any>;
-    defer(): {
-        (value?): any;
-        (value?): any;
-    };
-}