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

package/dist/Validation/RuleContext.js

@@ -1,130 +1,130 @@
-import { __extends } from "tslib";
-import { RuleSeverity, ValidationState } from './ValidationState';
-import { Utils } from '../Utils';
-export var AsyncStage;
-(function (AsyncStage) {
-    AsyncStage[AsyncStage["None"] = 0] = "None";
-    AsyncStage[AsyncStage["Debounce"] = 1] = "Debounce";
-    AsyncStage[AsyncStage["Busy"] = 2] = "Busy";
-    AsyncStage[AsyncStage["Completing"] = 3] = "Completing";
-})(AsyncStage || (AsyncStage = {}));
-var RuleContextBase = /** @class */ (function (_super) {
-    __extends(RuleContextBase, _super);
-    function RuleContextBase(ruleValidator) {
-        var _this = _super.call(this) || this;
-        _this.ruleValidator = ruleValidator;
-        _this.asyncBusyText = "";
-        _this.errors = [];
-        _this.warnings = [];
-        _this.messages = [];
-        return _this;
-    }
-    RuleContextBase.prototype.addError = function (errorText, forceDisplay) {
-        if (forceDisplay === void 0) { forceDisplay = false; }
-        this.errors.push(errorText);
-        this.severity = RuleSeverity.Error;
-        if (forceDisplay)
-            this.forceDisplaySeverity = RuleSeverity.Error;
-    };
-    RuleContextBase.prototype.addWarning = function (warningText, forceDisplay) {
-        if (forceDisplay === void 0) { forceDisplay = false; }
-        this.warnings.push(warningText);
-        if (this.severity < RuleSeverity.Warning)
-            this.severity = RuleSeverity.Warning;
-        if (forceDisplay && this.forceDisplaySeverity < RuleSeverity.Warning)
-            this.forceDisplaySeverity = RuleSeverity.Warning;
-    };
-    RuleContextBase.prototype.addMessage = function (message, forceDisplay) {
-        if (forceDisplay === void 0) { forceDisplay = false; }
-        this.messages.push(message);
-        if (this.severity < RuleSeverity.Info)
-            this.severity = RuleSeverity.Info;
-        if (forceDisplay && this.forceDisplaySeverity < RuleSeverity.Info)
-            this.forceDisplaySeverity = RuleSeverity.Info;
-    };
-    RuleContextBase.prototype.merge = function (ruleState, includeMessages) {
-        var _a, _b, _c;
-        if (includeMessages) {
-            (_a = this.errors).push.apply(_a, ruleState.errors);
-            (_b = this.warnings).push.apply(_b, ruleState.warnings);
-            (_c = this.messages).push.apply(_c, ruleState.messages);
-        }
-        this.severity = Math.max(this.severity, ruleState.severity);
-        this.forceDisplaySeverity = Math.max(this.forceDisplaySeverity, ruleState.forceDisplaySeverity);
-    };
-    Object.defineProperty(RuleContextBase.prototype, "hasDetail", {
-        get: function () {
-            return this.messages.length > 0 || this.warnings.length > 0 || this.errors.length > 0 || this.asyncBusyText.length > 0;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    return RuleContextBase;
-}(ValidationState));
-export { RuleContextBase };
-var RuleContext = /** @class */ (function (_super) {
-    __extends(RuleContext, _super);
-    function RuleContext() {
-        return _super !== null && _super.apply(this, arguments) || this;
-    }
-    /**
-     * Indicates that this object is validating.
-     * It will not be valid until endAsync is called in the provided callback.
-     * Async / await, or returning a promise can also be used as an alternative to using endAsync.
-     * @param loadingText Text to display until endAsync is called.
-     * @param onReady Callback function where the async action must be called from.
-     * @param options See options properties.
-     */
-    RuleContext.prototype.beginAsync = function (loadingText, onReady, options) {
-        var _this = this;
-        var model = this.ruleValidator.propertyInstance.attachedTo;
-        if (!model.isSuspended && ((options && options.checkWhenClean) || model.meta.isSelfDirty.peek) && this.ruleValidator.asyncStage !== AsyncStage.Completing) {
-            this.asyncBusyText = loadingText;
-            this.ruleValidator.asyncStage = AsyncStage.Debounce;
-            if (this.severity < RuleSeverity.AsyncBusy)
-                this.severity = RuleSeverity.AsyncBusy;
-            if (options && options.forceDisplay && this.forceDisplaySeverity < RuleSeverity.AsyncBusy)
-                this.forceDisplaySeverity = RuleSeverity.AsyncBusy;
-            if (this.ruleValidator.debounce)
-                clearTimeout(this.ruleValidator.debounce);
-            this.ruleValidator.debounce = setTimeout(function () {
-                _this.ruleValidator.asyncContext = _this;
-                _this.ruleValidator.asyncStage = AsyncStage.Busy;
-                var asyncContext = new AsyncRuleContext(_this, _this.ruleValidator);
-                var promise = onReady(asyncContext);
-                if (promise) {
-                    promise.catch(function (e) { return asyncContext.addError("Error: " + e, true); });
-                    promise.finally(function () {
-                        asyncContext.endAsync();
-                    });
-                }
-            }, ((options === null || options === void 0 ? void 0 : options.delayMs) !== undefined ? options.delayMs : 500));
-        }
-    };
-    return RuleContext;
-}(RuleContextBase));
-export { RuleContext };
-var AsyncRuleContext = /** @class */ (function (_super) {
-    __extends(AsyncRuleContext, _super);
-    function AsyncRuleContext(initiator, ruleValidator) {
-        var _this = _super.call(this, ruleValidator) || this;
-        _this.initiator = initiator;
-        return _this;
-    }
-    AsyncRuleContext.prototype.endAsync = function () {
-        var _this = this;
-        if (this.ruleValidator.asyncContext && this.ruleValidator.asyncContext === this.initiator && this.ruleValidator.asyncStage === AsyncStage.Busy) {
-            this.ruleValidator.asyncContext = this;
-            this.ruleValidator.asyncStage = AsyncStage.Completing;
-            // cause observers to refresh 
-            this.ruleValidator.refreshValue += 1;
-            // allow beginAsync to run next time
-            Utils.nextTick(function () {
-                _this.ruleValidator.asyncContext = null;
-                _this.ruleValidator.asyncStage = AsyncStage.None;
-            });
-        }
-    };
-    return AsyncRuleContext;
-}(RuleContextBase));
-export { AsyncRuleContext };
+import { __extends } from "tslib";
+import { RuleSeverity, ValidationState } from './ValidationState';
+import { Utils } from '../Utils';
+export var AsyncStage;
+(function (AsyncStage) {
+    AsyncStage[AsyncStage["None"] = 0] = "None";
+    AsyncStage[AsyncStage["Debounce"] = 1] = "Debounce";
+    AsyncStage[AsyncStage["Busy"] = 2] = "Busy";
+    AsyncStage[AsyncStage["Completing"] = 3] = "Completing";
+})(AsyncStage || (AsyncStage = {}));
+var RuleContextBase = /** @class */ (function (_super) {
+    __extends(RuleContextBase, _super);
+    function RuleContextBase(ruleValidator) {
+        var _this = _super.call(this) || this;
+        _this.ruleValidator = ruleValidator;
+        _this.asyncBusyText = "";
+        _this.errors = [];
+        _this.warnings = [];
+        _this.messages = [];
+        return _this;
+    }
+    RuleContextBase.prototype.addError = function (errorText, forceDisplay) {
+        if (forceDisplay === void 0) { forceDisplay = false; }
+        this.errors.push(errorText);
+        this.severity = RuleSeverity.Error;
+        if (forceDisplay)
+            this.forceDisplaySeverity = RuleSeverity.Error;
+    };
+    RuleContextBase.prototype.addWarning = function (warningText, forceDisplay) {
+        if (forceDisplay === void 0) { forceDisplay = false; }
+        this.warnings.push(warningText);
+        if (this.severity < RuleSeverity.Warning)
+            this.severity = RuleSeverity.Warning;
+        if (forceDisplay && this.forceDisplaySeverity < RuleSeverity.Warning)
+            this.forceDisplaySeverity = RuleSeverity.Warning;
+    };
+    RuleContextBase.prototype.addMessage = function (message, forceDisplay) {
+        if (forceDisplay === void 0) { forceDisplay = false; }
+        this.messages.push(message);
+        if (this.severity < RuleSeverity.Info)
+            this.severity = RuleSeverity.Info;
+        if (forceDisplay && this.forceDisplaySeverity < RuleSeverity.Info)
+            this.forceDisplaySeverity = RuleSeverity.Info;
+    };
+    RuleContextBase.prototype.merge = function (ruleState, includeMessages) {
+        var _a, _b, _c;
+        if (includeMessages) {
+            (_a = this.errors).push.apply(_a, ruleState.errors);
+            (_b = this.warnings).push.apply(_b, ruleState.warnings);
+            (_c = this.messages).push.apply(_c, ruleState.messages);
+        }
+        this.severity = Math.max(this.severity, ruleState.severity);
+        this.forceDisplaySeverity = Math.max(this.forceDisplaySeverity, ruleState.forceDisplaySeverity);
+    };
+    Object.defineProperty(RuleContextBase.prototype, "hasDetail", {
+        get: function () {
+            return this.messages.length > 0 || this.warnings.length > 0 || this.errors.length > 0 || this.asyncBusyText.length > 0;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    return RuleContextBase;
+}(ValidationState));
+export { RuleContextBase };
+var RuleContext = /** @class */ (function (_super) {
+    __extends(RuleContext, _super);
+    function RuleContext() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    /**
+     * Indicates that this object is validating.
+     * It will not be valid until endAsync is called in the provided callback.
+     * Async / await, or returning a promise can also be used as an alternative to using endAsync.
+     * @param loadingText Text to display until endAsync is called.
+     * @param onReady Callback function where the async action must be called from.
+     * @param options See options properties.
+     */
+    RuleContext.prototype.beginAsync = function (loadingText, onReady, options) {
+        var _this = this;
+        var model = this.ruleValidator.propertyInstance.attachedTo;
+        if (!model.isSuspended && ((options && options.checkWhenClean) || model.meta.isSelfDirty.peek) && this.ruleValidator.asyncStage !== AsyncStage.Completing) {
+            this.asyncBusyText = loadingText;
+            this.ruleValidator.asyncStage = AsyncStage.Debounce;
+            if (this.severity < RuleSeverity.AsyncBusy)
+                this.severity = RuleSeverity.AsyncBusy;
+            if (options && options.forceDisplay && this.forceDisplaySeverity < RuleSeverity.AsyncBusy)
+                this.forceDisplaySeverity = RuleSeverity.AsyncBusy;
+            if (this.ruleValidator.debounce)
+                clearTimeout(this.ruleValidator.debounce);
+            this.ruleValidator.debounce = setTimeout(function () {
+                _this.ruleValidator.asyncContext = _this;
+                _this.ruleValidator.asyncStage = AsyncStage.Busy;
+                var asyncContext = new AsyncRuleContext(_this, _this.ruleValidator);
+                var promise = onReady(asyncContext);
+                if (promise) {
+                    promise.catch(function (e) { return asyncContext.addError("Error: " + e, true); });
+                    promise.finally(function () {
+                        asyncContext.endAsync();
+                    });
+                }
+            }, ((options === null || options === void 0 ? void 0 : options.delayMs) !== undefined ? options.delayMs : 500));
+        }
+    };
+    return RuleContext;
+}(RuleContextBase));
+export { RuleContext };
+var AsyncRuleContext = /** @class */ (function (_super) {
+    __extends(AsyncRuleContext, _super);
+    function AsyncRuleContext(initiator, ruleValidator) {
+        var _this = _super.call(this, ruleValidator) || this;
+        _this.initiator = initiator;
+        return _this;
+    }
+    AsyncRuleContext.prototype.endAsync = function () {
+        var _this = this;
+        if (this.ruleValidator.asyncContext && this.ruleValidator.asyncContext === this.initiator && this.ruleValidator.asyncStage === AsyncStage.Busy) {
+            this.ruleValidator.asyncContext = this;
+            this.ruleValidator.asyncStage = AsyncStage.Completing;
+            // cause observers to refresh 
+            this.ruleValidator.refreshValue += 1;
+            // allow beginAsync to run next time
+            Utils.nextTick(function () {
+                _this.ruleValidator.asyncContext = null;
+                _this.ruleValidator.asyncStage = AsyncStage.None;
+            });
+        }
+    };
+    return AsyncRuleContext;
+}(RuleContextBase));
+export { AsyncRuleContext };

package/dist/Validation/Rules.d.ts

@@ -1,70 +1,70 @@
-import { RuleContext } from './RuleContext';
-import { IPropertyInstance } from '../Model/PropertyInstance';
-import { IModelBase } from '../Model/IModelBase';
-import PropertyInfo, { TransformStaticMetaType } from '../Model/PropertyInfo';
-import { RuleSeverity } from './ValidationState';
-export declare type PropertyInfoCallback<T> = (type: TransformStaticMetaType<T>) => (PropertyInfo | PropertyInfo[]);
-export declare type RuleExpression<T extends IModelBase> = (model: T) => boolean;
-export declare type ErrorExpression<T extends IModelBase> = (model: T) => string;
-export interface IRule {
-    ruleId: string;
-}
-export declare abstract class Rule implements IRule {
-    ruleId: string;
-    abstract checkRule(propertyInstance: IPropertyInstance, context: RuleContext): void;
-}
-export declare class RequiredRule extends Rule {
-    errorText: string;
-    allowZero: boolean;
-    constructor(errorText: string, allowZero?: boolean);
-    checkRule(propertyInstance: IPropertyInstance, context: RuleContext): void;
-}
-export declare class StringLengthRule extends Rule {
-    private maxLength;
-    private minLength?;
-    errorText?: string | undefined;
-    constructor(maxLength: number, minLength?: number | undefined, errorText?: string | undefined);
-    checkRule(propertyInstance: IPropertyInstance, context: RuleContext): void;
-}
-export declare class EmailAddressRule extends Rule {
-    errorText: string;
-    constructor(errorText: string);
-    checkRule(propertyInstance: IPropertyInstance, context: RuleContext): void;
-}
-export declare class RegExpRule extends Rule {
-    expression: RegExp;
-    errorText: string;
-    constructor(expression: RegExp, errorText: string);
-    checkRule(propertyInstance: IPropertyInstance, context: RuleContext): void;
-}
-export interface ICustomRule<T extends IModelBase> extends IRule {
-    /**
-     * Used to specify on which properties the rule should display. Return a property instance for 1 property, or an array for multiple.
-     */
-    onProperties(properties: PropertyInfoCallback<T>): IRule;
-}
-export interface IExpressionRule<T extends IModelBase> extends ICustomRule<T> {
-    /**
-     * Specifies that the rule should not be displayed on any properties, only in the object summary.
-     */
-    onModel(): IRule;
-}
-export declare abstract class CustomRule<T extends IModelBase> extends Rule implements IExpressionRule<T> {
-    private onPropertiesCallback?;
-    onProperties(properties: PropertyInfoCallback<T>): this;
-    onModel(): this;
-    getDisplayProperties(type: TransformStaticMetaType<T>): PropertyInfo[] | undefined;
-}
-export declare class CallbackRule<T extends IModelBase> extends CustomRule<T> {
-    private validateFn;
-    hasBoundFunction: boolean;
-    constructor(validateFn: (context: RuleContext) => void);
-    checkRule(propertyInstance: IPropertyInstance, context: RuleContext): void;
-}
-export declare class ExpressionRule<T extends IModelBase> extends CustomRule<T> {
-    private failExpression;
-    private error;
-    private severity?;
-    constructor(failExpression: RuleExpression<T>, error: ErrorExpression<T> | string, severity?: RuleSeverity | undefined);
-    checkRule(propertyInstance: IPropertyInstance, context: RuleContext): void;
-}
+import { RuleContext } from './RuleContext';
+import { IPropertyInstance } from '../Model/PropertyInstance';
+import { IModelBase } from '../Model/IModelBase';
+import PropertyInfo, { TransformStaticMetaType } from '../Model/PropertyInfo';
+import { RuleSeverity } from './ValidationState';
+export type PropertyInfoCallback<T> = (type: TransformStaticMetaType<T>) => (PropertyInfo | PropertyInfo[]);
+export type RuleExpression<T extends IModelBase> = (model: T) => boolean;
+export type ErrorExpression<T extends IModelBase> = (model: T) => string;
+export interface IRule {
+    ruleId: string;
+}
+export declare abstract class Rule implements IRule {
+    ruleId: string;
+    abstract checkRule(propertyInstance: IPropertyInstance, context: RuleContext): void;
+}
+export declare class RequiredRule extends Rule {
+    errorText: string;
+    allowZero: boolean;
+    constructor(errorText: string, allowZero?: boolean);
+    checkRule(propertyInstance: IPropertyInstance, context: RuleContext): void;
+}
+export declare class StringLengthRule extends Rule {
+    private maxLength;
+    private minLength?;
+    errorText?: string | undefined;
+    constructor(maxLength: number, minLength?: number | undefined, errorText?: string | undefined);
+    checkRule(propertyInstance: IPropertyInstance, context: RuleContext): void;
+}
+export declare class EmailAddressRule extends Rule {
+    errorText: string;
+    constructor(errorText: string);
+    checkRule(propertyInstance: IPropertyInstance, context: RuleContext): void;
+}
+export declare class RegExpRule extends Rule {
+    expression: RegExp;
+    errorText: string;
+    constructor(expression: RegExp, errorText: string);
+    checkRule(propertyInstance: IPropertyInstance, context: RuleContext): void;
+}
+export interface ICustomRule<T extends IModelBase> extends IRule {
+    /**
+     * Used to specify on which properties the rule should display. Return a property instance for 1 property, or an array for multiple.
+     */
+    onProperties(properties: PropertyInfoCallback<T>): IRule;
+}
+export interface IExpressionRule<T extends IModelBase> extends ICustomRule<T> {
+    /**
+     * Specifies that the rule should not be displayed on any properties, only in the object summary.
+     */
+    onModel(): IRule;
+}
+export declare abstract class CustomRule<T extends IModelBase> extends Rule implements IExpressionRule<T> {
+    private onPropertiesCallback?;
+    onProperties(properties: PropertyInfoCallback<T>): this;
+    onModel(): this;
+    getDisplayProperties(type: TransformStaticMetaType<T>): PropertyInfo[] | undefined;
+}
+export declare class CallbackRule<T extends IModelBase> extends CustomRule<T> {
+    private validateFn;
+    hasBoundFunction: boolean;
+    constructor(validateFn: (context: RuleContext) => void);
+    checkRule(propertyInstance: IPropertyInstance, context: RuleContext): void;
+}
+export declare class ExpressionRule<T extends IModelBase> extends CustomRule<T> {
+    private failExpression;
+    private error;
+    private severity?;
+    constructor(failExpression: RuleExpression<T>, error: ErrorExpression<T> | string, severity?: RuleSeverity | undefined);
+    checkRule(propertyInstance: IPropertyInstance, context: RuleContext): void;
+}