@wopjs/cast 0.1.6 → 0.1.8

package/src/is-to-as.test.ts

@@ -1,3 +1,5 @@
+import type { PlainObject } from ".";
+
 import { describe, it, expect } from "vitest";
 
 import {
@@ -7,6 +9,7 @@ import {
   asTrue,
   isTruthy,
   isFalsy,
+  toFalsy,
   isBoolean,
   toBoolean,
   isNumber,
@@ -24,6 +27,7 @@ import {
   asArray,
   toNonEmptyArray,
   isObject,
+  toObject,
   asObject,
   isPlainObject,
   toPlainObject,
@@ -37,6 +41,8 @@ import {
   toTruthy,
 } from ".";
 
+const castType = <T>(x: T): T => x;
+
 describe("primitive.ts", () => {
   it("isDefined", () => {
     expect(isDefined(1)).toBe(true);
@@ -65,6 +71,33 @@ describe("primitive.ts", () => {
     expect(isTruthy(true)).toBe(true);
     expect(isTruthy(false)).toBe(false);
     expect(isTruthy(1)).toBe(true);
+
+    {
+      // Type narrowing - excludes falsy from union
+      const val = castType<string | null | undefined>("hello");
+      if (isTruthy(val)) {
+        const check: string = val;
+        expect(check).toBe("hello");
+      }
+    }
+
+    {
+      // Type narrowing - excludes all falsy types
+      const val = castType<number | false | null | undefined | "" | 0>(42);
+      if (isTruthy(val)) {
+        const check: number = val;
+        expect(check).toBe(42);
+      }
+    }
+
+    {
+      // Type narrowing - narrows boolean to true
+      const val = castType<boolean>(true);
+      if (isTruthy(val)) {
+        const check: true = val;
+        expect(check).toBe(true);
+      }
+    }
   });
 
   it("toTruthy", () => {
@@ -87,6 +120,71 @@ describe("primitive.ts", () => {
     expect(isFalsy(true)).toBe(false);
     expect(isFalsy(false)).toBe(true);
     expect(isFalsy(1)).toBe(false);
+
+    {
+      // Type narrowing - extracts falsy from union
+      const val = castType<string | null | undefined>(null);
+      if (isFalsy(val)) {
+        const check: null | undefined = val;
+        expect(check).toBe(null);
+      }
+    }
+
+    {
+      // Type narrowing - extracts all falsy types
+      const val = castType<number | false | null | undefined | "" | 0>(0);
+      if (isFalsy(val)) {
+        const check: false | null | undefined | "" | 0 = val;
+        expect(check).toBe(0);
+      }
+    }
+
+    {
+      // Type narrowing - narrows boolean to false
+      const val = castType<boolean>(false);
+      if (isFalsy(val)) {
+        const check: false = val;
+        expect(check).toBe(false);
+      }
+    }
+  });
+
+  it("toFalsy", () => {
+    expect(toFalsy(false)).toBe(false);
+    expect(toFalsy(null)).toBe(null);
+    expect(toFalsy(undefined)).toBe(undefined);
+    expect(toFalsy(0)).toBe(0);
+    expect(toFalsy("")).toBe("");
+    expect(toFalsy(true)).toBe(undefined);
+    expect(toFalsy(1)).toBe(undefined);
+    expect(toFalsy("hello")).toBe(undefined);
+
+    {
+      // Type narrowing - extracts falsy from union
+      const val = castType<string | null | undefined>(null);
+      const result = toFalsy(val);
+      if (result !== undefined) {
+        const check: "" | null = result;
+        expect(check).toBe(null);
+      }
+    }
+
+    {
+      // Type narrowing - returns undefined for truthy value
+      const val = castType<string | null>("hello");
+      const result: "" | null | undefined = toFalsy(val);
+      expect(result).toBe(undefined);
+    }
+
+    {
+      // Type narrowing - extracts falsy from number union
+      const val = castType<number | false>(0);
+      const result = toFalsy(val);
+      if (result !== undefined) {
+        const check: 0 | false = result;
+        expect(check).toBe(0);
+      }
+    }
   });
 
   it("isBoolean", () => {
@@ -153,46 +251,58 @@ describe("primitive.ts", () => {
     expect(isArray([])).toBe(true);
     expect(isArray({})).toBe(false);
 
-    // Type narrowing - preserves array type
-    const stringArr: string[] = ["a", "b"];
-    if (isArray(stringArr)) {
-      const _check: string[] = stringArr;
-      expect(_check).toBe(stringArr);
+    {
+      // Type narrowing - preserves array type
+      const arr = castType<string[]>(["a", "b"]);
+      if (isArray(arr)) {
+        const check: string[] = arr;
+        expect(check).toBe(arr);
+      }
     }
 
-    // Type narrowing - extracts array from union
-    const unionValue: string | string[] = ["a"];
-    if (isArray(unionValue)) {
-      const _check: string[] = unionValue;
-      expect(_check).toBe(unionValue);
+    {
+      // Type narrowing - extracts array from union
+      const arr = castType<string | string[]>(["a"]);
+      if (isArray(arr)) {
+        const check: string[] = arr;
+        expect(check).toBe(arr);
+      }
     }
 
-    // Type narrowing - preserves readonly array
-    const readonlyArr: readonly number[] = [1, 2];
-    if (isArray(readonlyArr)) {
-      const _check: readonly number[] = readonlyArr;
-      expect(_check).toBe(readonlyArr);
+    {
+      // Type narrowing - preserves readonly array
+      const arr = castType<readonly number[]>([1, 2]);
+      if (isArray(arr)) {
+        const check: readonly number[] = arr;
+        expect(check).toBe(arr);
+      }
     }
 
-    // Type narrowing - preserves tuple
-    const tuple: [string, number] = ["a", 1];
-    if (isArray(tuple)) {
-      const _check: [string, number] = tuple;
-      expect(_check).toBe(tuple);
+    {
+      // Type narrowing - preserves tuple
+      const arr = castType<[string, number]>(["a", 1]);
+      if (isArray(arr)) {
+        const check: [string, number] = arr;
+        expect(check).toBe(arr);
+      }
     }
 
-    // Type narrowing - unknown input returns any[] | undefined
-    const unknownValue: unknown = ["a", "b"];
-    if (isArray(unknownValue)) {
-      const _check: unknown[] = unknownValue;
-      expect(_check).toEqual(["a", "b"]);
+    {
+      // Type narrowing - unknown input returns any[] | undefined
+      const arr = castType<unknown>(["a", "b"]);
+      if (isArray(arr)) {
+        const check: unknown[] = arr;
+        expect(check).toEqual(["a", "b"]);
+      }
     }
 
-    // Type narrowing - non-array type (string) returns string & any[] | undefined
-    const stringValue: string = "hello";
-    if (isArray(stringValue)) {
-      const _check: unknown[] = stringValue;
-      expect(_check).toBe(undefined);
+    {
+      // Type narrowing - non-array type (string) returns string & any[] | undefined
+      const arr = castType<string>("hello");
+      if (isArray(arr)) {
+        const check: unknown[] = arr;
+        expect(check).toBe(undefined);
+      }
     }
   });
 
@@ -200,47 +310,69 @@ describe("primitive.ts", () => {
     expect(toArray([])).toEqual([]);
     expect(toArray({})).toBe(undefined);
 
-    // Type narrowing - preserves array type
-    const stringArr: string[] = ["a", "b"];
-    const result1 = toArray(stringArr);
-    if (result1) {
-      const _check: string[] = result1;
-      expect(_check).toBe(stringArr);
+    {
+      // Type narrowing - preserves array type
+      const arr = castType<string[]>(["a", "b"]);
+      const result = toArray(arr);
+      if (result) {
+        const check: string[] = result;
+        expect(check).toBe(arr);
+      }
+    }
+
+    {
+      // Type narrowing - extracts array from union
+      const arr = castType<string | string[]>(["a"]);
+      const result = toArray(arr);
+      if (result) {
+        const check: string[] = result;
+        expect(check).toBe(arr);
+      }
     }
 
-    // Type narrowing - extracts array from union
-    const unionValue: string | string[] = ["a"];
-    const result2 = toArray(unionValue);
-    if (result2) {
-      const _check: string[] = result2;
-      expect(_check).toBe(unionValue);
+    {
+      // Type narrowing - extracts array from array | undefined union
+      const arr = castType<string[] | undefined>(["a"]);
+      const result = toArray(arr);
+      if (result) {
+        const check: string[] = result;
+        expect(check).toEqual(["a"]);
+      }
     }
 
-    // Type narrowing - preserves readonly array
-    const readonlyArr: readonly number[] = [1, 2];
-    const result3 = toArray(readonlyArr);
-    if (result3) {
-      const _check: readonly number[] = result3;
-      expect(_check).toBe(readonlyArr);
+    {
+      // Type narrowing - preserves readonly array
+      const arr = castType<readonly number[]>([1, 2]);
+      const result = toArray(arr);
+      if (result) {
+        const check: readonly number[] = result;
+        expect(check).toBe(arr);
+      }
     }
 
-    // Type narrowing - preserves tuple
-    const tuple: [string, number] = ["a", 1];
-    const result4 = toArray(tuple);
-    if (result4) {
-      const _check: [string, number] = result4;
-      expect(_check).toBe(tuple);
+    {
+      // Type narrowing - preserves tuple
+      const arr = castType<[string, number]>(["a", 1]);
+      const result = toArray(arr);
+      if (result) {
+        const check: [string, number] = result;
+        expect(check).toBe(arr);
+      }
     }
 
-    // Type narrowing - unknown input returns unknown[] | undefined
-    const unknownValue: unknown = ["a", "b"];
-    const result5: unknown[] | undefined = toArray(unknownValue);
-    expect(result5).toEqual(["a", "b"]);
+    {
+      // Type narrowing - unknown input returns unknown[] | undefined
+      const arr = castType<unknown>(["a", "b"]);
+      const result: unknown[] | undefined = toArray(arr);
+      expect(result).toEqual(["a", "b"]);
+    }
 
-    // Type narrowing - non-array type (string) returns unknown[] | undefined
-    const stringValue: string = "hello";
-    const result6: unknown[] | undefined = toArray(stringValue);
-    expect(result6).toBe(undefined);
+    {
+      // Type narrowing - non-array type (string) returns unknown[] | undefined
+      const arr = castType<string>("hello");
+      const result: unknown[] | undefined = toArray(arr);
+      expect(result).toBe(undefined);
+    }
   });
 
   it("isNonEmptyArray", () => {
@@ -253,75 +385,88 @@ describe("primitive.ts", () => {
     expect(isNonEmptyArray(undefined)).toBe(false);
     expect(isNonEmptyArray("string")).toBe(false);
 
-    // Type narrowing - preserves array type
-    const stringArr: string[] = ["a", "b"];
-    if (isNonEmptyArray(stringArr)) {
-      const _check: string[] = stringArr;
-      expect(_check).toBe(stringArr);
-    } else {
-      const _check: never = stringArr;
-      throw new Error("Unreachable");
-    }
-
-    // Type narrowing - extracts array from union
-    const unionValue: string | string[] = ["a"];
-    if (isNonEmptyArray(unionValue)) {
-      const _check: string[] = unionValue;
-      expect(_check).toBe(unionValue);
-    } else {
-      const _check: string = unionValue;
-      throw new Error("Unreachable");
-    }
-
-    // Type narrowing - extracts array from union
-    const stringLikeValue: string | string[] = "a";
-    if (isNonEmptyArray(stringLikeValue)) {
-      // @ts-expect-error Unreachable
-      const _check: string[] = stringLikeValue;
-      throw new Error("Unreachable");
-    } else {
-      const _check: string = stringLikeValue;
-      expect(_check).toBe(stringLikeValue);
-    }
-
-    // Type narrowing - preserves readonly array
-    const readonlyArr: readonly number[] = [1, 2];
-    if (isNonEmptyArray(readonlyArr)) {
-      const _check: readonly number[] = readonlyArr;
-      expect(_check).toBe(readonlyArr);
-    } else {
-      const _check: readonly number[] = readonlyArr;
-      throw new Error("Unreachable");
-    }
-
-    // Type narrowing - preserves tuple
-    const tuple: [string, number] = ["a", 1];
-    if (isNonEmptyArray(tuple)) {
-      const _check: [string, number] = tuple;
-      expect(_check).toBe(tuple);
-    } else {
-      const _check: never = tuple;
-      throw new Error("Unreachable");
-    }
-
-    // Type narrowing - unknown input returns unknown[]
-    const unknownValue: unknown = ["a", "b"];
-    if (isNonEmptyArray(unknownValue)) {
-      const _check: unknown[] = unknownValue;
-      expect(_check).toEqual(["a", "b"]);
-    } else {
-      const _check: unknown = unknownValue;
-      throw new Error("Unreachable");
-    }
-
-    // Type narrowing - non-array type (string) returns never
-    const stringValue: string = "hello";
-    if (isNonEmptyArray(stringValue)) {
-      const _check: unknown[] = stringValue;
-      throw new Error("Unreachable");
-    } else {
-      const _check: string = stringValue;
-      expect(_check).toBe("hello");
+    {
+      // Type narrowing - preserves array type
+      const arr = castType<string[]>(["a", "b"]);
+      if (isNonEmptyArray(arr)) {
+        const check: string[] = arr;
+        expect(check).toBe(arr);
+      } else {
+        const _check: never = arr;
+        throw new Error("Unreachable");
+      }
+    }
+
+    {
+      // Type narrowing - extracts array from union
+      const arr = castType<string | string[]>(["a"]);
+      if (isNonEmptyArray(arr)) {
+        const check: string[] = arr;
+        expect(check).toBe(arr);
+      } else {
+        const _check: string = arr;
+        throw new Error("Unreachable");
+      }
+    }
+
+    {
+      // Type narrowing - extracts array from union
+      const arr = castType<string | string[]>("a");
+      if (isNonEmptyArray(arr)) {
+        const _check: string[] = arr;
+        throw new Error("Unreachable");
+      } else {
+        const check: string = arr;
+        expect(check).toBe(arr);
+      }
+    }
+
+    {
+      // Type narrowing - preserves readonly array
+      const arr = castType<readonly number[]>([1, 2]);
+      if (isNonEmptyArray(arr)) {
+        const check: readonly number[] = arr;
+        expect(check).toBe(arr);
+      } else {
+        const _check: readonly number[] = arr;
+        throw new Error("Unreachable");
+      }
+    }
+
+    {
+      // Type narrowing - preserves tuple
+      const arr = castType<[string, number]>(["a", 1]);
+      if (isNonEmptyArray(arr)) {
+        const check: [string, number] = arr;
+        expect(check).toBe(arr);
+      } else {
+        const _check: never = arr;
+        throw new Error("Unreachable");
+      }
+    }
+
+    {
+      // Type narrowing - unknown input returns unknown[]
+      const arr = castType<unknown>(["a", "b"]);
+      if (isNonEmptyArray(arr)) {
+        const check: unknown[] = arr;
+        expect(check).toEqual(["a", "b"]);
+      } else {
+        const _check: unknown = arr;
+        throw new Error("Unreachable");
+      }
+    }
+
+    {
+      // Type narrowing - non-array type (string) returns never
+      const arr = castType<string>("hello");
+      if (isNonEmptyArray(arr)) {
+        const _check: unknown[] = arr;
+        throw new Error("Unreachable");
+      } else {
+        const check: string = arr;
+        expect(check).toBe("hello");
+      }
     }
   });
 
@@ -329,139 +474,527 @@ describe("primitive.ts", () => {
     expect(asArray([])).toEqual([]);
     expect(asArray({})).toEqual([]);
 
-    // Type narrowing - preserves array type
-    const stringArr: string[] = ["a", "b"];
-    const result1: string[] = asArray(stringArr);
-    expect(result1).toBe(stringArr);
+    {
+      // Type narrowing - preserves array type
+      const arr = castType<string[]>(["a", "b"]);
+      const result: string[] = asArray(arr);
+      expect(result).toBe(arr);
+    }
 
-    // Type narrowing - extracts array from union
-    const unionValue: string | string[] = ["a"];
-    const result2: string[] = asArray(unionValue);
-    expect(result2).toEqual(["a"]);
+    {
+      // Type narrowing - extracts array from union
+      const arr = castType<string | string[]>(["a"]);
+      const result: string[] = asArray(arr);
+      expect(result).toEqual(["a"]);
+    }
 
-    // Type narrowing - preserves readonly array
-    const readonlyArr: readonly number[] = [1, 2];
-    const result3: readonly number[] = asArray(readonlyArr);
-    expect(result3).toBe(readonlyArr);
+    {
+      // Type narrowing - preserves readonly array
+      const arr = castType<readonly number[]>([1, 2]);
+      const result: readonly number[] = asArray(arr);
+      expect(result).toBe(arr);
+    }
 
-    // Type narrowing - preserves tuple
-    const tuple: [string, number] = ["a", 1];
-    const result4: [string, number] = asArray(tuple);
-    expect(result4).toBe(tuple);
+    {
+      // Type narrowing - preserves tuple
+      const arr = castType<[string, number]>(["a", 1]);
+      const result: [string, number] = asArray(arr);
+      expect(result).toBe(arr);
+    }
 
-    // Type narrowing - unknown input returns unknown[]
-    const unknownValue: unknown = ["a", "b"];
-    const result5: unknown[] = asArray(unknownValue);
-    expect(result5).toEqual(["a", "b"]);
+    {
+      // Type narrowing - unknown input returns unknown[]
+      const arr = castType<unknown>(["a", "b"]);
+      const result: unknown[] = asArray(arr);
+      expect(result).toEqual(["a", "b"]);
+    }
 
-    // Type narrowing - non-array type (string) returns unknown[]
-    const stringValue: string = "hello";
-    const result6: unknown[] = asArray(stringValue);
-    expect(result6).toEqual([]);
+    {
+      // Type narrowing - non-array type (string) returns unknown[]
+      const arr = castType<string>("hello");
+      const result: unknown[] = asArray(arr);
+      expect(result).toEqual([]);
+    }
   });
 
   it("toNonEmptyArray", () => {
     expect(toNonEmptyArray([1])).toEqual([1]);
     expect(toNonEmptyArray([])).toBe(undefined);
 
-    // Type narrowing - preserves array type
-    const stringArr: string[] = ["a", "b"];
-    const result1 = toNonEmptyArray(stringArr);
-    if (result1) {
-      const _check: string[] = result1;
-      expect(_check).toBe(stringArr);
+    {
+      // Type narrowing - preserves array type
+      const arr = castType<string[]>(["a", "b"]);
+      const result = toNonEmptyArray(arr);
+      if (result) {
+        const check: string[] = result;
+        expect(check).toBe(arr);
+      }
     }
 
-    // Type narrowing - extracts array from union
-    const unionValue: string | string[] = ["a"];
-    const result2 = toNonEmptyArray(unionValue);
-    if (result2) {
-      const _check: string[] = result2;
-      expect(_check).toBe(unionValue);
+    {
+      // Type narrowing - extracts array from union
+      const arr = castType<string | string[]>(["a"]);
+      const result = toNonEmptyArray(arr);
+      if (result) {
+        const check: string[] = result;
+        expect(check).toBe(arr);
+      }
     }
 
-    // Type narrowing - preserves readonly array
-    const readonlyArr: readonly number[] = [1, 2];
-    const result3 = toNonEmptyArray(readonlyArr);
-    if (result3) {
-      const _check: readonly number[] = result3;
-      expect(_check).toBe(readonlyArr);
+    {
+      // Type narrowing - preserves readonly array
+      const arr = castType<readonly number[]>([1, 2]);
+      const result = toNonEmptyArray(arr);
+      if (result) {
+        const check: readonly number[] = result;
+        expect(check).toBe(arr);
+      }
     }
 
-    // Type narrowing - preserves tuple
-    const tuple: [string, number] = ["a", 1];
-    const result4 = toNonEmptyArray(tuple);
-    if (result4) {
-      const _check: [string, number] = result4;
-      expect(_check).toBe(tuple);
+    {
+      // Type narrowing - preserves tuple
+      const arr = castType<[string, number]>(["a", 1]);
+      const result = toNonEmptyArray(arr);
+      if (result) {
+        const check: [string, number] = result;
+        expect(check).toBe(arr);
+      }
     }
 
-    // Type narrowing - unknown input returns unknown[] | undefined
-    const unknownValue: unknown = ["a", "b"];
-    const result5: unknown[] | undefined = toNonEmptyArray(unknownValue);
-    expect(result5).toEqual(["a", "b"]);
+    {
+      // Type narrowing - unknown input returns unknown[]
+      const arr = castType<unknown>(["a", "b"]);
+      let result = toNonEmptyArray(arr);
+      if (result) {
+        // rule out never
+        let check = result;
+        check = castType<unknown[]>(result);
+        expect(check).toEqual(["a", "b"]);
+      }
+    }
 
-    // Type narrowing - non-array type (string) returns unknown[] | undefined
-    const stringValue: string = "hello";
-    const result6: unknown[] | undefined = toNonEmptyArray(stringValue);
-    expect(result6).toBe(undefined);
+    {
+      // Type narrowing - non-array type (string) returns unknown[] | undefined
+      const arr = castType<string>("hello");
+      const result = toNonEmptyArray(arr);
+      expect(result).toBe(undefined);
+      if (result) {
+        // rule out never
+        let _check = result;
+        _check = castType<unknown[]>(result);
+        throw new Error("Unreachable");
+      }
+    }
   });
 
   it("isObject", () => {
     expect(isObject({})).toBe(true);
     expect(isObject([])).toBe(true);
     expect(isObject(null)).toBe(false);
+
+    {
+      // Type narrowing - preserves object type
+      const obj = castType<{ a: string }>({ a: "hello" });
+      if (isObject(obj)) {
+        const check: { a: string } = obj;
+        expect(check).toBe(obj);
+      }
+    }
+
+    {
+      // Type narrowing - extracts object from union
+      const obj = castType<string | { a: string }>({ a: "hello" });
+      if (isObject(obj)) {
+        const check: object = obj;
+        expect(check).toEqual({ a: "hello" });
+      }
+    }
+
+    {
+      // Type narrowing - arrays are objects
+      const arr = castType<string[]>(["a", "b"]);
+      if (isObject(arr)) {
+        const check: string[] = arr;
+        expect(check).toBe(arr);
+      }
+    }
+
+    {
+      // Type narrowing - unknown input narrows to object
+      const obj = castType<unknown>({ a: 1 });
+      if (isObject(obj)) {
+        const check: object = obj;
+        expect(check).toEqual({ a: 1 });
+      }
+    }
+
+    {
+      // Type narrowing - null | object union extracts object
+      const obj = castType<null | { x: number }>({ x: 42 });
+      if (isObject(obj)) {
+        const check: { x: number } = obj;
+        expect(check).toEqual({ x: 42 });
+      }
+    }
+  });
+
+  it("toObject", () => {
+    expect(toObject({})).toEqual({});
+    expect(toObject([])).toEqual([]);
+    expect(toObject(null)).toBe(undefined);
+
+    {
+      // Type narrowing - preserves object type
+      const obj = castType<{ a: string }>({ a: "hello" });
+      const result = toObject(obj);
+      if (result) {
+        const check: { a: string } = result;
+        expect(check).toBe(obj);
+      }
+    }
+
+    {
+      // Type narrowing - extracts object from union
+      const obj = castType<string | { a: string }>({ a: "hello" });
+      const result = toObject(obj);
+      if (result) {
+        const check: { a: string } = result;
+        expect(check).toEqual({ a: "hello" });
+      }
+    }
+
+    {
+      // Type narrowing - preserves array (arrays are objects)
+      const arr = castType<string[]>(["a", "b"]);
+      const result = toObject(arr);
+      if (result) {
+        const check: string[] = result;
+        expect(check).toBe(arr);
+      }
+    }
+
+    {
+      // Type narrowing - unknown input returns object | undefined
+      const obj = castType<unknown>({ a: 1 });
+      const result: object | undefined = toObject(obj);
+      expect(result).toEqual({ a: 1 });
+    }
+
+    {
+      // Type narrowing - non-object type (string) returns undefined
+      const obj = castType<string>("hello");
+      const result: object | undefined = toObject(obj);
+      expect(result).toBe(undefined);
+    }
+
+    {
+      // Type narrowing - null | object union extracts object
+      const obj = castType<null | { x: number }>({ x: 42 });
+      const result = toObject(obj);
+      if (result) {
+        const check: { x: number } = result;
+        expect(check).toEqual({ x: 42 });
+      }
+    }
   });
 
   it("asObject", () => {
     expect(asObject({})).toEqual({});
     expect(asObject([])).toEqual([]);
     expect(asObject(null)).toEqual({});
+
+    {
+      // Type narrowing - preserves object type
+      const obj = castType<{ a: string }>({ a: "hello" });
+      const result: { a: string } = asObject(obj);
+      expect(result).toBe(obj);
+    }
+
+    {
+      // Type narrowing - extracts object from union
+      const obj = castType<string | { a: string }>({ a: "hello" });
+      const result: { a: string } = asObject(obj);
+      expect(result).toEqual({ a: "hello" });
+    }
+
+    {
+      // Type narrowing - preserves array (arrays are objects)
+      const arr = castType<string[]>(["a", "b"]);
+      const result: string[] = asObject(arr);
+      expect(result).toBe(arr);
+    }
+
+    {
+      // Type narrowing - unknown input returns object
+      const obj = castType<unknown>({ a: 1 });
+      const result: object = asObject(obj);
+      expect(result).toEqual({ a: 1 });
+    }
+
+    {
+      // Type narrowing - non-object type (string) returns object
+      const obj = castType<string>("hello");
+      const result: object = asObject(obj);
+      expect(result).toEqual({});
+    }
+
+    {
+      // Type narrowing - null | object union extracts object
+      const obj = castType<null | { x: number }>({ x: 42 });
+      const result: { x: number } = asObject(obj);
+      expect(result).toEqual({ x: 42 });
+    }
   });
 
   it("isPlainObject", () => {
     expect(isPlainObject({})).toBe(true);
     expect(isPlainObject([])).toBe(false);
     expect(isPlainObject(null)).toBe(false);
+
+    {
+      // Type narrowing - unknown input narrows to PlainObject
+      const obj = castType<unknown>({ a: 1 });
+      if (isPlainObject(obj)) {
+        const check: PlainObject = obj;
+        expect(check).toEqual({ a: 1 });
+      }
+    }
+
+    {
+      // Type narrowing - excludes array from union
+      const obj = castType<{ a: number } | number[]>({ a: 1 });
+      if (isPlainObject(obj)) {
+        const check: PlainObject = obj;
+        expect(check).toEqual({ a: 1 });
+      }
+    }
+
+    {
+      // Type narrowing - null | object union extracts PlainObject
+      const obj = castType<null | { x: number }>({ x: 42 });
+      if (isPlainObject(obj)) {
+        const check: { x: number } = obj;
+        expect(check).toEqual({ x: 42 });
+      }
+    }
   });
 
   it("toPlainObject", () => {
     expect(toPlainObject({})).toEqual({});
     expect(toPlainObject([])).toBe(undefined);
     expect(toPlainObject(null)).toBe(undefined);
+
+    {
+      // Type narrowing - unknown input returns PlainObject | undefined
+      const obj = castType<unknown>({ a: 1 });
+      const result: PlainObject | undefined = toPlainObject(obj);
+      expect(result).toEqual({ a: 1 });
+    }
+
+    {
+      // Type narrowing - array returns undefined
+      const arr = castType<number[]>([1, 2]);
+      const result: PlainObject | undefined = toPlainObject(arr);
+      expect(result).toBe(undefined);
+    }
   });
 
   it("asPlainObject", () => {
     expect(asPlainObject({})).toEqual({});
     expect(asPlainObject([])).toEqual({});
     expect(asPlainObject(null)).toEqual({});
+
+    {
+      // Type narrowing - unknown input returns PlainObject
+      const obj = castType<unknown>({ a: 1 });
+      const result: PlainObject = asPlainObject(obj);
+      expect(result).toEqual({ a: 1 });
+    }
+
+    {
+      // Type narrowing - array returns empty object
+      const arr = castType<number[]>([1, 2]);
+      const result: PlainObject = asPlainObject(arr);
+      expect(result).toEqual({});
+    }
+
+    {
+      // Type narrowing - non-object returns empty object
+      const val = castType<string>("hello");
+      const result: PlainObject = asPlainObject(val);
+      expect(result).toEqual({});
+    }
   });
 
   it("isNonEmptyPlainObject", () => {
     expect(isNonEmptyPlainObject({ a: 1 })).toBe(true);
     expect(isNonEmptyPlainObject({})).toBe(false);
     expect(isNonEmptyPlainObject([])).toBe(false);
+
+    {
+      // Type narrowing - unknown input narrows to PlainObject
+      const obj = castType<unknown>({ a: 1 });
+      if (isNonEmptyPlainObject(obj)) {
+        const check: PlainObject = obj;
+        expect(check).toEqual({ a: 1 });
+      }
+    }
+
+    {
+      // Type narrowing - empty object returns false
+      const obj = castType<{ a?: number }>({});
+      if (isNonEmptyPlainObject(obj)) {
+        const check: PlainObject = obj;
+        expect(check).toEqual({});
+      } else {
+        expect(obj).toEqual({});
+      }
+    }
+
+    {
+      // Type narrowing - excludes array
+      const obj = castType<{ a: number } | number[]>({ a: 1 });
+      if (isNonEmptyPlainObject(obj)) {
+        const check: PlainObject = obj;
+        expect(check).toEqual({ a: 1 });
+      }
+    }
   });
 
   it("toNonEmptyPlainObject", () => {
     expect(toNonEmptyPlainObject({ a: 1 })).toEqual({ a: 1 });
     expect(toNonEmptyPlainObject({})).toBe(undefined);
+
+    {
+      // Type narrowing - preserves object type
+      const obj = castType<{ a: number }>({ a: 1 });
+      const result = toNonEmptyPlainObject(obj);
+      if (result) {
+        const check: { a: number } = result;
+        expect(check).toEqual({ a: 1 });
+      }
+    }
+
+    {
+      // Type narrowing - undefined input returns undefined
+      const obj = castType<{ a: number } | undefined>(undefined);
+      const result: { a: number } | undefined = toNonEmptyPlainObject(obj);
+      expect(result).toBe(undefined);
+    }
+
+    {
+      // Type narrowing - empty object returns undefined
+      const obj = castType<{ a?: number }>({});
+      const result = toNonEmptyPlainObject(obj);
+      expect(result).toBe(undefined);
+    }
+
+    {
+      // type narrowing - non-object type returns PlainObject | undefined
+      const obj = castType<number>(42);
+      const result: PlainObject | undefined = toNonEmptyPlainObject(obj);
+      expect(result).toBe(undefined);
+    }
   });
 
   it("isNonEmptyJSONObject", () => {
     expect(isNonEmptyJSONObject({ a: 1 })).toBe(true);
     expect(isNonEmptyJSONObject({})).toBe(false);
     expect(isNonEmptyJSONObject([])).toBe(false);
+    expect(isNonEmptyJSONObject({ a: undefined })).toBe(false);
+
+    {
+      // Type narrowing - unknown input narrows to PlainObject
+      const obj = castType<unknown>({ a: 1 });
+      if (isNonEmptyJSONObject(obj)) {
+        const check: PlainObject = obj;
+        expect(check).toEqual({ a: 1 });
+      }
+    }
+
+    {
+      // Type narrowing - object with only undefined values returns false
+      const obj = castType<{ a?: number }>({ a: undefined });
+      if (isNonEmptyJSONObject(obj)) {
+        const check: PlainObject = obj;
+        expect(check).toEqual({});
+      } else {
+        expect(obj).toEqual({ a: undefined });
+      }
+    }
+
+    {
+      // Type narrowing - excludes array
+      const obj = castType<{ a: number } | number[]>({ a: 1 });
+      if (isNonEmptyJSONObject(obj)) {
+        const check: PlainObject = obj;
+        expect(check).toEqual({ a: 1 });
+      }
+    }
   });
 
   it("toNonEmptyJSONObject", () => {
     expect(toNonEmptyJSONObject({ a: 1 })).toEqual({ a: 1 });
     expect(toNonEmptyJSONObject({})).toBe(undefined);
+
+    {
+      // Type narrowing - preserves object type
+      const obj = castType<{ a: number }>({ a: 1 });
+      const result = toNonEmptyJSONObject(obj);
+      if (result) {
+        const check: { a: number } = result;
+        expect(check).toEqual({ a: 1 });
+      }
+    }
+
+    {
+      // Type narrowing - undefined input returns undefined
+      const obj = castType<{ a: number } | undefined>(undefined);
+      const result: { a: number } | undefined = toNonEmptyJSONObject(obj);
+      expect(result).toBe(undefined);
+    }
+
+    {
+      // Type narrowing - object with only undefined values returns undefined
+      const obj = castType<{ a: number; b?: string }>({ a: undefined as unknown as number });
+      const result = toNonEmptyJSONObject(obj);
+      expect(result).toBe(undefined);
+    }
   });
 
   it("toPlainObjectOf", () => {
     expect(toPlainObjectOf({ a: true, b: false }, isTrue)).toEqual({ a: true });
+    // @ts-expect-error type mismatched
     expect(toPlainObjectOf({ a: 1, b: 2 }, isTrue)).toBe(undefined);
+    expect(toPlainObjectOf({ a: 1, b: 2 }, isTruthy)).toEqual({ a: 1, b: 2 });
+    expect(toPlainObjectOf(undefined, isTrue)).toBe(undefined);
+
+    {
+      // Type narrowing - result type matches predicate
+      const obj = castType<{ a: unknown; b: unknown }>({ a: "hello", b: 123 });
+      const result = toPlainObjectOf(obj, isString);
+      if (result) {
+        const check: { [key: PropertyKey]: string } = result;
+        expect(check).toEqual({ a: "hello" });
+      }
+    }
+
+    {
+      // Type narrowing - filters to number type
+      const obj = castType<{ a: unknown; b: unknown }>({ a: 1, b: "hello" });
+      const result = toPlainObjectOf(obj, isNumber);
+      if (result) {
+        const check: { [key: PropertyKey]: number } = result;
+        expect(check).toEqual({ a: 1 });
+      }
+    }
+
+    {
+      // Type narrowing - returns undefined when no values match
+      const obj = castType<{ a: unknown; b: unknown }>({ a: "hello", b: "world" });
+      const result = toPlainObjectOf(obj, isNumber);
+      expect(result).toBe(undefined);
+    }
   });
 
   it("toPlainObjectOfTrue", () => {