npm - ts-data-forge - Versions diffs - 5.0.1 → 5.1.1 - Mend

ts-data-forge 5.0.1 → 5.1.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (539) hide show

package/src/functional/ternary-result/impl/ternary-result-err.mts CHANGED Viewed

@@ -9,10 +9,11 @@ import { ErrTypeTagName } from './tag.mjs';
  * const failure = TernaryResult.err(new Error('missing data'));
  *
  * assert.strictEqual(failure.$$tag, 'ts-data-forge::Result.err');
- * assert.ok(TernaryResult.isErr(failure));
+ *
+ * assert.isTrue(TernaryResult.isErr(failure));
  * ```
  */
-export const err = <E,>(value: E): TernaryErr<E> => ({
+export const err = <const E,>(value: E): TernaryErr<E> => ({
   $$tag: ErrTypeTagName,
   value,
 });

package/src/functional/ternary-result/impl/ternary-result-expect-to-be.mts CHANGED Viewed

@@ -11,6 +11,7 @@ import { type UnwrapOk } from './types.mjs';
  * const okValue = TernaryResult.ok('ready');
  *
  * assert.strictEqual(TernaryResult.expectToBe(okValue, 'missing'), 'ready');
+ *
  * const expectResult = TernaryResult.expectToBe<string>('needs value');
  *
  * assert.throws(() => expectResult(TernaryResult.err('oops')), /needs value/u);
@@ -32,10 +33,13 @@ export function expectToBe<R extends UnknownTernaryResult>(
   switch (args.length) {
     case 2: {
       const [result, message] = args;
       return expectImpl(result, message);
     }
     case 1: {
       const [message] = args;
       return (result: R) => expectImpl(result, message);
     }
   }

package/src/functional/ternary-result/impl/ternary-result-flat-map.mts CHANGED Viewed

@@ -17,14 +17,18 @@ import { type UnwrapErr, type UnwrapOk, type UnwrapWarn } from './types.mjs';
  * const doubled = TernaryResult.flatMap(TernaryResult.ok('3'), (text) =>
  *   TernaryResult.map(parse(text), (num) => num * 2),
  * );
+ *
  * const warnPassthrough = TernaryResult.flatMap(
  *   TernaryResult.warn('3', 'retry'),
  *   parse,
  * );
+ *
  * const errPassthrough = TernaryResult.flatMap(TernaryResult.err('oops'), parse);
  *
  * assert.deepStrictEqual(doubled, TernaryResult.ok(6));
+ *
  * assert.deepStrictEqual(warnPassthrough, TernaryResult.warn(3, 'retry'));
+ *
  * assert.deepStrictEqual(errPassthrough, TernaryResult.err('oops'));
  * ```
  */
@@ -51,10 +55,13 @@ export function flatMap<R extends UnknownTernaryResult, S2, W2, E2>(
   switch (args.length) {
     case 2: {
       const [result, flatMapFn] = args;
       return flatMapImpl(result, flatMapFn);
     }
     case 1: {
       const [flatMapFn] = args;
       return (result: R) => flatMapImpl(result, flatMapFn);
     }
   }

package/src/functional/ternary-result/impl/ternary-result-fold.mts CHANGED Viewed

@@ -17,6 +17,7 @@ import { type UnwrapErr, type UnwrapOk, type UnwrapWarn } from './types.mjs';
  *   (warn: string) => warn.length,
  *   (error: string) => error.toUpperCase(),
  * );
+ *
  * const warnFold = TernaryResult.fold(
  *   TernaryResult.warn(2, 'spike'),
  *   (value: number) => value,
@@ -25,6 +26,7 @@ import { type UnwrapErr, type UnwrapOk, type UnwrapWarn } from './types.mjs';
  * );
  *
  * assert.deepStrictEqual(okFold, TernaryResult.ok(4));
+ *
  * assert.deepStrictEqual(warnFold, TernaryResult.warn(2, 'SPIKE'));
  * ```
  */
@@ -59,10 +61,13 @@ export function fold<R extends UnknownTernaryResult, S2, W2, E2>(
   switch (args.length) {
     case 4: {
       const [result, mapOk, mapWarn, mapErr] = args;
       return foldImpl(result, mapOk, mapWarn, mapErr);
     }
     case 3: {
       const [mapOk, mapWarn, mapErr] = args;
       return (result: R) => foldImpl(result, mapOk, mapWarn, mapErr);
     }
   }

package/src/functional/ternary-result/impl/ternary-result-from-promise.mts CHANGED Viewed

@@ -12,12 +12,14 @@ type UnwrapPromise<P extends Promise<unknown>> =
  *
  * ```ts
  * const resolved = await TernaryResult.fromPromise(Promise.resolve('ok'));
+ *
  * const rejected = await TernaryResult.fromPromise(
  *   Promise.reject(new Error('fail')),
  * );
  *
  * assert.deepStrictEqual(resolved, TernaryResult.ok('ok'));
- * assert.ok(TernaryResult.isErr(rejected));
+ *
+ * assert.isTrue(TernaryResult.isErr(rejected));
  * ```
  */
 export const fromPromise = <P extends Promise<unknown>>(

package/src/functional/ternary-result/impl/ternary-result-from-throwable.mts CHANGED Viewed

@@ -10,12 +10,14 @@ import { ok } from './ternary-result-ok.mjs';
  *
  * ```ts
  * const success = TernaryResult.fromThrowable(() => 1 + 1);
+ *
  * const failure = TernaryResult.fromThrowable(() => {
  *   throw new Error('boom');
  * });
  *
  * assert.deepStrictEqual(success, TernaryResult.ok(2));
- * assert.ok(TernaryResult.isErr(failure));
+ *
+ * assert.isTrue(TernaryResult.isErr(failure));
  * ```
  */
 export const fromThrowable = <T,>(
@@ -27,6 +29,7 @@ export const fromThrowable = <T,>(
     if (isError(error)) {
       return err(error);
     }
     return err(new Error(unknownToString(error)));
   }
 };

package/src/functional/ternary-result/impl/ternary-result-is-ok.mts CHANGED Viewed

@@ -15,6 +15,7 @@ import { type NarrowToOk } from './types.mjs';
  *
  * if (TernaryResult.isOk(maybeNumber)) {
  *   const value: number = maybeNumber.value;
+ *
  *   assert.strictEqual(value, 42);
  * }
  * ```

package/src/functional/ternary-result/impl/ternary-result-is-ternary-result.mts CHANGED Viewed

@@ -8,12 +8,16 @@ import { ErrTypeTagName, OkTypeTagName, WarnTypeTagName } from './tag.mjs';
  *
  * ```ts
  * const okValue = TernaryResult.ok('done');
+ *
  * const warnValue = TernaryResult.warn('done', 'retry later');
+ *
  * const notResult = { $$tag: 'ts-data-forge::Result.ok' };
  *
- * assert.ok(TernaryResult.isTernaryResult(okValue));
- * assert.ok(TernaryResult.isTernaryResult(warnValue));
- * assert.ok(!TernaryResult.isTernaryResult(notResult));
+ * assert.isTrue(TernaryResult.isTernaryResult(okValue));
+ *
+ * assert.isTrue(TernaryResult.isTernaryResult(warnValue));
+ *
+ * assert.isFalse(TernaryResult.isTernaryResult(notResult));
  * ```
  */
 export const isTernaryResult = (

package/src/functional/ternary-result/impl/ternary-result-is-warn.mts CHANGED Viewed

@@ -15,6 +15,7 @@ import { type NarrowToWarn } from './types.mjs';
  *
  * if (TernaryResult.isWarn(maybeWarn)) {
  *   assert.strictEqual(maybeWarn.value, 'value');
+ *
  *   assert.strictEqual(maybeWarn.warning, 'check logs');
  * }
  * ```

package/src/functional/ternary-result/impl/ternary-result-map-err.mts CHANGED Viewed

@@ -9,15 +9,18 @@ import { type UnwrapErr, type UnwrapOk, type UnwrapWarn } from './types.mjs';
  *
  * ```ts
  * const errValue = TernaryResult.err('boom');
+ *
  * const mappedErr = TernaryResult.mapErr(errValue, (error) =>
  *   error.toUpperCase(),
  * );
+ *
  * const warnPassthrough = TernaryResult.mapErr(
  *   TernaryResult.warn(2, 'slow'),
  *   (error: string) => `${error}!`,
  * );
  *
  * assert.deepStrictEqual(mappedErr, TernaryResult.err('BOOM'));
+ *
  * assert.deepStrictEqual(warnPassthrough, TernaryResult.warn(2, 'slow'));
  * ```
  */
@@ -41,10 +44,13 @@ export function mapErr<R extends UnknownTernaryResult, E2>(
   switch (args.length) {
     case 2: {
       const [result, mapFn] = args;
       return mapErrImpl(result, mapFn);
     }
     case 1: {
       const [mapFn] = args;
       return (result: R) => mapErrImpl(result, mapFn);
     }
   }

package/src/functional/ternary-result/impl/ternary-result-map-warn.mts CHANGED Viewed

@@ -9,13 +9,16 @@ import { type UnwrapErr, type UnwrapOk, type UnwrapWarn } from './types.mjs';
  *
  * ```ts
  * const warnValue = TernaryResult.warn(2, 'slow');
+ *
  * const mappedWarn = TernaryResult.mapWarn(warnValue, (warning) => `${warning}!`);
+ *
  * const okPassthrough = TernaryResult.mapWarn(
  *   TernaryResult.ok(3),
  *   (value: number) => value * 2,
  * );
  *
  * assert.deepStrictEqual(mappedWarn, TernaryResult.warn(2, 'slow!'));
+ *
  * assert.deepStrictEqual(okPassthrough, TernaryResult.ok(3));
  * ```
  */
@@ -39,10 +42,13 @@ export function mapWarn<R extends UnknownTernaryResult, W2>(
   switch (args.length) {
     case 2: {
       const [result, mapFn] = args;
       return mapWarnImpl(result, mapFn);
     }
     case 1: {
       const [mapFn] = args;
       return (result: R) => mapWarnImpl(result, mapFn);
     }
   }

package/src/functional/ternary-result/impl/ternary-result-map.mts CHANGED Viewed

@@ -11,21 +11,27 @@ import { type UnwrapErr, type UnwrapOk, type UnwrapWarn } from './types.mjs';
  *
  * ```ts
  * const okNumber = TernaryResult.ok(5);
+ *
  * const warnValue = TernaryResult.warn(5, 'slow');
+ *
  * const errValue = TernaryResult.err('bad');
  *
  * const doubled = TernaryResult.map(okNumber, (value) => value * 2);
+ *
  * const warnPassthrough = TernaryResult.map(
  *   warnValue,
  *   (value: number) => value * 2,
  * );
+ *
  * const errPassthrough = TernaryResult.map(
  *   errValue,
  *   (value: number) => value * 2,
  * );
  *
  * assert.deepStrictEqual(doubled, TernaryResult.ok(10));
+ *
  * assert.deepStrictEqual(warnPassthrough, TernaryResult.warn(10, 'slow'));
+ *
  * assert.deepStrictEqual(errPassthrough, errValue);
  * ```
  */
@@ -49,10 +55,13 @@ export function map<R extends UnknownTernaryResult, S2>(
   switch (args.length) {
     case 2: {
       const [result, mapFn] = args;
       return mapImpl(result, mapFn);
     }
     case 1: {
       const [mapFn] = args;
       return (result: R) => mapImpl(result, mapFn);
     }
   }

package/src/functional/ternary-result/impl/ternary-result-ok.mts CHANGED Viewed

@@ -14,7 +14,7 @@ import { OkTypeTagName } from './tag.mjs';
  * });
  * ```
  */
-export const ok = <S,>(value: S): TernaryOk<S> => ({
+export const ok = <const S,>(value: S): TernaryOk<S> => ({
   $$tag: OkTypeTagName,
   value,
 });

package/src/functional/ternary-result/impl/ternary-result-or-else.mts CHANGED Viewed

@@ -14,10 +14,12 @@ import { type NarrowToOk, type NarrowToWarn } from './types.mjs';
  *   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,
@@ -47,10 +49,13 @@ export function orElse<
   switch (args.length) {
     case 2: {
       const [result, alternative] = args;
       return orElseImpl(result, alternative);
     }
     case 1: {
       const [alternative] = args;
       return (result: R) => orElseImpl(result, alternative);
     }
   }

package/src/functional/ternary-result/impl/ternary-result-to-optional.mts CHANGED Viewed

@@ -10,9 +10,11 @@ import { type UnwrapOk } from './types.mjs';
  *
  * ```ts
  * const okValue = TernaryResult.ok(7);
+ *
  * const warnValue = TernaryResult.warn(7, 'warn');
  *
  * assert.deepStrictEqual(TernaryResult.toOptional(okValue), Optional.some(7));
+ *
  * assert.deepStrictEqual(TernaryResult.toOptional(warnValue), Optional.some(7));
  * ```
  */

package/src/functional/ternary-result/impl/ternary-result-unwrap-err-or.mts CHANGED Viewed

@@ -10,9 +10,11 @@ import { type UnwrapErr } from './types.mjs';
  * const okValue = TernaryResult.ok('value');
  *
  * assert.strictEqual(TernaryResult.unwrapErrOr(okValue, 'default'), 'default');
+ *
  * const unwrapErr = TernaryResult.unwrapErrOr('fallback error');
  *
  * assert.strictEqual(unwrapErr(TernaryResult.err('boom')), 'boom');
+ *
  * assert.strictEqual(
  *   unwrapErr(TernaryResult.warn('value', 'warn')),
  *   'fallback error',
@@ -35,10 +37,13 @@ export function unwrapErrOr<R extends UnknownTernaryResult, D>(
   switch (args.length) {
     case 2: {
       const [result, defaultValue] = args;
       return unwrapErr(result) ?? defaultValue;
     }
     case 1: {
       const [defaultValue] = args;
       return (result: R) => unwrapErr(result) ?? defaultValue;
     }
   }

package/src/functional/ternary-result/impl/ternary-result-unwrap-err-throw.mts CHANGED Viewed

@@ -13,6 +13,7 @@ import { variantName } from './variant-name.mjs';
  * const errValue = TernaryResult.err('boom');
  *
  * assert.strictEqual(TernaryResult.unwrapErrThrow(errValue), 'boom');
+ *
  * assert.throws(
  *   () => TernaryResult.unwrapErrThrow(TernaryResult.ok('value')),
  *   /Expected Err/u,

package/src/functional/ternary-result/impl/ternary-result-unwrap-err.mts CHANGED Viewed

@@ -8,9 +8,11 @@ import { type UnwrapErr } from './types.mjs';
  *
  * ```ts
  * const errValue = TernaryResult.err('fail');
+ *
  * const okValue = TernaryResult.ok('value');
  *
  * assert.strictEqual(TernaryResult.unwrapErr(errValue), 'fail');
+ *
  * // eslint-disable-next-line @typescript-eslint/no-confusing-void-expression
  * assert.strictEqual(TernaryResult.unwrapErr(okValue), undefined);
  * ```

package/src/functional/ternary-result/impl/ternary-result-unwrap-ok-or.mts CHANGED Viewed

@@ -10,9 +10,11 @@ import { type UnwrapOk } from './types.mjs';
  * const errValue = TernaryResult.err('err');
  *
  * assert.strictEqual(TernaryResult.unwrapOkOr(errValue, 0), 0);
+ *
  * const unwrapWithDefault = TernaryResult.unwrapOkOr('fallback');
  *
  * assert.strictEqual(unwrapWithDefault(TernaryResult.ok(5)), 5);
+ *
  * assert.strictEqual(
  *   unwrapWithDefault(TernaryResult.warn('warn-value', 'warn')),
  *   'warn-value',
@@ -35,10 +37,13 @@ export function unwrapOkOr<R extends UnknownTernaryResult, D>(
   switch (args.length) {
     case 2: {
       const [result, defaultValue] = args;
       return unwrapOk(result) ?? defaultValue;
     }
     case 1: {
       const [defaultValue] = args;
       return (result: R) => unwrapOk(result) ?? defaultValue;
     }
   }

package/src/functional/ternary-result/impl/ternary-result-unwrap-ok.mts CHANGED Viewed

@@ -9,13 +9,16 @@ import { type UnwrapOk } from './types.mjs';
  *
  * ```ts
  * const okValue = TernaryResult.ok(3);
+ *
  * const warnValue = TernaryResult.warn(4, 'warn');
  *
  * assert.strictEqual(TernaryResult.unwrapOk(okValue), 3);
+ *
  * assert.strictEqual(TernaryResult.unwrapOk(warnValue), 4);
  * ```
  */
 export function unwrapOk<R extends TernaryOk<unknown>>(result: R): UnwrapOk<R>;
 export function unwrapOk<R extends UnknownTernaryResult>(
   result: R,
 ): UnwrapOk<R> | undefined;

package/src/functional/ternary-result/impl/ternary-result-unwrap-throw.mts CHANGED Viewed

@@ -12,6 +12,7 @@ import { type UnwrapErr, type UnwrapOk, type UnwrapWarn } from './types.mjs';
  * const okValue = TernaryResult.ok('ready');
  *
  * assert.strictEqual(TernaryResult.unwrapThrow(okValue), 'ready');
+ *
  * assert.throws(
  *   () => TernaryResult.unwrapThrow(TernaryResult.warn('warn', 'warned')),
  *   /Expected Ok/u,

package/src/functional/ternary-result/impl/ternary-result-unwrap-warn-or.mts CHANGED Viewed

@@ -10,9 +10,11 @@ import { type UnwrapWarn } from './types.mjs';
  * const okValue = TernaryResult.ok('value');
  *
  * assert.strictEqual(TernaryResult.unwrapWarnOr(okValue, 'warn'), 'warn');
+ *
  * const unwrapWarn = TernaryResult.unwrapWarnOr('fallback warn');
  *
  * assert.strictEqual(unwrapWarn(TernaryResult.warn('value', 'slow')), 'slow');
+ *
  * assert.strictEqual(unwrapWarn(TernaryResult.err('err')), 'fallback warn');
  * ```
  */
@@ -32,10 +34,13 @@ export function unwrapWarnOr<R extends UnknownTernaryResult, D>(
   switch (args.length) {
     case 2: {
       const [result, defaultValue] = args;
       return unwrapWarn(result) ?? defaultValue;
     }
     case 1: {
       const [defaultValue] = args;
       return (result: R) => unwrapWarn(result) ?? defaultValue;
     }
   }

package/src/functional/ternary-result/impl/ternary-result-unwrap-warn-throw.mts CHANGED Viewed

@@ -12,6 +12,7 @@ import { variantName } from './variant-name.mjs';
  * const warnValue = TernaryResult.warn('pending', 'check logs');
  *
  * assert.strictEqual(TernaryResult.unwrapWarnThrow(warnValue), 'check logs');
+ *
  * assert.throws(
  *   () => TernaryResult.unwrapWarnThrow(TernaryResult.err('err')),
  *   /Expected Warn/u,

package/src/functional/ternary-result/impl/ternary-result-unwrap-warn.mts CHANGED Viewed

@@ -8,9 +8,11 @@ import { type UnwrapWarn } from './types.mjs';
  *
  * ```ts
  * const warnValue = TernaryResult.warn('ok', 'careful');
+ *
  * const okValue = TernaryResult.ok('ok');
  *
  * assert.strictEqual(TernaryResult.unwrapWarn(warnValue), 'careful');
+ *
  * // eslint-disable-next-line @typescript-eslint/no-confusing-void-expression
  * assert.strictEqual(TernaryResult.unwrapWarn(okValue), undefined);
  * ```

package/src/functional/ternary-result/impl/ternary-result-warn.mts CHANGED Viewed

@@ -16,7 +16,10 @@ import { WarnTypeTagName } from './tag.mjs';
  * });
  * ```
  */
-export const warn = <S, W>(value: S, warning: W): TernaryWarn<S, W> => ({
+export const warn = <const S, const W>(
+  value: S,
+  warning: W,
+): TernaryWarn<S, W> => ({
   $$tag: WarnTypeTagName,
   value,
   warning,

package/src/functional/ternary-result/impl/ternary-result-zip.mts CHANGED Viewed

@@ -10,20 +10,24 @@ import { warn } from './ternary-result-warn.mjs';
  *
  * ```ts
  * const okPair = TernaryResult.zip(TernaryResult.ok('left'), TernaryResult.ok(1));
+ *
  * const warnPair = TernaryResult.zip(
  *   TernaryResult.warn('left', 'warn'),
  *   TernaryResult.ok(1),
  * );
+ *
  * const errPair = TernaryResult.zip(
  *   TernaryResult.ok('left'),
  *   TernaryResult.err('err'),
  * );
  *
  * assert.deepStrictEqual(okPair, TernaryResult.ok(['left', 1] as const));
+ *
  * assert.deepStrictEqual(
  *   warnPair,
  *   TernaryResult.warn(['left', 1] as const, 'warn'),
  * );
+ *
  * assert.deepStrictEqual(errPair, TernaryResult.err('err'));
  * ```
  */