Updated naming

package.json

@@ -66,7 +66,7 @@
     "url": "https://github.com/webdeveric/utils/issues"
   },
   "homepage": "https://github.com/webdeveric/utils/#readme",
-  "packageManager": "[email protected].3+sha512.bb45e34d50a9a76e858a95837301bfb6bd6d35aea2c5d52094fa497a467c43f5c440103ce2511e9e0a2f89c3d6071baac3358fc68ac6fb75e2ceb3d2736065e6",
+  "packageManager": "[email protected].4+sha512.da3d715bfd22a9a105e6e8088cfc7826699332ded60c423b14ec613a185f1602206702ff0fe4c438cb15c979081ce4cb02568e364b15174503a63c7a8e2a5f6c",
   "scripts": {
     "clean": "rimraf ./dist/",
     "prebuild": "pnpm clean",
@@ -88,7 +88,7 @@
     "@commitlint/config-conventional": "^19.8.0",
     "@commitlint/types": "^19.8.0",
     "@types/node": "^22.13.10",
-    "@vitest/coverage-v8": "^3.0.8",
+    "@vitest/coverage-v8": "^3.0.9",
     "@webdeveric/eslint-config-ts": "^0.11.0",
     "@webdeveric/prettier-config": "^0.3.0",
     "commitlint": "^19.8.0",
@@ -107,7 +107,7 @@
     "semantic-release": "^24.2.3",
     "typescript": "^5.8.2",
     "validate-package-exports": "^0.8.0",
-    "vitest": "^3.0.8"
+    "vitest": "^3.0.9"
   },
   "pnpm": {
     "onlyBuiltDependencies": [

src/predicate/factory/fromEnum.ts

@@ -1,10 +1,10 @@
 import type { TypePredicateFn } from '../../types/functions.js';
-import type { UnknownRecord } from '../../types/records.js';
+import type { EnumRecord } from '../../types/records.js';
 
 /**
  * @internal
  */
-const getEnumValues = <T extends UnknownRecord>(enumObject: T): Set<unknown> => {
+const getEnumValues = <T extends EnumRecord>(enumObject: T): Set<unknown> => {
   const entries = Object.entries(enumObject);
 
   const ignoreKeys = entries.reduce((keys, [, value]) => {
@@ -27,7 +27,7 @@ const getEnumValues = <T extends UnknownRecord>(enumObject: T): Set<unknown> =>
 /**
  * Create a type predicate function that checks if the input is a member of the TypeScript `enum`
  */
-export const fromEnum = <T extends UnknownRecord>(enumObject: T): TypePredicateFn<T[keyof T]> => {
+export const fromEnum = <T extends EnumRecord>(enumObject: T): TypePredicateFn<T[keyof T]> => {
   const values = getEnumValues(enumObject);
 
   return (input: unknown): input is T[keyof T] => values.has(input);

src/predicate/factory/index.ts

@@ -7,8 +7,9 @@ export * from './is.js';
 export * from './literal.js';
 export * from './matching.js';
 export * from './maybeArray.js';
-export * from './maybeNull.js';
-export * from './maybeUndefined.js';
+export * from './nonNullable.js';
+export * from './nullable.js';
+export * from './optional.js';
 export * from './range.js';
 export * from './shape.js';
 export * from './stringLength.js';

src/predicate/factory/nonNullable.ts

@@ -0,0 +1,9 @@
+import type { TypePredicateFn } from '../../types/functions.js';
+
+/**
+ * @see https://www.typescriptlang.org/docs/handbook/utility-types.html#nonnullabletype
+ */
+export const nonNullable =
+  <T>(predicate: TypePredicateFn<T>): TypePredicateFn<NonNullable<T>> =>
+  (input: unknown): input is NonNullable<T> =>
+    input != null && predicate(input);

src/predicate/factory/maybeNull.ts → src/predicate/factory/nullable.ts

@@ -1,6 +1,6 @@
 import type { TypePredicateFn } from '../../types/functions.js';
 
-export const maybeNull =
+export const nullable =
   <T>(predicate: TypePredicateFn<T>): TypePredicateFn<T | null> =>
   (input: unknown): input is T | null =>
     input === null || predicate(input);

src/predicate/factory/maybeUndefined.ts → src/predicate/factory/optional.ts

@@ -1,6 +1,6 @@
 import type { TypePredicateFn } from '../../types/functions.js';
 
-export const maybeUndefined =
+export const optional =
   <T>(predicate: TypePredicateFn<T>): TypePredicateFn<T | undefined> =>
   (input: unknown): input is T | undefined =>
     typeof input === 'undefined' || predicate(input);

src/predicate/factory/withLength.ts

@@ -21,7 +21,11 @@ export function withLength<Fn extends TypePredicateFn<{ length: number }>, Lengt
   lengthRange: LengthOrRange,
 ): TypePredicateFn<InferPredicateReturnType<Fn> & { length: number }> {
   if (Array.isArray(lengthRange)) {
-    const [min = Number.NEGATIVE_INFINITY, max = Number.POSITIVE_INFINITY] = lengthRange;
+    const [min = 0, max = Number.POSITIVE_INFINITY] = lengthRange;
+
+    if (min < 0) {
+      throw new RangeError('min must be greater than or equal to 0');
+    }
 
     if (min > max) {
       throw new RangeError('min cannot be greater than max');

src/predicate/factory/withSize.ts

@@ -21,7 +21,11 @@ export function withSize<Fn extends TypePredicateFn<{ size: number }>, SizeOrRan
   sizeRange: SizeOrRange,
 ): TypePredicateFn<InferPredicateReturnType<Fn> & { size: number }> {
   if (Array.isArray(sizeRange)) {
-    const [min = Number.NEGATIVE_INFINITY, max = Number.POSITIVE_INFINITY] = sizeRange;
+    const [min = 0, max = Number.POSITIVE_INFINITY] = sizeRange;
+
+    if (min < 0) {
+      throw new RangeError('min must be greater than or equal to 0');
+    }
 
     if (min > max) {
       throw new RangeError('min cannot be greater than max');

src/predicate/isOptionalBigInt.ts

@@ -1,4 +1,4 @@
-import { maybeUndefined } from './factory/maybeUndefined.js';
+import { optional } from './factory/optional.js';
 import { isBigInt } from './isBigInt.js';
 
-export const isOptionalBigInt = maybeUndefined(isBigInt);
+export const isOptionalBigInt = optional(isBigInt);

src/predicate/isOptionalBoolean.ts

@@ -1,4 +1,4 @@
-import { maybeUndefined } from './factory/maybeUndefined.js';
+import { optional } from './factory/optional.js';
 import { isBoolean } from './isBoolean.js';
 
-export const isOptionalBoolean = maybeUndefined(isBoolean);
+export const isOptionalBoolean = optional(isBoolean);

src/predicate/isOptionalISODateString.ts

@@ -1,4 +1,4 @@
-import { maybeUndefined } from './factory/maybeUndefined.js';
+import { optional } from './factory/optional.js';
 import { isISODateString } from './isISODateString.js';
 
-export const isOptionalISODateString = maybeUndefined(isISODateString);
+export const isOptionalISODateString = optional(isISODateString);

src/predicate/isOptionalNull.ts

@@ -1,4 +1,4 @@
-import { maybeUndefined } from './factory/maybeUndefined.js';
+import { optional } from './factory/optional.js';
 import { isNull } from './isNull.js';
 
-export const isOptionalNull = maybeUndefined(isNull);
+export const isOptionalNull = optional(isNull);

src/predicate/isOptionalNumber.ts

@@ -1,4 +1,4 @@
-import { maybeUndefined } from './factory/maybeUndefined.js';
+import { optional } from './factory/optional.js';
 import { isNumber } from './isNumber.js';
 
-export const isOptionalNumber = maybeUndefined(isNumber);
+export const isOptionalNumber = optional(isNumber);

src/predicate/isOptionalString.ts

@@ -1,4 +1,4 @@
-import { maybeUndefined } from './factory/maybeUndefined.js';
+import { optional } from './factory/optional.js';
 import { isString } from './isString.js';
 
-export const isOptionalString = maybeUndefined(isString);
+export const isOptionalString = optional(isString);

src/predicate/isOptionalSymbol.ts

@@ -1,4 +1,4 @@
-import { maybeUndefined } from './factory/maybeUndefined.js';
+import { optional } from './factory/optional.js';
 import { isSymbol } from './isSymbol.js';
 
-export const isOptionalSymbol = maybeUndefined(isSymbol);
+export const isOptionalSymbol = optional(isSymbol);

src/types/records.ts

@@ -7,6 +7,8 @@ export type NeverRecord = Record<PropertyKey, never>;
 
 export type StringRecord = Record<string, string>;
 
+export type EnumRecord = Record<string, string | number>;
+
 export type RemoveIndex<Type> = {
   [Key in keyof Type as symbol extends Key
     ? never

test/predicate/factory/nonNullable.test.ts

@@ -0,0 +1,24 @@
+import { describe, it, expect } from 'vitest';
+
+import { nonNullable } from '../../../src/predicate/factory/nonNullable.js';
+
+describe('nonNullable()', () => {
+  const predicate = (input: unknown): input is 'testing' | null | undefined => {
+    const values: unknown[] = ['testing', null, undefined];
+
+    return values.includes(input);
+  };
+
+  it('Returns a type predicate function', () => {
+    expect(nonNullable(predicate)).toBeInstanceOf(Function);
+  });
+
+  it('Calls a type predicate function', () => {
+    const fn = nonNullable(predicate);
+
+    expect(fn('testing')).toBeTruthy();
+    expect(fn('something else')).toBeFalsy();
+    expect(fn(null)).toBeFalsy();
+    expect(fn(undefined)).toBeFalsy();
+  });
+});

test/predicate/factory/maybeNull.test.ts → test/predicate/factory/nullable.test.ts

@@ -1,17 +1,17 @@
 import { describe, it, expect, vi } from 'vitest';
 
-import { maybeNull } from '../../../src/predicate/factory/maybeNull.js';
+import { nullable } from '../../../src/predicate/factory/nullable.js';
 import { isBoolean } from '../../../src/predicate/isBoolean.js';
 
-describe('maybeNull()', () => {
+describe('nullable()', () => {
   it('Returns a type predicate function', () => {
-    expect(maybeNull(isBoolean)).toBeInstanceOf(Function);
+    expect(nullable(isBoolean)).toBeInstanceOf(Function);
   });
 
   it('Calls a type predicate function', () => {
     const predicate = vi.fn(isBoolean) as unknown as typeof isBoolean;
 
-    const fn = maybeNull(predicate);
+    const fn = nullable(predicate);
 
     expect(fn(true)).toBeTruthy();
     expect(fn(null)).toBeTruthy();

test/predicate/factory/maybeUndefined.test.ts → test/predicate/factory/optional.test.ts

@@ -1,17 +1,17 @@
 import { describe, it, expect, vi } from 'vitest';
 
-import { maybeUndefined } from '../../../src/predicate/factory/maybeUndefined.js';
+import { optional } from '../../../src/predicate/factory/optional.js';
 import { isBoolean } from '../../../src/predicate/isBoolean.js';
 
-describe('maybeUndefined()', () => {
+describe('optional()', () => {
   it('Returns a type predicate function', () => {
-    expect(maybeUndefined(isBoolean)).toBeInstanceOf(Function);
+    expect(optional(isBoolean)).toBeInstanceOf(Function);
   });
 
   it('Calls a type predicate function', () => {
     const predicate = vi.fn(isBoolean) as unknown as typeof isBoolean;
 
-    const fn = maybeUndefined(predicate);
+    const fn = optional(predicate);
 
     expect(fn(true)).toBeTruthy();
     expect(fn(undefined)).toBeTruthy();

test/predicate/factory/withLength.test.ts

@@ -16,6 +16,10 @@ describe('withLength()', () => {
     expect(() => {
       withLength(isString, [100, 1]);
     }).toThrowError();
+
+    expect(() => {
+      withLength(isString, [-100, 100]);
+    }).toThrowError();
   });
 
   it('Returns true for strings with the specified length', () => {

test/predicate/factory/withSize.test.ts

@@ -15,6 +15,10 @@ describe('withSize()', () => {
     expect(() => {
       withSize(instanceOf(Set), [100, 1]);
     }).toThrowError();
+
+    expect(() => {
+      withSize(instanceOf(Set), [-100, 100]);
+    }).toThrowError();
   });
 
   it('Returns true for strings with the specified length', () => {