feat: add validation functions for type and value checking

Author: caperaven

src/validate/conditions.js

@@ -0,0 +1,64 @@
+/**
+ * // Null Checking
+ * is.not.null(value)               // value is not null or undefined
+ * is.null(value)                   // value is null or undefined
+ * 
+ * // Type Checking                 // value is not null and of the specified type
+ * is.string(value)                 // value is a string
+ * is.number(value)                 // value is a number
+ * is.object(value)                 // value is an object
+ * is.function(value)               // value is a function
+ * is.array(value)                  // value is an array
+ * is.boolean(value)                // value is a boolean
+ * is.regexp(value)                 // value is a regular expression
+ * is.date(value)                   // value is a date
+ * is.instanceOf(value, constructor) // value is an instance of the constructor
+ * is.symbol(value)                 // value is a symbol
+ * is.type(value, type)             // value is of the specified type
+ * 
+ * // Value Checking                // value is not null and of the specified type
+ * is.equal(value, other)           // value is equal to other
+ * is.not.equal(value, other)       // value is not equal to other
+ * is.empty(value)                  // value is a string or an array and is empty
+ * is.not.empty(value)              // value is a string or an array and is not empty
+ * is.truthy(value)                 // value is truthy
+ * is.falsy(value)                  // value is falsy
+ * is.between(value, min, max)      // value is between min and max
+ * is.not.between(value, min, max)  // value is not between min and max
+ * is.greater(value, other)         // value is greater than other
+ * is.less(value, other)            // value is not greater than other
+ * is.oneOf(value, array)           // value is one of the elements in the array
+ */
+
+const is = {
+  null: (val) => val == null,
+  not: {
+    null: (val) => val != null
+  },
+  string: (val) => val != null && typeof val === 'string',
+  number: (val) => val != null && typeof val === 'number',
+  object: (val) => val != null && typeof val === 'object' && !Array.isArray(val),
+  function: (val) => val != null && typeof val === 'function',
+  array: (val) => Array.isArray(val),
+  boolean: (val) => val === true || val === false,
+  regexp: (val) => val instanceof RegExp,
+  date: (val) => val instanceof Date,
+  instanceOf: (val, ctor) => val instanceof ctor,
+  symbol: (val) => typeof val === 'symbol',
+  type: (val, type) => typeof val === type,
+  equal: (val, other) => val === other,
+  empty: (val) => (typeof val === 'string' || Array.isArray(val)) && val.length === 0,
+  true: (val) => val === true || val === "true",
+  false: (val) => val === false || val === "false",
+  between: (val, min, max) => val > min && val < max,
+  greater: (val, other) => val > other,
+  less: (val, other) => val < other,
+  oneOf: (val, arr) => arr.includes(val)
+};
+
+// Negated checks
+is.not.equal = (val, other) => !is.equal(val, other);
+is.not.empty = (val) => !is.empty(val);
+is.not.between = (val, min, max) => !is.between(val, min, max);
+
+export { is };

tests/src/validate/conditions.test.js

@@ -0,0 +1,110 @@
+import { assertEquals } from "https://deno.land/[email protected]/testing/asserts.ts";
+import { is } from "../../../src/validate/conditions.js";
+
+Deno.test("is.null / is.not.null", () => {
+  assertEquals(is.null(null), true);
+  assertEquals(is.null(""), false);
+  assertEquals(is.not.null(null), false);
+  assertEquals(is.not.null("something"), true);
+});
+
+Deno.test("is.string", () => {
+  assertEquals(is.string("test"), true);
+  assertEquals(is.string(123), false);
+});
+
+Deno.test("is.number", () => {
+  assertEquals(is.number(123), true);
+  assertEquals(is.number("123"), false);
+});
+
+Deno.test("is.object", () => {
+  assertEquals(is.object({}), true);
+  assertEquals(is.object([]), false);
+});
+
+Deno.test("is.function", () => {
+  assertEquals(is.function(() => {}), true);
+  assertEquals(is.function({}), false);
+});
+
+Deno.test("is.array", () => {
+  assertEquals(is.array([]), true);
+  assertEquals(is.array({}), false);
+});
+
+Deno.test("is.boolean", () => {
+  assertEquals(is.boolean(true), true);
+  assertEquals(is.boolean("true"), false);
+});
+
+Deno.test("is.regexp", () => {
+  assertEquals(is.regexp(/abc/), true);
+  assertEquals(is.regexp("abc"), false);
+});
+
+Deno.test("is.date", () => {
+  assertEquals(is.date(new Date()), true);
+  assertEquals(is.date("2021-01-01"), false);
+});
+
+Deno.test("is.instanceOf", () => {
+  class Example {}
+  assertEquals(is.instanceOf(new Example(), Example), true);
+  assertEquals(is.instanceOf({}, Example), false);
+});
+
+Deno.test("is.symbol", () => {
+  assertEquals(is.symbol(Symbol()), true);
+  assertEquals(is.symbol("not a symbol"), false);
+});
+
+Deno.test("is.type", () => {
+  assertEquals(is.type("hello", "string"), true);
+  assertEquals(is.type(123, "string"), false);
+});
+
+Deno.test("is.equal / is.not.equal", () => {
+  assertEquals(is.equal(5, 5), true);
+  assertEquals(is.equal(5, "5"), false);
+  assertEquals(is.not.equal(5, 6), true);
+  assertEquals(is.not.equal(5, 5), false);
+});
+
+Deno.test("is.empty / is.not.empty", () => {
+  assertEquals(is.empty(""), true);
+  assertEquals(is.empty([]), true);
+  assertEquals(is.empty("abc"), false);
+  assertEquals(is.not.empty([]), false);
+  assertEquals(is.not.empty(["item"]), true);
+});
+
+Deno.test("is.truthy / is.falsy", () => {
+  assertEquals(is.true(1 == 1), true);
+  assertEquals(is.true("true"), true);
+  assertEquals(is.true(1 == 0), false);
+  assertEquals(is.true(null), false);
+
+  assertEquals(is.false(1 != 1), true);
+  assertEquals(is.false("false"), true);
+  assertEquals(is.false(1 == 0), true);
+  assertEquals(is.false(null), false);
+});
+
+Deno.test("is.between / is.not.between", () => {
+  assertEquals(is.between(5, 1, 10), true);
+  assertEquals(is.between(15, 1, 10), false);
+  assertEquals(is.not.between(15, 1, 10), true);
+  assertEquals(is.not.between(5, 1, 10), false);
+});
+
+Deno.test("is.greater / is.less", () => {
+  assertEquals(is.greater(10, 5), true);
+  assertEquals(is.less(3, 4), true);
+});
+
+Deno.test("is.oneOf", () => {
+  assertEquals(is.oneOf("apple", ["apple", "banana"]), true);
+  assertEquals(is.oneOf("pear", ["apple", "banana"]), false);
+});
+