Add 'any' and 'unknown' type definitions with corresponding tests

lib/forgeTypes/any.ts

@@ -0,0 +1,14 @@
+import { baseForgeType } from '../baseForgeType';
+import type { BaseForgeType } from '../types';
+
+export const any = (): BaseForgeType<
+    { _: unknown },
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    { type: any; optional: true; nullable: true; _: true }
+> => {
+    return baseForgeType({
+        isOptional: true,
+        isNullable: true,
+        queue: []
+    });
+};

lib/forgeTypes/unknown.ts

@@ -0,0 +1,13 @@
+import { baseForgeType } from '../baseForgeType';
+import type { BaseForgeType } from '../types';
+
+export const unknown = (): BaseForgeType<
+    { _: unknown },
+    { type: unknown; optional: true; nullable: true; _: true }
+> => {
+    return baseForgeType({
+        isOptional: true,
+        isNullable: true,
+        queue: []
+    });
+};

lib/index.ts

@@ -1,10 +1,12 @@
+import { any } from './forgeTypes/any';
 import { array } from './forgeTypes/array';
 import { boolean } from './forgeTypes/boolean';
 import { number } from './forgeTypes/number';
 import { object } from './forgeTypes/object';
 import { string } from './forgeTypes/string';
+import { unknown } from './forgeTypes/unknown';
 
-const f = { array, boolean, number, object, string };
+const f = { any, array, boolean, number, object, string, unknown };
 
-export { array, boolean, number, object, string };
+export { any, array, boolean, number, object, string, unknown };
 export default f;

test/any.test.ts

@@ -0,0 +1,18 @@
+import { describe, it, expect } from 'vitest';
+import f from '../lib';
+
+describe('any', () => {
+    it('should succeed for any value', async () => {
+        expect((await f.any().forge(123)).success).toBe(true);
+        expect((await f.any().forge('abc')).success).toBe(true);
+        expect((await f.any().forge(null)).success).toBe(true);
+        expect((await f.any().forge(undefined)).success).toBe(true);
+        expect((await f.any().forge({})).success).toBe(true);
+    });
+
+    it('should support check method', async () => {
+        const schema = f.any().check((v) => typeof v === 'number');
+        expect((await schema.forge(42)).success).toBe(true);
+        expect((await schema.forge('not a number')).success).toBe(false);
+    });
+});

test/unknown.test.ts

@@ -0,0 +1,18 @@
+import { describe, it, expect } from 'vitest';
+import f from '../lib';
+
+describe('unknown', () => {
+    it('should succeed for any value', async () => {
+        expect((await f.unknown().forge(123)).success).toBe(true);
+        expect((await f.unknown().forge('abc')).success).toBe(true);
+        expect((await f.unknown().forge(null)).success).toBe(true);
+        expect((await f.unknown().forge(undefined)).success).toBe(true);
+        expect((await f.unknown().forge({})).success).toBe(true);
+    });
+
+    it('should support check method', async () => {
+        const schema = f.unknown().check((v) => typeof v === 'string');
+        expect((await schema.forge('hello')).success).toBe(true);
+        expect((await schema.forge(123)).success).toBe(false);
+    });
+});