@rentman/rm-core 1.1.10 → 1.1.12

package/changelog.md

@@ -1,6 +1,28 @@
 #Changelog
 Contains new features, breaking changes and their reasoning
 
+##v1.12
+- **Breaking:** `ItemResource.isNew` returns true *only* if the resource was created using 
+`ItemAdministrator.getNewResource` or `ItemAdministrator.getItemByDef`. This fixes an issue where items where removed
+from the local cache inadvertently.
+- The `start`, `commit` and `rollback` functions of `EditResource` now return the resource itself to facilitate chaining.
+- When calling `CollectionEntry.revertChanges`, callbacks like `onAdd` / `onRemove` and `onActivate` / `onDeactivate`
+are now respected. This fixes an issue where items where *not* removed from the local cache.
+- When removing *local* items from collections, they are removed from `initial` as well as `modified`. This fixes an
+issue where changes were being detected continuously.
+- Updated the order of requests in `changesProcessor`. The `update` request is now executed before the `delete` request,
+except when updating documents. This fixes several issues.
+- `CollectionCache` now uses a map instead of an array to store collections. This fixes an issue where the same
+collection was added multiple times.
+- Updated all models to use dependency objects. This increases ease of debugging.
+
+##v.1.11
+- Fixed issue that occurs when saving when having an existing item refer to a newly created item.
+- **Breaking:** Removed `ItemResourceService.isNewResource`.
+- **Breaking:** Renamed `ItemResource.isNewResource` to `ItemResource.isNew`. Removed parameter.
+- `ItemResource.isNew` is equivalent to `ItemResource.isLocal`, while `EditResource.isNew` checks also checks for
+ completed transactions. 
+
 ##v.1.10
 - Fixed issue where changes on different subtabs were not detected.
 

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

@@ -27,7 +27,7 @@ export declare class ApiFormatter {
     formatRequestDate(value: any): any;
     formatRequestDuration(value: any): any;
     formatRequestColor(value: any): any;
-    getDefaultValue(columnType: any): false | 0 | "" | moment.Moment | moment.Duration | "0" | "#000000" | null;
+    getDefaultValue(columnType: any): false | moment.Moment | 0 | moment.Duration | "" | "0" | "#000000" | null;
     isDefaultValue(columnType: any, value: any): any;
     clone(columnType: any, value: any): any;
     getCloneFunction(columnType: any): (date: any) => any;

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

@@ -17,6 +17,8 @@ export declare class ChangesProcessor {
     private promiseService;
     constructor(apiRequestService: ApiRequestServiceInterface, itemHandler: ItemHandler, errorHandler: ErrorHandlerInterface, collectionHandler: CollectionHandler, changesCompilationFactory: ChangesCompilationFactory, createRequestFactory: CreateRequestFactory, columnExpansionFactory: ColumnExpansionFactory, requestColumnExpansionFactory: RequestColumnExpansionFactory, collectionEntryService: CollectionEntryService, apiFormatter: ApiFormatter, promiseService: PromiseInterface);
     getItemTypeUpdatePriority(itemType: any): 0 | 1 | 2;
+    isDocumentItemType(itemType: any): boolean;
+    isDocumentUpdate(compilation: any): boolean;
     buildMoveRequest(compilationEntries: any): {};
     getMapValue(itemType: any, itemId: any, map: any): any;
     private executeCreateRequests(changesCompilation, parameters, conversionMap, breakupByParent?, onAfterCreateCallback?);

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

@@ -1,12 +1,16 @@
 import { QueryMatcherFactory } from '../factories';
 import { CollectionEntry, CollectionResource } from '../models';
-import { CollectionEntryItemTypeMap, CollectionMatchResult, EntryParentNull, FieldMap, ItemType } from '../types';
+import { CollectionMatchResult, EntryParentNull, FieldMap, ItemType } from '../types';
 export declare class CollectionCache {
     private queryMatcherFactory;
-    entries: CollectionEntryItemTypeMap;
+    entries: {
+        [itemType: string]: {
+            [collectionEntryId: number]: CollectionEntry;
+        };
+    };
     constructor(queryMatcherFactory: QueryMatcherFactory);
     contains(collectionEntry: CollectionEntry): boolean;
-    some(callback: (entry: CollectionEntry) => void): boolean;
+    some(callback: (entry: CollectionEntry) => boolean): boolean;
     forEach(callback: (entry: CollectionEntry) => void): void;
     toArray(): CollectionEntry[];
     add(collectionEntry: CollectionEntry): CollectionEntry;

package/dist/dist/classes/ItemAdministrator.d.ts

@@ -2,7 +2,7 @@ import { CollectionCache, CollectionEntryService, CollectionHandler, CollectionM
 import { CollectionMatcherFactory, ColumnSetFactory, LocalCacheFactory, ModuleChangesCompilationFactory } from '../factories';
 import { ApiRequestServiceInterface, AuthInterface, ErrorHandlerInterface, LocalCacheManagerInterface, PromiseInterface } from '../interfaces';
 import { CollectionEntry, CollectionResource, ItemEntry, ItemResource } from '../models';
-import { CollectionEntryParentIdMap, CollectionResourceParentIdMap, CreateRequestParameterMap, ItemId, ItemIdConversionMap, ItemResourceItemTypeMap, ItemType, TemplateResponseItemEntryMap, TemplateResponseLinkedItemEntryMap } from '../types';
+import { CollectionEntryParentIdMap, CollectionResourceParentIdMap, CreateRequestParameterMap, ItemDefinition, ItemId, ItemIdConversionMap, ItemOptions, ItemResourceItemTypeMap, ItemType, TemplateResponseItemEntryMap, TemplateResponseLinkedItemEntryMap } from '../types';
 export declare class ItemAdministrator {
     private apiRequestService;
     private authInterface;
@@ -22,11 +22,7 @@ export declare class ItemAdministrator {
     private promiseInterface;
     private queryService;
     constructor(apiRequestService: ApiRequestServiceInterface, authInterface: AuthInterface, collectionEntryService: CollectionEntryService, collectionHandler: CollectionHandler, collectionMatcherFactory: CollectionMatcherFactory, collectionResourceService: CollectionResourceService, columnSetFactory: ColumnSetFactory, errorHandler: ErrorHandlerInterface, itemEntryService: ItemEntryService, itemHandler: ItemHandler, itemRequestService: ItemRequestService, keyService: KeyService, localCacheFactory: LocalCacheFactory, localCacheManager: LocalCacheManagerInterface, moduleChangesCompilationFactory: ModuleChangesCompilationFactory, promiseInterface: PromiseInterface, queryService: QueryService);
-    getItemDefinition(itemType: ItemType, itemId: any, options: any): {
-        itemType: string;
-        options: any;
-        itemId: any;
-    };
+    getItemDefinition(itemType: ItemType, stateKey: number | string, options: ItemOptions): ItemDefinition;
     getCollectionMatcher(itemEntries: ItemEntry[], addToTab: boolean): CollectionMatcher;
     fetchTitle(itemType: any, itemId: any, deferRequest: any): Promise<any>;
     getItemById(itemType: ItemType, itemId: ItemId, options: any): Promise<ItemResource>;
@@ -70,7 +66,7 @@ export declare class ItemAdministrator {
     getLinkCollections(linkType: string, linkIdArray: number[], itemType: string, options: any): Promise<CollectionResourceParentIdMap>;
     getLinkCollectionsFromDef(definition: any): Promise<CollectionResourceParentIdMap>;
     getAllLinkCollections(linkType: string, itemType: string, options: any): Promise<CollectionEntryParentIdMap>;
-    getItemByDef(definition: any, isRoot: boolean): Promise<any>;
+    getItemByDef(definition: ItemDefinition, isRoot?: boolean): Promise<any>;
     cloneItem(itemResource: ItemResource, options: any): ItemResource;
     cloneCollection(collectionResource: CollectionResource, options: any, conversionMap: any): CollectionResource;
     saveCurrentLocalCache(closeTab?: boolean, parameters?: CreateRequestParameterMap, breakupByParent?: boolean, onAfterCreateCallback?: (conversionMap: ItemIdConversionMap) => void): any;
@@ -81,10 +77,10 @@ export declare class ItemAdministrator {
         itemId: number;
         items: any;
     };
-    addSingleItem(itemEntry: ItemEntry, options: any, isRoot?: boolean, localCache?: LocalCache): ItemResource;
-    addSingleItems(itemEntries: ItemEntry[], options: any): ItemResource[];
+    addSingleItem(itemEntry: ItemEntry, options: ItemOptions, isRoot?: boolean, localCache?: LocalCache): ItemResource;
+    addSingleItems(itemEntries: ItemEntry[], options: ItemOptions): ItemResource[];
     addCollection(collectionEntry: CollectionEntry, options: any): CollectionResource;
-    processLinkedItems(linkedEntries: TemplateResponseLinkedItemEntryMap[], options: any, addToCollections: boolean): ItemResourceItemTypeMap;
+    processLinkedItems(linkedEntries: TemplateResponseLinkedItemEntryMap[], options: ItemOptions, addToCollections: boolean): ItemResourceItemTypeMap;
     getLocalCache(): LocalCache;
     resetLocalCache(): void;
     addToCollections(itemEntries: ItemEntry[], resultCollectionResource?: CollectionResource): ItemResource[] | null;

package/dist/dist/classes/ItemResourceService.d.ts

@@ -1,7 +1,5 @@
-import { EditResource } from '../models';
 export declare class ItemResourceService {
     constructor();
     processOptions(options: any): any;
     compareOptions(first: any, second: any): boolean;
-    isNewResource(resource: EditResource): boolean;
 }

package/dist/dist/classes/KeyService.d.ts

@@ -1,19 +1,11 @@
-import { ItemId } from '../types';
+import { ItemId, StateKey } from '../types';
 export declare class KeyService {
     separator: string;
     constructor();
     getSingleKey(itemType: string, itemId: number | string): string;
     getCollectionCacheKey(parentType: string, parentId: number, childType: string): string;
     getCssKey(): any;
-    parseStateKey(stateKey: string): {
-        type: string;
-        template: string;
-        itemId?: undefined;
-    } | {
-        type: string;
-        itemId: string;
-        template?: undefined;
-    } | null;
+    parseStateKey(stateKey: string): StateKey | null;
     getDuplicateStateKey(itemId: string | number): string;
     getNewStateKey(templateType: string): string;
     getLocalId(): ItemId;

package/dist/dist/classes/LocalCache.d.ts

@@ -2,7 +2,7 @@ import { CollectionCache, ItemCache, ItemResourceService, LockService } from '..
 import { ChangesProcessorFactory, CollectionCacheFactory, CollectionResourceFactory, ItemCacheFactory, ItemResourceFactory } from '../factories';
 import { ErrorHandlerInterface, PromiseInterface } from '../interfaces';
 import { CollectionEntry, CollectionResource, ItemEntry, ItemResource } from '../models';
-import { CollectionEntryParentIdMap, CreateRequestParameterMap, ItemIdConversionMap } from '../types';
+import { CollectionEntryParentIdMap, CreateRequestParameterMap, ItemIdConversionMap, ItemOptions } from '../types';
 export declare class LocalCache {
     private errorHandler;
     private lockService;
@@ -27,8 +27,8 @@ export declare class LocalCache {
     changesInterval: null | number;
     hasChanges: boolean;
     constructor(errorHandler: ErrorHandlerInterface, lockService: LockService, itemResourceFactory: ItemResourceFactory, collectionCacheFactory: CollectionCacheFactory, changesProcessorFactory: ChangesProcessorFactory, itemCacheFactory: ItemCacheFactory, collectionResourceFactory: CollectionResourceFactory, itemResourceService: ItemResourceService, promiseService: PromiseInterface, id?: string);
-    createItemResource(itemEntry: ItemEntry, options: any, isRoot?: boolean): ItemResource;
-    createItemResources(itemEntries: ItemEntry[], options: any): ItemResource[];
+    createItemResource(itemEntry: ItemEntry, options: ItemOptions, isRoot?: boolean, isNew?: boolean): ItemResource;
+    createItemResources(itemEntries: ItemEntry[], options: ItemOptions): ItemResource[];
     createCollectionResource(collectionEntry: CollectionEntry, resourceOptions: any): CollectionResource;
     createCollectionResources(collectionEntries: CollectionEntryParentIdMap, resourceOptions: any): {};
     clearItem(itemResource: ItemResource): void;

package/dist/dist/factories/CollectionEntryFactory.d.ts

@@ -3,14 +3,14 @@ import { ColumnSetFactory } from '../factories';
 import { ErrorHandlerInterface, PromiseInterface } from '../interfaces';
 import { CollectionEntry } from '../models/';
 export declare class CollectionEntryFactory {
-    private collectionEntryService;
-    private columnSetFactory;
-    private errorHandler;
-    private itemEntryService;
-    private itemRequestService;
-    private keyService;
-    private promiseService;
-    private queryService;
+    collectionEntryService: CollectionEntryService;
+    columnSetFactory: ColumnSetFactory;
+    errorHandler: ErrorHandlerInterface;
+    itemEntryService: ItemEntryService;
+    itemRequestService: ItemRequestService;
+    keyService: KeyService;
+    promiseService: PromiseInterface;
+    queryService: QueryService;
     constructor(collectionEntryService: CollectionEntryService, columnSetFactory: ColumnSetFactory, errorHandler: ErrorHandlerInterface, itemEntryService: ItemEntryService, itemRequestService: ItemRequestService, keyService: KeyService, promiseService: PromiseInterface, queryService: QueryService);
     construct(itemType: string, options: any): CollectionEntry;
 }

package/dist/dist/factories/CollectionResourceFactory.d.ts

@@ -3,14 +3,14 @@ import { ChangesProcessorFactory, ItemEntryFactory, ItemResourceFactory } from '
 import { ErrorHandlerInterface, PromiseInterface } from '../interfaces';
 import { CollectionEntry, CollectionResource } from '../models';
 export declare class CollectionResourceFactory {
-    private errorHandler;
-    private itemEntryFactory;
-    private itemHandler;
-    private itemResourceFactory;
-    private changesProcessorFactory;
-    private keyService;
-    private promiseService;
-    private collectionResourceService;
+    errorHandler: ErrorHandlerInterface;
+    itemEntryFactory: ItemEntryFactory;
+    itemHandler: ItemHandler;
+    itemResourceFactory: ItemResourceFactory;
+    changesProcessorFactory: ChangesProcessorFactory;
+    keyService: KeyService;
+    promiseService: PromiseInterface;
+    collectionResourceService: CollectionResourceService;
     constructor(errorHandler: ErrorHandlerInterface, itemEntryFactory: ItemEntryFactory, itemHandler: ItemHandler, itemResourceFactory: ItemResourceFactory, changesProcessorFactory: ChangesProcessorFactory, keyService: KeyService, promiseService: PromiseInterface, collectionResourceService: CollectionResourceService);
     construct(collectionEntry: CollectionEntry, options: any): CollectionResource;
 }

package/dist/dist/factories/ItemEntryFactory.d.ts

@@ -4,13 +4,13 @@ import { AuthInterface, PromiseInterface } from '../interfaces';
 import { ItemEntry } from '../models';
 import { EntryParentNull, FieldMap, ItemId, ItemIdConversionMap, ItemType, RequestColumns } from '../types';
 export declare class ItemEntryFactory {
-    private authInterface;
-    private apiFormatter;
-    private columnSetFactory;
-    private itemEntryService;
-    private keyService;
-    private promiseInterface;
-    constructor(authInterface: AuthInterface, apiFormatter: ApiFormatter, columnSetFactory: ColumnSetFactory, itemEntryService: ItemEntryService, keyService: KeyService, promiseInterface: PromiseInterface);
+    authInterface: AuthInterface;
+    apiFormatter: ApiFormatter;
+    columnSetFactory: ColumnSetFactory;
+    itemEntryService: ItemEntryService;
+    keyService: KeyService;
+    promiseService: PromiseInterface;
+    constructor(authInterface: AuthInterface, apiFormatter: ApiFormatter, columnSetFactory: ColumnSetFactory, itemEntryService: ItemEntryService, keyService: KeyService, promiseService: PromiseInterface);
     constructStub(itemType: ItemType, itemId: ItemId, columnSetStub: any): ItemEntry;
     constructLocalLinked(itemType: ItemType, localItemId: ItemId, initial: FieldMap, parent: EntryParentNull, columnSet: ColumnSet, conversionMap: ItemIdConversionMap): ItemEntry;
     constructLocal(itemId: ItemId, template: any, modified: FieldMap, derived: FieldMap, parent?: EntryParentNull, conversionMap?: any): ItemEntry;

package/dist/dist/factories/ItemResourceFactory.d.ts

@@ -1,14 +1,15 @@
 import { ApiFormatter, ChangesProcessor, ItemResourceService, LockService } from '../classes';
 import { ErrorHandlerInterface, PromiseInterface } from '../interfaces';
-import { EditResource, ItemEntry, ItemResource, ViewResource } from '../models';
+import { ItemEntry, ItemResource } from '../models';
+import { ItemOptions } from '../types';
 export declare class ItemResourceFactory {
-    private itemResourceService;
-    private apiFormatter;
-    private lockService;
-    private changesProcessor;
-    private errorHandler;
-    private promiseService;
+    itemResourceService: ItemResourceService;
+    apiFormatter: ApiFormatter;
+    lockService: LockService;
+    changesProcessor: ChangesProcessor;
+    errorHandler: ErrorHandlerInterface;
+    promiseService: PromiseInterface;
     constructor(itemResourceService: ItemResourceService, apiFormatter: ApiFormatter, lockService: LockService, changesProcessor: ChangesProcessor, errorHandler: ErrorHandlerInterface, promiseService: PromiseInterface);
-    getConstructor(options: any): (itemEntry: any) => EditResource | ViewResource;
-    construct(itemEntry: ItemEntry, options: any): ItemResource;
+    getConstructor(options: ItemOptions): (itemEntry: ItemEntry) => ItemResource;
+    construct(itemEntry: ItemEntry, options: ItemOptions, isNew?: boolean): ItemResource;
 }

package/dist/dist/models/CollectionEditResource.d.ts

@@ -1,21 +1,13 @@
-import { ItemHandler, KeyService } from '../classes';
-import { ChangesProcessorFactory, ItemEntryFactory, ItemResourceFactory } from '../factories';
-import { ErrorHandlerInterface, PromiseInterface } from '../interfaces';
-import { CollectionEntry } from './CollectionEntry';
-import { CollectionResource } from './CollectionResource';
+import { CollectionResourceFactory } from '../factories';
+import { CollectionEntry, CollectionResource, ItemResource } from '../models';
 export declare class CollectionEditResource extends CollectionResource {
-    private errorHandler;
-    private itemHandler;
-    private changesProcessorFactory;
-    private keyService;
-    private promiseService;
-    private itemEntryFactory;
-    constructor(errorHandler: ErrorHandlerInterface, itemHandler: ItemHandler, itemResourceFactory: ItemResourceFactory, changesProcessorFactory: ChangesProcessorFactory, keyService: KeyService, promiseService: PromiseInterface, itemEntryFactory: ItemEntryFactory, collectionEntry: CollectionEntry, options: any);
+    private factory;
+    constructor(factory: CollectionResourceFactory, collectionEntry: CollectionEntry, options: any);
     save(): Promise<any>;
-    moveItems(idArray: any, destination: any, enableCallbacks: any): any;
+    moveItems(idArray: any, destination: any, enableCallbacks: any): ItemResource[];
     removeItems(idArray: any, enableCallbacks: any): Promise<any>;
     removeItem(itemId: any, enableCallbacks: any): Promise<any>;
     addItems(valuesArray: any, enableCallbacks?: boolean): Promise<any>;
     addItem(values: any, enableCallbacks: any): Promise<any>;
-    clear(enableCallbacks: any): any;
+    clear(enableCallbacks: any): ItemResource[] | null;
 }

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

@@ -1,18 +1,9 @@
-import { CollectionEntryService, ColumnExpansion, ColumnInfo, ColumnSet, ItemEntryService, ItemRequestService, KeyService, QueryService } from '../classes';
-import { CollectionEntryFactory, ColumnSetFactory } from '../factories';
-import { ErrorHandlerInterface, PromiseInterface } from '../interfaces';
+import { ColumnExpansion, ColumnInfo, ColumnSet } from '../classes';
+import { CollectionEntryFactory } from '../factories';
 import { CollectionResource, ItemEntry, ItemResource } from '../models';
 import { EntryParentNull, ItemId, ItemIdConversionMap, ItemType, RequestColumns } from '../types';
 export declare class CollectionEntry {
-    private collectionEntryFactory;
-    private collectionEntryService;
-    private columnSetFactory;
-    private errorHandler;
-    private itemEntryService;
-    private itemRequestService;
-    private keyService;
-    private promiseService;
-    private queryService;
+    private factory;
     itemType: ItemType;
     options: any;
     id: number;
@@ -27,21 +18,23 @@ export declare class CollectionEntry {
     reloadQueued: boolean;
     hasEditResources: boolean;
     hasItemEditResources: boolean;
-    constructor(collectionEntryFactory: CollectionEntryFactory, collectionEntryService: CollectionEntryService, columnSetFactory: ColumnSetFactory, errorHandler: ErrorHandlerInterface, itemEntryService: ItemEntryService, itemRequestService: ItemRequestService, keyService: KeyService, promiseService: PromiseInterface, queryService: QueryService, itemType: ItemType, options: any);
+    constructor(factory: CollectionEntryFactory, itemType: ItemType, options: any);
     isDeferred(): boolean;
     resolve(itemEntryCompound: {
         columns: ColumnSet;
         items: ItemEntry[];
     }): CollectionEntry;
     isLocal(): boolean;
-    matchParent(itemType: any, itemId: any): boolean;
+    matchParent(itemType: ItemType, itemId: ItemId): boolean;
     forEach(callback: (itemEntry: ItemEntry) => void): void;
     getItemById(itemId: any): ItemEntry | undefined;
-    getIdArray(accumulator?: never[]): ItemId[];
-    addItems(itemEntries: any, resultResource: any, updateInitial?: boolean, callOnAdd?: boolean, callOnActivate?: boolean): ItemResource[] | null;
-    removeItems(idArray: any, resultResource: any, updateInitial: any, enableCallback?: any): any;
-    clear(resultResource: any, updateInitial: any, enableCallback?: any): any;
-    handleRemovedItems(filterFunction: any, resultResource: any, updateInitial: any, enableCallback?: boolean): any;
+    getIdArray(accumulator?: ItemId[]): ItemId[];
+    addItems(itemEntries: ItemEntry[], resultResource?: CollectionResource | null, updateInitial?: boolean, callOnAdd?: boolean, callOnActivate?: boolean): ItemResource[] | null;
+    private handleAddedItemCallbacks(entriesAddedToInitial, entriesAddedToModified, resultResource?, callOnAdd?, callOnActivate?);
+    removeItems(idArray: ItemId[], resultResource?: CollectionResource | null, updateInitial?: boolean, enableCallback?: boolean): ItemResource[] | null;
+    clear(resultResource?: CollectionResource | null, updateInitial?: boolean, enableCallback?: boolean): ItemResource[] | null;
+    handleRemovedItems(filterFunction: (itemEntry: ItemEntry) => boolean, resultResource?: CollectionResource | null, updateInitial?: boolean, enableCallback?: boolean): ItemResource[] | null;
+    private handleRemovedItemCallbacks(removedFromInitial, removedFromModified, resultResource?, callOnRemove?);
     expand(newColumns: any): Promise<any>;
     extendQuery(callback: any): any;
     extend(queryCallback: any, collectionResource: any, callOnAdd?: any, updateInitial?: any): Promise<any>;

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

@@ -1,22 +1,18 @@
-import { ApiFormatter, ChangesProcessor, LockService } from '../classes';
-import { ErrorHandlerInterface, PromiseInterface } from '../interfaces';
+import { ItemResourceFactory } from '../factories';
 import { FieldMap } from '../types';
 import { ItemEntry, ItemResource } from './';
 export declare class EditResource extends ItemResource {
-    private apiFormatter;
-    private lockService;
-    private changesProcessor;
-    private errorHandler;
-    private promiseService;
+    private factory;
     localCopies: FieldMap[];
     transactions: number;
-    constructor(apiFormatter: ApiFormatter, lockService: LockService, changesProcessor: ChangesProcessor, errorHandler: ErrorHandlerInterface, promiseService: PromiseInterface, entry: ItemEntry, options: any);
-    start(): void;
-    rollback(): void;
-    commit(initial?: boolean): void;
+    constructor(factory: ItemResourceFactory, entry: ItemEntry, options: any, isNew?: boolean);
+    isNew(): boolean;
+    start(): this;
+    rollback(): this;
+    commit(initial?: boolean): this;
     getLocalCopy(): FieldMap | null;
-    copyFields(destination?: any): any;
-    setFields(values: any, callOnChange: any): this;
-    callOnChange(previous: any): void;
-    save(parameters?: any): any;
+    copyFields(destination?: FieldMap): FieldMap;
+    setFields(values: FieldMap, callOnChange?: boolean): this;
+    callOnChange(previous: FieldMap): this;
+    save(parameters?: any): Promise<this>;
 }

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

@@ -1,15 +1,9 @@
-import { ApiFormatter, ColumnSet, ItemEntryService, KeyService } from '../classes';
+import { ColumnSet } from '../classes';
 import { ItemEntryFactory } from '../factories';
-import { AuthInterface, PromiseInterface } from '../interfaces';
 import { ItemResource } from '../models';
 import { EntryParentNull, FieldMap, ItemId, ItemIdConversionMap } from '../types';
 export declare class ItemEntry {
-    private promiseService;
-    private authInterface;
-    private itemEntryFactory;
-    private apiFormatter;
-    private itemEntryService;
-    private keyService;
+    private factory;
     itemType: string;
     itemId: ItemId;
     columns: ColumnSet;
@@ -21,7 +15,7 @@ export declare class ItemEntry {
     modified: FieldMap;
     derived: FieldMap;
     resources: ItemResource[];
-    constructor(promiseService: PromiseInterface, authInterface: AuthInterface, itemEntryFactory: ItemEntryFactory, apiFormatter: ApiFormatter, itemEntryService: ItemEntryService, keyService: KeyService, itemType: string, itemId: ItemId, columns: ColumnSet);
+    constructor(factory: ItemEntryFactory, itemType: string, itemId: ItemId, columns: ColumnSet);
     defer(deferRequest: any): this;
     resolve(): this;
     resolveDeferred(initial: any, derived: any, columns: any): this;

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

@@ -3,13 +3,14 @@ import { FieldMap, ResponseColumn } from '../types';
 export declare class ItemResource {
     entry: ItemEntry;
     options: any;
+    protected readonly _isNew: boolean;
     columns: {
         [columnId: string]: ResponseColumn;
     };
     fields: FieldMap;
     derived: FieldMap;
-    constructor(entry: ItemEntry, options: any);
-    isNewResource(resource: any): boolean;
+    constructor(entry: ItemEntry, options: any, _isNew?: boolean);
+    isNew(): boolean;
     isLocal(): boolean;
     clearResource(): void;
     deactivate(): void;

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

@@ -1,4 +1,4 @@
 import { ItemEntry, ItemResource } from '../models';
 export declare class ViewResource extends ItemResource {
-    constructor(entry: ItemEntry, options: any);
+    constructor(entry: ItemEntry, options: any, isNew?: boolean);
 }

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

@@ -9,6 +9,22 @@ export declare type EntryParentNull = EntryParent | null;
 export declare type FieldMap = {
     [key: string]: any;
 };
+export declare type ItemOptions = any;
+export declare type ItemDefinition = {
+    itemType: ItemType;
+    itemId: ItemId;
+    options: ItemOptions;
+    isNew: boolean;
+};
+export declare const enum StateKeyType {
+    New = 0,
+    Duplicate = 1,
+}
+export declare type StateKey = {
+    type: StateKeyType;
+    template?: string;
+    itemId?: string;
+};
 export declare type ItemResourceItemIdMap = {
     [itemId: number]: ItemResource;
 };
@@ -39,9 +55,6 @@ export declare type CollectionEntryBatchStatusMap = {
 export declare type CollectionEntryParentIdMap = {
     [parentId: number]: CollectionEntry;
 };
-export declare type CollectionEntryItemTypeMap = {
-    [itemType: string]: CollectionEntry[];
-};
 export declare type CollectionResourceParentIdMap = {
     [parentId: number]: CollectionResource;
 };