@rentman/rm-core 1.5.3 → 1.5.5

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

@@ -1,20 +1,20 @@
-import { CollectionCache, CollectionHandler, CreateCompilation, KeyService } from '../classes';
-import { CollectionMatcherFactory, RequestColumnExpansionFactory } from '../factories';
-import { CreateRequestEntry, CreateRequestParameterMap, ItemType } from '../types';
-export declare class CreateRequest {
-    private collectionHandler;
-    private collectionMatcherFactory;
-    private keyService;
-    private requestColumnExpansionFactory;
-    private compilation;
-    private localCollectionCache;
-    private parameterMap;
-    private breakupByParent;
-    requests: CreateRequestEntry[];
-    constructor(collectionHandler: CollectionHandler, collectionMatcherFactory: CollectionMatcherFactory, keyService: KeyService, requestColumnExpansionFactory: RequestColumnExpansionFactory, compilation: CreateCompilation, localCollectionCache: CollectionCache, parameterMap: CreateRequestParameterMap, breakupByParent?: boolean);
-    finalizeRequest(requestResource: CreateRequestEntry): CreateRequestEntry;
-    setRequestParent(parentType: ItemType, requestEntry: CreateRequestEntry): boolean;
-    run(): CreateRequestEntry[];
-    initializeRequest(): CreateRequestEntry;
-    private extendRequest;
-}
+import { CollectionCache, CollectionHandler, CreateCompilation, KeyService } from '../classes';
+import { CollectionMatcherFactory, RequestColumnExpansionFactory } from '../factories';
+import { CreateRequestEntry, CreateRequestParameterMap, ItemType } from '../types';
+export declare class CreateRequest {
+    private collectionHandler;
+    private collectionMatcherFactory;
+    private keyService;
+    private requestColumnExpansionFactory;
+    private compilation;
+    private localCollectionCache;
+    private parameterMap;
+    private breakupByParent;
+    requests: CreateRequestEntry[];
+    constructor(collectionHandler: CollectionHandler, collectionMatcherFactory: CollectionMatcherFactory, keyService: KeyService, requestColumnExpansionFactory: RequestColumnExpansionFactory, compilation: CreateCompilation, localCollectionCache: CollectionCache, parameterMap: CreateRequestParameterMap, breakupByParent?: boolean);
+    finalizeRequest(requestResource: CreateRequestEntry): CreateRequestEntry;
+    setRequestParent(parentType: ItemType, requestEntry: CreateRequestEntry): boolean;
+    run(): CreateRequestEntry[];
+    initializeRequest(): CreateRequestEntry;
+    private extendRequest(itemEntries, requestParentId, destination);
+}

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

@@ -1,70 +1,83 @@
-import { CollectionCache, CollectionHandler, CollectionMatcher, ItemCache, ItemHandler, ItemRequestService, KeyService, LocalCache, QueryService } from '../classes';
-import { CollectionMatcherFactory, ColumnSetFactory, LocalCacheFactory, ModuleChangesCompilationFactory } from '../factories';
-import { ApiRequestServiceInterface, AuthInterface, ErrorHandlerInterface, LocalCacheManagerInterface, PromiseLibraryInterface } from '../interfaces';
-import { CollectionEntry, CollectionResource, CollectionResourceOptionsInterface, EditResource, ItemEntry, ItemResource, ItemResourceOptionsInterface } from '../models';
-import { ApiQuery, CollectionDefinition, CollectionOptionsInterface, CollectionResourceParentIdMap, CreateRequestParameterMap, ItemId, ItemIdConversionMap, ItemOptionsInterface, ItemResourcesItemTypeMap, ItemType, LinkCollectionDefinition, LinkedItemEntryMap, LocalCacheCallbackCondition, OnSaveCallback, PromiseInterface, TemplateItemResourceMap } from '../types';
-export declare class ItemAdministrator {
-    private apiRequestService;
-    private authInterface;
-    private collectionHandler;
-    private collectionMatcherFactory;
-    private columnSetFactory;
-    private errorHandler;
-    private itemHandler;
-    private itemRequestService;
-    private keyService;
-    private localCacheFactory;
-    private localCacheManager;
-    private moduleChangesCompilationFactory;
-    private promiseInterface;
-    private queryService;
-    constructor(apiRequestService: ApiRequestServiceInterface, authInterface: AuthInterface, collectionHandler: CollectionHandler, collectionMatcherFactory: CollectionMatcherFactory, columnSetFactory: ColumnSetFactory, errorHandler: ErrorHandlerInterface, 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: ItemType, itemId: ItemId, deferRequest?: boolean): PromiseInterface<string>;
-    getItemById(itemType: ItemType, itemId: ItemId, options?: ItemOptionsInterface, isRoot?: boolean): PromiseInterface<ItemResource>;
-    getItemsById(itemType: ItemType, itemIds: ItemId[], options?: ItemOptionsInterface): PromiseInterface<ItemResource[]>;
-    getItemsByQuery(itemType: ItemType, query: ApiQuery, options?: ItemOptionsInterface): PromiseInterface<ItemResource[]>;
-    /**
-     * The return value is depended on the return links boolean. true returns the TemplateResponseItemEntryMap.
-     */
-    getNewResource(itemType: ItemType, options?: ItemOptionsInterface, returnLinks?: boolean, isRoot?: boolean): PromiseInterface<EditResource | TemplateItemResourceMap>;
-    getDuplicateById(itemType: ItemType, duplicateId: ItemId, options?: ItemOptionsInterface, returnLinks?: boolean, isRoot?: boolean): PromiseInterface<ItemResource | TemplateItemResourceMap>;
-    getItemByState(itemType: ItemType, stateKey: ItemId | string, options?: ItemOptionsInterface, isRoot?: boolean): PromiseInterface<ItemResource>;
-    getCollectionDef(itemType: ItemType, options: CollectionOptionsInterface): CollectionDefinition;
-    getLinkCollectionsDef(linkType: ItemType, linkIdArray: ItemId[] | (() => ItemId[]), itemType: ItemType, linkField: string, options: CollectionOptionsInterface): LinkCollectionDefinition;
-    getCollection(itemType: ItemType, options: CollectionOptionsInterface): PromiseInterface<CollectionResource>;
-    getCollectionFromDef(definition: CollectionDefinition): PromiseInterface<CollectionResource>;
-    /**
-     * @deprecated, use `parent` in options
-     */
-    getLinkCollection(linkType: ItemType, linkId: ItemId, itemType: ItemType, options?: CollectionOptionsInterface): PromiseInterface<CollectionResource>;
-    getLinkCollections(linkType: ItemType, linkIdArray: ItemId[], itemType: ItemType, options: CollectionOptionsInterface): PromiseInterface<CollectionResourceParentIdMap>;
-    getLinkCollectionsFromDef(definition: any): PromiseInterface<CollectionResourceParentIdMap>;
-    getAllLinkCollections(linkType: ItemType, itemType: ItemType, options: CollectionOptionsInterface): PromiseInterface<CollectionResourceParentIdMap>;
-    cloneItem(itemResource: ItemResource, options: any): ItemResource;
-    cloneCollection(collectionResource: CollectionResource, options: any, conversionMap: any): CollectionResource;
-    saveCurrentLocalCache(closeTab?: boolean, parameters?: CreateRequestParameterMap, breakupByParent?: boolean, onAfterCreateCallback?: (conversionMap: ItemIdConversionMap) => void): any;
-    getCurrentCollections(): CollectionCache;
-    getCurrentItems(): ItemCache;
-    getModuleChanges(localCache?: LocalCache): import("./ModuleChangesCompilation").ModuleChangesCompilationResult;
-    addSingleItem(itemEntry: ItemEntry, options?: ItemResourceOptionsInterface, isRoot?: boolean, localCache?: LocalCache): ItemResource;
-    addSingleItems(itemEntries: ItemEntry[], options: ItemResourceOptionsInterface): ItemResource[];
-    addCollection(collectionEntry: CollectionEntry, options: CollectionResourceOptionsInterface): CollectionResource;
-    private createItemResources;
-    processLinkedItems(linkedEntries: LinkedItemEntryMap[], options: ItemOptionsInterface, addToCollections?: boolean): ItemResourcesItemTypeMap;
-    expandProcessLinkedItems(linkedEntries: LinkedItemEntryMap[], options: ItemOptionsInterface): Promise<ItemResourcesItemTypeMap>;
-    private constructOnItemsExpanded;
-    private expandAddToCollections;
-    private getColumnSuperset;
-    getLocalCache(): LocalCache;
-    resetLocalCache(): void;
-    addToCollections(itemEntries: ItemEntry[], resultCollectionResource?: CollectionResource): ItemResource[] | null;
-    removeFromCollections(itemEntries: ItemEntry[], resultCollectionResource?: CollectionResource): ItemResource[] | null;
-    saveLocal(itemResource: ItemResource): PromiseInterface<ItemResource>;
-    updateItemIdMap(collectionMap: any, conversionMap: any): void;
-    createCollectionResource(collectionEntry: CollectionEntry, resourceOptions: CollectionResourceOptionsInterface): CollectionResource;
-    createItemResource(itemEntry: ItemEntry, options: ItemResourceOptionsInterface, isRoot: boolean): ItemResource;
-    onBeforeSave(key: string, callback: (localCache: LocalCache) => any, condition?: LocalCacheCallbackCondition): () => void;
-    onSaveSuccess(key: string, callback: OnSaveCallback, condition?: LocalCacheCallbackCondition): () => void;
-}
+import { CollectionCache, CollectionHandler, CollectionMatcher, ItemCache, ItemHandler, ItemRequestService, KeyService, LocalCache, QueryService } from '../classes';
+import { CollectionMatcherFactory, ColumnSetFactory, LocalCacheFactory, ModuleChangesCompilationFactory } from '../factories';
+import { ApiRequestServiceInterface, AuthInterface, ErrorHandlerInterface, LocalCacheManagerInterface, PromiseLibraryInterface } from '../interfaces';
+import { CollectionEntry, CollectionResource, CollectionResourceOptionsInterface, EditResource, ItemEntry, ItemResource, ItemResourceOptionsInterface } from '../models';
+import { ApiQuery, CollectionDefinition, CollectionOptionsInterface, CollectionResourceParentIdMap, CreateRequestParameterMap, ItemId, ItemIdConversionMap, ItemOptionsInterface, ItemResourcesItemTypeMap, ItemType, LinkCollectionDefinition, LinkedItemEntryMap, LocalCacheCallbackCondition, OnSaveCallback, PromiseInterface, TemplateItemResourceMap } from '../types';
+export declare class ItemAdministrator {
+    private apiRequestService;
+    private authInterface;
+    private collectionHandler;
+    private collectionMatcherFactory;
+    private columnSetFactory;
+    private errorHandler;
+    private itemHandler;
+    private itemRequestService;
+    private keyService;
+    private localCacheFactory;
+    private localCacheManager;
+    private moduleChangesCompilationFactory;
+    private promiseInterface;
+    private queryService;
+    constructor(apiRequestService: ApiRequestServiceInterface, authInterface: AuthInterface, collectionHandler: CollectionHandler, collectionMatcherFactory: CollectionMatcherFactory, columnSetFactory: ColumnSetFactory, errorHandler: ErrorHandlerInterface, 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: ItemType, itemId: ItemId, deferRequest?: boolean): PromiseInterface<string>;
+    getItemById(itemType: ItemType, itemId: ItemId, options?: ItemOptionsInterface, isRoot?: boolean): PromiseInterface<ItemResource>;
+    getItemsById(itemType: ItemType, itemIds: ItemId[], options?: ItemOptionsInterface): PromiseInterface<ItemResource[]>;
+    getItemsByQuery(itemType: ItemType, query: ApiQuery, options?: ItemOptionsInterface): PromiseInterface<ItemResource[]>;
+    /**
+     * The return value is depended on the return links boolean. true returns the TemplateResponseItemEntryMap.
+     */
+    getNewResource(itemType: ItemType, options?: ItemOptionsInterface, returnLinks?: boolean, isRoot?: boolean): PromiseInterface<EditResource | TemplateItemResourceMap>;
+    getDuplicateById(itemType: ItemType, duplicateId: ItemId, options?: ItemOptionsInterface, returnLinks?: boolean, isRoot?: boolean): PromiseInterface<ItemResource | TemplateItemResourceMap>;
+    getItemByState(itemType: ItemType, stateKey: ItemId | string, options?: ItemOptionsInterface, isRoot?: boolean): PromiseInterface<ItemResource>;
+    getCollectionDef(itemType: ItemType, options: CollectionOptionsInterface): CollectionDefinition;
+    getLinkCollectionsDef(linkType: ItemType, linkIdArray: ItemId[] | (() => ItemId[]), itemType: ItemType, linkField: string, options: CollectionOptionsInterface): LinkCollectionDefinition;
+    getCollection(itemType: ItemType, options: CollectionOptionsInterface): PromiseInterface<CollectionResource>;
+    getCollectionFromDef(definition: CollectionDefinition): PromiseInterface<CollectionResource>;
+    /**
+     * @deprecated, use `parent` in options
+     */
+    getLinkCollection(linkType: ItemType, linkId: ItemId, itemType: ItemType, options?: CollectionOptionsInterface): PromiseInterface<CollectionResource>;
+    getLinkCollections(linkType: ItemType, linkIdArray: ItemId[], itemType: ItemType, options: CollectionOptionsInterface): PromiseInterface<CollectionResourceParentIdMap>;
+    getLinkCollectionsFromDef(definition: any): PromiseInterface<CollectionResourceParentIdMap>;
+    getAllLinkCollections(linkType: ItemType, itemType: ItemType, options: CollectionOptionsInterface): PromiseInterface<CollectionResourceParentIdMap>;
+    cloneItem(itemResource: ItemResource, options: any): ItemResource;
+    cloneCollection(collectionResource: CollectionResource, options: any, conversionMap: any): CollectionResource;
+    saveCurrentLocalCache(closeTab?: boolean, parameters?: CreateRequestParameterMap, breakupByParent?: boolean, onAfterCreateCallback?: (conversionMap: ItemIdConversionMap) => void): any;
+    getCurrentCollections(): CollectionCache;
+    getCurrentItems(): ItemCache;
+    getModuleChanges(localCache?: LocalCache): {
+        itemType: string;
+        itemId: number;
+        items: {
+            [itemType: string]: {
+                [itemId: number]: {
+                    values?: any;
+                    links?: {
+                        [itemType: string]: number[];
+                    } | undefined;
+                };
+            };
+        };
+    };
+    addSingleItem(itemEntry: ItemEntry, options?: ItemResourceOptionsInterface, isRoot?: boolean, localCache?: LocalCache): ItemResource;
+    addSingleItems(itemEntries: ItemEntry[], options: ItemResourceOptionsInterface): ItemResource[];
+    addCollection(collectionEntry: CollectionEntry, options: CollectionResourceOptionsInterface): CollectionResource;
+    private createItemResources(itemType, itemEntries, options, localCache);
+    processLinkedItems(linkedEntries: LinkedItemEntryMap[], options: ItemOptionsInterface, addToCollections?: boolean): ItemResourcesItemTypeMap;
+    expandProcessLinkedItems(linkedEntries: LinkedItemEntryMap[], options: ItemOptionsInterface): 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;
+    removeFromCollections(itemEntries: ItemEntry[], resultCollectionResource?: CollectionResource): ItemResource[] | null;
+    saveLocal(itemResource: ItemResource): PromiseInterface<ItemResource>;
+    updateItemIdMap(collectionMap: any, conversionMap: any): void;
+    createCollectionResource(collectionEntry: CollectionEntry, resourceOptions: CollectionResourceOptionsInterface): CollectionResource;
+    createItemResource(itemEntry: ItemEntry, options: ItemResourceOptionsInterface, isRoot: boolean): ItemResource;
+    onBeforeSave(key: string, callback: (localCache: LocalCache) => any, condition?: LocalCacheCallbackCondition): () => void;
+    onSaveSuccess(key: string, callback: OnSaveCallback, condition?: LocalCacheCallbackCondition): () => void;
+}

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

@@ -1,22 +1,22 @@
-import { QueryMatcherFactory } from '../factories';
-import { ItemEntry } from '../models';
-import { ItemEntryParentIdMap, ItemId, ItemType } from '../types';
-export declare class ItemCache {
-    private queryMatcherFactory;
-    private entries;
-    constructor(queryMatcherFactory: QueryMatcherFactory);
-    some(callback: (itemEntry: ItemEntry) => boolean): boolean;
-    getByItemType(itemType: ItemType): ItemEntry[];
-    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;
-    get(itemType: ItemType, itemId: ItemId | string): any;
-    contains(itemType: ItemType, itemId: ItemId | string): boolean;
-    updateItemId(itemEntry: ItemEntry, oldItemId: any): ItemEntry;
-    clear(itemEntry: ItemEntry): boolean;
-    matchQuery(itemEntry: ItemEntry, query: any): boolean;
-}
+import { QueryMatcherFactory } from '../factories';
+import { ItemEntry } from '../models';
+import { ItemEntryParentIdMap, ItemId, ItemType } from '../types';
+export declare class ItemCache {
+    private queryMatcherFactory;
+    private entries;
+    constructor(queryMatcherFactory: QueryMatcherFactory);
+    some(callback: (itemEntry: ItemEntry) => boolean): boolean;
+    getByItemType(itemType: ItemType): ItemEntry[];
+    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;
+    get(itemType: ItemType, itemId: ItemId | string): any;
+    contains(itemType: ItemType, itemId: ItemId | string): boolean;
+    updateItemId(itemEntry: ItemEntry, oldItemId: any): ItemEntry;
+    clear(itemEntry: ItemEntry): boolean;
+    matchQuery(itemEntry: ItemEntry, query: any): boolean;
+}

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

@@ -1,24 +1,24 @@
-import { KeyService } from '../classes';
-import { AuthInterface } from '../interfaces';
-import { ItemEntry, ItemEntryOptions } from '../models';
-import { ApiResponse, FieldMap, ItemError, ItemId, ItemIdConversionMap, ItemOptionsInterface, ItemType } from '../types';
-export declare class ItemEntryService {
-    private authInterface;
-    private keyService;
-    constructor(authInterface: AuthInterface, keyService: KeyService);
-    processOptions(options: ItemOptionsInterface): ItemEntryOptions;
-    createUnfoundRemoteItemError(): ItemError;
-    createUnfoundLocalItemError(itemType: ItemType): {
-        message: string;
-    };
-    createLocalConversionMap(itemType: ItemType, itemId: ItemId, doExtend: boolean | undefined, apiResponse: ApiResponse): ItemIdConversionMap;
-    expandLocalConversionMap(parentType: ItemType, parentId: ItemId, apiResponse: ApiResponse, conversionMap: ItemIdConversionMap): void;
-    expandConversionMap(itemEntry: ItemEntry, conversionMap: ItemIdConversionMap, newItemId?: ItemId): any;
-    batchExpandConversionMap(itemEntries: ItemEntry[], conversionMap: ItemIdConversionMap): ItemIdConversionMap;
-    getConversionValue(itemType: any, itemId: any, map: any): any;
-    batchClone(itemEntries: ItemEntry[], conversionMap?: ItemIdConversionMap): ItemEntry[];
-    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;
-}
+import { KeyService } from '../classes';
+import { AuthInterface } from '../interfaces';
+import { ItemEntry, ItemEntryOptions } from '../models';
+import { ApiResponse, FieldMap, ItemError, ItemId, ItemIdConversionMap, ItemOptionsInterface, ItemType } from '../types';
+export declare class ItemEntryService {
+    private authInterface;
+    private keyService;
+    constructor(authInterface: AuthInterface, keyService: KeyService);
+    processOptions(options: ItemOptionsInterface): ItemEntryOptions;
+    createUnfoundRemoteItemError(): ItemError;
+    createUnfoundLocalItemError(itemType: ItemType): {
+        message: string;
+    };
+    createLocalConversionMap(itemType: ItemType, itemId: ItemId, doExtend: boolean | undefined, apiResponse: ApiResponse): ItemIdConversionMap;
+    expandLocalConversionMap(parentType: ItemType, parentId: ItemId, apiResponse: ApiResponse, conversionMap: ItemIdConversionMap): void;
+    expandConversionMap(itemEntry: ItemEntry, conversionMap: ItemIdConversionMap, newItemId?: ItemId): ItemId;
+    batchExpandConversionMap(itemEntries: ItemEntry[], conversionMap: ItemIdConversionMap): ItemIdConversionMap;
+    getConversionValue(itemType: ItemType, itemId: ItemId, map: ItemIdConversionMap): ItemId | undefined;
+    batchClone(itemEntries: ItemEntry[], conversionMap?: ItemIdConversionMap): ItemEntry[];
+    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

@@ -1,60 +1,60 @@
-import { ApiFormatter, ApiResponseProcessor, BatchStatus, ColumnExpansion, ColumnHandler, ColumnInfo, ColumnSubsetCache, ColumnUtil, ItemCache, ItemEntryService, KeyService } from '../classes';
-import { ENTRY_STATUS } from '../constants';
-import { BatchStatusFactory, ColumnExpansionFactory, ColumnSetFactory, ColumnSubsetCacheFactory, ItemCacheFactory, ItemEntryFactory, TemplateFactory } from '../factories';
-import { ApiRequestServiceInterface, ErrorHandlerInterface, PromiseLibraryInterface } from '../interfaces';
-import { ItemEntry, ItemEntryOptions, Template } from '../models';
-import { ApiRequestColumns, ApiResponse, EntryParentNull, EntryStatus, ItemId, ItemIdConversionMap, ItemType, LinkedItemEntryMap, PromiseInterface, ResponseColumnMap, TemplateItemEntryMap } from '../types';
-export declare class ItemHandler {
-    private apiFormatter;
-    private apiRequestService;
-    private batchStatusFactory;
-    private columnExpansionFactory;
-    private columnHandler;
-    private columnSetFactory;
-    private columnSubsetCacheFactory;
-    private columnUtil;
-    private errorHandler;
-    private itemCacheFactory;
-    private itemEntryFactory;
-    private itemEntryService;
-    private keyService;
-    private promiseService;
-    private templateFactory;
-    entries: ItemCache;
-    templates: {
-        [itemType: string]: Template;
-    };
-    constructor(apiFormatter: ApiFormatter, apiRequestService: ApiRequestServiceInterface, batchStatusFactory: BatchStatusFactory, columnExpansionFactory: ColumnExpansionFactory, columnHandler: ColumnHandler, columnSetFactory: ColumnSetFactory, columnSubsetCacheFactory: ColumnSubsetCacheFactory, columnUtil: ColumnUtil, errorHandler: ErrorHandlerInterface, itemCacheFactory: ItemCacheFactory, itemEntryFactory: ItemEntryFactory, itemEntryService: ItemEntryService, keyService: KeyService, promiseService: PromiseLibraryInterface, templateFactory: TemplateFactory);
-    fetchItem(itemType: ItemType, itemId: ItemId, options: ItemEntryOptions, localItemCache: ItemCache): PromiseInterface<ItemEntry>;
-    fetchNewItem(itemType: ItemType, options: ItemEntryOptions, localItemCache: ItemCache): PromiseInterface<TemplateItemEntryMap>;
-    createBatchStatus(itemType: ItemType, itemIds: ItemId[], parent: EntryParentNull, requestColumns: ApiRequestColumns, deferRequest: boolean, localItemCache: ItemCache, addToLocalCache: boolean): {
-        batchStatus: BatchStatus<ItemEntry>;
-        success: boolean;
-    };
-    /**
-     * For every item ID find the status of the ItemEntry and resolve the promises so the result is
-     * a usable ItemEntry
-     */
-    fetchItems(itemType: ItemType, itemIds: ItemId[], options: ItemEntryOptions, localItemCache: ItemCache): PromiseInterface<ItemEntry[]>;
-    handleBatchResponse(batchStatus: BatchStatus<ItemEntry>, localItemCache: ItemCache, requestColumns: ApiRequestColumns, response: ApiResponseProcessor | null, responseColumns: ResponseColumnMap | null, columnExpansion?: ColumnExpansion): PromiseInterface<boolean>;
-    resolveCached(itemEntry: ItemEntry, status: ENTRY_STATUS, options: ItemEntryOptions, localItemCache: ItemCache): PromiseInterface<ItemEntry>;
-    private getColumnDifference;
-    resolveLocal(itemEntry: ItemEntry, parent: EntryParentNull, template: Template, localItemCache: ItemCache): TemplateItemEntryMap;
-    resolveExpansion(itemEntry: ItemEntry, columnExpansion: ColumnExpansion, response: ApiResponse): ItemEntry;
-    private clearItem;
-    private resolveRemote;
-    private resolveRemoteValues;
-    private getResponseFields;
-    fetchTemplate(itemType: ItemType, templateOptions?: any, templateColumns?: any): PromiseInterface<Template>;
-    getEntryStatus(itemType: ItemType, itemId: ItemId, parent: EntryParentNull, deferRequest: boolean, localItemCache: ItemCache, addToLocalCache: boolean, columnSubsetCache: ColumnSubsetCache): EntryStatus<ItemEntry> | null;
-    getCachedEntryStatus(itemEntry: ItemEntry, columnSubsetCache: ColumnSubsetCache): ENTRY_STATUS;
-    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[], requestColumns: ApiRequestColumns, responseColumns: ResponseColumnMap, localItemCache: ItemCache): PromiseInterface<ItemEntry[]>;
-    resolveDerivedValues(itemEntries: ItemEntry[], columns: ColumnInfo[], localItemCache: ItemCache): PromiseInterface<ItemEntry[]>;
-    private setDefaultValuesByColumn;
-    private getItemIdByColumn;
-    private fetchDerivedValuesByColumn;
-    requestItem(itemEntry: ItemEntry, requestColumns?: ApiRequestColumns): PromiseInterface<ApiResponseProcessor>;
-    requestItems(itemType: ItemType, itemIds: ItemId[], columns: ApiRequestColumns): PromiseInterface<ApiResponseProcessor>;
-}
+import { ApiFormatter, ApiResponseProcessor, BatchStatus, ColumnExpansion, ColumnHandler, ColumnInfo, ColumnSubsetCache, ColumnUtil, ItemCache, ItemEntryService, KeyService } from '../classes';
+import { ENTRY_STATUS } from '../constants';
+import { BatchStatusFactory, ColumnExpansionFactory, ColumnSetFactory, ColumnSubsetCacheFactory, ItemCacheFactory, ItemEntryFactory, TemplateFactory } from '../factories';
+import { ApiRequestServiceInterface, ErrorHandlerInterface, PromiseLibraryInterface } from '../interfaces';
+import { ItemEntry, ItemEntryOptions, Template } from '../models';
+import { ApiRequestColumns, ApiResponse, EntryParentNull, EntryStatus, ItemId, ItemIdConversionMap, ItemType, LinkedItemEntryMap, PromiseInterface, ResponseColumnMap, TemplateItemEntryMap } from '../types';
+export declare class ItemHandler {
+    private apiFormatter;
+    private apiRequestService;
+    private batchStatusFactory;
+    private columnExpansionFactory;
+    private columnHandler;
+    private columnSetFactory;
+    private columnSubsetCacheFactory;
+    private columnUtil;
+    private errorHandler;
+    private itemCacheFactory;
+    private itemEntryFactory;
+    private itemEntryService;
+    private keyService;
+    private promiseService;
+    private templateFactory;
+    entries: ItemCache;
+    templates: {
+        [itemType: string]: Template;
+    };
+    constructor(apiFormatter: ApiFormatter, apiRequestService: ApiRequestServiceInterface, batchStatusFactory: BatchStatusFactory, columnExpansionFactory: ColumnExpansionFactory, columnHandler: ColumnHandler, columnSetFactory: ColumnSetFactory, columnSubsetCacheFactory: ColumnSubsetCacheFactory, columnUtil: ColumnUtil, errorHandler: ErrorHandlerInterface, itemCacheFactory: ItemCacheFactory, itemEntryFactory: ItemEntryFactory, itemEntryService: ItemEntryService, keyService: KeyService, promiseService: PromiseLibraryInterface, templateFactory: TemplateFactory);
+    fetchItem(itemType: ItemType, itemId: ItemId, options: ItemEntryOptions, localItemCache: ItemCache): PromiseInterface<ItemEntry>;
+    fetchNewItem(itemType: ItemType, options: ItemEntryOptions, localItemCache: ItemCache): PromiseInterface<TemplateItemEntryMap>;
+    createBatchStatus(itemType: ItemType, itemIds: ItemId[], parent: EntryParentNull, requestColumns: ApiRequestColumns, deferRequest: boolean, localItemCache: ItemCache, addToLocalCache: boolean): {
+        batchStatus: BatchStatus<ItemEntry>;
+        success: boolean;
+    };
+    /**
+     * For every item ID find the status of the ItemEntry and resolve the promises so the result is
+     * a usable ItemEntry
+     */
+    fetchItems(itemType: ItemType, itemIds: ItemId[], options: ItemEntryOptions, localItemCache: ItemCache): PromiseInterface<ItemEntry[]>;
+    handleBatchResponse(batchStatus: BatchStatus<ItemEntry>, localItemCache: ItemCache, requestColumns: ApiRequestColumns, response: ApiResponseProcessor | null, responseColumns: ResponseColumnMap | null, columnExpansion?: ColumnExpansion): PromiseInterface<boolean>;
+    resolveCached(itemEntry: ItemEntry, status: ENTRY_STATUS, options: ItemEntryOptions, localItemCache: ItemCache): PromiseInterface<ItemEntry>;
+    private getColumnDifference(itemEntry, requestColumns);
+    resolveLocal(itemEntry: ItemEntry, parent: EntryParentNull, template: Template, localItemCache: ItemCache): TemplateItemEntryMap;
+    resolveExpansion(itemEntry: ItemEntry, columnExpansion: ColumnExpansion, response: ApiResponse): ItemEntry;
+    private clearItem(itemEntry, localCache);
+    private resolveRemote(itemEntry, columnSet, response, localCache);
+    private resolveRemoteValues(itemEntry, response);
+    private getResponseFields(itemEntry, columnSet, response);
+    fetchTemplate(itemType: ItemType, templateOptions?: any, templateColumns?: any): PromiseInterface<Template>;
+    getEntryStatus(itemType: ItemType, itemId: ItemId, parent: EntryParentNull, deferRequest: boolean, localItemCache: ItemCache, addToLocalCache: boolean, columnSubsetCache: ColumnSubsetCache): EntryStatus<ItemEntry> | null;
+    getCachedEntryStatus(itemEntry: ItemEntry, columnSubsetCache: ColumnSubsetCache): ENTRY_STATUS;
+    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[], requestColumns: ApiRequestColumns, responseColumns: ResponseColumnMap, localItemCache: ItemCache): PromiseInterface<ItemEntry[]>;
+    resolveDerivedValues(itemEntries: ItemEntry[], columns: ColumnInfo[], localItemCache: ItemCache): PromiseInterface<ItemEntry[]>;
+    private setDefaultValuesByColumn(itemEntries, rootColumn);
+    private getItemIdByColumn(itemEntry, column);
+    private fetchDerivedValuesByColumn(itemEntries, rootColumn, localItemCache);
+    requestItem(itemEntry: ItemEntry, requestColumns?: ApiRequestColumns): PromiseInterface<ApiResponseProcessor>;
+    requestItems(itemType: ItemType, itemIds: ItemId[], columns: ApiRequestColumns): PromiseInterface<ApiResponseProcessor>;
+}

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

@@ -1,23 +1,23 @@
-import { ApiResponseProcessor, ColumnExpansion, ColumnSet, ItemHandler, QueryService } from '../classes';
-import { ColumnExpansionFactory, ColumnSetFactory, ItemEntryFactory } from '../factories';
-import { ApiRequestServiceInterface, ErrorHandlerInterface, PromiseLibraryInterface } from '../interfaces';
-import { CollectionEntry, ItemEntry } from '../models';
-import { ApiQuery, ApiRequestColumns, ApiResponse, EntryParentNull, ItemId, ItemType, PromiseInterface } from '../types';
-export declare class ItemRequestService {
-    private apiRequestService;
-    private errorHandler;
-    private itemHandler;
-    private columnExpansionFactory;
-    private columnSetFactory;
-    private itemEntryFactory;
-    private queryService;
-    private promiseService;
-    constructor(apiRequestService: ApiRequestServiceInterface, errorHandler: ErrorHandlerInterface, itemHandler: ItemHandler, columnExpansionFactory: ColumnExpansionFactory, columnSetFactory: ColumnSetFactory, itemEntryFactory: ItemEntryFactory, queryService: QueryService, promiseService: PromiseLibraryInterface);
-    requestItem(itemType: any, itemId: any, columns: any): PromiseInterface<ApiResponseProcessor>;
-    requestItems(collectionEntry: CollectionEntry, query?: ApiQuery, columns?: ApiRequestColumns): PromiseInterface<ApiResponseProcessor>;
-    requestLinkItems(parentType: any, parentIdArray: any, itemType: any, query: any, columns: any): PromiseInterface<ApiResponseProcessor>;
-    processExpansion(requestColumns: ApiRequestColumns, response: ApiResponse, itemType: ItemType, itemEntries: ItemEntry[]): ColumnExpansion;
-    processResponse(response: ApiResponse, idArray: ItemId[], parent: EntryParentNull, columnSet: ColumnSet, columnExpansion?: ColumnExpansion): PromiseInterface<ItemEntry[]>;
-    handleCachedItem(itemEntry: ItemEntry, response: ApiResponse, columnExpansion: ColumnExpansion): ItemEntry;
-    processLinkResponse(response: ApiResponse, parentType: ItemType, parentIdArray: ItemId[], itemType: ItemType, options: any): Promise<any>;
-}
+import { ApiResponseProcessor, ColumnExpansion, ColumnSet, ItemHandler, QueryService } from '../classes';
+import { ColumnExpansionFactory, ColumnSetFactory, ItemEntryFactory } from '../factories';
+import { ApiRequestServiceInterface, ErrorHandlerInterface, PromiseLibraryInterface } from '../interfaces';
+import { CollectionEntry, ItemEntry } from '../models';
+import { ApiQuery, ApiRequestColumns, ApiResponse, EntryParentNull, ItemId, ItemType, PromiseInterface } from '../types';
+export declare class ItemRequestService {
+    private apiRequestService;
+    private errorHandler;
+    private itemHandler;
+    private columnExpansionFactory;
+    private columnSetFactory;
+    private itemEntryFactory;
+    private queryService;
+    private promiseService;
+    constructor(apiRequestService: ApiRequestServiceInterface, errorHandler: ErrorHandlerInterface, itemHandler: ItemHandler, columnExpansionFactory: ColumnExpansionFactory, columnSetFactory: ColumnSetFactory, itemEntryFactory: ItemEntryFactory, queryService: QueryService, promiseService: PromiseLibraryInterface);
+    requestItem(itemType: any, itemId: any, columns: any): PromiseInterface<ApiResponseProcessor>;
+    requestItems(collectionEntry: CollectionEntry, query?: ApiQuery, columns?: ApiRequestColumns): PromiseInterface<ApiResponseProcessor>;
+    requestLinkItems(parentType: any, parentIdArray: any, itemType: any, query: any, columns: any): PromiseInterface<ApiResponseProcessor>;
+    processExpansion(requestColumns: ApiRequestColumns, response: ApiResponse, itemType: ItemType, itemEntries: ItemEntry[]): ColumnExpansion;
+    processResponse(response: ApiResponse, idArray: ItemId[], parent: EntryParentNull, columnSet: ColumnSet, columnExpansion?: ColumnExpansion): PromiseInterface<ItemEntry[]>;
+    handleCachedItem(itemEntry: ItemEntry, response: ApiResponse, columnExpansion: ColumnExpansion): ItemEntry;
+    processLinkResponse(response: ApiResponse, parentType: ItemType, parentIdArray: ItemId[], itemType: ItemType, options: any): Promise<any>;
+}

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

@@ -1,16 +1,16 @@
-import { ItemId, StateKey } from '../types';
-export declare class KeyService {
-    separator: string;
-    constructor();
-    getSingleKey(itemType: string, itemId: number | string): string;
-    getCssKey(): any;
-    parseStateKey(stateKey: string): StateKey | null;
-    getDuplicateStateKey(itemId: string | number): string;
-    getNewStateKey(templateType: string): string;
-    getLocalId(): ItemId;
-    getLocalDuplicateId(): ItemId;
-    getRandomString(): string;
-    isLocalId(itemId: ItemId | string): boolean;
-    isNewId(itemId: ItemId | string): boolean;
-    isDuplicateId(itemId: ItemId | string): boolean;
-}
+import { ItemId, StateKey } from '../types';
+export declare class KeyService {
+    separator: string;
+    constructor();
+    getSingleKey(itemType: string, itemId: number | string): string;
+    getCssKey(): any;
+    parseStateKey(stateKey: string): StateKey | null;
+    getDuplicateStateKey(itemId: string | number): string;
+    getNewStateKey(templateType: string): string;
+    getLocalId(): ItemId;
+    getLocalDuplicateId(): ItemId;
+    getRandomString(): string;
+    isLocalId(itemId: ItemId | string): boolean;
+    isNewId(itemId: ItemId | string): boolean;
+    isDuplicateId(itemId: ItemId | string): boolean;
+}

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

@@ -1,51 +1,51 @@
-import { CollectionCache, ItemCache, LockService } from '../classes';
-import { ChangesProcessorFactory, CollectionCacheFactory, CollectionResourceFactory, ItemCacheFactory, ItemResourceFactory } from '../factories';
-import { ErrorHandlerInterface, PromiseLibraryInterface } from '../interfaces';
-import { CollectionEntry, CollectionResource, CollectionResourceOptionsInterface, ItemEntry, ItemResource } from '../models';
-import { CollectionEntryParentIdMap, CreateRequestParameterMap, ItemIdConversionMap, ItemOptionsInterface, LocalCacheCallbackCondition, OnSaveCallback } from '../types';
-export declare class LocalCache {
-    private errorHandler;
-    private lockService;
-    private itemResourceFactory;
-    private collectionCacheFactory;
-    private changesProcessorFactory;
-    private itemCacheFactory;
-    private collectionResourceFactory;
-    private promiseService;
-    id: string;
-    items: ItemCache;
-    rootItem: ItemEntry | undefined;
-    collections: CollectionCache;
-    deferredCollections: CollectionCache;
-    tabRequestParameters: {};
-    isSaving: boolean;
-    private callbacks;
-    private changesInterval;
-    hasChanges: boolean;
-    constructor(errorHandler: ErrorHandlerInterface, lockService: LockService, itemResourceFactory: ItemResourceFactory, collectionCacheFactory: CollectionCacheFactory, changesProcessorFactory: ChangesProcessorFactory, itemCacheFactory: ItemCacheFactory, collectionResourceFactory: CollectionResourceFactory, promiseService: PromiseLibraryInterface, id?: string);
-    createItemResource(itemEntry: ItemEntry, options: ItemOptionsInterface, isRoot?: boolean, isNew?: boolean): ItemResource;
-    createItemResources(itemEntries: ItemEntry[], options: ItemOptionsInterface): ItemResource[];
-    createCollectionResource(collectionEntry: CollectionEntry, resourceOptions: CollectionResourceOptionsInterface): CollectionResource;
-    createCollectionResources(collectionEntries: CollectionEntryParentIdMap, resourceOptions: CollectionResourceOptionsInterface): {
-        [parentId: string]: CollectionResource;
-    };
-    clearItem(itemResource: ItemResource): void;
-    clearItemEntry(itemEntry: ItemEntry): void;
-    clearCollection(collectionResource: CollectionResource): void;
-    clearResources(isSubTabChange?: boolean): void;
-    updateSingleItems(conversionMap: any): void;
-    revertChanges(): any;
-    resetCollection(collectionEntry: CollectionEntry): void;
-    detectChanges(): boolean;
-    private collectionHasChanges;
-    isLockable(): boolean;
-    save(closeTab?: boolean, parameters?: CreateRequestParameterMap, breakUpByParent?: boolean, onAfterCreateCallback?: (conversionMap: ItemIdConversionMap) => void): any;
-    onBeforeSave(key: string, callback: (localCache: LocalCache) => any, condition?: LocalCacheCallbackCondition): () => void;
-    onSaveSuccess(key: string, callback: OnSaveCallback, condition?: LocalCacheCallbackCondition): () => void;
-    private executeCallbackEvent;
-    private executeCallbacks;
-    enableChangesWatcher(): void;
-    disableChangesWatcher(): void;
-    onDeactivateItem(itemEntry: any): void;
-    onActivateItem(itemEntry: any): void;
-}
+import { CollectionCache, ItemCache, LockService } from '../classes';
+import { ChangesProcessorFactory, CollectionCacheFactory, CollectionResourceFactory, ItemCacheFactory, ItemResourceFactory } from '../factories';
+import { ErrorHandlerInterface, PromiseLibraryInterface } from '../interfaces';
+import { CollectionEntry, CollectionResource, CollectionResourceOptionsInterface, ItemEntry, ItemResource } from '../models';
+import { CollectionEntryParentIdMap, CreateRequestParameterMap, ItemIdConversionMap, ItemOptionsInterface, LocalCacheCallbackCondition, OnSaveCallback } from '../types';
+export declare class LocalCache {
+    private errorHandler;
+    private lockService;
+    private itemResourceFactory;
+    private collectionCacheFactory;
+    private changesProcessorFactory;
+    private itemCacheFactory;
+    private collectionResourceFactory;
+    private promiseService;
+    id: string;
+    items: ItemCache;
+    rootItem: ItemEntry | undefined;
+    collections: CollectionCache;
+    deferredCollections: CollectionCache;
+    tabRequestParameters: {};
+    isSaving: boolean;
+    private callbacks;
+    private changesInterval;
+    hasChanges: boolean;
+    constructor(errorHandler: ErrorHandlerInterface, lockService: LockService, itemResourceFactory: ItemResourceFactory, collectionCacheFactory: CollectionCacheFactory, changesProcessorFactory: ChangesProcessorFactory, itemCacheFactory: ItemCacheFactory, collectionResourceFactory: CollectionResourceFactory, promiseService: PromiseLibraryInterface, id?: string);
+    createItemResource(itemEntry: ItemEntry, options: ItemOptionsInterface, isRoot?: boolean, isNew?: boolean): ItemResource;
+    createItemResources(itemEntries: ItemEntry[], options: ItemOptionsInterface): ItemResource[];
+    createCollectionResource(collectionEntry: CollectionEntry, resourceOptions: CollectionResourceOptionsInterface): CollectionResource;
+    createCollectionResources(collectionEntries: CollectionEntryParentIdMap, resourceOptions: CollectionResourceOptionsInterface): {
+        [parentId: string]: CollectionResource;
+    };
+    clearItem(itemResource: ItemResource): void;
+    clearItemEntry(itemEntry: ItemEntry): void;
+    clearCollection(collectionResource: CollectionResource): void;
+    clearResources(isSubTabChange?: boolean): void;
+    updateSingleItems(conversionMap: any): void;
+    revertChanges(): any;
+    resetCollection(collectionEntry: CollectionEntry): void;
+    detectChanges(): boolean;
+    private collectionHasChanges(collectionEntry);
+    isLockable(): boolean;
+    save(closeTab?: boolean, parameters?: CreateRequestParameterMap, breakUpByParent?: boolean, onAfterCreateCallback?: (conversionMap: ItemIdConversionMap) => void): any;
+    onBeforeSave(key: string, callback: (localCache: LocalCache) => any, condition?: LocalCacheCallbackCondition): () => void;
+    onSaveSuccess(key: string, callback: OnSaveCallback, condition?: LocalCacheCallbackCondition): () => void;
+    private executeCallbackEvent<T>(callbacks, execute, closeTab);
+    private executeCallbacks<T>(callbacks, execute);
+    enableChangesWatcher(): void;
+    disableChangesWatcher(): void;
+    onDeactivateItem(itemEntry: any): void;
+    onActivateItem(itemEntry: any): void;
+}