jis 1.0.30 → 1.0.34

package/README.md

@@ -170,6 +170,48 @@ jis.$numeric( null ) // false
 
 ```
 
+##### $primitive
+
+Check if the argument is primitive type
+
+```js
+
+jis.$primitive(undefined) // true
+jis.$primitive(null) // true
+jis.$primitive("something") // true
+jis.$primitive(true) // true
+jis.$primitive(false) // true
+jis.$primitive(12) // true
+jis.$primitive(Symbol()) // true
+
+jis.$primitive({}) // false
+jis.$primitive([]) // false
+jis.$primitive(new Date()) // false
+
+```
+
+##### $empty
+
+```js
+
+jis.$empty(null) // true
+jis.$empty(undefined) // true
+jis.$empty(false) // true
+jis.$empty(0) // true
+jis.$empty(0.0) // true
+jis.$empty("") // true
+jis.$empty("0") // true
+jis.$empty([]) // true
+
+jis.$empty(true) // false
+jis.$empty(12) // false
+jis.$empty(12.0) // false
+jis.$empty("something") // false
+jis.$empty("012") // false
+jis.$empty([1, 2, 3]) // false
+
+```
+
 ##### is
 
 This method is the library core. Have more options.

package/dist/jis.js

@@ -0,0 +1,160 @@
+(function webpackUniversalModuleDefinition(root, factory) {
+	if(typeof exports === 'object' && typeof module === 'object')
+		module.exports = factory();
+	else if(typeof define === 'function' && define.amd)
+		define("jis", [], factory);
+	else if(typeof exports === 'object')
+		exports["jis"] = factory();
+	else
+		root["jis"] = factory();
+})(this, function() {
+return /******/ (() => { // webpackBootstrap
+/******/ 	"use strict";
+/******/ 	var __webpack_modules__ = ({
+
+/***/ 138:
+/***/ ((__unused_webpack_module, exports) => {
+
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+var Is = /** @class */ (function () {
+    function Is() {
+    }
+    Is.callToString = function (arg) {
+        return Object.prototype.toString.call(arg);
+    };
+    Is.$string = function (arg) {
+        return Is.callToString(arg) === '[object String]';
+    };
+    Is.is = function (arg, type) {
+        if (Is.$function(type)) {
+            return arg instanceof type;
+        }
+        if (Is.$string(type)) {
+            return Is.callToString(arg) === "[object " + type + "]";
+        }
+        return arg === type;
+    };
+    Is.$array = function (arg) {
+        return Is.is(arg, 'Array');
+    };
+    Is.$null = function (arg) {
+        return Is.is(arg, 'Null');
+    };
+    Is.$number = function (arg) {
+        return Is.is(arg, 'Number');
+    };
+    Is.$object = function (arg) {
+        return Is.is(arg, 'Object');
+    };
+    Is.$undefined = function (arg) {
+        return Is.is(arg, 'Undefined');
+    };
+    Is.$boolean = function (arg) {
+        return Is.is(arg, 'Boolean');
+    };
+    Is.$function = function (arg) {
+        return Is.callToString(arg) === '[object Function]';
+    };
+    Is.objectIsValid = function (data, rules) {
+        if (!Is.$object(data))
+            throw new Error('The data parameter must be an Object');
+        if (!Is.$object(rules))
+            throw new Error('The rules parameter must be an Object');
+        var $response = true;
+        var $keys = Object.getOwnPropertyNames(rules);
+        $keys.forEach(function (key) {
+            var rule = rules[key];
+            if (Is.$array(rule)) {
+                if (rule.length < 1)
+                    return;
+                var parcial_1 = false;
+                rule.forEach(function (_rule) {
+                    parcial_1 = parcial_1 || Is.is(data[key], _rule);
+                });
+                return $response = $response && parcial_1;
+            }
+            $response = $response && Is.is(data[key], rule);
+        });
+        return $response;
+    };
+    Is.$numeric = function (arg) {
+        if (Is.$number(arg)) {
+            return true;
+        }
+        var $arg = String(arg || '');
+        var regex = /^[-+]?(([0-9]+)|([0-9]*(\.[0-9]+))|([0-9]+\.))([Ee]([-+]?[0-9]+))?$/g;
+        return regex.test($arg);
+    };
+    Is.$primitive = function (arg) {
+        var validations = [
+            Is.$undefined,
+            Is.$null,
+            Is.$boolean,
+            Is.$number,
+            Is.$string,
+            function (arg) { return Is.is(arg, 'Symbol'); }
+        ];
+        return validations.some(function (item) { return item(arg); });
+    };
+    Is.$empty = function (arg) {
+        var validations = [
+            Is.$undefined,
+            Is.$null,
+            function (arg) { return Is.$boolean(arg) && !arg; },
+            function (arg) { return Is.$number(arg) && arg === 0; },
+            function (arg) { return (Is.$array(arg) || Is.$string(arg)) && (arg === "0" || arg.length === 0); }
+        ];
+        return validations.some(function (item) { return item(arg); });
+    };
+    return Is;
+}());
+exports.default = Is;
+
+
+/***/ })
+
+/******/ 	});
+/************************************************************************/
+/******/ 	// The module cache
+/******/ 	var __webpack_module_cache__ = {};
+/******/ 	
+/******/ 	// The require function
+/******/ 	function __webpack_require__(moduleId) {
+/******/ 		// Check if module is in cache
+/******/ 		var cachedModule = __webpack_module_cache__[moduleId];
+/******/ 		if (cachedModule !== undefined) {
+/******/ 			return cachedModule.exports;
+/******/ 		}
+/******/ 		// Create a new module (and put it into the cache)
+/******/ 		var module = __webpack_module_cache__[moduleId] = {
+/******/ 			// no module.id needed
+/******/ 			// no module.loaded needed
+/******/ 			exports: {}
+/******/ 		};
+/******/ 	
+/******/ 		// Execute the module function
+/******/ 		__webpack_modules__[moduleId](module, module.exports, __webpack_require__);
+/******/ 	
+/******/ 		// Return the exports of the module
+/******/ 		return module.exports;
+/******/ 	}
+/******/ 	
+/************************************************************************/
+var __webpack_exports__ = {};
+// This entry need to be wrapped in an IIFE because it need to be isolated against other modules in the chunk.
+(() => {
+var exports = __webpack_exports__;
+var __webpack_unused_export__;
+
+__webpack_unused_export__ = ({ value: true });
+var Is_1 = __webpack_require__(138);
+exports.default = Is_1.default;
+
+})();
+
+__webpack_exports__ = __webpack_exports__.default;
+/******/ 	return __webpack_exports__;
+/******/ })()
+;
+});

package/dist/jis.min.js

@@ -0,0 +1 @@
+!function(n,t){"object"==typeof exports&&"object"==typeof module?module.exports=t():"function"==typeof define&&define.amd?define("jis",[],t):"object"==typeof exports?exports.jis=t():n.jis=t()}(this,function(){return(()=>{"use strict";var e={138:(n,t)=>{Object.defineProperty(t,"__esModule",{value:!0});var e=(i.callToString=function(n){return Object.prototype.toString.call(n)},i.$string=function(n){return"[object String]"===i.callToString(n)},i.is=function(n,t){return i.$function(t)?n instanceof t:i.$string(t)?i.callToString(n)==="[object "+t+"]":n===t},i.$array=function(n){return i.is(n,"Array")},i.$null=function(n){return i.is(n,"Null")},i.$number=function(n){return i.is(n,"Number")},i.$object=function(n){return i.is(n,"Object")},i.$undefined=function(n){return i.is(n,"Undefined")},i.$boolean=function(n){return i.is(n,"Boolean")},i.$function=function(n){return"[object Function]"===i.callToString(n)},i.objectIsValid=function(r,o){if(!i.$object(r))throw new Error("The data parameter must be an Object");if(!i.$object(o))throw new Error("The rules parameter must be an Object");var u=!0;return Object.getOwnPropertyNames(o).forEach(function(t){var n=o[t];if(i.$array(n)){if(n.length<1)return;var e=!1;return n.forEach(function(n){e=e||i.is(r[t],n)}),u=u&&e}u=u&&i.is(r[t],n)}),u},i.$numeric=function(n){if(i.$number(n))return!0;n=String(n||"");return/^[-+]?(([0-9]+)|([0-9]*(\.[0-9]+))|([0-9]+\.))([Ee]([-+]?[0-9]+))?$/g.test(n)},i.$primitive=function(t){return[i.$undefined,i.$null,i.$boolean,i.$number,i.$string,function(n){return i.is(n,"Symbol")}].some(function(n){return n(t)})},i.$empty=function(t){return[i.$undefined,i.$null,function(n){return i.$boolean(n)&&!n},function(n){return i.$number(n)&&0===n},function(n){return(i.$array(n)||i.$string(n))&&("0"===n||0===n.length)}].some(function(n){return n(t)})},i);function i(){}t.default=e}},r={};function o(n){var t=r[n];if(void 0!==t)return t.exports;t=r[n]={exports:{}};return e[n](t,t.exports,o),t.exports}var n,t,u={};return n=u,t=o(138),n.default=t.default,u.default})()});

package/index.html

@@ -0,0 +1,10 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <title>Title</title>
+</head>
+<body>
+    <script src="dist/jis.min.js"></script>
+</body>
+</html>

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "jis",
-  "version": "1.0.30",
+  "version": "1.0.34",
   "description": "When you need validate the variable data type",
-  "main": "index.js",
+  "main": "dist/jis.js",
   "types": "types/index.d.ts",
   "scripts": {
     "test": "mocha test.js",
-    "build": "tsc src/*.ts --outDir build/"
+    "build": "webpack"
   },
   "keywords": [
     "Is",
@@ -27,8 +27,13 @@
   "devDependencies": {
     "chai": "^4.2.0",
     "mocha": "^8.2.1",
+    "ts-loader": "^9.2.2",
     "tsc": "^1.20150623.0",
-    "typescript": "^4.0.5"
+    "typescript": "^4.0.5",
+    "webpack-cli": "^4.7.0"
   },
-  "dependencies": {}
+  "dependencies": {
+    "uglifyjs-webpack-plugin": "^2.2.0",
+    "webpack": "^5.37.1"
+  }
 }

package/src/Is.ts

@@ -83,4 +83,32 @@ export default class Is{
 
         return regex.test( $arg );
     }
+
+    static $primitive(arg: any)
+    {
+        let validations = [
+            Is.$undefined,
+            Is.$null,
+            Is.$boolean,
+            Is.$number,
+            Is.$string,
+            (arg) => Is.is(arg, 'Symbol')
+        ]
+
+        return validations.some(item => item(arg))
+    }
+
+    static $empty(arg: any)
+    {
+        let validations = [
+            Is.$undefined,
+            Is.$null,
+
+            (arg) => Is.$boolean(arg) && !arg,
+            (arg) => Is.$number(arg) && arg === 0,
+            (arg) => (Is.$array(arg) || Is.$string(arg)) && (arg === "0" || (arg as any[]|string).length === 0)
+        ]
+
+        return validations.some(item => item(arg))
+    }
 }

package/src/main.ts

@@ -0,0 +1,3 @@
+import Is from './Is';
+
+export default Is;

package/test.js

@@ -84,6 +84,42 @@ describe('Jis types test', () => {
 
     });
 
+    it('$primitive method', function () {
+
+        assert.equal(jis.$primitive(undefined), true, '$primitive(undefined) must be true')
+        assert.equal(jis.$primitive(null), true, '$primitive(null) must be true')
+        assert.equal(jis.$primitive("something"), true, '$primitive("something") must be true')
+        assert.equal(jis.$primitive(true), true, '$primitive(true) must be true')
+        assert.equal(jis.$primitive(false), true, '$primitive(false) must be true')
+        assert.equal(jis.$primitive(12), true, '$primitive(12) must be true')
+        assert.equal(jis.$primitive(Symbol()), true, '$primitive(Symbol()) must be true')
+
+        assert.equal(jis.$primitive({}), false, '$primitive({}) must be true')
+        assert.equal(jis.$primitive([]), false, '$primitive([]) must be true')
+        assert.equal(jis.$primitive(new Date()), false, '$primitive(new Date()) must be true')
+
+    });
+
+    it('$empty method', function () {
+
+        assert.equal(jis.$empty(null), true, '$empty(null) must be true')
+        assert.equal(jis.$empty(undefined), true, '$empty(undefined) must be true')
+        assert.equal(jis.$empty(false), true, '$empty(false) must be true')
+        assert.equal(jis.$empty(0), true, '$empty(0) must be true')
+        assert.equal(jis.$empty(0.0), true, '$empty(0.0) must be true')
+        assert.equal(jis.$empty(""), true, '$empty("") must be true')
+        assert.equal(jis.$empty("0"), true, '$empty("0") must be true')
+        assert.equal(jis.$empty([]), true, '$empty([]) must be true')
+
+        assert.equal(jis.$empty(true), false, '$empty(true) must be true')
+        assert.equal(jis.$empty(12), false, '$empty(12) must be true')
+        assert.equal(jis.$empty(12.0), false, '$empty(12.0) must be true')
+        assert.equal(jis.$empty("something"), false, '$empty("something") must be true')
+        assert.equal(jis.$empty("012"), false, '$empty("012") must be true')
+        assert.equal(jis.$empty([1, 2, 3]), false, '$empty([1, 2, 3]) must be true')
+
+    });
+
     it('"is" method', function () {
         assert.equal(jis.is( [], 'Array' ) , true)
         assert.equal(jis.is( false, 'Boolean' ) , true)

package/tsconfig.json

@@ -0,0 +1,15 @@
+{
+  "compilerOptions": {
+    "sourceMap": false,
+    "module": "commonjs",
+    "target": "es5",
+    "lib": [ "es2015", "dom" ],
+    "outDir": "build"
+  },
+  "exclude": [
+    "node_modules"
+  ],
+  "include": [
+    "src/*.ts"
+  ]
+}

package/types/index.d.ts

@@ -1,2 +1,2 @@
-import * as jis from './../'
-export default jis;
+import Is from '../src/Is'
+export default Is;

package/webpack.config.js

@@ -0,0 +1,45 @@
+const path = require('path')
+const UglifyJsPlugin = require('uglifyjs-webpack-plugin')
+
+module.exports = {
+    mode: 'production',
+    entry: {
+        'jis': './src/main.ts',
+        'jis.min': './src/main.ts'
+    },
+    output: {
+        path: path.resolve(__dirname, 'dist'),
+        filename: '[name].js',
+        libraryTarget: 'umd',
+        library: {
+            name: 'jis',
+            type: 'global'
+        },
+        umdNamedDefine: true,
+        globalObject: "this",
+        libraryExport: "default"
+    },
+    resolve: {
+        extensions: ['.ts', '.tsx', '.js']
+    },
+    // devtool: 'source-map',
+    module: {
+        rules: [{
+            test: /\.tsx?$/,
+            loader: 'ts-loader',
+            exclude: /node_modules/
+        }]
+    },
+    optimization: {
+        minimizer: [
+            new UglifyJsPlugin({
+                include: /\.min\.js$/,
+                uglifyOptions: {
+                    output: {
+                        comments: false
+                    }
+                }
+            })
+        ]
+    }
+}

package/build/Is.js

@@ -1,74 +0,0 @@
-"use strict";
-exports.__esModule = true;
-var Is = /** @class */ (function () {
-    function Is() {
-    }
-    Is.callToString = function (arg) {
-        return Object.prototype.toString.call(arg);
-    };
-    Is.$string = function (arg) {
-        return Is.callToString(arg) === '[object String]';
-    };
-    Is.is = function (arg, type) {
-        if (Is.$function(type)) {
-            return arg instanceof type;
-        }
-        if (Is.$string(type)) {
-            return Is.callToString(arg) === "[object " + type + "]";
-        }
-        return arg === type;
-    };
-    Is.$array = function (arg) {
-        return Is.is(arg, 'Array');
-    };
-    Is.$null = function (arg) {
-        return Is.is(arg, 'Null');
-    };
-    Is.$number = function (arg) {
-        return Is.is(arg, 'Number');
-    };
-    Is.$object = function (arg) {
-        return Is.is(arg, 'Object');
-    };
-    Is.$undefined = function (arg) {
-        return Is.is(arg, 'Undefined');
-    };
-    Is.$boolean = function (arg) {
-        return Is.is(arg, 'Boolean');
-    };
-    Is.$function = function (arg) {
-        return Is.callToString(arg) === '[object Function]';
-    };
-    Is.objectIsValid = function (data, rules) {
-        if (!Is.$object(data))
-            throw new Error('The data parameter must be an Object');
-        if (!Is.$object(rules))
-            throw new Error('The rules parameter must be an Object');
-        var $response = true;
-        var $keys = Object.getOwnPropertyNames(rules);
-        $keys.forEach(function (key) {
-            var rule = rules[key];
-            if (Is.$array(rule)) {
-                if (rule.length < 1)
-                    return;
-                var parcial_1 = false;
-                rule.forEach(function (_rule) {
-                    parcial_1 = parcial_1 || Is.is(data[key], _rule);
-                });
-                return $response = $response && parcial_1;
-            }
-            $response = $response && Is.is(data[key], rule);
-        });
-        return $response;
-    };
-    Is.$numeric = function (arg) {
-        if (Is.$number(arg)) {
-            return true;
-        }
-        var $arg = String(arg || '');
-        var regex = /^[-+]?(([0-9]+)|([0-9]*(\.[0-9]+))|([0-9]+\.))([Ee]([-+]?[0-9]+))?$/g;
-        return regex.test($arg);
-    };
-    return Is;
-}());
-exports["default"] = Is;

package/index.js

@@ -1 +0,0 @@
-module.exports = require('./build/Is').default;