ts-data-forge 5.0.1 → 5.1.1

package/src/functional/ternary-result.test.mts

@@ -5,47 +5,65 @@ import { TernaryResult } from './ternary-result/index.mjs';
 describe('TernaryResult test', () => {
   test('constructors and guards', () => {
     const ok = TernaryResult.ok(1);
+
     const warn = TernaryResult.warn(1, 'caution');
+
     const err = TernaryResult.err(new Error('boom'));
 
-    expect(TernaryResult.isOk(ok)).toBe(true);
-    expect(TernaryResult.isWarn(warn)).toBe(true);
-    expect(TernaryResult.isErr(err)).toBe(true);
-    expect(TernaryResult.isTernaryResult(ok)).toBe(true);
-    expect(TernaryResult.isTernaryResult({})).toBe(false);
+    assert.isTrue(TernaryResult.isOk(ok));
+
+    assert.isTrue(TernaryResult.isWarn(warn));
+
+    assert.isTrue(TernaryResult.isErr(err));
+
+    assert.isTrue(TernaryResult.isTernaryResult(ok));
+
+    assert.isFalse(TernaryResult.isTernaryResult({}));
 
     expectType<typeof ok, TernaryResult<number, never, never>>('<=');
+
     expectType<typeof warn, TernaryResult<number, never, string>>('<=');
+
     expectType<typeof err, TernaryResult<never, Error, never>>('<=');
   });
 
   test('map transforms Ok and Warn success values', () => {
     const ok = TernaryResult.ok(2);
+
     const warn = TernaryResult.warn(2, 'check');
+
     const err = TernaryResult.err('fail');
 
     const double = TernaryResult.map((value: number) => value * 2);
 
     expect(TernaryResult.unwrapOk(double(ok))).toBe(4);
+
     expect(TernaryResult.unwrapOk(double(warn))).toBe(4);
+
     expect(TernaryResult.unwrapWarn(double(warn))).toBe('check');
+
     expect(TernaryResult.unwrapErr(double(err))).toBe('fail');
   });
 
   test('mapWarn and mapErr leave other variants untouched', () => {
     const warn = TernaryResult.warn(2, 'slow');
+
     const err = TernaryResult.err('err');
 
     const warnMessage = TernaryResult.mapWarn(
       (warning: string) => `${warning}!`,
     );
+
     const errUpper = TernaryResult.mapErr((value: string) =>
       value.toUpperCase(),
     );
 
     expect(TernaryResult.unwrapWarn(warnMessage(warn))).toBe('slow!');
+
     expect(TernaryResult.unwrapOk(warnMessage(warn))).toBe(2);
+
     expect(TernaryResult.unwrapWarn(errUpper(warn))).toBe('slow');
+
     expect(TernaryResult.unwrapErr(errUpper(err))).toBe('ERR');
   });
 
@@ -56,17 +74,22 @@ describe('TernaryResult test', () => {
         : TernaryResult.ok(Number(value));
 
     const warn = TernaryResult.warn('3', 'slow');
+
     const err = TernaryResult.err('bad');
 
     const okResult = TernaryResult.flatMap(TernaryResult.ok('3'), parse);
+
     const warnResult = TernaryResult.flatMap(warn, parse);
+
     const errResult = TernaryResult.flatMap(err, parse);
 
     expect(TernaryResult.unwrapOk(okResult)).toBe(3);
-    expect(TernaryResult.isWarn(warnResult)).toBe(true);
+
+    assert.isTrue(TernaryResult.isWarn(warnResult));
 
     if (TernaryResult.isWarn(warnResult)) {
       expect(warnResult.value).toBe(3);
+
       expect(warnResult.warning).toBe('slow');
     }
 
@@ -80,12 +103,14 @@ describe('TernaryResult test', () => {
       (w: string) => ({ warning: w }),
       (e: string) => ({ message: e }),
     );
+
     const warn = TernaryResult.fold(
       TernaryResult.warn(2, 'heads up'),
       (x) => x * 2,
       (w: string) => ({ warning: w }),
       (e: string) => ({ message: e }),
     );
+
     const err = TernaryResult.fold(
       TernaryResult.err('boom'),
       (x) => x,
@@ -94,11 +119,13 @@ describe('TernaryResult test', () => {
     );
 
     expect(TernaryResult.unwrapOk(value)).toBe(2);
+
     expect(TernaryResult.unwrapOk(warn)).toBe(4);
 
     assert.deepStrictEqual(TernaryResult.unwrapWarn(warn), {
       warning: 'heads up',
     });
+
     assert.deepStrictEqual(TernaryResult.unwrapErr(err), { message: 'boom' });
   });
 
@@ -109,10 +136,12 @@ describe('TernaryResult test', () => {
       TernaryResult.orElse(TernaryResult.ok('value'), fallback),
       TernaryResult.ok('value'),
     );
+
     assert.deepStrictEqual(
       TernaryResult.orElse(TernaryResult.warn('value', 'warn'), fallback),
       TernaryResult.warn('value', 'warn'),
     );
+
     assert.deepStrictEqual(
       TernaryResult.orElse(TernaryResult.err('err'), fallback),
       fallback,
@@ -121,14 +150,21 @@ describe('TernaryResult test', () => {
 
   test('unwrap helpers', () => {
     const warn = TernaryResult.warn('value', 'careful');
+
     const err = TernaryResult.err('broken');
 
     expect(TernaryResult.unwrapOk(TernaryResult.ok(3))).toBe(3);
+
     expect(TernaryResult.unwrapOk(warn)).toBe('value');
+
     expect(TernaryResult.unwrapWarn(warn)).toBe('careful');
+
     expect(TernaryResult.unwrapErr(err)).toBe('broken');
+
     expect(TernaryResult.unwrapOkOr(err, 0)).toBe(0);
+
     expect(TernaryResult.unwrapWarnOr(err, 'default')).toBe('default');
+
     expect(TernaryResult.unwrapErrOr(warn, 'default')).toBe('default');
   });
 
@@ -136,9 +172,11 @@ describe('TernaryResult test', () => {
     expect(() =>
       TernaryResult.unwrapThrow(TernaryResult.warn('notice', 'warned')),
     ).toThrow(/Warn/u);
+
     expect(() =>
       TernaryResult.unwrapWarnThrow(TernaryResult.err('no warn')),
     ).toThrow(/Err/u);
+
     expect(() =>
       TernaryResult.unwrapErrThrow(TernaryResult.ok('no err')),
     ).toThrow(/Ok/u);
@@ -146,6 +184,7 @@ describe('TernaryResult test', () => {
 
   test('expectToBe unwraps Ok values', () => {
     expect(TernaryResult.expectToBe(TernaryResult.ok('v'), 'msg')).toBe('v');
+
     expect(() =>
       TernaryResult.expectToBe(TernaryResult.err('x'), 'missing'),
     ).toThrow(/missing/u);
@@ -153,22 +192,28 @@ describe('TernaryResult test', () => {
 
   test('zip prefers Err over Warn or Ok.', () => {
     const ok = TernaryResult.ok('x');
+
     const warn = TernaryResult.warn('warn', 'warned');
+
     const err = TernaryResult.err('err');
 
     assert.deepStrictEqual(
       TernaryResult.zip(ok, TernaryResult.ok(1)),
       TernaryResult.ok(['x', 1] as const),
     );
+
     assert.deepStrictEqual(
       TernaryResult.zip(ok, warn),
       TernaryResult.warn(['x', 'warn'] as const, 'warned'),
     );
+
     assert.deepStrictEqual(
       TernaryResult.zip(warn, ok),
       TernaryResult.warn(['warn', 'x'] as const, 'warned'),
     );
+
     assert.deepStrictEqual(TernaryResult.zip(ok, err), err);
+
     assert.deepStrictEqual(TernaryResult.zip(err, warn), err);
   });
 
@@ -177,6 +222,7 @@ describe('TernaryResult test', () => {
       TernaryResult.toOptional(TernaryResult.ok(1)),
       Optional.some(1),
     );
+
     assert.deepStrictEqual(
       TernaryResult.toOptional(TernaryResult.warn(1, 'warn')),
       Optional.some(1),
@@ -196,7 +242,7 @@ describe('TernaryResult test', () => {
       Promise.reject(new Error('bad')),
     );
 
-    expect(TernaryResult.isErr(rejected)).toBe(true);
+    assert.isTrue(TernaryResult.isErr(rejected));
   });
 
   test('fromThrowable converts thrown values', () => {
@@ -209,6 +255,51 @@ describe('TernaryResult test', () => {
       throw new Error('boom');
     });
 
-    expect(TernaryResult.isErr(errorResult)).toBe(true);
+    assert.isTrue(TernaryResult.isErr(errorResult));
+  });
+
+  test('unwrapOkOr curried version', () => {
+    const unwrap = TernaryResult.unwrapOkOr(999);
+
+    expect(unwrap(TernaryResult.ok(42))).toBe(42);
+
+    expect(unwrap(TernaryResult.warn(10, 'notice'))).toBe(10);
+
+    expect(unwrap(TernaryResult.err('error'))).toBe(999);
+  });
+
+  test('unwrapWarnOr curried version', () => {
+    const unwrap = TernaryResult.unwrapWarnOr('default');
+
+    expect(unwrap(TernaryResult.warn(1, 'alert'))).toBe('alert');
+
+    expect(unwrap(TernaryResult.ok(5))).toBe('default');
+
+    expect(unwrap(TernaryResult.err('fail'))).toBe('default');
+  });
+
+  test('unwrapErrOr curried version', () => {
+    const unwrap = TernaryResult.unwrapErrOr('fallback');
+
+    expect(unwrap(TernaryResult.err('bad'))).toBe('bad');
+
+    expect(unwrap(TernaryResult.ok(3))).toBe('fallback');
+
+    expect(unwrap(TernaryResult.warn(1, 'note'))).toBe('fallback');
+  });
+
+  test('orElse curried version', () => {
+    const fallback = TernaryResult.ok('backup');
+
+    const useBackup = TernaryResult.orElse(fallback);
+
+    assert.deepStrictEqual(useBackup(TernaryResult.ok(1)), TernaryResult.ok(1));
+
+    assert.deepStrictEqual(
+      useBackup(TernaryResult.warn(2, 'w')),
+      TernaryResult.warn(2, 'w'),
+    );
+
+    assert.deepStrictEqual(useBackup(TernaryResult.err('e')), fallback);
   });
 });

package/src/globals.d.mts

@@ -13,7 +13,8 @@ type ArgArrayIndex<Ar extends readonly unknown[]> =
 
 type ArgArrayIndexWithNegative<Ar extends readonly unknown[]> =
   IsFixedLengthList<Ar> extends true
-    ? IndexOfTuple<[...Ar, 0]> | NegativeIndexOfTuple<Ar>
+    ? // eslint-disable-next-line @typescript-eslint/no-redundant-type-constituents
+        IndexOfTuple<[...Ar, 0]> | NegativeIndexOfTuple<Ar>
     : SizeType.ArgArrWithNegative;
 
 // https://developer.mozilla.org/ja/docs/Web/JavaScript/Reference/Global_Objects/Array/length
@@ -23,27 +24,37 @@ type ArgArrayIndexWithNegative<Ar extends readonly unknown[]> =
 
 declare namespace SizeType {
   type Arr = Uint32;
+
   type TypedArray = SafeUint;
+
   type Str = SafeUint;
 
   type ArrSearchResult = Arr | -1;
+
   type TypedArraySearchResult = TypedArray | -1;
+
   type StrSearchResult = Str | -1;
 
   type ArgArr = WithSmallInt<Arr>;
+
   type ArgTypedArray = WithSmallInt<TypedArray>;
+
   type ArgStr = WithSmallInt<Str>;
 
   type ArgArrWithNegative = WithSmallInt<
     NormalizeBrandUnion<NegativeInt32 | Arr>
   >;
+
   type ArgTypedArrayWithNegative = WithSmallInt<SafeInt>;
+
   type ArgStrWithNegative = WithSmallInt<SafeInt>;
 
   type ArgArrPositive = WithSmallInt<IntersectBrand<PositiveNumber, Arr>>;
+
   type ArgTypedArrayPositive = WithSmallInt<
     IntersectBrand<PositiveNumber, TypedArray>
   >;
+
   type ArgStrPositive = WithSmallInt<IntersectBrand<PositiveNumber, Str>>;
 }
 

package/src/guard/has-key.mts

@@ -21,9 +21,9 @@
  *
  * if (hasKey(maybeUser, 'id')) {
  *   // `maybeUser` is now known to have an `id` property.
- *   assert(maybeUser.id === 42);
+ *   assert.isTrue(maybeUser.id === 42);
  * } else {
- *   assert.fail('Expected the object to contain the id key.');
+ *   assert.fail();
  * }
  * ```
  *
@@ -58,11 +58,14 @@ export type HasKeyReturnType<
 > = R extends R // union distribution
   ? K extends keyof R
     ? string extends keyof R
-      ? ReadonlyRecord<K, R[keyof R]> & R
+      ? // eslint-disable-next-line @typescript-eslint/no-redundant-type-constituents
+        ReadonlyRecord<K, R[keyof R]> & R
       : number extends keyof R
-        ? ReadonlyRecord<K, R[keyof R]> & R
+        ? // eslint-disable-next-line @typescript-eslint/no-redundant-type-constituents
+          ReadonlyRecord<K, R[keyof R]> & R
         : symbol extends keyof R
-          ? ReadonlyRecord<K, R[keyof R]> & R
+          ? // eslint-disable-next-line @typescript-eslint/no-redundant-type-constituents
+            ReadonlyRecord<K, R[keyof R]> & R
           : R
     : never // omit union member that does not have key K
   : never; // dummy case for union distribution

package/src/guard/has-key.test.mts

@@ -61,11 +61,11 @@ import { hasKey, type HasKeyReturnType } from './has-key.mjs';
 {
   type R = Readonly<{ a: 0 }> | Readonly<{ b: 1 }>;
 
-  // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
   const obj: R = { a: 0 } as R;
 
   if (hasKey(obj, 'a')) {
     expectType<typeof obj.a, 0>('=');
+
     expectType<typeof obj, Readonly<{ a: 0 }>>('=');
   }
 
@@ -81,12 +81,13 @@ import { hasKey, type HasKeyReturnType } from './has-key.mjs';
     | Readonly<{ b: 2 }>
     | Readonly<{ c: 3 }>;
 
-  // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
   const obj: R = { a: 0 } as R;
 
   if (hasKey(obj, 'a') && hasKey(obj, 'b')) {
     expectType<typeof obj.a, 1>('=');
+
     expectType<typeof obj.b, 1>('=');
+
     expectType<typeof obj, Readonly<{ a: 1; b: 1 }>>('=');
   }
 }
@@ -98,7 +99,6 @@ import { hasKey, type HasKeyReturnType } from './has-key.mjs';
     | Readonly<{ a: 1; b: 1 }>
     | Readonly<{ b: 2 }>;
 
-  // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
   const obj: R = { a: 0 } as R;
 
   expectType<
@@ -122,7 +122,9 @@ import { hasKey, type HasKeyReturnType } from './has-key.mjs';
 
   if (hasKey(obj, 'a') && hasKey(obj, 'b')) {
     expectType<typeof obj.a, number>('=');
+
     expectType<typeof obj.b, number>('=');
+
     expectType<
       typeof obj,
       | Readonly<{ a: 1; b: 1 }>
@@ -138,6 +140,7 @@ import { hasKey, type HasKeyReturnType } from './has-key.mjs';
 
   if (hasKey(o, 'a')) {
     expectType<typeof o.a, unknown>('=');
+
     expectType<
       typeof o,
       ReadonlyRecord<'a', unknown> & ReadonlyRecord<string, unknown>
@@ -146,6 +149,7 @@ import { hasKey, type HasKeyReturnType } from './has-key.mjs';
 
   if (hasKey(o, 'c')) {
     expectType<typeof o.c, unknown>('=');
+
     expectType<
       typeof o,
       ReadonlyRecord<'c', unknown> & ReadonlyRecord<string, unknown>
@@ -154,7 +158,9 @@ import { hasKey, type HasKeyReturnType } from './has-key.mjs';
 
   if (hasKey(o, 'a') && hasKey(o, 'b')) {
     expectType<typeof o.a, unknown>('=');
+
     expectType<typeof o.b, unknown>('=');
+
     expectType<
       typeof o,
       ReadonlyRecord<'a', unknown> &
@@ -184,7 +190,6 @@ import { hasKey, type HasKeyReturnType } from './has-key.mjs';
         | Readonly<{ b: 2 }>
         | Record<string, number>;
 
-      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
       const o2 = { b: 2 } as O;
 
       if (hasOwnNaive(o2, 'a')) {
@@ -203,7 +208,6 @@ import { hasKey, type HasKeyReturnType } from './has-key.mjs';
         | Readonly<{ a: 1; b: 1 }>
         | Readonly<{ b: 2 }>;
 
-      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
       const o2 = { b: 2 } as O;
 
       if (hasOwnNaive(o2, 'a')) {

package/src/guard/is-error.test.mts

@@ -0,0 +1,143 @@
+/* eslint-disable functional/immutable-data */
+/* eslint-disable functional/no-class-inheritance */
+/* eslint-disable unicorn/error-message */
+import { isError as isErrorBySindreSorhus } from '@sindresorhus/is';
+import { expectType } from '../expect-type.mjs';
+
+describe('isError from @sindresorhus/is', () => {
+  test('should return true for native Error instances', () => {
+    assert.isTrue(isErrorBySindreSorhus(new Error()));
+
+    assert.isTrue(isErrorBySindreSorhus(new Error('test message')));
+  });
+
+  test('should return true for native Error subclasses', () => {
+    assert.isTrue(isErrorBySindreSorhus(new TypeError()));
+
+    assert.isTrue(isErrorBySindreSorhus(new RangeError()));
+
+    assert.isTrue(isErrorBySindreSorhus(new ReferenceError()));
+
+    assert.isTrue(isErrorBySindreSorhus(new SyntaxError()));
+
+    assert.isTrue(isErrorBySindreSorhus(new EvalError()));
+
+    assert.isTrue(isErrorBySindreSorhus(new URIError()));
+  });
+
+  test('should return true for custom Error subclasses', () => {
+    class CustomError extends Error {
+      constructor(message?: string) {
+        super(message);
+
+        this.name = 'CustomError';
+      }
+    }
+
+    assert.isTrue(isErrorBySindreSorhus(new CustomError()));
+
+    assert.isTrue(
+      isErrorBySindreSorhus(new CustomError('custom error message')),
+    );
+  });
+
+  test('should return true for Error subclass with additional properties', () => {
+    class ExtendedError extends Error {
+      code: number;
+
+      constructor(message: string, code: number) {
+        super(message);
+
+        this.name = 'ExtendedError';
+
+        this.code = code;
+      }
+    }
+
+    assert.isTrue(
+      isErrorBySindreSorhus(new ExtendedError('error with code', 404)),
+    );
+  });
+
+  test('should return true for deeply nested Error subclass', () => {
+    class BaseCustomError extends Error {
+      constructor(message?: string) {
+        super(message);
+
+        this.name = 'BaseCustomError';
+      }
+    }
+
+    class DerivedCustomError extends BaseCustomError {
+      constructor(message?: string) {
+        super(message);
+
+        this.name = 'DerivedCustomError';
+      }
+    }
+
+    assert.isTrue(isErrorBySindreSorhus(new DerivedCustomError()));
+  });
+
+  test('should return false for Error-like objects', () => {
+    const errorLikeObject = {
+      name: 'Error',
+      message: 'This is not a real error',
+      stack: 'fake stack trace',
+    };
+
+    assert.isFalse(isErrorBySindreSorhus(errorLikeObject));
+  });
+
+  test('should return false for non-Error values', () => {
+    assert.isFalse(isErrorBySindreSorhus(null));
+
+    assert.isFalse(isErrorBySindreSorhus(undefined));
+
+    assert.isFalse(isErrorBySindreSorhus(0));
+
+    assert.isFalse(isErrorBySindreSorhus(''));
+
+    assert.isFalse(isErrorBySindreSorhus('Error'));
+
+    assert.isFalse(isErrorBySindreSorhus(true));
+
+    assert.isFalse(isErrorBySindreSorhus({}));
+
+    assert.isFalse(isErrorBySindreSorhus([]));
+
+    assert.isFalse(isErrorBySindreSorhus(() => {}));
+  });
+
+  test('should act as a type guard', () => {
+    const value: Error | string = new Error('test');
+
+    if (isErrorBySindreSorhus(value)) {
+      expectType<typeof value, Error>('=');
+
+      expect(value.message).toBe('test');
+    }
+  });
+
+  test('should work with AggregateError', () => {
+    const aggregateError = new AggregateError(
+      [new Error('error 1'), new Error('error 2')],
+      'Multiple errors occurred',
+    );
+
+    assert.isTrue(isErrorBySindreSorhus(aggregateError));
+  });
+
+  test('should return false for errors created with Object.create', () => {
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+    const protoError = Object.create(Error.prototype);
+
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+    protoError.message = 'proto error';
+
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+    protoError.name = 'ProtoError';
+
+    assert.isFalse(isErrorBySindreSorhus(protoError));
+  });
+});

package/src/guard/is-non-empty-string.test.mts

@@ -3,37 +3,51 @@ import { isNonEmptyString } from './is-non-empty-string.mjs';
 
 describe(isNonEmptyString, () => {
   test('should return true for non-empty strings', () => {
-    expect(isNonEmptyString('hello')).toBe(true);
-    expect(isNonEmptyString('a')).toBe(true);
-    expect(isNonEmptyString(' ')).toBe(true); // Space is not empty
-    expect(isNonEmptyString('  multiple spaces  ')).toBe(true);
-    expect(isNonEmptyString('123')).toBe(true);
-    expect(isNonEmptyString('special!@#$%')).toBe(true);
+    assert.isTrue(isNonEmptyString('hello'));
+
+    assert.isTrue(isNonEmptyString('a'));
+
+    assert.isTrue(isNonEmptyString(' ')); // Space is not empty
+
+    assert.isTrue(isNonEmptyString('  multiple spaces  '));
+
+    assert.isTrue(isNonEmptyString('123'));
+
+    assert.isTrue(isNonEmptyString('special!@#$%'));
   });
 
   test('should return false for empty string', () => {
-    expect(isNonEmptyString('')).toBe(false);
+    assert.isFalse(isNonEmptyString(''));
   });
 
   test('should return false for non-string values', () => {
-    expect(isNonEmptyString(null)).toBe(false);
-    expect(isNonEmptyString(undefined)).toBe(false);
+    assert.isFalse(isNonEmptyString(null));
+
+    assert.isFalse(isNonEmptyString(undefined));
+
     // @ts-expect-error Testing non-string types
-    expect(isNonEmptyString(42)).toBe(false);
+    assert.isFalse(isNonEmptyString(42));
+
     // @ts-expect-error Testing non-string types
-    expect(isNonEmptyString(0)).toBe(false);
+    assert.isFalse(isNonEmptyString(0));
+
     // @ts-expect-error Testing non-string types
-    expect(isNonEmptyString(true)).toBe(false);
+    assert.isFalse(isNonEmptyString(true));
+
     // @ts-expect-error Testing non-string types
-    expect(isNonEmptyString(false)).toBe(false);
+    assert.isFalse(isNonEmptyString(false));
+
     // @ts-expect-error Testing non-string types
-    expect(isNonEmptyString({})).toBe(false);
+    assert.isFalse(isNonEmptyString({}));
+
     // @ts-expect-error Testing non-string types
-    expect(isNonEmptyString([])).toBe(false);
+    assert.isFalse(isNonEmptyString([]));
+
     // @ts-expect-error Testing non-string types
-    expect(isNonEmptyString(['string'])).toBe(false);
+    assert.isFalse(isNonEmptyString(['string']));
+
     // @ts-expect-error Testing non-string types
-    expect(isNonEmptyString(() => 'string')).toBe(false);
+    assert.isFalse(isNonEmptyString(() => 'string'));
   });
 
   test('should act as a type guard', () => {
@@ -45,6 +59,7 @@ describe(isNonEmptyString, () => {
 
       // TypeScript knows it's a string
       expect(value.length).toBeGreaterThan(0);
+
       expect(value.charAt(0)).toBe('t');
     }
   });
@@ -78,17 +93,22 @@ describe(isNonEmptyString, () => {
   });
 
   test('should handle string edge cases', () => {
-    expect(isNonEmptyString('\n')).toBe(true); // Newline
-    expect(isNonEmptyString('\t')).toBe(true); // Tab
-    expect(isNonEmptyString('\r')).toBe(true); // Carriage return
-    expect(isNonEmptyString('\0')).toBe(true); // Null character
-    expect(isNonEmptyString('🎉')).toBe(true); // Emoji
-    expect(isNonEmptyString('你好')).toBe(true); // Unicode characters
+    assert.isTrue(isNonEmptyString('\n')); // Newline
+
+    assert.isTrue(isNonEmptyString('\t')); // Tab
+
+    assert.isTrue(isNonEmptyString('\r')); // Carriage return
+
+    assert.isTrue(isNonEmptyString('\0')); // Null character
+
+    assert.isTrue(isNonEmptyString('🎉')); // Emoji
+
+    assert.isTrue(isNonEmptyString('你好')); // Unicode characters
   });
 
   test('should not accept String objects', () => {
     // @ts-expect-error Testing non-string types
     // eslint-disable-next-line unicorn/new-for-builtins
-    expect(isNonEmptyString(new String('hello') as unknown)).toBe(false);
+    assert.isFalse(isNonEmptyString(new String('hello') as unknown));
   });
 });