@rentman/rm-core 1.3.8-1 → 1.4.0-1

package/dist/src/classes/ApiFormatter.d.ts

@@ -1,7 +1,7 @@
 /// <reference types="moment" />
 import * as moment from 'moment';
+import { ColumnInfo } from '../classes';
 import { FieldMap } from '../types';
-import { ColumnInfo } from './ColumnInfo';
 export declare class ApiFormatter {
     MOMENT_INVALID: string;
     SERVER_DATETIME_FORMAT: string;
@@ -30,7 +30,7 @@ export declare class ApiFormatter {
     formatRequestDate(value: any): any;
     formatRequestDuration(value: any): any;
     formatRequestColor(value: any): any;
-    getDefaultValue(columnType: any): false | 0 | "" | moment.Moment | moment.Duration | "0" | "#000000" | null;
+    getDefaultValue(columnType: any): false | "" | 0 | "0" | moment.Moment | moment.Duration | "#000000" | null;
     isDefaultValue(columnType: any, value: any): boolean;
     clone(columnType: any, value: any): any;
     getCloneFunction(columnType: any): (date: any) => any;

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

@@ -1,19 +1,25 @@
 import { ENTRY_STATUS } from '../constants';
 import { PromiseLibraryInterface } from '../interfaces';
-import { ItemEntry } from '../models';
-import { EntryStatus, ItemEntryEntryStatusMap, ItemId, PromiseInterface } from '../types';
-export declare class BatchStatus {
+import { EntryStatus, EntryStatusMap, ItemId, PromiseInterface } from '../types';
+export declare class BatchStatus<T> {
     private promiseService;
-    getItemId: (itemEntry: ItemEntry) => ItemId;
-    getPromise: (itemEntry: ItemEntry) => PromiseInterface<ItemEntry>;
-    readonly requestStatusArray: ENTRY_STATUS[];
-    entries: ItemEntryEntryStatusMap;
-    constructor(promiseService: PromiseLibraryInterface, getItemId: (itemEntry: ItemEntry) => ItemId, getPromise: (itemEntry: ItemEntry) => PromiseInterface<ItemEntry>);
-    add(entryStatus: EntryStatus<ItemEntry>): void;
+    getItemId: (itemEntry: T) => ItemId;
+    getPromise: (itemEntry: T) => PromiseInterface<T>;
+    readonly requestStatus: ENTRY_STATUS[];
+    readonly remoteExpandStatus: ENTRY_STATUS[];
+    entries: EntryStatusMap<T>;
+    constructor(promiseService: PromiseLibraryInterface, getItemId: (itemEntry: T) => ItemId, getPromise: (itemEntry: T) => PromiseInterface<T>);
+    add(entryStatus: EntryStatus<T>): void;
     hasEntries(statusArray: ENTRY_STATUS[]): boolean;
     hasRequests(): boolean;
-    forEachEntry(statusArray: ENTRY_STATUS[], callback: (itemEntry: ItemEntry) => void): void;
-    getPromises(): PromiseInterface<ItemEntry[]>;
-    getRequestIds(): number[];
-    getArray(): ItemEntry[];
+    forEachEntry(statusArray: ENTRY_STATUS[], callback: (entry: T, itemId: ItemId) => void): void;
+    reduceEntries<U>(statusArray: ENTRY_STATUS[], callback: (entry: T, itemId: ItemId, destination: U) => void, destination: U): U;
+    reduceAllEntries<U>(callback: (entry: T, itemId: ItemId, destination: U) => void, destination: U): U;
+    getPromises(): PromiseInterface<T[]>;
+    getItemIds(statusArray: ENTRY_STATUS[]): ItemId[];
+    getRequestIds(): ItemId[];
+    getArray(statusArray?: ENTRY_STATUS[]): T[];
+    getMap(): {
+        [itemId: string]: T;
+    };
 }

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

@@ -1,27 +1,27 @@
 import { PromiseInterface } from '../';
-import { CollectionCache, CollectionEntryService, CollectionMatcher, ColumnExpansion, ColumnHandler, ColumnSet, ItemCache, ItemRequestService, KeyService, QueryService } from '../classes';
+import { BatchStatus, CollectionCache, CollectionEntryService, CollectionMatcher, ColumnExpansion, ColumnHandler, ColumnSet, ItemCache, ItemHandler, ItemRequestService, KeyService, QueryService } from '../classes';
 import { ENTRY_STATUS } from '../constants';
-import { CollectionCacheFactory, CollectionEntryFactory, CollectionMatcherFactory, ColumnSetFactory, QueryParserFactory } from '../factories';
+import { BatchStatusFactory, CollectionCacheFactory, CollectionEntryFactory, CollectionMatcherFactory, ColumnSetFactory, QueryParserFactory } from '../factories';
 import { ErrorHandlerInterface, PromiseLibraryInterface } from '../interfaces';
 import { CollectionEntry, CollectionResource, ItemResource } from '../models';
-import { ApiRequestColumn, CollectionEntryBatchStatusMap, CollectionEntryParentIdMap, EntryStatus, ItemEntryParentIdMap, ItemId, ItemResourceItemIdMap, ItemType } from '../types';
+import { ApiRequestColumn, CollectionEntryParentIdMap, EntryStatus, ItemEntryParentIdMap, ItemId, ItemResourceItemIdMap, ItemType } from '../types';
 export declare class CollectionHandler {
-    private errorHandler;
-    private itemRequestService;
-    private columnHandler;
-    private columnSetFactory;
-    private collectionEntryFactory;
+    private batchStatusFactory;
     private collectionCacheFactory;
-    private queryParserFactory;
+    private collectionEntryFactory;
     private collectionEntryService;
+    private collectionMatcherFactory;
+    private columnHandler;
+    private columnSetFactory;
+    private errorHandler;
+    private itemHandler;
+    private itemRequestService;
     private keyService;
     private promiseService;
+    private queryParserFactory;
     private queryService;
-    private collectionMatcherFactory;
     entries: CollectionCache;
-    constructor(errorHandler: ErrorHandlerInterface, itemRequestService: ItemRequestService, columnHandler: ColumnHandler, columnSetFactory: ColumnSetFactory, collectionEntryFactory: CollectionEntryFactory, collectionCacheFactory: CollectionCacheFactory, queryParserFactory: QueryParserFactory, collectionEntryService: CollectionEntryService, keyService: KeyService, promiseService: PromiseLibraryInterface, queryService: QueryService, collectionMatcherFactory: CollectionMatcherFactory);
-    getPromises(statusResource: CollectionEntryBatchStatusMap): CollectionEntry[];
-    getRequestIds(statusResource: any): number[];
+    constructor(batchStatusFactory: BatchStatusFactory, collectionCacheFactory: CollectionCacheFactory, collectionEntryFactory: CollectionEntryFactory, collectionEntryService: CollectionEntryService, collectionMatcherFactory: CollectionMatcherFactory, columnHandler: ColumnHandler, columnSetFactory: ColumnSetFactory, errorHandler: ErrorHandlerInterface, itemHandler: ItemHandler, itemRequestService: ItemRequestService, keyService: KeyService, promiseService: PromiseLibraryInterface, queryParserFactory: QueryParserFactory, queryService: QueryService);
     /**
      * @deprecated, use collectionMatcherFactory
      */
@@ -37,8 +37,12 @@ export declare class CollectionHandler {
     addToCollections(collectionMap: any, updateInitial: boolean, resultResource?: CollectionResource | null): ItemResource[];
     batchExpand(parentType: ItemType, itemType: ItemType, collections: CollectionResource[], newColumns: ApiRequestColumn[]): PromiseInterface<CollectionResource[]>;
     batchExtend(parentType: string, itemType: string, options: any, queryCallback: any, collections: CollectionResource[], returnAllItems?: boolean): PromiseInterface<ItemResourceItemIdMap>;
-    batchFetch(parentType: ItemType, parentIdArray: ItemId[], itemType: ItemType, options: any, itemCache: ItemCache, localCollectionCache: CollectionCache, deferredCollectionCache: CollectionCache): PromiseInterface<CollectionEntryParentIdMap>;
-    createStatusResource(parentType: ItemType, parentIdArray: ItemId[], itemType: ItemType, options: any, localCollectionCache: CollectionCache, deferredCollectionCache: CollectionCache): CollectionEntryBatchStatusMap;
+    batchFetch(parentType: ItemType, parentIdArray: ItemId[], itemType: ItemType, options: any, itemCache: ItemCache, localCollectionCache: CollectionCache, deferredCollectionCache: CollectionCache): Promise<CollectionEntryParentIdMap>;
+    handleBatchResponse(batchStatus: BatchStatus<CollectionEntry>, itemEntryCompound: {
+        columns: ColumnSet;
+        columnExpansion?: ColumnExpansion;
+        items?: ItemEntryParentIdMap;
+    }, localItems: ItemEntryParentIdMap): CollectionEntryParentIdMap;
     fetch(itemType: ItemType, options: any, itemCache: ItemCache, localCollectionCache: CollectionCache, deferredCollectionCache: CollectionCache): PromiseInterface<CollectionEntry>;
     getCachedEntryStatus(collectionEntry: CollectionEntry, options: any): ENTRY_STATUS;
     getDeferredEntryStatus(itemType: ItemType, options: any, query: any, deferredEntries: CollectionCache): {
@@ -46,11 +50,6 @@ export declare class CollectionHandler {
         isDeferred: boolean;
     };
     getEntryStatus(itemType: ItemType, options: any, localEntries: CollectionCache, deferredEntries: CollectionCache): EntryStatus<CollectionEntry>;
-    handleBatchResponse(statusResource: any, itemEntryCompound: {
-        columns: ColumnSet;
-        columnExpansion?: ColumnExpansion;
-        items?: ItemEntryParentIdMap;
-    }, itemCache: ItemCache): CollectionEntryParentIdMap;
     resolveLocal(collectionEntry: CollectionEntry, itemCache: ItemCache): PromiseInterface<CollectionEntry>;
     resolveRemote(collectionEntry: CollectionEntry, itemCache: ItemCache): PromiseInterface<CollectionEntry>;
     isLocal(options: any): boolean;

package/dist/src/classes/ColumnExpansion.d.ts

@@ -1,14 +1,18 @@
-import { ColumnSet, ColumnUtil } from '../classes';
+import { ColumnInfo, ColumnSet, ColumnUtil } from '../classes';
 import { ApiRequestColumn, ApiRequestColumns, ColumnExpansionResult, ItemType, ResponseColumnMap } from '../types';
 export declare class ColumnExpansion {
+    private columnInfoFactory;
     private columnUtil;
     itemType: ItemType;
     responseColumns: ResponseColumnMap;
     expansionMap: {
-        [columnSetId: number]: ColumnExpansionResult;
+        [columnSetId: number]: ColumnExpansionResult | null;
     };
     requestColumnsTrue: boolean;
     requestColumns: ApiRequestColumn[];
-    constructor(columnUtil: ColumnUtil, itemType: ItemType, requestColumns: ApiRequestColumns, responseColumns: ResponseColumnMap);
+    constructor(columnInfoFactory: any, columnUtil: ColumnUtil, itemType: ItemType, requestColumns: ApiRequestColumns, responseColumns: ResponseColumnMap);
     run(columnSet: ColumnSet): ColumnExpansionResult | null;
+    aggregateRootColumns(): ColumnInfo[];
+    private expandRootColumnMap(columns, destination);
+    private processRootColumnMap(rootColumnMap, parent);
 }

package/dist/src/classes/ColumnInfo.d.ts

@@ -1,12 +1,14 @@
+import { ItemType, ResponseColumn } from '../types';
 export declare class ColumnInfo {
-    readonly apiColumn: any;
+    readonly apiColumn: ResponseColumn;
     readonly parent: ColumnInfo | null;
     id: string;
     level: number;
     path: string;
     tailPath: string;
-    itemType: string;
+    itemType: ItemType | null;
     children: ColumnInfo[];
     isLeaf: boolean;
-    constructor(apiColumn: any, parent?: ColumnInfo | null);
+    constructor(apiColumn: ResponseColumn, parent?: ColumnInfo | null);
+    setChildren(itemType: ItemType, children: ColumnInfo[]): this;
 }

package/dist/src/classes/ColumnSet.d.ts

@@ -39,5 +39,8 @@ export declare class ColumnSet {
     private processRequestColumns(responseColumns, includeIdColumn);
     private getRequestColumnInfo(requestColumn, itemType, parent, responseColumns);
     private getColumnInfo(columnId, itemType, children, parent, responseColumns);
+    private getColumnSetExpansion(requestColumns, responseColumns);
+    private getMergedColumnSet(columnSetExpansion, requestColumnsTrue);
+    merge(columnSet: ColumnSet): ColumnSet;
     expand(requestColumns: ApiRequestColumns, requestColumnsTrue: boolean, responseColumns: ResponseColumnMap): ColumnExpansionResult;
 }

package/dist/src/classes/ColumnUtil.d.ts

@@ -1,4 +1,4 @@
-import { ApiRequestColumn, ApiRequestColumns } from '../types';
+import { ApiRequestColumn, ApiRequestColumns, ResponseColumnMap } from '../types';
 export declare class ColumnUtil {
     constructor();
     getColumnPath(columns: any, renderAs: any): string;
@@ -54,9 +54,9 @@ export declare class ColumnUtil {
      * @param {object} second
      * @returns {object} An object containing a 'merged' and a 'difference' property.
      */
-    mergeResponseColumns(first: any, second: any): {
-        merged: {};
-        difference: {};
+    mergeResponseColumns(first: ResponseColumnMap, second: ResponseColumnMap): {
+        merged: ResponseColumnMap;
+        difference: ResponseColumnMap;
     };
     /**
      * @param {array} first

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

@@ -2,7 +2,7 @@ import { CollectionCache, CollectionEntryService, CollectionHandler, CollectionM
 import { CollectionMatcherFactory, ColumnSetFactory, LocalCacheFactory, ModuleChangesCompilationFactory } from '../factories';
 import { ApiRequestServiceInterface, AuthInterface, ErrorHandlerInterface, LocalCacheManagerInterface, PromiseLibraryInterface } from '../interfaces';
 import { CollectionEntry, CollectionResource, ItemEntry, ItemResource } from '../models';
-import { CollectionResourceParentIdMap, CreateRequestParameterMap, ItemId, ItemIdConversionMap, ItemOptions, ItemResourceItemTypeMap, ItemType, LocalCacheCallbackCondition, OnSaveCallback, PromiseInterface, TemplateItemResourceMap, TemplateLinkedItemEntryMap } from '../types';
+import { CollectionResourceParentIdMap, CreateRequestParameterMap, ItemId, ItemIdConversionMap, ItemOptions, ItemResourcesItemTypeMap, ItemType, LinkedItemEntryMap, LocalCacheCallbackCondition, OnSaveCallback, PromiseInterface, TemplateItemResourceMap } from '../types';
 export declare class ItemAdministrator {
     private apiRequestService;
     private authInterface;
@@ -23,8 +23,8 @@ export declare class ItemAdministrator {
     private queryService;
     constructor(apiRequestService: ApiRequestServiceInterface, authInterface: AuthInterface, collectionEntryService: CollectionEntryService, collectionHandler: CollectionHandler, collectionMatcherFactory: CollectionMatcherFactory, collectionResourceService: CollectionResourceService, columnSetFactory: ColumnSetFactory, errorHandler: ErrorHandlerInterface, itemEntryService: ItemEntryService, itemHandler: ItemHandler, itemRequestService: ItemRequestService, keyService: KeyService, localCacheFactory: LocalCacheFactory, localCacheManager: LocalCacheManagerInterface, moduleChangesCompilationFactory: ModuleChangesCompilationFactory, promiseInterface: PromiseLibraryInterface, queryService: QueryService);
     invalidateCache(): void;
-    getCollectionMatcher(itemEntries: ItemEntry[], addToTab: boolean): CollectionMatcher;
-    fetchTitle(itemType: any, itemId: any, deferRequest: any): PromiseInterface<string>;
+    getCollectionMatcher(itemEntries: ItemEntry[], addToTab?: boolean): CollectionMatcher;
+    fetchTitle(itemType: ItemType, itemId: ItemId, deferRequest?: boolean): PromiseInterface<string>;
     getItemById(itemType: ItemType, itemId: ItemId, options: ItemOptions, isRoot?: boolean): PromiseInterface<ItemResource>;
     getItemsById(itemType: string, itemIds: number[], options: any): PromiseInterface<ItemResource[]>;
     getItemsByQuery(itemType: string, query: any, options: any): PromiseInterface<ItemResource[]>;
@@ -89,7 +89,12 @@ export declare class ItemAdministrator {
     addSingleItem(itemEntry: ItemEntry, options: ItemOptions, isRoot?: boolean, localCache?: LocalCache): ItemResource;
     addSingleItems(itemEntries: ItemEntry[], options: ItemOptions): ItemResource[];
     addCollection(collectionEntry: CollectionEntry, options: any): CollectionResource;
-    processLinkedItems(linkedEntries: TemplateLinkedItemEntryMap[], options: ItemOptions, addToCollections: boolean): ItemResourceItemTypeMap;
+    private createItemResources(itemType, itemEntries, options, localCache);
+    processLinkedItems(linkedEntries: LinkedItemEntryMap[], options: ItemOptions, addToCollections?: boolean): ItemResourcesItemTypeMap;
+    expandProcessLinkedItems(linkedEntries: LinkedItemEntryMap[], options: ItemOptions): Promise<ItemResourcesItemTypeMap>;
+    private constructOnItemsExpanded(itemType, itemEntries, itemOptions, localCache);
+    private expandAddToCollections(itemType, itemEntries, resultCollectionResource?, localCache?);
+    private getColumnSuperset(collectionEntries);
     getLocalCache(): LocalCache;
     resetLocalCache(): void;
     addToCollections(itemEntries: ItemEntry[], resultCollectionResource?: CollectionResource): ItemResource[] | null;

package/dist/src/classes/ItemCache.d.ts

@@ -1,6 +1,6 @@
 import { QueryMatcherFactory } from '../factories';
 import { ItemEntry } from '../models';
-import { ItemEntryMap, ItemId, ItemType } from '../types';
+import { ItemEntryMap, ItemEntryParentIdMap, ItemId, ItemType } from '../types';
 export declare class ItemCache {
     private queryMatcherFactory;
     entries: ItemEntryMap;
@@ -10,6 +10,7 @@ export declare class ItemCache {
     getByQuery(itemType: ItemType, query: any): ItemEntry[];
     getLocalByQuery(itemType: ItemType, query: any): ItemEntry[];
     getByParent(parentType: ItemType, parentId: ItemId, itemType: ItemType): ItemEntry[];
+    batchGetLocalByParent(parentType: ItemType, parentIds: ItemId[], itemType: ItemType, additionalQuery: any): ItemEntryParentIdMap;
     forEach(callback: (itemEntry: ItemEntry) => void): void;
     toArray(): ItemEntry[];
     add(itemEntry: ItemEntry): ItemEntry;

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

@@ -20,4 +20,5 @@ export declare class ItemEntryService {
     getFullName(firstName: any, infix: any, lastName: any): any;
     getTitleField(itemType: any): "serienummer" | "nummer" | "friendlyname" | "naamintern" | "omschrijving" | "code" | "naam" | "displayname";
     getLocalDefaultValues(): FieldMap;
+    hasLocalDefaultValue(columnId: string): boolean;
 }

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

@@ -3,7 +3,7 @@ import { ENTRY_STATUS } from '../constants';
 import { BatchStatusFactory, ColumnExpansionFactory, ColumnSetFactory, ItemCacheFactory, ItemEntryFactory, TemplateFactory } from '../factories';
 import { ApiRequestServiceInterface, ErrorHandlerInterface, PromiseLibraryInterface } from '../interfaces';
 import { ItemEntry, Template } from '../models';
-import { ApiResponse, EntryStatus, FieldMap, ItemId, ItemIdConversionMap, ItemOptions, ItemType, PromiseInterface, ApiRequestColumns, TemplateItemEntryMap, TemplateLinkedItemEntryMap } from '../types';
+import { ApiResponse, EntryStatus, FieldMap, ItemId, ItemIdConversionMap, ItemOptions, ItemType, PromiseInterface, ApiRequestColumns, TemplateItemEntryMap, LinkedItemEntryMap } from '../types';
 export declare class ItemHandler {
     private apiFormatter;
     private apiRequestService;
@@ -61,12 +61,13 @@ 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: ItemType, batchStatus: BatchStatus, requestColumns: ApiRequestColumns, resolved: {
+    batchResolve(itemType: ItemType, batchStatus: BatchStatus<ItemEntry>, requestColumns: ApiRequestColumns, resolved: {
         entries: ItemEntry[];
         requests?: ApiResponseProcessor;
     }): ItemEntry[] | PromiseInterface<any>;
-    createLocalEntries(parentType: ItemType, localParentId: ItemId, template: any, itemIdConversion: ItemIdConversionMap, localItemCache: ItemCache, excludeItemTypes?: ItemType[]): TemplateLinkedItemEntryMap[];
     fetchTitle(itemType: ItemType, itemId: ItemId, deferRequest: boolean | undefined, localItemCache: ItemCache): PromiseInterface<string>;
+    createLocalEntries(parentType: ItemType, localParentId: ItemId, template: Template, itemIdConversion: ItemIdConversionMap, localItemCache: ItemCache, filterItemEntry?: (itemEntry: ItemEntry) => boolean): LinkedItemEntryMap[];
+    expandLocalEntries(itemType: ItemType, itemEntries: ItemEntry[], columnSet: ColumnSet, localItemCache: ItemCache): Promise<ItemEntry[]>;
     resolveDerivedValues(itemEntries: ItemEntry[], columns: ColumnInfo[], localItemCache: ItemCache): PromiseInterface<ItemEntry[]>;
     private getDefaultValuesByColumn(itemEntries, rootColumn);
     private getItemIdByColumn(itemEntry, column);

package/dist/src/classes/RequestColumnExpansion.d.ts

@@ -1,9 +1,12 @@
-import { ColumnUtil } from './ColumnUtil';
+import { ColumnSet, ColumnUtil } from '../classes';
+import { ApiRequestColumns } from '../types';
 export declare class RequestColumnExpansion {
     private columnUtil;
     private columns;
-    private columnInfoIdMap;
+    private columnSetIdMap;
     constructor(columnUtil: ColumnUtil);
-    expand(columnInfo: any): void;
-    get(): {};
+    expand(columnSet: ColumnSet): void;
+    get(): {
+        [itemType: string]: ApiRequestColumns;
+    };
 }

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

@@ -20,7 +20,11 @@ export declare class SocketMessageHandler {
         [itemId: number]: CollectionMatchResult;
     };
     groupByCollectionId(itemType: any, collectionMap: any): GroupedExtendedCollectionMatchResult;
-    getRequestColumns(itemType: any, collectionMap: any): {};
+    getRequestColumns(itemType: any, collectionMap: any): {
+        [itemType: string]: true | (string | {
+            [columnId: string]: (string | any)[];
+        })[];
+    };
     deferEntry(itemEntry: any): any;
     processMessage(body: any): PromiseInterface<GroupedExtendedCollectionMatchResult>;
     processFunctionChangesResolve(body: any): Promise<any> | undefined;

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

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

package/dist/src/factories/ColumnExpansionFactory.d.ts

@@ -1,6 +1,9 @@
 import { ColumnExpansion, ColumnUtil } from '../classes';
+import { ColumnInfoFactory } from '../factories';
+import { ApiRequestColumns, ItemType, ResponseColumnMap } from '../types';
 export declare class ColumnExpansionFactory {
+    private columnInfoFactory;
     private columnUtil;
-    constructor(columnUtil: ColumnUtil);
-    construct(itemType: string, requestColumns: any | boolean, responseColumns: any): ColumnExpansion;
+    constructor(columnInfoFactory: ColumnInfoFactory, columnUtil: ColumnUtil);
+    construct(itemType: ItemType, requestColumns: ApiRequestColumns, responseColumns: ResponseColumnMap): ColumnExpansion;
 }

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

@@ -1,7 +1,7 @@
 import { ColumnSet } from '../classes';
 import { ItemEntryFactory } from '../factories';
 import { ItemResource } from '../models';
-import { ColumnExpansionResult, EntryParentNull, FieldMap, ItemId, ItemIdConversionMap, ItemType, ResponseColumn } from '../types';
+import { ColumnExpansionResult, EntryParentNull, FieldMap, ItemId, ItemIdConversionMap, ItemType } from '../types';
 export declare class ItemEntry {
     private factory;
     itemType: string;
@@ -31,12 +31,14 @@ export declare class ItemEntry {
     deactivateResources(): this;
     getFields(): FieldMap;
     expand(main: FieldMap, derived: FieldMap, columnExpansionResult: ColumnExpansionResult): this;
+    expandLocal(columnExpansionResult: ColumnExpansionResult): this;
+    private setLocalValues(fields, columns);
     /**
      * 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;
+    private updateItemValues(fields, itemColumns, conversionMap);
     updateItemFields(conversionMap: ItemIdConversionMap, columns?: ColumnSet): this;
     formatRequest(): FieldMap;
     setDisplayName(): this;

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

@@ -39,8 +39,8 @@ export declare type LocalCacheCallbacks<T> = {
 export declare type ItemResourceItemIdMap = {
     [itemId: number]: ItemResource;
 };
-export declare type ItemResourceItemTypeMap = {
-    [itemType: string]: ItemResource;
+export declare type ItemResourcesItemTypeMap = {
+    [itemType: string]: ItemResource[];
 };
 export declare type ItemId = number;
 export declare type ItemType = string;
@@ -49,8 +49,13 @@ export declare type ItemEntryMap = {
         [itemId: number]: ItemEntry;
     };
 };
-export declare type ItemEntryEntryStatusMap = {
-    [entryStatus: string]: ItemEntry[];
+export declare type LinkedItemEntryMap = {
+    itemType: string;
+    itemEntries: ItemEntry[];
+    columnSet: ColumnSet;
+};
+export declare type EntryStatusMap<T> = {
+    [entryStatus: string]: T[];
 };
 export declare type ItemEntryParentIdMap = {
     [parentId: number]: ItemEntry[];
@@ -65,9 +70,6 @@ export declare type CreateRequestParameterMap = {
         [itemId: number]: any;
     };
 };
-export declare type CollectionEntryBatchStatusMap = {
-    [status: string]: CollectionEntryParentIdMap;
-};
 export declare type CollectionEntryParentIdMap = {
     [parentId: number]: CollectionEntry;
 };
@@ -97,18 +99,27 @@ export declare type ColumnExpansionResult = {
     merged: ColumnSet;
     difference: ColumnSet;
 };
+export declare type ColumnSetExpansion = {
+    request: {
+        merged: ApiRequestColumns;
+        difference: ApiRequestColumns;
+    };
+    response: ResponseColumnMap;
+};
+export declare type RootColumnMap = {
+    [columnId: string]: {
+        apiColumn: ResponseColumn;
+        children: RootColumnMap;
+    };
+};
 export declare type ApiResponse = ApiResponseProcessor;
 export declare type TemplateItemResourceMap = {
     main: ItemResource;
-    linked: ItemResourceItemTypeMap;
+    linked: ItemResourcesItemTypeMap;
 };
 export declare type TemplateItemEntryMap = {
     main: ItemEntry;
-    linked: TemplateLinkedItemEntryMap[];
-};
-export declare type TemplateLinkedItemEntryMap = {
-    itemType: string;
-    itemEntries: ItemEntry[];
+    linked: LinkedItemEntryMap[];
 };
 export declare type ItemTypeMap = {
     [itemType: string]: any;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rentman/rm-core",
-  "version": "1.3.8-1",
+  "version": "1.4.0-1",
   "description": "Rentman core functionalities",
   "main": "./dist/rm-core.js",
   "types": "./dist/src/index.d.ts",