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

package/dist/Model/NeoTypeInfo.js

@@ -1,250 +1,300 @@
-import { __spreadArray } from "tslib";
-import { ExpressionRule, CallbackRule } from '../Validation/Rules';
-import PropertyInstance from './PropertyInstance';
-import PropertyInfo from './PropertyInfo';
-import Globals from '../Globals';
-import { ValidationRules } from '../Validation/ValidationRules';
-import ModelProxy from '../Validation/ModelProxy';
-import NeoTypes from '../AppServices/NeoTypes';
-import { RelationType } from './Misc';
-var ignoredPropertyNames = ["$mobx"];
-var inversifyMetadataKey = "inversify:tagged";
-var NeoTypeInfo = /** @class */ (function () {
-    function NeoTypeInfo() {
-        this._inheritsBindableBase = false;
-        this._inheritsModelBase = false;
-        // Property info for each property on this type.
-        this.properties = [];
-        // Property info dictionary for easy lookup.
-        this.propertyMap = {};
-        // Properties of type List<T>, or marked with the ChildList or ChildObject decorator.
-        this.children = [];
-        // Properties marked with the parent decorator, multiple if a class can be child of more than one type.
-        this.parentProperties = [];
-        // List of rules added to the object only (not a property).
-        this.objectRules = [];
-        // Property instances for each property. These have the attachedTo properties set to null, so only static information is available.
-        this.meta = {};
-        // Main display member for drop downs etc.
-        this.displayMember = null;
-    }
-    Object.defineProperty(NeoTypeInfo.prototype, "inheritsBindableBase", {
-        get: function () {
-            return this._inheritsBindableBase;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(NeoTypeInfo.prototype, "inheritsModelBase", {
-        get: function () {
-            return this._inheritsModelBase;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(NeoTypeInfo.prototype, "metaItem", {
-        get: function () {
-            if (!this._metaItem) {
-                this._metaItem = { meta: this.meta };
-                populateMetaItem(this._metaItem, 0);
-            }
-            return this._metaItem;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    NeoTypeInfo.prototype.initialise = function (objectConstructor) {
-        this.objectConstructor = objectConstructor;
-    };
-    NeoTypeInfo.prototype.addPropertyInfo = function (propertyInfo) {
-        this.propertyMap[propertyInfo.propertyName] = propertyInfo;
-        this.properties.push(propertyInfo);
-        this.meta[propertyInfo.propertyName] = new PropertyInstance(null, propertyInfo);
-    };
-    NeoTypeInfo.prototype.getOrAddProperty = function (propertyName) {
-        var propertyInfo = this.propertyMap[propertyName];
-        if (!propertyInfo) {
-            propertyInfo = new PropertyInfo(propertyName);
-            this.addPropertyInfo(propertyInfo);
-        }
-        return propertyInfo;
-    };
-    NeoTypeInfo.prototype.addComputed = function (propertyName, descriptor, isComputed) {
-        if (isComputed === void 0) { isComputed = true; }
-        var pi = this.getOrAddProperty(propertyName);
-        if (pi.isComputed === null) {
-            pi.isComputed = isComputed;
-            pi.noTrack = true;
-        }
-        pi.isReadOnly = descriptor.set === undefined;
-        pi.descriptor = descriptor;
-    };
-    NeoTypeInfo.prototype.addAttributeRule = function (propertyName, rule) {
-        this.getOrAddProperty(propertyName).addAttributeRule(rule);
-    };
-    /**
-     * Ensures the type has all the information it needs in order to convert instances of this type.
-     * E.g. Making sure each property has a property info object.
-     * */
-    NeoTypeInfo.prototype.ensureStaticRuntimeInfo = function (instance) {
-        if (!this.modelCreator) {
-            this.modelCreator = Globals.appService.get(NeoTypes.Core.ModelCreator);
-            var baseType = Object.getPrototypeOf(this.objectConstructor.prototype);
-            if (baseType != Object.prototype) {
-                this.merge(baseType.constructor);
-            }
-            else {
-                this._inheritsBindableBase = this.modelCreator.isBindableBase(this.objectConstructor);
-            }
-            this.modelCreator.initialise(this, this.objectConstructor);
-            if (instance && this.modelCreator.shouldInitialiseAllMembers) {
-                for (var _i = 0, _a = Object.getOwnPropertyNames(instance); _i < _a.length; _i++) {
-                    var propertyName = _a[_i];
-                    if (ignoredPropertyNames.indexOf(propertyName) < 0) {
-                        var pi = this.getOrAddProperty(propertyName);
-                        pi.setupFromInstance(instance);
-                    }
-                }
-            }
-            if (instance)
-                this.addRules(instance);
-        }
-    };
-    NeoTypeInfo.prototype.addRules = function (instance) {
-        if (instance.addBusinessRules !== undefined) {
-            var validationRules = new ValidationRules();
-            instance.addBusinessRules(validationRules);
-            if (validationRules.rules.some(function (c) { return c instanceof CallbackRule && c.hasBoundFunction; })) {
-                console.error("Warning: ".concat(this.objectConstructor.name, " has rules which have been added using a bound function, or arrow function."));
-            }
-            var modelProxy = new ModelProxy(instance);
-            for (var _i = 0, _a = validationRules.rules; _i < _a.length; _i++) {
-                var rule = _a[_i];
-                var properties = rule.getDisplayProperties(this.propertyMap);
-                if (properties === undefined && rule instanceof ExpressionRule) {
-                    properties = modelProxy.tryExtractProperties(rule);
-                }
-                if (properties && properties.length) {
-                    for (var _b = 0, properties_1 = properties; _b < properties_1.length; _b++) {
-                        var property = properties_1[_b];
-                        property.rules.push(rule);
-                    }
-                }
-                else {
-                    this.objectRules.push(rule);
-                }
-            }
-        }
-    };
-    /** Copy the property info list from each base type into the current type. */
-    NeoTypeInfo.prototype.merge = function (baseConstructor) {
-        // Convert base class to a neo type
-        var base = ensureTypeInfo(baseConstructor).neo;
-        base.ensureStaticRuntimeInfo();
-        for (var _i = 0, _a = base.properties; _i < _a.length; _i++) {
-            var propertyInfo = _a[_i];
-            this.addPropertyInfo(propertyInfo.clone());
-        }
-        for (var _b = 0, _c = base.children; _b < _c.length; _b++) {
-            var child = _c[_b];
-            this.children.push(this.propertyMap[child.propertyName]);
-        }
-        for (var _d = 0, _e = base.parentProperties; _d < _e.length; _d++) {
-            var parent_1 = _e[_d];
-            this.parentProperties.push(this.propertyMap[parent_1.propertyName]);
-        }
-        if (!this.parentProperty && base.parentProperty) {
-            this.parentProperty = this.propertyMap[base.parentProperty.propertyName];
-        }
-        this._inheritsBindableBase = base._inheritsBindableBase;
-        if (this.modelCreator.isModelBase(this.objectConstructor) || base._inheritsModelBase) {
-            this._inheritsModelBase = true;
-        }
-    };
-    NeoTypeInfo.prototype.ensureInitialised = function () {
-        if (!this.modelCreator) {
-            // create a new instance which will cause the type to be setup.
-            this.getOverrideConstructor()();
-        }
-    };
-    /** Gets the override constructor which can setup a neo model. */
-    NeoTypeInfo.prototype.getOverrideConstructor = function () {
-        var self = this;
-        var baseType = Object.getPrototypeOf(self.objectConstructor);
-        if ((baseType === null || baseType === void 0 ? void 0 : baseType.name) === "neoConstructor") {
-            return function () {
-                throw Error(self.objectConstructor.name + " cannot inherit from a model decorated with @NeoModel.");
-            };
-        }
-        var newConstructor = function neoConstructor() {
-            var _a;
-            var args = [];
-            for (var _i = 0; _i < arguments.length; _i++) {
-                args[_i] = arguments[_i];
-            }
-            var instance = new ((_a = self.objectConstructor).bind.apply(_a, __spreadArray([void 0], args, false)))();
-            return self.makeObservable(instance);
-        };
-        // Copy statics from the original constructor, and all base classes to the new constructor.
-        baseType = this.objectConstructor;
-        while (baseType && baseType !== Function.prototype) {
-            for (var _i = 0, _a = Object.getOwnPropertyNames(baseType); _i < _a.length; _i++) {
-                var propertyName = _a[_i];
-                if (propertyName !== "prototype" && propertyName !== "caller" && propertyName !== "arguments" && propertyName !== "neo") {
-                    if (newConstructor[propertyName] === undefined) {
-                        var descriptor = Object.getOwnPropertyDescriptor(baseType, propertyName);
-                        if (descriptor.value !== void 0) {
-                            if (typeof descriptor.value === 'function') {
-                                newConstructor[propertyName] = baseType[propertyName];
-                            }
-                            else {
-                                // Define a property on this constructor pointing to the original property.
-                                this.defineProxyProperty(baseType, newConstructor, propertyName);
-                            }
-                        }
-                    }
-                }
-            }
-            baseType = Object.getPrototypeOf(baseType);
-        }
-        // Copy inversify metadata:
-        Reflect.defineMetadata(inversifyMetadataKey, Reflect.getMetadata(inversifyMetadataKey, this.objectConstructor), newConstructor);
-        newConstructor.neo = self.objectConstructor.neo;
-        newConstructor.prototype = self.objectConstructor.prototype;
-        return newConstructor;
-    };
-    NeoTypeInfo.prototype.makeObservable = function (instance) {
-        this.ensureStaticRuntimeInfo(instance);
-        return this.modelCreator.convertInstance(instance);
-    };
-    NeoTypeInfo.prototype.defineProxyProperty = function (baseType, newConstructor, propertyKey) {
-        Object.defineProperty(newConstructor, propertyKey, {
-            get: function () { return baseType[propertyKey]; },
-            set: function (value) { return baseType[propertyKey] = value; }
-        });
-    };
-    return NeoTypeInfo;
-}());
-export { NeoTypeInfo };
-export function ensureTypeInfo(constructor) {
-    if (!constructor.hasOwnProperty("neo")) {
-        constructor.neo = new NeoTypeInfo();
-        constructor.neo.initialise(constructor);
-    }
-    return constructor;
-}
-function populateMetaItem(item, level) {
-    if (level < 5) {
-        for (var propertyKey in item.meta) {
-            var propertyInfo = item.meta[propertyKey].propertyInfo;
-            if ((propertyInfo.relationType === RelationType.ChildObject || propertyInfo.relationType === RelationType.ValueObject)) {
-                var propertyType = propertyInfo.type;
-                if (propertyType) {
-                    var childItem = { meta: propertyType.neo.meta };
-                    populateMetaItem(childItem, level + 1);
-                    item[propertyKey] = childItem;
-                }
-            }
-        }
-    }
-}
+import { __spreadArray } from "tslib";
+import { ExpressionRule, CallbackRule } from '../Validation/Rules';
+import PropertyInstance from './PropertyInstance';
+import PropertyInfo from './PropertyInfo';
+import Globals from '../Globals';
+import { ValidationRules } from '../Validation/ValidationRules';
+import ModelProxy from '../Validation/ModelProxy';
+import NeoTypes from '../AppServices/NeoTypes';
+import { RelationType } from './Misc';
+var ignoredPropertyNames = ["$mobx"];
+var inversifyMetadataKey = "inversify:tagged";
+var hasConvertedSymbol = Symbol("hasConvertedModel");
+var NeoTypeInfo = /** @class */ (function () {
+    function NeoTypeInfo() {
+        this._inheritsBindableBase = false;
+        this._inheritsModelBase = false;
+        // Property info for each property on this type.
+        this.properties = [];
+        // Property info dictionary for easy lookup.
+        this.propertyMap = {};
+        // Properties of type List<T>, or marked with the ChildList or ChildObject decorator.
+        this.children = [];
+        // Properties marked with the parent decorator, multiple if a class can be child of more than one type.
+        this.parentProperties = [];
+        // List of rules added to the object only (not a property).
+        this.objectRules = [];
+        // Property instances for each property. These have the attachedTo properties set to null, so only static information is available.
+        this.meta = {};
+        // Main display member for drop downs etc.
+        this.displayMember = null;
+    }
+    Object.defineProperty(NeoTypeInfo.prototype, "inheritsBindableBase", {
+        get: function () {
+            return this._inheritsBindableBase;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(NeoTypeInfo.prototype, "inheritsModelBase", {
+        get: function () {
+            return this._inheritsModelBase;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(NeoTypeInfo.prototype, "metaItem", {
+        get: function () {
+            if (!this._metaItem) {
+                this._metaItem = { meta: this.meta };
+                populateMetaItem(this._metaItem, 0);
+            }
+            return this._metaItem;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    NeoTypeInfo.prototype.initialise = function (objectConstructor) {
+        this.objectConstructor = objectConstructor;
+    };
+    NeoTypeInfo.prototype.addPropertyInfo = function (propertyInfo) {
+        this.propertyMap[propertyInfo.propertyName] = propertyInfo;
+        this.properties.push(propertyInfo);
+        this.meta[propertyInfo.propertyName] = new PropertyInstance(null, propertyInfo);
+    };
+    NeoTypeInfo.prototype.getOrAddProperty = function (propertyName) {
+        var propertyInfo = this.propertyMap[propertyName];
+        if (!propertyInfo) {
+            propertyInfo = new PropertyInfo(propertyName);
+            this.addPropertyInfo(propertyInfo);
+        }
+        return propertyInfo;
+    };
+    NeoTypeInfo.prototype.addComputed = function (propertyName, descriptor, isComputed) {
+        if (isComputed === void 0) { isComputed = true; }
+        var pi = this.getOrAddProperty(propertyName);
+        if (pi.isComputed === null) {
+            pi.isComputed = isComputed;
+            pi.noTrack = true;
+        }
+        pi.isReadOnly = descriptor.set === undefined;
+        pi.descriptor = descriptor;
+    };
+    NeoTypeInfo.prototype.addAttributeRule = function (propertyName, rule) {
+        this.getOrAddProperty(propertyName).addAttributeRule(rule);
+    };
+    /**
+     * Ensures the type has all the information it needs in order to convert instances of this type.
+     * E.g. Making sure each property has a property info object.
+     * */
+    NeoTypeInfo.prototype.ensureStaticRuntimeInfo = function (instance) {
+        if (!this.modelCreator) {
+            this.modelCreator = Globals.appService.get(NeoTypes.Core.ModelCreator);
+            var baseType = Object.getPrototypeOf(this.objectConstructor.prototype);
+            if (baseType != Object.prototype) {
+                this.merge(baseType.constructor);
+            }
+            else {
+                this._inheritsBindableBase = this.modelCreator.isBindableBase(this.objectConstructor);
+            }
+            this.modelCreator.initialise(this, this.objectConstructor);
+            if (instance && this.modelCreator.shouldInitialiseAllMembers) {
+                for (var _i = 0, _a = Object.getOwnPropertyNames(instance); _i < _a.length; _i++) {
+                    var propertyName = _a[_i];
+                    if (ignoredPropertyNames.indexOf(propertyName) < 0) {
+                        var pi = this.getOrAddProperty(propertyName);
+                        pi.setupFromInstance(instance);
+                    }
+                }
+            }
+            if (instance)
+                this.addRules(instance);
+        }
+    };
+    NeoTypeInfo.prototype.addRules = function (instance) {
+        if (instance.addBusinessRules !== undefined) {
+            var validationRules = new ValidationRules();
+            instance.addBusinessRules(validationRules);
+            if (validationRules.rules.some(function (c) { return c instanceof CallbackRule && c.hasBoundFunction; })) {
+                console.error("Warning: ".concat(this.objectConstructor.name, " has rules which have been added using a bound function, or arrow function."));
+            }
+            var modelProxy = new ModelProxy(instance);
+            for (var _i = 0, _a = validationRules.rules; _i < _a.length; _i++) {
+                var rule = _a[_i];
+                var properties = rule.getDisplayProperties(this.propertyMap);
+                if (properties === undefined && rule instanceof ExpressionRule) {
+                    properties = modelProxy.tryExtractProperties(rule);
+                }
+                if (properties && properties.length) {
+                    for (var _b = 0, properties_1 = properties; _b < properties_1.length; _b++) {
+                        var property = properties_1[_b];
+                        property.rules.push(rule);
+                    }
+                }
+                else {
+                    this.objectRules.push(rule);
+                }
+            }
+        }
+    };
+    /** Copy the property info list from each base type into the current type. */
+    NeoTypeInfo.prototype.merge = function (baseConstructor) {
+        // Convert base class to a neo type
+        var base = ensureTypeInfo(baseConstructor).neo;
+        base.ensureStaticRuntimeInfo();
+        for (var _i = 0, _a = base.properties; _i < _a.length; _i++) {
+            var propertyInfo = _a[_i];
+            this.addPropertyInfo(propertyInfo.clone());
+        }
+        for (var _b = 0, _c = base.children; _b < _c.length; _b++) {
+            var child = _c[_b];
+            this.children.push(this.propertyMap[child.propertyName]);
+        }
+        for (var _d = 0, _e = base.parentProperties; _d < _e.length; _d++) {
+            var parent_1 = _e[_d];
+            this.parentProperties.push(this.propertyMap[parent_1.propertyName]);
+        }
+        if (!this.parentProperty && base.parentProperty) {
+            this.parentProperty = this.propertyMap[base.parentProperty.propertyName];
+        }
+        this._inheritsBindableBase = base._inheritsBindableBase;
+        if (this.modelCreator.isModelBase(this.objectConstructor) || base._inheritsModelBase) {
+            this._inheritsModelBase = true;
+        }
+    };
+    NeoTypeInfo.prototype.ensureInitialised = function () {
+        if (!this.modelCreator) {
+            // create a new instance which will cause the type to be setup.
+            this.createInstance();
+        }
+    };
+    NeoTypeInfo.prototype.createInstance = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        if (this.wrapperConstructor) {
+            return this.wrapperConstructor(args);
+        }
+        else {
+            return new this.objectConstructor(args);
+        }
+    };
+    /** Gets the override constructor which can setup a neo model. */
+    NeoTypeInfo.prototype.getOverrideConstructor = function () {
+        if (!this.wrapperConstructor) {
+            this.wrapperConstructor = this.createWrapperConstructor();
+        }
+        return this.wrapperConstructor;
+    };
+    NeoTypeInfo.prototype.createWrapperConstructor = function () {
+        var self = this;
+        var baseType = Object.getPrototypeOf(self.objectConstructor);
+        if ((baseType === null || baseType === void 0 ? void 0 : baseType.name) === "neoConstructor") {
+            return function () {
+                throw Error(self.objectConstructor.name + " cannot inherit from a model decorated with @NeoModel.");
+            };
+        }
+        var newConstructor = function neoConstructor() {
+            var _a;
+            var args = [];
+            for (var _i = 0; _i < arguments.length; _i++) {
+                args[_i] = arguments[_i];
+            }
+            var instance = new ((_a = self.objectConstructor).bind.apply(_a, __spreadArray([void 0], args, false)))();
+            return self.makeObservable(instance);
+        };
+        // Copy statics from the original constructor, and all base classes to the new constructor.
+        baseType = this.objectConstructor;
+        while (baseType && baseType !== Function.prototype) {
+            for (var _i = 0, _a = Object.getOwnPropertyNames(baseType); _i < _a.length; _i++) {
+                var propertyName = _a[_i];
+                if (propertyName !== "prototype" && propertyName !== "caller" && propertyName !== "arguments" && propertyName !== "neo") {
+                    // @ts-ignore
+                    if (newConstructor[propertyName] === undefined) {
+                        var descriptor = Object.getOwnPropertyDescriptor(baseType, propertyName);
+                        if (descriptor.value !== void 0) {
+                            if (typeof descriptor.value === 'function') {
+                                // @ts-ignore
+                                newConstructor[propertyName] = baseType[propertyName];
+                            }
+                            else {
+                                // Define a property on this constructor pointing to the original property.
+                                this.defineProxyProperty(baseType, newConstructor, propertyName);
+                            }
+                        }
+                    }
+                }
+            }
+            baseType = Object.getPrototypeOf(baseType);
+        }
+        // Copy inversify metadata:
+        Reflect.defineMetadata(inversifyMetadataKey, Reflect.getMetadata(inversifyMetadataKey, this.objectConstructor), newConstructor);
+        newConstructor.neo = self.objectConstructor.neo;
+        newConstructor.prototype = self.objectConstructor.prototype;
+        return newConstructor;
+    };
+    NeoTypeInfo.prototype.makeObservable = function (instance, options) {
+        options = options !== null && options !== void 0 ? options : {};
+        if (!options.skipConversion) {
+            this.ensureStaticRuntimeInfo(instance);
+            if (options.makeObservable === undefined) {
+                options.makeObservable = this.inheritsModelBase;
+            }
+            if (instance[hasConvertedSymbol]) {
+                throw Error("makeObservable() or makeBindable() has been called multiple times on type ".concat(this.objectConstructor.name, ". Make sure this is only called on the last derived type."));
+            }
+            else {
+                instance[hasConvertedSymbol] = true;
+            }
+            return this.modelCreator.convertInstance(instance, options);
+        }
+        return instance;
+    };
+    NeoTypeInfo.prototype.defineProxyProperty = function (baseType, newConstructor, propertyKey) {
+        Object.defineProperty(newConstructor, propertyKey, {
+            get: function () { return baseType[propertyKey]; },
+            set: function (value) { return baseType[propertyKey] = value; }
+        });
+    };
+    /**
+     * Makes a class instance observable.
+     * Must be called in the constructor, preferably directly after the super() call.
+     * This method can be used as an alternative to the @NeoModel decorator.
+     */
+    NeoTypeInfo.makeObservable = function (instance, options) {
+        var ctor = instance.constructor;
+        ensureTypeInfo(ctor);
+        ctor.neo.makeObservable(instance, options);
+    };
+    /** Ensures the type and its metadata are initialised. */
+    NeoTypeInfo.ensureInitialised = function (constructor) {
+        var typeInfo = ensureTypeInfo(constructor).neo;
+        typeInfo.ensureInitialised();
+        return typeInfo;
+    };
+    return NeoTypeInfo;
+}());
+export { NeoTypeInfo };
+export function ensureTypeInfo(constructor) {
+    if (!constructor.hasOwnProperty("neo")) {
+        constructor.neo = new NeoTypeInfo();
+        constructor.neo.initialise(constructor);
+    }
+    return constructor;
+}
+function populateMetaItem(item, level) {
+    if (level < 5) {
+        for (var propertyKey in item.meta) {
+            var propertyInfo = item.meta[propertyKey].propertyInfo;
+            if ((propertyInfo.relationType === RelationType.ChildObject || propertyInfo.relationType === RelationType.ValueObject)) {
+                var propertyType = propertyInfo.type;
+                if (propertyType) {
+                    var childItem = { meta: propertyType.neo.meta };
+                    populateMetaItem(childItem, level + 1);
+                    item[propertyKey] = childItem;
+                }
+            }
+        }
+    }
+}

package/dist/Model/ObservableProperty.d.ts

@@ -1,8 +1,8 @@
-import PropertyInfo from './PropertyInfo';
-import PropertyInstance from './PropertyInstance';
-export declare class ObservableProperty {
-    /** Creates an observable property which can be used for binding. */
-    static create(displayName: string, defaultValue: any, options?: Partial<PropertyInfo>, isRequired?: boolean): PropertyInstance;
-    /** Creates an observable property which can be used for binding. The value will be required when bound in an editor. */
-    static required(displayName: string, defaultValue: any, options?: Partial<PropertyInfo>): PropertyInstance;
-}
+import PropertyInfo from './PropertyInfo';
+import PropertyInstance from './PropertyInstance';
+export declare class ObservableProperty {
+    /** Creates an observable property which can be used for binding. */
+    static create(displayName: string, defaultValue: any, options?: Partial<PropertyInfo>, isRequired?: boolean): PropertyInstance;
+    /** Creates an observable property which can be used for binding. The value will be required when bound in an editor. */
+    static required(displayName: string, defaultValue: any, options?: Partial<PropertyInfo>): PropertyInstance;
+}