@rentman/rm-core 6.0.1 → 6.0.2

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

@@ -1,23 +1,23 @@
-import { ApiQuery, ApiRequestColumns, CollectionQuery, ColumnSubsetCache, ItemEntryOptions, ParentIdMap, PromiseInterface, TransactionCollectionHandlerDependencyInterface, TransactionItemHandler } from '../../../index';
-import { ItemEntry } from '../../../models';
-import { CollectionOptions } from '../../../models/CollectionOptions';
-import { ItemId, ItemType } from '../../../types';
-import { CachedQueryHandlerBase, CachedQueryItem } from '../CachedQueryHandlerBase';
-import { TransactionCache } from './TransactionCache';
-export declare class TransactionCachedQueryHandler extends CachedQueryHandlerBase {
-    private dependencies;
-    private itemHandler;
-    protected transaction: TransactionCache;
-    constructor(dependencies: TransactionCollectionHandlerDependencyInterface, itemHandler: TransactionItemHandler, transaction: TransactionCache);
-    __fetchCachedQueryItem<ItemTypeType extends ItemType>(itemType: ItemTypeType, options: CollectionOptions): PromiseInterface<CachedQueryItem<ItemTypeType>>;
-    __expandCachedQuery<ItemTypeType extends ItemType = any>(cachedQuery: CachedQueryItem<ItemTypeType>, newColumns: ApiRequestColumns): PromiseInterface<CachedQueryItem<ItemTypeType>>;
-    __addItemEntriesToCachedQueries<ItemTypeType extends ItemType>(itemType: ItemTypeType, parsedQuery: CollectionQuery, itemEntries: Array<ItemEntry<ItemTypeType>>): void;
-    /**
-     * @remark
-     * todo not only linkedTo should be checked, but it should check if there's a local ID anywhere in the query
-     * ({<field>: <localId>}) is also a local query
-     */
-    isLocal(options: CollectionOptions | ItemEntryOptions, query: ApiQuery): boolean;
-    __fetchItemEntriesByQueryData<ItemTypeType extends ItemType>(itemType: ItemTypeType, options: CollectionOptions<ItemTypeType>, columnSubsetCache: ColumnSubsetCache<ItemTypeType>, collectionQuery: CollectionQuery): PromiseInterface<CachedQueryItem<ItemTypeType>>;
-    __fetchLinkedCachedQueryItems<ItemTypeType extends ItemType>(parentType: ItemType, parentIdArray: ItemId[] | (() => ItemId[]), itemType: ItemTypeType, options: CollectionOptions): PromiseInterface<ParentIdMap<CachedQueryItem<ItemTypeType>>>;
-}
+import { ApiQuery, ApiRequestColumns, CollectionQuery, ColumnSubsetCache, ItemEntryOptions, ParentIdMap, PromiseInterface, TransactionCollectionHandlerDependencyInterface, TransactionItemHandler } from '../../../index';
+import { ItemEntry } from '../../../models';
+import { CollectionOptions } from '../../../models/CollectionOptions';
+import { ItemId, ItemType } from '../../../types';
+import { CachedQueryHandlerBase, CachedQueryItem } from '../CachedQueryHandlerBase';
+import { TransactionCache } from './TransactionCache';
+export declare class TransactionCachedQueryHandler extends CachedQueryHandlerBase {
+    private dependencies;
+    private itemHandler;
+    protected transaction: TransactionCache;
+    constructor(dependencies: TransactionCollectionHandlerDependencyInterface, itemHandler: TransactionItemHandler, transaction: TransactionCache);
+    __fetchCachedQueryItem<ItemTypeType extends ItemType>(itemType: ItemTypeType, options: CollectionOptions): PromiseInterface<CachedQueryItem<ItemTypeType>>;
+    __expandCachedQuery<ItemTypeType extends ItemType = any>(cachedQuery: CachedQueryItem<ItemTypeType>, newColumns: ApiRequestColumns): PromiseInterface<CachedQueryItem<ItemTypeType>>;
+    __addItemEntriesToCachedQueries<ItemTypeType extends ItemType>(itemType: ItemTypeType, parsedQuery: CollectionQuery, itemEntries: Array<ItemEntry<ItemTypeType>>): void;
+    /**
+     * @remark
+     * todo not only linkedTo should be checked, but it should check if there's a local ID anywhere in the query
+     * ({<field>: <localId>}) is also a local query
+     */
+    isLocal(options: CollectionOptions | ItemEntryOptions, query: ApiQuery): boolean;
+    __fetchItemEntriesByQueryData<ItemTypeType extends ItemType>(itemType: ItemTypeType, options: CollectionOptions<ItemTypeType>, columnSubsetCache: ColumnSubsetCache<ItemTypeType>, collectionQuery: CollectionQuery): PromiseInterface<CachedQueryItem<ItemTypeType>>;
+    __fetchLinkedCachedQueryItems<ItemTypeType extends ItemType>(parentType: ItemType, parentIdArray: ItemId[] | (() => ItemId[]), itemType: ItemTypeType, options: CollectionOptions): PromiseInterface<ParentIdMap<CachedQueryItem<ItemTypeType>>>;
+}

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

@@ -1,28 +1,28 @@
-import { TransactionCollectionHandlerDependencyInterface } from '../../../interfaces/TransactionCollectionHandlerDependencyInterface';
-import { CollectionEntry, CollectionResource, ItemEntry } from '../../../models';
-import { ApiRequestColumns, ItemIdConversionMap, ItemType, ModifyFieldsCallback, PromiseInterface } from '../../../types';
-import { ChangesDelta } from '../../ChangesDelta';
-import { TransactionCache } from './TransactionCache';
-import { TransactionCachedQueryHandler } from './TransactionCachedQueryHandler';
-import { TransactionItemHandler } from './TransactionItemHandler';
-export declare class TransactionCollectionHandler {
-    protected itemHandler: TransactionItemHandler;
-    protected cachedQueryHandler: TransactionCachedQueryHandler;
-    private dependencies;
-    private transaction;
-    collectionResources: {
-        [itemType: string]: {
-            [queryString: string]: CollectionResource[];
-        };
-    };
-    constructor(itemHandler: TransactionItemHandler, cachedQueryHandler: TransactionCachedQueryHandler, dependencies: TransactionCollectionHandlerDependencyInterface, transaction: TransactionCache);
-    expandCollectionResource<ItemTypeType extends ItemType = any>(collectionResource: CollectionResource<ItemTypeType>, newColumns: ApiRequestColumns): PromiseInterface<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;
-    cloneCollectionEntry<CollectionEntryType extends CollectionEntry>(changesDelta: ChangesDelta, sourceEntry: CollectionEntryType, conversionMap?: ItemIdConversionMap, modifyFieldsCallback?: ModifyFieldsCallback): void;
-}
+import { TransactionCollectionHandlerDependencyInterface } from '../../../interfaces/TransactionCollectionHandlerDependencyInterface';
+import { CollectionEntry, CollectionResource, ItemEntry } from '../../../models';
+import { ApiRequestColumns, ItemIdConversionMap, ItemType, ModifyFieldsCallback, PromiseInterface } from '../../../types';
+import { ChangesDelta } from '../../ChangesDelta';
+import { TransactionCache } from './TransactionCache';
+import { TransactionCachedQueryHandler } from './TransactionCachedQueryHandler';
+import { TransactionItemHandler } from './TransactionItemHandler';
+export declare class TransactionCollectionHandler {
+    protected itemHandler: TransactionItemHandler;
+    protected cachedQueryHandler: TransactionCachedQueryHandler;
+    private dependencies;
+    private transaction;
+    collectionResources: {
+        [itemType: string]: {
+            [queryString: string]: CollectionResource[];
+        };
+    };
+    constructor(itemHandler: TransactionItemHandler, cachedQueryHandler: TransactionCachedQueryHandler, dependencies: TransactionCollectionHandlerDependencyInterface, transaction: TransactionCache);
+    expandCollectionResource<ItemTypeType extends ItemType = any>(collectionResource: CollectionResource<ItemTypeType>, newColumns: ApiRequestColumns): PromiseInterface<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;
+    cloneCollectionEntry<CollectionEntryType extends CollectionEntry>(changesDelta: ChangesDelta, sourceEntry: CollectionEntryType, conversionMap?: ItemIdConversionMap, modifyFieldsCallback?: ModifyFieldsCallback): void;
+}

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,90 +1,90 @@
-import { TransactionItemHandlerDependencyInterface } from '../../../interfaces';
-import { ItemEntry, ItemEntryOptions } from '../../../models';
-import { ApiQuery, ApiRequestColumns, DeregFunction, FieldChangeCallback, 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 __fetchCachedQueryItem 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;
-    };
-    fieldChangeCallbacks: {
-        [itemType: string]: {
-            [itemId: string]: FieldChangeCallback[];
-        };
-    };
-    constructor(dependencies: TransactionItemHandlerDependencyInterface, transaction: TransactionCache, validator?: TransactionValidator | undefined);
-    registerFieldChangeCallback<ItemTypeType extends ItemType>(itemType: ItemTypeType, itemId: ItemId, callback: FieldChangeCallback<ItemTypeType>): DeregFunction;
-    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']>;
-    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 __fetchCachedQueryItem 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 } from '../../../models';
+import { ApiQuery, ApiRequestColumns, DeregFunction, FieldChangeCallback, 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 __fetchCachedQueryItem 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;
+    };
+    fieldChangeCallbacks: {
+        [itemType: string]: {
+            [itemId: string]: FieldChangeCallback[];
+        };
+    };
+    constructor(dependencies: TransactionItemHandlerDependencyInterface, transaction: TransactionCache, validator?: TransactionValidator | undefined);
+    registerFieldChangeCallback<ItemTypeType extends ItemType>(itemType: ItemTypeType, itemId: ItemId, callback: FieldChangeCallback<ItemTypeType>): DeregFunction;
+    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']>;
+    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 __fetchCachedQueryItem 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,46 +1,46 @@
-export * from './ApiFormatter';
-export * from './ApiRequestService';
-export * from './ApiResponseProcessor';
-export * from './ChangesCompilation';
-export * from './ChangesProcessor';
-export * from './CollectionEntryService';
-export * from './CollectionMatcherCachedCollectionProcessor';
-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/ServerCachedQueryHandler';
-export * from './cache/transaction/TransactionCache';
-export * from './cache/transaction/TransactionItemHandler';
-export * from './cache/transaction/TransactionCachedQueryHandler';
-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';
+export * from './ApiFormatter';
+export * from './ApiRequestService';
+export * from './ApiResponseProcessor';
+export * from './ChangesCompilation';
+export * from './ChangesProcessor';
+export * from './CollectionEntryService';
+export * from './CollectionMatcherCachedCollectionProcessor';
+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/ServerCachedQueryHandler';
+export * from './cache/transaction/TransactionCache';
+export * from './cache/transaction/TransactionItemHandler';
+export * from './cache/transaction/TransactionCachedQueryHandler';
+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;

package/dist/types/core.d.ts

@@ -1,51 +1,51 @@
-import { ApiFormatter, ApiRequestService, CollectionEntryService, CollectionResourceService, ColumnCache, ColumnHandler, ColumnUtil, ConversionMapService, ItemEntryService, KeyService, LockService, QueryService, SocketMessageHandler } from './classes';
-import { ItemCreateService } from './classes/ItemCreateService';
-import { TemplateCache } from './classes/TemplateCache';
-import { ApiResponseProcessorFactory, ChangesCompilationFactory, CollectionEntryFactory, CollectionMatcherFactory, CollectionResourceFactory, ColumnExpansionFactory, ColumnInfoFactory, ColumnSetFactory, ColumnSubsetCacheFactory, CreateRequestFactory, ItemCacheFactory, ItemEntryFactory, ItemResourceFactory, ModuleChangesCompilationFactory, QueryMatcherFactory, QueryParserFactory, RequestColumnExpansionFactory, TemplateFactory, TransactionCacheFactory } from './factories';
-import { ChangesDeltaFactory } from './factories/ChangesDeltaFactory';
-import { ChangesProcessorFactory } from './factories/ChangesProcessorFactory';
-import { ApiRequestServiceInterface, AuthInterface, ErrorHandlerInterface, ExceptionHandlerInterface, PromiseLibraryInterface } from './interfaces';
-import { LinkTreeServiceInterface } from './interfaces/LinkTreeServiceInterface';
-export declare class RmCore {
-    version: string;
-    noop: typeof noop;
-    apiFormatter: ApiFormatter;
-    apiRequestService: ApiRequestService;
-    apiResponseProcessorFactory: ApiResponseProcessorFactory;
-    changesCompilationFactory: ChangesCompilationFactory;
-    changesDeltaFactory: ChangesDeltaFactory;
-    changesProcessorFactory: ChangesProcessorFactory;
-    collectionEntryFactory: CollectionEntryFactory;
-    collectionEntryService: CollectionEntryService;
-    collectionMatcherFactory: CollectionMatcherFactory;
-    collectionResourceFactory: CollectionResourceFactory;
-    collectionResourceService: CollectionResourceService;
-    columnCache: ColumnCache;
-    columnExpansionFactory: ColumnExpansionFactory;
-    columnHandler: ColumnHandler;
-    columnInfoFactory: ColumnInfoFactory;
-    columnSetFactory: ColumnSetFactory;
-    columnSubsetCacheFactory: ColumnSubsetCacheFactory;
-    columnUtil: ColumnUtil;
-    conversionMapService: ConversionMapService;
-    createRequestFactory: CreateRequestFactory;
-    itemCacheFactory: ItemCacheFactory;
-    itemCreateService: ItemCreateService;
-    itemEntryFactory: ItemEntryFactory;
-    itemEntryService: ItemEntryService;
-    itemResourceFactory: ItemResourceFactory;
-    keyService: KeyService;
-    lockService: LockService;
-    moduleChangesCompilationFactory: ModuleChangesCompilationFactory;
-    queryMatcherFactory: QueryMatcherFactory;
-    queryParserFactory: QueryParserFactory;
-    queryService: QueryService;
-    requestColumnExpansionFactory: RequestColumnExpansionFactory;
-    socketMessageHandler: SocketMessageHandler;
-    templateCache: TemplateCache;
-    templateFactory: TemplateFactory;
-    transactionCacheFactory: TransactionCacheFactory;
-    constructor(_apiRequestService: ApiRequestServiceInterface, authInterface: AuthInterface, errorHandler: ErrorHandlerInterface, exceptionHandler: ExceptionHandlerInterface, promiseLibrary: PromiseLibraryInterface, linkTreeService: LinkTreeServiceInterface);
-}
-export declare function noop(): void;
-export declare function identity(value: any): any;
+import { ApiFormatter, ApiRequestService, CollectionEntryService, CollectionResourceService, ColumnCache, ColumnHandler, ColumnUtil, ConversionMapService, ItemEntryService, KeyService, LockService, QueryService, SocketMessageHandler } from './classes';
+import { ItemCreateService } from './classes/ItemCreateService';
+import { TemplateCache } from './classes/TemplateCache';
+import { ApiResponseProcessorFactory, ChangesCompilationFactory, CollectionEntryFactory, CollectionMatcherFactory, CollectionResourceFactory, ColumnExpansionFactory, ColumnInfoFactory, ColumnSetFactory, ColumnSubsetCacheFactory, CreateRequestFactory, ItemCacheFactory, ItemEntryFactory, ItemResourceFactory, ModuleChangesCompilationFactory, QueryMatcherFactory, QueryParserFactory, RequestColumnExpansionFactory, TemplateFactory, TransactionCacheFactory } from './factories';
+import { ChangesDeltaFactory } from './factories/ChangesDeltaFactory';
+import { ChangesProcessorFactory } from './factories/ChangesProcessorFactory';
+import { ApiRequestServiceInterface, AuthInterface, ErrorHandlerInterface, ExceptionHandlerInterface, PromiseLibraryInterface } from './interfaces';
+import { LinkTreeServiceInterface } from './interfaces/LinkTreeServiceInterface';
+export declare class RmCore {
+    version: string;
+    noop: typeof noop;
+    apiFormatter: ApiFormatter;
+    apiRequestService: ApiRequestService;
+    apiResponseProcessorFactory: ApiResponseProcessorFactory;
+    changesCompilationFactory: ChangesCompilationFactory;
+    changesDeltaFactory: ChangesDeltaFactory;
+    changesProcessorFactory: ChangesProcessorFactory;
+    collectionEntryFactory: CollectionEntryFactory;
+    collectionEntryService: CollectionEntryService;
+    collectionMatcherFactory: CollectionMatcherFactory;
+    collectionResourceFactory: CollectionResourceFactory;
+    collectionResourceService: CollectionResourceService;
+    columnCache: ColumnCache;
+    columnExpansionFactory: ColumnExpansionFactory;
+    columnHandler: ColumnHandler;
+    columnInfoFactory: ColumnInfoFactory;
+    columnSetFactory: ColumnSetFactory;
+    columnSubsetCacheFactory: ColumnSubsetCacheFactory;
+    columnUtil: ColumnUtil;
+    conversionMapService: ConversionMapService;
+    createRequestFactory: CreateRequestFactory;
+    itemCacheFactory: ItemCacheFactory;
+    itemCreateService: ItemCreateService;
+    itemEntryFactory: ItemEntryFactory;
+    itemEntryService: ItemEntryService;
+    itemResourceFactory: ItemResourceFactory;
+    keyService: KeyService;
+    lockService: LockService;
+    moduleChangesCompilationFactory: ModuleChangesCompilationFactory;
+    queryMatcherFactory: QueryMatcherFactory;
+    queryParserFactory: QueryParserFactory;
+    queryService: QueryService;
+    requestColumnExpansionFactory: RequestColumnExpansionFactory;
+    socketMessageHandler: SocketMessageHandler;
+    templateCache: TemplateCache;
+    templateFactory: TemplateFactory;
+    transactionCacheFactory: TransactionCacheFactory;
+    constructor(_apiRequestService: ApiRequestServiceInterface, authInterface: AuthInterface, errorHandler: ErrorHandlerInterface, exceptionHandler: ExceptionHandlerInterface, promiseLibrary: PromiseLibraryInterface, linkTreeService: LinkTreeServiceInterface);
+}
+export declare function noop(): void;
+export declare function identity(value: any): any;