@singularsystems/neo-core 1.0.3 → 1.0.5

package/dist/Model/IModelBase.d.ts

@@ -46,6 +46,9 @@ export type PartialPlainNonTrackedObject<T> = PartialPlainObject<T> & {
 export interface NeoModelConstructor extends Function {
     neo: NeoTypeInfo;
 }
+export interface NeoModelConstructorInternal extends Function {
+    addBusinessRules?(validationRules: ValidationRules<IModelBase>): void;
+}
 export interface IMakeBindableOptions {
     /**
      * Specifies whether properties should be observable

package/dist/Model/ModelBase.d.ts

@@ -79,10 +79,15 @@ export default abstract class ModelBase extends BindableBase implements IModelBa
      * @param shouldSerialise The value determined by the serialiser.
      */
     protected canSerialise(shouldSerialise: boolean): boolean;
+    /** @deprecated Make your addBusinessRules method `static`. E.g.
+     * ```
+     * protected static addBusinessRules(rules: ValidationRules<MyType>) {
+     * ```  */
+    protected addBusinessRules(validationRules: ValidationRules<this>): void;
     /**
-     * Add custom business rules. Note, this will be called once per type and should be treated as static.
+     * Add custom business rules for this type.
      */
-    protected addBusinessRules(validationRules: ValidationRules<this>): void;
+    protected static addBusinessRules(rules: ValidationRules<ModelBase>): void;
     /** The server side type name used to find this type. Include the namespace if there is more than one type with the same name. */
     static typeName: string | null;
 }

package/dist/Model/ModelBase.js

@@ -142,10 +142,16 @@ var ModelBase = /** @class */ (function (_super) {
     ModelBase.prototype.canSerialise = function (shouldSerialise) {
         return shouldSerialise;
     };
+    /** @deprecated Make your addBusinessRules method `static`. E.g.
+     * ```
+     * protected static addBusinessRules(rules: ValidationRules<MyType>) {
+     * ```  */
+    ModelBase.prototype.addBusinessRules = function (validationRules) {
+    };
     /**
-     * Add custom business rules. Note, this will be called once per type and should be treated as static.
+     * Add custom business rules for this type.
      */
-    ModelBase.prototype.addBusinessRules = function (validationRules) {
+    ModelBase.addBusinessRules = function (rules) {
     };
     /** The server side type name used to find this type. Include the namespace if there is more than one type with the same name. */
     ModelBase.typeName = null;

package/dist/Model/ModelGraphTraverser.d.ts

@@ -4,12 +4,15 @@ import PropertyInfo from './PropertyInfo';
 export declare class RecursionState {
     stop: boolean;
     canRecurse: (model: IModelBase, property: PropertyInfo) => boolean;
+    canRecurseType(item: any): boolean;
     pushState(): void;
     popState(): void;
     /**
      * Overwrites the canRecurse callback to always return true.
      */
     includeNonTrackedProperties(): this;
+    /** Child objects / lists of any type will be included. By default only types extending ModelBase are included. */
+    includeNonModelBaseTypes(): this;
 }
 export declare class BooleanRecursionState extends RecursionState {
     flag: boolean;

package/dist/Model/ModelGraphTraverser.js

@@ -1,10 +1,14 @@
 import { __extends } from "tslib";
 import { RelationType } from './Misc';
+import ModelBase from "./ModelBase";
 var RecursionState = /** @class */ (function () {
     function RecursionState() {
         this.stop = false;
         this.canRecurse = function (model, property) { return !property.noTrack; };
     }
+    RecursionState.prototype.canRecurseType = function (item) {
+        return item instanceof ModelBase;
+    };
     RecursionState.prototype.pushState = function () {
     };
     RecursionState.prototype.popState = function () {
@@ -16,6 +20,11 @@ var RecursionState = /** @class */ (function () {
         this.canRecurse = function (model, property) { return true; };
         return this;
     };
+    /** Child objects / lists of any type will be included. By default only types extending ModelBase are included. */
+    RecursionState.prototype.includeNonModelBaseTypes = function () {
+        this.canRecurseType = function () { return true; };
+        return this;
+    };
     return RecursionState;
 }());
 export { RecursionState };
@@ -67,32 +76,34 @@ function invokeOnSelfAndChildren(model, state, callback, listCallback, relationT
         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 {
+                try {
+                    if (cpi.relationType == RelationType.ChildList) {
+                        // @ts-ignore
+                        var childList = model[cpi.propertyName];
+                        if (listCallback)
+                            listCallback(childList, state);
+                        if (state.stop)
+                            return state;
+                        if (childList.length && state.canRecurseType(childList[0])) {
+                            state.pushState();
+                            invokeOnItemsAndChildren(childList, state, callback, listCallback, RelationType.ChildList);
+                            state.popState();
+                            if (state.stop)
+                                return state;
+                        }
+                    }
+                    else {
                         // @ts-ignore
                         var child = model[cpi.propertyName];
-                        if (child) {
+                        if (child && state.canRecurseType(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);
-                    }
+                }
+                catch (error) {
+                    throw "Error on property '".concat(cpi.propertyName, "' on type '").concat(model.constructor.name, "': ").concat(error, ".");
                 }
             }
         }

package/dist/Model/NeoTypeInfo.js

@@ -125,22 +125,24 @@ var NeoTypeInfo = /** @class */ (function () {
         }
     };
     NeoTypeInfo.prototype.addRules = function (instance) {
-        if (instance.addBusinessRules !== undefined) {
+        var _a;
+        var addRulesMethod = (_a = this.objectConstructor.addBusinessRules) !== null && _a !== void 0 ? _a : instance.addBusinessRules;
+        if (addRulesMethod !== 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."));
+            addRulesMethod(validationRules);
+            if (validationRules.rules.some(function (c) { return c instanceof CallbackRule && c.hasArrowFunction; })) {
+                console.error("Warning: ".concat(this.objectConstructor.name, " has rules which have been added using an arrow function."));
             }
             var modelProxy = new ModelProxy(instance);
-            for (var _i = 0, _a = validationRules.rules; _i < _a.length; _i++) {
-                var rule = _a[_i];
+            for (var _i = 0, _b = validationRules.rules; _i < _b.length; _i++) {
+                var rule = _b[_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];
+                    for (var _c = 0, properties_1 = properties; _c < properties_1.length; _c++) {
+                        var property = properties_1[_c];
                         property.rules.push(rule);
                     }
                 }

package/dist/Security/IAuthenticationService.d.ts

@@ -26,8 +26,6 @@ export default interface IAuthenticationService {
     tryCompleteSignIn(): Promise<ISignInResult>;
     signinSilent(): Promise<any>;
     endSignInSilent(): Promise<any>;
-    /** Clears the user locally */
-    signOutLocal(): void;
     beginSignOut(): void;
     endSignOut(): Promise<any>;
     /** Returns true if there is a user, and the token has not expired */

package/dist/Security/Oidc/OidcAuthService.d.ts

@@ -11,6 +11,7 @@ export default abstract class OidcAuthService<TUser extends OidcUser = OidcUser>
     protected userManager: IUserManager;
     private axios;
     private _user;
+    private isRedirecting;
     private afterUserLoadedPromise;
     /**
      * Creates an Oidc auth service
@@ -18,6 +19,7 @@ export default abstract class OidcAuthService<TUser extends OidcUser = OidcUser>
      * @param user User which existed in storage at startup
      */
     constructor(userManager: IUserManager, axios: AxiosInstance);
+    isSigningOut: boolean;
     loadUserFromToken(): Promise<TUser | null>;
     loadUserFromSession(): Promise<TUser | null>;
     ensureSignedIn(redirectLocal?: string): boolean;
@@ -45,7 +47,7 @@ export default abstract class OidcAuthService<TUser extends OidcUser = OidcUser>
     signinSilent(): Promise<IOidcUser | null>;
     beginSignOut(): void;
     endSignOut(): Promise<any>;
-    signOutLocal(): void;
+    private signOutLocal;
     get user(): TUser | null;
     get isAuthenticated(): boolean;
     static createIdentityServerMetadata(identityServerUrl: string): {

package/dist/Security/Oidc/OidcAuthService.js

@@ -18,6 +18,8 @@ var OidcAuthService = /** @class */ (function () {
         this.userManager = userManager;
         this.axios = axios;
         this._user = null;
+        this.isRedirecting = false;
+        this.isSigningOut = false;
         this.userManager = userManager;
         this.userManager.events.addUserLoaded(this.onUserLoaded.bind(this));
         this.userManager.events.addUserUnloaded(this.onUserUnloaded.bind(this));
@@ -64,7 +66,11 @@ var OidcAuthService = /** @class */ (function () {
      * @param redirectPath Local path to redirect to once login is complete.
      */
     OidcAuthService.prototype.beginSignIn = function (redirectPath) {
-        return this.userManager.signinRedirect({ state: redirectPath });
+        if (!this.isRedirecting) {
+            this.isRedirecting = true;
+            return this.userManager.signinRedirect({ state: redirectPath });
+        }
+        return Promise.resolve();
     };
     ;
     /**
@@ -77,6 +83,7 @@ var OidcAuthService = /** @class */ (function () {
                 switch (_a.label) {
                     case 0:
                         _a.trys.push([0, 2, , 3]);
+                        this.isRedirecting = false;
                         return [4 /*yield*/, this.userManager.signinRedirectCallback()];
                     case 1:
                         user = _a.sent();
@@ -168,14 +175,20 @@ var OidcAuthService = /** @class */ (function () {
         return this.userManager.signinSilent();
     };
     OidcAuthService.prototype.beginSignOut = function () {
-        if (this._user) {
-            this.userManager.signoutRedirect({ id_token_hint: this._user.userData.id_token });
-            this.signOutLocal();
+        if (!this.isRedirecting) {
+            if (this._user) {
+                this.isRedirecting = true;
+                this.isSigningOut = true;
+                this.userManager.signoutRedirect({ id_token_hint: this._user.userData.id_token });
+                this.signOutLocal();
+            }
+            this.userManager.clearStaleState();
         }
-        this.userManager.clearStaleState();
     };
     ;
     OidcAuthService.prototype.endSignOut = function () {
+        this.isRedirecting = false;
+        this.isSigningOut = false;
         return this.userManager.signoutRedirectCallback();
     };
     ;

package/dist/Settings.d.ts

@@ -75,6 +75,7 @@ export declare const Settings: {
         /** Global allowed extensions. Can be changed on each file upload manager. Must be lower case. */
         allowedExtensions: string[];
         fileEditorButton: IButtonOptions;
+        browseButton: IButtonOptions;
     };
     progressBar: {
         /** True if you want the animation to be reversed globally. */

package/dist/Settings.js

@@ -106,7 +106,8 @@ export var Settings = {
         disallowedFileExtensions: [".exe", ".bat", ".cmd", ".sh", ".com", ".ps", ".ps1", ".dll"],
         /** Global allowed extensions. Can be changed on each file upload manager. Must be lower case. */
         allowedExtensions: [],
-        fileEditorButton: { variant: "dark" }
+        fileEditorButton: { variant: "dark" },
+        browseButton: { variant: "light" },
     },
     progressBar: {
         /** True if you want the animation to be reversed globally. */

package/dist/Validation/Rules.d.ts

@@ -57,7 +57,7 @@ export declare abstract class CustomRule<T extends IModelBase> extends Rule impl
 }
 export declare class CallbackRule<T extends IModelBase> extends CustomRule<T> {
     private validateFn;
-    hasBoundFunction: boolean;
+    hasArrowFunction: boolean;
     constructor(validateFn: (context: RuleContext) => void);
     checkRule(propertyInstance: IPropertyInstance, context: RuleContext): void;
 }

package/dist/Validation/Rules.js

@@ -125,14 +125,14 @@ var CallbackRule = /** @class */ (function (_super) {
     function CallbackRule(validateFn) {
         var _this = _super.call(this) || this;
         _this.validateFn = validateFn;
-        _this.hasBoundFunction = false;
-        if (!validateFn.hasOwnProperty("prototype")) {
-            _this.hasBoundFunction = true;
+        _this.hasArrowFunction = false;
+        if (!validateFn.hasOwnProperty("prototype") && !validateFn.name) {
+            _this.hasArrowFunction = true;
         }
         return _this;
     }
     CallbackRule.prototype.checkRule = function (propertyInstance, context) {
-        if (this.hasBoundFunction) {
+        if (this.hasArrowFunction) {
             var reboundFn = this.validateFn.bind(propertyInstance.attachedTo);
             reboundFn(context);
         }

package/dist/Validation/ValidationRules.d.ts

@@ -5,10 +5,12 @@ export declare class ValidationRules<T extends IModelBase> {
     rules: CustomRule<T>[];
     /**
      * Registers a custom rule.
-     * NOTE: Do not use an arrow function: add(context => {}), either pass in the address of a function: add(this.myRule), or pass an anonymous function: add(function(context) {}).
-     * @param ruleFunction
+     * - Pass in the address of a function: `add(MyType.prototype.myRule)`
+     * - or pass an anonymous function: `add(function(context) {})`
+     *
+     * **NOTE: Do not use `.bind(this)`, and do not use an arrow function**.
      */
-    add(ruleFunction: (context: IRuleContext) => void): ICustomRule<T>;
+    add(ruleFunction: (this: T, context: IRuleContext) => void): ICustomRule<T>;
     failWhen(failCondition: RuleExpression<T>, errorTextExpression: ErrorExpression<T>): IExpressionRule<T>;
     failWhen(failCondition: RuleExpression<T>, errorText: string): IExpressionRule<T>;
     warnWhen(condition: RuleExpression<T>, warningTextExpression: ErrorExpression<T>): IExpressionRule<T>;

package/dist/Validation/ValidationRules.js

@@ -6,8 +6,10 @@ var ValidationRules = /** @class */ (function () {
     }
     /**
      * Registers a custom rule.
-     * NOTE: Do not use an arrow function: add(context => {}), either pass in the address of a function: add(this.myRule), or pass an anonymous function: add(function(context) {}).
-     * @param ruleFunction
+     * - Pass in the address of a function: `add(MyType.prototype.myRule)`
+     * - or pass an anonymous function: `add(function(context) {})`
+     *
+     * **NOTE: Do not use `.bind(this)`, and do not use an arrow function**.
      */
     ValidationRules.prototype.add = function (ruleFunction) {
         var rule = new CallbackRule(ruleFunction);

package/package.json

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