ts-rules - npm Package Compare versions

Comparing version 0.3.0 to 0.4.1

dist/ts-rules.js

+(function () {
+  var main = null;
+  var modules = {
+      "require": {
+          factory: undefined,
+          dependencies: [],
+          exports: function (args, callback) { return require(args, callback); },
+          resolved: true
+      }
+  };
+  function define(id, dependencies, factory) {
+      return main = modules[id] = {
+          dependencies: dependencies,
+          factory: factory,
+          exports: {},
+          resolved: false
+      };
+  }
+  function resolve(definition) {
+      if (definition.resolved === true)
+          return;
+      definition.resolved = true;
+      var dependencies = definition.dependencies.map(function (id) {
+          return (id === "exports")
+              ? definition.exports
+              : (function () {
+                  if(modules[id] !== undefined) {
+                    resolve(modules[id]);
+                    return modules[id].exports;
+                  } else return require(id)
+              })();
+      });
+      definition.factory.apply(null, dependencies);
+  }
+  function collect() {
+      Object.keys(modules).map(function (key) { return modules[key]; }).forEach(resolve);
+      return (main !== null) 
+        ? main.exports
+        : undefined
+  }
+
+  define("src/enum-type", ["require", "exports"], function (require, exports) {
+      "use strict";
+      var ParamType;
+      (function (ParamType) {
+          ParamType[ParamType["PROPERTY"] = 0] = "PROPERTY";
+          ParamType[ParamType["VALUE"] = 1] = "VALUE";
+      })(ParamType = exports.ParamType || (exports.ParamType = {}));
+      ;
+  });
+  define("src/origin-rules-analyse", ["require", "exports", "src/enum-type"], function (require, exports, enum_type_1) {
+      "use strict";
+      function originRulesAnalyse(originRules) {
+          var realRules = {};
+          for (var p in originRules) {
+              var ruleStr = originRules[p];
+              updateRule(realRules, p, ruleStr);
+          }
+          return realRules;
+      }
+      exports.originRulesAnalyse = originRulesAnalyse;
+      function updateRule(rules, propName, propValue) {
+          var ruleStringList = propValue.split(/\s*\|\s*/), selectorSplit = propName.split(/\s*:\s*/), field = selectorSplit[0];
+          if (rules[field] === undefined) {
+              rules[field] = [];
+          }
+          var ruleItem = rules[field];
+          for (var i = 0, len = ruleStringList.length; i < len; i++) {
+              var ruleStringItem = ruleStringList[i].split(/\s*:\s*/), ruleParams = void 0, methodName = ruleStringItem.splice(0, 1)[0].replace(/^\s+|\s+$/g, ''), isReverse = false;
+              if (ruleStringItem.length > 0) {
+                  ruleParams = ruleStringItem.map(function (item) {
+                      var type;
+                      if (/^\s*['"]|['"]\s*$/.test(item) || /^-?\d+(?:\.\d+)?$/.test(item)) {
+                          type = enum_type_1.ParamType.VALUE;
+                      }
+                      else {
+                          type = enum_type_1.ParamType.PROPERTY;
+                      }
+                      return {
+                          type: type,
+                          value: item.replace(/^\s+|\s+$/g, '').replace(/^['"]|['"]$/g, '')
+                      };
+                  });
+              }
+              if (methodName.indexOf('!') !== -1) {
+                  isReverse = true;
+                  methodName = methodName.substr(1);
+              }
+              ruleItem.push({
+                  method: methodName,
+                  params: ruleParams,
+                  reverse: isReverse
+              });
+          }
+      }
+  });
+  define("src/build-in-validators", ["require", "exports"], function (require, exports) {
+      "use strict";
+      exports.ValidatorCollection = {
+          create: function () {
+              return {
+                  'required': function (value) {
+                      return !(value === undefined || value === null || /^\s*$/.test(value));
+                  },
+                  'number': function (value) {
+                      return /^-?\d+(?:\.\d+)?$/.test(value);
+                  },
+                  'email': function (value) {
+                      return /^(\w+|\.+)((-\w+|\.+)|(\.+\w+))*\@\w+((\.|-)\w+)*\.\w+/.test(value);
+                  },
+                  'maxLen': function (value, len) {
+                      var str = String(value), rps_value = str.replace(/^\s+|\s+$/g, '');
+                      return rps_value.length <= len;
+                  },
+                  'eq': function (value, compareVal) {
+                      return value == compareVal;
+                  },
+                  'gt': function (val1, val2) {
+                      return val1 > val2;
+                  },
+                  'gte': function (val1, val2) {
+                      return val1 >= val2;
+                  },
+                  'lt': function (val1, val2) {
+                      return val1 < val2;
+                  },
+                  'lte': function (val1, val2) {
+                      return val1 <= val2;
+                  }
+              };
+          }
+      };
+  });
+  define("src/rules", ["require", "exports", "src/origin-rules-analyse", "src/build-in-validators"], function (require, exports, origin_rules_analyse_1, build_in_validators_1) {
+      "use strict";
+      function rules(config) {
+          var realRules = origin_rules_analyse_1.originRulesAnalyse(config), newValidators = build_in_validators_1.ValidatorCollection.create(), ruleFn = getRuleFunction(realRules, newValidators);
+          ruleFn.register = function (methodName, fn) {
+              newValidators[methodName] = fn;
+          };
+          return ruleFn;
+      }
+      exports.rules = rules;
+      function getRuleFunction(realRules, newValidators) {
+          return function (data) {
+              for (var fieldName in realRules) {
+                  var filedItem = realRules[fieldName], dataItem = data[fieldName];
+                  for (var _i = 0, filedItem_1 = filedItem; _i < filedItem_1.length; _i++) {
+                      var ruleItem = filedItem_1[_i];
+                      var params = void 0;
+                      if (ruleItem.params) {
+                          params = ruleItem.params.map(function (param) {
+                              return param.value;
+                          });
+                      }
+                      var valid = newValidators[ruleItem.method].apply(null, [dataItem].concat(params));
+                      if (!valid) {
+                          return { valid: false };
+                      }
+                  }
+              }
+              return { valid: true };
+          };
+      }
+  });
+  define("index", ["require", "exports", "src/rules"], function (require, exports, rules_1) {
+      "use strict";
+      exports.rules = rules_1.rules;
+  });
+  
+  return collect(); 
+})();
+
+rules({})

coverage/PhantomJS 2.1.1 (Mac OS X 0.0.0)/html/index.html

@@ -80,3 +80,3 @@ <!doctype html>
   Code coverage
-  generated by <a href="http://istanbul-js.org/" target="_blank">istanbul</a> at Tue Feb 21 2017 14:29:47 GMT+0800 (CST)
+  generated by <a href="http://istanbul-js.org/" target="_blank">istanbul</a> at Wed Feb 22 2017 18:06:01 GMT+0800 (CST)
 </div>
@@ -83,0 +83,0 @@ </div>

coverage/PhantomJS...0)/html/src/build-in-validators.ts.html

@@ -145,3 +145,3 @@ <!doctype html>
   Code coverage
-  generated by <a href="http://istanbul-js.org/" target="_blank">istanbul</a> at Tue Feb 21 2017 14:29:47 GMT+0800 (CST)
+  generated by <a href="http://istanbul-js.org/" target="_blank">istanbul</a> at Wed Feb 22 2017 18:06:01 GMT+0800 (CST)
 </div>
@@ -148,0 +148,0 @@ </div>

coverage/PhantomJS... OS X 0.0.0)/html/src/enum-type.ts.html

@@ -61,3 +61,3 @@ <!doctype html>
   Code coverage
-  generated by <a href="http://istanbul-js.org/" target="_blank">istanbul</a> at Tue Feb 21 2017 14:29:47 GMT+0800 (CST)
+  generated by <a href="http://istanbul-js.org/" target="_blank">istanbul</a> at Wed Feb 22 2017 18:06:01 GMT+0800 (CST)
 </div>
@@ -64,0 +64,0 @@ </div>

coverage/PhantomJS....1 (Mac OS X 0.0.0)/html/src/index.html

@@ -119,3 +119,3 @@ <!doctype html>
   Code coverage
-  generated by <a href="http://istanbul-js.org/" target="_blank">istanbul</a> at Tue Feb 21 2017 14:29:47 GMT+0800 (CST)
+  generated by <a href="http://istanbul-js.org/" target="_blank">istanbul</a> at Wed Feb 22 2017 18:06:01 GMT+0800 (CST)
 </div>
@@ -122,0 +122,0 @@ </div>

coverage/PhantomJS...)/html/src/origin-rules-analyse.ts.html

@@ -280,3 +280,3 @@ <!doctype html>
   Code coverage
-  generated by <a href="http://istanbul-js.org/" target="_blank">istanbul</a> at Tue Feb 21 2017 14:29:47 GMT+0800 (CST)
+  generated by <a href="http://istanbul-js.org/" target="_blank">istanbul</a> at Wed Feb 22 2017 18:06:01 GMT+0800 (CST)
 </div>
@@ -283,0 +283,0 @@ </div>

coverage/PhantomJS...(Mac OS X 0.0.0)/html/src/rules.ts.html

@@ -223,3 +223,3 @@ <!doctype html>
   Code coverage
-  generated by <a href="http://istanbul-js.org/" target="_blank">istanbul</a> at Tue Feb 21 2017 14:29:47 GMT+0800 (CST)
+  generated by <a href="http://istanbul-js.org/" target="_blank">istanbul</a> at Wed Feb 22 2017 18:06:01 GMT+0800 (CST)
 </div>
@@ -226,0 +226,0 @@ </div>

package.json

 {
   "name": "ts-rules",
-  "version": "0.3.0",
+  "version": "0.4.1",
   "description": "",
@@ -5,0 +5,0 @@ "main": "index.js",

src/build-in-validators.ts

@@ -8,12 +8,12 @@ export interface Validator{
         return {
-            'required': (value) => {
+            'required': (value): boolean => {
                 return !(value === undefined || value === null || /^\s*$/.test(value));
             },
-            'number': (value) => {
+            'number': (value): boolean => {
                 return /^-?\d+(?:\.\d+)?$/.test(value);
             },
-            'email': (value) => {
+            'email': (value):boolean => {
                 return /^(\w+|\.+)((-\w+|\.+)|(\.+\w+))*\@\w+((\.|-)\w+)*\.\w+/.test(value);
             },
-            'maxLen': (value, len) => {
+            'maxLen': (value, len): boolean => {
                 let str = String(value),
@@ -23,8 +23,17 @@ rps_value = str.replace(/^\s+|\s+$/g, '');
             },
-            // 'eq': (orginVal, compareVal) => {
-            //     return  angular.equals(orginVal, compareVal);
-            // },
-            // 'gt': (val1, val2) => {
-            //     return val1 > val2;
-            // }
+            'eq': (value: any, compareVal: any): boolean => {
+                return value == compareVal;
+            },
+            'gt': (val1: any, val2: any) => {
+                return val1 > val2;
+            },
+            'gte': (val1: any, val2: any) => {
+                return val1 >= val2;
+            },
+            'lt': (val1: any, val2: any) => {
+                return val1 < val2;
+            },
+            'lte': (val1: any, val2: any) => {
+                return val1 <= val2;
+            }
         };
@@ -31,0 +40,0 @@

src/rules.spec.ts

@@ -38,3 +38,2 @@ import {rules, RuleFunction} from './rules';
 
-
         it('number', () => {
@@ -101,2 +100,97 @@ r = rules({
 
+        it('eq', () => {
+
+            r = rules({
+                p: `eq: 'kino'`
+            });
+
+            json = {
+                p: 'kino'
+            };
+
+            expect(r(json).valid).toBe(true);
+
+            json = {
+                p: 'onik'
+            };
+
+            expect(r(json).valid).toBe(false);
+        });
+
+        it('gt', () => {
+
+            r = rules({
+                age: `gt: 18`
+            });
+
+            json = {
+                age: 20
+            };
+
+            expect(r(json).valid).toBe(true);
+
+            json = {
+                age: 17
+            };
+
+            expect(r(json).valid).toBe(false);
+        });
+
+        it('gte', () => {
+
+            r = rules({
+                age: `gte: 18`
+            });
+
+            json = {
+                age: 18
+            };
+
+            expect(r(json).valid).toBe(true);
+
+            json = {
+                age: 17
+            };
+
+            expect(r(json).valid).toBe(false);
+        });
+
+        it('lt', () => {
+
+            r = rules({
+                age: `lt: 18`
+            });
+
+            json = {
+                age: 17
+            };
+
+            expect(r(json).valid).toBe(true);
+
+            json = {
+                age: 20
+            };
+
+            expect(r(json).valid).toBe(false);
+        });
+
+        it('lte', () => {
+
+            r = rules({
+                age: `lte: 18`
+            });
+
+            json = {
+                age: 18
+            };
+
+            expect(r(json).valid).toBe(true);
+
+            json = {
+                age: 20
+            };
+
+            expect(r(json).valid).toBe(false);
+        });
+
         it('custom rule', () => {
@@ -140,3 +234,52 @@ r = rules({
 
+    describe('multiple fields', () => {
+
+        it('variable', () => {
+            r = rules({
+                pwd1: 'required',
+                pwd2: `eq: {{pwd1}}`
+            });
+
+            json = {
+                pwd1: 'hello123',
+                pwd2: 'hello123'
+            };
+
+            expect(r(json).valid).toBe(true);
+
+            json = {
+                pwd1: 'hello123',
+                pwd2: 'hello234'
+            };
+
+            expect(r(json).valid).toBe(false);
+        });
+
+        it('mix rules test', () => {
+            r = rules({
+                name: 'required | maxLen: 15',
+                age: 'required | number',
+                desc: 'maxLen: 20'
+            });
+
+            json = {
+                name: 'Tom',
+                age: 28,
+                desc: ''
+            };
+
+            expect(r(json).valid).toBe(true);
+
+            json = {
+                name: '',
+                age: 21,
+                desc: 'Hello'
+            };
+
+            expect(r(json).valid).toBe(false);
+        });
+
+    });
+
 });
 

src/rules.ts

 import {originRulesAnalyse, RealRules} from "./origin-rules-analyse";
 import {ValidatorCollection, Validator} from "./build-in-validators";
+import {ParamType} from "./enum-type";
 
@@ -43,3 +44,9 @@ interface RuleResult{
                     params =  ruleItem.params.map((param) => {
-                        return param.value;
+                        if(param.type === ParamType.PROPERTY){
+                            let field = param.value.replace(/^\s*\{\{|\}\}\s*$/g, '');
+                            return data[field];
+                        }
+                        else {
+                            return param.value;
+                        }
                     });
@@ -46,0 +53,0 @@ }

New alerts

Dynamic require

Supply chain risk

Dynamic require can indicate the package is performing dangerous or unsafe dynamic code execution.

Fixed alerts

Major refactor

Supply chain risk

Package has recently undergone a major refactor. It may be unstable or indicate significant internal changes. Use caution when updating to versions that include significant changes.

Improved metrics

Total package byte prevSize

215300

6.01%

Number of package files

46

2.22%

Lines of code

1429

25.24%

Number of medium supply chain risk alerts

0

-100%

Worsened metrics

Number of low supply chain risk alerts

3

200%

No dependency changes