@wopjs/cast 0.1.8 → 0.1.9

package/dist/index.d.mts

@@ -1,6 +1,6 @@
 type _ = undefined;
-/** Map `never` to a different type */
-type MapNeverTo<T, U> = [T, U][T extends any ? 0 : 1];
+/** Returns `U` if `T` is `never` or `any`, otherwise returns `T`. */
+type SetDefaultType<T, U> = [T, U][T extends any ? (0 extends 1 & T ? 1 : 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;
@@ -9,7 +9,7 @@ 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 | "";
-type ExtractFalsy<T> = MapNeverTo<Extract<T, Falsy>, Falsy>;
+type ExtractFalsy<T> = SetDefaultType<Extract<T, Falsy>, Falsy>;
 /** Returns `true` if `Boolean(x)` is `false`. */
 declare const isFalsy: <T>(x: T) => x is ExtractFalsy<T>;
 /** Returns `x` if `Boolean(x)` is `false`, otherwise returns `undefined`. */
@@ -37,7 +37,7 @@ 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 ExtractArray<T> = MapNeverTo<Extract<T, readonly unknown[]>, unknown[]>;
+type ExtractArray<T> = SetDefaultType<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> | _;
@@ -47,7 +47,7 @@ declare const asArray: <T>(x: T) => ExtractArray<T>;
 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> | _;
-type ExtractObject<T> = MapNeverTo<Extract<T, object>, object>;
+type ExtractObject<T> = SetDefaultType<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). */
@@ -57,7 +57,7 @@ declare const asObject: <T>(x: T) => ExtractObject<T>;
 interface PlainObject {
     [key: PropertyKey]: unknown;
 }
-type ExtractPlainObject<T> = MapNeverTo<Exclude<Extract<T, object>, readonly unknown[]>, PlainObject>;
+type ExtractPlainObject<T> = SetDefaultType<Exclude<Extract<T, object>, readonly unknown[]>, PlainObject>;
 /** Returns `true` if `x` is a plain object (shallow test), not `null` or array. */
 declare const isPlainObject: <T>(x: T) => x is ExtractPlainObject<T>;
 /** Returns `x` if `x` is a plain object. */
@@ -94,4 +94,4 @@ declare const returnsFalse: () => false;
 declare const returnsTrue: () => true;
 declare const returnsEmptyString: () => string;
 
-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 };
+export { type ExtractArray, type ExtractFalsy, type ExtractObject, type ExtractPlainObject, type Falsy, type PlainObject, type SetDefaultType, 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,6 +1,6 @@
 type _ = undefined;
-/** Map `never` to a different type */
-type MapNeverTo<T, U> = [T, U][T extends any ? 0 : 1];
+/** Returns `U` if `T` is `never` or `any`, otherwise returns `T`. */
+type SetDefaultType<T, U> = [T, U][T extends any ? (0 extends 1 & T ? 1 : 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;
@@ -9,7 +9,7 @@ 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 | "";
-type ExtractFalsy<T> = MapNeverTo<Extract<T, Falsy>, Falsy>;
+type ExtractFalsy<T> = SetDefaultType<Extract<T, Falsy>, Falsy>;
 /** Returns `true` if `Boolean(x)` is `false`. */
 declare const isFalsy: <T>(x: T) => x is ExtractFalsy<T>;
 /** Returns `x` if `Boolean(x)` is `false`, otherwise returns `undefined`. */
@@ -37,7 +37,7 @@ 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 ExtractArray<T> = MapNeverTo<Extract<T, readonly unknown[]>, unknown[]>;
+type ExtractArray<T> = SetDefaultType<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> | _;
@@ -47,7 +47,7 @@ declare const asArray: <T>(x: T) => ExtractArray<T>;
 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> | _;
-type ExtractObject<T> = MapNeverTo<Extract<T, object>, object>;
+type ExtractObject<T> = SetDefaultType<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). */
@@ -57,7 +57,7 @@ declare const asObject: <T>(x: T) => ExtractObject<T>;
 interface PlainObject {
     [key: PropertyKey]: unknown;
 }
-type ExtractPlainObject<T> = MapNeverTo<Exclude<Extract<T, object>, readonly unknown[]>, PlainObject>;
+type ExtractPlainObject<T> = SetDefaultType<Exclude<Extract<T, object>, readonly unknown[]>, PlainObject>;
 /** Returns `true` if `x` is a plain object (shallow test), not `null` or array. */
 declare const isPlainObject: <T>(x: T) => x is ExtractPlainObject<T>;
 /** Returns `x` if `x` is a plain object. */
@@ -94,4 +94,4 @@ declare const returnsFalse: () => false;
 declare const returnsTrue: () => true;
 declare const returnsEmptyString: () => string;
 
-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 };
+export { type ExtractArray, type ExtractFalsy, type ExtractObject, type ExtractPlainObject, type Falsy, type PlainObject, type SetDefaultType, 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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wopjs/cast",
-  "version": "0.1.8",
+  "version": "0.1.9",
   "description": "Type-safe utilities for filtering and coercing unknown values in TypeScript.",
   "repository": "wopjs/cast",
   "main": "./dist/index.js",

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

@@ -304,6 +304,16 @@ describe("primitive.ts", () => {
         expect(check).toBe(undefined);
       }
     }
+
+    {
+      // Type narrowing - generic
+      const _fn = <T>(x: T): void => {
+        if (isArray(x)) {
+          const y: readonly any[] = x;
+          expect(Array.isArray(y)).toBe(true);
+        }
+      };
+    }
   });
 
   it("toArray", () => {
@@ -372,6 +382,15 @@ describe("primitive.ts", () => {
       const arr = castType<string>("hello");
       const result: unknown[] | undefined = toArray(arr);
       expect(result).toBe(undefined);
+      toArray(arr)?.map(x => x);
+    }
+
+    {
+      // Type narrowing - any returns any[]
+      const arr = castType<any>("hello");
+      const result: unknown[] | undefined = toArray(arr);
+      expect(result).toBe(undefined);
+      toArray(arr)?.map(x => x);
     }
   });
 
@@ -507,6 +526,7 @@ describe("primitive.ts", () => {
       const arr = castType<unknown>(["a", "b"]);
       const result: unknown[] = asArray(arr);
       expect(result).toEqual(["a", "b"]);
+      asArray(arr).map(x => x);
     }
 
     {
@@ -514,6 +534,7 @@ describe("primitive.ts", () => {
       const arr = castType<string>("hello");
       const result: unknown[] = asArray(arr);
       expect(result).toEqual([]);
+      asArray(arr).map(x => x);
     }
   });
 

package/src/is-to-as.ts

@@ -1,8 +1,8 @@
 const _ = undefined;
 export type _ = undefined;
 
-/** Map `never` to a different type */
-export type MapNeverTo<T, U> = [T, U][T extends any ? 0 : 1];
+/** Returns `U` if `T` is `never` or `any`, otherwise returns `T`. */
+export type SetDefaultType<T, U> = [T, U][T extends any ? (0 extends 1 & T ? 1 : 0) : 1];
 
 /** Returns `true` if `x` is not `undefined`. */
 export const isDefined = <T>(x: T | undefined): x is T => x !== _;
@@ -17,7 +17,7 @@ export const asTrue = (x: unknown): boolean => (x === true ? x : false);
 
 export type Falsy = false | null | undefined | 0 | "";
 
-export type ExtractFalsy<T> = MapNeverTo<Extract<T, Falsy>, Falsy>;
+export type ExtractFalsy<T> = SetDefaultType<Extract<T, Falsy>, Falsy>;
 
 /** Returns `true` if `Boolean(x)` is `false`. */
 export const isFalsy = <T>(x: T): x is ExtractFalsy<T> => !x;
@@ -60,7 +60,7 @@ 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 ExtractArray<T> = MapNeverTo<Extract<T, readonly unknown[]>, unknown[]>;
+export type ExtractArray<T> = SetDefaultType<Extract<T, readonly unknown[]>, unknown[]>;
 
 export const isArray = Array.isArray as <T>(x: T) => x is ExtractArray<T>;
 
@@ -76,7 +76,7 @@ export const isNonEmptyArray = <T>(x: T): x is ExtractArray<T> => isArray(x) &&
 /** 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 : _);
 
-export type ExtractObject<T> = MapNeverTo<Extract<T, object>, object>;
+export type ExtractObject<T> = SetDefaultType<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";
@@ -91,7 +91,7 @@ export interface PlainObject {
   [key: PropertyKey]: unknown;
 }
 
-export type ExtractPlainObject<T> = MapNeverTo<Exclude<Extract<T, object>, readonly unknown[]>, PlainObject>;
+export type ExtractPlainObject<T> = SetDefaultType<Exclude<Extract<T, object>, readonly unknown[]>, PlainObject>;
 
 /** Returns `true` if `x` is a plain object (shallow test), not `null` or array. */
 export const isPlainObject = <T>(x: T): x is ExtractPlainObject<T> => isObject(x) && !isArray(x);