Added number range

validators/number.test.ts

@@ -1,4 +1,4 @@
-import { isNumber, isInteger } from "./number.ts";
+import { isNumber, isInteger, isInRange, hasParity } from "./number.ts";
 import { validate } from "../mod.ts";
 import {
   assertEquals,
@@ -79,3 +79,94 @@ Deno.test("isInteger (no match)", async () => {
     String(NaN),
   );
 });
+
+Deno.test("isInRange (match)", async () => {
+  const values: [number[], object][] = [
+    [[10.5, 11], { greaterThan: 10 }],
+    [[10, 10.5, 11], { greaterThanOrEqualTo: 10 }],
+    [[10], { equalTo: 10 }],
+    [[9.5, 9], { lessThan: 10 }],
+    [[10, 9.5, 9], { lessThanOrEqualTo: 10 }],
+    [[11, 11.5], { greaterThan: 10, lessThan: 12 }],
+    [[10, 11, 11.5], { greaterThanOrEqualTo: 10, lessThan: 12 }],
+    [[NaN], { allowNaN: true }],
+  ];
+  for (const [vals, options] of values) {
+    for (const value of vals) {
+      assertEquals(
+        await validate(value, isInRange(options)),
+        [],
+        `${String(value)} - ${JSON.stringify(options)}`,
+      );
+    }
+  }
+});
+
+Deno.test("isInRange (no match)", async () => {
+  const values: [number[], any][] = [
+    [[8.5, 9, 10], { greaterThan: 10 }],
+    [[8.5, 9], { greaterThanOrEqualTo: 10 }],
+    [[9, 9.5, 11], { equalTo: 10 }],
+    [[10, 10.5, 11], { lessThan: 10 }],
+    [[10.5, 11], { lessThanOrEqualTo: 10 }],
+    [[9.5, 10, 12, 13], { greaterThan: 10, lessThan: 12 }],
+    [[9.5, 12, 13], { greaterThanOrEqualTo: 10, lessThan: 12 }],
+    [[NaN], { allowNaN: false }],
+    [[NaN], {}],
+  ];
+  for (const [vals, options] of values) {
+    for (const value of vals) {
+      assertNotEquals(
+        await validate(value, isInRange(options)),
+        [],
+        `${String(value)} - ${JSON.stringify(options)}`,
+      );
+    }
+  }
+});
+
+Deno.test("hasParity (match)", async () => {
+  const values: [number[], object][] = [
+    [[-2, -1, 0, 1, 2, 3, 4, 5, 6], {}],
+    [[-2, 0, 2, 4, 6], { odd: false }],
+    [[-1, 1, 3, 5], { even: false }],
+    [[0, 3, 6], { divisibleBy: 3 }],
+    [[], { odd: false, even: false }],
+    [[0, 6], { odd: false, divisibleBy: 3 }],
+    [[3], { even: false, divisibleBy: 3 }],
+    [[NaN], { allowNaN: true }],
+  ];
+  for (const [vals, options] of values) {
+    for (const value of vals) {
+      assertEquals(
+        await validate(value, hasParity(options)),
+        [],
+        `${String(value)} - ${JSON.stringify(options)}`,
+      );
+    }
+  }
+});
+
+Deno.test("hasParity (no match)", async () => {
+  const values: [number[], any][] = [
+    [[], {}],
+    [[-1, 1, 3, 5], { odd: false }],
+    [[-2, 0, 2, 4, 6], { even: false }],
+    [[-2, -1, 1, 2, 4, 5], { divisibleBy: 3 }],
+    [[-2, -1, 0, 1, 2, 3, 4, 5, 6], { odd: false, even: false }],
+    [[-2, -1, 1, 2, 3, 4, 5], { odd: false, divisibleBy: 3 }],
+    [[-2, -1, 0, 1, 2, 4, 5, 6], { even: false, divisibleBy: 3 }],
+    [[NaN], { allowNaN: false }],
+    [[NaN], {}],
+    [[0.5], {}],
+  ];
+  for (const [vals, options] of values) {
+    for (const value of vals) {
+      assertNotEquals(
+        await validate(value, hasParity(options)),
+        [],
+        `${String(value)} - ${JSON.stringify(options)}`,
+      );
+    }
+  }
+});

validators/number.ts

@@ -35,3 +35,83 @@ export function isInteger(
     },
   };
 }
+
+export function isInRange(
+  {
+    allowNaN = false,
+    greaterThan = undefined,
+    greaterThanOrEqualTo = undefined,
+    equalTo = undefined,
+    lessThan = undefined,
+    lessThanOrEqualTo = undefined,
+  }: {
+    allowNaN?: boolean;
+    greaterThan?: number;
+    greaterThanOrEqualTo?: number;
+    equalTo?: number;
+    lessThan?: number;
+    lessThanOrEqualTo?: number;
+  } = {},
+): Validator {
+  return {
+    type: "isInRange",
+    extends: [isNumber({ allowNaN })],
+    check: (value: any) => {
+      if (value === null || value === undefined) return;
+      if (allowNaN && Number.isNaN(value)) return;
+      if (greaterThan !== undefined && value <= greaterThan) {
+        return { range: "greaterThan" };
+      }
+      if (greaterThanOrEqualTo !== undefined && value < greaterThanOrEqualTo) {
+        return { range: "greaterThanOrEqualTo" };
+      }
+      if (equalTo !== undefined && value !== equalTo) {
+        return { range: "equalTo" };
+      }
+      if (lessThan !== undefined && value >= lessThan) {
+        return { range: "lessThan" };
+      }
+      if (lessThanOrEqualTo !== undefined && value > lessThanOrEqualTo) {
+        return { range: "lessThanOrEqualTo" };
+      }
+    },
+    message: (value: any, args?: Args) => {
+      return `This value is not in the given range.`;
+    },
+  };
+}
+
+export function hasParity(
+  {
+    allowNaN = false,
+    odd = true,
+    even = true,
+    divisibleBy = undefined,
+  }: {
+    allowNaN?: boolean;
+    odd?: boolean;
+    even?: boolean;
+    divisibleBy?: number;
+  } = {},
+): Validator {
+  return {
+    type: "hasParity",
+    extends: [isInteger({ allowNaN })],
+    check: (value: any) => {
+      if (value === null || value === undefined) return;
+      if (allowNaN && Number.isNaN(value)) return;
+      if (!odd && Math.abs(value % 2) == 1) {
+        return { partity: "odd" };
+      }
+      if (!even && value % 2 == 0) {
+        return { partity: "even" };
+      }
+      if (divisibleBy !== undefined && (value % divisibleBy !== 0)) {
+        return { divisibleBy: "divisibleBy" };
+      }
+    },
+    message: (value: any, args?: Args) => {
+      return `This value is not in the given range.`;
+    },
+  };
+}