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

package/dist/Model/ModelFieldInfo.d.ts

@@ -1,12 +1,29 @@
-import ValueObject from "./ValueObject";
-export declare class ModelFieldInfo extends ValueObject {
-    constructor(displayName: string, valueString: string);
-    /**
-     * Display name for the field.
-     */
-    displayName: string;
-    /**
-     * Lookup of the field value
-     */
-    valueString: string;
-}
+import ValueObject from "./ValueObject";
+import PropertyInfo from "./PropertyInfo";
+export interface IModelFieldInfoContainer {
+    /**
+     * Extra information about lookup fields in this object.
+     */
+    fieldInfo: {
+        [K in keyof this]?: ModelFieldInfo;
+    };
+    /**
+     * Sets the model field info for a property.
+     */
+    setModelFieldInfo(property: PropertyInfo, displayValue: string): ModelFieldInfo;
+}
+export declare class ModelFieldInfo extends ValueObject {
+    constructor(displayName: string, valueString: string);
+    /**
+     * Display name for the field.
+     */
+    displayName: string;
+    /**
+     * Lookup of the field value
+     */
+    valueString: string;
+    /**
+     * If the instance is a container of ModelFieldInfo, the instance is returned, otherwise null is returned.
+     */
+    static asModelFieldInfoContainer(instance: any): IModelFieldInfoContainer | null;
+}

package/dist/Model/ModelFieldInfo.js

@@ -1,26 +1,35 @@
-import { __decorate, __extends, __metadata } from "tslib";
-import ValueObject from "./ValueObject";
-import NeoModel from './NeoModel';
-var ModelFieldInfo = /** @class */ (function (_super) {
-    __extends(ModelFieldInfo, _super);
-    function ModelFieldInfo(displayName, valueString) {
-        var _this = _super.call(this) || this;
-        /**
-         * Display name for the field.
-         */
-        _this.displayName = "";
-        /**
-         * Lookup of the field value
-         */
-        _this.valueString = "";
-        _this.displayName = displayName;
-        _this.valueString = valueString;
-        return _this;
-    }
-    ModelFieldInfo = __decorate([
-        NeoModel,
-        __metadata("design:paramtypes", [String, String])
-    ], ModelFieldInfo);
-    return ModelFieldInfo;
-}(ValueObject));
-export { ModelFieldInfo };
+import { __decorate, __extends, __metadata } from "tslib";
+import ValueObject from "./ValueObject";
+import NeoModel from './NeoModel';
+export var ModelFieldInfo = /** @class */ (function (_super) {
+    __extends(ModelFieldInfo, _super);
+    function ModelFieldInfo(displayName, valueString) {
+        var _this = _super.call(this) || this;
+        /**
+         * Display name for the field.
+         */
+        _this.displayName = "";
+        /**
+         * Lookup of the field value
+         */
+        _this.valueString = "";
+        _this.displayName = displayName;
+        _this.valueString = valueString;
+        return _this;
+    }
+    /**
+     * If the instance is a container of ModelFieldInfo, the instance is returned, otherwise null is returned.
+     */
+    ModelFieldInfo.asModelFieldInfoContainer = function (instance) {
+        if (instance.fieldInfo &&
+            instance.setModelFieldInfo) {
+            return instance;
+        }
+        return null;
+    };
+    ModelFieldInfo = __decorate([
+        NeoModel,
+        __metadata("design:paramtypes", [String, String])
+    ], ModelFieldInfo);
+    return ModelFieldInfo;
+}(ValueObject));

package/dist/Model/ModelGraphTraverser.d.ts

@@ -1,35 +1,35 @@
-import { RelationType } from './Misc';
-import { IModelBase } from './IModelBase';
-import PropertyInfo from './PropertyInfo';
-export declare class RecursionState {
-    stop: boolean;
-    canRecurse: (model: IModelBase, property: PropertyInfo) => boolean;
-    pushState(): void;
-    popState(): void;
-    /**
-     * Overwrites the canRecurse callback to always return true.
-     */
-    includeNonTrackedProperties(): this;
-}
-export declare class BooleanRecursionState extends RecursionState {
-    flag: boolean;
-    constructor(flag?: boolean);
-}
-declare type itemDelegate<T> = (item: IModelBase, state: T, relationType?: RelationType) => void;
-declare type listDelegate<T> = (list: any[], state: T) => void;
-/**
- * Recursively traverses the model graph, and invokes the provided callback for each item in the graph.
- * @param model Model object, or list of objects.
- * @param callback Callback to be invoked for each item.
- * @param listCallback Callback to be invoked when a child list is found.
- */
-export declare function traverseItems(model: IModelBase | IModelBase[], callback: itemDelegate<null>, listCallback?: listDelegate<null>): void;
-/**
- * Recursively traverses the model graph, and invokes the provided callback for each item in the graph.
- * @param model Model object, or list of objects.
- * @param state State object.
- * @param callback Callback to be invoked for each item.
- * @param listCallback Callback to be invoked when a child list is found.
- */
-export declare function traverseItems<T extends RecursionState>(model: IModelBase | IModelBase[], state: T, callback: itemDelegate<T>, listCallback?: listDelegate<T>): T;
-export {};
+import { RelationType } from './Misc';
+import { IModelBase } from './IModelBase';
+import PropertyInfo from './PropertyInfo';
+export declare class RecursionState {
+    stop: boolean;
+    canRecurse: (model: IModelBase, property: PropertyInfo) => boolean;
+    pushState(): void;
+    popState(): void;
+    /**
+     * Overwrites the canRecurse callback to always return true.
+     */
+    includeNonTrackedProperties(): this;
+}
+export declare class BooleanRecursionState extends RecursionState {
+    flag: boolean;
+    constructor(flag?: boolean);
+}
+type itemDelegate<T> = (item: IModelBase, state: T, relationType?: RelationType) => void;
+type listDelegate<T> = (list: any[], state: T) => void;
+/**
+ * Recursively traverses the model graph, and invokes the provided callback for each item in the graph.
+ * @param model Model object, or list of objects.
+ * @param callback Callback to be invoked for each item.
+ * @param listCallback Callback to be invoked when a child list is found.
+ */
+export declare function traverseItems(model: IModelBase | IModelBase[], callback: itemDelegate<null>, listCallback?: listDelegate<null>): void;
+/**
+ * Recursively traverses the model graph, and invokes the provided callback for each item in the graph.
+ * @param model Model object, or list of objects.
+ * @param state State object.
+ * @param callback Callback to be invoked for each item.
+ * @param listCallback Callback to be invoked when a child list is found.
+ */
+export declare function traverseItems<T extends RecursionState>(model: IModelBase | IModelBase[], state: T, callback: itemDelegate<T>, listCallback?: listDelegate<T>): T;
+export {};

package/dist/Model/ModelGraphTraverser.js

@@ -1,99 +1,101 @@
-import { __extends } from "tslib";
-import { RelationType } from './Misc';
-var RecursionState = /** @class */ (function () {
-    function RecursionState() {
-        this.stop = false;
-        this.canRecurse = function (model, property) { return !property.noTrack; };
-    }
-    RecursionState.prototype.pushState = function () {
-    };
-    RecursionState.prototype.popState = function () {
-    };
-    /**
-     * Overwrites the canRecurse callback to always return true.
-     */
-    RecursionState.prototype.includeNonTrackedProperties = function () {
-        this.canRecurse = function (model, property) { return true; };
-        return this;
-    };
-    return RecursionState;
-}());
-export { RecursionState };
-var BooleanRecursionState = /** @class */ (function (_super) {
-    __extends(BooleanRecursionState, _super);
-    function BooleanRecursionState(flag) {
-        if (flag === void 0) { flag = false; }
-        var _this = _super.call(this) || this;
-        _this.flag = flag;
-        return _this;
-    }
-    return BooleanRecursionState;
-}(RecursionState));
-export { BooleanRecursionState };
-export function traverseItems(model, stateOrCallback, callbackOrListCallback, listCallback) {
-    var state;
-    var callback;
-    if (typeof stateOrCallback === "function") {
-        state = new RecursionState();
-        callback = stateOrCallback;
-        listCallback = callbackOrListCallback;
-    }
-    else {
-        state = stateOrCallback;
-        callback = callbackOrListCallback;
-    }
-    if (model instanceof Array) {
-        return invokeOnItemsAndChildren(model, state, callback, listCallback, undefined);
-    }
-    else {
-        return invokeOnSelfAndChildren(model, state, callback, listCallback, undefined);
-    }
-}
-function invokeOnItemsAndChildren(list, state, callback, listCallback, relationType) {
-    for (var _i = 0, list_1 = list; _i < list_1.length; _i++) {
-        var item = list_1[_i];
-        invokeOnSelfAndChildren(item, state, callback, listCallback, relationType);
-        if (state.stop)
-            break;
-    }
-    return state;
-}
-function invokeOnSelfAndChildren(model, state, callback, listCallback, relationType) {
-    callback(model, state, relationType);
-    if (state.stop)
-        return state;
-    var ctor = model.constructor;
-    if (ctor.neo.children) {
-        for (var i = 0; i < ctor.neo.children.length; i++) {
-            var cpi = ctor.neo.children[i];
-            if (state.canRecurse(model, cpi)) {
-                if (cpi.relationType == RelationType.ChildList) {
-                    var childList = model[cpi.propertyName];
-                    if (listCallback)
-                        listCallback(childList, state);
-                    if (state.stop)
-                        return state;
-                    state.pushState();
-                    invokeOnItemsAndChildren(childList, state, callback, listCallback, RelationType.ChildList);
-                    state.popState();
-                    if (state.stop)
-                        return state;
-                }
-                else {
-                    try {
-                        var child = model[cpi.propertyName];
-                        if (child) {
-                            state.pushState();
-                            invokeOnSelfAndChildren(child, state, callback, listCallback, cpi.relationType);
-                            state.popState();
-                        }
-                    }
-                    catch (error) {
-                        throw "Error on property '".concat(cpi.propertyName, "' on type '").concat(model.constructor.name, "': ").concat(error);
-                    }
-                }
-            }
-        }
-    }
-    return state;
-}
+import { __extends } from "tslib";
+import { RelationType } from './Misc';
+var RecursionState = /** @class */ (function () {
+    function RecursionState() {
+        this.stop = false;
+        this.canRecurse = function (model, property) { return !property.noTrack; };
+    }
+    RecursionState.prototype.pushState = function () {
+    };
+    RecursionState.prototype.popState = function () {
+    };
+    /**
+     * Overwrites the canRecurse callback to always return true.
+     */
+    RecursionState.prototype.includeNonTrackedProperties = function () {
+        this.canRecurse = function (model, property) { return true; };
+        return this;
+    };
+    return RecursionState;
+}());
+export { RecursionState };
+var BooleanRecursionState = /** @class */ (function (_super) {
+    __extends(BooleanRecursionState, _super);
+    function BooleanRecursionState(flag) {
+        if (flag === void 0) { flag = false; }
+        var _this = _super.call(this) || this;
+        _this.flag = flag;
+        return _this;
+    }
+    return BooleanRecursionState;
+}(RecursionState));
+export { BooleanRecursionState };
+export function traverseItems(model, stateOrCallback, callbackOrListCallback, listCallback) {
+    var state;
+    var callback;
+    if (typeof stateOrCallback === "function") {
+        state = new RecursionState();
+        callback = stateOrCallback;
+        listCallback = callbackOrListCallback;
+    }
+    else {
+        state = stateOrCallback;
+        callback = callbackOrListCallback;
+    }
+    if (model instanceof Array) {
+        return invokeOnItemsAndChildren(model, state, callback, listCallback, undefined);
+    }
+    else {
+        return invokeOnSelfAndChildren(model, state, callback, listCallback, undefined);
+    }
+}
+function invokeOnItemsAndChildren(list, state, callback, listCallback, relationType) {
+    for (var _i = 0, list_1 = list; _i < list_1.length; _i++) {
+        var item = list_1[_i];
+        invokeOnSelfAndChildren(item, state, callback, listCallback, relationType);
+        if (state.stop)
+            break;
+    }
+    return state;
+}
+function invokeOnSelfAndChildren(model, state, callback, listCallback, relationType) {
+    callback(model, state, relationType);
+    if (state.stop)
+        return state;
+    var ctor = model.constructor;
+    if (ctor.neo.children) {
+        for (var i = 0; i < ctor.neo.children.length; i++) {
+            var cpi = ctor.neo.children[i];
+            if (state.canRecurse(model, cpi)) {
+                if (cpi.relationType == RelationType.ChildList) {
+                    // @ts-ignore
+                    var childList = model[cpi.propertyName];
+                    if (listCallback)
+                        listCallback(childList, state);
+                    if (state.stop)
+                        return state;
+                    state.pushState();
+                    invokeOnItemsAndChildren(childList, state, callback, listCallback, RelationType.ChildList);
+                    state.popState();
+                    if (state.stop)
+                        return state;
+                }
+                else {
+                    try {
+                        // @ts-ignore
+                        var child = model[cpi.propertyName];
+                        if (child) {
+                            state.pushState();
+                            invokeOnSelfAndChildren(child, state, callback, listCallback, cpi.relationType);
+                            state.popState();
+                        }
+                    }
+                    catch (error) {
+                        throw "Error on property '".concat(cpi.propertyName, "' on type '").concat(model.constructor.name, "': ").concat(error);
+                    }
+                }
+            }
+        }
+    }
+    return state;
+}

package/dist/Model/NeoModel.d.ts

@@ -1,6 +1,6 @@
-/** ModelBase decorator
- * Intercepts the construction of objects to call SetupModel.
- */
-export default function NeoModel<T extends {
-    new (...args: any[]): {};
-}>(target: T): T;
+/** ModelBase decorator
+ * Intercepts the construction of objects to call SetupModel.
+ */
+export default function NeoModel<T extends {
+    new (...args: any[]): {};
+}>(target: T): T;

package/dist/Model/NeoModel.js

@@ -1,13 +1,13 @@
-import { ensureTypeInfo } from './NeoTypeInfo';
-/** ModelBase decorator
- * Intercepts the construction of objects to call SetupModel.
- */
-export default function NeoModel(target) {
-    var originalConstructor = target;
-    // Ensure neo info is set
-    var ctor = originalConstructor;
-    // Call this in case no property decorators were added
-    ensureTypeInfo(ctor);
-    var newConstructor = ctor.neo.getOverrideConstructor();
-    return newConstructor;
-}
+import { ensureTypeInfo } from './NeoTypeInfo';
+/** ModelBase decorator
+ * Intercepts the construction of objects to call SetupModel.
+ */
+export default function NeoModel(target) {
+    var originalConstructor = target;
+    // Ensure neo info is set
+    var ctor = originalConstructor;
+    // Call this in case no property decorators were added
+    ensureTypeInfo(ctor);
+    var newConstructor = ctor.neo.getOverrideConstructor();
+    return newConstructor;
+}

package/dist/Model/NeoTypeInfo.d.ts

@@ -1,41 +1,55 @@
-import { Rule } from '../Validation/Rules';
-import { PropertyInstanceMap } from './PropertyInstance';
-import PropertyInfo, { PropertyInfoMap } from './PropertyInfo';
-import { NeoModelConstructor, IModelBase, IMetaItem } from './IModelBase';
-export declare class NeoTypeInfo {
-    private modelCreator;
-    private objectConstructor;
-    private _inheritsBindableBase;
-    private _inheritsModelBase;
-    private _metaItem;
-    properties: PropertyInfo[];
-    propertyMap: PropertyInfoMap;
-    children: PropertyInfo[];
-    parentProperties: PropertyInfo[];
-    parentProperty?: PropertyInfo;
-    objectRules: Rule[];
-    meta: PropertyInstanceMap;
-    displayMember: PropertyInfo | null;
-    get inheritsBindableBase(): boolean;
-    get inheritsModelBase(): boolean;
-    get metaItem(): IMetaItem;
-    initialise(objectConstructor: NeoModelConstructor): void;
-    private addPropertyInfo;
-    getOrAddProperty(propertyName: string): PropertyInfo;
-    addComputed(propertyName: string, descriptor: PropertyDescriptor, isComputed?: boolean): void;
-    addAttributeRule(propertyName: string, rule: Rule): void;
-    /**
-     * 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.
-     * */
-    protected ensureStaticRuntimeInfo(instance?: IModelBase): void;
-    private addRules;
-    /** Copy the property info list from each base type into the current type. */
-    merge(baseConstructor: NeoModelConstructor): void;
-    ensureInitialised(): void;
-    /** Gets the override constructor which can setup a neo model. */
-    getOverrideConstructor(): Function;
-    makeObservable(instance: any): {};
-    private defineProxyProperty;
-}
-export declare function ensureTypeInfo(constructor: NeoModelConstructor): NeoModelConstructor;
+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;
+    private wrapperConstructor?;
+    private _inheritsBindableBase;
+    private _inheritsModelBase;
+    private _metaItem;
+    properties: PropertyInfo[];
+    propertyMap: PropertyInfoMap;
+    methods: Map<string, MethodInfo>;
+    children: PropertyInfo[];
+    parentProperties: PropertyInfo[];
+    parentProperty?: PropertyInfo;
+    objectRules: Rule[];
+    meta: PropertyInstanceMap;
+    displayMember: PropertyInfo | null;
+    get inheritsBindableBase(): boolean;
+    get inheritsModelBase(): boolean;
+    get metaItem(): IMetaItem;
+    initialise(objectConstructor: NeoModelConstructor): void;
+    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.
+     * E.g. Making sure each property has a property info object.
+     * */
+    protected ensureStaticRuntimeInfo(instance?: IModelBase): void;
+    private addRules;
+    /** Copy the property info list from each base type into the current type. */
+    merge(baseConstructor: NeoModelConstructor): void;
+    ensureInitialised(): void;
+    createInstance(...args: any): any;
+    /** Gets the override constructor which can setup a neo model. */
+    getOverrideConstructor(): Function;
+    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;