Have added display name methods too

dist/amd/builders/reactive-validation-group-builder.js

@@ -0,0 +1,43 @@
+define(["require", "exports", "../validation-groups/reactive-validation-group", "../factories/model-watcher-factory", "../factories/model-resolver-factory"], function (require, exports, reactive_validation_group_1, model_watcher_factory_1, model_resolver_factory_1) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    var ReactiveValidationGroupBuilder = (function () {
+        function ReactiveValidationGroupBuilder(fieldErrorProcessor, ruleResolver) {
+            var _this = this;
+            this.fieldErrorProcessor = fieldErrorProcessor;
+            this.ruleResolver = ruleResolver;
+            this.create = function () {
+                _this.refreshRate = 500;
+                _this.validateOnStart = false;
+                _this.modelWatcherFactory = new model_watcher_factory_1.ModelWatcherFactory();
+                _this.modelResolverFactory = new model_resolver_factory_1.ModelResolverFactory();
+                return _this;
+            };
+            this.withRefreshRate = function (refreshRate) {
+                _this.refreshRate = refreshRate;
+                return _this;
+            };
+            this.withModelResolverFactory = function (modelResolverFactory) {
+                _this.modelResolverFactory = modelResolverFactory;
+                return _this;
+            };
+            this.withModelWatcherFactory = function (modelWatcherFactory) {
+                _this.modelWatcherFactory = modelWatcherFactory;
+                return _this;
+            };
+            this.andValidateOnStart = function () {
+                _this.validateOnStart = true;
+                return _this;
+            };
+            this.build = function (model, ruleset) {
+                var validationGroup = new reactive_validation_group_1.ReactiveValidationGroup(_this.fieldErrorProcessor, _this.ruleResolver, _this.modelResolverFactory, _this.modelWatcherFactory, model, ruleset, _this.refreshRate);
+                if (_this.validateOnStart) {
+                    validationGroup.validate();
+                }
+                return validationGroup;
+            };
+        }
+        return ReactiveValidationGroupBuilder;
+    }());
+    exports.ReactiveValidationGroupBuilder = ReactiveValidationGroupBuilder;
+});

dist/amd/builders/ruleset-builder.js

@@ -0,0 +1,98 @@
+define(["require", "exports", "../rulesets/ruleset", "../rulesets/rule-link", "../rulesets/for-each-rule", "../helpers/type-helper", "../rules/composite/dynamic-composite-validation-rule"], function (require, exports, ruleset_1, rule_link_1, for_each_rule_1, type_helper_1, dynamic_composite_validation_rule_1) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    var RulesetBuilder = (function () {
+        function RulesetBuilder(ruleRegistry) {
+            var _this = this;
+            this.ruleRegistry = ruleRegistry;
+            this.verifyExistingProperty = function () {
+                if (!_this.currentProperty) {
+                    throw new Error("A property must precede any rule calls in the chain");
+                }
+            };
+            this.verifyRuleNameIsValid = function (rule) {
+                if (rule == null || typeof (rule) == "undefined" || rule.length == 0) {
+                    throw new Error("A rule name is required");
+                }
+                if (_this.ruleRegistry && !_this.ruleRegistry.hasRuleNamed(rule)) {
+                    throw new Error("The rule [" + rule + "] has not been registered");
+                }
+            };
+            this.create = function () {
+                _this.internalRuleset = new ruleset_1.Ruleset();
+                _this.currentProperty = null;
+                return _this;
+            };
+            this.forProperty = function (propertyNameOrPredicate) {
+                var endProperty = propertyNameOrPredicate;
+                if (type_helper_1.TypeHelper.isFunctionType(endProperty)) {
+                    endProperty = _this.extractPropertyName(propertyNameOrPredicate);
+                    if (!endProperty) {
+                        throw new Error("cannot resolve property from: " + propertyNameOrPredicate);
+                    }
+                }
+                _this.currentProperty = endProperty;
+                _this.currentRule = null;
+                return _this;
+            };
+            this.addRule = function (rule, ruleOptions) {
+                _this.verifyRuleNameIsValid(rule);
+                _this.verifyExistingProperty();
+                _this.internalRuleset.addRule(_this.currentProperty, _this.currentRule = new rule_link_1.RuleLink(rule, ruleOptions));
+                return _this;
+            };
+            this.addCompositeRule = function (compositeRule) {
+                _this.internalRuleset.compositeRules[compositeRule.propertyName] = compositeRule;
+                return _this;
+            };
+            this.withDisplayName = function (displayName) {
+                _this.verifyExistingProperty();
+                _this.internalRuleset.propertyDisplayNames[_this.currentProperty] = displayName;
+                return _this;
+            };
+            this.addDynamicRule = function (propertyName, validate, getMessage) {
+                var compositeRule = new dynamic_composite_validation_rule_1.DynamicCompositeValidationRule(propertyName, validate, getMessage);
+                _this.internalRuleset.compositeRules[propertyName] = compositeRule;
+                return _this;
+            };
+            this.withMessage = function (messageOverride) {
+                _this.verifyExistingProperty();
+                _this.currentRule.messageOverride = messageOverride;
+                return _this;
+            };
+            this.appliesIf = function (appliesFunction) {
+                _this.verifyExistingProperty();
+                _this.currentRule.appliesIf = appliesFunction;
+                return _this;
+            };
+            this.addRuleForEach = function (rule, ruleOptions) {
+                _this.verifyRuleNameIsValid(rule);
+                _this.verifyExistingProperty();
+                var ruleLink = new rule_link_1.RuleLink(rule, ruleOptions);
+                _this.currentRule = ruleLink;
+                _this.internalRuleset.addRule(_this.currentProperty, new for_each_rule_1.ForEachRule(ruleLink));
+                return _this;
+            };
+            this.addRuleset = function (ruleset) {
+                _this.verifyExistingProperty();
+                _this.internalRuleset.addRuleset(_this.currentProperty, ruleset);
+                return _this;
+            };
+            this.addRulesetForEach = function (ruleset) {
+                _this.verifyExistingProperty();
+                _this.internalRuleset.addRuleset(_this.currentProperty, new for_each_rule_1.ForEachRule(ruleset));
+                return _this;
+            };
+            this.build = function () {
+                return _this.internalRuleset;
+            };
+        }
+        RulesetBuilder.prototype.extractPropertyName = function (predicate) {
+            var regex = /.*\.([\w]*);/;
+            var predicateString = predicate.toString();
+            return regex.exec(predicateString)[1];
+        };
+        return RulesetBuilder;
+    }());
+    exports.RulesetBuilder = RulesetBuilder;
+});

dist/amd/builders/validation-group-builder.js

@@ -0,0 +1,39 @@
+define(["require", "exports", "../validation-groups/validation-group", "./reactive-validation-group-builder", "../factories/model-resolver-factory"], function (require, exports, validation_group_1, reactive_validation_group_builder_1, model_resolver_factory_1) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    var ValidationGroupBuilder = (function () {
+        function ValidationGroupBuilder(fieldErrorProcessor, ruleResolver) {
+            var _this = this;
+            this.fieldErrorProcessor = fieldErrorProcessor;
+            this.ruleResolver = ruleResolver;
+            this.create = function () {
+                _this.modelResolverFactory = new model_resolver_factory_1.ModelResolverFactory();
+                _this.validateOnStart = false;
+                return _this;
+            };
+            this.asReactiveGroup = function () {
+                var reactiveBuilder = new reactive_validation_group_builder_1.ReactiveValidationGroupBuilder(_this.fieldErrorProcessor, _this.ruleResolver)
+                    .create()
+                    .withModelResolverFactory(_this.modelResolverFactory);
+                return reactiveBuilder;
+            };
+            this.withModelResolverFactory = function (modelResolverFactory) {
+                _this.modelResolverFactory = modelResolverFactory;
+                return _this;
+            };
+            this.andValidateOnStart = function () {
+                _this.validateOnStart = true;
+                return _this;
+            };
+            this.build = function (model, ruleset) {
+                var validationGroup = new validation_group_1.ValidationGroup(_this.fieldErrorProcessor, _this.ruleResolver, _this.modelResolverFactory, model, ruleset);
+                if (_this.validateOnStart) {
+                    validationGroup.validate();
+                }
+                return validationGroup;
+            };
+        }
+        return ValidationGroupBuilder;
+    }());
+    exports.ValidationGroupBuilder = ValidationGroupBuilder;
+});

dist/amd/events/model-state-changed-event.js

@@ -0,0 +1,11 @@
+define(["require", "exports"], function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    var ModelStateChangedEvent = (function () {
+        function ModelStateChangedEvent(isValid) {
+            this.isValid = isValid;
+        }
+        return ModelStateChangedEvent;
+    }());
+    exports.ModelStateChangedEvent = ModelStateChangedEvent;
+});

dist/amd/events/property-changed-event.js

@@ -0,0 +1,13 @@
+define(["require", "exports"], function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    var PropertyChangedEvent = (function () {
+        function PropertyChangedEvent(propertyPath, newValue, oldValue) {
+            this.propertyPath = propertyPath;
+            this.newValue = newValue;
+            this.oldValue = oldValue;
+        }
+        return PropertyChangedEvent;
+    }());
+    exports.PropertyChangedEvent = PropertyChangedEvent;
+});

dist/amd/events/property-state-changed-event.js

@@ -0,0 +1,13 @@
+define(["require", "exports"], function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    var PropertyStateChangedEvent = (function () {
+        function PropertyStateChangedEvent(property, isValid, error) {
+            this.property = property;
+            this.isValid = isValid;
+            this.error = error;
+        }
+        return PropertyStateChangedEvent;
+    }());
+    exports.PropertyStateChangedEvent = PropertyStateChangedEvent;
+});

dist/amd/exposer.js

@@ -0,0 +1,16 @@
+define(["require", "exports", "./processors/field-error-processor", "./rulesets/rule-resolver", "./builders/validation-group-builder", "./rule-registry-setup", "./builders/ruleset-builder"], function (require, exports, field_error_processor_1, rule_resolver_1, validation_group_builder_1, rule_registry_setup_1, ruleset_builder_1) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    var fieldErrorProcessor = new field_error_processor_1.FieldErrorProcessor(rule_registry_setup_1.ruleRegistry);
+    var ruleResolver = new rule_resolver_1.RuleResolver();
+    function createRuleset(withRuleVerification) {
+        if (withRuleVerification === void 0) { withRuleVerification = false; }
+        var rulesetBuilder = withRuleVerification ? new ruleset_builder_1.RulesetBuilder(rule_registry_setup_1.ruleRegistry) : new ruleset_builder_1.RulesetBuilder();
+        return rulesetBuilder.create();
+    }
+    exports.createRuleset = createRuleset;
+    function createGroup() {
+        return new validation_group_builder_1.ValidationGroupBuilder(fieldErrorProcessor, ruleResolver).create();
+    }
+    exports.createGroup = createGroup;
+});

dist/amd/factories/imodel-resolver-factory.js

@@ -0,0 +1,4 @@
+define(["require", "exports"], function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+});

dist/amd/factories/imodel-watcher-factory.js

@@ -0,0 +1,4 @@
+define(["require", "exports"], function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+});

dist/amd/factories/model-resolver-factory.js

@@ -0,0 +1,16 @@
+define(["require", "exports", "../resolvers/model-resolver", "property-resolver"], function (require, exports, model_resolver_1, property_resolver_1) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    var ModelResolverFactory = (function () {
+        function ModelResolverFactory(propertyResolver) {
+            if (propertyResolver === void 0) { propertyResolver = new property_resolver_1.PropertyResolver(); }
+            var _this = this;
+            this.propertyResolver = propertyResolver;
+            this.createModelResolver = function (model) {
+                return new model_resolver_1.ModelResolver(_this.propertyResolver, model);
+            };
+        }
+        return ModelResolverFactory;
+    }());
+    exports.ModelResolverFactory = ModelResolverFactory;
+});

dist/amd/factories/model-watcher-factory.js

@@ -0,0 +1,13 @@
+define(["require", "exports", "../watcher/model-watcher"], function (require, exports, model_watcher_1) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    var ModelWatcherFactory = (function () {
+        function ModelWatcherFactory() {
+            this.createModelWatcher = function () {
+                return new model_watcher_1.ModelWatcher();
+            };
+        }
+        return ModelWatcherFactory;
+    }());
+    exports.ModelWatcherFactory = ModelWatcherFactory;
+});

dist/amd/helpers/comparer-helper.js

@@ -0,0 +1,17 @@
+define(["require", "exports"], function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    var ComparerHelper = (function () {
+        function ComparerHelper() {
+        }
+        ComparerHelper.simpleTypeComparer = function (value1, value2, isWeak) {
+            if (isWeak) {
+                return (value1 == value2);
+            }
+            return (value1 === value2);
+        };
+        ComparerHelper.dateTimeCompararer = function (value1, value2) { return (value1.getTime() == value2.getTime()); };
+        return ComparerHelper;
+    }());
+    exports.ComparerHelper = ComparerHelper;
+});

dist/amd/helpers/type-helper.js

@@ -0,0 +1,22 @@
+define(["require", "exports"], function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    var TypeHelper = (function () {
+        function TypeHelper() {
+        }
+        TypeHelper.isDateType = function (value) {
+            return (typeof value.getMonth === 'function');
+        };
+        TypeHelper.isFunctionType = function (value) {
+            return (typeof value === 'function');
+        };
+        TypeHelper.isSimpleType = function (value) {
+            return (typeof value == "string" || typeof value == "number");
+        };
+        TypeHelper.isArrayType = function (value) {
+            return Object.prototype.toString.call(value) === '[object Array]';
+        };
+        return TypeHelper;
+    }());
+    exports.TypeHelper = TypeHelper;
+});

dist/amd/index.js

@@ -0,0 +1,50 @@
+define(["require", "exports", "./exposer", "./rule-registry-setup", "./builders/reactive-validation-group-builder", "./builders/ruleset-builder", "./builders/validation-group-builder", "./events/model-state-changed-event", "./events/property-changed-event", "./events/property-state-changed-event", "./factories/model-resolver-factory", "./factories/model-watcher-factory", "./helpers/comparer-helper", "./helpers/type-helper", "./processors/field-error-processor", "./processors/field-has-error", "./processors/validation-error", "./promises/promise-counter", "./resolvers/model-resolver", "./rulesets/for-each-rule", "./rulesets/rule-link", "./rulesets/rule-resolver", "./rulesets/ruleset", "./rules/advanced-regex-rule", "./rules/date-validation-rule", "./rules/decimal-validation-rule", "./rules/email-validation-rule", "./rules/equal-validation-rule", "./rules/iso-date-validation-rule", "./rules/matches-validation-rule", "./rules/max-length-validation-rule", "./rules/max-value-validation-rule", "./rules/min-length-validation-rule", "./rules/min-value-validation-rule", "./rules/not-equal-validation-rule", "./rules/number-validation-rule", "./rules/regex-validation-rule", "./rules/required-validation-rule", "./rules/rule-registry", "./rules/step-validation-rule", "./watcher/model-watcher", "./watcher/property-watcher", "./validation-groups/reactive-validation-group", "./validation-groups/validation-group", "./rules/composite/dynamic-composite-validation-rule"], function (require, exports, exposer_1, rule_registry_setup_1, reactive_validation_group_builder_1, ruleset_builder_1, validation_group_builder_1, model_state_changed_event_1, property_changed_event_1, property_state_changed_event_1, model_resolver_factory_1, model_watcher_factory_1, comparer_helper_1, type_helper_1, field_error_processor_1, field_has_error_1, validation_error_1, promise_counter_1, model_resolver_1, for_each_rule_1, rule_link_1, rule_resolver_1, ruleset_1, advanced_regex_rule_1, date_validation_rule_1, decimal_validation_rule_1, email_validation_rule_1, equal_validation_rule_1, iso_date_validation_rule_1, matches_validation_rule_1, max_length_validation_rule_1, max_value_validation_rule_1, min_length_validation_rule_1, min_value_validation_rule_1, not_equal_validation_rule_1, number_validation_rule_1, regex_validation_rule_1, required_validation_rule_1, rule_registry_1, step_validation_rule_1, model_watcher_1, property_watcher_1, reactive_validation_group_1, validation_group_1, dynamic_composite_validation_rule_1) {
+    "use strict";
+    function __export(m) {
+        for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];
+    }
+    Object.defineProperty(exports, "__esModule", { value: true });
+    __export(exposer_1);
+    __export(rule_registry_setup_1);
+    __export(reactive_validation_group_builder_1);
+    __export(ruleset_builder_1);
+    __export(validation_group_builder_1);
+    __export(model_state_changed_event_1);
+    __export(property_changed_event_1);
+    __export(property_state_changed_event_1);
+    __export(model_resolver_factory_1);
+    __export(model_watcher_factory_1);
+    __export(comparer_helper_1);
+    __export(type_helper_1);
+    __export(field_error_processor_1);
+    __export(field_has_error_1);
+    __export(validation_error_1);
+    __export(promise_counter_1);
+    __export(model_resolver_1);
+    __export(for_each_rule_1);
+    __export(rule_link_1);
+    __export(rule_resolver_1);
+    __export(ruleset_1);
+    __export(advanced_regex_rule_1);
+    __export(date_validation_rule_1);
+    __export(decimal_validation_rule_1);
+    __export(email_validation_rule_1);
+    __export(equal_validation_rule_1);
+    __export(iso_date_validation_rule_1);
+    __export(matches_validation_rule_1);
+    __export(max_length_validation_rule_1);
+    __export(max_value_validation_rule_1);
+    __export(min_length_validation_rule_1);
+    __export(min_value_validation_rule_1);
+    __export(not_equal_validation_rule_1);
+    __export(number_validation_rule_1);
+    __export(regex_validation_rule_1);
+    __export(required_validation_rule_1);
+    __export(rule_registry_1);
+    __export(step_validation_rule_1);
+    __export(model_watcher_1);
+    __export(property_watcher_1);
+    __export(reactive_validation_group_1);
+    __export(validation_group_1);
+    __export(dynamic_composite_validation_rule_1);
+});