ts-data-forge 5.0.1 → 5.1.1

package/src/functional/optional/impl/optional-map.mts

@@ -14,6 +14,7 @@ import { type Unwrap } from './types.mjs';
  *
  * ```ts
  * const numberOptional = Optional.some(21);
+ *
  * const mapped = Optional.map(numberOptional, (value) => value * 2);
  *
  * assert.deepStrictEqual(mapped, Optional.some(42));
@@ -21,6 +22,7 @@ import { type Unwrap } from './types.mjs';
  * const mapToLength = Optional.map((text: string) => text.length);
  *
  * assert.deepStrictEqual(mapToLength(Optional.some('abc')), Optional.some(3));
+ *
  * assert.deepStrictEqual(mapToLength(Optional.none), Optional.none);
  * ```
  *
@@ -49,11 +51,14 @@ export function map<O extends UnknownOptional, S2>(
   switch (args.length) {
     case 2: {
       const [optional, mapFn] = args;
+
       return mapImpl(optional, mapFn);
     }
+
     case 1: {
       // Curried version: first argument is mapping function
       const [mapFn] = args;
+
       return (optional: O) => mapImpl(optional, mapFn);
     }
   }

package/src/functional/optional/impl/optional-none.mts

@@ -8,10 +8,12 @@ import { NoneTypeTagName } from './tag.mjs';
  *
  * ```ts
  * const someValue = Optional.some({ id: 1 });
+ *
  * const noneValue = Optional.none;
  *
- * assert.ok(Optional.isSome(someValue));
- * assert.ok(Optional.isNone(noneValue));
+ * assert.isTrue(Optional.isSome(someValue));
+ *
+ * assert.isTrue(Optional.isNone(noneValue));
  * ```
  */
 export const none: None = { $$tag: NoneTypeTagName } as const;

package/src/functional/optional/impl/optional-or-else.mts

@@ -12,15 +12,19 @@ import { type Unwrap } from './types.mjs';
  *
  * ```ts
  * const preferred = Optional.some('primary');
+ *
  * const fallback = Optional.some('secondary');
+ *
  * const noneValue = Optional.none as Optional<string>;
  *
  * assert.deepStrictEqual(Optional.orElse(preferred, fallback), preferred);
+ *
  * assert.deepStrictEqual(Optional.orElse(noneValue, fallback), fallback);
  *
  * const orElseFallback = Optional.orElse(Optional.some('default'));
  *
  * assert.deepStrictEqual(orElseFallback(Optional.none), Optional.some('default'));
+ *
  * assert.deepStrictEqual(
  *   orElseFallback(Optional.some('value')),
  *   Optional.some('value'),
@@ -52,12 +56,14 @@ export function orElse<
   switch (args.length) {
     case 2: {
       const [optional, alternative] = args;
+
       return orElseImpl(optional, alternative);
     }
 
     case 1: {
       // Curried version
       const [alternative] = args;
+
       return (optional: Optional<Unwrap<O>>) =>
         orElseImpl(optional, alternative);
     }

package/src/functional/optional/impl/optional-some.mts

@@ -7,17 +7,19 @@ import { SomeTypeTagName } from './tag.mjs';
  *
  * ```ts
  * const someValue = Optional.some({ id: 1 });
+ *
  * const noneValue = Optional.none;
  *
- * assert.ok(Optional.isSome(someValue));
- * assert.ok(Optional.isNone(noneValue));
+ * assert.isTrue(Optional.isSome(someValue));
+ *
+ * assert.isTrue(Optional.isNone(noneValue));
  * ```
  *
  * @template S The type of the value.
  * @param value The value to wrap in an {@link Some}.
  * @returns An {@link Some}<S> containing the value.
  */
-export const some = <S,>(value: S): Some<S> => ({
+export const some = <const S,>(value: S): Some<S> => ({
   $$tag: SomeTypeTagName,
   value,
 });

package/src/functional/optional/impl/optional-to-nullable.mts

@@ -16,10 +16,12 @@ import { type Unwrap } from './types.mjs';
  *
  * ```ts
  * const someNumber = Optional.some(42);
+ *
  * const noneNumber = Optional.none as Optional<number>;
  *
- * assert(Optional.toNullable(someNumber) === 42);
- * assert(Optional.toNullable(noneNumber) === undefined);
+ * assert.isTrue(Optional.toNullable(someNumber) === 42);
+ *
+ * assert.isTrue(Optional.toNullable(noneNumber) === undefined);
  * ```
  *
  * @template O The `UnknownOptional` type to convert.

package/src/functional/optional/impl/optional-unwrap-or.mts

@@ -13,15 +13,18 @@ import { type Unwrap } from './types.mjs';
  *
  * ```ts
  * const withValue = Optional.some(5);
+ *
  * const withoutValue = Optional.none as Optional<number>;
  *
- * assert(Optional.unwrapOr(withValue, 0) === 5);
- * assert(Optional.unwrapOr(withoutValue, 0) === 0);
+ * assert.isTrue(Optional.unwrapOr(withValue, 0) === 5);
+ *
+ * assert.isTrue(Optional.unwrapOr(withoutValue, 0) === 0);
  *
  * const unwrapWithDefault = Optional.unwrapOr(10);
  *
- * assert(unwrapWithDefault(Optional.some(3)) === 3);
- * assert(unwrapWithDefault(Optional.none) === 10);
+ * assert.isTrue(unwrapWithDefault(Optional.some(3)) === 3);
+ *
+ * assert.isTrue(unwrapWithDefault(Optional.none) === 10);
  * ```
  *
  * @template O The `UnknownOptional` type to unwrap.
@@ -46,12 +49,14 @@ export function unwrapOr<O extends UnknownOptional, D>(
   switch (args.length) {
     case 2: {
       const [optional, defaultValue] = args;
+
       return unwrapOrImpl(optional, defaultValue);
     }
 
     case 1: {
       // Curried version: first argument is default value
       const [defaultValue] = args;
+
       return (optional: Optional<Unwrap<O>>) =>
         unwrapOrImpl(optional, defaultValue);
     }

package/src/functional/optional/impl/optional-unwrap-throw.mts

@@ -14,7 +14,8 @@ import { type Unwrap } from './types.mjs';
  * ```ts
  * const present = Optional.some('available');
  *
- * assert(Optional.unwrapThrow(present) === 'available');
+ * assert.isTrue(Optional.unwrapThrow(present) === 'available');
+ *
  * assert.throws(
  *   () => Optional.unwrapThrow(Optional.none),
  *   /has failed because it is `None`/u,

package/src/functional/optional/impl/optional-unwrap.mts

@@ -15,10 +15,12 @@ import { type Unwrap } from './types.mjs';
  *
  * ```ts
  * const someString = Optional.some('text');
+ *
  * const noneString = Optional.none as Optional<string>;
  *
- * assert(Optional.unwrap(someString) === 'text');
- * assert(Optional.unwrap(noneString) === undefined);
+ * assert.isTrue(Optional.unwrap(someString) === 'text');
+ *
+ * assert.isTrue(Optional.unwrap(noneString) === undefined);
  * ```
  *
  * @template O The `UnknownOptional` type to unwrap.

package/src/functional/optional/impl/optional-zip.mts

@@ -11,9 +11,11 @@ import { some } from './optional-some.mjs';
  * ```ts
  * const zipped = Optional.zip(Optional.some('left'), Optional.some(1));
  *
- * assert.ok(Optional.isSome(zipped));
+ * assert.isTrue(Optional.isSome(zipped));
+ *
  * if (Optional.isSome(zipped)) {
  *   const expected: readonly [string, number] = ['left', 1];
+ *
  *   assert.deepStrictEqual(zipped.value, expected);
  * }
  *