@rentman/rm-core 1.9.0 → 2.0.1

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

@@ -1,19 +1,36 @@
 import * as moment from 'moment';
 import { ColumnInfo } from '../classes';
-import { FieldMap } from '../types';
+import { FieldMap, ItemType, ResponseColumn } 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;
+    /**
+     * @description
+     * Returns if a column type is an 'expensive' type, meaning that the action to format the field takes significant CPU time
+     *
+     * ----
+     * @remarks
+     * Currently only used for Moment objects
+     */
+    isExpensiveFormat(columnType: string): boolean;
+    /**
+     * @description
+     * Overwrites the values in 'changes' if the values in 'initial' and 'changes' are the same (leaving user changes intact)
+     */
+    mergeCopyFields<ItemTypeType extends ItemType>(initial: FieldMap<ItemTypeType>, changes: FieldMap<ItemTypeType>, newInitial: FieldMap<ItemTypeType>, columns: Array<ColumnInfo<ItemTypeType>>): FieldMap<ItemTypeType>;
+    /**
+     * @description
+     * Clones the fields from `source` to `destination`, calls {@link ApiFormatter.isExpensiveFormat isExpensiveFormat} to determine if values should immediately be cloned, or the getter should be cloned
+     */
+    lazyClone(apiColumn: ResponseColumn, source: object, destination: object, key: string): void;
+    formatRequest<ItemTypeType extends ItemType>(initial: FieldMap<ItemTypeType>, modified: FieldMap<ItemTypeType>, columns: Array<ColumnInfo<any>>): FieldMap<ItemTypeType>;
+    formatRequestLocal<ItemTypeType extends ItemType>(fields: FieldMap<ItemTypeType>, columns: Array<ColumnInfo<any>>): FieldMap<ItemTypeType>;
+    hasChanges(initial: FieldMap, modified: FieldMap, columns: Array<ColumnInfo<any>>, includeReadOnlyColumns?: boolean): boolean;
+    getChanges<ItemTypeType extends ItemType>(initial: FieldMap<ItemTypeType>, modified: FieldMap<ItemTypeType>, columns: Array<ColumnInfo<any>>): FieldMap<ItemTypeType>;
+    copyFields<ItemTypeType extends ItemType>(source: FieldMap<ItemTypeType>, destination: FieldMap<ItemTypeType>, columns: Array<ColumnInfo<any>>): FieldMap<ItemTypeType>;
     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;

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

@@ -3,37 +3,27 @@ import { FieldMap, ItemId, ItemType, ItemTypeMap, ResponseColumn } from '../type
 export declare class ApiResponseProcessor {
     apiFormatter: ApiFormatter;
     response: any;
-    columns: ItemTypeMap;
-    items: {
+    columns: ItemTypeMap<ResponseColumn[]>;
+    links: ItemTypeMap<ItemId[]>;
+    cacheable: boolean;
+    map: any;
+    items: any;
+    columnIndexMap: {
         [itemType: string]: {
-            [itemId: number]: any;
+            [columnId: string]: number;
         };
     };
-    links: ItemTypeMap;
-    cacheable: boolean;
-    map: any;
-    columnIndexMap: any;
     columnMap: any;
     constructor(apiFormatter: ApiFormatter, response: any);
-    createColumnMaps(): void;
+    private createColumnMaps;
+    fetchColumnObject(itemType: ItemType): ResponseColumn;
     fetchValue(itemType: ItemType, itemId: ItemId, columnId: string): any;
+    fetchColumnArray(itemType: ItemType): ResponseColumn[];
     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/ChangesCompilation.d.ts

@@ -1,18 +1,10 @@
-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;
-};
+import { ItemEntry } from '../models';
+import { ItemEntryMap, ItemMap, ItemType } from '../types';
+import { TransactionCache } from './cache/transaction/TransactionCache';
+import { InternalCreateDelta } from './InternalChangesDelta';
 export declare type CreateCompilation = {
     [parentType: string]: {
-        [parentId: number]: ItemEntryMap<ItemType>;
+        [parentId: number]: ItemMap<InternalCreateDelta>;
     };
 };
 export declare type DeleteCompilation = {
@@ -21,31 +13,22 @@ export declare type DeleteCompilation = {
 export declare type UpdateCompilation = ItemEntryMap<ItemType>;
 export declare type MoveCompilation = {
     [parentType: string]: {
-        [parentId: number]: Array<MoveMapEntry<any>>;
+        [parentId: number]: ItemEntry[];
     };
 };
 export declare class ChangesCompilation {
-    private collectionCacheFactory;
-    private keyService;
-    singleItems: Array<ItemEntry<ItemType>>;
+    private transaction;
     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;
+    constructor(transaction: TransactionCache);
+    private processDelta;
+    private getDefaultParent;
+    private addMoveEntry;
+    private addDeleteEntry;
+    private addUpdateEntry;
+    private addCreateEntry;
 }

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

@@ -0,0 +1,42 @@
+import { ItemEntry } from '../models';
+import { EntryParent, EntryParentNull, FieldMap, ItemId, ItemType } from '../types';
+import { ChangesDeltaBase } from './ChangesDeltaBase';
+import { ColumnSet } from './ColumnSet';
+import { ItemEntryService } from './ItemEntryService';
+export declare type ChangesDeltaItemCreateDelta<ItemTypeType extends ItemType = any> = {
+    itemId: ItemId;
+    fields: FieldMap<ItemTypeType>;
+    columns: ColumnSet<ItemTypeType>;
+};
+/**
+ * @description
+ * ChangesDelta used to apply changes from outside of the core to a transaction
+ *
+ * ----------
+ *
+ * The difference between {@link InternalChangesDelta InternalChangesDelta} and {@link ChangesDelta ChangesDelta} is that the ChangesDelta
+ * assumes 'created' values have no itemEntries yet.
+ *
+ * Use this when calling {@link TransactionCache.applyChangesDelta applyChangesDelta}
+ */
+export declare class ChangesDelta extends ChangesDeltaBase {
+    created: ChangesDeltaItemCreateDelta[];
+    constructor(itemEntryService: ItemEntryService);
+    /**
+     * @description
+     * Will create an {@link ItemEntry ItemEntry} when the delta is applied
+     * Does not always mean the item is local, just that it isn't cached yet
+     *
+     * ------
+     *
+     * @remark
+     * When the `parent` property is passed it will automatically set the proper fields to match the parent, this assumes the required parent columns are in the passed columns
+     * You can easily get the required columns by also passing the `parent` to the {@link TemplateCache.fetchTemplate template fetchCollectionEntry} call
+     */
+    setItemCreated<ItemTypeType extends ItemType>(itemId: ItemId, fields: FieldMap<ItemTypeType>, columns: ColumnSet<ItemTypeType>, parent?: EntryParentNull): void;
+    /**
+     * @description
+     * Convenience function to assign the proper parent fields, will call {@link ChangesDeltaBase.setItemUpdated setItemUpdated} internally
+     */
+    setItemMoved(entry: ItemEntry, to: EntryParent): void;
+}

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

@@ -0,0 +1,33 @@
+import { ItemEntry } from '../models';
+import { ColumnExpansionResult, EntryParentNull, FieldMap, ItemType } from '../types';
+import { ItemEntryService } from './ItemEntryService';
+export declare type ChangesDeltaResult = {
+    rollback: () => void;
+    created: ItemEntry[];
+};
+/**
+ * @remark
+ * We explicitly keep track of the new parent, so we can set an item to moved if it isn't null (Needed for linkTo request)
+ */
+export declare type ChangesDeltaItemUpdateDelta<ItemTypeType extends ItemType = any> = {
+    entry: ItemEntry<ItemTypeType>;
+    changes: {
+        expandedColumns: ColumnExpansionResult<ItemTypeType> | null;
+        fields: FieldMap<ItemTypeType>;
+        parent: EntryParentNull;
+    };
+};
+export declare type ChangesDeltaItemDeleteDelta = ItemEntry[];
+export declare abstract class ChangesDeltaBase {
+    protected itemEntryService: ItemEntryService;
+    updated: {
+        [itemEntryId: number]: ChangesDeltaItemUpdateDelta;
+    };
+    deleted: {
+        [itemType: string]: ChangesDeltaItemDeleteDelta;
+    };
+    protected constructor(itemEntryService: ItemEntryService);
+    setItemUpdated<ItemEntryType extends ItemEntry>(entry: ItemEntryType, fields: FieldMap<ItemEntryType['itemType']>, columnExpansionResult?: ColumnExpansionResult<ItemEntryType['itemType']> | null, parent?: EntryParentNull): void;
+    setItemDeleted(deleted: ItemEntry): void;
+    setItemsDeleted(deleted: ItemEntry[]): void;
+}

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

@@ -1,23 +1,42 @@
-import { ApiFormatter, CollectionEntryService, CollectionHandler, ItemHandler, MoveMapEntry } from '../classes';
+import { ApiRequestService, CollectionEntryService, ItemEntryService } 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';
+import { ChangesDeltaFactory } from '../factories/ChangesDeltaFactory';
+import { ErrorHandlerInterface, PromiseLibraryInterface } from '../interfaces';
+import { ItemIdConversionMap, PromiseInterface } from '../types';
+import { TransactionCache } from './cache/transaction/TransactionCache';
+export declare type OnAfterCreateCallback = (conversionMap: ItemIdConversionMap) => void;
+/**
+ * @description
+ * Executes the changes from a specific {@link TransactionCache transaction} and returns a {@link ChangesDelta ChangesDelta}
+ */
 export declare class ChangesProcessor {
-    private apiFormatter;
+    private changesDeltaFactory;
     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 collectionEntryService;
+    private itemEntryService;
+    private transaction;
+    private breakUpByParent?;
+    private onAfterCreateCallback?;
+    private itemIdConversionMap;
+    private serverCache;
+    constructor(changesDeltaFactory: ChangesDeltaFactory, apiRequestService: ApiRequestService, changesCompilationFactory: ChangesCompilationFactory, columnExpansionFactory: ColumnExpansionFactory, createRequestFactory: CreateRequestFactory, errorHandler: ErrorHandlerInterface, promiseService: PromiseLibraryInterface, requestColumnExpansionFactory: RequestColumnExpansionFactory, collectionEntryService: CollectionEntryService, itemEntryService: ItemEntryService, transaction: TransactionCache, breakUpByParent?: boolean | undefined, onAfterCreateCallback?: OnAfterCreateCallback | undefined);
+    /**
+     * @description
+     * Executes the requests in the order of:
+     * 1. create
+     * 2. move
+     * 3. delete
+     * 4. update
+     */
+    execute(): PromiseInterface<ItemIdConversionMap>;
+    private buildMoveRequest;
+    private getMapValue;
     private executeCreateRequests;
     private executeCreateRequest;
     private executeUpdateRequests;
@@ -25,9 +44,4 @@ export declare class ChangesProcessor {
     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,10 +1,13 @@
 import { QueryMatcherFactory } from '../factories';
 import { CollectionEntry, CollectionResource } from '../models';
 import { CollectionMatchResult, CollectionQuery, EntryParentNull, FieldMap, ItemId, ItemType } from '../types';
+import { AbstractCache } from './cache/AbstractCache';
 export declare class CollectionCache {
     private queryMatcherFactory;
+    private transaction;
     private entries;
-    constructor(queryMatcherFactory: QueryMatcherFactory);
+    constructor(queryMatcherFactory: QueryMatcherFactory, transaction: AbstractCache);
+    getByEntryId(collectionEntryId: CollectionEntry['id']): CollectionEntry | undefined;
     contains(collectionEntry: CollectionEntry<any>): boolean;
     some(callback: (entry: CollectionEntry<any>) => boolean): boolean;
     forEach(callback: (entry: CollectionEntry<any>) => void): void;
@@ -14,7 +17,6 @@ export declare class CollectionCache {
     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
@@ -28,5 +30,8 @@ export declare class CollectionCache {
     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>>;
+    /**
+     * @deprecated
+     */
     getResourceByKey<ItemTypeType extends ItemType>(itemType: ItemTypeType, resourceKey: string): Array<CollectionResource<ItemTypeType>>;
 }

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

@@ -6,6 +6,9 @@ export declare class CollectionEntryService {
     private queryParserFactory;
     private queryService;
     constructor(queryParserFactory: QueryParserFactory, queryService: QueryService);
+    createUnfoundLocalCollectionError(itemType: ItemType): {
+        message: string;
+    };
     cloneOptions(options: CollectionEntryOptions, parent: EntryParentNull): CollectionEntryOptions;
     processOptions<ItemTypeType extends ItemType>(options: CollectionOptionsInterface<ItemTypeType>): CollectionEntryOptions;
     cloneQueryParams<T extends object>(parameters: T): T;

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

@@ -1,42 +1,9 @@
-import { ItemId, ItemType } from '../';
-import { CollectionCache } from '../classes';
-import { QueryMatcherFactory } from '../factories/';
-import { CollectionEntry, CollectionResource, ItemEntry } from '../models';
-export declare type CollectionMatcherMatches<ItemTypeType extends ItemType> = {
-    [itemId: number]: {
-        item: ItemEntry<ItemTypeType>;
-        isMatch: boolean | 'maybe';
-    };
-};
-export declare type GroupedCollectionMatcherResult<ItemTypeType extends ItemType> = {
-    fitting: Array<ItemEntry<ItemTypeType>>;
-    notFitting: ItemId[];
-    maybe: Array<ItemEntry<ItemTypeType>>;
-};
-export declare class CollectionMatcher<ItemTypeType extends ItemType> {
-    private queryMatcherFactory;
-    private collectionCaches;
-    private updateInitial;
-    private callOnAdd;
-    private callOnActivate;
-    map: {
-        [collectionEntryId: number]: {
-            collection: CollectionEntry<ItemTypeType>;
-            matches: CollectionMatcherMatches<ItemTypeType>;
-        };
-    };
-    constructor(queryMatcherFactory: QueryMatcherFactory, collectionCaches: CollectionCache[], updateInitial: boolean, callOnAdd: boolean, callOnActivate: boolean);
-    expand(itemEntry: ItemEntry<ItemTypeType>): this;
-    private _expand;
-    getCollectionsWithFittingItems(): Array<CollectionEntry<ItemTypeType>>;
-    addToCollections<U extends CollectionResource<ItemTypeType>>(resultResource: U): U['items'];
-    addToCollections(resultResource?: null): null;
-    addToCollections<U extends CollectionResource<ItemTypeType>>(resultResource?: CollectionResource<ItemTypeType> | null): U['items'] | null;
-    removeFromCollections<U extends CollectionResource<ItemTypeType>>(resultResource: U): U['items'];
-    removeFromCollections(resultResource?: null): null;
-    removeFromCollections<U extends CollectionResource<ItemTypeType>>(resultResource?: CollectionResource<ItemTypeType> | null): U['items'] | null;
-    removeFromAndAddToCollections(): void;
-    private groupItemEntries;
-    private groupItemIds;
-    private hasFittingItems;
+import { QueryMatcherFactory } from '../factories';
+import { CollectionEntry } from '../models';
+import { ItemType } from '../types';
+import { AbstractCache } from './cache/AbstractCache';
+import { CollectionMatcherBase } from './CollectionMatcherBase';
+export declare class CollectionMatcher extends CollectionMatcherBase {
+    constructor(queryMatcherFactory: QueryMatcherFactory, transaction: AbstractCache, getCollectionEntries: (itemType: ItemType) => CollectionEntry[]);
+    getCollectionsWithFittingItems(): CollectionEntry[];
 }

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

@@ -0,0 +1,26 @@
+import { AbstractCache, FieldMap, ItemType } from '../';
+import { QueryMatcherFactory } from '../factories/';
+import { CollectionEntry, ItemEntry } from '../models';
+import { InternalChangesDelta } from './InternalChangesDelta';
+export declare type CollectionMatcherMatches<ItemTypeType extends ItemType = ItemType> = {
+    [itemId: number]: {
+        item: ItemEntry<ItemTypeType>;
+        isMatch: boolean | 'maybe';
+    };
+};
+export declare class CollectionMatcherBase {
+    protected queryMatcherFactory: QueryMatcherFactory;
+    protected transaction: AbstractCache;
+    private getCollectionEntries;
+    protected map: {
+        [collectionEntryId: number]: {
+            collection: CollectionEntry;
+            matches: CollectionMatcherMatches;
+        };
+    };
+    constructor(queryMatcherFactory: QueryMatcherFactory, transaction: AbstractCache, getCollectionEntries: (itemType: ItemType) => CollectionEntry[]);
+    expand<ItemEntryType extends ItemEntry>(itemEntry: ItemEntryType, fields: FieldMap<ItemEntryType['itemType']>): this;
+    processDelta(internalChangesDelta: InternalChangesDelta): this;
+    protected hasFittingItems(matches: CollectionMatcherMatches): boolean;
+    protected _expand(itemEntry: ItemEntry, matchFunction: (collectionEntry: CollectionEntry) => boolean | 'maybe'): this;
+}

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

@@ -1,6 +1,10 @@
 import { ColumnInfo, ColumnSet } from '../classes';
 import { ColumnInfoFactory } from '../factories';
 import { ApiRequestColumn, ApiRequestColumns, ColumnExpansionResult, ItemType, ResponseColumnItemTypeMap } from '../types';
+/**
+ * @description
+ * A ColumnExpansion is used to make sure {@link ItemEntry ItemEntries} that have the same {@link ColumnSet ColumnSet} (matched on {@link ColumnSet.id ColumnSet.id}) will all get the same new expanded ColumnSet
+ */
 export declare class ColumnExpansion<ItemTypeType extends ItemType> {
     private columnInfoFactory;
     itemType: ItemTypeType;

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

@@ -1,5 +1,5 @@
-import { ColumnCache, ColumnUtil } from '../classes';
-import { ApiRequestServiceInterface, ErrorHandlerInterface, PromiseLibraryInterface } from '../interfaces';
+import { ApiRequestService, ColumnCache, ColumnUtil } from '../classes';
+import { ErrorHandlerInterface, PromiseLibraryInterface } from '../interfaces';
 import { ApiRequestColumns, ItemType, PromiseInterface, ResponseColumn, ResponseColumnItemTypeMap } from '../types';
 export declare class ColumnHandler {
     private apiRequestService;
@@ -7,7 +7,7 @@ export declare class ColumnHandler {
     private promiseService;
     private cache;
     private columnUtil;
-    constructor(apiRequestService: ApiRequestServiceInterface, errorHandler: ErrorHandlerInterface, promiseService: PromiseLibraryInterface, cache: ColumnCache, columnUtil: ColumnUtil);
+    constructor(apiRequestService: ApiRequestService, errorHandler: ErrorHandlerInterface, promiseService: PromiseLibraryInterface, cache: ColumnCache, columnUtil: ColumnUtil);
     setColumn(itemType: ItemType, responseColumn: ResponseColumn): ResponseColumn;
     setColumns(itemType: ItemType, requestColumns: ApiRequestColumns, responseColumns: ResponseColumnItemTypeMap): ResponseColumnItemTypeMap;
     fetchItemTypeTranslations(itemTypes: ItemType[]): PromiseInterface<{

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

@@ -1,10 +1,21 @@
+import { LinkTreeServiceInterface } from '../interfaces/LinkTreeServiceInterface';
 import { ApiRequestColumn, ApiRequestColumns, ItemType, ResponseColumn, ResponseColumnItemTypeMap, ResponseColumnMap } from '../types';
 export declare type RequestColumnMergeResult<T extends ApiRequestColumns = ApiRequestColumns, U extends ApiRequestColumns = ApiRequestColumns> = {
     merged: T;
     difference: U;
 };
 export declare class ColumnUtil {
-    constructor();
+    private linkTreeService;
+    constructor(linkTreeService: LinkTreeServiceInterface);
+    /**
+     * @description
+     * Checks the {@link ApiLinkTree LinkTree} and returns the link columnIds for the given ItemType
+     *
+     * @remark
+     * - For {@link ApiLinkTreeType.DIRECT direct links} it will be a columnId
+     * - For {@link ApiLinkTreeType.ITEMTABLE itemtable links} it will be 'itemtype' and 'item'
+     */
+    getColumnsFromLink(parentType: ItemType, itemType: ItemType): ApiRequestColumn[];
     getColumnPath(columns: ResponseColumn[], renderAs: null | string): string;
     getDateFormatOptions(columnType?: 'datetime'): {
         'J-M-Y': string;

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

@@ -1,17 +1,16 @@
-import { CollectionCache, CollectionHandler, CreateCompilation, KeyService } from '../classes';
-import { CollectionMatcherFactory, RequestColumnExpansionFactory } from '../factories';
-import { CreateRequestEntry, CreateRequestParameterMap, ItemType } from '../types';
+import { ApiFormatter, CreateCompilation, KeyService } from '../classes';
+import { RequestColumnExpansionFactory } from '../factories';
+import { CreateRequestEntry, ItemType } from '../types';
+import { TransactionCache } from './cache/transaction/TransactionCache';
 export declare class CreateRequest<ItemTypeType extends ItemType> {
-    private collectionHandler;
-    private collectionMatcherFactory;
+    private apiFormatter;
     private keyService;
     private requestColumnExpansionFactory;
     private compilation;
-    private localCollectionCache;
-    private parameterMap;
+    private transaction;
     private breakupByParent;
     requests: Array<CreateRequestEntry<ItemTypeType>>;
-    constructor(collectionHandler: CollectionHandler, collectionMatcherFactory: CollectionMatcherFactory, keyService: KeyService, requestColumnExpansionFactory: RequestColumnExpansionFactory, compilation: CreateCompilation, localCollectionCache: CollectionCache, parameterMap: CreateRequestParameterMap, breakupByParent?: boolean);
+    constructor(apiFormatter: ApiFormatter, keyService: KeyService, requestColumnExpansionFactory: RequestColumnExpansionFactory, compilation: CreateCompilation, transaction: TransactionCache, breakupByParent?: boolean);
     finalizeRequest(requestResource: CreateRequestEntry<ItemTypeType>): CreateRequestEntry<ItemTypeType>;
     setRequestParent(parentType: ItemType, requestEntry: CreateRequestEntry<ItemTypeType>): boolean;
     run(): CreateRequestEntry<ItemTypeType>[];

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

@@ -0,0 +1,38 @@
+import { ItemEntry } from '../models';
+import { EntryParent, FieldMap, ItemIdConversionMap, ItemType } from '../types';
+import { ChangesDeltaBase } from './ChangesDeltaBase';
+import { ItemEntryService } from './ItemEntryService';
+export declare type InternalCreateDelta<ItemTypeType extends ItemType = any> = {
+    entry: ItemEntry<ItemTypeType>;
+    fields: FieldMap<ItemTypeType>;
+};
+/**
+ * @description
+ * ChangesDelta used internally by the core
+ *
+ * ----------
+ *
+ * The difference between {@link InternalChangesDelta InternalChangesDelta} and {@link ChangesDelta ChangesDelta} is that the InternalChangesDelta
+ * assumes 'created' entries are already existing, so it has a different format.
+ *
+ * Use this when calling {@link TransactionCache.applyChangesFromParent applyChangesFromParent} and {@link TransactionCache.applyChangesFromChild applyChangesFromChild}
+ */
+export declare class InternalChangesDelta extends ChangesDeltaBase {
+    created: {
+        [itemEntryId: string]: InternalCreateDelta;
+    };
+    moved: {
+        [itemEntryId: number]: {
+            entry: ItemEntry;
+            to: EntryParent;
+        };
+    };
+    itemIdConversionMap: ItemIdConversionMap;
+    constructor(itemEntryService: ItemEntryService);
+    setItemCreated<ItemTypeType extends ItemType>(itemEntry: ItemEntry<ItemTypeType>, fields: FieldMap<ItemTypeType>): void;
+    /**
+     * @remark
+     * Parent fields are non-writable so we need to keep track of moved entries another way (to do a linkTo request)
+     */
+    setItemMoved(entry: ItemEntry, to: EntryParent): void;
+}

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

@@ -1,10 +1,16 @@
 import { QueryMatcherFactory } from '../factories';
 import { ItemEntry } from '../models';
 import { CollectionQuery, ItemEntryParentIdMap, ItemId, ItemType } from '../types';
+import { AbstractCache } from './cache/AbstractCache';
 export declare class ItemCache {
     private queryMatcherFactory;
+    private transaction;
     private entries;
-    constructor(queryMatcherFactory: QueryMatcherFactory);
+    entriesByEntryId: {
+        [itemEntryId: number]: ItemEntry;
+    };
+    constructor(queryMatcherFactory: QueryMatcherFactory, transaction: AbstractCache);
+    getByEntryId(itemEntryId: ItemEntry['id']): ItemEntry | undefined;
     some(callback: (itemEntry: ItemEntry<ItemType>) => boolean): boolean;
     getByItemType<ItemTypeType extends ItemType>(itemType: ItemTypeType): ItemEntry<ItemTypeType>[];
     getByQuery<ItemTypeType extends ItemType>(itemType: ItemTypeType, query: CollectionQuery): ItemEntry<ItemTypeType>[];

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

@@ -1,11 +1,31 @@
 import { KeyService } from '../classes';
 import { AuthInterface } from '../interfaces';
+import { LinkTreeServiceInterface } from '../interfaces/LinkTreeServiceInterface';
 import { ItemEntry, ItemEntryOptions } from '../models';
-import { ApiResponse, FieldMap, ItemError, ItemId, ItemIdConversionMap, ItemOptionsInterface, ItemType } from '../types';
+import { ApiResponse, EntryParent, EntryParentNull, FieldMap, ItemError, ItemId, ItemIdConversionMap, ItemOptionsInterface, ItemType } from '../types';
 export declare class ItemEntryService {
     private authInterface;
     private keyService;
-    constructor(authInterface: AuthInterface, keyService: KeyService);
+    private linkTreeService;
+    constructor(authInterface: AuthInterface, keyService: KeyService, linkTreeService: LinkTreeServiceInterface);
+    matchParent(oldParent: EntryParentNull, newParent: EntryParentNull): boolean;
+    /**
+     * @description
+     * Gets the fields required to set the parent
+     *
+     * @remark
+     * Opposite of {@link ItemEntryService.getParentByFields ItemEntryService.getParentByFields}
+     */
+    getLinkFieldsByParent<ItemTypeType extends ItemType>(parent: EntryParent, itemType: ItemTypeType): Partial<FieldMap<ItemTypeType>>;
+    /**
+     * @description
+     * Gets an {@link EntryParent EntryParent} object from the fields
+     *
+     * @remark
+     * Opposite of {@link ItemEntryService.getLinkFieldsByParent ItemEntryService.getLinkFieldsByParent}
+     */
+    getParentByFields<ItemTypeType extends ItemType>(parentType: ItemType, itemEntry: ItemEntry<ItemTypeType>, fields: FieldMap<ItemTypeType>): Partial<FieldMap<ItemTypeType>>;
+    getDisplayName<ItemEntryType extends ItemEntry>(itemEntry: ItemEntryType, fields: FieldMap<ItemEntryType['itemType']>): string;
     processOptions(options: ItemOptionsInterface): ItemEntryOptions;
     createUnfoundRemoteItemError(): ItemError;
     createUnfoundLocalItemError(itemType: ItemType): ItemError;
@@ -15,9 +35,7 @@ export declare class ItemEntryService {
     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;
+    getFullName(firstName?: string, infix?: string, lastName?: string): string;
     getTitleField(itemType: ItemType): string;
     getLocalDefaultValues(): FieldMap;
-    hasLocalDefaultValue(columnId: string): boolean;
 }