@wopjs/cast 0.1.7 → 0.1.8

package/README.md

@@ -6,7 +6,14 @@
 [![Coverage Status](https://wopjs.github.io/cast/coverage-badges/@wopjs/cast.svg)](https://wopjs.github.io/cast/coverage/)
 [![minified-size](https://img.shields.io/bundlephobia/minzip/@wopjs/cast)](https://bundlephobia.com/package/@wopjs/cast)
 
-Filter types from unknown.
+Type-safe utilities for filtering and coercing `unknown` values in TypeScript.
+
+## Features
+
+- **Three-tier API pattern** (`is`/`to`/`as`) for flexible type filtering
+- **Strong TypeScript type narrowing** that preserves complex types (unions, tuples, readonly arrays)
+- **Zero dependencies** and tree-shakeable
+- **Safe edge case handling** (NaN, null, undefined, circular references)
 
 ## Install
 
@@ -14,22 +21,153 @@ Filter types from unknown.
 npm add @wopjs/cast
 ```
 
-## Usage
+## API Pattern
 
-```js
-import * as c from "@wopjs/cast";
-import { Option } from "@wopjs/tsur";
+Every type has up to three functions following a consistent naming pattern:
+
+| Pattern | Returns          | Use Case                                      |
+| ------- | ---------------- | --------------------------------------------- |
+| `is*`   | `boolean`        | Type guards for conditional narrowing         |
+| `to*`   | `T \| undefined` | Optional values, composable with Option types |
+| `as*`   | `T`              | Always returns valid value with fallback      |
+
+```ts
+import { isNumber, toNumber, asNumber } from "@wopjs/cast";
+
+// is* - Type guard for conditionals
+if (isNumber(value)) {
+  value; // type narrowed to number
+}
+
+// to* - Returns undefined for invalid input
+const num = toNumber(input); // number | undefined
+
+// as* - Always returns a number (0 as fallback)
+const safeNum = asNumber(input); // number
+```
+
+## Type Narrowing
+
+The library preserves and correctly narrows complex TypeScript types:
+
+```ts
+import { isArray, toArray, isTruthy } from "@wopjs/cast";
+
+// Preserves array element types
+const arr: string[] = ["a", "b"];
+if (isArray(arr)) {
+  arr; // still string[], not unknown[]
+}
+
+// Extracts from unions
+const value: string | string[] = getData();
+if (isArray(value)) {
+  value; // narrowed to string[]
+}
+
+// Preserves tuples and readonly arrays
+const tuple: [string, number] = ["a", 1];
+const result = toArray(tuple); // [string, number] | undefined
+
+// Excludes falsy types
+const val: string | null | undefined = "hello";
+if (isTruthy(val)) {
+  val; // narrowed to string
+}
+```
+
+## Available Functions
+
+### Booleans
+
+| Function    | Description                                  |
+| ----------- | -------------------------------------------- |
+| `isTrue`    | Returns `true` if value is exactly `true`    |
+| `toTrue`    | Returns `true` or `undefined`                |
+| `asTrue`    | Returns `true` or `false`                    |
+| `isTruthy`  | Returns `true` if `Boolean(x)` is `true`     |
+| `toTruthy`  | Returns truthy value or `undefined`          |
+| `isFalsy`   | Returns `true` if `Boolean(x)` is `false`    |
+| `toFalsy`   | Returns falsy value or `undefined`           |
+| `isBoolean` | Returns `true` if value is `true` or `false` |
+| `toBoolean` | Returns boolean or `undefined`               |
+
+### Numbers
+
+| Function   | Description                                           |
+| ---------- | ----------------------------------------------------- |
+| `isNumber` | Returns `true` if value is a number (excluding `NaN`) |
+| `toNumber` | Returns number or `undefined`                         |
+| `asNumber` | Returns number or `0`                                 |
+
+### Strings
+
+| Function           | Description                                   |
+| ------------------ | --------------------------------------------- |
+| `isString`         | Returns `true` if value is a string           |
+| `toString`         | Returns string or `undefined`                 |
+| `asString`         | Returns string or `""`                        |
+| `isNonEmptyString` | Returns `true` if value is a non-empty string |
+| `toNonEmptyString` | Returns non-empty string or `undefined`       |
+
+### Arrays
 
-const dataParser = {
-  width: c.toNumber,
-  position: a => Option.from(a, a => a && c.isNumber(a.x) && c.isNumber(a.y)),
-  metadata: c.toNonEmptyPlainObject,
-};
+| Function          | Description                                     |
+| ----------------- | ----------------------------------------------- |
+| `isArray`         | Type guard for arrays (preserves element types) |
+| `toArray`         | Returns array or `undefined`                    |
+| `asArray`         | Returns array or `[]`                           |
+| `isNonEmptyArray` | Type guard for non-empty arrays                 |
+| `toNonEmptyArray` | Returns non-empty array or `undefined`          |
 
-function parseData(data) {
-  const d = c.asObject(data);
-  return Object.fromEntries(Object.keys(dataParser).map(k => [k, Option.unwrapOr(dataParser[k](d[k]))]));
+### Objects
+
+| Function                | Description                                                     |
+| ----------------------- | --------------------------------------------------------------- |
+| `isObject`              | Returns `true` for objects (including arrays, excluding `null`) |
+| `toObject`              | Returns object or `undefined`                                   |
+| `asObject`              | Returns object or `{}`                                          |
+| `isPlainObject`         | Returns `true` for plain objects (excluding arrays)             |
+| `toPlainObject`         | Returns plain object or `undefined`                             |
+| `asPlainObject`         | Returns plain object or `{}`                                    |
+| `isNonEmptyPlainObject` | Returns `true` for objects with at least one key                |
+| `toNonEmptyPlainObject` | Returns non-empty object or `undefined`                         |
+| `isNonEmptyJSONObject`  | Returns `true` for objects with non-undefined values            |
+| `toNonEmptyJSONObject`  | Returns JSON object or `undefined`                              |
+
+### Utilities
+
+| Function              | Description                                |
+| --------------------- | ------------------------------------------ |
+| `isDefined`           | Returns `true` if value is not `undefined` |
+| `toPlainObjectOf`     | Filter object values by type predicate     |
+| `toPlainObjectOfTrue` | Filter object to only `true` values        |
+| `print`               | Safely stringify any value for display     |
+
+## Usage Example
+
+```ts
+import * as c from "@wopjs/cast";
+
+// Parsing unknown API response
+function parseUser(data: unknown) {
+  const obj = c.asPlainObject(data);
+  return {
+    name: c.asString(obj.name),
+    age: c.toNumber(obj.age), // undefined if not a number
+    tags: c.asArray(obj.tags),
+    settings: c.toNonEmptyPlainObject(obj.settings),
+  };
 }
+
+// Filtering object values
+const config = { debug: true, verbose: false, enabled: true };
+c.toPlainObjectOfTrue(config); // { debug: true, enabled: true }
+
+// Safe number handling
+c.isNumber(NaN); // false (NaN is excluded)
+c.asNumber(NaN); // 0 (safe fallback)
+c.asNumber("42"); // 0 (not coerced, use parseInt for that)
 ```
 
 ## Publish New Version

package/dist/index.d.mts

@@ -1,4 +1,6 @@
 type _ = undefined;
+/** Map `never` to a different type */
+type MapNeverTo<T, U> = [T, U][T extends any ? 0 : 1];
 /** Returns `true` if `x` is not `undefined`. */
 declare const isDefined: <T>(x: T | undefined) => x is T;
 declare const isTrue: (x: unknown) => x is true;
@@ -7,12 +9,11 @@ declare const toTrue: (x: unknown) => true | _;
 /** Returns `true` if `x` is `true`, otherwise returns `false`. */
 declare const asTrue: (x: unknown) => boolean;
 type Falsy = false | null | undefined | 0 | "";
-interface IsFalsy {
-    (x: unknown): x is Falsy;
-    <T>(x: T): x is Extract<T, Falsy>;
-}
+type ExtractFalsy<T> = MapNeverTo<Extract<T, Falsy>, Falsy>;
 /** Returns `true` if `Boolean(x)` is `false`. */
-declare const isFalsy: IsFalsy;
+declare const isFalsy: <T>(x: T) => x is ExtractFalsy<T>;
+/** Returns `x` if `Boolean(x)` is `false`, otherwise returns `undefined`. */
+declare const toFalsy: <T>(x: T) => ExtractFalsy<T> | _;
 /** Returns `true` if `Boolean(x)` is `true`. */
 declare const isTruthy: <T>(x: T) => x is Exclude<T, Falsy>;
 /** Returns `x` if `Boolean(x)` is `true`, otherwise returns `undefined`. */
@@ -36,53 +37,49 @@ declare const asString: (x: unknown) => string;
 declare const isNonEmptyString: (x: unknown) => x is string;
 /** Returns `x` if `x` is a string and not empty, otherwise returns `undefined`. */
 declare const toNonEmptyString: (x: unknown) => string | _;
-type NormalizeArrayType<T> = T extends readonly unknown[] ? T : unknown[];
-type ExtractArray<T> = NormalizeArrayType<Extract<T, readonly unknown[]>>;
-interface IsArray {
-    (x: unknown): x is unknown[];
-    <T>(x: T): x is T extends readonly unknown[] ? T : never;
-}
-declare const isArray: IsArray;
+type ExtractArray<T> = MapNeverTo<Extract<T, readonly unknown[]>, unknown[]>;
+declare const isArray: <T>(x: T) => x is ExtractArray<T>;
 /** Returns `x` if `x` is an array. */
 declare const toArray: <T>(x: T) => ExtractArray<T> | _;
+/** Returns `x` if `x` is an array, otherwise returns `[]` (empty array). */
+declare const asArray: <T>(x: T) => ExtractArray<T>;
 /** Returns `true` if `x` is an array and has at least one element. */
-declare const isNonEmptyArray: IsArray;
+declare const isNonEmptyArray: <T>(x: T) => x is ExtractArray<T>;
 /** Returns `x` if `x` is an array and has at least one element, otherwise returns `undefined`. */
 declare const toNonEmptyArray: <T>(x: T) => ExtractArray<T> | _;
-/** Returns `x` if `x` is an array, otherwise returns `[]` (empty array). */
-declare const asArray: <T>(x: T) => ExtractArray<T>;
+type ExtractObject<T> = MapNeverTo<Extract<T, object>, object>;
+/** Returns `true` if `x` is an object (including array) and not null. */
+declare const isObject: <T>(x: T) => x is ExtractObject<T>;
+/** Returns `x` if `x` is an object (including array). */
+declare const toObject: <T>(x: T) => ExtractObject<T> | _;
+/** Returns `x` if `x` is an object (including array), otherwise returns `{}` (empty object). */
+declare const asObject: <T>(x: T) => ExtractObject<T>;
 interface PlainObject {
     [key: PropertyKey]: unknown;
 }
-/** Returns `true` if `x` is an object (including array) and not null. */
-declare const isObject: (x: unknown) => x is object;
-/** Returns `x` if `x` is an object (including array), otherwise returns `{}` (empty object). */
-declare const asObject: (x: unknown) => object;
+type ExtractPlainObject<T> = MapNeverTo<Exclude<Extract<T, object>, readonly unknown[]>, PlainObject>;
 /** Returns `true` if `x` is a plain object (shallow test), not `null` or array. */
-declare const isPlainObject: (x: unknown) => x is PlainObject;
+declare const isPlainObject: <T>(x: T) => x is ExtractPlainObject<T>;
 /** Returns `x` if `x` is a plain object. */
-declare const toPlainObject: (x: unknown) => PlainObject | _;
+declare const toPlainObject: <T>(x: T) => ExtractPlainObject<T> | _;
 /** Returns `x` if `x` is a plain object, otherwise returns `{}` (empty object). */
-declare const asPlainObject: (x: unknown) => PlainObject;
+declare const asPlainObject: <T>(x: T) => ExtractPlainObject<T>;
 /** Returns `true` if `x` is a plain object and has at least one key. */
-declare const isNonEmptyPlainObject: (x: unknown) => x is PlainObject;
+declare const isNonEmptyPlainObject: <T>(x: T) => x is ExtractPlainObject<T>;
 /** Returns `x` if `x` is a plain object and has at least one key. */
-declare const toNonEmptyPlainObject: <T extends PlainObject>(x: T) => T | _;
+declare const toNonEmptyPlainObject: <T>(x: T) => ExtractPlainObject<T> | _;
 /** Returns `true` if `x` is a plain object and has at least one key with non-undefined value. */
-declare const isNonEmptyJSONObject: (x: unknown) => x is PlainObject;
+declare const isNonEmptyJSONObject: <T>(x: T) => x is ExtractPlainObject<T>;
 /** Returns `x` if `x` is a plain object and has at least one key with non-undefined value, otherwise returns `undefined`. */
-declare const toNonEmptyJSONObject: <T extends PlainObject>(x: T) => T | _;
+declare const toNonEmptyJSONObject: <T>(x: T) => ExtractPlainObject<T> | _;
+type ExtractPlainObjectValue<T> = ExtractPlainObject<T>[keyof ExtractPlainObject<T>];
 /**
  * Creates an object from `x` with keys `k` if `f(x[k])` returns `true`.
  * If `x` is not a plain object, or there's no passed props, returns `undefined`.
  */
-declare const toPlainObjectOf: <T>(x: unknown, f: (v: unknown) => v is T) => {
-    [key: PropertyKey]: T;
-} | _;
+declare const toPlainObjectOf: <T, U extends ExtractPlainObjectValue<T>>(x: T, f: (v: ExtractPlainObjectValue<T>) => v is U) => Record<PropertyKey, U> | _;
 /** Filter props from object `x` whose values are `true`. */
-declare const toPlainObjectOfTrue: (x: unknown) => {
-    [key: PropertyKey]: true;
-} | _;
+declare const toPlainObjectOfTrue: (x: unknown) => Record<PropertyKey, true> | _;
 /**
  * Returns `x` if `x` is string, otherwise returns `''` (empty string) if
  * `x` is `null` or `undefined`, otherwise returns `JSON.stringify(x)`.
@@ -97,4 +94,4 @@ declare const returnsFalse: () => false;
 declare const returnsTrue: () => true;
 declare const returnsEmptyString: () => string;
 
-export { type ExtractArray, type Falsy, type IsArray, type IsFalsy, type NormalizeArrayType, type PlainObject, type _, asArray, asNumber, asObject, asPlainObject, asString, asTrue, isArray, isBoolean, isDefined, isFalsy, isNonEmptyArray, isNonEmptyJSONObject, isNonEmptyPlainObject, isNonEmptyString, isNumber, isObject, isPlainObject, isString, isTrue, isTruthy, noop, print, returnsEmptyString, returnsFalse, returnsNull, returnsTrue, returnsUndefined, toArray, toBoolean, toNonEmptyArray, toNonEmptyJSONObject, toNonEmptyPlainObject, toNonEmptyString, toNumber, toPlainObject, toPlainObjectOf, toPlainObjectOfTrue, toString, toTrue, toTruthy };
+export { type ExtractArray, type ExtractFalsy, type ExtractObject, type ExtractPlainObject, type Falsy, type MapNeverTo, type PlainObject, type _, asArray, asNumber, asObject, asPlainObject, asString, asTrue, isArray, isBoolean, isDefined, isFalsy, isNonEmptyArray, isNonEmptyJSONObject, isNonEmptyPlainObject, isNonEmptyString, isNumber, isObject, isPlainObject, isString, isTrue, isTruthy, noop, print, returnsEmptyString, returnsFalse, returnsNull, returnsTrue, returnsUndefined, toArray, toBoolean, toFalsy, toNonEmptyArray, toNonEmptyJSONObject, toNonEmptyPlainObject, toNonEmptyString, toNumber, toObject, toPlainObject, toPlainObjectOf, toPlainObjectOfTrue, toString, toTrue, toTruthy };

package/dist/index.d.ts

@@ -1,4 +1,6 @@
 type _ = undefined;
+/** Map `never` to a different type */
+type MapNeverTo<T, U> = [T, U][T extends any ? 0 : 1];
 /** Returns `true` if `x` is not `undefined`. */
 declare const isDefined: <T>(x: T | undefined) => x is T;
 declare const isTrue: (x: unknown) => x is true;
@@ -7,12 +9,11 @@ declare const toTrue: (x: unknown) => true | _;
 /** Returns `true` if `x` is `true`, otherwise returns `false`. */
 declare const asTrue: (x: unknown) => boolean;
 type Falsy = false | null | undefined | 0 | "";
-interface IsFalsy {
-    (x: unknown): x is Falsy;
-    <T>(x: T): x is Extract<T, Falsy>;
-}
+type ExtractFalsy<T> = MapNeverTo<Extract<T, Falsy>, Falsy>;
 /** Returns `true` if `Boolean(x)` is `false`. */
-declare const isFalsy: IsFalsy;
+declare const isFalsy: <T>(x: T) => x is ExtractFalsy<T>;
+/** Returns `x` if `Boolean(x)` is `false`, otherwise returns `undefined`. */
+declare const toFalsy: <T>(x: T) => ExtractFalsy<T> | _;
 /** Returns `true` if `Boolean(x)` is `true`. */
 declare const isTruthy: <T>(x: T) => x is Exclude<T, Falsy>;
 /** Returns `x` if `Boolean(x)` is `true`, otherwise returns `undefined`. */
@@ -36,53 +37,49 @@ declare const asString: (x: unknown) => string;
 declare const isNonEmptyString: (x: unknown) => x is string;
 /** Returns `x` if `x` is a string and not empty, otherwise returns `undefined`. */
 declare const toNonEmptyString: (x: unknown) => string | _;
-type NormalizeArrayType<T> = T extends readonly unknown[] ? T : unknown[];
-type ExtractArray<T> = NormalizeArrayType<Extract<T, readonly unknown[]>>;
-interface IsArray {
-    (x: unknown): x is unknown[];
-    <T>(x: T): x is T extends readonly unknown[] ? T : never;
-}
-declare const isArray: IsArray;
+type ExtractArray<T> = MapNeverTo<Extract<T, readonly unknown[]>, unknown[]>;
+declare const isArray: <T>(x: T) => x is ExtractArray<T>;
 /** Returns `x` if `x` is an array. */
 declare const toArray: <T>(x: T) => ExtractArray<T> | _;
+/** Returns `x` if `x` is an array, otherwise returns `[]` (empty array). */
+declare const asArray: <T>(x: T) => ExtractArray<T>;
 /** Returns `true` if `x` is an array and has at least one element. */
-declare const isNonEmptyArray: IsArray;
+declare const isNonEmptyArray: <T>(x: T) => x is ExtractArray<T>;
 /** Returns `x` if `x` is an array and has at least one element, otherwise returns `undefined`. */
 declare const toNonEmptyArray: <T>(x: T) => ExtractArray<T> | _;
-/** Returns `x` if `x` is an array, otherwise returns `[]` (empty array). */
-declare const asArray: <T>(x: T) => ExtractArray<T>;
+type ExtractObject<T> = MapNeverTo<Extract<T, object>, object>;
+/** Returns `true` if `x` is an object (including array) and not null. */
+declare const isObject: <T>(x: T) => x is ExtractObject<T>;
+/** Returns `x` if `x` is an object (including array). */
+declare const toObject: <T>(x: T) => ExtractObject<T> | _;
+/** Returns `x` if `x` is an object (including array), otherwise returns `{}` (empty object). */
+declare const asObject: <T>(x: T) => ExtractObject<T>;
 interface PlainObject {
     [key: PropertyKey]: unknown;
 }
-/** Returns `true` if `x` is an object (including array) and not null. */
-declare const isObject: (x: unknown) => x is object;
-/** Returns `x` if `x` is an object (including array), otherwise returns `{}` (empty object). */
-declare const asObject: (x: unknown) => object;
+type ExtractPlainObject<T> = MapNeverTo<Exclude<Extract<T, object>, readonly unknown[]>, PlainObject>;
 /** Returns `true` if `x` is a plain object (shallow test), not `null` or array. */
-declare const isPlainObject: (x: unknown) => x is PlainObject;
+declare const isPlainObject: <T>(x: T) => x is ExtractPlainObject<T>;
 /** Returns `x` if `x` is a plain object. */
-declare const toPlainObject: (x: unknown) => PlainObject | _;
+declare const toPlainObject: <T>(x: T) => ExtractPlainObject<T> | _;
 /** Returns `x` if `x` is a plain object, otherwise returns `{}` (empty object). */
-declare const asPlainObject: (x: unknown) => PlainObject;
+declare const asPlainObject: <T>(x: T) => ExtractPlainObject<T>;
 /** Returns `true` if `x` is a plain object and has at least one key. */
-declare const isNonEmptyPlainObject: (x: unknown) => x is PlainObject;
+declare const isNonEmptyPlainObject: <T>(x: T) => x is ExtractPlainObject<T>;
 /** Returns `x` if `x` is a plain object and has at least one key. */
-declare const toNonEmptyPlainObject: <T extends PlainObject>(x: T) => T | _;
+declare const toNonEmptyPlainObject: <T>(x: T) => ExtractPlainObject<T> | _;
 /** Returns `true` if `x` is a plain object and has at least one key with non-undefined value. */
-declare const isNonEmptyJSONObject: (x: unknown) => x is PlainObject;
+declare const isNonEmptyJSONObject: <T>(x: T) => x is ExtractPlainObject<T>;
 /** Returns `x` if `x` is a plain object and has at least one key with non-undefined value, otherwise returns `undefined`. */
-declare const toNonEmptyJSONObject: <T extends PlainObject>(x: T) => T | _;
+declare const toNonEmptyJSONObject: <T>(x: T) => ExtractPlainObject<T> | _;
+type ExtractPlainObjectValue<T> = ExtractPlainObject<T>[keyof ExtractPlainObject<T>];
 /**
  * Creates an object from `x` with keys `k` if `f(x[k])` returns `true`.
  * If `x` is not a plain object, or there's no passed props, returns `undefined`.
  */
-declare const toPlainObjectOf: <T>(x: unknown, f: (v: unknown) => v is T) => {
-    [key: PropertyKey]: T;
-} | _;
+declare const toPlainObjectOf: <T, U extends ExtractPlainObjectValue<T>>(x: T, f: (v: ExtractPlainObjectValue<T>) => v is U) => Record<PropertyKey, U> | _;
 /** Filter props from object `x` whose values are `true`. */
-declare const toPlainObjectOfTrue: (x: unknown) => {
-    [key: PropertyKey]: true;
-} | _;
+declare const toPlainObjectOfTrue: (x: unknown) => Record<PropertyKey, true> | _;
 /**
  * Returns `x` if `x` is string, otherwise returns `''` (empty string) if
  * `x` is `null` or `undefined`, otherwise returns `JSON.stringify(x)`.
@@ -97,4 +94,4 @@ declare const returnsFalse: () => false;
 declare const returnsTrue: () => true;
 declare const returnsEmptyString: () => string;
 
-export { type ExtractArray, type Falsy, type IsArray, type IsFalsy, type NormalizeArrayType, type PlainObject, type _, asArray, asNumber, asObject, asPlainObject, asString, asTrue, isArray, isBoolean, isDefined, isFalsy, isNonEmptyArray, isNonEmptyJSONObject, isNonEmptyPlainObject, isNonEmptyString, isNumber, isObject, isPlainObject, isString, isTrue, isTruthy, noop, print, returnsEmptyString, returnsFalse, returnsNull, returnsTrue, returnsUndefined, toArray, toBoolean, toNonEmptyArray, toNonEmptyJSONObject, toNonEmptyPlainObject, toNonEmptyString, toNumber, toPlainObject, toPlainObjectOf, toPlainObjectOfTrue, toString, toTrue, toTruthy };
+export { type ExtractArray, type ExtractFalsy, type ExtractObject, type ExtractPlainObject, type Falsy, type MapNeverTo, type PlainObject, type _, asArray, asNumber, asObject, asPlainObject, asString, asTrue, isArray, isBoolean, isDefined, isFalsy, isNonEmptyArray, isNonEmptyJSONObject, isNonEmptyPlainObject, isNonEmptyString, isNumber, isObject, isPlainObject, isString, isTrue, isTruthy, noop, print, returnsEmptyString, returnsFalse, returnsNull, returnsTrue, returnsUndefined, toArray, toBoolean, toFalsy, toNonEmptyArray, toNonEmptyJSONObject, toNonEmptyPlainObject, toNonEmptyString, toNumber, toObject, toPlainObject, toPlainObjectOf, toPlainObjectOfTrue, toString, toTrue, toTruthy };

package/dist/index.js

@@ -7,6 +7,7 @@ var isTrue = (x) => x === true;
 var toTrue = (x) => x === true ? true : _;
 var asTrue = (x) => x === true ? x : false;
 var isFalsy = (x) => !x;
+var toFalsy = (x) => isFalsy(x) ? x : _;
 var isTruthy = (x) => !!x;
 var toTruthy = (x) => isTruthy(x) ? x : _;
 var isBoolean = (x) => x === true || x === false;
@@ -21,10 +22,11 @@ var isNonEmptyString = (x) => isString(x) && x !== "";
 var toNonEmptyString = (x) => isNonEmptyString(x) ? x : _;
 var isArray = Array.isArray;
 var toArray = (x) => isArray(x) ? x : _;
+var asArray = (x) => isArray(x) ? x : [];
 var isNonEmptyArray = (x) => isArray(x) && x.length > 0;
 var toNonEmptyArray = (x) => isNonEmptyArray(x) ? x : _;
-var asArray = (x) => isArray(x) ? x : [];
 var isObject = (x) => x !== null && typeof x === "object";
+var toObject = (x) => isObject(x) ? x : _;
 var asObject = (x) => isObject(x) ? x : {};
 var isPlainObject = (x) => isObject(x) && !isArray(x);
 var toPlainObject = (x) => isPlainObject(x) ? x : _;
@@ -98,11 +100,13 @@ exports.returnsTrue = returnsTrue;
 exports.returnsUndefined = returnsUndefined;
 exports.toArray = toArray;
 exports.toBoolean = toBoolean;
+exports.toFalsy = toFalsy;
 exports.toNonEmptyArray = toNonEmptyArray;
 exports.toNonEmptyJSONObject = toNonEmptyJSONObject;
 exports.toNonEmptyPlainObject = toNonEmptyPlainObject;
 exports.toNonEmptyString = toNonEmptyString;
 exports.toNumber = toNumber;
+exports.toObject = toObject;
 exports.toPlainObject = toPlainObject;
 exports.toPlainObjectOf = toPlainObjectOf;
 exports.toPlainObjectOfTrue = toPlainObjectOfTrue;

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/is-to-as.ts","../src/returns.ts"],"names":[],"mappings":";;;AAAA,IAAM,CAAA,GAAI,MAAA;AAIH,IAAM,SAAA,GAAY,CAAI,CAAA,KAA6B,CAAA,KAAM;AAEzD,IAAM,MAAA,GAAS,CAAC,CAAA,KAA0B,CAAA,KAAM;AAGhD,IAAM,MAAA,GAAS,CAAC,CAAA,KAA0B,CAAA,KAAM,OAAO,IAAA,GAAO;AAG9D,IAAM,MAAA,GAAS,CAAC,CAAA,KAAyB,CAAA,KAAM,OAAO,CAAA,GAAI;AAU1D,IAAM,OAAA,GAAmB,CAAC,CAAA,KAA2B,CAAC;AAGtD,IAAM,QAAA,GAAW,CAAI,CAAA,KAAiC,CAAC,CAAC;AAGxD,IAAM,WAAW,CAAI,CAAA,KAAiC,QAAA,CAAS,CAAC,IAAI,CAAA,GAAI;AAExE,IAAM,SAAA,GAAY,CAAC,CAAA,KAA6B,CAAA,KAAM,QAAQ,CAAA,KAAM;AAGpE,IAAM,YAAY,CAAC,CAAA,KAA6B,SAAA,CAAU,CAAC,IAAI,CAAA,GAAI;AAGnE,IAAM,WAAW,CAAC,CAAA,KAA4B,OAAO,CAAA,KAAM,YAAY,CAAA,KAAM;AAG7E,IAAM,WAAW,CAAC,CAAA,KAA4B,QAAA,CAAS,CAAC,IAAI,CAAA,GAAI;AAGhE,IAAM,WAAW,CAAC,CAAA,KAAwB,QAAA,CAAS,CAAC,IAAI,CAAA,GAAI;AAG5D,IAAM,QAAA,GAAW,CAAC,CAAA,KAA4B,OAAO,CAAA,KAAM;AAG3D,IAAM,WAAW,CAAC,CAAA,KAA4B,QAAA,CAAS,CAAC,IAAI,CAAA,GAAI;AAGhE,IAAM,WAAW,CAAC,CAAA,KAAwB,QAAA,CAAS,CAAC,IAAI,CAAA,GAAI;AAG5D,IAAM,mBAAmB,CAAC,CAAA,KAA4B,QAAA,CAAS,CAAC,KAAK,CAAA,KAAM;AAG3E,IAAM,mBAAmB,CAAC,CAAA,KAA4B,gBAAA,CAAiB,CAAC,IAAI,CAAA,GAAI;AAWhF,IAAM,UAAmB,KAAA,CAAM;AAG/B,IAAM,UAAU,CAAI,CAAA,KAA+B,OAAA,CAAQ,CAAC,IAAK,CAAA,GAAwB;AAGzF,IAAM,kBAA2B,CAAC,CAAA,KAA+B,QAAQ,CAAC,CAAA,IAAK,EAAE,MAAA,GAAS;AAG1F,IAAM,kBAAkB,CAAI,CAAA,KAA+B,eAAA,CAAgB,CAAC,IAAK,CAAA,GAAwB;AAGzG,IAAM,UAAU,CAAI,CAAA,KAA2B,QAAQ,CAAC,CAAA,GAAK,IAAyB;AAOtF,IAAM,WAAW,CAAC,CAAA,KAA4B,CAAA,KAAM,IAAA,IAAQ,OAAO,CAAA,KAAM;AAGzE,IAAM,WAAW,CAAC,CAAA,KAAwB,SAAS,CAAC,CAAA,GAAI,IAAI;AAG5D,IAAM,aAAA,GAAgB,CAAC,CAAA,KAAiC,QAAA,CAAS,CAAC,CAAA,IAAK,CAAC,QAAQ,CAAC;AAGjF,IAAM,gBAAgB,CAAC,CAAA,KAAiC,aAAA,CAAc,CAAC,IAAI,CAAA,GAAI;AAG/E,IAAM,gBAAgB,CAAC,CAAA,KAA6B,cAAc,CAAC,CAAA,GAAI,IAAI;AAG3E,IAAM,qBAAA,GAAwB,CAAC,CAAA,KAAiC,aAAA,CAAc,CAAC,KAAK,MAAA,CAAO,IAAA,CAAK,CAAC,CAAA,CAAE,MAAA,GAAS;AAG5G,IAAM,wBAAwB,CAAwB,CAAA,KAAiB,qBAAA,CAAsB,CAAC,IAAI,CAAA,GAAI;AAGtG,IAAM,oBAAA,GAAuB,CAAC,CAAA,KACnC,aAAA,CAAc,CAAC,CAAA,IAAK,MAAA,CAAO,MAAA,CAAO,CAAC,CAAA,CAAE,IAAA,CAAK,SAAS;AAG9C,IAAM,uBAAuB,CAAwB,CAAA,KAAiB,oBAAA,CAAqB,CAAC,IAAI,CAAA,GAAI;AAMpG,IAAM,eAAA,GAAkB,CAAI,CAAA,EAAY,CAAA,KAA6D;AAC1G,EAAA,IAAI,aAAA,CAAc,CAAC,CAAA,EAAG;AACpB,IAAA,IAAI,KAAA,GAAQ,EAAA;AACZ,IAAA,IAAI,KAAA,GAAQ,MAAA,CAAO,IAAA,CAAK,CAAC,CAAA;AACzB,IAAA,IAAI,SAAS,KAAA,CAAM,MAAA;AACnB,IAAA,IAAI,MAAA;AAEJ,IAAA,OAAO,EAAE,QAAQ,MAAA,EAAQ;AACvB,MAAA,IAAI,GAAA,GAAM,MAAM,KAAK,CAAA;AACrB,MAAA,IAAI,KAAA,GAAQ,EAAE,GAAG,CAAA;AACjB,MAAA,IAAI,CAAA,CAAE,KAAK,CAAA,EAAG;AACZ,QAAA,CAAC,MAAA,KAAW,EAAC,EAAG,GAAG,CAAA,GAAI,KAAA;AAAA,MACzB;AAAA,IACF;AAEA,IAAA,OAAO,MAAA;AAAA,EACT;AACF;AAGO,IAAM,mBAAA,GAAsB,CAAC,CAAA,KAAiD,eAAA,CAAgB,GAAG,MAAM;AAOvG,IAAM,KAAA,GAAQ,CAAC,CAAA,KAAuB;AAC3C,EAAA,IAAI,QAAA,CAAS,CAAC,CAAA,EAAG,OAAO,CAAA;AACxB,EAAA,IAAI,CAAA,IAAK,MAAM,OAAO,EAAA;AACtB,EAAA,IAAI;AACF,IAAA,OAAO,IAAA,CAAK,SAAA,CAAU,CAAA,EAAG,IAAA,EAAM,CAAC,CAAA;AAAA,EAClC,CAAA,CAAA,MAAQ;AAEN,IAAA,OAAO,CAAA,GAAI,EAAA;AAAA,EACb;AACF;;;AC1JO,IAAM,OAAO,MAAY;AAAC;AAE1B,IAAM,gBAAA,GAAmB;AAEzB,IAAM,cAAc,MAAY;AAEhC,IAAM,eAAe,MAAa;AAElC,IAAM,cAAc,MAAY;AAEhC,IAAM,qBAAqB,MAAc","file":"index.js"}
+{"version":3,"sources":["../src/is-to-as.ts","../src/returns.ts"],"names":[],"mappings":"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","file":"index.js"}

package/dist/index.mjs

@@ -5,6 +5,7 @@ var isTrue = (x) => x === true;
 var toTrue = (x) => x === true ? true : _;
 var asTrue = (x) => x === true ? x : false;
 var isFalsy = (x) => !x;
+var toFalsy = (x) => isFalsy(x) ? x : _;
 var isTruthy = (x) => !!x;
 var toTruthy = (x) => isTruthy(x) ? x : _;
 var isBoolean = (x) => x === true || x === false;
@@ -19,10 +20,11 @@ var isNonEmptyString = (x) => isString(x) && x !== "";
 var toNonEmptyString = (x) => isNonEmptyString(x) ? x : _;
 var isArray = Array.isArray;
 var toArray = (x) => isArray(x) ? x : _;
+var asArray = (x) => isArray(x) ? x : [];
 var isNonEmptyArray = (x) => isArray(x) && x.length > 0;
 var toNonEmptyArray = (x) => isNonEmptyArray(x) ? x : _;
-var asArray = (x) => isArray(x) ? x : [];
 var isObject = (x) => x !== null && typeof x === "object";
+var toObject = (x) => isObject(x) ? x : _;
 var asObject = (x) => isObject(x) ? x : {};
 var isPlainObject = (x) => isObject(x) && !isArray(x);
 var toPlainObject = (x) => isPlainObject(x) ? x : _;
@@ -67,6 +69,6 @@ var returnsFalse = () => false;
 var returnsTrue = () => true;
 var returnsEmptyString = () => "";
 
-export { asArray, asNumber, asObject, asPlainObject, asString, asTrue, isArray, isBoolean, isDefined, isFalsy, isNonEmptyArray, isNonEmptyJSONObject, isNonEmptyPlainObject, isNonEmptyString, isNumber, isObject, isPlainObject, isString, isTrue, isTruthy, noop, print, returnsEmptyString, returnsFalse, returnsNull, returnsTrue, returnsUndefined, toArray, toBoolean, toNonEmptyArray, toNonEmptyJSONObject, toNonEmptyPlainObject, toNonEmptyString, toNumber, toPlainObject, toPlainObjectOf, toPlainObjectOfTrue, toString, toTrue, toTruthy };
+export { asArray, asNumber, asObject, asPlainObject, asString, asTrue, isArray, isBoolean, isDefined, isFalsy, isNonEmptyArray, isNonEmptyJSONObject, isNonEmptyPlainObject, isNonEmptyString, isNumber, isObject, isPlainObject, isString, isTrue, isTruthy, noop, print, returnsEmptyString, returnsFalse, returnsNull, returnsTrue, returnsUndefined, toArray, toBoolean, toFalsy, toNonEmptyArray, toNonEmptyJSONObject, toNonEmptyPlainObject, toNonEmptyString, toNumber, toObject, toPlainObject, toPlainObjectOf, toPlainObjectOfTrue, toString, toTrue, toTruthy };
 //# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/is-to-as.ts","../src/returns.ts"],"names":[],"mappings":"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","file":"index.mjs"}
+{"version":3,"sources":["../src/is-to-as.ts","../src/returns.ts"],"names":[],"mappings":"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","file":"index.mjs"}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@wopjs/cast",
-  "version": "0.1.7",
-  "description": "Filter types from unknown",
+  "version": "0.1.8",
+  "description": "Type-safe utilities for filtering and coercing unknown values in TypeScript.",
   "repository": "wopjs/cast",
   "main": "./dist/index.js",
   "module": "./dist/index.mjs",
@@ -25,7 +25,14 @@
   },
   "keywords": [
     "typescript",
-    "coerce"
+    "type-guard",
+    "type-narrowing",
+    "type-safe",
+    "coerce",
+    "cast",
+    "unknown",
+    "validation",
+    "filter"
   ],
   "maintainers": [
     {

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,
@@ -67,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", () => {
@@ -89,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", () => {
@@ -466,17 +562,28 @@ describe("primitive.ts", () => {
     }
 
     {
-      // Type narrowing - unknown input returns unknown[] | undefined
+      // Type narrowing - unknown input returns unknown[]
       const arr = castType<unknown>(["a", "b"]);
-      const result: unknown[] | undefined = toNonEmptyArray(arr);
-      expect(result).toEqual(["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 arr = castType<string>("hello");
-      const result: unknown[] | undefined = toNonEmptyArray(arr);
+      const result = toNonEmptyArray(arr);
       expect(result).toBe(undefined);
+      if (result) {
+        // rule out never
+        let _check = result;
+        _check = castType<unknown[]>(result);
+        throw new Error("Unreachable");
+      }
     }
   });
 
@@ -484,59 +591,410 @@ describe("primitive.ts", () => {
     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", () => {

package/src/is-to-as.ts

@@ -1,6 +1,9 @@
 const _ = undefined;
 export type _ = undefined;
 
+/** Map `never` to a different type */
+export type MapNeverTo<T, U> = [T, U][T extends any ? 0 : 1];
+
 /** Returns `true` if `x` is not `undefined`. */
 export const isDefined = <T>(x: T | undefined): x is T => x !== _;
 
@@ -14,13 +17,13 @@ export const asTrue = (x: unknown): boolean => (x === true ? x : false);
 
 export type Falsy = false | null | undefined | 0 | "";
 
-export interface IsFalsy {
-  (x: unknown): x is Falsy;
-  <T>(x: T): x is Extract<T, Falsy>;
-}
+export type ExtractFalsy<T> = MapNeverTo<Extract<T, Falsy>, Falsy>;
 
 /** Returns `true` if `Boolean(x)` is `false`. */
-export const isFalsy: IsFalsy = (x: unknown): x is Falsy => !x;
+export const isFalsy = <T>(x: T): x is ExtractFalsy<T> => !x;
+
+/** Returns `x` if `Boolean(x)` is `false`, otherwise returns `undefined`. */
+export const toFalsy = <T>(x: T): ExtractFalsy<T> | _ => (isFalsy(x) ? x : _);
 
 /** Returns `true` if `Boolean(x)` is `true`. */
 export const isTruthy = <T>(x: T): x is Exclude<T, Falsy> => !!x;
@@ -57,74 +60,80 @@ export const isNonEmptyString = (x: unknown): x is string => isString(x) && x !=
 /** Returns `x` if `x` is a string and not empty, otherwise returns `undefined`. */
 export const toNonEmptyString = (x: unknown): string | _ => (isNonEmptyString(x) ? x : _);
 
-export type NormalizeArrayType<T> = T extends readonly unknown[] ? T : unknown[];
+export type ExtractArray<T> = MapNeverTo<Extract<T, readonly unknown[]>, unknown[]>;
 
-export type ExtractArray<T> = NormalizeArrayType<Extract<T, readonly unknown[]>>;
-
-export interface IsArray {
-  (x: unknown): x is unknown[];
-  <T>(x: T): x is T extends readonly unknown[] ? T : never;
-}
-
-export const isArray: IsArray = Array.isArray;
+export const isArray = Array.isArray as <T>(x: T) => x is ExtractArray<T>;
 
 /** Returns `x` if `x` is an array. */
-export const toArray = <T>(x: T): ExtractArray<T> | _ => (isArray(x) ? (x as ExtractArray<T>) : _);
+export const toArray = <T>(x: T): ExtractArray<T> | _ => (isArray(x) ? x : _);
+
+/** Returns `x` if `x` is an array, otherwise returns `[]` (empty array). */
+export const asArray = <T>(x: T): ExtractArray<T> => (isArray(x) ? x : ([] as ExtractArray<T>));
 
 /** Returns `true` if `x` is an array and has at least one element. */
-export const isNonEmptyArray: IsArray = (x: unknown): x is unknown[] => isArray(x) && x.length > 0;
+export const isNonEmptyArray = <T>(x: T): x is ExtractArray<T> => isArray(x) && x.length > 0;
 
 /** Returns `x` if `x` is an array and has at least one element, otherwise returns `undefined`. */
-export const toNonEmptyArray = <T>(x: T): ExtractArray<T> | _ => (isNonEmptyArray(x) ? (x as ExtractArray<T>) : _);
+export const toNonEmptyArray = <T>(x: T): ExtractArray<T> | _ => (isNonEmptyArray(x) ? x : _);
 
-/** Returns `x` if `x` is an array, otherwise returns `[]` (empty array). */
-export const asArray = <T>(x: T): ExtractArray<T> => (isArray(x) ? (x as ExtractArray<T>) : ([] as ExtractArray<T>));
+export type ExtractObject<T> = MapNeverTo<Extract<T, object>, object>;
+
+/** Returns `true` if `x` is an object (including array) and not null. */
+export const isObject = <T>(x: T): x is ExtractObject<T> => x !== null && typeof x === "object";
+
+/** Returns `x` if `x` is an object (including array). */
+export const toObject = <T>(x: T): ExtractObject<T> | _ => (isObject(x) ? x : _);
+
+/** Returns `x` if `x` is an object (including array), otherwise returns `{}` (empty object). */
+export const asObject = <T>(x: T): ExtractObject<T> => (isObject(x) ? x : ({} as ExtractObject<T>));
 
 export interface PlainObject {
   [key: PropertyKey]: unknown;
 }
 
-/** Returns `true` if `x` is an object (including array) and not null. */
-export const isObject = (x: unknown): x is object => x !== null && typeof x === "object";
-
-/** Returns `x` if `x` is an object (including array), otherwise returns `{}` (empty object). */
-export const asObject = (x: unknown): object => (isObject(x) ? x : {});
+export type ExtractPlainObject<T> = MapNeverTo<Exclude<Extract<T, object>, readonly unknown[]>, PlainObject>;
 
 /** Returns `true` if `x` is a plain object (shallow test), not `null` or array. */
-export const isPlainObject = (x: unknown): x is PlainObject => isObject(x) && !isArray(x);
+export const isPlainObject = <T>(x: T): x is ExtractPlainObject<T> => isObject(x) && !isArray(x);
 
 /** Returns `x` if `x` is a plain object. */
-export const toPlainObject = (x: unknown): PlainObject | _ => (isPlainObject(x) ? x : _);
+export const toPlainObject = <T>(x: T): ExtractPlainObject<T> | _ => (isPlainObject(x) ? x : _);
 
 /** Returns `x` if `x` is a plain object, otherwise returns `{}` (empty object). */
-export const asPlainObject = (x: unknown): PlainObject => (isPlainObject(x) ? x : {});
+export const asPlainObject = <T>(x: T): ExtractPlainObject<T> => (isPlainObject(x) ? x : ({} as ExtractPlainObject<T>));
 
 /** Returns `true` if `x` is a plain object and has at least one key. */
-export const isNonEmptyPlainObject = (x: unknown): x is PlainObject => isPlainObject(x) && Object.keys(x).length > 0;
+export const isNonEmptyPlainObject = <T>(x: T): x is ExtractPlainObject<T> =>
+  isPlainObject(x) && Object.keys(x).length > 0;
 
 /** Returns `x` if `x` is a plain object and has at least one key. */
-export const toNonEmptyPlainObject = <T extends PlainObject>(x: T): T | _ => (isNonEmptyPlainObject(x) ? x : _);
+export const toNonEmptyPlainObject = <T>(x: T): ExtractPlainObject<T> | _ => (isNonEmptyPlainObject(x) ? x : _);
 
 /** Returns `true` if `x` is a plain object and has at least one key with non-undefined value. */
-export const isNonEmptyJSONObject = (x: unknown): x is PlainObject =>
+export const isNonEmptyJSONObject = <T>(x: T): x is ExtractPlainObject<T> =>
   isPlainObject(x) && Object.values(x).some(isDefined);
 
 /** Returns `x` if `x` is a plain object and has at least one key with non-undefined value, otherwise returns `undefined`. */
-export const toNonEmptyJSONObject = <T extends PlainObject>(x: T): T | _ => (isNonEmptyJSONObject(x) ? x : _);
+export const toNonEmptyJSONObject = <T>(x: T): ExtractPlainObject<T> | _ => (isNonEmptyJSONObject(x) ? x : _);
+
+type ExtractPlainObjectValue<T> = ExtractPlainObject<T>[keyof ExtractPlainObject<T>];
 
 /**
  * Creates an object from `x` with keys `k` if `f(x[k])` returns `true`.
  * If `x` is not a plain object, or there's no passed props, returns `undefined`.
  */
-export const toPlainObjectOf = <T>(x: unknown, f: (v: unknown) => v is T): { [key: PropertyKey]: T } | _ => {
+export const toPlainObjectOf = <T, U extends ExtractPlainObjectValue<T>>(
+  x: T,
+  f: (v: ExtractPlainObjectValue<T>) => v is U
+): Record<PropertyKey, U> | _ => {
   if (isPlainObject(x)) {
     let index = -1;
     let props = Object.keys(x);
     let length = props.length;
-    let result: { [key: PropertyKey]: T } | _;
+    let result: Record<PropertyKey, U> | _;
 
     while (++index < length) {
-      let key = props[index];
+      let key = props[index] as keyof typeof x;
       let value = x[key];
       if (f(value)) {
         (result ??= {})[key] = value;
@@ -136,7 +145,7 @@ export const toPlainObjectOf = <T>(x: unknown, f: (v: unknown) => v is T): { [ke
 };
 
 /** Filter props from object `x` whose values are `true`. */
-export const toPlainObjectOfTrue = (x: unknown): { [key: PropertyKey]: true } | _ => toPlainObjectOf(x, isTrue);
+export const toPlainObjectOfTrue = (x: unknown): Record<PropertyKey, true> | _ => toPlainObjectOf(x, isTrue);
 
 /**
  * Returns `x` if `x` is string, otherwise returns `''` (empty string) if