@lijuhong1981/jscheck 1.0.0

package/index.js

@@ -0,0 +1,23 @@
+import Check from "./src/Check.js";
+import isArray from "./src/isArray.js";
+import isBoolean from "./src/isBoolean.js";
+import isFunction from "./src/isFunction.js";
+import isInteger from "./src/isInteger.js";
+import isNumber from "./src/isNumber.js";
+import isObject from "./src/isObject.js";
+import isString from "./src/isString.js";
+import isTypedArray from "./src/isTypedArray.js";
+import isValid from "./src/isValid.js";
+
+export default Check;
+export {
+    isArray,
+    isBoolean,
+    isFunction,
+    isInteger,
+    isNumber,
+    isObject,
+    isString,
+    isTypedArray,
+    isValid,
+};

package/package.json

@@ -0,0 +1,13 @@
+{
+  "name": "@lijuhong1981/jscheck",
+  "version": "1.0.0",
+  "description": "",
+  "main": "index.js",
+  "module": "index.js",
+  "type": "module",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "author": "lijuhong1981",
+  "license": "ISC"
+}

package/src/Check.js

@@ -0,0 +1,235 @@
+import isValid from "./isValid.js";
+
+const Check = {};
+
+Check.typeOf = {};
+
+function getInvalidErrorMessage(name) {
+    return name + " is required, actual value was invalid.";
+}
+
+function getFailedTypeErrorMessage(actual, expected, name) {
+    return (
+        "Expected " +
+        name +
+        " to be typeof " +
+        expected +
+        ", actual typeof was " +
+        actual
+    );
+}
+
+Check.isValid = function (name, test) {
+    if (!isValid(test)) {
+        throw new Error(getInvalidErrorMessage(name));
+    }
+};
+
+Check.typeOf.func = function (name, test) {
+    if (typeof test !== "function") {
+        throw new Error(
+            getFailedTypeErrorMessage(typeof test, "function", name)
+        );
+    }
+};
+
+Check.typeOf.string = function (name, test) {
+    if (typeof test !== "string") {
+        throw new Error(
+            getFailedTypeErrorMessage(typeof test, "string", name)
+        );
+    }
+};
+
+Check.typeOf.number = function (name, test) {
+    if (typeof test !== "number") {
+        throw new Error(
+            getFailedTypeErrorMessage(typeof test, "number", name)
+        );
+    }
+};
+
+Check.typeOf.number.lessThan = function (name, test, limit) {
+    Check.typeOf.number(name, test);
+    if (test >= limit) {
+        throw new Error(
+            "Expected " +
+            name +
+            " to be less than " +
+            limit +
+            ", actual value was " +
+            test
+        );
+    }
+};
+
+Check.typeOf.number.lessThanOrEquals = function (name, test, limit) {
+    Check.typeOf.number(name, test);
+    if (test > limit) {
+        throw new Error(
+            "Expected " +
+            name +
+            " to be less than or equal to " +
+            limit +
+            ", actual value was " +
+            test
+        );
+    }
+};
+
+Check.typeOf.number.greaterThan = function (name, test, limit) {
+    Check.typeOf.number(name, test);
+    if (test <= limit) {
+        throw new Error(
+            "Expected " +
+            name +
+            " to be greater than " +
+            limit +
+            ", actual value was " +
+            test
+        );
+    }
+};
+
+Check.typeOf.number.greaterThanOrEquals = function (name, test, limit) {
+    Check.typeOf.number(name, test);
+    if (test < limit) {
+        throw new Error(
+            "Expected " +
+            name +
+            " to be greater than or equal to" +
+            limit +
+            ", actual value was " +
+            test
+        );
+    }
+};
+
+Check.typeOf.number.equals = function (name1, name2, test1, test2) {
+    Check.typeOf.number(name1, test1);
+    Check.typeOf.number(name2, test2);
+    if (test1 !== test2) {
+        throw new Error(
+            name1 +
+            " must be equal to " +
+            name2 +
+            ", the actual values are " +
+            test1 +
+            " and " +
+            test2
+        );
+    }
+};
+
+Check.typeOf.object = function (name, test) {
+    if (typeof test !== "object") {
+        throw new Error(
+            getFailedTypeErrorMessage(typeof test, "object", name)
+        );
+    }
+};
+
+Check.typeOf.bool = function (name, test) {
+    if (typeof test !== "boolean") {
+        throw new Error(
+            getFailedTypeErrorMessage(typeof test, "boolean", name)
+        );
+    }
+};
+
+Check.typeOf.array = function (name, test) {
+    if (Array.isArray(test) === false) {
+        throw new Error(getFailedTypeErrorMessage(typeof test, 'array', name));
+    }
+};
+
+Check.typeOf.integer = function (name, test) {
+    if (Number.isSafeInteger(test) === false) {
+        throw new Error(getFailedTypeErrorMessage(typeof test, 'integer', name));
+    }
+}
+
+Check.typeOf.integer.lessThan = function (name, test, limit) {
+    Check.typeOf.integer(name, test);
+    if (test >= limit) {
+        throw new Error('Expected ' +
+            name +
+            ' to be less than ' +
+            limit +
+            ', actual value was ' +
+            test);
+    }
+};
+
+Check.typeOf.integer.lessThanOrEquals = function (name, test, limit) {
+    Check.typeOf.integer(name, test);
+    if (test > limit) {
+        throw new Error('Expected ' +
+            name +
+            ' to be less than or equal to ' +
+            limit +
+            ', actual value was ' +
+            test);
+    }
+};
+
+Check.typeOf.integer.greaterThan = function (name, test, limit) {
+    Check.typeOf.integer(name, test);
+    if (test <= limit) {
+        throw new Error('Expected ' +
+            name +
+            ' to be greater than ' +
+            limit +
+            ', actual value was ' +
+            test);
+    }
+};
+
+Check.typeOf.integer.greaterThanOrEquals = function (name, test, limit) {
+    Check.typeOf.integer(name, test);
+    if (test < limit) {
+        throw new Error('Expected ' +
+            name +
+            ' to be greater than or equal to' +
+            limit +
+            ', actual value was ' +
+            test);
+    }
+};
+
+Check.typeOf.integer.equals = function (name1, name2, test1, test2) {
+    Check.typeOf.integer(name1, test1);
+    Check.typeOf.integer(name2, test2);
+    if (test1 !== test2) {
+        throw new Error(
+            name1 +
+            " must be equal to " +
+            name2 +
+            ", the actual values are " +
+            test1 +
+            " and " +
+            test2
+        );
+    }
+};
+
+Check.instanceOf = function (name, test, target) {
+    if (test instanceof target === false) {
+        throw new Error(getFailedTypeErrorMessage(false, target.name, name));
+    }
+};
+
+Check.equals = function (name, test, target) {
+    Check.isValid(test);
+    Check.isValid(target);
+    if (test !== target) {
+        throw new Error('Expected ' +
+            name +
+            ' to be equal ' +
+            target +
+            ', actual value was ' +
+            test);
+    }
+};
+
+export default Check;

package/src/isArray.js

@@ -0,0 +1,5 @@
+function isArray(value) {
+    return Array.isArray(value);
+};
+
+export default isArray;

package/src/isBoolean.js

@@ -0,0 +1,5 @@
+function isBoolean(value) {
+    return typeof value === 'boolean';
+};
+
+export default isBoolean;

package/src/isFunction.js

@@ -0,0 +1,5 @@
+function isFunction(value) {
+    return typeof value === 'function';
+};
+
+export default isFunction;

package/src/isInteger.js

@@ -0,0 +1,5 @@
+function isInteger(value) {
+    return Number.isSafeInteger(value);
+};
+
+export default isInteger;

package/src/isNumber.js

@@ -0,0 +1,5 @@
+function isNumber(value) {
+    return typeof value === 'number';
+}
+
+export default isNumber;

package/src/isObject.js

@@ -0,0 +1,5 @@
+function isObject(value) {
+    return value !== null && typeof value === 'object';
+};
+
+export default isObject;

package/src/isString.js

@@ -0,0 +1,5 @@
+function isString(value) {
+    return typeof value === 'string';
+};
+
+export default isString;

package/src/isTypedArray.js

@@ -0,0 +1,17 @@
+function isTypedArray(value) {
+    if (value instanceof Int8Array ||
+        value instanceof Uint8Array ||
+        value instanceof Uint8ClampedArray ||
+        value instanceof Int16Array ||
+        value instanceof Uint16Array ||
+        value instanceof Int32Array ||
+        value instanceof Uint32Array ||
+        value instanceof Float32Array ||
+        value instanceof Float64Array ||
+        value instanceof BigInt64Array ||
+        value instanceof BigUint64Array)
+        return true;
+    return false;
+}
+
+export default isTypedArray;

package/src/isValid.js

@@ -0,0 +1,9 @@
+import isNumber from "./isNumber.js";
+
+function isValid(value) {
+    if (value === undefined || value === null || (isNumber(value) && isNaN(value)))
+        return false;
+    return true;
+}
+
+export default isValid;