@rentman/rm-core 3.0.0 → 3.1.0

package/dist/types/classes/cache/transaction/TransactionCollectionHandler.d.ts

@@ -1,73 +1,62 @@
-import { CollectionCacheFactory, CollectionMatcherFactory, ColumnExpansionFactory, ColumnSubsetCacheFactory, RequestColumnExpansionFactory } from '../../../factories';
-import { ChangesDeltaFactory } from '../../../factories/ChangesDeltaFactory';
-import { ApiQuery, ApiRequestColumns, ChangesDelta, CollectionEntryOptions, CollectionResource, ColumnUtil, ConversionMap, EntryParent, ExceptionHandlerInterface, ItemEntryOptions, ItemIdConversionMap, PromiseInterface } from '../../../index';
-import { ErrorHandlerInterface, PromiseLibraryInterface } from '../../../interfaces';
-import { CollectionEntry, ItemEntry } from '../../../models';
-import { ApiRequestColumn, CollectionEntryParentIdMap, CollectionResourceParentIdMap, ItemId, ItemType, QueryCallback } from '../../../types';
-import { CollectionEntryService, CollectionMatcher, ColumnHandler, KeyService, TransactionItemHandler } from '../../index';
-import { CollectionHandlerBase } from '../CollectionHandlerBase';
-import { TransactionCache } from './TransactionCache';
-export declare class TransactionCollectionHandler extends CollectionHandlerBase {
-    private columnSubsetCacheFactory;
-    private columnExpansionFactory;
-    private changesDeltaFactory;
-    private collectionMatcherFactory;
-    private columnHandler;
-    private errorHandler;
-    private itemHandler;
-    private keyService;
-    private promiseService;
-    private exceptionHandler;
-    protected transaction: TransactionCache;
-    collectionResources: {
-        [collectionEntryId: number]: CollectionResource[];
-    };
-    constructor(requestColumnExpansionFactory: RequestColumnExpansionFactory, columnUtil: ColumnUtil, columnSubsetCacheFactory: ColumnSubsetCacheFactory, columnExpansionFactory: ColumnExpansionFactory, changesDeltaFactory: ChangesDeltaFactory, collectionCacheFactory: CollectionCacheFactory, collectionEntryService: CollectionEntryService, collectionMatcherFactory: CollectionMatcherFactory, columnHandler: ColumnHandler, errorHandler: ErrorHandlerInterface, itemHandler: TransactionItemHandler, keyService: KeyService, promiseService: PromiseLibraryInterface, exceptionHandler: ExceptionHandlerInterface, transaction: TransactionCache);
-    fetchItemEntriesByQuery<ItemTypeType extends ItemType>(itemType: ItemTypeType, query: ApiQuery, options: ItemEntryOptions): PromiseInterface<Array<ItemEntry<ItemTypeType>>>;
-    getAllCollectionsByItemType<ItemTypeType extends ItemType>(itemType: ItemTypeType): Array<CollectionEntry<ItemTypeType>>;
-    createCollectionEntry<ItemTypeType extends ItemType>(itemType: ItemTypeType, options: CollectionEntryOptions): CollectionEntry<ItemTypeType>;
-    /**
-     * @description
-     * Calls the {@link CollectionResourceOptions.onItemsCreated onItemsCreated} callback whenever a create request is done on {@link ItemEntry ItemEntries} that fit in the collection
-     * Can be used to update maps that use {@link ItemEntry.itemId ItemEntry.itemId}
-     *
-     * @deprecated
-     * You should use itemResource.onChange and compare previous.id with fields.id
-     */
-    onItemEntriesCreated(collectionEntry: CollectionEntry, conversionMap: ConversionMap): void;
-    clearEntry(entry: CollectionEntry): void;
-    addResource(resource: CollectionResource): void;
-    clearResource(resource: CollectionResource): void;
-    /**
-     * @description
-     * Updates the parents of the passed {@link ItemEntry ItemEntries}, returns `void` because you should use the {@link CollectionResourceOptions.onAdd onAdd} and {@link CollectionResourceOptions.onRemove onRemove} callbacks
-     */
-    moveItems<CollectionEntryType extends CollectionEntry>(sourceCollectionEntry: CollectionEntryType, destinationCollectionEntry: CollectionEntryType, itemEntries: Array<ItemEntry<CollectionEntryType['itemType']>>): void;
-    extendCollectionEntry<CollectionEntryType extends CollectionEntry>(collectionEntry: CollectionEntryType, queryCallback: QueryCallback): PromiseInterface<CollectionEntryType>;
-    cloneCollectionEntry<CollectionEntryType extends CollectionEntry>(sourceEntry: CollectionEntryType, parent: EntryParent, conversionMap?: ItemIdConversionMap): CollectionEntry<CollectionEntryType['itemType']>;
-    getCollectionMatcher(): CollectionMatcher;
-    fetchCollectionEntry<ItemTypeType extends ItemType>(itemType: ItemTypeType, options: CollectionEntryOptions): PromiseInterface<CollectionEntry<ItemTypeType>>;
-    fetchLinkedCollectionEntries<ItemTypeType extends ItemType>(parentType: ItemType, parentIdArray: ItemId[] | (() => ItemId[]), itemType: ItemTypeType, options: CollectionEntryOptions): PromiseInterface<CollectionEntryParentIdMap<ItemTypeType>>;
-    expandCollectionEntries<ItemTypeType extends ItemType>(parentType: ItemType, itemType: ItemTypeType, collections: CollectionResourceParentIdMap, newColumns: ApiRequestColumn[]): PromiseInterface<CollectionResourceParentIdMap>;
-    extendCollectionEntries<T extends CollectionResourceParentIdMap>(parentType: ItemType, itemType: ItemType, options: CollectionEntryOptions, queryCallback: QueryCallback, collections: T): PromiseInterface<void>;
-    addItemEntriesToCollectionChanges<CollectionEntryType extends CollectionEntry>(collectionEntry: CollectionEntryType, itemEntries: Array<ItemEntry<CollectionEntryType['itemType']>>, isCalledAfterSocketUpdate?: boolean): void;
-    isLocal(options: CollectionEntryOptions | ItemEntryOptions): boolean;
-    expandCollectionEntry<CollectionEntryType extends CollectionEntry>(changesDelta: ChangesDelta, collectionEntry: CollectionEntryType, newColumns: ApiRequestColumns): PromiseInterface<CollectionEntryType>;
-    /**
-     * @description
-     * When {@link ItemEntry ItemEntries} are added to the changes of a {@link CollectionEntry CollectionEntry} all {@link CollectionResource CollectionResources}
-     * should get new {@link ItemResource ItemResources} for the newly added entries
-     */
-    protected handleAddedItemEntriesCallback<CollectionEntryType extends CollectionEntry>(collectionEntry: CollectionEntryType, addedEntries: Array<ItemEntry<CollectionEntryType['itemType']>>): void;
-    /**
-     * @description
-     * When {@link ItemEntry ItemEntries} are removed from the changes of a {@link CollectionEntry CollectionEntry} the {@link ItemResource ItemResources} of the ItemEntries should be removed from all {@link CollectionResource CollectionResources}
-     */
-    protected handleRemovedItemEntriesCallback<CollectionEntryType extends CollectionEntry>(collectionEntry: CollectionEntryType, removedItemEntries: Array<ItemEntry<CollectionEntryType['itemType']>>): void;
-    private fetchCollectionData;
-    /**
-     * @description
-     * Fetches {@link CollectionEntry CollectionEntries} of which the parents are local
-     */
-    private fetchLinkedLocalCollectionEntries;
-}
+import { ApiQuery, ApiRequestColumns, ChangesDelta, CollectionEntryOptions, CollectionResource, ConversionMap, ItemEntryOptions, ItemIdConversionMap, ModifyFieldsCallback, PromiseInterface, TransactionCollectionHandlerDependencyInterface, TransactionItemHandler } from '../../../index';
+import { CollectionEntry, ItemEntry } from '../../../models';
+import { ApiRequestColumn, CollectionEntryParentIdMap, CollectionResourceParentIdMap, ItemId, ItemType, QueryCallback } from '../../../types';
+import { CollectionMatcher } from '../../index';
+import { CollectionHandlerBase } from '../CollectionHandlerBase';
+import { TransactionCache } from './TransactionCache';
+export declare class TransactionCollectionHandler extends CollectionHandlerBase {
+    private dependencies;
+    private itemHandler;
+    protected transaction: TransactionCache;
+    collectionResources: {
+        [collectionEntryId: number]: CollectionResource[];
+    };
+    constructor(dependencies: TransactionCollectionHandlerDependencyInterface, itemHandler: TransactionItemHandler, transaction: TransactionCache);
+    fetchItemEntriesByQuery<ItemTypeType extends ItemType>(itemType: ItemTypeType, query: ApiQuery, options: ItemEntryOptions): PromiseInterface<Array<ItemEntry<ItemTypeType>>>;
+    getAllCollectionsByItemType<ItemTypeType extends ItemType>(itemType: ItemTypeType): Array<CollectionEntry<ItemTypeType>>;
+    createCollectionEntry<ItemTypeType extends ItemType>(itemType: ItemTypeType, options: CollectionEntryOptions): CollectionEntry<ItemTypeType>;
+    /**
+     * @description
+     * Calls the {@link CollectionResourceOptions.onItemsCreated onItemsCreated} callback whenever a create request is done on {@link ItemEntry ItemEntries} that fit in the collection
+     * Can be used to update maps that use {@link ItemEntry.itemId ItemEntry.itemId}
+     *
+     * @deprecated
+     * You should use itemResource.onChange and compare previous.id with fields.id
+     */
+    onItemEntriesCreated(collectionEntry: CollectionEntry, conversionMap: ConversionMap): void;
+    clearEntry(entry: CollectionEntry): void;
+    addResource(resource: CollectionResource): void;
+    clearResource(resource: CollectionResource): void;
+    /**
+     * @description
+     * Updates the parents of the passed {@link ItemEntry ItemEntries}, returns `void` because you should use the {@link CollectionResourceOptions.onAdd onAdd} and {@link CollectionResourceOptions.onRemove onRemove} callbacks
+     */
+    moveItems<CollectionEntryType extends CollectionEntry>(sourceCollectionEntry: CollectionEntryType, destinationCollectionEntry: CollectionEntryType, itemEntries: Array<ItemEntry<CollectionEntryType['itemType']>>): void;
+    extendCollectionEntry<CollectionEntryType extends CollectionEntry>(collectionEntry: CollectionEntryType, queryCallback: QueryCallback): PromiseInterface<CollectionEntryType>;
+    cloneCollectionEntry<CollectionEntryType extends CollectionEntry>(changesDelta: ChangesDelta, sourceEntry: CollectionEntryType, conversionMap?: ItemIdConversionMap, modifyFieldsCallback?: ModifyFieldsCallback): void;
+    getCollectionMatcher(): CollectionMatcher;
+    fetchCollectionEntry<ItemTypeType extends ItemType>(itemType: ItemTypeType, options: CollectionEntryOptions): PromiseInterface<CollectionEntry<ItemTypeType>>;
+    fetchLinkedCollectionEntries<ItemTypeType extends ItemType>(parentType: ItemType, parentIdArray: ItemId[] | (() => ItemId[]), itemType: ItemTypeType, options: CollectionEntryOptions): PromiseInterface<CollectionEntryParentIdMap<ItemTypeType>>;
+    expandCollectionEntries<ItemTypeType extends ItemType>(parentType: ItemType, itemType: ItemTypeType, collections: CollectionResourceParentIdMap, newColumns: ApiRequestColumn[]): PromiseInterface<CollectionResourceParentIdMap>;
+    extendCollectionEntries<T extends CollectionResourceParentIdMap>(parentType: ItemType, itemType: ItemType, options: CollectionEntryOptions, queryCallback: QueryCallback, collections: T): PromiseInterface<void>;
+    addItemEntriesToCollectionChanges<CollectionEntryType extends CollectionEntry>(collectionEntry: CollectionEntryType, itemEntries: Array<ItemEntry<CollectionEntryType['itemType']>>, isCalledAfterSocketUpdate?: boolean): void;
+    isLocal(options: CollectionEntryOptions | ItemEntryOptions): boolean;
+    expandCollectionEntry<CollectionEntryType extends CollectionEntry>(changesDelta: ChangesDelta, collectionEntry: CollectionEntryType, newColumns: ApiRequestColumns): PromiseInterface<CollectionEntryType>;
+    /**
+     * @description
+     * When {@link ItemEntry ItemEntries} are added to the changes of a {@link CollectionEntry CollectionEntry} all {@link CollectionResource CollectionResources}
+     * should get new {@link ItemResource ItemResources} for the newly added entries
+     */
+    protected handleAddedItemEntriesCallback<CollectionEntryType extends CollectionEntry>(collectionEntry: CollectionEntryType, addedEntries: Array<ItemEntry<CollectionEntryType['itemType']>>): void;
+    /**
+     * @description
+     * When {@link ItemEntry ItemEntries} are removed from the changes of a {@link CollectionEntry CollectionEntry} the {@link ItemResource ItemResources} of the ItemEntries should be removed from all {@link CollectionResource CollectionResources}
+     */
+    protected handleRemovedItemEntriesCallback<CollectionEntryType extends CollectionEntry>(collectionEntry: CollectionEntryType, removedItemEntries: Array<ItemEntry<CollectionEntryType['itemType']>>): void;
+    private fetchCollectionData;
+    /**
+     * @description
+     * Fetches {@link CollectionEntry CollectionEntries} of which the parents are local
+     */
+    private fetchLinkedLocalCollectionEntries;
+}

package/dist/types/classes/cache/transaction/TransactionEventHandler.d.ts

@@ -1,24 +1,24 @@
-import { ErrorHandlerInterface, ExceptionHandlerInterface, PromiseLibraryInterface } from '../../../interfaces';
-import { ItemEntry } from '../../../models';
-import { ItemIdConversionMap, PromiseInterface } from '../../../types';
-import { TransactionCache, TransactionErrorLevel } from './TransactionCache';
-export declare type TransactionCacheCallbackCondition = 'always' | 'onClose' | 'skipOnClose';
-export declare type TransactionCacheCallbackType = {
-    onBeforeSave: (transaction: TransactionCache) => any;
-    onSaveSuccess: (transaction: TransactionCache, conversionMap: ItemIdConversionMap) => any;
-    onSetItemError: (itemEntryId: ItemEntry['id'], columnId: string, key: string) => void;
-    onClearItemError: (itemEntryId: ItemEntry['id'], columnId: string, key: string) => void;
-    onSetGlobalError: (key: string, level: TransactionErrorLevel) => void;
-    onClearGlobalError: (key: string) => void;
-};
-export declare class TransactionEventHandler {
-    private errorHandler;
-    private exceptionHandler;
-    private promiseService;
-    private callbacks;
-    constructor(errorHandler: ErrorHandlerInterface, exceptionHandler: ExceptionHandlerInterface, promiseService: PromiseLibraryInterface);
-    registerCallback<T extends keyof TransactionCacheCallbackType>(type: T, key: string, callback: TransactionCacheCallbackType[T], condition?: TransactionCacheCallbackCondition, priority?: number): () => void;
-    executeCallbacks<T extends keyof TransactionCacheCallbackType>(type: T, execute: (callback: TransactionCacheCallbackType[T]) => any, closeTab: boolean): PromiseInterface<any>;
-    private getPriorityLevel;
-    private executeCallbacksPriorityLevel;
-}
+import { ErrorHandlerInterface, ExceptionHandlerInterface, PromiseLibraryInterface } from '../../../interfaces';
+import { ItemEntry } from '../../../models';
+import { ItemIdConversionMap, PromiseInterface } from '../../../types';
+import { TransactionCache, TransactionErrorLevel } from './TransactionCache';
+export declare type TransactionCacheCallbackCondition = 'always' | 'onClose' | 'skipOnClose';
+export declare type TransactionCacheCallbackType = {
+    onBeforeSave: (transaction: TransactionCache) => any;
+    onSaveSuccess: (transaction: TransactionCache, conversionMap: ItemIdConversionMap) => any;
+    onSetItemError: (itemEntryId: ItemEntry['id'], columnId: string, key: string) => void;
+    onClearItemError: (itemEntryId: ItemEntry['id'], columnId: string, key: string) => void;
+    onSetGlobalError: (key: string, level: TransactionErrorLevel) => void;
+    onClearGlobalError: (key: string) => void;
+};
+export declare class TransactionEventHandler {
+    private errorHandler;
+    private exceptionHandler;
+    private promiseService;
+    private callbacks;
+    constructor(errorHandler: ErrorHandlerInterface, exceptionHandler: ExceptionHandlerInterface, promiseService: PromiseLibraryInterface);
+    registerCallback<T extends keyof TransactionCacheCallbackType>(type: T, key: string, callback: TransactionCacheCallbackType[T], condition?: TransactionCacheCallbackCondition, priority?: number): () => void;
+    executeCallbacks<T extends keyof TransactionCacheCallbackType>(type: T, execute: (callback: TransactionCacheCallbackType[T]) => any, closeTab: boolean): PromiseInterface<any>;
+    private getPriorityLevel;
+    private executeCallbacksPriorityLevel;
+}

package/dist/types/classes/cache/transaction/TransactionItemHandler.d.ts

@@ -1,110 +1,99 @@
-import { ChangesDeltaFactory, ColumnExpansionFactory, ColumnSubsetCacheFactory, ItemCacheFactory, ItemEntryFactory, RequestColumnExpansionFactory } from '../../../factories';
-import { ErrorHandlerInterface, ExceptionHandlerInterface, PromiseLibraryInterface } from '../../../interfaces';
-import { ItemEntry, ItemEntryOptions, ItemResource } from '../../../models';
-import { ApiQuery, ApiRequestColumns, FieldMap, ItemId, ItemIdConversionMap, ItemType, ItemTypeMap, ModifyFieldsCallback, PromiseInterface, ResponseColumnItemTypeMap } from '../../../types';
-import { ChangesDelta, ChangesDeltaItemCreateDelta } from '../../ChangesDelta';
-import { ChangesDeltaBase, ChangesDeltaItemUpdateDelta, ChangesDeltaResult } from '../../ChangesDeltaBase';
-import { ApiFormatter, ColumnHandler, ColumnSubsetCache, ColumnUtil, ItemEntryService, KeyService } from '../../index';
-import { ItemCreateService } from '../../ItemCreateService';
-import { TemplateCache } from '../../TemplateCache';
-import { ItemHandlerBase } from '../ItemHandlerBase';
-import { TransactionCache } from './TransactionCache';
-import { TransactionValidator } from './TransactionValidator';
-export declare type TransactionItemEntryChanges<ItemTypeType extends ItemType = any> = {
-    initial: FieldMap<ItemTypeType>;
-    changes: FieldMap<ItemTypeType>;
-};
-/**
- * @description
- * In a {@link TransactionCache Transaction} only local items can be stored, so all entries in {@link TransactionItemHandler.entries this.entries} are local
- * If a non-local entry is requested it should be passed on to the {@link ServerItemHandler ServerItemHandler} which will fetchCollectionEntry the entry from the server
- */
-export declare class TransactionItemHandler extends ItemHandlerBase {
-    private changesDeltaFactory;
-    private exceptionHandler;
-    private templateCache;
-    private columnExpansionFactory;
-    private columnHandler;
-    private columnSubsetCacheFactory;
-    private itemEntryService;
-    private keyService;
-    private changesDeltaService;
-    protected transaction: TransactionCache;
-    private validator?;
-    deletedItems: ItemTypeMap<ItemEntry[]>;
-    itemChanges: {
-        [itemEntryId: number]: TransactionItemEntryChanges;
-    };
-    itemResources: {
-        [itemEntryId: number]: ItemResource[];
-    };
-    constructor(changesDeltaFactory: ChangesDeltaFactory, exceptionHandler: ExceptionHandlerInterface, templateCache: TemplateCache, columnExpansionFactory: ColumnExpansionFactory, columnHandler: ColumnHandler, columnSubsetCacheFactory: ColumnSubsetCacheFactory, errorHandler: ErrorHandlerInterface, itemEntryService: ItemEntryService, keyService: KeyService, changesDeltaService: ItemCreateService, promiseService: PromiseLibraryInterface, columnUtil: ColumnUtil, apiFormatter: ApiFormatter, itemEntryFactory: ItemEntryFactory, itemCacheFactory: ItemCacheFactory, requestColumnExpansionFactory: RequestColumnExpansionFactory, transaction: TransactionCache, validator?: TransactionValidator | undefined);
-    copyTransactionItemEntryChanges(itemEntryChanges: TransactionItemEntryChanges, entry: ItemEntry): TransactionItemEntryChanges;
-    createItemEntry(createTuple: ChangesDeltaItemCreateDelta): ItemEntry;
-    /**
-     * @description
-     * Gets the local {@link FieldMap changes} of the {@link ItemEntry entry} on the {@link TransactionCache transaction} in a formatted way the API accepts
-     */
-    formatRequest<ItemEntryType extends ItemEntry>(entry: ItemEntryType): FieldMap<ItemEntryType['itemType']>;
-    clearItemEntry(entry: ItemEntry): void;
-    /**
-     * @description
-     * Stores am {@link ItemResource ItemResource} on the transaction, used to call {@link ItemResource.options.onChange the onChange callback}
-     */
-    addResource(resource: ItemResource): void;
-    /**
-     * @description
-     * Removes a resource from the transaction, preventing the {@link ItemResource.options.onChange the onChange callback} from being called.
-     * You should call this function when the resource is no longer needed
-     */
-    clearResource(resource: ItemResource): void;
-    detectChanges(): boolean;
-    /**
-     * @description
-     * Checks if the transaction has changes for the passed {@link ItemEntry.id ItemEntryId}
-     *
-     * -----
-     * @remarks
-     * Compares every field (of the entry) in {@link TransactionItemHandler.itemChanges itemChanges} with the initial fields, because fields are copied over when creating a resource having something in itemChanges doesn't actually mean that there are changes (just that a resource has been made)
-     */
-    detectEntryChanges(itemEntryId: ItemEntry['id']): boolean;
-    /**
-     * @description
-     * Processes on a cached entry, if there are no {@link TransactionItemHandler.itemChanges itemChanges} the new values will not be processed, unless forceOverwrite is set
-     *
-     * @param itemEntryChangesTuple The changes tuple
-     * @param forceOverwrite Instead of calling {@link ApiFormatter.mergeCopyFields mergeCopyFields}, {@link ApiFormatter.copyFields copyFields} will be used (because API values are always right)
-     * @param updateInitial Should be `true` if called by applyChangesFromParent
-     * @param isCalledAfterSocketUpdate Indicates that the change is done by a different user
-     * @param createItemChangesIfNoneExist Is `true` when called from `applyChangesDelta`, we can assume that when you call `applyChangesDelta` with updates that aren't on the transaction yet you want to add those
-     *
-     * @returns
-     * The previous changes {@link FieldMap FieldMap}
-     */
-    processItemEntryChanges<ItemTypeType extends ItemType = any>(itemEntryChangesTuple: ChangesDeltaItemUpdateDelta<ItemTypeType>, forceOverwrite?: boolean, updateInitial?: boolean, isCalledAfterSocketUpdate?: boolean, createItemChangesIfNoneExist?: boolean): FieldMap<ItemTypeType> | null;
-    cloneItemEntries<ItemTypeType extends ItemType>(itemEntries: Array<ItemEntry<ItemTypeType>>, conversionMap?: ItemIdConversionMap, modifyFieldsCallback?: ModifyFieldsCallback): PromiseInterface<ChangesDeltaResult>;
-    cloneItemEntry<ItemTypeType extends ItemType>(changesDelta: ChangesDelta, sourceEntry: ItemEntry<ItemTypeType>, newFields?: FieldMap<ItemTypeType>, conversionMap?: ItemIdConversionMap, modifyFieldsCallback?: ModifyFieldsCallback): ItemId;
-    fetchItemEntriesByQuery<ItemTypeType extends ItemType>(itemType: ItemTypeType, query: ApiQuery, entryOptions: ItemEntryOptions): PromiseInterface<Array<ItemEntry<ItemTypeType>>>;
-    fetchItemEntry<ItemTypeType extends ItemType>(itemType: ItemTypeType, itemId: ItemId, options: ItemEntryOptions): PromiseInterface<ItemEntry<ItemTypeType>>;
-    /**
-     * @description
-     * Fetches a template and creates a new {@link ItemEntry ItemEntry}, will error if the ItemEntry with the given ItemId already exists
-     */
-    fetchNewItemEntry<ItemTypeType extends ItemType>(itemType: ItemTypeType, itemId: ItemId, options: ItemEntryOptions): PromiseInterface<ChangesDeltaResult>;
-    fetchItemEntries<ItemTypeType extends ItemType>(itemType: ItemTypeType, itemIds: ItemId[], options: ItemEntryOptions): PromiseInterface<Array<ItemEntry<ItemTypeType>>>;
-    fetchTitle(itemType: ItemType, itemId: ItemId): PromiseInterface<string>;
-    resolveLocalItemEntry<ItemTypeType extends ItemType>(changesDelta: ChangesDelta, itemEntry: ItemEntry<ItemTypeType>, columnSubsetCache: ColumnSubsetCache<ItemTypeType>, options: ItemEntryOptions): PromiseInterface<ItemEntry<ItemTypeType>>;
-    expandLocalItemEntries<ItemTypeType extends ItemType>(changesDelta: ChangesDeltaBase, itemType: ItemTypeType, itemEntries: Array<ItemEntry<ItemTypeType>>, requestColumns: ApiRequestColumns, responseColumns: ResponseColumnItemTypeMap): PromiseInterface<Array<ItemEntry<ItemTypeType>>>;
-    /**
-     * @description
-     * Fetches the data for the passed ItemType/ItemId/columns, is able to fetchCollectionEntry non-local derived values.
-     *
-     * @remark
-     * Assumes the the ItemEntry with the given ItemType-ItemId is already cached
-     */
-    fetchLocalItemEntryData<ItemTypeType extends ItemType>(changesDelta: ChangesDelta, itemType: ItemTypeType, itemId: ItemId, columnSubsetCache: ColumnSubsetCache<ItemTypeType>, options: ItemEntryOptions): PromiseInterface<any>;
-    fetchLocalItemEntries<ItemTypeType extends ItemType>(itemType: ItemTypeType, itemIds: ItemId[], options: ItemEntryOptions): PromiseInterface<Array<ItemEntry<ItemTypeType>>>;
-    private getColumnDifference;
-    private expandLocalItemEntry;
-    private getLocalValues;
-}
+import { TransactionItemHandlerDependencyInterface } from '../../../interfaces';
+import { ItemEntry, ItemEntryOptions, ItemResource } from '../../../models';
+import { ApiQuery, ApiRequestColumns, FieldMap, ItemId, ItemIdConversionMap, ItemType, ItemTypeMap, ModifyFieldsCallback, PromiseInterface, ResponseColumnItemTypeMap } from '../../../types';
+import { ChangesDelta } from '../../ChangesDelta';
+import { ChangesDeltaBase, ChangesDeltaItemUpdateDelta, ChangesDeltaResult } from '../../ChangesDeltaBase';
+import { ChangesDeltaItemCreateDelta, ColumnSubsetCache } from '../../index';
+import { ItemHandlerBase } from '../ItemHandlerBase';
+import { TransactionCache } from './TransactionCache';
+import { TransactionValidator } from './TransactionValidator';
+export declare type TransactionItemEntryChanges<ItemTypeType extends ItemType = any> = {
+    initial: FieldMap<ItemTypeType>;
+    changes: FieldMap<ItemTypeType>;
+};
+/**
+ * @description
+ * In a {@link TransactionCache Transaction} only local items can be stored, so all entries in {@link TransactionItemHandler.entries this.entries} are local
+ * If a non-local entry is requested it should be passed on to the {@link ServerItemHandler ServerItemHandler} which will fetchCollectionEntry the entry from the server
+ */
+export declare class TransactionItemHandler extends ItemHandlerBase {
+    private dependencies;
+    protected transaction: TransactionCache;
+    private validator?;
+    deletedItems: ItemTypeMap<ItemEntry[]>;
+    itemChanges: {
+        [itemEntryId: number]: TransactionItemEntryChanges;
+    };
+    itemResources: {
+        [itemEntryId: number]: ItemResource[];
+    };
+    constructor(dependencies: TransactionItemHandlerDependencyInterface, transaction: TransactionCache, validator?: TransactionValidator | undefined);
+    copyTransactionItemEntryChanges(itemEntryChanges: TransactionItemEntryChanges, entry: ItemEntry): TransactionItemEntryChanges;
+    createItemEntry(createTuple: ChangesDeltaItemCreateDelta): ItemEntry;
+    /**
+     * @description
+     * Gets the local {@link FieldMap changes} of the {@link ItemEntry entry} on the {@link TransactionCache transaction} in a formatted way the API accepts
+     */
+    formatRequest<ItemEntryType extends ItemEntry>(entry: ItemEntryType): FieldMap<ItemEntryType['itemType']>;
+    clearItemEntry(entry: ItemEntry): void;
+    /**
+     * @description
+     * Stores am {@link ItemResource ItemResource} on the transaction, used to call {@link ItemResource.options.onChange the onChange callback}
+     */
+    addResource(resource: ItemResource): void;
+    /**
+     * @description
+     * Removes a resource from the transaction, preventing the {@link ItemResource.options.onChange the onChange callback} from being called.
+     * You should call this function when the resource is no longer needed
+     */
+    clearResource(resource: ItemResource): void;
+    detectChanges(): boolean;
+    /**
+     * @description
+     * Checks if the transaction has changes for the passed {@link ItemEntry.id ItemEntryId}
+     *
+     * -----
+     * @remarks
+     * Compares every field (of the entry) in {@link TransactionItemHandler.itemChanges itemChanges} with the initial fields, because fields are copied over when creating a resource having something in itemChanges doesn't actually mean that there are changes (just that a resource has been made)
+     */
+    detectEntryChanges(itemEntryId: ItemEntry['id']): boolean;
+    /**
+     * @description
+     * Processes on a cached entry, if there are no {@link TransactionItemHandler.itemChanges itemChanges} the new values will not be processed, unless forceOverwrite is set
+     *
+     * @param itemEntryChangesTuple The changes tuple
+     * @param forceOverwrite Instead of calling {@link ApiFormatter.mergeCopyFields mergeCopyFields}, {@link ApiFormatter.copyFields copyFields} will be used (because API values are always right)
+     * @param updateInitial Should be `true` if called by applyChangesFromParent
+     * @param isCalledAfterSocketUpdate Indicates that the change is done by a different user
+     * @param createItemChangesIfNoneExist Is `true` when called from `applyChangesDelta`, we can assume that when you call `applyChangesDelta` with updates that aren't on the transaction yet you want to add those
+     *
+     * @returns
+     * The previous changes {@link FieldMap FieldMap}
+     */
+    processItemEntryChanges<ItemTypeType extends ItemType = any>(itemEntryChangesTuple: ChangesDeltaItemUpdateDelta<ItemTypeType>, forceOverwrite?: boolean, updateInitial?: boolean, isCalledAfterSocketUpdate?: boolean, createItemChangesIfNoneExist?: boolean): FieldMap<ItemTypeType> | null;
+    cloneItemEntries<ItemTypeType extends ItemType>(changesDelta: ChangesDelta, itemEntries: Array<ItemEntry<ItemTypeType>>, conversionMap?: ItemIdConversionMap, modifyFieldsCallback?: ModifyFieldsCallback): ItemId[];
+    cloneItemEntry<ItemTypeType extends ItemType>(changesDelta: ChangesDelta, sourceEntry: ItemEntry<ItemTypeType>, conversionMap?: ItemIdConversionMap, modifyFieldsCallback?: ModifyFieldsCallback): ItemId;
+    fetchItemEntriesByQuery<ItemTypeType extends ItemType>(itemType: ItemTypeType, query: ApiQuery, entryOptions: ItemEntryOptions): PromiseInterface<Array<ItemEntry<ItemTypeType>>>;
+    fetchItemEntry<ItemTypeType extends ItemType>(itemType: ItemTypeType, itemId: ItemId, options: ItemEntryOptions): PromiseInterface<ItemEntry<ItemTypeType>>;
+    /**
+     * @description
+     * Fetches a template and creates a new {@link ItemEntry ItemEntry}, will error if the ItemEntry with the given ItemId already exists
+     */
+    fetchNewItemEntry<ItemTypeType extends ItemType>(itemType: ItemTypeType, itemId: ItemId, options: ItemEntryOptions): PromiseInterface<ChangesDeltaResult>;
+    fetchItemEntries<ItemTypeType extends ItemType>(itemType: ItemTypeType, itemIds: ItemId[], options: ItemEntryOptions): PromiseInterface<Array<ItemEntry<ItemTypeType>>>;
+    fetchTitle(itemType: ItemType, itemId: ItemId): PromiseInterface<string>;
+    resolveLocalItemEntry<ItemTypeType extends ItemType>(changesDelta: ChangesDelta, itemEntry: ItemEntry<ItemTypeType>, columnSubsetCache: ColumnSubsetCache<ItemTypeType>, options: ItemEntryOptions): PromiseInterface<ItemEntry<ItemTypeType>>;
+    expandLocalItemEntries<ItemTypeType extends ItemType>(changesDelta: ChangesDeltaBase, itemType: ItemTypeType, itemEntries: Array<ItemEntry<ItemTypeType>>, requestColumns: ApiRequestColumns, responseColumns: ResponseColumnItemTypeMap): PromiseInterface<Array<ItemEntry<ItemTypeType>>>;
+    /**
+     * @description
+     * Fetches the data for the passed ItemType/ItemId/columns, is able to fetchCollectionEntry non-local derived values.
+     *
+     * @remark
+     * Assumes the the ItemEntry with the given ItemType-ItemId is already cached
+     */
+    fetchLocalItemEntryData<ItemTypeType extends ItemType>(changesDelta: ChangesDelta, itemType: ItemTypeType, itemId: ItemId, columnSubsetCache: ColumnSubsetCache<ItemTypeType>, options: ItemEntryOptions): PromiseInterface<any>;
+    fetchLocalItemEntries<ItemTypeType extends ItemType>(itemType: ItemTypeType, itemIds: ItemId[], options: ItemEntryOptions): PromiseInterface<Array<ItemEntry<ItemTypeType>>>;
+    private getColumnDifference;
+    private expandLocalItemEntry;
+    private getLocalValues;
+}

package/dist/types/classes/cache/transaction/TransactionValidator.d.ts

@@ -1,28 +1,28 @@
-import { ItemEntry } from '../../../models/index';
-import { FieldMap, ItemType, PromiseInterface } from '../../../types/index';
-import { TransactionCache, TransactionErrorLevel } from './TransactionCache';
-export interface TransactionValidatorFactory {
-    construct(transaction: TransactionCache): TransactionValidator;
-}
-export declare abstract class TransactionValidator {
-    protected transaction: TransactionCache;
-    private lastCallId;
-    protected constructor(transaction: TransactionCache);
-    /**
-     * @description
-     * Will be called after {@link TransactionCache.applyChangesFromParent applyChangesFromParent}, {@link TransactionCache.applyChangesFromChild applyChangesFromChild} or {@link TransactionCache.applyChangesDelta applyChangesDelta} is called
-     * Allows you to set {@link TransactionCache.errors global errors}
-     */
-    abstract validateTransaction(): void;
-    /**
-     * @description
-     * Will be called whenever an item is changed, allows you to set errors on the transaction
-     * @param itemEntry
-     * @param fields
-     * @param previous
-     */
-    abstract validateItem<ItemTypeType extends ItemType>(itemEntry: ItemEntry<ItemTypeType>, fields: FieldMap<ItemTypeType>, previous: FieldMap<ItemTypeType>): void;
-    protected setGlobalError(key: string, isInvalid: boolean | PromiseInterface<boolean>, saveButtonErrorTranslationFn: () => string, level: TransactionErrorLevel): void;
-    protected setItemError(itemEntryId: ItemEntry['id'], columnId: string, errorKey: string, isInvalid: boolean | PromiseInterface<boolean>, fieldErrorTranslationFn: () => string, saveButtonErrorTranslationFn: () => string, level: TransactionErrorLevel): void;
-    private getRandomId;
-}
+import { ItemEntry } from '../../../models/index';
+import { FieldMap, ItemType, PromiseInterface } from '../../../types/index';
+import { TransactionCache, TransactionErrorLevel } from './TransactionCache';
+export interface TransactionValidatorFactory {
+    construct(transaction: TransactionCache): TransactionValidator;
+}
+export declare abstract class TransactionValidator {
+    protected transaction: TransactionCache;
+    private lastCallId;
+    protected constructor(transaction: TransactionCache);
+    /**
+     * @description
+     * Will be called after {@link TransactionCache.applyChangesFromParent applyChangesFromParent}, {@link TransactionCache.applyChangesFromChild applyChangesFromChild} or {@link TransactionCache.applyChangesDelta applyChangesDelta} is called
+     * Allows you to set {@link TransactionCache.errors global errors}
+     */
+    abstract validateTransaction(): void;
+    /**
+     * @description
+     * Will be called whenever an item is changed, allows you to set errors on the transaction
+     * @param itemEntry
+     * @param fields
+     * @param previous
+     */
+    abstract validateItem<ItemTypeType extends ItemType>(itemEntry: ItemEntry<ItemTypeType>, fields: FieldMap<ItemTypeType>, previous: FieldMap<ItemTypeType>): void;
+    protected setGlobalError(key: string, isInvalid: boolean | PromiseInterface<boolean>, saveButtonErrorTranslationFn: () => string, level: TransactionErrorLevel): void;
+    protected setItemError(itemEntryId: ItemEntry['id'], columnId: string, errorKey: string, isInvalid: boolean | PromiseInterface<boolean>, fieldErrorTranslationFn: () => string, saveButtonErrorTranslationFn: () => string, level: TransactionErrorLevel): void;
+    private getRandomId;
+}

package/dist/types/classes/index.d.ts

@@ -1,44 +1,46 @@
-export * from './ApiFormatter';
-export * from './ApiRequestService';
-export * from './ApiResponseProcessor';
-export * from './ChangesCompilation';
-export * from './ChangesProcessor';
-export * from './CollectionCache';
-export * from './CollectionEntryService';
-export * from './CollectionMatcher';
-export * from './CollectionResourceService';
-export * from './ColumnCache';
-export * from './ColumnExpansion';
-export * from './ColumnHandler';
-export * from './ColumnInfo';
-export * from './ColumnSet';
-export * from './ColumnSubsetCache';
-export * from './ColumnUtil';
-export * from './CreateRequest';
-export * from './ItemCache';
-export * from './ItemEntryService';
-export * from './KeyService';
-export * from './cache/transaction/TransactionEventHandler';
-export * from './LockService';
-export * from './ModuleChangesCompilation';
-export * from './QueryMatcher';
-export * from './QueryParser';
-export * from './QueryService';
-export * from './RequestColumnExpansion';
-export * from './SocketMessageHandler';
-export * from './Util';
-export * from './cache/AbstractCache';
-export * from './cache/server/ServerCache';
-export * from './cache/server/ServerItemHandler';
-export * from './cache/server/ServerCollectionHandler';
-export * from './cache/transaction/TransactionCache';
-export * from './cache/transaction/TransactionItemHandler';
-export * from './cache/transaction/TransactionCollectionHandler';
-export * from './cache/transaction/TransactionEventHandler';
-export * from './cache/transaction/TransactionValidator';
-export * from './ChangesDeltaBase';
-export * from './ChangesDelta';
-export * from './InternalChangesDelta';
-export * from './RequestBufferManager';
-export * from './RequestBuffer';
-export * from './ItemCreateService';
+export * from './ApiFormatter';
+export * from './ApiRequestService';
+export * from './ApiResponseProcessor';
+export * from './ChangesCompilation';
+export * from './ChangesProcessor';
+export * from './CollectionCache';
+export * from './CollectionEntryService';
+export * from './CollectionMatcher';
+export * from './CollectionResourceService';
+export * from './ColumnCache';
+export * from './ColumnExpansion';
+export * from './ColumnHandler';
+export * from './ColumnInfo';
+export * from './ColumnSet';
+export * from './ColumnSubsetCache';
+export * from './ColumnUtil';
+export * from './ConversionMapService';
+export * from './CreateRequest';
+export * from './ItemCache';
+export * from './ItemEntryService';
+export * from './KeyService';
+export * from './cache/transaction/TransactionEventHandler';
+export * from './LockService';
+export * from './ModuleChangesCompilation';
+export * from './QueryMatcher';
+export * from './QueryParser';
+export * from './QueryService';
+export * from './RequestColumnExpansion';
+export * from './SocketMessageHandler';
+export * from './Util';
+export * from './cache/AbstractCache';
+export * from './cache/server/ServerCache';
+export * from './cache/server/ServerItemHandler';
+export * from './cache/server/ServerCollectionHandler';
+export * from './cache/transaction/TransactionCache';
+export * from './cache/transaction/TransactionItemHandler';
+export * from './cache/transaction/TransactionCollectionHandler';
+export * from './cache/transaction/TransactionEventHandler';
+export * from './cache/transaction/TransactionValidator';
+export * from './ChangesDeltaBase';
+export * from './ChangesDelta';
+export * from './InternalChangesDelta';
+export * from './RequestBufferManager';
+export * from './RequestBuffer';
+export * from './ItemCreateService';
+export * from './CreatedChangesDelta';

package/dist/types/constants.d.ts

@@ -1,7 +1,7 @@
-export declare const ALL_PERMISSIONS = "7";
-export declare const COLUMN_SEPERATOR = ">";
-export declare const RENDER_AS_SEPERATOR = ":";
-export declare const NEW_PREFIX: string;
-export declare const DUPLICATE_PREFIX: string;
-export declare const NEW_KEYWORD: string;
-export declare const DUPLICATE_KEYWORD: string;
+export declare const ALL_PERMISSIONS = "7";
+export declare const COLUMN_SEPERATOR = ">";
+export declare const RENDER_AS_SEPERATOR = ":";
+export declare const NEW_PREFIX: string;
+export declare const DUPLICATE_PREFIX: string;
+export declare const NEW_KEYWORD: string;
+export declare const DUPLICATE_KEYWORD: string;