@rentman/rm-core 1.7.6 → 1.8.0

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

@@ -1,39 +1,39 @@
-import * as moment from 'moment';
-import { ColumnInfo } from '../classes';
-import { FieldMap } from '../types';
-export declare class ApiFormatter {
-    MOMENT_INVALID: string;
-    SERVER_DATETIME_FORMAT: string;
-    SERVER_TIME_FORMAT: string;
-    SERVER_DATE_FORMAT: string;
-    constructor();
-    formatResponse(fields: FieldMap, columns: Array<ColumnInfo<any>>): FieldMap;
-    expandResponse(current: FieldMap, expanded: FieldMap, columns: Array<ColumnInfo<any>>): FieldMap;
-    formatRequest(initial: FieldMap, modified: FieldMap, columns: Array<ColumnInfo<any>>): FieldMap;
-    formatRequestLocal(fields: FieldMap, columns: Array<ColumnInfo<any>>): FieldMap;
-    hasChanges(initial: FieldMap, modified: FieldMap, columns: Array<ColumnInfo<any>>): boolean;
-    getChanges(initial: FieldMap, modified: FieldMap, columns: Array<ColumnInfo<any>>): FieldMap;
-    copyFields(source: FieldMap, destination: FieldMap, columns: Array<ColumnInfo<any>>): FieldMap;
-    shallowCopyFields(shallowSource: FieldMap, deepSource: FieldMap, destination: FieldMap, columns: Array<ColumnInfo<any>>): FieldMap;
-    setDefaultValues(destination: FieldMap, columns: Array<ColumnInfo<any>>): FieldMap;
-    compareFields(columnType: string, first?: any, second?: any): boolean;
-    compareFloats(a: number, b: number): boolean;
-    compareMomentObjects(first: moment.Moment, second: moment.Moment): boolean;
-    compareDurations(first: moment.Duration, second: moment.Duration): boolean;
-    formatResponseValue(columnType: string, value: any): any;
-    formatRequestValue(columnType: string, value: any): any;
-    formatResponseDate(value: null | any): moment.Moment;
-    formatResponseDuration(value: null | number): moment.Duration;
-    formatResponseColor(value: string): string;
-    formatRequestDateTime(value: moment.Moment): string | null;
-    formatRequestDate(value: moment.Moment): string | null;
-    formatRequestDuration(value: moment.Duration): number;
-    formatRequestColor(value: string): string;
-    getDefaultValue(columnType: string): any;
-    isDefaultValue(columnType: string, value: any): boolean;
-    clone(columnType: string, value: any): any;
-    getCloneFunction(columnType: string): ((duration: moment.Duration) => moment.Duration) | ((date: moment.Moment) => moment.Moment);
-    cloneDuration(duration: moment.Duration): moment.Duration;
-    cloneDate(date: moment.Moment): moment.Moment;
-    identity<T>(input: T): T;
-}
+import * as moment from 'moment';
+import { ColumnInfo } from '../classes';
+import { FieldMap } from '../types';
+export declare class ApiFormatter {
+    MOMENT_INVALID: string;
+    SERVER_DATETIME_FORMAT: string;
+    SERVER_TIME_FORMAT: string;
+    SERVER_DATE_FORMAT: string;
+    constructor();
+    formatResponse(fields: FieldMap, columns: Array<ColumnInfo<any>>): FieldMap;
+    expandResponse(current: FieldMap, expanded: FieldMap, columns: Array<ColumnInfo<any>>): FieldMap;
+    formatRequest(initial: FieldMap, modified: FieldMap, columns: Array<ColumnInfo<any>>): FieldMap;
+    formatRequestLocal(fields: FieldMap, columns: Array<ColumnInfo<any>>): FieldMap;
+    hasChanges(initial: FieldMap, modified: FieldMap, columns: Array<ColumnInfo<any>>): boolean;
+    getChanges(initial: FieldMap, modified: FieldMap, columns: Array<ColumnInfo<any>>): FieldMap;
+    copyFields(source: FieldMap, destination: FieldMap, columns: Array<ColumnInfo<any>>): FieldMap;
+    shallowCopyFields(shallowSource: FieldMap, deepSource: FieldMap, destination: FieldMap, columns: Array<ColumnInfo<any>>): FieldMap;
+    setDefaultValues(destination: FieldMap, columns: Array<ColumnInfo<any>>): FieldMap;
+    compareFields(columnType: string, first?: any, second?: any): boolean;
+    compareFloats(a: number, b: number): boolean;
+    compareMomentObjects(first: moment.Moment, second: moment.Moment): boolean;
+    compareDurations(first: moment.Duration, second: moment.Duration): boolean;
+    formatResponseValue(columnType: string, value: any): any;
+    formatRequestValue(columnType: string, value: any): any;
+    formatResponseDate(value: null | any): moment.Moment;
+    formatResponseDuration(value: null | number): moment.Duration;
+    formatResponseColor(value: string): string;
+    formatRequestDateTime(value: moment.Moment): string | null;
+    formatRequestDate(value: moment.Moment): string | null;
+    formatRequestDuration(value: moment.Duration): number;
+    formatRequestColor(value: string): string;
+    getDefaultValue(columnType: string): any;
+    isDefaultValue(columnType: string, value: any): boolean;
+    clone(columnType: string, value: any): any;
+    getCloneFunction(columnType: string): ((duration: moment.Duration) => moment.Duration) | ((date: moment.Moment) => moment.Moment);
+    cloneDuration(duration: moment.Duration): moment.Duration;
+    cloneDate(date: moment.Moment): moment.Moment;
+    identity<T>(input: T): T;
+}

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

@@ -1,20 +1,20 @@
-import { ApiResponseProcessor } from '../classes';
-import { ApiResponseProcessorFactory } from '../factories';
-import { ApiRequestServiceInterface } from '../interfaces';
-import { ApiRequestColumnMap, ApiRequestItemMap, ApiRequestLimit, ItemId, ItemType, PromiseInterface } from '../types';
-export declare class ApiRequestService {
-    private externalApiRequestService;
-    private apiResponseProcessorFactory;
-    constructor(externalApiRequestService: ApiRequestServiceInterface, apiResponseProcessorFactory: ApiResponseProcessorFactory);
-    template(itemType: ItemType, params: any): PromiseInterface<ApiResponseProcessor>;
-    create(itemType: ItemType, itemId: ItemId, values: any, parentType?: ItemType, parentId?: ItemId): PromiseInterface<ApiResponseProcessor>;
-    delete(itemType: ItemType, itemIds: ItemId[]): PromiseInterface<ApiResponseProcessor>;
-    updateItems(itemType: ItemType, items: ApiRequestItemMap, columns: any): PromiseInterface<ApiResponseProcessor>;
-    requestSkeleton(params: any, requestCanceler?: PromiseInterface<any>): PromiseInterface<ApiResponseProcessor>;
-    moveItems(parentType: ItemType, parentId: ItemId, items: {
-        [itemType: string]: ItemId[];
-    }): PromiseInterface<ApiResponseProcessor>;
-    columns(itemType: ItemType, columns: ApiRequestColumnMap, params?: any): PromiseInterface<ApiResponseProcessor>;
-    query(itemType: ItemType, query: any, columns: ApiRequestColumnMap, limit?: ApiRequestLimit): PromiseInterface<ApiResponseProcessor>;
-    processResponse(request: any): PromiseInterface<ApiResponseProcessor>;
-}
+import { ApiResponseProcessor } from '../classes';
+import { ApiResponseProcessorFactory } from '../factories';
+import { ApiRequestServiceInterface } from '../interfaces';
+import { ApiRequestColumnMap, ApiRequestItemMap, ApiRequestLimit, ItemId, ItemType, PromiseInterface } from '../types';
+export declare class ApiRequestService {
+    private externalApiRequestService;
+    private apiResponseProcessorFactory;
+    constructor(externalApiRequestService: ApiRequestServiceInterface, apiResponseProcessorFactory: ApiResponseProcessorFactory);
+    template(itemType: ItemType, params: any): PromiseInterface<ApiResponseProcessor>;
+    create(itemType: ItemType, itemId: ItemId, values: any, parentType?: ItemType, parentId?: ItemId): PromiseInterface<ApiResponseProcessor>;
+    delete(itemType: ItemType, itemIds: ItemId[]): PromiseInterface<ApiResponseProcessor>;
+    updateItems(itemType: ItemType, items: ApiRequestItemMap, columns: any): PromiseInterface<ApiResponseProcessor>;
+    requestSkeleton(params: any, requestCanceler?: PromiseInterface<any>): PromiseInterface<ApiResponseProcessor>;
+    moveItems(parentType: ItemType, parentId: ItemId, items: {
+        [itemType: string]: ItemId[];
+    }): PromiseInterface<ApiResponseProcessor>;
+    columns(itemType: ItemType, columns: ApiRequestColumnMap, params?: any): PromiseInterface<ApiResponseProcessor>;
+    query(itemType: ItemType, query: any, columns: ApiRequestColumnMap, limit?: ApiRequestLimit): PromiseInterface<ApiResponseProcessor>;
+    processResponse(request: any): PromiseInterface<ApiResponseProcessor>;
+}

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

@@ -1,39 +1,39 @@
-import { ApiFormatter } from '../classes';
-import { FieldMap, ItemId, ItemType, ItemTypeMap, ResponseColumn } from '../types';
-export declare class ApiResponseProcessor {
-    apiFormatter: ApiFormatter;
-    response: any;
-    columns: ItemTypeMap;
-    items: {
-        [itemType: string]: {
-            [itemId: number]: any;
-        };
-    };
-    links: ItemTypeMap;
-    cacheable: boolean;
-    map: any;
-    columnIndexMap: any;
-    columnMap: any;
-    constructor(apiFormatter: ApiFormatter, response: any);
-    createColumnMaps(): void;
-    fetchValue(itemType: ItemType, itemId: ItemId, columnId: string): any;
-    fetchDerivedObject(itemType: ItemType, itemId: ItemId, rootColumns: ResponseColumn[]): {};
-    fetchDerivedValues(value: any, column: ResponseColumn, destination: any): void;
-    fetchObject<ItemTypeType extends ItemType>(itemType: ItemTypeType, itemId: string | ItemId, includeLinks?: boolean): FieldMap<ItemTypeType> | undefined;
-    fetchObjectArray<ItemTypeType extends ItemType>(itemType: ItemTypeType, includeLinks?: boolean, idArray?: ItemId[] | null): Array<FieldMap<ItemTypeType>>;
-    fetchObjectMap(itemType: ItemType, columnId: string, includeLinks?: boolean, returnKeys?: boolean): {
-        [key: string]: any;
-    };
-    fetchFieldMap<ItemTypeType extends ItemType>(itemType: ItemTypeType, columnId: string): FieldMap<ItemTypeType>;
-    fetchColumnArray(itemType: ItemType): ResponseColumn[];
-    fetchColumnObject(itemType: ItemType): ResponseColumn;
-    fetchColumnsObject(): {
-        [itemType: string]: ResponseColumn;
-    };
-    createResource<ItemTypeType extends ItemType>(itemType: ItemTypeType, id: ItemId): {
-        object: FieldMap<ItemTypeType> | undefined;
-        links: any;
-    };
-    hasItems(itemType: ItemType): boolean;
-    getIdArray(itemType: ItemType): ItemId[];
-}
+import { ApiFormatter } from '../classes';
+import { FieldMap, ItemId, ItemType, ItemTypeMap, ResponseColumn } from '../types';
+export declare class ApiResponseProcessor {
+    apiFormatter: ApiFormatter;
+    response: any;
+    columns: ItemTypeMap;
+    items: {
+        [itemType: string]: {
+            [itemId: number]: any;
+        };
+    };
+    links: ItemTypeMap;
+    cacheable: boolean;
+    map: any;
+    columnIndexMap: any;
+    columnMap: any;
+    constructor(apiFormatter: ApiFormatter, response: any);
+    createColumnMaps(): void;
+    fetchValue(itemType: ItemType, itemId: ItemId, columnId: string): any;
+    fetchDerivedObject(itemType: ItemType, itemId: ItemId, rootColumns: ResponseColumn[]): {};
+    fetchDerivedValues(value: any, column: ResponseColumn, destination: any): void;
+    fetchObject<ItemTypeType extends ItemType>(itemType: ItemTypeType, itemId: string | ItemId, includeLinks?: boolean): FieldMap<ItemTypeType> | undefined;
+    fetchObjectArray<ItemTypeType extends ItemType>(itemType: ItemTypeType, includeLinks?: boolean, idArray?: ItemId[] | null): Array<FieldMap<ItemTypeType>>;
+    fetchObjectMap(itemType: ItemType, columnId: string, includeLinks?: boolean, returnKeys?: boolean): {
+        [key: string]: any;
+    };
+    fetchFieldMap<ItemTypeType extends ItemType>(itemType: ItemTypeType, columnId: string): FieldMap<ItemTypeType>;
+    fetchColumnArray(itemType: ItemType): ResponseColumn[];
+    fetchColumnObject(itemType: ItemType): ResponseColumn;
+    fetchColumnsObject(): {
+        [itemType: string]: ResponseColumn;
+    };
+    createResource<ItemTypeType extends ItemType>(itemType: ItemTypeType, id: ItemId): {
+        object: FieldMap<ItemTypeType> | undefined;
+        links: any;
+    };
+    hasItems(itemType: ItemType): boolean;
+    getIdArray(itemType: ItemType): ItemId[];
+}

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

@@ -1,28 +1,28 @@
-import { ENTRY_STATUS } from '../constants';
-import { PromiseLibraryInterface } from '../interfaces';
-import { CollectionEntry, ItemEntry } from '../models';
-import { EntryStatus, EntryStatusMap, ItemId, ItemType, PromiseInterface } from '../types';
-export declare class BatchStatus<ItemTypeType extends ItemType, T extends ItemEntry<ItemTypeType> | CollectionEntry<ItemTypeType>> {
-    private promiseService;
-    itemType: ItemTypeType;
-    getItemId: (itemEntry: T) => ItemId;
-    getPromise: (itemEntry: T) => PromiseInterface<T>;
-    readonly requestStatus: ENTRY_STATUS[];
-    readonly remoteExpandStatus: ENTRY_STATUS[];
-    readonly localExpandStatus: ENTRY_STATUS[];
-    entries: EntryStatusMap<T>;
-    constructor(promiseService: PromiseLibraryInterface, itemType: ItemTypeType, 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: (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;
-    };
-}
+import { ENTRY_STATUS } from '../constants';
+import { PromiseLibraryInterface } from '../interfaces';
+import { CollectionEntry, ItemEntry } from '../models';
+import { EntryStatus, EntryStatusMap, ItemId, ItemType, PromiseInterface } from '../types';
+export declare class BatchStatus<ItemTypeType extends ItemType, T extends ItemEntry<ItemTypeType> | CollectionEntry<ItemTypeType>> {
+    private promiseService;
+    itemType: ItemTypeType;
+    getItemId: (itemEntry: T) => ItemId;
+    getPromise: (itemEntry: T) => PromiseInterface<T>;
+    readonly requestStatus: ENTRY_STATUS[];
+    readonly remoteExpandStatus: ENTRY_STATUS[];
+    readonly localExpandStatus: ENTRY_STATUS[];
+    entries: EntryStatusMap<T>;
+    constructor(promiseService: PromiseLibraryInterface, itemType: ItemTypeType, 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: (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/ChangesCompilation.d.ts

@@ -1,51 +1,51 @@
-import { CollectionCache, KeyService } from '../classes';
-import { CollectionCacheFactory } from '../factories';
-import { CollectionEntry, ItemEntry } from '../models';
-import { EntryParent, EntryParentNull, ItemEntryMap, ItemId, ItemType } from '../types';
-export declare type DeleteMapEntry<ItemTypeType extends ItemType> = {
-    item: ItemEntry<ItemTypeType>;
-    parent: EntryParentNull;
-};
-export declare type MoveMapEntry<ItemTypeType extends ItemType> = {
-    item: ItemEntry<ItemTypeType>;
-    parent: EntryParent;
-};
-export declare type CreateCompilation = {
-    [parentType: string]: {
-        [parentId: number]: ItemEntryMap<ItemType>;
-    };
-};
-export declare type DeleteCompilation = {
-    [itemType: string]: Array<ItemEntry<ItemType>>;
-};
-export declare type UpdateCompilation = ItemEntryMap<ItemType>;
-export declare type MoveCompilation = {
-    [parentType: string]: {
-        [parentId: number]: Array<MoveMapEntry<any>>;
-    };
-};
-export declare class ChangesCompilation {
-    private collectionCacheFactory;
-    private keyService;
-    singleItems: Array<ItemEntry<ItemType>>;
-    compilation: {
-        create: CreateCompilation;
-        delete: DeleteCompilation;
-        update: UpdateCompilation;
-        move: MoveCompilation;
-    };
-    collections: CollectionCache;
-    private moveArray;
-    private deleteMap;
-    constructor(collectionCacheFactory: CollectionCacheFactory, keyService: KeyService, singleItems: Array<ItemEntry<ItemType>>, collectionEntries: Array<CollectionEntry<ItemType>>);
-    getDefaultParent(): EntryParent;
-    addMoveEntry(itemEntry: ItemEntry<ItemType>): void;
-    addDeleteEntry(itemEntry: ItemEntry<ItemType>, parent: EntryParentNull): void;
-    addUpdateEntry(itemEntry: ItemEntry<ItemType>): void;
-    addCreateEntry(itemEntry: ItemEntry<ItemType>): void;
-    containsCreateEntry(itemType: ItemType, itemId: ItemId): boolean;
-    private createDeleteCompilation;
-    postProcess(): void;
-    private processSingleItems;
-    private processCollections;
-}
+import { CollectionCache, KeyService } from '../classes';
+import { CollectionCacheFactory } from '../factories';
+import { CollectionEntry, ItemEntry } from '../models';
+import { EntryParent, EntryParentNull, ItemEntryMap, ItemId, ItemType } from '../types';
+export declare type DeleteMapEntry<ItemTypeType extends ItemType> = {
+    item: ItemEntry<ItemTypeType>;
+    parent: EntryParentNull;
+};
+export declare type MoveMapEntry<ItemTypeType extends ItemType> = {
+    item: ItemEntry<ItemTypeType>;
+    parent: EntryParent;
+};
+export declare type CreateCompilation = {
+    [parentType: string]: {
+        [parentId: number]: ItemEntryMap<ItemType>;
+    };
+};
+export declare type DeleteCompilation = {
+    [itemType: string]: Array<ItemEntry<ItemType>>;
+};
+export declare type UpdateCompilation = ItemEntryMap<ItemType>;
+export declare type MoveCompilation = {
+    [parentType: string]: {
+        [parentId: number]: Array<MoveMapEntry<any>>;
+    };
+};
+export declare class ChangesCompilation {
+    private collectionCacheFactory;
+    private keyService;
+    singleItems: Array<ItemEntry<ItemType>>;
+    compilation: {
+        create: CreateCompilation;
+        delete: DeleteCompilation;
+        update: UpdateCompilation;
+        move: MoveCompilation;
+    };
+    collections: CollectionCache;
+    private moveArray;
+    private deleteMap;
+    constructor(collectionCacheFactory: CollectionCacheFactory, keyService: KeyService, singleItems: Array<ItemEntry<ItemType>>, collectionEntries: Array<CollectionEntry<ItemType>>);
+    getDefaultParent(): EntryParent;
+    addMoveEntry(itemEntry: ItemEntry<ItemType>): void;
+    addDeleteEntry(itemEntry: ItemEntry<ItemType>, parent: EntryParentNull): void;
+    addUpdateEntry(itemEntry: ItemEntry<ItemType>): void;
+    addCreateEntry(itemEntry: ItemEntry<ItemType>): void;
+    containsCreateEntry(itemType: ItemType, itemId: ItemId): boolean;
+    private createDeleteCompilation;
+    postProcess(): void;
+    private processSingleItems;
+    private processCollections;
+}

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

@@ -1,33 +1,33 @@
-import { ApiFormatter, CollectionEntryService, CollectionHandler, ItemHandler, MoveMapEntry } from '../classes';
-import { ChangesCompilationFactory, ColumnExpansionFactory, CreateRequestFactory, RequestColumnExpansionFactory } from '../factories';
-import { ApiRequestServiceInterface, ErrorHandlerInterface, PromiseLibraryInterface } from '../interfaces';
-import { CollectionEntry, ItemEntry } from '../models';
-import { ApiRequestMoveItems, CreateRequestParameterMap, ItemId, ItemIdConversionMap, ItemType, PromiseInterface } from '../types';
-export declare class ChangesProcessor {
-    private apiFormatter;
-    private apiRequestService;
-    private changesCompilationFactory;
-    private collectionEntryService;
-    private collectionHandler;
-    private columnExpansionFactory;
-    private createRequestFactory;
-    private errorHandler;
-    private itemHandler;
-    private promiseService;
-    private requestColumnExpansionFactory;
-    constructor(apiFormatter: ApiFormatter, apiRequestService: ApiRequestServiceInterface, changesCompilationFactory: ChangesCompilationFactory, collectionEntryService: CollectionEntryService, collectionHandler: CollectionHandler, columnExpansionFactory: ColumnExpansionFactory, createRequestFactory: CreateRequestFactory, errorHandler: ErrorHandlerInterface, itemHandler: ItemHandler, promiseService: PromiseLibraryInterface, requestColumnExpansionFactory: RequestColumnExpansionFactory);
-    buildMoveRequest(compilationEntries: Array<MoveMapEntry<any>>): ApiRequestMoveItems;
-    getMapValue(itemType: ItemType, itemId: ItemId, map: ItemIdConversionMap): ItemId | undefined;
-    private executeCreateRequests;
-    private executeCreateRequest;
-    private executeUpdateRequests;
-    private executeUpdateRequest;
-    private executeDeleteRequests;
-    private executeDeleteRequest;
-    private executeMoveRequests;
-    private processMoveResponse;
-    private addCollectionMapEntry;
-    private forEachCollection;
-    private onItemsCreated;
-    execute(singleItems: Array<ItemEntry<any>>, collections: Array<CollectionEntry<any>>, parameters?: CreateRequestParameterMap, breakupByParent?: boolean, onAfterCreateCallback?: (conversionMap: ItemIdConversionMap) => void): PromiseInterface<ItemIdConversionMap>;
-}
+import { ApiFormatter, CollectionEntryService, CollectionHandler, ItemHandler, MoveMapEntry } from '../classes';
+import { ChangesCompilationFactory, ColumnExpansionFactory, CreateRequestFactory, RequestColumnExpansionFactory } from '../factories';
+import { ApiRequestServiceInterface, ErrorHandlerInterface, PromiseLibraryInterface } from '../interfaces';
+import { CollectionEntry, ItemEntry } from '../models';
+import { ApiRequestMoveItems, CreateRequestParameterMap, ItemId, ItemIdConversionMap, ItemType, PromiseInterface } from '../types';
+export declare class ChangesProcessor {
+    private apiFormatter;
+    private apiRequestService;
+    private changesCompilationFactory;
+    private collectionEntryService;
+    private collectionHandler;
+    private columnExpansionFactory;
+    private createRequestFactory;
+    private errorHandler;
+    private itemHandler;
+    private promiseService;
+    private requestColumnExpansionFactory;
+    constructor(apiFormatter: ApiFormatter, apiRequestService: ApiRequestServiceInterface, changesCompilationFactory: ChangesCompilationFactory, collectionEntryService: CollectionEntryService, collectionHandler: CollectionHandler, columnExpansionFactory: ColumnExpansionFactory, createRequestFactory: CreateRequestFactory, errorHandler: ErrorHandlerInterface, itemHandler: ItemHandler, promiseService: PromiseLibraryInterface, requestColumnExpansionFactory: RequestColumnExpansionFactory);
+    buildMoveRequest(compilationEntries: Array<MoveMapEntry<any>>): ApiRequestMoveItems;
+    getMapValue(itemType: ItemType, itemId: ItemId, map: ItemIdConversionMap): ItemId | undefined;
+    private executeCreateRequests;
+    private executeCreateRequest;
+    private executeUpdateRequests;
+    private executeUpdateRequest;
+    private executeDeleteRequests;
+    private executeDeleteRequest;
+    private executeMoveRequests;
+    private processMoveResponse;
+    private addCollectionMapEntry;
+    private forEachCollection;
+    private onItemsCreated;
+    execute(singleItems: Array<ItemEntry<any>>, collections: Array<CollectionEntry<any>>, parameters?: CreateRequestParameterMap, breakupByParent?: boolean, onAfterCreateCallback?: (conversionMap: ItemIdConversionMap) => void): PromiseInterface<ItemIdConversionMap>;
+}

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

@@ -1,34 +1,32 @@
-import { CollectionResourceFactory, QueryMatcherFactory } from '../factories';
-import { CollectionEntry, CollectionResource } from '../models';
-import { CollectionMatchResult, CollectionQuery, EntryParentNull, FieldMap, ItemId, ItemType } from '../types';
-export declare class CollectionCache {
-    private collectionResourceFactory;
-    private queryMatcherFactory;
-    private entries;
-    constructor(collectionResourceFactory: CollectionResourceFactory, queryMatcherFactory: QueryMatcherFactory);
-    contains(collectionEntry: CollectionEntry<any>): boolean;
-    some(callback: (entry: CollectionEntry<any>) => boolean): boolean;
-    forEach(callback: (entry: CollectionEntry<any>) => void): void;
-    toArray(): CollectionEntry<any>[];
-    add<T extends CollectionEntry<any>>(collectionEntry: T): T;
-    clear(collectionEntry?: CollectionEntry<any>): boolean;
-    getByItemType<ItemTypeType extends ItemType>(itemType: ItemTypeType): CollectionEntry<ItemTypeType>[];
-    matchParent(collectionEntry: CollectionEntry<any>, itemType: string, itemId: ItemId): boolean;
-    getByParent<ItemTypeType extends ItemType>(parentType: ItemType, parentId: ItemId, itemType: ItemTypeType): CollectionEntry<ItemTypeType> | null;
-    getResourceByParent<ItemTypeType extends ItemType>(parentType: ItemType, parentId: ItemId, itemType: ItemTypeType): CollectionResource<ItemTypeType> | null;
-    getCollectionsByParent(parentType: ItemType, parentId: ItemId): CollectionEntry<any>[];
-    /**
-     * Only resources
-     * @param {String} itemType
-     * @param {String|Integer} itemId
-     * @returns {Object} Array of collections.
-     */
-    getByContainingItem<ItemTypeType extends ItemType>(itemType: ItemTypeType, itemId: ItemId): CollectionEntry<ItemTypeType>[];
-    /**
-     * Returns an array of collections the item 'belongs' in.
-     */
-    getByFittingItem<ItemTypeType extends ItemType>(itemType: ItemTypeType, fields: FieldMap, parent: EntryParentNull): CollectionMatchResult<ItemTypeType>;
-    getByQuery<ItemTypeType extends ItemType>(itemType: ItemTypeType, query: CollectionQuery): CollectionEntry<ItemTypeType> | null;
-    getByKey<ItemTypeType extends ItemType>(itemType: ItemTypeType, entryKey: string): Array<CollectionEntry<ItemTypeType>>;
-    getResourceByKey<ItemTypeType extends ItemType>(itemType: ItemTypeType, resourceKey: string): Array<CollectionResource<ItemTypeType>>;
-}
+import { QueryMatcherFactory } from '../factories';
+import { CollectionEntry, CollectionResource } from '../models';
+import { CollectionMatchResult, CollectionQuery, EntryParentNull, FieldMap, ItemId, ItemType } from '../types';
+export declare class CollectionCache {
+    private queryMatcherFactory;
+    private entries;
+    constructor(queryMatcherFactory: QueryMatcherFactory);
+    contains(collectionEntry: CollectionEntry<any>): boolean;
+    some(callback: (entry: CollectionEntry<any>) => boolean): boolean;
+    forEach(callback: (entry: CollectionEntry<any>) => void): void;
+    toArray(): CollectionEntry<any>[];
+    add<T extends CollectionEntry<any>>(collectionEntry: T): T;
+    clear(collectionEntry?: CollectionEntry<any>): boolean;
+    getByItemType<ItemTypeType extends ItemType>(itemType: ItemTypeType): CollectionEntry<ItemTypeType>[];
+    matchParent(collectionEntry: CollectionEntry<any>, itemType: string, itemId: ItemId): boolean;
+    getByParent<ItemTypeType extends ItemType>(parentType: ItemType, parentId: ItemId, itemType: ItemTypeType): CollectionEntry<ItemTypeType> | null;
+    getResourceByParent<ItemTypeType extends ItemType>(parentType: ItemType, parentId: ItemId, itemType: ItemTypeType): CollectionResource<ItemTypeType> | null;
+    getCollectionsByParent(parentType: ItemType, parentId: ItemId): CollectionEntry<any>[];
+    /**
+     * @description
+     * Gets {@link CollectionEntry CollectionEntries} which contain the item with the passed ItemType/ItemId
+     */
+    getByContainingItem<ItemTypeType extends ItemType>(itemType: ItemTypeType, itemId: ItemId): CollectionEntry<ItemTypeType>[];
+    /**
+     * @description
+     * Checks if the passed fields would fit in the collections using the {@link QueryMatcher QueryMatcher}
+     */
+    getByFittingItem<ItemTypeType extends ItemType>(itemType: ItemTypeType, fields: FieldMap, parent: EntryParentNull): CollectionMatchResult<ItemTypeType>;
+    getByQuery<ItemTypeType extends ItemType>(itemType: ItemTypeType, query: CollectionQuery): CollectionEntry<ItemTypeType> | null;
+    getByKey<ItemTypeType extends ItemType>(itemType: ItemTypeType, entryKey: string): Array<CollectionEntry<ItemTypeType>>;
+    getResourceByKey<ItemTypeType extends ItemType>(itemType: ItemTypeType, resourceKey: string): Array<CollectionResource<ItemTypeType>>;
+}

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

@@ -1,23 +1,22 @@
-import { QueryService } from '../classes';
-import { QueryParserFactory } from '../factories';
-import { CollectionEntryOptions, ItemEntry } from '../models';
-import { CollectionOptionsInterface, CollectionQuery, EntryParentNull, ItemId, ItemType } from '../types';
-export declare class CollectionEntryService {
-    private queryParserFactory;
-    private queryService;
-    constructor(queryParserFactory: QueryParserFactory, queryService: QueryService);
-    cloneOptions(options: CollectionEntryOptions, parent: EntryParentNull): CollectionEntryOptions;
-    processOptions<ItemTypeType extends ItemType>(options: CollectionOptionsInterface<ItemTypeType>): CollectionEntryOptions;
-    cloneQueryParams<T extends object>(parameters: T): T;
-    createQuery(options: CollectionEntryOptions): CollectionQuery;
-    getIdArray(itemEntries: Array<ItemEntry<any>>, accumulator?: ItemId[]): ItemId[];
-    /**
-     * @param {ItemEntry[]} itemEntries
-     * @param {(itemEntry: ItemEntry) => boolean} callback
-     * @returns {ItemEntry[]}
-     *
-     * filter an array according to the callback function. Return the entries that failed the condition
-     * Replace the given array with the entries that didn't fail the condition.
-     */
-    filterArray<T extends ItemEntry<any> = ItemEntry<any>>(itemEntries: T[], callback: (itemEntry: T) => boolean): T[];
-}
+import { QueryService } from '../classes';
+import { QueryParserFactory } from '../factories';
+import { CollectionEntryOptions, ItemEntry } from '../models';
+import { CollectionOptionsInterface, CollectionQuery, EntryParentNull, ItemId, ItemType } from '../types';
+export declare class CollectionEntryService {
+    private queryParserFactory;
+    private queryService;
+    constructor(queryParserFactory: QueryParserFactory, queryService: QueryService);
+    cloneOptions(options: CollectionEntryOptions, parent: EntryParentNull): CollectionEntryOptions;
+    processOptions<ItemTypeType extends ItemType>(options: CollectionOptionsInterface<ItemTypeType>): CollectionEntryOptions;
+    cloneQueryParams<T extends object>(parameters: T): T;
+    createQuery(options: CollectionEntryOptions): CollectionQuery;
+    getIdArray(itemEntries: Array<ItemEntry<any>>, accumulator?: ItemId[]): ItemId[];
+    /**
+     * @description
+     * Filters an array of {@link ItemEntry ItemEntries} according to the callback function.
+     * Does an in-place replacement of the items in the array that do match the condition (keeping the array reference)
+     *
+     * @returns {@link ItemEntry ItemEntries} that failed the condition
+     */
+    filterArray<T extends ItemEntry<any> = ItemEntry<any>>(itemEntries: T[], callback: (itemEntry: T) => boolean): T[];
+}