@singularsystems/neo-core 1.0.0-alpha.2 → 1.0.0-alpha.4

package/dist/Model/List.d.ts

@@ -1,77 +1,79 @@
-import { ISerialiseOptions } from '../Data/Serialiser';
-import { PlainObject, PartialPlainObject, PlainTrackedObject, IMetaItem } from './IModelBase';
-import { IDeserialiseOptions } from '../Data/Deserialiser';
-export default class List<T> extends Array<T> {
-    childObjectType: (new () => T);
-    attachedTo: object | null;
-    private _deletedList;
-    get deletedList(): T[];
-    private baseMethods;
-    constructor(childObjectType: (new () => T));
-    /**
-     * Copies the methods and properties from the prototype to the new instance.
-     * This is needed because vue / mobx changes the prototype to its own.
-     */
-    static copyMethods(toInstance: any): void;
-    setupProxy(proxy: any, attachedTo: any): void;
-    /**
-     * Converts the neo models to plain javascript objects without tracking state.
-     * @param options Serialisation options.
-     * */
-    toJSArray(options?: ISerialiseOptions & {
-        suppressTrackingState: true;
-    }): Array<PlainObject<T>>;
-    /**
-     * Converts the neo models to plain javascript objects.
-     * @param options Serialisation options.
-     * */
-    toJSArray(options?: ISerialiseOptions & {
-        suppressTrackingState?: false;
-    }): Array<PlainTrackedObject<T>>;
-    /**
-     * Converts the neo models to plain javascript objects.
-     * */
-    toJSArray(): Array<PlainTrackedObject<T>>;
-    /**
-     * Converts a plain javascript Array to a neo model graph.
-     * Replaces a list - Items in the list, but not in jsArray will be removed.
-     * If you need missing items to remain, use update() instead.
-     * This will generally be used after calling toJSArray(includeClean = true)
-     * */
-    set(jsArray: PartialPlainObject<T>[], options?: IDeserialiseOptions): void;
-    /**
-     * Converts a plain javascript Array to a neo model graph.
-     * Updates a list - Items in the list, but not in jsArray will remain in the list.
-     * If you need to replace the List with jsArray, use set() instead.
-     * This will generally be used after calling toJSArray(includeClean = false)
-     * */
-    update(jsArray: PartialPlainObject<T>[], options?: IDeserialiseOptions): void;
-    /**
-     * Converts a plain javascript array into a neo model graph.
-     */
-    static fromJSArray<T>(childType: new () => T, jsArray: PartialPlainObject<T>[], options?: IDeserialiseOptions): List<T>;
-    /** Creates a new item of type T */
-    createChild(): T;
-    push(...items: T[]): any;
-    clearDeletedList(): void;
-    private setParent;
-    /** Creates a new item of type T, adds it to the array and returns the new item. */
-    addNew(): T;
-    /**
-     * Removes an item from the array, and adds it to the deleted list. Deleted items will be included when calling toJSArray
-     * @param item Item to remove
-     */
-    remove(item: T): void;
-    /**
-     * Removes an item from the array without adding it to the deleted list.
-     * @param item Item to remove
-     */
-    removeWithoutTracking(item: T): void;
-    private removeItem;
-    /** Returns a static meta object containing all the properties of the lists item type. */
-    getMetaItem(): IMetaItem;
-    /** True if all items in the list are valid. */
-    get isValid(): boolean;
-    /** True if any item in the list is dirty, or the list contains any deleted items. */
-    get isDirty(): boolean;
-}
+import { ISerialiseOptions } from '../Data/Serialiser';
+import { PlainObject, PartialPlainObject, PlainTrackedObject, IMetaItem } from './IModelBase';
+import { IDeserialiseOptions } from '../Data/Deserialiser';
+export default class List<T> extends Array<T> {
+    childObjectType: (new () => T);
+    attachedTo: object | null;
+    private _deletedList;
+    get deletedList(): T[];
+    private baseMethods;
+    constructor(childObjectType: (new () => T));
+    /**
+     * Copies the methods and properties from the prototype to the new instance.
+     * This is needed because vue / mobx changes the prototype to its own.
+     */
+    static copyMethods(toInstance: any): void;
+    setupProxy(proxy: any, attachedTo: any): void;
+    /**
+     * Converts the neo models to plain javascript objects without tracking state.
+     * @param options Serialisation options.
+     * */
+    toJSArray(options?: ISerialiseOptions & {
+        suppressTrackingState: true;
+    }): Array<PlainObject<T>>;
+    /**
+     * Converts the neo models to plain javascript objects.
+     * @param options Serialisation options.
+     * */
+    toJSArray(options?: ISerialiseOptions & {
+        suppressTrackingState?: false;
+    }): Array<PlainTrackedObject<T>>;
+    /**
+     * Converts the neo models to plain javascript objects.
+     * */
+    toJSArray(): Array<PlainTrackedObject<T>>;
+    /**
+     * Converts a plain javascript Array to a neo model graph.
+     * Replaces a list - Items in the list, but not in jsArray will be removed.
+     * If you need missing items to remain, use update() instead.
+     * This will generally be used after calling toJSArray(includeClean = true)
+     * */
+    set(jsArray: PartialPlainObject<T>[], options?: IDeserialiseOptions): void;
+    /**
+     * Converts a plain javascript Array to a neo model graph.
+     * Updates a list - Items in the list, but not in jsArray will remain in the list.
+     * If you need to replace the List with jsArray, use set() instead.
+     * This will generally be used after calling toJSArray(includeClean = false)
+     * */
+    update(jsArray: PartialPlainObject<T>[], options?: IDeserialiseOptions): void;
+    /**
+     * Converts a plain javascript array into a neo model graph.
+     */
+    static fromJSArray<T>(childType: new () => T, jsArray: PartialPlainObject<T>[], options?: IDeserialiseOptions): List<T>;
+    /** Creates a new item of type T */
+    createChild(): T;
+    push(...items: T[]): any;
+    clearDeletedList(): void;
+    private setParent;
+    /** Creates a new item of type T, adds it to the array and returns the new item. */
+    addNew(): T;
+    /**
+     * Removes an item from the array, and adds it to the deleted list. Deleted items will be included when calling toJSArray
+     * @param item Item to remove
+     */
+    remove(item: T): void;
+    /**
+     * Removes an item from the array without adding it to the deleted list.
+     * @param item Item to remove
+     */
+    removeWithoutTracking(item: T): void;
+    private removeItem;
+    /** Returns a static meta object containing all the properties of the lists item type. */
+    getMetaItem(): IMetaItem;
+    /** True if all items in the list are valid. */
+    get isValid(): boolean;
+    /** True if any item in the list is dirty, or the list contains any deleted items. */
+    get isDirty(): boolean;
+    /** Indicates that the model is dirty and valid and can be saved. */
+    get readyToSave(): boolean;
+}

package/dist/Model/List.js

@@ -1,198 +1,208 @@
-import { __assign, __extends } from "tslib";
-import { JSFormatter } from '../Data/Serialiser';
-import { Utils } from '../Utils';
-import { ObservableValue } from './ObservableValue';
-var List = /** @class */ (function (_super) {
-    __extends(List, _super);
-    function List(childObjectType) {
-        var _this = _super.call(this) || this;
-        _this.childObjectType = childObjectType;
-        _this._deletedList = new ObservableValue([]);
-        List.copyMethods(_this);
-        return _this;
-    }
-    Object.defineProperty(List.prototype, "deletedList", {
-        get: function () {
-            return this._deletedList.value;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    /**
-     * Copies the methods and properties from the prototype to the new instance.
-     * This is needed because vue / mobx changes the prototype to its own.
-     */
-    List.copyMethods = function (toInstance) {
-        toInstance.baseMethods = {};
-        for (var _i = 0, _a = Object.getOwnPropertyNames(this.prototype); _i < _a.length; _i++) {
-            var propertyName = _a[_i];
-            if (propertyName !== "constructor") {
-                var descriptor = Object.getOwnPropertyDescriptor(this.prototype, propertyName);
-                if (descriptor.value !== void 0) {
-                    // Method
-                    if (toInstance[propertyName]) {
-                        toInstance.baseMethods[propertyName] = toInstance[propertyName];
-                    }
-                    toInstance[propertyName] = this.prototype[propertyName];
-                }
-                else if (descriptor.get) {
-                    Object.defineProperty(toInstance, propertyName, descriptor);
-                }
-            }
-        }
-    };
-    List.prototype.setupProxy = function (proxy, attachedTo) {
-        proxy.childObjectType = this.childObjectType;
-        proxy._deletedList = new ObservableValue([]);
-        proxy.attachedTo = attachedTo;
-    };
-    List.prototype.toJSArray = function (options) {
-        if (options === void 0) { options = {}; }
-        return JSFormatter.serialise(this, options);
-    };
-    /**
-     * Converts a plain javascript Array to a neo model graph.
-     * Replaces a list - Items in the list, but not in jsArray will be removed.
-     * If you need missing items to remain, use update() instead.
-     * This will generally be used after calling toJSArray(includeClean = true)
-     * */
-    List.prototype.set = function (jsArray, options) {
-        JSFormatter.deserialise(jsArray, this, this.childObjectType, __assign({ removeOldItems: true }, options));
-    };
-    /**
-     * Converts a plain javascript Array to a neo model graph.
-     * Updates a list - Items in the list, but not in jsArray will remain in the list.
-     * If you need to replace the List with jsArray, use set() instead.
-     * This will generally be used after calling toJSArray(includeClean = false)
-     * */
-    List.prototype.update = function (jsArray, options) {
-        JSFormatter.deserialise(jsArray, this, this.childObjectType, options);
-    };
-    /**
-     * Converts a plain javascript array into a neo model graph.
-     */
-    List.fromJSArray = function (childType, jsArray, options) {
-        var list = new List(childType);
-        list.set(jsArray, options);
-        return list;
-    };
-    /** Creates a new item of type T */
-    List.prototype.createChild = function () {
-        return new this.childObjectType();
-    };
-    List.prototype.push = function () {
-        var _this = this;
-        var items = [];
-        for (var _i = 0; _i < arguments.length; _i++) {
-            items[_i] = arguments[_i];
-        }
-        items.forEach(function (item) {
-            if (!(item instanceof _this.childObjectType)) {
-                throw "Type error, cannot add item of type " + Utils.getTypeName(item.constructor) + " to list of type " + Utils.getTypeName(_this.childObjectType) + ".";
-            }
-            _this.setParent(item);
-        });
-        return this.baseMethods.push.apply(this, items);
-    };
-    List.prototype.clearDeletedList = function () {
-        this._deletedList.value = [];
-    };
-    List.prototype.setParent = function (item) {
-        if (this.attachedTo) {
-            var itemConstructor = this.childObjectType.prototype.constructor;
-            // set the parent property
-            if (itemConstructor.neo) {
-                var parentConstructor = this.attachedTo.constructor.prototype.constructor;
-                var parentProperty = null;
-                // check default parent
-                if (itemConstructor.neo.parentProperty && Utils.sameTypes(parentConstructor, itemConstructor.neo.parentProperty.typeWithAssert)) {
-                    parentProperty = itemConstructor.neo.parentProperty;
-                }
-                // check for other parents
-                var parents = itemConstructor.neo.parentProperties;
-                if (!parentProperty && parents.length > 1) {
-                    for (var i = 0; i < parents.length; i++) {
-                        if (Utils.sameTypes(parentConstructor, parents[i].typeWithAssert)) {
-                            parentProperty = parents[i];
-                            break;
-                        }
-                    }
-                }
-                if (parentProperty) {
-                    item[parentProperty.propertyName] = this.attachedTo;
-                }
-            }
-        }
-    };
-    /** Creates a new item of type T, adds it to the array and returns the new item. */
-    List.prototype.addNew = function () {
-        var newItem = this.createChild();
-        this.push(newItem);
-        return newItem;
-    };
-    /**
-     * Removes an item from the array, and adds it to the deleted list. Deleted items will be included when calling toJSArray
-     * @param item Item to remove
-     */
-    List.prototype.remove = function (item) {
-        this.removeItem(item, true);
-    };
-    /**
-     * Removes an item from the array without adding it to the deleted list.
-     * @param item Item to remove
-     */
-    List.prototype.removeWithoutTracking = function (item) {
-        this.removeItem(item, false);
-    };
-    List.prototype.removeItem = function (item, addToDeletedList) {
-        var index = this.indexOf(item);
-        if (index >= 0) {
-            if (addToDeletedList && item.entityIdentifier) {
-                if (this.deletedList.indexOf(item) == -1 && !item.isNew)
-                    this.deletedList.push(item);
-            }
-            this.splice(index, 1);
-        }
-    };
-    /** Returns a static meta object containing all the properties of the lists item type. */
-    List.prototype.getMetaItem = function () {
-        if (this.length) {
-            return this[0];
-        }
-        else {
-            var ctor = this.childObjectType.prototype.constructor;
-            ctor.neo.ensureInitialised();
-            return ctor.neo.metaItem;
-        }
-    };
-    Object.defineProperty(List.prototype, "isValid", {
-        /** True if all items in the list are valid. */
-        get: function () {
-            for (var i = 0; i < this.length; i++) {
-                if (!this[i].isValid) {
-                    return false;
-                }
-            }
-            return true;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(List.prototype, "isDirty", {
-        /** True if any item in the list is dirty, or the list contains any deleted items. */
-        get: function () {
-            if (this.deletedList.length)
-                return true;
-            for (var i = 0; i < this.length; i++) {
-                if (this[i].isDirty) {
-                    return true;
-                }
-            }
-            return false;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    return List;
-}(Array));
-export default List;
+import { __assign, __extends } from "tslib";
+import { JSFormatter } from '../Data/Serialiser';
+import { Utils } from '../Utils';
+import { ObservableValue } from './ObservableValue';
+import { NeoTypeInfo } from './NeoTypeInfo';
+var List = /** @class */ (function (_super) {
+    __extends(List, _super);
+    function List(childObjectType) {
+        var _this = _super.call(this) || this;
+        _this.childObjectType = childObjectType;
+        _this._deletedList = new ObservableValue([]);
+        List.copyMethods(_this);
+        return _this;
+    }
+    Object.defineProperty(List.prototype, "deletedList", {
+        get: function () {
+            return this._deletedList.value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    /**
+     * Copies the methods and properties from the prototype to the new instance.
+     * This is needed because vue / mobx changes the prototype to its own.
+     */
+    List.copyMethods = function (toInstance) {
+        toInstance.baseMethods = {};
+        for (var _i = 0, _a = Object.getOwnPropertyNames(this.prototype); _i < _a.length; _i++) {
+            var propertyName = _a[_i];
+            if (propertyName !== "constructor") {
+                var descriptor = Object.getOwnPropertyDescriptor(this.prototype, propertyName);
+                if (descriptor.value !== void 0) {
+                    // Method
+                    if (toInstance[propertyName]) {
+                        toInstance.baseMethods[propertyName] = toInstance[propertyName];
+                    }
+                    // @ts-ignore
+                    toInstance[propertyName] = this.prototype[propertyName];
+                }
+                else if (descriptor.get) {
+                    Object.defineProperty(toInstance, propertyName, descriptor);
+                }
+            }
+        }
+    };
+    List.prototype.setupProxy = function (proxy, attachedTo) {
+        proxy.childObjectType = this.childObjectType;
+        proxy._deletedList = new ObservableValue([]);
+        proxy.attachedTo = attachedTo;
+    };
+    List.prototype.toJSArray = function (options) {
+        if (options === void 0) { options = {}; }
+        return JSFormatter.serialise(this, options);
+    };
+    /**
+     * Converts a plain javascript Array to a neo model graph.
+     * Replaces a list - Items in the list, but not in jsArray will be removed.
+     * If you need missing items to remain, use update() instead.
+     * This will generally be used after calling toJSArray(includeClean = true)
+     * */
+    List.prototype.set = function (jsArray, options) {
+        JSFormatter.deserialise(jsArray, this, this.childObjectType, __assign({ removeOldItems: true }, options));
+    };
+    /**
+     * Converts a plain javascript Array to a neo model graph.
+     * Updates a list - Items in the list, but not in jsArray will remain in the list.
+     * If you need to replace the List with jsArray, use set() instead.
+     * This will generally be used after calling toJSArray(includeClean = false)
+     * */
+    List.prototype.update = function (jsArray, options) {
+        JSFormatter.deserialise(jsArray, this, this.childObjectType, options);
+    };
+    /**
+     * Converts a plain javascript array into a neo model graph.
+     */
+    List.fromJSArray = function (childType, jsArray, options) {
+        var list = new List(childType);
+        list.set(jsArray, options);
+        return list;
+    };
+    /** Creates a new item of type T */
+    List.prototype.createChild = function () {
+        return new this.childObjectType();
+    };
+    List.prototype.push = function () {
+        var _this = this;
+        var items = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            items[_i] = arguments[_i];
+        }
+        items.forEach(function (item) {
+            if (!(item instanceof _this.childObjectType)) {
+                throw "Type error, cannot add item of type " + Utils.getTypeName(item.constructor) + " to list of type " + Utils.getTypeName(_this.childObjectType) + ".";
+            }
+            _this.setParent(item);
+        });
+        return this.baseMethods.push.apply(this, items);
+    };
+    List.prototype.clearDeletedList = function () {
+        this._deletedList.value = [];
+    };
+    List.prototype.setParent = function (item) {
+        if (this.attachedTo) {
+            var itemConstructor = this.childObjectType.prototype.constructor;
+            // set the parent property
+            if (itemConstructor.neo) {
+                var parentConstructor = this.attachedTo.constructor.prototype.constructor;
+                var parentProperty = null;
+                // check default parent
+                if (itemConstructor.neo.parentProperty && Utils.sameTypes(parentConstructor, itemConstructor.neo.parentProperty.typeWithAssert)) {
+                    parentProperty = itemConstructor.neo.parentProperty;
+                }
+                // check for other parents
+                var parents = itemConstructor.neo.parentProperties;
+                if (!parentProperty && parents.length > 1) {
+                    for (var i = 0; i < parents.length; i++) {
+                        if (Utils.sameTypes(parentConstructor, parents[i].typeWithAssert)) {
+                            parentProperty = parents[i];
+                            break;
+                        }
+                    }
+                }
+                if (parentProperty) {
+                    // @ts-ignore
+                    item[parentProperty.propertyName] = this.attachedTo;
+                }
+            }
+        }
+    };
+    /** Creates a new item of type T, adds it to the array and returns the new item. */
+    List.prototype.addNew = function () {
+        var newItem = this.createChild();
+        this.push(newItem);
+        return newItem;
+    };
+    /**
+     * Removes an item from the array, and adds it to the deleted list. Deleted items will be included when calling toJSArray
+     * @param item Item to remove
+     */
+    List.prototype.remove = function (item) {
+        this.removeItem(item, true);
+    };
+    /**
+     * Removes an item from the array without adding it to the deleted list.
+     * @param item Item to remove
+     */
+    List.prototype.removeWithoutTracking = function (item) {
+        this.removeItem(item, false);
+    };
+    List.prototype.removeItem = function (item, addToDeletedList) {
+        var index = this.indexOf(item);
+        if (index >= 0) {
+            if (addToDeletedList && item.entityIdentifier) {
+                if (this.deletedList.indexOf(item) == -1 && !item.isNew)
+                    this.deletedList.push(item);
+            }
+            this.splice(index, 1);
+        }
+    };
+    /** Returns a static meta object containing all the properties of the lists item type. */
+    List.prototype.getMetaItem = function () {
+        if (this.length) {
+            return this[0];
+        }
+        else {
+            var ctor = this.childObjectType.prototype.constructor;
+            return NeoTypeInfo.ensureInitialised(ctor).metaItem;
+        }
+    };
+    Object.defineProperty(List.prototype, "isValid", {
+        /** True if all items in the list are valid. */
+        get: function () {
+            for (var i = 0; i < this.length; i++) {
+                if (!this[i].isValid) {
+                    return false;
+                }
+            }
+            return true;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(List.prototype, "isDirty", {
+        /** True if any item in the list is dirty, or the list contains any deleted items. */
+        get: function () {
+            if (this.deletedList.length)
+                return true;
+            for (var i = 0; i < this.length; i++) {
+                if (this[i].isDirty) {
+                    return true;
+                }
+            }
+            return false;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(List.prototype, "readyToSave", {
+        /** Indicates that the model is dirty and valid and can be saved. */
+        get: function () {
+            return this.isDirty && this.isValid;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    return List;
+}(Array));
+export default List;

package/dist/Model/LookupBase.d.ts

@@ -1,6 +1,13 @@
-import { BindableBase } from './BindableBase';
-import { IBindableBase } from './IModelBase';
-export interface ILookupBase extends IBindableBase {
-}
-export declare abstract class LookupBase extends BindableBase implements ILookupBase {
-}
+import { IDeserialiseOptions } from '../Data/Deserialiser';
+import { BindableBase } from './BindableBase';
+import { IBindableBase, PartialPlainObject } from './IModelBase';
+export interface ILookupBase extends IBindableBase {
+}
+export declare abstract class LookupBase extends BindableBase implements ILookupBase {
+    /**
+     * @deprecated Models that extend LookupBase are designed to be immutable.
+     * Calling set() on an instance that is already being observed will not cause the ui to update.
+     * Rather deserialise on create using `MyLookup.fromJSObject<MyLookup>(data)`.
+     * */
+    set(jsObject: PartialPlainObject<this>, options?: IDeserialiseOptions): void;
+}

package/dist/Model/LookupBase.js

@@ -1,10 +1,19 @@
-import { __extends } from "tslib";
-import { BindableBase } from './BindableBase';
-var LookupBase = /** @class */ (function (_super) {
-    __extends(LookupBase, _super);
-    function LookupBase() {
-        return _super !== null && _super.apply(this, arguments) || this;
-    }
-    return LookupBase;
-}(BindableBase));
-export { LookupBase };
+import { __extends } from "tslib";
+import { BindableBase } from './BindableBase';
+var LookupBase = /** @class */ (function (_super) {
+    __extends(LookupBase, _super);
+    function LookupBase() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    /**
+     * @deprecated Models that extend LookupBase are designed to be immutable.
+     * Calling set() on an instance that is already being observed will not cause the ui to update.
+     * Rather deserialise on create using `MyLookup.fromJSObject<MyLookup>(data)`.
+     * */
+    LookupBase.prototype.set = function (jsObject, options) {
+        console.warn("Do not use the set() method on lookup models. Rather use the static fromJSObject().");
+        _super.prototype.set.call(this, jsObject, options);
+    };
+    return LookupBase;
+}(BindableBase));
+export { LookupBase };