Refactored anyOf and allOf return type

package.json

@@ -87,7 +87,7 @@
   "devDependencies": {
     "@commitlint/config-conventional": "^19.7.1",
     "@commitlint/types": "^19.5.0",
-    "@types/node": "^22.13.5",
+    "@types/node": "^22.13.8",
     "@vitest/coverage-v8": "^3.0.7",
     "@webdeveric/eslint-config-ts": "^0.11.0",
     "@webdeveric/prettier-config": "^0.3.0",
@@ -96,7 +96,7 @@
     "conventional-changelog-conventionalcommits": "^8.0.0",
     "cspell": "^8.17.5",
     "eslint": "^8.57.1",
-    "eslint-config-prettier": "^10.0.1",
+    "eslint-config-prettier": "^10.0.2",
     "eslint-import-resolver-typescript": "^3.8.3",
     "eslint-plugin-import": "^2.31.0",
     "husky": "^9.1.7",
@@ -105,7 +105,7 @@
     "prettier": "^3.5.2",
     "rimraf": "^6.0.1",
     "semantic-release": "^24.2.3",
-    "typescript": "^5.7.3",
+    "typescript": "^5.8.2",
     "validate-package-exports": "^0.8.0",
     "vitest": "^3.0.7"
   }

src/predicate-factory/allOf.ts

@@ -1,16 +1,16 @@
 import type { InferPredicatesReturnType, TypePredicateFn } from '../types/functions.js';
-import type { UnionToIntersection } from '../types/utils.js';
+import type { IntersectionOf } from '../types/utils.js';
 
 /**
  * All predicates must pass
  */
 export const allOf = <Predicates extends TypePredicateFn<unknown>[]>(
   ...predicates: Predicates
-): TypePredicateFn<UnionToIntersection<InferPredicatesReturnType<Predicates>>> => {
+): TypePredicateFn<IntersectionOf<InferPredicatesReturnType<Predicates>>> => {
   if (!predicates.length) {
     throw new Error('Predicate functions not provided');
   }
 
-  return (input: unknown): input is UnionToIntersection<InferPredicatesReturnType<Predicates>> =>
+  return (input: unknown): input is IntersectionOf<InferPredicatesReturnType<Predicates>> =>
     predicates.every((predicate) => predicate(input));
 };

src/predicate-factory/anyOf.ts

@@ -1,15 +1,16 @@
 import type { InferPredicatesReturnType, TypePredicateFn } from '../types/functions.js';
+import type { UnionOf } from '../types/utils.js';
 
 /**
  * Any predicate can pass
  */
 export const anyOf = <Predicates extends TypePredicateFn<unknown>[]>(
   ...predicates: Predicates
-): TypePredicateFn<InferPredicatesReturnType<Predicates>> => {
+): TypePredicateFn<UnionOf<InferPredicatesReturnType<Predicates>>> => {
   if (!predicates.length) {
     throw new Error('Predicate functions not provided');
   }
 
-  return (input: unknown): input is InferPredicatesReturnType<Predicates> =>
+  return (input: unknown): input is UnionOf<InferPredicatesReturnType<Predicates>> =>
     predicates.some((predicate) => predicate(input));
 };

src/types/functions.ts

@@ -18,7 +18,7 @@ export type InferPredicateReturnType<Fn> = Fn extends TypePredicateFn<infer T> ?
 
 export type InferPredicatesReturnType<Predicates extends TypePredicateFn<unknown>[]> = {
   [K in keyof Predicates]: InferPredicateReturnType<Predicates[K]>;
-}[number];
+};
 
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 export type TypeAssertionFn<T> = (input: unknown, ...args: any[]) => asserts input is T;

src/types/utils.ts

@@ -72,7 +72,9 @@ export type RequiredKeys<Type, Keys extends keyof Type> = Type extends any
   ? Omit<Type, Keys> & Required<Pick<Type, Keys>>
   : never;
 
-export type NonVoid<Type> = Type extends void ? never : Type;
+export type NonVoid<Type> = Exclude<Type, void>;
+
+export type Defined<Type> = Exclude<Type, undefined | void>;
 
 export type RemoveNever<Type> = {
   [Key in keyof Type as [Type[Key]] extends [never] ? never : Key]: Type[Key];
@@ -114,6 +116,12 @@ export type UnionToIntersection<Union> = (Union extends any ? (union: Union) =>
   ? Type
   : never;
 
+export type IntersectionOf<T extends unknown[]> = T extends [infer First, ...infer Rest]
+  ? First & IntersectionOf<Rest>
+  : unknown;
+
+export type UnionOf<T extends unknown[]> = T extends [infer First, ...infer Rest] ? First | UnionOf<Rest> : never;
+
 export type Pretty<Type> = {
   [Property in keyof Type]: Type[Property];
 } & unknown;

test/predicate-factory/allOf.test.ts

@@ -1,9 +1,9 @@
 import { describe, it, expect } from 'vitest';
 
 import { isNumber } from '../../src/predicate/isNumber.js';
-import { isObjectWith } from '../../src/predicate/isObjectWith.js';
 import { isString } from '../../src/predicate/isString.js';
 import { allOf } from '../../src/predicate-factory/allOf.js';
+import { createObjectShapePredicate } from '../../src/predicate-factory/createObjectShapePredicate.js';
 
 describe('allOf()', () => {
   it('Requires one or more type predicate function', () => {
@@ -12,12 +12,12 @@ describe('allOf()', () => {
 
   it('Returns a type predicate function', () => {
     const fn = allOf(
-      (input): input is { name: string } => {
-        return isObjectWith(input, 'name') && isString(input.name);
-      },
-      (input): input is { age: number } => {
-        return isObjectWith(input, 'age') && isNumber(input.age);
-      },
+      createObjectShapePredicate({
+        name: isString,
+      }),
+      createObjectShapePredicate({
+        age: isNumber,
+      }),
     );
 
     expect(fn).instanceOf(Function);