@rentman/rm-core 1.9.0 → 2.0.1

package/dist/src/models/CollectionEntry.d.ts

@@ -1,87 +1,27 @@
-import { ColumnExpansion, ColumnInfo, ColumnSet, ItemCache } from '../classes';
-import { CollectionEntryFactory } from '../factories';
-import { Deferred } from '../interfaces';
-import { CollectionEntryOptions, CollectionResource, ItemEntry } from '../models';
-import { ApiRequestColumns, CollectionQuery, ConversionMap, EntryParentNull, FieldMap, ItemId, ItemIdConversionMap, ItemType, PromiseInterface, QueryCallback } from '../types';
+import { CollectionEntryService, ColumnExpansion, ColumnInfo, ColumnSet, KeyService } from '../classes';
+import { ColumnSetFactory } from '../factories';
+import { CollectionEntryOptions } from '../models';
+import { ApiQuery, ApiRequestColumns, CollectionQuery, EntryParentNull, ItemId, ItemIdConversionMap, ItemType, PromiseInterface, QueryCallback } from '../types';
 export declare class CollectionEntry<ItemTypeType extends ItemType = any> {
-    private factory;
+    private collectionEntryService;
+    private columnSetFactory;
+    private keyService;
     itemType: ItemTypeType;
     options: CollectionEntryOptions;
     id: number;
     parent: EntryParentNull;
     query: CollectionQuery;
     columns: ColumnSet<ItemTypeType>;
-    initial: Array<ItemEntry<ItemTypeType>>;
-    items: Array<ItemEntry<ItemTypeType>>;
-    resources: Array<CollectionResource<ItemTypeType>>;
-    deferred?: Deferred<this>;
-    promise: PromiseInterface<this>;
     reloadQueued: boolean;
-    hasEditResources: boolean;
-    hasItemEditResources: boolean;
-    private templateColumns;
-    constructor(factory: CollectionEntryFactory, itemType: ItemTypeType, options: CollectionEntryOptions);
-    clearResource(resource: CollectionResource): void;
-    clearResources(): void;
-    defer(): this;
-    isDeferred(): boolean;
-    _resolve(): this;
-    resolve(itemEntryCompound: {
-        columns: ColumnSet<ItemTypeType>;
-        initial: Array<ItemEntry<ItemTypeType>>;
-        modified?: Array<ItemEntry<ItemTypeType>>;
-    }): this;
+    promise: PromiseInterface<this>;
+    constructor(collectionEntryService: CollectionEntryService, columnSetFactory: ColumnSetFactory, keyService: KeyService, itemType: ItemTypeType, options: CollectionEntryOptions);
     isLocal(): boolean;
     matchParent(itemType: ItemType, itemId: ItemId): boolean;
-    forEach(callback: (itemEntry: this['items'][0]) => void): void;
-    getItemById(itemId: ItemId): this['items'][0] | undefined;
-    getIdArray(accumulator?: ItemId[]): ItemId[];
-    createItems(valuesArray: Array<FieldMap<ItemTypeType>>): PromiseInterface<Array<ItemEntry<ItemTypeType>>>;
-    resolveDerivedValues(itemEntries: Array<ItemEntry<ItemTypeType>>, localItemCache: ItemCache): PromiseInterface<Array<ItemEntry<ItemTypeType>>>;
-    addItems<U extends CollectionResource<ItemTypeType>>(itemEntries: Array<ItemEntry<ItemTypeType>>, resultResource: U, updateInitial?: boolean, callOnAdd?: boolean, callOnActivate?: boolean): U['items'];
-    addItems(itemEntries: Array<ItemEntry<ItemTypeType>>, resultResource?: null, updateInitial?: boolean, callOnAdd?: boolean, callOnActivate?: boolean): null;
-    addItems<U extends CollectionResource<ItemTypeType>>(itemEntries: Array<ItemEntry<ItemTypeType>>, resultResource?: U | null, updateInitial?: boolean, callOnAdd?: boolean, callOnActivate?: boolean): U['items'] | null;
-    private handleAddedItemCallbacks;
-    removeItems<U extends CollectionResource<ItemTypeType>>(idArray: ItemId[], resultResource: U, updateInitial?: boolean, callOnRemove?: boolean): U['items'];
-    removeItems(idArray: ItemId[], resultResource?: null, updateInitial?: boolean, callOnRemove?: boolean): null;
-    removeItems<U extends CollectionResource<ItemTypeType>>(idArray: ItemId[], resultResource?: U | null, updateInitial?: boolean, callOnRemove?: boolean): U['items'] | null;
-    clear<U extends CollectionResource<ItemTypeType>>(resultResource: U, updateInitial?: boolean, callOnRemove?: boolean): U['items'];
-    clear(resultResource?: null, updateInitial?: boolean, callOnRemove?: boolean): null;
-    handleRemovedItems<U extends CollectionResource<ItemTypeType>>(filterFunction: (itemEntry: this['items'][0]) => boolean, resultResource: U, updateInitial?: boolean, callOnRemove?: boolean): U['items'];
-    handleRemovedItems(filterFunction: (itemEntry: this['items'][0]) => boolean, resultResource?: null, updateInitial?: boolean, callOnRemove?: boolean): null;
-    handleRemovedItems<U extends CollectionResource<ItemTypeType>>(filterFunction: (itemEntry: this['items'][0]) => boolean, resultResource?: U | null, updateInitial?: boolean, callOnRemove?: boolean): U['items'] | null;
-    private handleRemovedItemCallbacks;
-    private createBatchStatus;
-    private expandLocal;
-    private expandRemote;
-    expand(newColumns: ApiRequestColumns, localItemCache: ItemCache): PromiseInterface<this>;
-    extendQuery(callback?: QueryCallback): CollectionQuery;
-    extend<U extends CollectionResource<ItemTypeType>>(queryCallback: QueryCallback, collectionResource?: U, callOnAdd?: boolean): PromiseInterface<U['items']>;
-    extend(queryCallback: QueryCallback, collectionResource?: null, callOnAdd?: boolean): PromiseInterface<null>;
+    extendQuery(callback?: QueryCallback): ApiQuery;
     queueReload(): void;
     expandColumns(columnExpansion: ColumnExpansion<ItemTypeType>): void;
     expandRequestColumns(requestColumns: ApiRequestColumns): void;
-    getAddedItems(returnItemIds: true): ItemId[];
-    getAddedItems(returnItemIds?: boolean): Array<ItemEntry<ItemTypeType>>;
-    getRemovedItems(returnItemIds: true): ItemId[];
-    getRemovedItems(returnItemIds?: boolean): Array<ItemEntry<ItemTypeType>>;
-    getUpdatedItems(): Array<ItemEntry<ItemTypeType>>;
-    hasAddedItems(): boolean;
-    hasRemovedItems(): boolean;
-    hasUpdatedItems(): boolean;
-    /**
-     * @description
-     * Reverts added and removed items
-     *
-     * @remarks
-     * - Doesn't revert changes on the items themselves
-     */
-    revertChanges(): void;
-    onItemsCreated(conversionMap: ConversionMap): void;
-    private onAddInitial;
-    private onRemoveInitial;
     getUpdatedItemColumns(conversionMap: ItemIdConversionMap): {
         [columnId: string]: ColumnInfo<ItemTypeType>;
     };
-    clone(parent: EntryParentNull, conversionMap?: ItemIdConversionMap): CollectionEntry<ItemTypeType>;
 }

package/dist/src/models/CollectionEntryOptions.d.ts

@@ -4,6 +4,7 @@ export declare class CollectionEntryOptions {
     columns: ApiRequestColumns;
     query: ApiQuery | null;
     queryParams: any;
+    queryColumns: ApiRequestColumns;
     parent: EntryParentNull;
     deferRequest: boolean;
     limit: ApiRequestLimit | null;

package/dist/src/models/CollectionResource.d.ts

@@ -1,28 +1,28 @@
-import { LocalCache } from '../classes';
+import { TransactionCache } from '../classes/cache/transaction/TransactionCache';
 import { CollectionResourceFactory } from '../factories';
 import { CollectionEntry, CollectionResourceOptions, ItemEntry, ItemResource, LocalViewResource } from '../models';
-import { ItemResourceItemIdMap, ItemType, PromiseInterface, QueryCallback, ResponseColumnItemTypeMap } from '../types';
+import { ItemId, ItemResourceItemIdMap, ItemType, PromiseInterface, QueryCallback, ResponseColumnItemTypeMap } from '../types';
 export declare abstract class CollectionResource<ItemTypeType extends ItemType = any, T extends ItemResource<ItemTypeType> = LocalViewResource<ItemTypeType>> {
     protected factory: CollectionResourceFactory;
     entry: CollectionEntry<ItemTypeType>;
     options: CollectionResourceOptions<ItemTypeType>;
-    localCache: LocalCache | null;
+    transaction: TransactionCache;
     items: T[];
     columns: ResponseColumnItemTypeMap;
     protected itemIdMap: ItemResourceItemIdMap<T>;
     private readonly onChange;
-    protected constructor(factory: CollectionResourceFactory, entry: CollectionEntry<ItemTypeType>, options: CollectionResourceOptions<ItemTypeType>, localCache: LocalCache | null);
+    protected constructor(factory: CollectionResourceFactory, entry: CollectionEntry<ItemTypeType>, options: CollectionResourceOptions<ItemTypeType>, transaction: TransactionCache);
     onConstruct(): void;
+    getIdArray(): ItemId[];
     getItemById(itemId: number): T;
-    rebuildMap(): void;
-    addItemResources(itemEntries: Array<ItemEntry<ItemTypeType>>): T[];
+    addItemResources(itemEntries: Array<ItemEntry<ItemTypeType>>, _isInitialCall?: boolean): T[];
     /**
      * @description
      * Returns the {@link ItemResource ItemResources} that where removed from the {@link CollectionResource collection}.
      * Filters on {@link ItemResource ItemResource}.{@link ItemEntry entry} === {@link ItemEntry entry}
      */
     removeItemResources(itemEntries: Array<ItemEntry<ItemTypeType>>): T[];
-    callOnAdd(itemResources: T[]): void;
+    callOnAdd(itemResources: T[], isInitialCall?: boolean): void;
     callOnRemove(itemResources: T[]): void;
     forEach(callback: (itemResource: T) => void): void;
     filter(callback: (itemResource: T) => boolean): T[];
@@ -33,20 +33,20 @@ export declare abstract class CollectionResource<ItemTypeType extends ItemType =
     };
     map<U>(argument: string | ((itemResource: T) => U)): U[];
     reduce<U>(callback: (itemResource: T, value: U) => U, value: U): U;
-    extend(queryCallback: QueryCallback, returnAllItems?: boolean, callOnAdd?: boolean): PromiseInterface<T[]>;
     /**
      * @description
-     * Removes the reference to the {@link CollectionResource CollectionResource} from the {@link CollectionEntry CollectionEntry}
+     * Fetches new items and adds them to the collection
      *
      * @remarks
-     * - Doesn't revert changes on the items themselves
+     * - Used to return {@link ItemResource ItemResources}, but you should the {@link CollectionResource.onAdd onAdd) instead
      */
-    clearResource(clearItems?: boolean): void;
+    extend(queryCallback: QueryCallback): PromiseInterface<CollectionEntry<ItemTypeType>>;
     /**
-     * @deprecated
+     * @description
+     * Removes the reference to the {@link CollectionResource CollectionResource} from the {@link CollectionEntry CollectionEntry}
      *
      * @remarks
-     * - Does *not* clear resources
+     * - Doesn't revert changes on the items themselves
      */
-    deactivate(): void;
+    clearResource(clearItems?: boolean): void;
 }

package/dist/src/models/CollectionResourceOptions.d.ts

@@ -1,6 +1,7 @@
 import { CollectionEntry, CollectionResource, ItemEntry, ItemResource } from '../models';
 import { ConversionMap, ItemType, OnChangeFunction } from '../types';
 export declare type CollectionResourceCallback<ItemTypeType extends ItemType> = (itemResources: Array<ItemResource<ItemTypeType>>, collectionResource: CollectionResource<ItemTypeType>) => void;
+export declare type CollectionResourceOnAddCallback<ItemTypeType extends ItemType> = (itemResources: Array<ItemResource<ItemTypeType>>, collectionResource: CollectionResource<ItemTypeType>, isInitialCall: boolean) => void;
 export declare type CollectionResourceInitialCallback<ItemTypeType extends ItemType> = (itemEntries: Array<ItemEntry<ItemTypeType>>, collectionEntry: CollectionEntry<ItemTypeType>) => void;
 export declare type OnItemsCreatedCallback = (conversionMap: ConversionMap) => void;
 export declare type CollectionResourceOptionsInterface<ItemTypeType extends ItemType> = Partial<CollectionResourceOptions<ItemTypeType>>;
@@ -8,11 +9,14 @@ export declare class CollectionResourceOptions<ItemTypeType extends ItemType> {
     editItems: boolean;
     remoteItems: boolean;
     editCollection: boolean;
-    modInstant: boolean;
     enableSave: boolean;
+    /**
+     * @deprecated
+     * You should use itemResource.onChange and compare previous.id with fields.id
+     */
     onItemsCreated: OnItemsCreatedCallback;
     onChange: OnChangeFunction;
-    onAdd: CollectionResourceCallback<ItemTypeType>;
+    onAdd: CollectionResourceOnAddCallback<ItemTypeType>;
     onRemove: CollectionResourceCallback<ItemTypeType>;
     onAddInitial: CollectionResourceInitialCallback<ItemTypeType>;
     onRemoveInitial: CollectionResourceInitialCallback<ItemTypeType>;

package/dist/src/models/CollectionViewResource.d.ts

@@ -1,7 +1,7 @@
-import { LocalCache } from '../classes';
+import { TransactionCache } from '../classes/cache/transaction/TransactionCache';
 import { CollectionResourceFactory } from '../factories';
 import { CollectionEntry, CollectionResource, CollectionResourceOptions, ItemResource, LocalViewResource } from '../models';
 import { ItemType } from '../types';
 export declare class CollectionViewResource<ItemTypeType extends ItemType = any, T extends ItemResource<ItemTypeType> = LocalViewResource<ItemTypeType>> extends CollectionResource<ItemTypeType, T> {
-    constructor(collectionResourceFactory: CollectionResourceFactory, collectionEntry: CollectionEntry<ItemTypeType>, options: CollectionResourceOptions<ItemTypeType>, localCache: LocalCache | null);
+    constructor(collectionResourceFactory: CollectionResourceFactory, collectionEntry: CollectionEntry<ItemTypeType>, options: CollectionResourceOptions<ItemTypeType>, transactionCache: TransactionCache);
 }

package/dist/src/models/EditResource.d.ts

@@ -1,18 +1,16 @@
-import { LocalCache } from '../classes';
+import { TransactionCache } from '../classes/cache/transaction/TransactionCache';
 import { ItemResourceFactory } from '../factories';
 import { ItemEntry, ItemResource, ItemResourceOptions } from '../models';
 import { FieldMap, ItemType, PromiseInterface } from '../types';
 export declare class EditResource<ItemTypeType extends ItemType = any> extends ItemResource<ItemTypeType> {
     protected localCopies: Array<FieldMap<ItemTypeType>>;
-    protected transactions: number;
-    constructor(factory: ItemResourceFactory, entry: ItemEntry<ItemTypeType>, options: ItemResourceOptions, isNew: boolean, localCache: LocalCache | null);
+    fields: FieldMap<ItemTypeType>;
+    constructor(factory: ItemResourceFactory, entry: ItemEntry<ItemTypeType>, options: ItemResourceOptions, isNew: boolean, transaction: TransactionCache);
     isNew(): boolean;
-    start(): this;
-    rollback(): this;
-    commit(callOnChange?: boolean): this;
-    getLocalCopy(): FieldMap<ItemTypeType> | null;
     copyFields(destination?: FieldMap<ItemTypeType>): FieldMap<ItemTypeType>;
-    setFields(values: FieldMap<ItemTypeType>, callOnChange?: boolean): this;
-    callOnChange(previous?: FieldMap<ItemTypeType>): this;
-    save(parameters?: any): PromiseInterface<this>;
+    /**
+     * @description
+     * Updates the fields of the item and calls onChange, when updating many fields of many items it's better to create a {@link ChangesDelta ChangesDelta} yourself so all changes can be applied at once
+     */
+    setFields(values: FieldMap<ItemTypeType>): PromiseInterface<this>;
 }

package/dist/src/models/ItemEntry.d.ts

@@ -1,8 +1,6 @@
 import { ColumnSet } from '../classes';
 import { ItemEntryFactory } from '../factories';
-import { Deferred } from '../interfaces';
-import { ItemResource } from '../models';
-import { ColumnExpansionResult, EntryParentNull, FieldMap, ItemError, ItemId, ItemIdConversionMap, ItemType, PromiseInterface } from '../types';
+import { ItemId, ItemType } from '../types';
 export declare class ItemEntry<ItemTypeType extends ItemType = any> {
     private factory;
     itemType: ItemTypeType;
@@ -10,67 +8,12 @@ export declare class ItemEntry<ItemTypeType extends ItemType = any> {
     columns: ColumnSet<ItemTypeType>;
     id: number;
     reloadQueued: boolean;
-    deferRequest: boolean;
-    deferred?: Deferred<this>;
-    parent: EntryParentNull;
-    initial: FieldMap<ItemTypeType>;
-    modified: FieldMap<ItemTypeType>;
-    derived: FieldMap<ItemTypeType>;
-    resources: Array<ItemResource<ItemTypeType>>;
     constructor(factory: ItemEntryFactory, itemType: ItemTypeType, itemId: ItemId, columns: ColumnSet<ItemTypeType>);
     queueReload(): this;
-    clearResource(resource: ItemResource): void;
-    clearResources(): void;
-    defer(deferRequest?: boolean): this;
-    getPromise(): PromiseInterface<this>;
-    resolve(): this;
-    resolveDeferred(initial: FieldMap, derived: FieldMap, columns: ColumnSet<ItemTypeType>): this;
-    isDeferred(): boolean;
-    reject(error?: ItemError): this;
-    setFields(initial: FieldMap<ItemTypeType>, derived: FieldMap): this;
-    setLocalFields(initialValues: FieldMap, conversionMap: ItemIdConversionMap, columns?: ColumnSet<ItemTypeType>): this;
-    clone(conversionMap?: ItemIdConversionMap): ItemEntry<ItemTypeType>;
-    resetDerived(columnIds: string[]): this;
-    getFields(): FieldMap<ItemTypeType>;
-    expand(main: FieldMap, derived: FieldMap, columnExpansionResult: ColumnExpansionResult<ItemTypeType>): this;
-    expandLocal(columnExpansionResult: ColumnExpansionResult<ItemTypeType>): this;
-    private setLocalValues;
-    /**
-     * @description
-     * Updates the {@link ItemEntry.initial initial}, {@link ItemEntry.modified modified} and {@link ItemEntry.derived derived} properties in-place to preserve references in existing {@link ItemResource ItemResources}.
-     *
-     * @remarks
-     * - Assumes the {@link ItemEntry.initial initial}, {@link ItemEntry.modified modified} and {@link ItemEntry.derived derived} properties are already set.
-     */
-    updateFields(fields: FieldMap<ItemTypeType>, derived?: FieldMap | null, overwrite?: boolean): this;
-    private updateItemValues;
-    updateItemFields(conversionMap: ItemIdConversionMap, columns?: ColumnSet<ItemTypeType>): this;
-    formatRequest(): FieldMap<ItemTypeType>;
-    setDisplayName(): this;
-    getDisplayName(): string;
-    /**
-     * @param returnAll Returns all initial values if true
-     */
-    getChanges(returnAll?: boolean): FieldMap<any>;
     isLocal(): boolean;
     isLockable(): boolean;
-    hasChanges(): boolean;
-    resetModified(): this;
-    setInitial(values: FieldMap, enableCallbacks?: boolean): this;
-    /**
-     * @remarks
-     * - Does a shallow copy of values!
-     */
-    setModified(values?: FieldMap<ItemTypeType>): this;
-    setDerived(values: FieldMap): this;
-    setParent(parentType: ItemType, parentId: ItemId): this;
-    callOnChange(previous?: FieldMap<ItemTypeType>): this;
     toJSON(): {
         id: number;
-        parent: EntryParentNull;
-        initial: FieldMap<ItemTypeType>;
-        modified: FieldMap<ItemTypeType>;
-        derived: FieldMap<ItemTypeType>;
         columns: ColumnSet<ItemTypeType>;
     };
 }

package/dist/src/models/ItemEntryOptions.d.ts

@@ -5,6 +5,5 @@ export declare class ItemEntryOptions {
     parent: EntryParentNull;
     templateOptions: any;
     templateColumns: ApiRequestColumnMap;
-    deferRequest: boolean;
     constructor(values: ItemEntryOptionsInterface);
 }

package/dist/src/models/ItemResource.d.ts

@@ -1,4 +1,4 @@
-import { LocalCache } from '../classes';
+import { TransactionCache } from '../classes';
 import { ItemResourceFactory } from '../factories';
 import { ItemEntry, ItemResourceOptions } from '../models';
 import { FieldMap, ItemType, ResponseColumn } from '../types';
@@ -7,14 +7,38 @@ export declare abstract class ItemResource<ItemTypeType extends ItemType = any>
     readonly entry: ItemEntry<ItemTypeType>;
     readonly options: ItemResourceOptions<ItemResource<ItemTypeType>>;
     protected readonly _isNew: boolean;
-    protected readonly localCache: LocalCache | null;
+    protected readonly transaction: TransactionCache;
     columns: {
         [columnId: string]: ResponseColumn;
     };
-    fields: FieldMap<ItemTypeType>;
-    derived: FieldMap<ItemTypeType>;
-    protected constructor(factory: ItemResourceFactory, entry: ItemEntry<ItemTypeType>, options: ItemResourceOptions<ItemResource<ItemTypeType>>, _isNew: boolean, localCache: LocalCache | null);
+    fields: Readonly<FieldMap<ItemTypeType>>;
+    initial: Readonly<FieldMap<ItemTypeType>>;
+    protected constructor(factory: ItemResourceFactory, entry: ItemEntry<ItemTypeType>, options: ItemResourceOptions<ItemResource<ItemTypeType>>, _isNew: boolean, transaction: TransactionCache);
     onConstruct(): void;
+    /**
+     * @deprecated
+     * Use {@link TransactionCache.applyChangesDelta transaction.applyChangesDelta} instead
+     */
+    callOnChange(previous: FieldMap<ItemTypeType>): void;
+    /**
+     * @description
+     * Utility function to easily check if a field is changed.
+     * Will return `false` if the field is changed
+     *
+     * @example
+     * onChange: (
+     *     itemResource,
+     *     previous,
+     *     compareItemField
+     * ) {
+     *     if (!compareItemField('columnId')) {
+     *         processItem(itemResource);
+     *     }
+     * }
+     */
+    compareItemField(columnId: keyof FieldMap<ItemTypeType>, previous: FieldMap<ItemTypeType>): boolean;
+    hasChanges(): boolean;
+    setTransactionParameters(parameters: any): void;
     /**
      * @description
      * 'isNew' means that the {@link ItemEntry ItemEntry} is a local item and that this resource was created when the {@link ItemEntry ItemEntry} was first created
@@ -23,23 +47,32 @@ export declare abstract class ItemResource<ItemTypeType extends ItemType = any>
     isLocal(): boolean;
     /**
      * @description
-     * Removes the reference to the {@link ItemResource ItemResource} from the {@link ItemEntry ItemEntry}
+     * Removes the reference to the {@link ItemResource ItemResource} from the {@link TransactionCache TransactionCache}, so that the OnChange callback won't be called anymore.
      *
      * Warning:
-     * This doesn't revert any changes made to the item, in order to revert the changes you should use {@link EditResource.start start} and {@link EditResource.rollback rollback}.
+     * This doesn't revert any changes made to the item, in order to revert the changes you should use {@link TransactionItemHandler.clearItemEntry TransactionItemHandler.clearItemEntry}
      */
     clearResource(): void;
-    /**
-     * @deprecated
-     *
-     * @remarks
-     * - Does *not* clear resources
-     */
-    deactivate(): void;
     toJSON(): {
         columns: string[];
-        fields: FieldMap<ItemTypeType>;
-        derived: FieldMap<ItemTypeType>;
+        fields: Readonly<FieldMap<ItemTypeType>>;
         entry: ItemEntry<ItemTypeType>;
     };
+    /**
+     * @description
+     * Returns the value of the columnPath, or undefined when the path couldn't be traversed
+     *
+     * @param columnPath Can either be an array of columnIds (['column', 'column2']) or a config column string ('column>column2')
+     */
+    getDerivedValue<T extends any = any>(columnPath: string[] | string): T | undefined;
+    /**
+     * @description
+     * Traverses the column path and returns the fields of the derived item, returns undefined if the item isn't found
+     *
+     * ---------------------
+     *
+     * @remark
+     * Assumes the derived item's values are already cached
+     */
+    getDerivedValues(columnPath: string[]): Readonly<FieldMap> | undefined;
 }

package/dist/src/models/LocalViewResource.d.ts

@@ -1,7 +1,7 @@
-import { LocalCache } from '../classes';
+import { TransactionCache } from '../classes/cache/transaction/TransactionCache';
 import { ItemResourceFactory } from '../factories';
 import { ItemEntry, ItemResourceOptions, ViewResource } from '../models';
 import { ItemType } from '../types';
 export declare class LocalViewResource<ItemTypeType extends ItemType = any> extends ViewResource<ItemTypeType> {
-    constructor(factory: ItemResourceFactory, entry: ItemEntry<ItemTypeType>, options: ItemResourceOptions, isNew: boolean, localCache: LocalCache | null);
+    constructor(factory: ItemResourceFactory, entry: ItemEntry<ItemTypeType>, options: ItemResourceOptions, isNew: boolean, transaction: TransactionCache);
 }

package/dist/src/models/RemoteViewResource.d.ts

@@ -1,7 +1,7 @@
-import { LocalCache } from '../classes';
+import { TransactionCache } from '../classes/cache/transaction/TransactionCache';
 import { ItemResourceFactory } from '../factories';
 import { ItemEntry, ItemResourceOptions, ViewResource } from '../models';
 import { ItemType } from '../types';
 export declare class RemoteViewResource<ItemTypeType extends ItemType = any> extends ViewResource<ItemTypeType> {
-    constructor(factory: ItemResourceFactory, entry: ItemEntry<ItemTypeType>, options: ItemResourceOptions<RemoteViewResource<ItemTypeType>>, isNew: boolean, localCache: LocalCache | null);
+    constructor(factory: ItemResourceFactory, entry: ItemEntry<ItemTypeType>, options: ItemResourceOptions<RemoteViewResource<ItemTypeType>>, isNew: boolean, transaction: TransactionCache);
 }

package/dist/src/models/ViewResource.d.ts

@@ -1,8 +1,8 @@
-import { LocalCache } from '../classes';
+import { TransactionCache } from '../classes/cache/transaction/TransactionCache';
 import { ItemResourceFactory } from '../factories';
 import { ItemEntry, ItemResource, ItemResourceOptions } from '../models';
 import { FieldMap, ItemType } from '../types';
 export declare abstract class ViewResource<ItemTypeType extends ItemType = any> extends ItemResource<ItemTypeType> {
     fields: Readonly<FieldMap<ItemTypeType>>;
-    protected constructor(factory: ItemResourceFactory, entry: ItemEntry<ItemTypeType>, options: ItemResourceOptions<ViewResource<ItemTypeType>>, isNew: boolean, localCache: LocalCache | null);
+    protected constructor(factory: ItemResourceFactory, entry: ItemEntry<ItemTypeType>, options: ItemResourceOptions<ViewResource<ItemTypeType>>, isNew: boolean, transaction: TransactionCache);
 }

package/dist/src/types/ItemTypesCollection.d.ts

@@ -1,11 +1,14 @@
 import { ApiResponseProcessor, CollectionMatcher, ColumnSet, RequestColumnExpansion } from '../classes';
-import { ENTRY_STATUS } from '../constants';
 import { CollectionEntry, CollectionEntryOptions, CollectionEntryOptionsInterface, CollectionResource, CollectionResourceOptions, CollectionResourceOptionsInterface, ItemEntry, ItemEntryOptionsInterface, ItemResource, ItemResourceOptionsInterface } from '../models';
 export declare type EntryParent = {
     itemType: string;
     itemId: number;
 };
 export declare type EntryParentNull = EntryParent | null;
+/**
+ * @description
+ * Used for fields that belong to a specific itemType
+ */
 export declare type FieldMap<_ItemTypeType extends ItemType = any> = {
     [key: string]: any;
 };
@@ -21,7 +24,12 @@ export interface CollectionDefinition<ItemTypeType extends ItemType = any> {
 export interface LinkCollectionDefinition<ItemTypeType extends ItemType = any> extends CollectionDefinition<ItemTypeType> {
     linkField: string;
 }
-export declare type OnChangeFunction<ItemResourceType extends ItemResource<any> = ItemResource<any>> = (itemResource: ItemResourceType, previous?: FieldMap<ItemResourceType['entry']['itemType']>) => void;
+export declare type OnChangeFunction<ItemResourceType extends ItemResource<any> = ItemResource<any>> = (itemResource: ItemResourceType, previous: FieldMap<ItemResourceType['entry']['itemType']>, 
+/**
+ * @description
+ * Returns 'true' if the field changed
+ */
+compareField: (field: keyof FieldMap<ItemResourceType['entry']['itemType']>) => boolean) => void;
 export declare const enum StateKeyType {
     New = "new",
     Duplicate = "duplicate"
@@ -55,6 +63,58 @@ export interface SocketMessage {
     body: any;
     messageType: SocketMessageType;
 }
+export interface SocketMessageCreate extends SocketMessage {
+    body: {
+        eventType: 'create';
+        columns: ResponseColumnItemTypeMap;
+        itemType: ItemType;
+        items: {
+            [itemType: string]: {
+                [itemId: number]: {
+                    parent: null | EntryParent;
+                    values: FieldMap;
+                };
+            };
+        };
+    };
+}
+export interface SocketMessageUpdate extends SocketMessage {
+    body: {
+        eventType: 'update';
+        columns: ResponseColumnItemTypeMap;
+        itemType: ItemType;
+        items: {
+            [itemType: string]: {
+                [itemId: number]: {
+                    parent: null | EntryParent;
+                    values: FieldMap;
+                };
+            };
+        };
+    };
+}
+export interface SocketMessageLinkTo extends SocketMessage {
+    body: {
+        eventType: 'linkto';
+        columns: ResponseColumnItemTypeMap;
+        itemType: ItemType;
+        items: {
+            [itemType: string]: {
+                [itemId: number]: {
+                    parent: null | EntryParent;
+                    values: FieldMap;
+                };
+            };
+        };
+    };
+}
+export interface SocketMessageDelete extends SocketMessage {
+    body: {
+        eventType: 'delete';
+        itemType: ItemType;
+        items: ItemId[];
+    };
+}
 export interface FunctionChangesResolveSocketMessage extends SocketMessage {
     body: {
         itemType: 'FunctionChangesResolve';
@@ -75,14 +135,6 @@ export declare type ItemMap<T> = {
     };
 };
 export declare type ItemEntryMap<ItemTypeType extends ItemType> = ItemMap<ItemEntry<ItemTypeType>>;
-export declare type LinkedItemEntryMap<ItemTypeType extends ItemType = any> = {
-    itemType: ItemTypeType;
-    itemEntries: Array<ItemEntry<ItemTypeType>>;
-    columnSet: ColumnSet<ItemTypeType>;
-};
-export declare type EntryStatusMap<T> = {
-    [entryStatus: string]: T[];
-};
 export declare type ItemEntryParentIdMap<ItemTypeType extends ItemType> = {
     [parentId: number]: Array<ItemEntry<ItemTypeType>>;
 };
@@ -126,7 +178,7 @@ export declare type ResponseColumnMap = {
 export declare type ResponseColumnItemTypeMap = {
     [itemType: string]: ResponseColumnMap;
 };
-export declare type ColumnExpansionResult<ItemTypeType extends ItemType> = {
+export declare type ColumnExpansionResult<ItemTypeType extends ItemType = any> = {
     merged: ColumnSet<ItemTypeType>;
     difference: ColumnSet<ItemTypeType>;
 };
@@ -141,16 +193,8 @@ export declare type TemplateItemResourceMap<T extends ItemResource<any>> = {
     main: T;
     linked: ItemResourcesItemTypeMap;
 };
-export declare type TemplateItemEntryMap<ItemTypeType extends ItemType> = {
-    main: ItemEntry<ItemTypeType>;
-    linked: Array<LinkedItemEntryMap<ItemType>>;
-};
-export declare type ItemTypeMap = {
-    [itemType: string]: any;
-};
-export declare type EntryStatus<T> = {
-    entry: T;
-    status: ENTRY_STATUS;
+export declare type ItemTypeMap<T = any> = {
+    [itemType: string]: T;
 };
 export declare type ApiQuery = any;
 export declare type ApiRequestItemValues = {
@@ -193,5 +237,20 @@ export declare type CreateRequestEntry<ItemTypeType extends ItemType> = {
     };
     columns: RequestColumnExpansion;
     items: ItemEntryMap<ItemTypeType>;
-    collections: CollectionMatcher<ItemTypeType>;
+    collections: CollectionMatcher;
+};
+export declare enum ApiLinkTreeType {
+    ITEMTABLE = "itemtable",
+    DIRECT = "direct"
+}
+export declare type ApiLinkTreeEntry = {
+    type: ApiLinkTreeType.ITEMTABLE;
+} | {
+    type: ApiLinkTreeType.DIRECT;
+    field: string;
+};
+export declare type ApiLinkTree = {
+    [itemType: string]: {
+        [childType: string]: ApiLinkTreeEntry;
+    };
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rentman/rm-core",
-  "version": "1.9.0",
+  "version": "2.0.1",
   "description": "Rentman core functionalities",
   "main": "./dist/rm-core.js",
   "types": "./dist/src/index.d.ts",

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

@@ -1,28 +0,0 @@
-import { ENTRY_STATUS } from '../constants';
-import { PromiseLibraryInterface } from '../interfaces';
-import { CollectionEntry, ItemEntry } from '../models';
-import { EntryStatus, EntryStatusMap, ItemId, ItemType, PromiseInterface } from '../types';
-export declare class BatchStatus<ItemTypeType extends ItemType, T extends ItemEntry<ItemTypeType> | CollectionEntry<ItemTypeType>> {
-    private promiseService;
-    itemType: ItemTypeType;
-    getItemId: (itemEntry: T) => ItemId;
-    getPromise: (itemEntry: T) => PromiseInterface<T>;
-    readonly requestStatus: ENTRY_STATUS[];
-    readonly remoteExpandStatus: ENTRY_STATUS[];
-    readonly localExpandStatus: ENTRY_STATUS[];
-    entries: EntryStatusMap<T>;
-    constructor(promiseService: PromiseLibraryInterface, itemType: ItemTypeType, getItemId: (itemEntry: T) => ItemId, getPromise: (itemEntry: T) => PromiseInterface<T>);
-    add(entryStatus: EntryStatus<T>): void;
-    hasEntries(statusArray: ENTRY_STATUS[]): boolean;
-    hasRequests(): boolean;
-    forEachEntry(statusArray: ENTRY_STATUS[], callback: (entry: T, itemId: ItemId) => void): void;
-    reduceEntries<U>(statusArray: ENTRY_STATUS[], callback: (entry: T, itemId: ItemId, destination: U) => void, destination: U): U;
-    reduceAllEntries<U>(callback: (entry: T, itemId: ItemId, destination: U) => void, destination: U): U;
-    getPromises(): PromiseInterface<T[]>;
-    getItemIds(statusArray: ENTRY_STATUS[]): ItemId[];
-    getRequestIds(): ItemId[];
-    getArray(statusArray?: ENTRY_STATUS[]): T[];
-    getMap(): {
-        [itemId: string]: T;
-    };
-}