@singularsystems/neo-core 1.0.0-alpha.4 → 1.0.0-beta.0

package/README.md

@@ -1,6 +1,6 @@
 # neo-core
 
-This project contains the core functionality of the neo client library. The code in this library is referenced by the neo-vue and neo-react projects.
+This project contains the core functionality of the neo client library. 
 
 ## Testing
 

package/dist/Components/DatePicker/DatePicker.d.ts

@@ -10,7 +10,6 @@ export default class DatePicker {
     private headerAnimationHelper;
     private inputHasChanged;
     private canAutoSetDate;
-    private suspendLayout;
     private input;
     private popup;
     private headerContainer;
@@ -65,6 +64,7 @@ export default class DatePicker {
     private previousClick;
     private nextClick;
     private moveCurrent;
+    private autoSetDate;
     private createAndAppend;
     destroy(): void;
 }

package/dist/Components/DatePicker/DatePicker.js

@@ -2,7 +2,6 @@ import DateUtils from '../../Dates/DateUtils';
 import AnimationHelper from '../AnimationHelper';
 import { YearsInYearView, ProcessedDatePickerOptions } from './DatePickerOptions';
 import PositionHelper from '../PositionHelper';
-import { Utils } from '../../Utils';
 // TODO: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DateTimeFormat
 // TODO: Allow input to be shown with inline picker, and specify position.
 var ViewType;
@@ -17,7 +16,6 @@ var DatePicker = /** @class */ (function () {
         this.isReadOnly = false;
         this.inputHasChanged = false;
         this.canAutoSetDate = false;
-        this.suspendLayout = false;
         this.currentBindValue = null;
         this.boundDateNoTime = null;
         this.options = ProcessedDatePickerOptions.fromPartial(options || {});
@@ -139,15 +137,11 @@ var DatePicker = /** @class */ (function () {
         }
     };
     DatePicker.prototype.setBindProperty = function (dateValue, suspend) {
-        var _this = this;
         if (dateValue) {
             dateValue = DateUtils.max(DateUtils.min(dateValue, this.options.maxDate), this.options.minDate);
         }
-        if (suspend)
-            this.suspendLayout = true;
+        this.currentBindValue = dateValue;
         this.bindProperty.value = dateValue;
-        if (suspend)
-            Utils.nextTick(function () { return _this.suspendLayout = false; });
         if (this.options.onDateSelected !== undefined) {
             this.options.onDateSelected(!suspend);
         }
@@ -191,14 +185,10 @@ var DatePicker = /** @class */ (function () {
             this.currentBindValue = bindProperty === null || bindProperty === void 0 ? void 0 : bindProperty.value;
             this.resetCurrentViewDate();
             if (this.options.alwaysShow) {
-                if (!this.suspendLayout) {
-                    this.createComponents();
-                }
-            }
-            else {
-                this.setInputValue();
+                this.createComponents();
             }
         }
+        this.setInputValue();
     };
     DatePicker.prototype.resetCurrentViewDate = function () {
         this.setCurrentViewDate(this.bindProperty.value);
@@ -313,11 +303,13 @@ var DatePicker = /** @class */ (function () {
         var lastDayOfMonth = DateUtils.monthEnd(currentDate);
         this.prevButton.disabled = this.options.minDateNoTime.getTime() >= currentDate.getTime();
         if (this.canAutoSetDate && this.options.autoChangeDate == "start") {
-            this.setBindProperty(currentDate, true);
+            //this.setCurrentViewDate(currentDate)
+            //this.setBindProperty(currentDate, true);
         }
         this.nextButton.disabled = this.options.maxDateNoTime.getTime() <= lastDayOfMonth.getTime();
         if (this.canAutoSetDate && this.options.autoChangeDate == "end") {
-            this.setBindProperty(lastDayOfMonth, true);
+            //this.setCurrentViewDate(lastDayOfMonth)
+            //this.setBindProperty(lastDayOfMonth, true);
         }
         // Start with the first Sunday before the first of the month.
         currentDate.setDate(currentDate.getDate() - currentDate.getDay());
@@ -471,6 +463,7 @@ var DatePicker = /** @class */ (function () {
         if (this.currentViewType == ViewType.Days) {
             this.canAutoSetDate = true;
             this.currentViewDate.setMonth(this.currentViewDate.getMonth() + delta, 1);
+            this.autoSetDate(delta);
         }
         else {
             this.currentViewDate.setFullYear(this.currentViewDate.getFullYear() + delta * (this.currentViewType == ViewType.Months ? 1 : YearsInYearView));
@@ -478,6 +471,21 @@ var DatePicker = /** @class */ (function () {
         this.populateContentContainer(false, true);
         this.contentAnimationHelper.slide(delta, true);
     };
+    DatePicker.prototype.autoSetDate = function (delta) {
+        var autoDate = null;
+        if (this.options.autoChangeDate === "end") {
+            // Forward
+            autoDate = DateUtils.monthEnd(this.currentViewDate);
+        }
+        else if (this.options.autoChangeDate === "start") {
+            // Back
+            autoDate = this.currentViewDate;
+        }
+        if (autoDate) {
+            this.setBindProperty(autoDate, true);
+            this.setCurrentViewDate(this.bindProperty.value);
+        }
+    };
     DatePicker.prototype.createAndAppend = function (parent, elementType, className) {
         if (className === void 0) { className = ""; }
         var newElement = document.createElement(elementType);

package/dist/Components/ErrorHandler.d.ts

@@ -33,7 +33,11 @@ export declare enum ErrorDisplayType {
 }
 export declare class ErrorHandler implements IErrorHandler {
     private notifications;
-    constructor(notifications: INotificationHelper);
+    private blobType;
+    constructor(notifications: INotificationHelper, blobType?: {
+        new (blobParts?: BlobPart[] | undefined, options?: BlobPropertyBag | undefined): Blob;
+        prototype: Blob;
+    });
     showError(error: any, displayType: ErrorDisplayType): Promise<void>;
     parseError(error: any): Promise<IErrorDisplay>;
     protected getAxiosError(error: AxiosError, response?: AxiosResponse): Promise<IErrorDisplay>;

package/dist/Components/ErrorHandler.js

@@ -2,7 +2,6 @@ import { __awaiter, __decorate, __generator, __metadata, __param } from "tslib";
 import { injectable, inject } from 'inversify';
 import { ModalUtils } from './Modal/ModalUtils';
 import NeoTypes from '../AppServices/NeoTypes';
-import { Blob } from 'buffer';
 export var ErrorDisplayType;
 (function (ErrorDisplayType) {
     /** Show the error text in a modal. */
@@ -13,8 +12,10 @@ export var ErrorDisplayType;
     ErrorDisplayType[ErrorDisplayType["ThrowError"] = 2] = "ThrowError";
 })(ErrorDisplayType || (ErrorDisplayType = {}));
 export var ErrorHandler = /** @class */ (function () {
-    function ErrorHandler(notifications) {
+    function ErrorHandler(notifications, blobType) {
+        if (blobType === void 0) { blobType = Blob; }
         this.notifications = notifications;
+        this.blobType = blobType;
     }
     ErrorHandler.prototype.showError = function (error, displayType) {
         return __awaiter(this, void 0, void 0, function () {
@@ -163,7 +164,7 @@ export var ErrorHandler = /** @class */ (function () {
             return __generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
-                        if (!(responseData instanceof Blob)) return [3 /*break*/, 2];
+                        if (!(responseData instanceof this.blobType)) return [3 /*break*/, 2];
                         return [4 /*yield*/, responseData.text()];
                     case 1:
                         errorText = _a.sent();
@@ -204,7 +205,7 @@ export var ErrorHandler = /** @class */ (function () {
     ErrorHandler = __decorate([
         injectable(),
         __param(0, inject(NeoTypes.UI.GlobalNotifications.symbol)),
-        __metadata("design:paramtypes", [Object])
+        __metadata("design:paramtypes", [Object, Object])
     ], ErrorHandler);
     return ErrorHandler;
 }());

package/dist/Model/BindableBase.d.ts

@@ -29,7 +29,7 @@ export declare abstract class BindableBase {
      * 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 makeObservable(): void;
+    protected makeObservable(options?: IMakeBindableOptions): 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.

package/dist/Model/BindableBase.js

@@ -41,8 +41,11 @@ export var BindableBase = /** @class */ (function () {
      * 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.makeObservable = function () {
-        this.makeBindable({ makeObservable: true });
+    BindableBase.prototype.makeObservable = function (options) {
+        var _a;
+        options !== null && options !== void 0 ? options : (options = {});
+        (_a = options.makeObservable) !== null && _a !== void 0 ? _a : (options.makeObservable = true);
+        this.makeBindable(options);
     };
     /**
      * Makes the model bindable (and observable if it inherits from ModelBase) by creating its 'meta' object.

package/dist/Model/Decorators.d.ts

@@ -43,5 +43,8 @@ export declare function OnChanged<T>(callback: (target: T) => (oldValue: any, ne
 export declare function Debounce(value?: boolean): (type: any, propertyKey: string) => void;
 /** Converts a getter into a computed. Note, when using NeoModel you do not need to do this. */
 export declare function Computed(isComputed?: boolean): (type: any, propertyKey: string, descriptor: PropertyDescriptor) => void;
+/** Specifies whether a method is a mobx action. By default all methods are actions.
+ * Use this decorator to suppress this behaviour (by passing in false), or change the default behaviour in the makeObservable options passed to makeObservable. */
+export declare function Action(isAction?: boolean): (type: any, propertyKey: string, descriptor: PropertyDescriptor) => void;
 /** Sets this property as the display member to be used in drop downs / radio lists etc. */
 export declare function DisplayMember(): (type: any, propertyKey: string) => void;

package/dist/Model/Decorators.js

@@ -173,6 +173,13 @@ export function Computed(isComputed) {
         ensureTypeInfo(type.constructor).neo.addComputed(propertyKey, descriptor, isComputed);
     };
 }
+/** Specifies whether a method is a mobx action. By default all methods are actions.
+ * Use this decorator to suppress this behaviour (by passing in false), or change the default behaviour in the makeObservable options passed to makeObservable. */
+export function Action(isAction) {
+    return function (type, propertyKey, descriptor) {
+        ensureTypeInfo(type.constructor).neo.addMethod(propertyKey).isAction = isAction;
+    };
+}
 /** Sets this property as the display member to be used in drop downs / radio lists etc. */
 export function DisplayMember() {
     return function (type, propertyKey) {

package/dist/Model/IModelBase.d.ts

@@ -26,15 +26,20 @@ type RemoveChildren<T> = Pick<T, {
 export type PartialOrNull<T> = {
     [P in keyof T]?: T[P] | null;
 };
+/** Removes ModelBase properties (isNew, isDirty etc), removes methods, and changes list types to arrays. */
 export type PlainObject<T> = TransformLists<NoModelBase<T>>;
+/** PlainObject plus tracking state and entity identifier.  */
 export type PlainTrackedObject<T> = PlainObject<T> & {
     trackingState?: Misc.TrackingState;
     entityIdentifier?: string;
 };
+/** Plain object with no tracking state, and no lists. */
 export type PlainFlatObject<T> = Pick<T, Exclude<keyof T, keyof IModelBase> & keyof RemoveMethods<T> & keyof RemoveChildren<T>>;
+/** Plain object where the meta property is not allowed. Used to accept any Plain* object. */
 export type PartialPlainObject<T> = Partial<PlainObject<T>> & {
     meta?: never;
 };
+/** Plain object where the meta and tracking state properties are not allowed. Used to accept PlainObject and PlainFlatObject. */
 export type PartialPlainNonTrackedObject<T> = PartialPlainObject<T> & {
     trackingState?: never;
 };
@@ -49,6 +54,10 @@ export interface IMakeBindableOptions {
      * * If `undefined`, only types that inherit from `ModelBase` will be observable by default.
      */
     makeObservable?: boolean;
+    /**
+     * Specifies whether methods should be converted to mobx actions. This is `true` by default.
+     * Use `Attributes.Action()` to override this per methis. */
+    autoActions?: boolean;
     /**
      * If `true`, this instance will not be converted. In inheritence heirarchies, use this to ensure only the last derived type converts the instance.
      */

package/dist/Model/MethodInfo.d.ts

@@ -0,0 +1,8 @@
+export default class MethodInfo {
+    name: string;
+    constructor(name: string);
+    /**
+     * Specifies whether the method should be converted to a mobx action.
+     */
+    isAction?: boolean;
+}

package/dist/Model/MethodInfo.js

@@ -0,0 +1,7 @@
+var MethodInfo = /** @class */ (function () {
+    function MethodInfo(name) {
+        this.name = name;
+    }
+    return MethodInfo;
+}());
+export default MethodInfo;

package/dist/Model/ModelBase.js

@@ -1,7 +1,8 @@
 import { __decorate, __extends, __metadata } from "tslib";
 import * as ModelTraverser from './ModelGraphTraverser';
-import { Computed, NoTracking, Observable } from './Decorators';
+import { Action, Computed, NoTracking, Observable } from './Decorators';
 import { JSFormatter } from '../Data/Serialiser';
+import { ValidationRules } from '../Validation/ValidationRules';
 import { BindableBase } from './BindableBase';
 import { Misc } from '../';
 import { SerialiseType } from './Misc';
@@ -177,6 +178,12 @@ var ModelBase = /** @class */ (function (_super) {
         __metadata("design:type", Object),
         __metadata("design:paramtypes", [])
     ], ModelBase.prototype, "readyToSave", null);
+    __decorate([
+        Action(false),
+        __metadata("design:type", Function),
+        __metadata("design:paramtypes", [ValidationRules]),
+        __metadata("design:returntype", void 0)
+    ], ModelBase.prototype, "addBusinessRules", null);
     return ModelBase;
 }(BindableBase));
 export default ModelBase;

package/dist/Model/ModelCreatorBase.d.ts

@@ -19,6 +19,5 @@ export declare abstract class ModelCreatorBase implements IModelCreatorBase {
      */
     protected ensureChildInfo(instance: {}, propertyInfo: PropertyInfo): void;
     protected addMethodInfo(methodName: string, method: Function): void;
-    protected addProperty(propertyName: string, descriptor: PropertyDescriptor): void;
     abstract convertInstance(instance: {}, options: IMakeBindableOptions): {};
 }

package/dist/Model/ModelCreatorBase.js

@@ -5,6 +5,7 @@ import { RelationType } from './Misc';
 import { ChildList, ChildObject } from './Decorators';
 import ValueObject from './ValueObject';
 import { BindableBase } from './BindableBase';
+var nonActionMethods = ["addBusinessRules", "toString"];
 export var ModelCreatorBase = /** @class */ (function () {
     function ModelCreatorBase() {
         this.alwaysInitialiseMembers = false;
@@ -49,10 +50,6 @@ export var ModelCreatorBase = /** @class */ (function () {
                     if (this.typeInfo.inheritsBindableBase) {
                         this.typeInfo.addComputed(propertyName, descriptor);
                     }
-                    else {
-                        // for general objects, getters must explicitly define @Computed to become computed properties.
-                        this.addProperty(propertyName, descriptor);
-                    }
                 }
             }
         }
@@ -82,8 +79,10 @@ export var ModelCreatorBase = /** @class */ (function () {
         }
     };
     ModelCreatorBase.prototype.addMethodInfo = function (methodName, method) {
-    };
-    ModelCreatorBase.prototype.addProperty = function (propertyName, descriptor) {
+        var methodInfo = this.typeInfo.addMethod(methodName);
+        if (nonActionMethods.indexOf(methodInfo.name) >= 0) {
+            methodInfo.isAction = false;
+        }
     };
     ModelCreatorBase = __decorate([
         injectable()

package/dist/Model/NeoTypeInfo.d.ts

@@ -2,6 +2,7 @@ import { Rule } from '../Validation/Rules';
 import { PropertyInstanceMap } from './PropertyInstance';
 import PropertyInfo, { PropertyInfoMap } from './PropertyInfo';
 import { NeoModelConstructor, IModelBase, IMetaItem, IMakeBindableOptions } from './IModelBase';
+import MethodInfo from './MethodInfo';
 export declare class NeoTypeInfo {
     private modelCreator;
     private objectConstructor;
@@ -11,6 +12,7 @@ export declare class NeoTypeInfo {
     private _metaItem;
     properties: PropertyInfo[];
     propertyMap: PropertyInfoMap;
+    methods: Map<string, MethodInfo>;
     children: PropertyInfo[];
     parentProperties: PropertyInfo[];
     parentProperty?: PropertyInfo;
@@ -24,6 +26,7 @@ export declare class NeoTypeInfo {
     private addPropertyInfo;
     getOrAddProperty(propertyName: string): PropertyInfo;
     addComputed(propertyName: string, descriptor: PropertyDescriptor, isComputed?: boolean): void;
+    addMethod(methodName: string): MethodInfo;
     addAttributeRule(propertyName: string, rule: Rule): void;
     /**
      * Ensures the type has all the information it needs in order to convert instances of this type.

package/dist/Model/NeoTypeInfo.js

@@ -7,7 +7,7 @@ import { ValidationRules } from '../Validation/ValidationRules';
 import ModelProxy from '../Validation/ModelProxy';
 import NeoTypes from '../AppServices/NeoTypes';
 import { RelationType } from './Misc';
-var ignoredPropertyNames = ["$mobx"];
+import MethodInfo from './MethodInfo';
 var inversifyMetadataKey = "inversify:tagged";
 var hasConvertedSymbol = Symbol("hasConvertedModel");
 var NeoTypeInfo = /** @class */ (function () {
@@ -18,6 +18,7 @@ var NeoTypeInfo = /** @class */ (function () {
         this.properties = [];
         // Property info dictionary for easy lookup.
         this.propertyMap = {};
+        this.methods = new Map();
         // 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.
@@ -80,6 +81,9 @@ var NeoTypeInfo = /** @class */ (function () {
         pi.isReadOnly = descriptor.set === undefined;
         pi.descriptor = descriptor;
     };
+    NeoTypeInfo.prototype.addMethod = function (methodName) {
+        return this.methods.getOrAdd(methodName, function () { return new MethodInfo(methodName); });
+    };
     NeoTypeInfo.prototype.addAttributeRule = function (propertyName, rule) {
         this.getOrAddProperty(propertyName).addAttributeRule(rule);
     };
@@ -99,13 +103,22 @@ var NeoTypeInfo = /** @class */ (function () {
             }
             this.modelCreator.initialise(this, this.objectConstructor);
             if (instance && this.modelCreator.shouldInitialiseAllMembers) {
-                for (var _i = 0, _a = Object.getOwnPropertyNames(instance); _i < _a.length; _i++) {
+                var allProperties = __spreadArray([], this.properties, true);
+                var ownProperties = [];
+                for (var _i = 0, _a = Object.keys(instance); _i < _a.length; _i++) {
                     var propertyName = _a[_i];
-                    if (ignoredPropertyNames.indexOf(propertyName) < 0) {
+                    if (!(typeof instance[propertyName] === "function")) {
                         var pi = this.getOrAddProperty(propertyName);
                         pi.setupFromInstance(instance);
+                        // Properties with decorators will be added before own properties.
+                        // Mobx as of version 6 deletes properties, and re-adds them, 
+                        // causing future Object.keys evaulations to return the keys in the order they are passed to mobX.
+                        // This will preserve the order of the keys as they were defined in the object.
+                        allProperties.remove(pi);
+                        ownProperties.push(pi);
                     }
                 }
+                this.properties = __spreadArray(__spreadArray([], ownProperties, true), allProperties, true);
             }
             if (instance)
                 this.addRules(instance);
@@ -247,7 +260,13 @@ var NeoTypeInfo = /** @class */ (function () {
             else {
                 instance[hasConvertedSymbol] = true;
             }
-            return this.modelCreator.convertInstance(instance, options);
+            try {
+                return this.modelCreator.convertInstance(instance, options);
+            }
+            catch (e) {
+                console.error("Error converting model type " + instance.constructor.name);
+                throw e;
+            }
         }
         return instance;
     };

package/dist/Model/PropertyInfo.js

@@ -7,7 +7,6 @@ var PropertyInfo = /** @class */ (function () {
         this.attributeRules = [];
         /** Name to use on labels for this property */
         this.displayName = "";
-        // TODO: noTrack and Observable should be combined and use an enum?
         /** True if the property does not cause the object to become dirty. */
         this.noTrack = false;
         /**

package/package.json

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