@wopjs/cast 0.1.6 → 0.1.8

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,72 +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 ExtractArray<T> = T extends readonly unknown[] ? T : unknown[];
-
-export interface IsArray {
-  (x: unknown): x is unknown[];
-  <T>(x: T): x is T extends readonly unknown[] ? T : never;
-}
+export type ExtractArray<T> = MapNeverTo<Extract<T, readonly unknown[]>, unknown[]>;
 
-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;
@@ -134,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