@rentman/rm-core 1.1.15 → 1.1.17

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

@@ -1,11 +1,9 @@
-import { ApiResponseProcessor, BatchStatus, ColumnHandler, ColumnUtil, ItemCache, ItemEntryService, KeyService } from '../classes';
+import { ApiResponseProcessor, BatchStatus, ColumnExpansion, ColumnHandler, ColumnSet, ColumnUtil, ItemCache, ItemEntryService, KeyService } from '../classes';
 import { ENTRY_STATUS } from '../constants';
 import { BatchStatusFactory, ColumnExpansionFactory, ColumnSetFactory, ItemCacheFactory, ItemEntryFactory } from '../factories';
 import { ApiRequestServiceInterface, ErrorHandlerInterface, PromiseInterface } from '../interfaces';
 import { ItemEntry } from '../models';
-import { ApiResponse, ApiTemplateItemTypeMap, EntryStatus, ItemId, ItemIdConversionMap, ItemType, RequestColumns, TemplateResponseItemEntryMap, TemplateResponseLinkedItemEntryMap } from '../types';
-import { ColumnExpansion } from './ColumnExpansion';
-import { ColumnSet } from './ColumnSet';
+import { ApiResponse, ApiTemplateItemTypeMap, EntryStatus, FieldMap, ItemId, ItemIdConversionMap, ItemType, RequestColumns, TemplateResponseItemEntryMap, TemplateResponseLinkedItemEntryMap } from '../types';
 export declare class ItemHandler {
     private apiRequestService;
     private errorHandler;
@@ -38,6 +36,11 @@ export declare class ItemHandler {
     resolveLocal(itemEntry: ItemEntry, parent: any, template: any, localItemCache: ItemCache): TemplateResponseItemEntryMap;
     resolveExpansion(itemEntry: ItemEntry, columnExpansion: ColumnExpansion, response: ApiResponse): ItemEntry;
     resolveRemote(itemEntry: ItemEntry, columnSet: ColumnSet, response: ApiResponse): ItemEntry | null;
+    resolveRemoteValues(itemEntry: ItemEntry, response: ApiResponse): ItemEntry | null;
+    getResponseFields(itemEntry: ItemEntry, columnSet: any, response: ApiResponse): {
+        initial: FieldMap;
+        derived: FieldMap;
+    } | null;
     fetchTemplate(itemType: string, templateOptions?: any, templateColumns?: any): Promise<any>;
     getEntryStatus(itemType: ItemType, itemId: ItemId, options: any, localItemCache: ItemCache): EntryStatus<ItemEntry>;
     isColumnSuperset(itemEntry: ItemEntry, columns: RequestColumns): any;
@@ -53,8 +56,9 @@ export declare 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, localItemCache: ItemCache): ItemEntry[] | Promise<any>;
+    batchResolve(itemType: ItemType, batchStatus: BatchStatus, requestColumns: RequestColumns, resolved: any, localItemCache: ItemCache): ItemEntry[] | Promise<any>;
     createLocalEntries(parentType: ItemType, localParentId: ItemId, template: any, itemIdConversion: ItemIdConversionMap, localItemCache: ItemCache, excludeItemTypes?: ItemType[]): TemplateResponseLinkedItemEntryMap[];
     fetchTitle(itemType: ItemType, itemId: ItemId, deferRequest: boolean | undefined, localItemCache: ItemCache): Promise<any>;
-    requestItems(itemType: string, itemIds: ItemId[], columns: any): Promise<ApiResponseProcessor>;
+    requestItem(itemEntry: ItemEntry, requestColumns?: RequestColumns): Promise<ApiResponseProcessor>;
+    requestItems(itemType: ItemType, itemIds: ItemId[], columns: RequestColumns): Promise<ApiResponseProcessor>;
 }

package/dist/dist/constants.d.ts

@@ -4,6 +4,7 @@ export declare enum ENTRY_STATUS {
     EXPAND = "expand",
     PROMISED_EXPAND = "promised-expand",
     RESOLVE = "resolve",
+    RESOLVE_VALUES = "resolve-values",
     LOCAL = "local",
 }
 export declare const ALL_PERMISSIONS = "7";

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

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

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

@@ -19,6 +19,7 @@ export declare class CollectionEntry {
     hasEditResources: boolean;
     hasItemEditResources: boolean;
     constructor(factory: CollectionEntryFactory, itemType: ItemType, options: any);
+    defer(): void;
     isDeferred(): boolean;
     resolve(itemEntryCompound: {
         columns: ColumnSet;
@@ -31,9 +32,9 @@ export declare class CollectionEntry {
     getIdArray(accumulator?: ItemId[]): ItemId[];
     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, enableCallback?: boolean): ItemResource[] | null;
-    clear(resultResource?: CollectionResource | null, updateInitial?: boolean, enableCallback?: boolean): ItemResource[] | null;
-    handleRemovedItems(filterFunction: (itemEntry: ItemEntry) => boolean, resultResource?: CollectionResource | null, updateInitial?: boolean, enableCallback?: boolean): ItemResource[] | null;
+    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: any): Promise<any>;
     extendQuery(callback: any): any;

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

@@ -27,10 +27,12 @@ export declare class CollectionResource {
     filter(callback: (itemResource: ItemResource) => boolean): ItemResource[];
     first(callback: (itemResource: ItemResource) => boolean): ItemResource | null;
     some(callback: (itemResource: ItemResource) => boolean): boolean;
-    groupBy(argument: any): {};
-    map(argument: any): any[];
+    groupBy(argument: string | ((itemResource: ItemResource) => string | null)): {
+        [key: string]: ItemResource[];
+    };
+    map<T>(argument: string | ((itemResource: ItemResource) => T)): T[];
     reduce<T>(callback: (itemResource: ItemResource, value: T) => T, value: T): T;
-    extend(queryCallback: any, returnAllItems: any, enableCallbacks: any): Promise<ItemResource[]>;
+    extend(queryCallback: any, returnAllItems?: boolean, callOnAdd?: boolean): Promise<ItemResource[]>;
     deactivate(): void;
     clearResource(): void;
 }

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

@@ -1,13 +1,14 @@
 import { ColumnSet } from '../classes';
 import { ItemEntryFactory } from '../factories';
 import { ItemResource } from '../models';
-import { EntryParentNull, FieldMap, ItemId, ItemIdConversionMap } from '../types';
+import { ColumnExpansionResult, EntryParentNull, FieldMap, ItemId, ItemIdConversionMap, ItemType, ResponseColumn } from '../types';
 export declare class ItemEntry {
     private factory;
     itemType: string;
     itemId: ItemId;
     columns: ColumnSet;
     id: number;
+    reloadQueued: boolean;
     deferRequest: boolean;
     deferred: any;
     parent: EntryParentNull;
@@ -16,41 +17,45 @@ export declare class ItemEntry {
     derived: FieldMap;
     resources: ItemResource[];
     constructor(factory: ItemEntryFactory, itemType: string, itemId: ItemId, columns: ColumnSet);
-    defer(deferRequest: any): this;
+    queueReload(): this;
+    defer(deferRequest?: boolean): this;
     resolve(): this;
     resolveDeferred(initial: any, derived: any, columns: any): this;
     isDeferred(): boolean;
     reject(error?: any): this;
-    process(initial: any, derived: any): this;
-    processLocal(initial: any, modified: any, derived: any, conversionMap: ItemIdConversionMap): this;
-    setCreator(): this;
+    setFields(initial: FieldMap, derived: FieldMap): this;
+    setLocalFields(initialValues: FieldMap, conversionMap: ItemIdConversionMap): this;
     clone(conversionMap?: ItemIdConversionMap): ItemEntry;
     resetDerived(columnIds: any): this;
     clearResources(): this;
     deactivateResources(): this;
     getFields(): FieldMap;
-    expand(main: any, derived: any, columnExpansionResult: any): this;
-    updateFields(source: any, overwrite?: boolean): this;
-    updateItemValue(fields: any, apiColumn: any, conversionMap: any): this;
-    updateItemFields(conversionMap: any): this;
-    formatRequest(): {};
+    expand(main: FieldMap, derived: FieldMap, columnExpansionResult: ColumnExpansionResult): this;
+    /**
+     * This function assumes the initial, modified, derived properties are already set. It will update the values
+     * themselves to preserve references in existing item resources.
+     */
+    updateFields(fields: FieldMap, derived?: FieldMap | null, overwrite?: boolean): this;
+    updateItemValue(fields: FieldMap, apiColumn: ResponseColumn, conversionMap: ItemIdConversionMap): this;
+    updateItemFields(conversionMap: ItemIdConversionMap): this;
+    formatRequest(): FieldMap;
     setDisplayName(): this;
-    getDisplayName(): any;
+    getDisplayName(): string;
     /**
      * @param {Boolean} returnAll Returns all initial values if true
      * @returns {Object}
      */
-    getChanges(returnAll?: boolean): object[];
+    getChanges(returnAll?: boolean): FieldMap;
     isLocal(): boolean;
     isLockable(): boolean;
     hasChanges(): boolean;
     resetModified(): this;
-    setInitial(values: any, enableCallbacks?: any): this;
+    setInitial(values: FieldMap, enableCallbacks?: boolean): this;
     /**
      * Does a shallow copy of values!
      */
-    setModified(values?: any): this;
-    setDerived(values: any): this;
-    setParent(parentType: any, parentId: any): this;
-    callOnChange(previous: any): this;
+    setModified(values?: FieldMap): this;
+    setDerived(values: FieldMap): this;
+    setParent(parentType: ItemType, parentId: ItemId): this;
+    callOnChange(previous: FieldMap): this;
 }

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

@@ -1,4 +1,4 @@
-import { CollectionMatcher, ColumnSet, RequestColumnExpansion } from '../classes';
+import { ApiResponseProcessor, CollectionMatcher, ColumnSet, RequestColumnExpansion } from '../classes';
 import { ENTRY_STATUS } from '../constants';
 import { CollectionEntry, CollectionResource, ItemEntry, ItemResource } from '../models';
 export declare type EntryParent = {
@@ -17,8 +17,8 @@ export declare type ItemDefinition = {
     isNew: boolean;
 };
 export declare const enum StateKeyType {
-    New = 0,
-    Duplicate = 1,
+    New = "new",
+    Duplicate = "duplicate",
 }
 export declare type StateKey = {
     type: StateKeyType;
@@ -76,7 +76,7 @@ export declare type ColumnExpansionResult = {
     merged: ColumnSet;
     difference: ColumnSet;
 };
-export declare type ApiResponse = any;
+export declare type ApiResponse = ApiResponseProcessor;
 export interface ApiTemplate {
     fields: any;
     columns: any;