@singularsystems/neo-core 0.10.60 → 0.10.62

package/dist/Components/ButtonOptions.d.ts

@@ -4,6 +4,8 @@ import { ITooltipOptions } from "./TooltipOptions";
 export interface IButtonOptions {
     /** True if the click event of this button must be invoked when the parent form of this button is submitted. */
     isSubmit?: boolean;
+    /** The id of the form this button should attach to. Use this if the button is not nested within the form. */
+    form?: string;
     /** Bootstrap variant */
     variant?: variant;
     /** Bootstrap size */

package/dist/Model/BindableBase.d.ts

@@ -1,4 +1,4 @@
-import { TransformMetaType, PartialPlainObject, PlainFlatObject, PartialOrNull } from './IModelBase';
+import { TransformMetaType, PartialPlainObject, PlainFlatObject, PartialOrNull, IMakeBindableOptions } from './IModelBase';
 import { NeoTypeInfo } from './NeoTypeInfo';
 import { IDeserialiseOptions } from '../Data/Deserialiser';
 export declare abstract class BindableBase {
@@ -30,6 +30,12 @@ export declare abstract class BindableBase {
      * This method can be used as an alternative to the @NeoModel decorator.
      */
     protected makeObservable(): void;
+    /**
+     * Makes the model bindable (and observable if it inherits from ModelBase) by creating its 'meta' object.
+     * Must be called in the constructor, preferably directly after the super() call.
+     * This method can be used as an alternative to the @NeoModel decorator.
+     */
+    protected makeBindable(options?: IMakeBindableOptions): void;
     static neo: NeoTypeInfo;
     /**
      * Creates a new instance of this type, and deserialises the plain javascript object graph into it.

package/dist/Model/BindableBase.js

@@ -1,7 +1,7 @@
 import { __assign, __decorate, __metadata } from "tslib";
 import { NoTracking, Observable } from './Decorators';
 import { JSFormatter } from '../Data/Serialiser';
-import { ensureTypeInfo } from './NeoTypeInfo';
+import { NeoTypeInfo } from './NeoTypeInfo';
 import { Utils } from '../Utils';
 import { SerialiseType } from './Misc';
 var BindableBase = /** @class */ (function () {
@@ -42,11 +42,15 @@ var BindableBase = /** @class */ (function () {
      * This method can be used as an alternative to the @NeoModel decorator.
      */
     BindableBase.prototype.makeObservable = function () {
-        // Ensure neo info is set
-        var ctor = this.constructor;
-        // Call this in case no property decorators were added
-        ensureTypeInfo(ctor);
-        ctor.neo.makeObservable(this);
+        this.makeBindable({ makeObservable: true });
+    };
+    /**
+     * Makes the model bindable (and observable if it inherits from ModelBase) by creating its 'meta' object.
+     * Must be called in the constructor, preferably directly after the super() call.
+     * This method can be used as an alternative to the @NeoModel decorator.
+     */
+    BindableBase.prototype.makeBindable = function (options) {
+        NeoTypeInfo.makeObservable(this, options);
     };
     /**
      * Creates a new instance of this type, and deserialises the plain javascript object graph into it.

package/dist/Model/IModelBase.d.ts

@@ -41,6 +41,19 @@ export declare type PartialPlainNonTrackedObject<T> = PartialPlainObject<T> & {
 export interface NeoModelConstructor extends Function {
     neo: NeoTypeInfo;
 }
+export interface IMakeBindableOptions {
+    /**
+     * Specifies whether properties should be observable
+     * * If this is `true`, all properties will be observable by default.
+     * * If `false` only properties decorated with @Attributes.Observable will be made observable.
+     * * If `undefined`, only types that inherit from `ModelBase` will be observable by default.
+     */
+    makeObservable?: boolean;
+    /**
+     * If `true`, this instance will not be converted. In inheritence heirarchies, use this to ensure only the last derived type converts the instance.
+     */
+    skipConversion?: boolean;
+}
 export interface IDebounceOptions {
     delayMs?: number;
 }

package/dist/Model/IModelCreatorBase.d.ts

@@ -1,9 +1,9 @@
 import { NeoTypeInfo } from './NeoTypeInfo';
-import { NeoModelConstructor } from './IModelBase';
+import { IMakeBindableOptions, NeoModelConstructor } from './IModelBase';
 export default interface IModelCreatorBase {
     shouldInitialiseAllMembers: boolean;
     initialise(typeInfo: NeoTypeInfo, originalConstructor: NeoModelConstructor): void;
     isBindableBase(type: NeoModelConstructor): boolean;
     isModelBase(type: NeoModelConstructor): boolean;
-    convertInstance(instance: {}): {};
+    convertInstance(instance: {}, options: IMakeBindableOptions): {};
 }

package/dist/Model/List.d.ts

@@ -74,4 +74,6 @@ export default class List<T> extends Array<T> {
     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

@@ -2,6 +2,7 @@ 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) {
@@ -179,8 +180,7 @@ var List = /** @class */ (function (_super) {
         }
         else {
             var ctor = this.childObjectType.prototype.constructor;
-            ctor.neo.ensureInitialised();
-            return ctor.neo.metaItem;
+            return NeoTypeInfo.ensureInitialised(ctor).metaItem;
         }
     };
     Object.defineProperty(List.prototype, "isValid", {
@@ -211,6 +211,14 @@ var List = /** @class */ (function (_super) {
         enumerable: true,
         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: true,
+        configurable: true
+    });
     return List;
 }(Array));
 export default List;

package/dist/Model/ModelCreatorBase.d.ts

@@ -1,7 +1,8 @@
 import { NeoTypeInfo } from './NeoTypeInfo';
-import { NeoModelConstructor } from './IModelBase';
+import { IMakeBindableOptions, NeoModelConstructor } from './IModelBase';
 import PropertyInfo from './PropertyInfo';
-export declare abstract class ModelCreatorBase {
+import IModelCreatorBase from './IModelCreatorBase';
+export declare abstract class ModelCreatorBase implements IModelCreatorBase {
     protected typeInfo: NeoTypeInfo;
     protected alwaysInitialiseMembers: boolean;
     /**
@@ -19,5 +20,5 @@ export declare abstract class ModelCreatorBase {
     protected ensureChildInfo(instance: {}, propertyInfo: PropertyInfo): void;
     protected addMethodInfo(methodName: string, method: Function): void;
     protected addProperty(propertyName: string, descriptor: PropertyDescriptor): void;
-    abstract convertInstance(instance: {}): {};
+    abstract convertInstance(instance: {}, options: IMakeBindableOptions): {};
 }

package/dist/Model/NeoTypeInfo.d.ts

@@ -1,10 +1,11 @@
 import { Rule } from '../Validation/Rules';
 import { PropertyInstanceMap } from './PropertyInstance';
 import PropertyInfo, { PropertyInfoMap } from './PropertyInfo';
-import { NeoModelConstructor, IModelBase, IMetaItem } from './IModelBase';
+import { NeoModelConstructor, IModelBase, IMetaItem, IMakeBindableOptions } from './IModelBase';
 export declare class NeoTypeInfo {
     private modelCreator;
     private objectConstructor;
+    private wrapperConstructor?;
     private _inheritsBindableBase;
     private _inheritsModelBase;
     private _metaItem;
@@ -35,7 +36,16 @@ export declare class NeoTypeInfo {
     ensureInitialised(): void;
     /** Gets the override constructor which can setup a neo model. */
     getOverrideConstructor(): Function;
-    makeObservable(instance: any): {};
+    private createWrapperConstructor;
+    makeObservable(instance: any, options?: IMakeBindableOptions): any;
     private defineProxyProperty;
+    /**
+     * 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.
+     */
+    static makeObservable(instance: any, options?: IMakeBindableOptions): void;
+    /** Ensures the type and its metadata are initialised. */
+    static ensureInitialised(constructor: NeoModelConstructor): NeoTypeInfo;
 }
 export declare function ensureTypeInfo(constructor: NeoModelConstructor): NeoModelConstructor;

package/dist/Model/NeoTypeInfo.js

@@ -9,6 +9,7 @@ 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;
@@ -164,11 +165,22 @@ var NeoTypeInfo = /** @class */ (function () {
     NeoTypeInfo.prototype.ensureInitialised = function () {
         if (!this.modelCreator) {
             // create a new instance which will cause the type to be setup.
-            this.getOverrideConstructor()();
+            if (this.wrapperConstructor) {
+                this.wrapperConstructor();
+            }
+            else {
+                void new this.objectConstructor();
+            }
         }
     };
     /** 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 _a;
         var self = this;
         var baseType = Object.getPrototypeOf(self.objectConstructor);
@@ -214,9 +226,22 @@ var NeoTypeInfo = /** @class */ (function () {
         newConstructor.prototype = self.objectConstructor.prototype;
         return newConstructor;
     };
-    NeoTypeInfo.prototype.makeObservable = function (instance) {
-        this.ensureStaticRuntimeInfo(instance);
-        return this.modelCreator.convertInstance(instance);
+    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 " + 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, {
@@ -224,6 +249,22 @@ var NeoTypeInfo = /** @class */ (function () {
             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 };

package/dist/Model/index.d.ts

@@ -1,4 +1,4 @@
-export { IBindableBase, IModelBase, NeoModelConstructor, PlainObject, PlainTrackedObject, PartialPlainObject, PartialPlainNonTrackedObject, TransformMetaType } from './IModelBase';
+export { IBindableBase, IModelBase, NeoModelConstructor, PlainObject, PlainTrackedObject, PartialPlainObject, PartialPlainNonTrackedObject, TransformMetaType, IMakeBindableOptions } from './IModelBase';
 export { ILookupBase } from './LookupBase';
 export { IPropertyInstance, PropertyAccessor } from './PropertyInstance';
 export { IObservableValue, ObservableValue } from './ObservableValue';

package/dist/Validation/Validators/ModelValidator.js

@@ -1,5 +1,4 @@
 import { __decorate, __metadata } from "tslib";
-import NeoModel from '../../Model/NeoModel';
 import { Observable, Computed } from '../../Model/Decorators';
 import PropertyInstance from '../../Model/PropertyInstance';
 import RuleValidator from './RuleValidator';
@@ -7,6 +6,7 @@ import { ContainerValidationState } from '../ValidationState';
 import PropertyValidator from './PropertyValidator';
 import PropertyInfo from '../../Model/PropertyInfo';
 import ValidationDisplayHelper from '../DisplayHelper';
+import { NeoTypeInfo } from '../../Model/NeoTypeInfo';
 var ModelValidator = /** @class */ (function () {
     function ModelValidator(model, objectRules) {
         var _this = this;
@@ -25,6 +25,7 @@ var ModelValidator = /** @class */ (function () {
                 _this.objectRules.push(new RuleValidator(tempPropertyInstance_1, rule));
             });
         }
+        NeoTypeInfo.makeObservable(this);
     }
     ModelValidator.prototype.addProperty = function (property) {
         this.ruleProperties.push(property);
@@ -128,10 +129,6 @@ var ModelValidator = /** @class */ (function () {
         __metadata("design:type", ContainerValidationState),
         __metadata("design:paramtypes", [])
     ], ModelValidator.prototype, "ruleState", null);
-    ModelValidator = __decorate([
-        NeoModel,
-        __metadata("design:paramtypes", [Object, Array])
-    ], ModelValidator);
     return ModelValidator;
 }());
 export default ModelValidator;

package/dist/Validation/Validators/PropertyValidator.js

@@ -2,14 +2,15 @@ import { __decorate, __metadata } from "tslib";
 import { ContainerValidationState } from '../ValidationState';
 import { ValidationDisplayMode } from '../Misc';
 import { ValidationDisplayInfo } from '../DisplayHelper';
-import NeoModel from '../../Model/NeoModel';
 import { Observable, Computed } from '../../Model/Decorators';
+import { NeoTypeInfo } from '../../Model/NeoTypeInfo';
 var PropertyValidator = /** @class */ (function () {
     function PropertyValidator(propertyInstance, ruleList) {
         this.propertyInstance = propertyInstance;
         this.ruleList = ruleList;
         /** True if an element bound to this property has lost focus. Used for displaying rules. */
         this.hasBlurred = false;
+        NeoTypeInfo.makeObservable(this);
     }
     Object.defineProperty(PropertyValidator.prototype, "ruleState", {
         get: function () {
@@ -58,10 +59,6 @@ var PropertyValidator = /** @class */ (function () {
         __metadata("design:type", ContainerValidationState),
         __metadata("design:paramtypes", [])
     ], PropertyValidator.prototype, "ruleState", null);
-    PropertyValidator = __decorate([
-        NeoModel,
-        __metadata("design:paramtypes", [Object, Array])
-    ], PropertyValidator);
     return PropertyValidator;
 }());
 export default PropertyValidator;

package/dist/Validation/Validators/RuleValidator.js

@@ -1,8 +1,7 @@
 import { __decorate, __metadata } from "tslib";
-import { Rule } from '../Rules';
 import { RuleContext, AsyncStage } from '../RuleContext';
-import NeoModel from '../../Model/NeoModel';
 import { Observable, Computed } from '../../Model/Decorators';
+import { NeoTypeInfo } from '../../Model/NeoTypeInfo';
 var RuleValidator = /** @class */ (function () {
     function RuleValidator(propertyInstance, rule) {
         this.propertyInstance = propertyInstance;
@@ -13,6 +12,7 @@ var RuleValidator = /** @class */ (function () {
         // Properties this rule has been added to, including the primary property.
         this.properties = [];
         this.refreshValue = 0;
+        NeoTypeInfo.makeObservable(this);
     }
     Object.defineProperty(RuleValidator.prototype, "ruleId", {
         get: function () {
@@ -46,10 +46,6 @@ var RuleValidator = /** @class */ (function () {
         __metadata("design:type", Object),
         __metadata("design:paramtypes", [])
     ], RuleValidator.prototype, "ruleContext", null);
-    RuleValidator = __decorate([
-        NeoModel,
-        __metadata("design:paramtypes", [Object, Rule])
-    ], RuleValidator);
     return RuleValidator;
 }());
 export default RuleValidator;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@singularsystems/neo-core",
-  "version": "0.10.60",
+  "version": "0.10.62",
   "description": "Core functionality for the Neo client library",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",