jis 1.0.35 → 2.0.1

package/.gitlab-ci.yml

@@ -0,0 +1,55 @@
+
+image: node:20
+
+workflow:
+  rules:
+    - when: always
+
+stages:
+  - setup
+  - test
+  - deploy
+
+.default_rules:
+  rules:
+    - if: $CI_COMMIT_BRANCH
+    - if: $CI_MERGE_REQUEST_ID
+    - if: $CI_COMMIT_TAG
+
+install_and_build:
+  stage: setup
+  extends: .default_rules
+  script:
+    - yarn install --frozen-lockfile
+    - yarn build
+  artifacts:
+    paths:
+      - node_modules/
+      - .yarn/
+      - yarn.lock
+      - dist/
+    expire_in: 15 mins
+
+run_tests:
+  stage: test
+  extends: .default_rules
+  dependencies:
+    - install_and_build
+  script:
+    - yarn test
+
+publish_npm:
+  stage: deploy
+  rules:
+    - if: $CI_COMMIT_TAG =~ /^v\d+\.\d+\.\d+/
+  dependencies:
+    - install_and_build
+  script:
+    - PACKAGE_VERSION=$(node -p "require('./package.json').version")
+    - |
+      if [ "$PACKAGE_VERSION" != "${CI_COMMIT_TAG#v}" ]; then
+        echo "Error: Version mismatch ($PACKAGE_VERSION vs $CI_COMMIT_TAG)"
+        exit 1
+      fi
+    - echo "//registry.npmjs.org/:_authToken=${NPM_TOKEN}" > ~/.npmrc
+    - npm publish --access public

package/package.json

@@ -1,12 +1,24 @@
 {
   "name": "jis",
-  "version": "1.0.35",
+  "private": false,
+  "version": "2.0.1",
   "description": "When you need validate the variable data type",
-  "main": "dist/jis.js",
-  "types": "types/index.d.ts",
+  "type": "module",
+  "main": "./dist/jis.umd.cjs",
+  "module": "./dist/jis.js",
+  "types": "./dist/main.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/main.d.ts",
+      "import": "./dist/jis.js",
+      "require": "./dist/jis.umd.cjs"
+    }
+  },
   "scripts": {
-    "test": "mocha test.js",
-    "build": "webpack"
+    "dev": "vite",
+    "build": "tsc && vite build",
+    "preview": "vite preview",
+    "test": "vitest run"
   },
   "keywords": [
     "Is",
@@ -20,20 +32,15 @@
   ],
   "repository": {
     "type": "git",
-    "url": "https://gitlab.com/josebasmtz/jis.git"
+    "url": "git+https://gitlab.com/josebasmtzdev/jis.git"
   },
   "author": "Jose Can <joseluisgpecanmtz@gmail.com>",
   "license": "ISC",
   "devDependencies": {
-    "chai": "^4.2.0",
-    "mocha": "^8.2.1",
-    "ts-loader": "^9.2.2",
-    "tsc": "^1.20150623.0",
-    "typescript": "^4.0.5",
-    "webpack-cli": "^4.7.0"
-  },
-  "dependencies": {
-    "uglifyjs-webpack-plugin": "^2.2.0",
-    "webpack": "^5.37.1"
+    "@types/node": "^25.0.3",
+    "typescript": "~5.9.3",
+    "vite": "^7.2.4",
+    "vite-plugin-dts": "^4.5.4",
+    "vitest": "^4.0.16"
   }
 }

package/src/Is.ts

@@ -1,3 +1,5 @@
+import type {Gen} from "./interfaces/main.ts";
+
 export default class Is{
     private static callToString(arg:any) {
         return Object.prototype.toString.call(arg)
@@ -7,7 +9,7 @@ export default class Is{
         return Is.callToString(arg) === '[object String]';
     }
 
-    static is(arg:any, type){
+    static is(arg: any, type : any){
         if(Is.$function(type))
         {
             return arg instanceof type;
@@ -21,47 +23,47 @@ export default class Is{
         return arg === type;
     }
 
-    static $array(arg:any){
+    static $array(arg: any){
         return Is.is(arg, 'Array');
     }
 
-    static $null(arg:any){
+    static $null(arg: any){
         return Is.is(arg, 'Null');
     }
 
-    static $number(arg:any){
+    static $number(arg: any){
         return Is.is(arg, 'Number');
     }
 
-    static $object(arg:any){
+    static $object(arg: any){
         return Is.is(arg, 'Object');
     }
 
-    static $undefined(arg:any){
+    static $undefined(arg: any){
         return Is.is(arg, 'Undefined');
     }
 
-    static $boolean(arg:any){
+    static $boolean(arg: any){
         return Is.is(arg, 'Boolean');
     }
 
-    static $function(arg:any){
+    static $function(arg: any){
         return Is.callToString(arg) === '[object Function]';
     }
 
-    static objectIsValid(data:object, rules:object) {
+    static objectIsValid(data: Gen, rules: Gen) {
         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');
 
         let $response = true;
         let $keys = Object.getOwnPropertyNames(rules);
 
-        $keys.forEach((key) => {
+        $keys.forEach((key: string) => {
             let rule = rules[key];
             if (Is.$array(rule)) {
                 if (rule.length < 1) return;
                 let parcial = false;
-                rule.forEach((_rule) => {
+                rule.forEach((_rule: any) => {
                     parcial = parcial || Is.is(data[key], _rule);
                 });
                 return $response = $response && parcial;
@@ -92,7 +94,7 @@ export default class Is{
             Is.$boolean,
             Is.$number,
             Is.$string,
-            (arg) => Is.is(arg, 'Symbol')
+            (arg: any) => Is.is(arg, 'Symbol')
         ]
 
         return validations.some(item => item(arg))
@@ -104,9 +106,9 @@ export default class Is{
             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)
+            (arg: any) => Is.$boolean(arg) && !arg,
+            (arg: any) => Is.$number(arg) && arg === 0,
+            (arg: any) => (Is.$array(arg) || Is.$string(arg)) && (arg === "0" || (arg as any[]|string).length === 0)
         ]
 
         return validations.some(item => item(arg))

package/src/interfaces/main.ts

@@ -0,0 +1,3 @@
+export interface Gen extends Object {
+    [key: string]: any;
+}

package/src/main.ts

@@ -1,3 +1,4 @@
-import Is from './Is';
+
+import Is from "./Is.ts";
 
 export default Is;

package/test/array.test.ts

@@ -0,0 +1,19 @@
+
+import {expect, test, describe} from "vitest";
+import jis from "jis";
+
+const { $array } = jis;
+
+describe("$array method", () => {
+    test("jis.$array('') returns false", () => {
+        expect($array('')).toBe(false);
+    });
+
+    test("jis.$array(1) returns false", () => {
+        expect($array(1)).toBe(false);
+    });
+
+    test("jis.$array([]) returns true", () => {
+        expect($array([])).toBe(true);
+    });
+})

package/test/boolean.test.ts

@@ -0,0 +1,19 @@
+
+import {describe, test, expect} from "vitest";
+import jis from "jis";
+
+const { $boolean } = jis;
+
+describe("$boolean method", () => {
+    test("jis.$boolean('') returns false", () => {
+        expect($boolean('')).toBe(false)
+    });
+
+    test("jis.$boolean(false) returns false", () => {
+        expect($boolean(false)).toBe(true)
+    })
+
+    test("jis.$boolean(true) returns false", () => {
+        expect($boolean(true)).toBe(true)
+    })
+})

package/test/empty.test.ts

@@ -0,0 +1,63 @@
+import { describe, expect, test } from "vitest";
+import jis from "jis";
+
+const { $empty } = jis;
+
+describe("$empty method", () => {
+    test("jis.$empty(null) returns true", () => {
+        expect($empty(null)).toBe(true);
+    });
+
+    test("jis.$empty(undefined) returns true", () => {
+        expect($empty(undefined)).toBe(true);
+    });
+
+    test("jis.$empty(false) returns true", () => {
+        expect($empty(false)).toBe(true);
+    });
+
+    test("jis.$empty(0) returns true", () => {
+        expect($empty(0)).toBe(true);
+    });
+
+    test("jis.$empty(0.0) returns true", () => {
+        expect($empty(0.0)).toBe(true);
+    });
+
+    test("jis.$empty('') returns true", () => {
+        expect($empty('')).toBe(true);
+    });
+
+    test("jis.$empty('0') returns true", () => {
+        expect($empty('0')).toBe(true);
+    });
+
+    test("jis.$empty([]) returns true", () => {
+        expect($empty([])).toBe(true);
+    });
+
+
+    test("jis.$empty(true) returns false", () => {
+        expect($empty(true)).toBe(false);
+    });
+
+    test("jis.$empty(12) returns false", () => {
+        expect($empty(12)).toBe(false);
+    });
+
+    test("jis.$empty(12.0) returns false", () => {
+        expect($empty(12.0)).toBe(false);
+    });
+
+    test("jis.$empty('something') returns false", () => {
+        expect($empty('something')).toBe(false);
+    });
+
+    test("jis.$empty('012') returns false", () => {
+        expect($empty('012')).toBe(false);
+    });
+
+    test("jis.$empty([1, 2, 3]) returns false", () => {
+        expect($empty([1, 2, 3])).toBe(false);
+    });
+})

package/test/function.test.ts

@@ -0,0 +1,15 @@
+
+import {expect, test, describe} from "vitest";
+import jis from "jis";
+
+const { $function } = jis;
+
+describe("$function method", () => {
+    test("jis.$function('') returns false", () => {
+        expect($function('')).toBe(false)
+    });
+
+    test("jis.$function(function(){}) returns true", () => {
+        expect($function(function(){})).toBe(true)
+    });
+});

package/test/is.test.ts

@@ -0,0 +1,59 @@
+import {describe, expect, test} from "vitest";
+import jis from "jis";
+
+const { is } = jis;
+
+describe('"is" method', () => {
+    test("jis.is([], 'Array') returns true", () =>  {
+        expect(is([], 'Array')).toBe(true);
+    });
+
+    test("jis.is(false, 'Boolean') returns true", () =>  {
+        expect(is(false, 'Boolean')).toBe(true);
+    });
+
+    test("jis.is(true, 'Boolean') returns true", () =>  {
+        expect(is(true, 'Boolean')).toBe(true);
+    });
+
+    test("jis.is(function() {}, 'Function' returns true", () =>  {
+        expect(is(function() {}, 'Function')).toBe(true);
+    });
+
+    test("jis.is(null, 'Null') returns true", () =>  {
+        expect(is(null, 'Null')).toBe(true);
+    });
+
+    test("jis.is(12, 'Number') returns true", () =>  {
+        expect(is(12, 'Number')).toBe(true);
+    });
+
+    test("jis.is({}, 'Object') returns true", () =>  {
+        expect(is({}, 'Object')).toBe(true);
+    });
+
+    test("jis.is('Text','String') returns true", () =>  {
+        expect(is('Text','String')).toBe(true);
+    });
+
+    test("jis.is(undefined, 'Undefined') returns true", () =>  {
+        expect(is(undefined, 'Undefined')).toBe(true);
+    });
+
+    test("jis.is(date, Date) returns true", () =>  {
+        const date = new Date();
+        expect(is(date, Date)).toBe(true);
+    });
+
+    test("jis.is(/^$/g, RegExp) returns true", () =>  {
+        expect(is(/^$/g, RegExp)).toBe(true);
+    });
+
+    test("jis.is(/^$/g, 'RegExp') returns true", () =>  {
+        expect(is(/^$/g, 'RegExp')).toBe(true);
+    });
+
+    test("jis.is(12, 12) returns true", () =>  {
+        expect(is(12, 12)).toBe(true);
+    });
+})

package/test/null.test.ts

@@ -0,0 +1,19 @@
+
+import {test, expect, describe} from "vitest";
+import jis from "jis";
+
+const { $null } = jis;
+
+describe("$null method", () => {
+    test("jis.$null(true) returns false", () => {
+        expect($null(true)).toBe(false);
+    })
+
+    test("jis.$null([]) returns false", () => {
+        expect($null([])).toBe(false);
+    })
+
+    test("jis.$null(null) returns true", () => {
+        expect($null(null)).toBe(true);
+    })
+})

package/test/number.test.ts

@@ -0,0 +1,15 @@
+
+import {describe, test, expect} from "vitest";
+import jis from "jis";
+
+const { $number } = jis;
+
+describe("$number method", () => {
+    test("jis.$number('12') returns false", () => {
+        expect($number('12')).toBe(false);
+    });
+
+    test("jis.$number(12) returns true", () => {
+        expect($number(12)).toBe(true);
+    });
+});

package/test/numeric.test.ts

@@ -0,0 +1,63 @@
+import {describe, expect, test} from "vitest";
+import jis from "jis";
+
+const {$numeric} = jis;
+
+describe("$numeric method", () => {
+    test("jis.$numeric(12) returns true", () => {
+        expect($numeric(12)).toBe(true);
+    });
+
+    test("jis.$numeric('12') returns true", () => {
+        expect($numeric('12')).toBe(true);
+    });
+
+    test("jis.$numeric('-12') returns true", () => {
+        expect($numeric('-12')).toBe(true);
+    });
+
+    test("jis.$numeric('+12') returns true", () => {
+        expect($numeric('+12')).toBe(true);
+    });
+
+    test("jis.$numeric('12.') returns true", () => {
+        expect($numeric('12.')).toBe(true);
+    });
+
+    test("jis.$numeric('12.e5') returns true", () => {
+        expect($numeric('12.e5')).toBe(true);
+    });
+
+    test("jis.$numeric('12.E5') returns true", () => {
+        expect($numeric('12.E5')).toBe(true);
+    });
+
+    test("jis.$numeric('12.E-5') returns true", () => {
+        expect($numeric('12.E-5')).toBe(true);
+    });
+
+    test("jis.$numeric('-12.E-5') returns true", () => {
+        expect($numeric('-12.E-5')).toBe(true);
+    });
+
+    test("jis.$numeric('+12.E-5') returns true", () => {
+        expect($numeric('+12.E-5')).toBe(true);
+    });
+
+
+    test("jis.$numeric('12.E-') returns false", () => {
+        expect($numeric('12.E-')).toBe(false);
+    });
+
+    test("jis.$numeric('A3B') returns false", () => {
+        expect($numeric('A3B')).toBe(false);
+    });
+
+    test("jis.$numeric(undefined) returns false", () => {
+        expect($numeric(undefined)).toBe(false);
+    });
+
+    test("jis.$numeric(null) returns false", () => {
+        expect($numeric(null)).toBe(false);
+    });
+})

package/test/object.test.ts

@@ -0,0 +1,15 @@
+
+import {describe, test, expect} from "vitest";
+import jis from "jis";
+
+const { $object } = jis;
+
+describe("$object method", () => {
+    test("jis.$object(undefined) returns false", () => {
+        expect($object(undefined)).toBe(false);
+    });
+
+    test("jis.$object({}) returns true", () => {
+        expect($object({})).toBe(true);
+    });
+})

package/test/primitive.test.ts

@@ -0,0 +1,47 @@
+import { describe, test, expect } from "vitest";
+import jis from "jis";
+
+const { $primitive } = jis;
+
+describe("$primitive method", () => {
+    test("jis.$primitive(undefined) returns true", () => {
+        expect($primitive(undefined)).toBe(true);
+    });
+
+    test("jis.$primitive(null) returns true", () => {
+        expect($primitive(null)).toBe(true);
+    });
+
+    test("jis.$primitive('something') returns true", () => {
+        expect($primitive('something')).toBe(true);
+    });
+
+    test("jis.$primitive(true) returns true", () => {
+        expect($primitive(true)).toBe(true);
+    });
+
+    test("jis.$primitive(false) returns true", () => {
+        expect($primitive(false)).toBe(true);
+    });
+
+    test("jis.$primitive(12) returns true", () => {
+        expect($primitive(12)).toBe(true);
+    });
+
+    test("jis.$primitive(Symbol()) returns true", () => {
+        expect($primitive(Symbol())).toBe(true);
+    });
+
+
+    test("jis.$primitive({}) returns false", () => {
+        expect($primitive({})).toBe(false);
+    });
+
+    test("jis.$primitive([]) returns false", () => {
+        expect($primitive([])).toBe(false);
+    });
+
+    test("jis.$primitive(new Date()) returns false", () => {
+        expect($primitive(new Date())).toBe(false);
+    });
+})

package/test/string.test.ts

@@ -0,0 +1,18 @@
+import { describe, test, expect } from "vitest";
+import jis from "jis";
+
+const { $string } = jis;
+
+describe("$string method", () => {
+    test("jis.$string(12) returns false", () => {
+        expect($string(12)).toBe(false);
+    });
+
+    test("jis.$string([]) returns false", () => {
+        expect($string([])).toBe(false);
+    });
+
+    test("jis.$string('') returns true", () => {
+        expect($string('')).toBe(true);
+    });
+})

package/test/undefined.test.ts

@@ -0,0 +1,14 @@
+import { describe, test, expect } from "vitest";
+import jis from "jis";
+
+const { $undefined } = jis;
+
+describe("$undefined method", () => {
+    test("jis.$undefined({}) returns false", () => {
+        expect($undefined({})).toBe(false);
+    });
+
+    test("jis.$undefined(undefined) returns true", () => {
+        expect($undefined(undefined)).toBe(true);
+    });
+})

package/tsconfig.json

@@ -1,15 +1,26 @@
 {
   "compilerOptions": {
-    "sourceMap": false,
-    "module": "commonjs",
-    "target": "es5",
-    "lib": [ "es2015", "dom" ],
-    "outDir": "build"
+    "target": "ES2022",
+    "useDefineForClassFields": true,
+    "module": "ESNext",
+    "lib": ["ES2022", "DOM", "DOM.Iterable"],
+    "types": ["vite/client"],
+    "skipLibCheck": true,
+
+    /* Bundler mode */
+    "moduleResolution": "bundler",
+    "allowImportingTsExtensions": true,
+    "verbatimModuleSyntax": true,
+    "moduleDetection": "force",
+    "noEmit": true,
+
+    /* Linting */
+    "strict": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "erasableSyntaxOnly": true,
+    "noFallthroughCasesInSwitch": true,
+    "noUncheckedSideEffectImports": true
   },
-  "exclude": [
-    "node_modules"
-  ],
-  "include": [
-    "src/*.ts"
-  ]
-}
+  "include": ["src"]
+}

package/vite.config.ts

@@ -0,0 +1,28 @@
+import { resolve } from 'path';
+import { defineConfig } from 'vitest/config';
+import dts from 'vite-plugin-dts';
+
+export default defineConfig({
+    build: {
+        lib: {
+            // Entry point for your library
+            entry: resolve(import.meta.dirname, 'src/main.ts'),
+            name: 'jis',
+            // Format to output (es, umd, etc.)
+            fileName: 'jis',
+        },
+        rollupOptions: {
+            // Externalize dependencies you don't want bundled
+            external: [],
+            output: {
+                globals: {},
+            },
+        },
+    },
+    plugins: [dts()],
+    test: {
+        environment: 'node',
+        globals: true,
+        reporters: ['verbose']
+    }
+});

package/dist/jis.js

@@ -1,160 +0,0 @@
-(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

@@ -1 +0,0 @@
-!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

@@ -1,10 +0,0 @@
-<!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/test.js

@@ -1,143 +0,0 @@
-require('mocha');
-let assert = require('chai').assert;
-let jis = require('./')
-
-describe('Jis types test', () => {
-
-    it('$array method', () => {
-
-        assert.equal( jis.$array(''), false, "$array('') must be false");
-        assert.equal( jis.$array(1), false, "$array(1) must be false");
-        assert.equal( jis.$array([]), true, "$array([]) must be true");
-
-    });
-
-    it('$boolean method', () => {
-
-        assert.equal( jis.$boolean(''), false, "$boolean('') must be false" );
-        assert.equal( jis.$boolean(true), true, "$boolean('') must be true" );
-        assert.equal( jis.$boolean(false), true, "$boolean('') must be true" );
-
-    })
-
-    it('$function method', () => {
-
-        assert.equal( jis.$function(''), false, "$function('') must be false" )
-        assert.equal( jis.$function(() => {}), true, "$function(function(){}) must be true" )
-
-    });
-
-    it('$null method', () => {
-
-        assert.equal(jis.$null(true), false, '$null(true) must be false');
-        assert.equal(jis.$null([]), false, '$null([]) must be false');
-        assert.equal(jis.$null(null), true, '$null(null) must be true');
-
-    })
-
-    it('$number method', function () {
-
-        assert.equal( jis.$number('12'), false, "$number('12') must be false" )
-        assert.equal( jis.$number(12), true, "$number('12') must be true" )
-
-    });
-
-    it('$object method', () => {
-
-        assert.equal( jis.$object(undefined), false, '$object(undefined) must be false' )
-        assert.equal( jis.$object({}), true, '$object({}) must be true' )
-
-    });
-
-    it('$string method', () => {
-
-        assert.equal( jis.$string(12), false, '$string(12) must be false' )
-        assert.equal( jis.$string([]), false, '$string([]) must be false' )
-        assert.equal( jis.$string(""), true, '$string("") must be true' )
-
-    });
-
-    it('$undefined method', function () {
-
-        assert.equal( jis.$undefined({}), false, '$undefined({}) must be false')
-        assert.equal( jis.$undefined(undefined), true, '$undefined({}) must be true')
-
-    });
-
-    it('$numeric method', function () {
-
-        assert.equal( jis.$numeric(12), true, '$numeric(12) must be true' );
-        assert.equal( jis.$numeric('12'), true, "$numeric('12') must be true" );
-        assert.equal( jis.$numeric('-12'), true, "$numeric('-12') must be true" );
-        assert.equal( jis.$numeric('+12'), true, "$numeric('+12') must be true" );
-        assert.equal( jis.$numeric('12.'), true, "$numeric('12.') must be true" );
-        assert.equal( jis.$numeric('12.e5'), true, "$numeric('12.e5') must be true" );
-        assert.equal( jis.$numeric('12.E5'), true, "$numeric('12.E5') must be true" );
-        assert.equal( jis.$numeric('12.E-5'), true, "$numeric('12.E-5') must be true" );
-        assert.equal( jis.$numeric('-12.E-5'), true, "$numeric('-12.E-5') must be true" );
-        assert.equal( jis.$numeric('+12.E-5'), true, "$numeric('+12.E-5') must be true" );
-
-        assert.equal( jis.$numeric('12.E-'), false, "$numeric('12.E-') must be false" );
-        assert.equal( jis.$numeric('A3B'), false, "$numeric('A3B') must be false" );
-        assert.equal( jis.$numeric(undefined), false, "$numeric(undefined) must be false" );
-        assert.equal( jis.$numeric(null), false, "$numeric(null) must be false" );
-
-    });
-
-    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)
-        assert.equal(jis.is( true, 'Boolean' ) , true)
-        assert.equal(jis.is( function(){}, 'Function' ) , true)
-        assert.equal(jis.is( null, 'Null' ) , true)
-        assert.equal(jis.is( 12, 'Number' ) , true)
-        assert.equal(jis.is( {}, 'Object' ) , true)
-        assert.equal(jis.is( 'Text', 'String' ) , true)
-        assert.equal(jis.is( undefined, 'Undefined' ) , true)
-
-        let date = new Date();
-        assert.equal(jis.is(date, Date) , true)
-
-        assert.equal(jis.is(/^$/g, RegExp) , true)
-        assert.equal(jis.is(/^$/g, 'RegExp') , true)
-
-        assert.equal(jis.is(12, 12), true);
-    });
-
-})

package/types/index.d.ts

@@ -1,3 +0,0 @@
-import Is from "../src/Is";
-
-export = Is;

package/webpack.config.js

@@ -1,45 +0,0 @@
-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
-                    }
-                }
-            })
-        ]
-    }
-}