@rentman/rm-core 1.7.6 → 1.8.0

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

@@ -1,23 +1,23 @@
-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): ItemError;
-    createExistingLocalItemError(itemType: ItemType): ItemError;
-    createLocalConversionMap(itemType: ItemType, itemId: ItemId, doExtend: boolean | undefined, apiResponse: ApiResponse): ItemIdConversionMap;
-    expandLocalConversionMap(parentType: ItemType, parentId: ItemId, apiResponse: ApiResponse, conversionMap: ItemIdConversionMap): void;
-    expandConversionMap(itemEntry: ItemEntry<any>, conversionMap: ItemIdConversionMap, newItemId?: ItemId): ItemId;
-    batchExpandConversionMap(itemEntries: Array<ItemEntry<any>>, conversionMap: ItemIdConversionMap): ItemIdConversionMap;
-    getConversionValue(itemType: ItemType, itemId: ItemId, map: ItemIdConversionMap): ItemId | undefined;
-    batchClone<ItemTypeType extends ItemType>(itemEntries: Array<ItemEntry<ItemTypeType>>, conversionMap?: ItemIdConversionMap): Array<ItemEntry<ItemTypeType>>;
-    getFullName(firstName: string, infix: string, lastName: string): string;
-    getTitleField(itemType: ItemType): string;
-    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): ItemError;
+    createExistingLocalItemError(itemType: ItemType): ItemError;
+    createLocalConversionMap(itemType: ItemType, itemId: ItemId, doExtend: boolean | undefined, apiResponse: ApiResponse): ItemIdConversionMap;
+    expandLocalConversionMap(parentType: ItemType, parentId: ItemId, apiResponse: ApiResponse, conversionMap: ItemIdConversionMap): void;
+    expandConversionMap(itemEntry: ItemEntry<any>, conversionMap: ItemIdConversionMap, newItemId?: ItemId): ItemId;
+    batchExpandConversionMap(itemEntries: Array<ItemEntry<any>>, conversionMap: ItemIdConversionMap): ItemIdConversionMap;
+    getConversionValue(itemType: ItemType, itemId: ItemId, map: ItemIdConversionMap): ItemId | undefined;
+    batchClone<ItemTypeType extends ItemType>(itemEntries: Array<ItemEntry<ItemTypeType>>, conversionMap?: ItemIdConversionMap): Array<ItemEntry<ItemTypeType>>;
+    getFullName(firstName: string, infix: string, lastName: string): string;
+    getTitleField(itemType: ItemType): string;
+    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<any>;
-    };
-    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<ItemTypeType extends ItemType>(itemType: ItemTypeType, itemId: ItemId, options: ItemEntryOptions, localItemCache: ItemCache): PromiseInterface<ItemEntry<ItemTypeType>>;
-    fetchNewItem<ItemTypeType extends ItemType>(itemType: ItemTypeType, itemId: ItemId, options: ItemEntryOptions, localItemCache: ItemCache): PromiseInterface<TemplateItemEntryMap<ItemTypeType>>;
-    createBatchStatus<ItemTypeType extends ItemType>(itemType: ItemTypeType, itemIds: ItemId[], parent: EntryParentNull, requestColumns: ApiRequestColumns, deferRequest: boolean, localItemCache: ItemCache, addToLocalCache: boolean): {
-        batchStatus: BatchStatus<ItemTypeType, ItemEntry<ItemTypeType>>;
-        success: boolean;
-    };
-    /**
-     * For every item ID find the status of the ItemEntry and resolve the promises so the result is
-     * a usable ItemEntry
-     */
-    fetchItems<ItemTypeType extends ItemType>(itemType: ItemTypeType, itemIds: ItemId[], options: ItemEntryOptions, localItemCache: ItemCache): PromiseInterface<Array<ItemEntry<ItemTypeType>>>;
-    handleBatchResponse<ItemTypeType extends ItemType>(batchStatus: BatchStatus<ItemTypeType, ItemEntry<ItemTypeType>>, localItemCache: ItemCache, requestColumns: ApiRequestColumns, response: ApiResponseProcessor | null, responseColumns: ResponseColumnMap | null, columnExpansion?: ColumnExpansion<ItemTypeType>): PromiseInterface<boolean>;
-    resolveCached<ItemTypeType extends ItemType>(itemEntry: ItemEntry<ItemTypeType>, status: ENTRY_STATUS, options: ItemEntryOptions, localItemCache: ItemCache): PromiseInterface<ItemEntry<ItemTypeType>>;
-    private getColumnDifference;
-    resolveLocal<ItemTypeType extends ItemType>(itemEntry: ItemEntry<ItemTypeType>, parent: EntryParentNull, template: Template<ItemTypeType>, localItemCache: ItemCache): TemplateItemEntryMap<ItemTypeType>;
-    resolveExpansion<ItemTypeType extends ItemType>(itemEntry: ItemEntry<ItemTypeType>, columnExpansion: ColumnExpansion<ItemTypeType>, response: ApiResponse): ItemEntry<ItemTypeType>;
-    private clearItem;
-    private resolveRemote;
-    private resolveRemoteValues;
-    private getResponseFields;
-    fetchTemplate<ItemTypeType extends ItemType>(itemType: ItemTypeType, templateOptions?: any, templateColumns?: any): PromiseInterface<Template<ItemTypeType>>;
-    getEntryStatus<ItemTypeType extends ItemType>(itemType: ItemTypeType, itemId: ItemId, parent: EntryParentNull, deferRequest: boolean, localItemCache: ItemCache, addToLocalCache: boolean, columnSubsetCache: ColumnSubsetCache<ItemTypeType>): EntryStatus<ItemEntry<ItemTypeType>> | null;
-    getCachedEntryStatus<ItemTypeType extends ItemType>(itemEntry: ItemEntry<ItemTypeType>, columnSubsetCache: ColumnSubsetCache<ItemTypeType>): ENTRY_STATUS;
-    fetchTitle(itemType: ItemType, itemId: ItemId, deferRequest: boolean | undefined, localItemCache: ItemCache): PromiseInterface<string>;
-    createLocalEntries(parentType: ItemType, localParentId: ItemId, template: Template<ItemType>, itemIdConversion: ItemIdConversionMap, localItemCache: ItemCache, filterItemEntry?: (itemEntry: ItemEntry<ItemType>) => boolean): Array<LinkedItemEntryMap<ItemType>>;
-    expandLocalEntries<ItemTypeType extends ItemType>(itemType: ItemTypeType, itemEntries: Array<ItemEntry<ItemTypeType>>, requestColumns: ApiRequestColumns, responseColumns: ResponseColumnMap, localItemCache: ItemCache): PromiseInterface<Array<ItemEntry<ItemTypeType>>>;
-    resolveDerivedValues<ItemTypeType extends ItemType>(itemEntries: Array<ItemEntry<ItemTypeType>>, columns: Array<ColumnInfo<ItemTypeType>>, localItemCache: ItemCache): PromiseInterface<Array<ItemEntry<ItemTypeType>>>;
-    private setDefaultValuesByColumn;
-    private getItemIdByColumn;
-    private fetchDerivedValuesByColumn;
-    requestItem(itemEntry: ItemEntry<any>, 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, ResponseColumnItemTypeMap, 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<any>;
+    };
+    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<ItemTypeType extends ItemType>(itemType: ItemTypeType, itemId: ItemId, options: ItemEntryOptions, localItemCache: ItemCache): PromiseInterface<ItemEntry<ItemTypeType>>;
+    fetchNewItem<ItemTypeType extends ItemType>(itemType: ItemTypeType, itemId: ItemId, options: ItemEntryOptions, localItemCache: ItemCache): PromiseInterface<TemplateItemEntryMap<ItemTypeType>>;
+    createBatchStatus<ItemTypeType extends ItemType>(itemType: ItemTypeType, itemIds: ItemId[], parent: EntryParentNull, requestColumns: ApiRequestColumns, deferRequest: boolean, localItemCache: ItemCache, addToLocalCache: boolean): {
+        batchStatus: BatchStatus<ItemTypeType, ItemEntry<ItemTypeType>>;
+        success: boolean;
+    };
+    /**
+     * @description
+     * For every {@link ItemEntry.itemId ItemId}, find the status of the {@link ItemEntry ItemEntry} and resolve the promises so the result is a usable {@link ItemEntry ItemEntry}
+     */
+    fetchItems<ItemTypeType extends ItemType>(itemType: ItemTypeType, itemIds: ItemId[], options: ItemEntryOptions, localItemCache: ItemCache): PromiseInterface<Array<ItemEntry<ItemTypeType>>>;
+    handleBatchResponse<ItemTypeType extends ItemType>(batchStatus: BatchStatus<ItemTypeType, ItemEntry<ItemTypeType>>, localItemCache: ItemCache, requestColumns: ApiRequestColumns, response: ApiResponseProcessor | null, responseColumns: ResponseColumnItemTypeMap | null, columnExpansion?: ColumnExpansion<ItemTypeType>): PromiseInterface<boolean>;
+    resolveCached<ItemTypeType extends ItemType>(itemEntry: ItemEntry<ItemTypeType>, status: ENTRY_STATUS, options: ItemEntryOptions, localItemCache: ItemCache): PromiseInterface<ItemEntry<ItemTypeType>>;
+    private getColumnDifference;
+    resolveLocal<ItemTypeType extends ItemType>(itemEntry: ItemEntry<ItemTypeType>, parent: EntryParentNull, template: Template<ItemTypeType>, localItemCache: ItemCache): TemplateItemEntryMap<ItemTypeType>;
+    resolveExpansion<ItemTypeType extends ItemType>(itemEntry: ItemEntry<ItemTypeType>, columnExpansion: ColumnExpansion<ItemTypeType>, response: ApiResponse): ItemEntry<ItemTypeType>;
+    private clearItem;
+    private resolveRemote;
+    private resolveRemoteValues;
+    private getResponseFields;
+    fetchTemplate<ItemTypeType extends ItemType>(itemType: ItemTypeType, templateOptions?: any, templateColumns?: any): PromiseInterface<Template<ItemTypeType>>;
+    getEntryStatus<ItemTypeType extends ItemType>(itemType: ItemTypeType, itemId: ItemId, parent: EntryParentNull, deferRequest: boolean, localItemCache: ItemCache, addToLocalCache: boolean, columnSubsetCache: ColumnSubsetCache<ItemTypeType>): EntryStatus<ItemEntry<ItemTypeType>> | null;
+    getCachedEntryStatus<ItemTypeType extends ItemType>(itemEntry: ItemEntry<ItemTypeType>, columnSubsetCache: ColumnSubsetCache<ItemTypeType>): ENTRY_STATUS;
+    fetchTitle(itemType: ItemType, itemId: ItemId, deferRequest: boolean | undefined, localItemCache: ItemCache): PromiseInterface<string>;
+    createLocalEntries(parentType: ItemType, localParentId: ItemId, template: Template<ItemType>, itemIdConversion: ItemIdConversionMap, localItemCache: ItemCache, filterItemEntry?: (itemEntry: ItemEntry<ItemType>) => boolean): Array<LinkedItemEntryMap<ItemType>>;
+    expandLocalEntries<ItemTypeType extends ItemType>(itemType: ItemTypeType, itemEntries: Array<ItemEntry<ItemTypeType>>, requestColumns: ApiRequestColumns, responseColumns: ResponseColumnItemTypeMap, localItemCache: ItemCache): PromiseInterface<Array<ItemEntry<ItemTypeType>>>;
+    resolveDerivedValues<ItemTypeType extends ItemType>(itemEntries: Array<ItemEntry<ItemTypeType>>, columns: Array<ColumnInfo<ItemTypeType>>, localItemCache: ItemCache): PromiseInterface<Array<ItemEntry<ItemTypeType>>>;
+    private setDefaultValuesByColumn;
+    private getItemIdByColumn;
+    private fetchDerivedValuesByColumn;
+    requestItem(itemEntry: ItemEntry<any>, 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: ItemType, itemId: ItemId, columns: ApiRequestColumns): PromiseInterface<ApiResponseProcessor>;
-    requestItems<ItemTypeType extends ItemType>(collectionEntry: CollectionEntry<ItemTypeType>, query?: ApiQuery, columns?: ApiRequestColumns): PromiseInterface<ApiResponseProcessor>;
-    requestLinkItems(parentType: ItemType, parentIdArray: ItemId[], itemType: ItemType, query: ApiQuery, columns: ApiRequestColumns): PromiseInterface<ApiResponseProcessor>;
-    processExpansion<ItemTypeType extends ItemType>(requestColumns: ApiRequestColumns, response: ApiResponse, itemType: ItemTypeType, itemEntries: Array<ItemEntry<ItemTypeType>>): ColumnExpansion<ItemTypeType>;
-    processResponse<ItemTypeType extends ItemType>(response: ApiResponse, idArray: ItemId[], parent: EntryParentNull, columnSet: ColumnSet<ItemTypeType>, columnExpansion?: ColumnExpansion<ItemTypeType>): PromiseInterface<Array<ItemEntry<ItemTypeType>>>;
-    handleCachedItem<ItemTypeType extends ItemType>(itemEntry: ItemEntry<ItemTypeType>, response: ApiResponse, columnExpansion: ColumnExpansion<ItemTypeType>): ItemEntry<ItemTypeType>;
-    processLinkResponse<ItemTypeType extends ItemType>(response: ApiResponse, parentType: ItemType, parentIdArray: ItemId[], itemType: ItemTypeType, 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: ItemType, itemId: ItemId, columns: ApiRequestColumns): PromiseInterface<ApiResponseProcessor>;
+    requestItems<ItemTypeType extends ItemType>(collectionEntry: CollectionEntry<ItemTypeType>, query?: ApiQuery, columns?: ApiRequestColumns): PromiseInterface<ApiResponseProcessor>;
+    requestLinkItems(parentType: ItemType, parentIdArray: ItemId[], itemType: ItemType, query: ApiQuery, columns: ApiRequestColumns): PromiseInterface<ApiResponseProcessor>;
+    processExpansion<ItemTypeType extends ItemType>(requestColumns: ApiRequestColumns, response: ApiResponse, itemType: ItemTypeType, itemEntries: Array<ItemEntry<ItemTypeType>>): ColumnExpansion<ItemTypeType>;
+    processResponse<ItemTypeType extends ItemType>(response: ApiResponse, idArray: ItemId[], parent: EntryParentNull, columnSet: ColumnSet<ItemTypeType>, columnExpansion?: ColumnExpansion<ItemTypeType>): PromiseInterface<Array<ItemEntry<ItemTypeType>>>;
+    handleCachedItem<ItemTypeType extends ItemType>(itemEntry: ItemEntry<ItemTypeType>, response: ApiResponse, columnExpansion: ColumnExpansion<ItemTypeType>): ItemEntry<ItemTypeType>;
+    processLinkResponse<ItemTypeType extends ItemType>(response: ApiResponse, parentType: ItemType, parentIdArray: ItemId[], itemType: ItemTypeType, 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(...args: any[]): string;
-    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(...args: any[]): string;
+    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,92 +1,112 @@
-import { ChangesProcessor, CollectionCache, ItemCache, LocalCacheCallbackCondition, LocalCacheCallbackType, LockService } from '../classes';
-import { CollectionCacheFactory, CollectionResourceFactory, ItemCacheFactory, ItemResourceFactory } from '../factories';
-import { ErrorHandlerInterface, ExceptionHandlerInterface, PromiseLibraryInterface } from '../interfaces';
-import { CollectionEditResource, CollectionEntry, CollectionResource, CollectionResourceOptionsInterface, CollectionViewResource, EditResource, ItemEntry, ItemResource, LocalViewResource, RemoteViewResource } from '../models';
-import { CollectionEntryParentIdMap, CollectionResourceParentIdMap, CreateRequestParameterMap, ItemIdConversionMap, ItemOptionsInterface, ItemType, PromiseInterface } from '../types';
-export declare class LocalCache {
-    private changesProcessor;
-    private collectionResourceFactory;
-    private errorHandler;
-    private itemResourceFactory;
-    private lockService;
-    private promiseService;
-    id: string;
-    readonly defaultResourceLevel: number;
-    readonly items: ItemCache;
-    readonly collections: CollectionCache;
-    readonly deferredCollections: CollectionCache;
-    rootItem: ItemEntry<any> | undefined;
-    tabRequestParameters: {};
-    isSaving: boolean;
-    private changesInterval;
-    hasChanges: boolean;
-    private eventHandler;
-    constructor(exceptionHandler: ExceptionHandlerInterface, collectionCacheFactory: CollectionCacheFactory, itemCacheFactory: ItemCacheFactory, changesProcessor: ChangesProcessor, collectionResourceFactory: CollectionResourceFactory, errorHandler: ErrorHandlerInterface, itemResourceFactory: ItemResourceFactory, lockService: LockService, promiseService: PromiseLibraryInterface, id: string, defaultResourceLevel: number);
-    createItemResource<ItemTypeType extends ItemType>(itemEntry: ItemEntry<ItemTypeType>, options: ItemOptionsInterface & {
-        edit: true;
-    }, level?: number, isRoot?: boolean, isNew?: boolean): EditResource<ItemTypeType>;
-    createItemResource<ItemTypeType extends ItemType>(itemEntry: ItemEntry<ItemTypeType>, options: ItemOptionsInterface & {
-        remote: true;
-    }, level?: number, isRoot?: boolean, isNew?: boolean): RemoteViewResource<ItemTypeType>;
-    createItemResource<ItemTypeType extends ItemType>(itemEntry: ItemEntry<ItemTypeType>, options: ItemOptionsInterface, level?: number, isRoot?: boolean, isNew?: boolean): LocalViewResource<ItemTypeType>;
-    createItemResources<ItemTypeType extends ItemType>(itemEntries: Array<ItemEntry<ItemTypeType>>, options: ItemOptionsInterface & {
-        edit: true;
-    }, level?: number): Array<EditResource<ItemTypeType>>;
-    createItemResources<ItemTypeType extends ItemType>(itemEntries: Array<ItemEntry<ItemTypeType>>, options: ItemOptionsInterface & {
-        remote: true;
-    }, level?: number): Array<RemoteViewResource<ItemTypeType>>;
-    createItemResources<ItemTypeType extends ItemType>(itemEntries: Array<ItemEntry<ItemTypeType>>, options: ItemOptionsInterface, level?: number): Array<LocalViewResource<ItemTypeType>>;
-    createCollectionResource<ItemTypeType extends ItemType>(collectionEntry: CollectionEntry<ItemTypeType>, resourceOptions: CollectionResourceOptionsInterface<ItemTypeType> & {
-        editItems: true;
-        editCollection: true;
-    }, level?: number): CollectionEditResource<ItemTypeType, EditResource<ItemTypeType>>;
-    createCollectionResource<ItemTypeType extends ItemType>(collectionEntry: CollectionEntry<ItemTypeType>, resourceOptions: CollectionResourceOptionsInterface<ItemTypeType> & {
-        remoteItems: true;
-        editCollection: true;
-    }, level?: number): CollectionEditResource<ItemTypeType, RemoteViewResource<ItemTypeType>>;
-    createCollectionResource<ItemTypeType extends ItemType>(collectionEntry: CollectionEntry<ItemTypeType>, resourceOptions: CollectionResourceOptionsInterface<ItemTypeType> & {
-        editCollection: true;
-    }, level?: number): CollectionEditResource<ItemTypeType, LocalViewResource<ItemTypeType>>;
-    createCollectionResource<ItemTypeType extends ItemType>(collectionEntry: CollectionEntry<ItemTypeType>, resourceOptions: CollectionResourceOptionsInterface<ItemTypeType> & {
-        editItems: true;
-    }, level?: number): CollectionViewResource<ItemTypeType, EditResource<ItemTypeType>>;
-    createCollectionResource<ItemTypeType extends ItemType>(collectionEntry: CollectionEntry<ItemTypeType>, resourceOptions: CollectionResourceOptionsInterface<ItemTypeType> & {
-        remoteItems: true;
-    }, level?: number): CollectionViewResource<ItemTypeType, RemoteViewResource<ItemTypeType>>;
-    createCollectionResource<ItemTypeType extends ItemType>(collectionEntry: CollectionEntry<ItemTypeType>, resourceOptions: CollectionResourceOptionsInterface<ItemTypeType>, level?: number): CollectionViewResource<ItemTypeType, LocalViewResource<ItemTypeType>>;
-    createCollectionResources<ItemTypeType extends ItemType>(collectionEntries: CollectionEntryParentIdMap<ItemTypeType>, resourceOptions: CollectionResourceOptionsInterface<ItemTypeType> & {
-        editItems: true;
-        editCollection: true;
-    }, level?: number): CollectionResourceParentIdMap<CollectionEditResource<ItemTypeType, EditResource<ItemTypeType>>>;
-    createCollectionResources<ItemTypeType extends ItemType>(collectionEntries: CollectionEntryParentIdMap<ItemTypeType>, resourceOptions: CollectionResourceOptionsInterface<ItemTypeType> & {
-        remoteItems: true;
-        editCollection: true;
-    }, level?: number): CollectionResourceParentIdMap<CollectionEditResource<ItemTypeType, RemoteViewResource<ItemTypeType>>>;
-    createCollectionResources<ItemTypeType extends ItemType>(collectionEntries: CollectionEntryParentIdMap<ItemTypeType>, resourceOptions: CollectionResourceOptionsInterface<ItemTypeType> & {
-        editCollection: true;
-    }, level?: number): CollectionResourceParentIdMap<CollectionEditResource<ItemTypeType, LocalViewResource<ItemTypeType>>>;
-    createCollectionResources<ItemTypeType extends ItemType>(collectionEntries: CollectionEntryParentIdMap<ItemTypeType>, resourceOptions: CollectionResourceOptionsInterface<ItemTypeType> & {
-        editItems: true;
-    }, level?: number): CollectionResourceParentIdMap<CollectionViewResource<ItemTypeType, EditResource<ItemTypeType>>>;
-    createCollectionResources<ItemTypeType extends ItemType>(collectionEntries: CollectionEntryParentIdMap<ItemTypeType>, resourceOptions: CollectionResourceOptionsInterface<ItemTypeType> & {
-        remoteItems: true;
-    }, level?: number): CollectionResourceParentIdMap<CollectionViewResource<ItemTypeType, RemoteViewResource<ItemTypeType>>>;
-    createCollectionResources<ItemTypeType extends ItemType>(collectionEntries: CollectionEntryParentIdMap<ItemTypeType>, resourceOptions: CollectionResourceOptionsInterface<ItemTypeType>, level?: number): CollectionResourceParentIdMap<CollectionViewResource<ItemTypeType, LocalViewResource<ItemTypeType>>>;
-    clearItem(itemResource: ItemResource<any>): void;
-    clearItemEntry(itemEntry: ItemEntry<any>): void;
-    clearCollection(collectionResource: CollectionResource<any>): void;
-    clearDeferredCollections(): void;
-    updateSingleItems(conversionMap: ItemIdConversionMap): void;
-    revertChanges(): PromiseInterface<void>;
-    resetCollection(collectionEntry: CollectionEntry<any>): void;
-    detectChanges(): boolean;
-    private collectionHasChanges;
-    isLockable(): boolean;
-    save(closeTab?: boolean, parameters?: CreateRequestParameterMap, breakUpByParent?: boolean, onAfterCreateCallback?: (conversionMap: ItemIdConversionMap) => void): PromiseInterface<ItemIdConversionMap>;
-    onBeforeSave(key: string, callback: LocalCacheCallbackType['onBeforeSave'], condition?: LocalCacheCallbackCondition, priority?: number): () => void;
-    onSaveSuccess(key: string, callback: LocalCacheCallbackType['onSaveSuccess'], condition?: LocalCacheCallbackCondition, priority?: number): () => void;
-    enableChangesWatcher(): void;
-    disableChangesWatcher(): void;
-    onDeactivateItem(itemEntry: ItemEntry<any>): void;
-    onActivateItem(itemEntry: ItemEntry<any>): void;
-}
+import { ChangesProcessor, CollectionCache, ItemCache, LocalCacheCallbackCondition, LocalCacheCallbackType, LockService } from '../classes';
+import { CollectionCacheFactory, CollectionResourceFactory, ItemCacheFactory, ItemResourceFactory } from '../factories';
+import { ErrorHandlerInterface, ExceptionHandlerInterface, PromiseLibraryInterface } from '../interfaces';
+import { CollectionEditResource, CollectionEntry, CollectionResource, CollectionResourceOptionsInterface, CollectionViewResource, EditResource, ItemEntry, ItemResource, LocalViewResource, RemoteViewResource } from '../models';
+import { CollectionEntryParentIdMap, CollectionResourceParentIdMap, CreateRequestParameterMap, ItemIdConversionMap, ItemOptionsInterface, ItemType, PromiseInterface } from '../types';
+/**
+ * @description
+ * The {@link LocalCache LocalCache} is responsible for keeping track of {@link ItemEntry ItemEntries} and {@link CollectionEntry CollectionEntries} which might have changes
+ * in order to save them efficiently.
+ *
+ * @remarks
+ * - Local entries are *not* stored in the global cache until they are saved.
+ * - Remote entries *are* stored in the global cache, and can also be stored in the LocalCache.
+ */
+export declare class LocalCache {
+    private changesProcessor;
+    private collectionResourceFactory;
+    private errorHandler;
+    private itemResourceFactory;
+    private lockService;
+    private promiseService;
+    id: string;
+    readonly items: ItemCache;
+    readonly collections: CollectionCache;
+    readonly deferredCollections: CollectionCache;
+    rootItem: ItemEntry<any> | undefined;
+    tabRequestParameters: {};
+    isSaving: boolean;
+    private changesInterval;
+    hasChanges: boolean;
+    private eventHandler;
+    constructor(exceptionHandler: ExceptionHandlerInterface, collectionCacheFactory: CollectionCacheFactory, itemCacheFactory: ItemCacheFactory, changesProcessor: ChangesProcessor, collectionResourceFactory: CollectionResourceFactory, errorHandler: ErrorHandlerInterface, itemResourceFactory: ItemResourceFactory, lockService: LockService, promiseService: PromiseLibraryInterface, id: string);
+    createItemResource<ItemTypeType extends ItemType>(itemEntry: ItemEntry<ItemTypeType>, options: ItemOptionsInterface & {
+        edit: true;
+    }, isRoot?: boolean, isNew?: boolean): EditResource<ItemTypeType>;
+    createItemResource<ItemTypeType extends ItemType>(itemEntry: ItemEntry<ItemTypeType>, options: ItemOptionsInterface & {
+        remote: true;
+    }, isRoot?: boolean, isNew?: boolean): RemoteViewResource<ItemTypeType>;
+    createItemResource<ItemTypeType extends ItemType>(itemEntry: ItemEntry<ItemTypeType>, options: ItemOptionsInterface, isRoot?: boolean, isNew?: boolean): LocalViewResource<ItemTypeType>;
+    createItemResources<ItemTypeType extends ItemType>(itemEntries: Array<ItemEntry<ItemTypeType>>, options: ItemOptionsInterface & {
+        edit: true;
+    }): Array<EditResource<ItemTypeType>>;
+    createItemResources<ItemTypeType extends ItemType>(itemEntries: Array<ItemEntry<ItemTypeType>>, options: ItemOptionsInterface & {
+        remote: true;
+    }): Array<RemoteViewResource<ItemTypeType>>;
+    createItemResources<ItemTypeType extends ItemType>(itemEntries: Array<ItemEntry<ItemTypeType>>, options: ItemOptionsInterface): Array<LocalViewResource<ItemTypeType>>;
+    createCollectionResource<ItemTypeType extends ItemType>(collectionEntry: CollectionEntry<ItemTypeType>, resourceOptions: CollectionResourceOptionsInterface<ItemTypeType> & {
+        editItems: true;
+        editCollection: true;
+    }): CollectionEditResource<ItemTypeType, EditResource<ItemTypeType>>;
+    createCollectionResource<ItemTypeType extends ItemType>(collectionEntry: CollectionEntry<ItemTypeType>, resourceOptions: CollectionResourceOptionsInterface<ItemTypeType> & {
+        remoteItems: true;
+        editCollection: true;
+    }): CollectionEditResource<ItemTypeType, RemoteViewResource<ItemTypeType>>;
+    createCollectionResource<ItemTypeType extends ItemType>(collectionEntry: CollectionEntry<ItemTypeType>, resourceOptions: CollectionResourceOptionsInterface<ItemTypeType> & {
+        editCollection: true;
+    }): CollectionEditResource<ItemTypeType, LocalViewResource<ItemTypeType>>;
+    createCollectionResource<ItemTypeType extends ItemType>(collectionEntry: CollectionEntry<ItemTypeType>, resourceOptions: CollectionResourceOptionsInterface<ItemTypeType> & {
+        editItems: true;
+    }): CollectionViewResource<ItemTypeType, EditResource<ItemTypeType>>;
+    createCollectionResource<ItemTypeType extends ItemType>(collectionEntry: CollectionEntry<ItemTypeType>, resourceOptions: CollectionResourceOptionsInterface<ItemTypeType> & {
+        remoteItems: true;
+    }): CollectionViewResource<ItemTypeType, RemoteViewResource<ItemTypeType>>;
+    createCollectionResource<ItemTypeType extends ItemType>(collectionEntry: CollectionEntry<ItemTypeType>, resourceOptions: CollectionResourceOptionsInterface<ItemTypeType>): CollectionViewResource<ItemTypeType, LocalViewResource<ItemTypeType>>;
+    createCollectionResources<ItemTypeType extends ItemType>(collectionEntries: CollectionEntryParentIdMap<ItemTypeType>, resourceOptions: CollectionResourceOptionsInterface<ItemTypeType> & {
+        editItems: true;
+        editCollection: true;
+    }): CollectionResourceParentIdMap<CollectionEditResource<ItemTypeType, EditResource<ItemTypeType>>>;
+    createCollectionResources<ItemTypeType extends ItemType>(collectionEntries: CollectionEntryParentIdMap<ItemTypeType>, resourceOptions: CollectionResourceOptionsInterface<ItemTypeType> & {
+        remoteItems: true;
+        editCollection: true;
+    }): CollectionResourceParentIdMap<CollectionEditResource<ItemTypeType, RemoteViewResource<ItemTypeType>>>;
+    createCollectionResources<ItemTypeType extends ItemType>(collectionEntries: CollectionEntryParentIdMap<ItemTypeType>, resourceOptions: CollectionResourceOptionsInterface<ItemTypeType> & {
+        editCollection: true;
+    }): CollectionResourceParentIdMap<CollectionEditResource<ItemTypeType, LocalViewResource<ItemTypeType>>>;
+    createCollectionResources<ItemTypeType extends ItemType>(collectionEntries: CollectionEntryParentIdMap<ItemTypeType>, resourceOptions: CollectionResourceOptionsInterface<ItemTypeType> & {
+        editItems: true;
+    }): CollectionResourceParentIdMap<CollectionViewResource<ItemTypeType, EditResource<ItemTypeType>>>;
+    createCollectionResources<ItemTypeType extends ItemType>(collectionEntries: CollectionEntryParentIdMap<ItemTypeType>, resourceOptions: CollectionResourceOptionsInterface<ItemTypeType> & {
+        remoteItems: true;
+    }): CollectionResourceParentIdMap<CollectionViewResource<ItemTypeType, RemoteViewResource<ItemTypeType>>>;
+    createCollectionResources<ItemTypeType extends ItemType>(collectionEntries: CollectionEntryParentIdMap<ItemTypeType>, resourceOptions: CollectionResourceOptionsInterface<ItemTypeType>): CollectionResourceParentIdMap<CollectionViewResource<ItemTypeType, LocalViewResource<ItemTypeType>>>;
+    /**
+     * @description
+     * Removes an {@link ItemEntry ItemEntry} through an {@link ItemResource ItemResource} from the {@link LocalCache LocalCache} which means that changes on this entry will no longer be tracked.
+     */
+    clearItem(itemResource: ItemResource<any>): void;
+    /**
+     * @description
+     * Removes an {@link ItemEntry ItemEntry} from the {@link LocalCache LocalCache} which means that changes on this entry will no longer be tracked.
+     */
+    clearItemEntry(itemEntry: ItemEntry<any>): void;
+    /**
+     * @description
+     * Removes a {@link CollectionEntry CollectionEntry} through a {@link CollectionResource CollectionResource} from the {@link LocalCache LocalCache} which means that changes on this collection will no longer be tracked.
+     */
+    clearCollection(collectionResource: CollectionResource<any>): void;
+    clearDeferredCollections(): void;
+    updateSingleItems(conversionMap: ItemIdConversionMap): void;
+    revertChanges(): PromiseInterface<void>;
+    resetCollection(collectionEntry: CollectionEntry<any>): void;
+    detectChanges(): boolean;
+    private collectionHasChanges;
+    isLockable(): boolean;
+    save(closeTab?: boolean, parameters?: CreateRequestParameterMap, breakUpByParent?: boolean, onAfterCreateCallback?: (conversionMap: ItemIdConversionMap) => void): PromiseInterface<ItemIdConversionMap>;
+    onBeforeSave(key: string, callback: LocalCacheCallbackType['onBeforeSave'], condition?: LocalCacheCallbackCondition, priority?: number): () => void;
+    onSaveSuccess(key: string, callback: LocalCacheCallbackType['onSaveSuccess'], condition?: LocalCacheCallbackCondition, priority?: number): () => void;
+    enableChangesWatcher(): void;
+    disableChangesWatcher(): void;
+    onDeactivateItem(itemEntry: ItemEntry<any>): void;
+    onActivateItem(itemEntry: ItemEntry<any>): void;
+}

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

@@ -1,19 +1,19 @@
-import { LocalCache } from '../classes';
-import { ErrorHandlerInterface, ExceptionHandlerInterface, PromiseLibraryInterface } from '../interfaces';
-import { ItemIdConversionMap, PromiseInterface } from '../types';
-export declare type LocalCacheCallbackCondition = 'always' | 'onClose' | 'skipOnClose';
-export declare type LocalCacheCallbackType = {
-    onBeforeSave: (localCache: LocalCache) => any;
-    onSaveSuccess: (localCache: LocalCache, conversionMap: ItemIdConversionMap) => any;
-};
-export declare class LocalCacheEventHandler {
-    private errorHandler;
-    private exceptionHandler;
-    private promiseService;
-    private callbacks;
-    constructor(errorHandler: ErrorHandlerInterface, exceptionHandler: ExceptionHandlerInterface, promiseService: PromiseLibraryInterface);
-    registerCallback<T extends keyof LocalCacheCallbackType>(type: T, key: string, callback: LocalCacheCallbackType[T], condition?: LocalCacheCallbackCondition, priority?: number): () => void;
-    executeCallbacks<T extends keyof LocalCacheCallbackType>(type: T, execute: (callback: LocalCacheCallbackType[T]) => any, closeTab: boolean): PromiseInterface<any>;
-    private getPriorityLevel;
-    private executeCallbacksPriorityLevel;
-}
+import { LocalCache } from '../classes';
+import { ErrorHandlerInterface, ExceptionHandlerInterface, PromiseLibraryInterface } from '../interfaces';
+import { ItemIdConversionMap, PromiseInterface } from '../types';
+export declare type LocalCacheCallbackCondition = 'always' | 'onClose' | 'skipOnClose';
+export declare type LocalCacheCallbackType = {
+    onBeforeSave: (localCache: LocalCache) => any;
+    onSaveSuccess: (localCache: LocalCache, conversionMap: ItemIdConversionMap) => any;
+};
+export declare class LocalCacheEventHandler {
+    private errorHandler;
+    private exceptionHandler;
+    private promiseService;
+    private callbacks;
+    constructor(errorHandler: ErrorHandlerInterface, exceptionHandler: ExceptionHandlerInterface, promiseService: PromiseLibraryInterface);
+    registerCallback<T extends keyof LocalCacheCallbackType>(type: T, key: string, callback: LocalCacheCallbackType[T], condition?: LocalCacheCallbackCondition, priority?: number): () => void;
+    executeCallbacks<T extends keyof LocalCacheCallbackType>(type: T, execute: (callback: LocalCacheCallbackType[T]) => any, closeTab: boolean): PromiseInterface<any>;
+    private getPriorityLevel;
+    private executeCallbacksPriorityLevel;
+}

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

@@ -1,32 +1,32 @@
-import { KeyService } from '../classes';
-import { ApiRequestServiceInterface, ErrorHandlerInterface, PromiseLibraryInterface } from '../interfaces';
-import { ItemEntry } from '../models';
-import { ItemId, ItemMap, PromiseInterface } from '../types';
-export declare type LockToken = {
-    isForeign: false;
-    id: number;
-    token: string;
-} | {
-    isForeign: true;
-    message: string;
-};
-export declare class LockService {
-    private apiRequestService;
-    private errorHandler;
-    private keyService;
-    private promiseService;
-    lockItems: ItemMap<LockToken>;
-    promises: ItemMap<PromiseInterface<LockToken>>;
-    constructor(apiRequestService: ApiRequestServiceInterface, errorHandler: ErrorHandlerInterface, keyService: KeyService, promiseService: PromiseLibraryInterface);
-    private getValue;
-    private setValue;
-    getLocks(): this['lockItems'];
-    hasLock(lockTokenId: ItemId): boolean;
-    isLocked(itemEntry: ItemEntry<any>): boolean;
-    getMessage(itemEntry: ItemEntry<any>): undefined | string;
-    fetchCachedLock(itemEntry: ItemEntry<any>): PromiseInterface<undefined | LockToken>;
-    fetchLock(itemEntry: ItemEntry<any>): PromiseInterface<string>;
-    requestLock(itemEntry: ItemEntry<any>): PromiseInterface<LockToken>;
-    deleteLock(itemEntry: ItemEntry<any>): PromiseInterface<void>;
-    clearLock(itemEntry: ItemEntry<any>): boolean;
-}
+import { KeyService } from '../classes';
+import { ApiRequestServiceInterface, ErrorHandlerInterface, PromiseLibraryInterface } from '../interfaces';
+import { ItemEntry } from '../models';
+import { ItemId, ItemMap, PromiseInterface } from '../types';
+export declare type LockToken = {
+    isForeign: false;
+    id: number;
+    token: string;
+} | {
+    isForeign: true;
+    message: string;
+};
+export declare class LockService {
+    private apiRequestService;
+    private errorHandler;
+    private keyService;
+    private promiseService;
+    lockItems: ItemMap<LockToken>;
+    promises: ItemMap<PromiseInterface<LockToken>>;
+    constructor(apiRequestService: ApiRequestServiceInterface, errorHandler: ErrorHandlerInterface, keyService: KeyService, promiseService: PromiseLibraryInterface);
+    private getValue;
+    private setValue;
+    getLocks(): this['lockItems'];
+    hasLock(lockTokenId: ItemId): boolean;
+    isLocked(itemEntry: ItemEntry<any>): boolean;
+    getMessage(itemEntry: ItemEntry<any>): undefined | string;
+    fetchCachedLock(itemEntry: ItemEntry<any>): PromiseInterface<undefined | LockToken>;
+    fetchLock(itemEntry: ItemEntry<any>): PromiseInterface<string>;
+    requestLock(itemEntry: ItemEntry<any>): PromiseInterface<LockToken>;
+    deleteLock(itemEntry: ItemEntry<any>): PromiseInterface<void>;
+    clearLock(itemEntry: ItemEntry<any>): boolean;
+}