ts-data-forge 14.6.2 → 14.6.3

package/dist/functional/ternary-result/impl/ternary-result-err.mjs

@@ -1,17 +1,17 @@
 import { ErrTypeTagName } from './tag.mjs';
-/**
- * Creates a `TernaryResult.Err` containing the provided error value.
- *
- * @example
- *
- * ```ts
- * const failure = TernaryResult.err(new Error('missing data'));
- *
- * assert.strictEqual(failure.$$tag, 'ts-data-forge::Result.err');
- *
- * assert.isTrue(TernaryResult.isErr(failure));
- * ```
- */
+
+
+
+
+
+
+
+
+
+
+
+
+
 export const err = (value) => ({
     $$tag: ErrTypeTagName,
     value,

package/dist/functional/ternary-result/impl/ternary-result-flat-map.mjs

@@ -15,16 +15,16 @@ export function flatMap(...args) {
 }
 const flatMapImpl = (result, flatMapFn) => {
     if (isOk(result)) {
-        // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+
         return flatMapFn(result.value);
     }
     if (isWarn(result)) {
         const next = flatMapFn(
-        // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+
         result.value);
         if (isOk(next)) {
             return warn(next.value, 
-            // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+
             result.warning);
         }
         if (isWarn(next)) {
@@ -32,7 +32,7 @@ const flatMapImpl = (result, flatMapFn) => {
         }
         return next;
     }
-    // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+
     return result;
 };
 //# sourceMappingURL=ternary-result-flat-map.mjs.map

package/dist/functional/ternary-result/impl/ternary-result-fold.mjs

@@ -17,17 +17,17 @@ export function fold(...args) {
 }
 const foldImpl = (result, mapOk, mapWarnFn, mapErrFn) => {
     if (isOk(result)) {
-        // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+
         return ok(mapOk(result.value));
     }
     if (isWarn(result)) {
         return warn(
-        // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+
         mapOk(result.value), 
-        // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+
         mapWarnFn(result.warning));
     }
-    // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+
     return err(mapErrFn(result.value));
 };
 //# sourceMappingURL=ternary-result-fold.mjs.map

package/dist/functional/ternary-result/impl/ternary-result-from-promise.mjs

@@ -1,23 +1,23 @@
 import { err } from './ternary-result-err.mjs';
 import { ok } from './ternary-result-ok.mjs';
-/**
- * Converts a Promise into a Promise that resolves to a `TernaryResult`.
- *
- * @example
- *
- * ```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.isTrue(TernaryResult.isErr(rejected));
- * ```
- */
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 export const fromPromise = (promise) => 
-// eslint-disable-next-line total-functions/no-unsafe-type-assertion
+
 promise.then((value) => ok(value)).catch(err);
 //# sourceMappingURL=ternary-result-from-promise.mjs.map

package/dist/functional/ternary-result/impl/ternary-result-from-throwable.mjs

@@ -2,23 +2,23 @@ import { isError } from '@sindresorhus/is';
 import { unknownToString } from '../../../others/index.mjs';
 import { err } from './ternary-result-err.mjs';
 import { ok } from './ternary-result-ok.mjs';
-/**
- * Wraps a potentially-throwing function in a `TernaryResult`.
- *
- * @example
- *
- * ```ts
- * const success = TernaryResult.fromThrowable(() => 1 + 1);
- *
- * const failure = TernaryResult.fromThrowable(() => {
- *   throw new Error('boom');
- * });
- *
- * assert.deepStrictEqual(success, TernaryResult.ok(2));
- *
- * assert.isTrue(TernaryResult.isErr(failure));
- * ```
- */
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 export const fromThrowable = (fn) => {
     try {
         return ok(fn());

package/dist/functional/ternary-result/impl/ternary-result-is-err.mjs

@@ -1,20 +1,20 @@
 import { ErrTypeTagName } from './tag.mjs';
-/**
- * Type guard for the Err variant.
- *
- * @example
- *
- * ```ts
- * const maybeErr = TernaryResult.err('boom') as TernaryResult<
- *   number,
- *   string,
- *   string
- * >;
- *
- * if (TernaryResult.isErr(maybeErr)) {
- *   assert.strictEqual(maybeErr.value, 'boom');
- * }
- * ```
- */
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 export const isErr = (result) => result.$$tag === ErrTypeTagName;
 //# sourceMappingURL=ternary-result-is-err.mjs.map

package/dist/functional/ternary-result/impl/ternary-result-is-ok.mjs

@@ -1,22 +1,22 @@
 import { OkTypeTagName } from './tag.mjs';
-/**
- * Type guard for the Ok variant.
- *
- * @example
- *
- * ```ts
- * const maybeNumber = TernaryResult.ok(42) as TernaryResult<
- *   number,
- *   string,
- *   string
- * >;
- *
- * if (TernaryResult.isOk(maybeNumber)) {
- *   const value: number = maybeNumber.value;
- *
- *   assert.strictEqual(value, 42);
- * }
- * ```
- */
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 export const isOk = (result) => result.$$tag === OkTypeTagName;
 //# sourceMappingURL=ternary-result-is-ok.mjs.map

package/dist/functional/ternary-result/impl/ternary-result-is-ternary-result.mjs

@@ -1,24 +1,24 @@
 import { hasKey, isRecord } from '../../../guard/index.mjs';
 import { ErrTypeTagName, OkTypeTagName, WarnTypeTagName } from './tag.mjs';
-/**
- * Checks whether the provided value is a {@link TernaryResult}.
- *
- * @example
- *
- * ```ts
- * const okValue = TernaryResult.ok('done');
- *
- * const warnValue = TernaryResult.warn('done', 'retry later');
- *
- * const notResult = { $$tag: 'ts-data-forge::Result.ok' } as const;
- *
- * assert.isTrue(TernaryResult.isTernaryResult(okValue));
- *
- * assert.isTrue(TernaryResult.isTernaryResult(warnValue));
- *
- * assert.isFalse(TernaryResult.isTernaryResult(notResult));
- * ```
- */
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 export const isTernaryResult = (maybeResult) => isRecord(maybeResult) &&
     hasKey(maybeResult, '$$tag') &&
     hasKey(maybeResult, 'value') &&

package/dist/functional/ternary-result/impl/ternary-result-is-warn.mjs

@@ -1,21 +1,21 @@
 import { WarnTypeTagName } from './tag.mjs';
-/**
- * Type guard for the Warn variant.
- *
- * @example
- *
- * ```ts
- * const maybeWarn = TernaryResult.warn(
- *   'value',
- *   'check logs',
- * ) as TernaryResult<string, string, string>;
- *
- * if (TernaryResult.isWarn(maybeWarn)) {
- *   assert.strictEqual(maybeWarn.value, 'value');
- *
- *   assert.strictEqual(maybeWarn.warning, 'check logs');
- * }
- * ```
- */
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 export const isWarn = (result) => result.$$tag === WarnTypeTagName;
 //# sourceMappingURL=ternary-result-is-warn.mjs.map

package/dist/functional/ternary-result/impl/ternary-result-map-err.mjs

@@ -14,10 +14,10 @@ export function mapErr(...args) {
 }
 const mapErrImpl = (result, mapFn) => {
     if (isErr(result)) {
-        // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+
         return err(mapFn(result.value));
     }
-    // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+
     return result;
 };
 //# sourceMappingURL=ternary-result-map-err.mjs.map

package/dist/functional/ternary-result/impl/ternary-result-map-warn.mjs

@@ -15,12 +15,12 @@ export function mapWarn(...args) {
 const mapWarnImpl = (result, mapFn) => {
     if (isWarn(result)) {
         return warn(
-        // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+
         result.value, 
-        // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+
         mapFn(result.warning));
     }
-    // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+
     return result;
 };
 //# sourceMappingURL=ternary-result-map-warn.mjs.map

package/dist/functional/ternary-result/impl/ternary-result-map.mjs

@@ -16,17 +16,17 @@ export function map(...args) {
 }
 const mapImpl = (result, mapFn) => {
     if (isOk(result)) {
-        // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+
         return ok(mapFn(result.value));
     }
     if (isWarn(result)) {
         return warn(
-        // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+
         mapFn(result.value), 
-        // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+
         result.warning);
     }
-    // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+
     return result;
 };
 //# sourceMappingURL=ternary-result-map.mjs.map

package/dist/functional/ternary-result/impl/ternary-result-ok.mjs

@@ -1,18 +1,18 @@
 import { OkTypeTagName } from './tag.mjs';
-/**
- * Creates a `TernaryResult.Ok` containing the provided value.
- *
- * @example
- *
- * ```ts
- * const success = TernaryResult.ok({ id: 1 });
- *
- * assert.deepStrictEqual(success, {
- *   $$tag: 'ts-data-forge::Result.ok',
- *   value: { id: 1 },
- * });
- * ```
- */
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 export const ok = (value) => ({
     $$tag: OkTypeTagName,
     value,

package/dist/functional/ternary-result/impl/ternary-result-to-optional.mjs

@@ -1,26 +1,26 @@
 import { Optional } from '../../optional/index.mjs';
 import { isOk } from './ternary-result-is-ok.mjs';
 import { isWarn } from './ternary-result-is-warn.mjs';
-/**
- * Converts a `TernaryResult` into an `Optional` by keeping only Ok values.
- *
- * @example
- *
- * ```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),
- * );
- * ```
- */
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 export const toOptional = (result) => isOk(result) || isWarn(result)
-    ? // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+    ?
         Optional.some(result.value)
     : Optional.none;
 //# sourceMappingURL=ternary-result-to-optional.mjs.map

package/dist/functional/ternary-result/impl/ternary-result-unwrap-err-throw.mjs

@@ -2,32 +2,32 @@ import { unknownToString } from '../../../others/index.mjs';
 import { isErr } from './ternary-result-is-err.mjs';
 import { isWarn } from './ternary-result-is-warn.mjs';
 import { variantName } from './variant-name.mjs';
-/**
- * Returns the Err value or throws if the result is not Err.
- *
- * @example
- *
- * ```ts
- * const errValue = TernaryResult.err('boom');
- *
- * assert.strictEqual(TernaryResult.unwrapErrThrow(errValue), 'boom');
- *
- * assert.throws(
- *   () => TernaryResult.unwrapErrThrow(TernaryResult.ok('value')),
- *   /Expected Err/u,
- * );
- * ```
- */
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 export const unwrapErrThrow = (result, toStr = unknownToString) => {
     if (isErr(result)) {
-        // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+
         return result.value;
     }
     const variant = variantName(result.$$tag);
     const payload = isWarn(result)
-        ? // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+        ?
             result.warning
-        : // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+        :
             result.value;
     throw new Error(`Expected Err but got ${variant}: ${toStr(payload)}`);
 };

package/dist/functional/ternary-result/impl/ternary-result-unwrap-err.mjs

@@ -1,21 +1,21 @@
 import { isErr } from './ternary-result-is-err.mjs';
-/**
- * Safely unwraps the Err value.
- *
- * @example
- *
- * ```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);
- * ```
- */
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 export const unwrapErr = (result) => 
-// eslint-disable-next-line total-functions/no-unsafe-type-assertion
+
 isErr(result) ? result.value : undefined;
 //# sourceMappingURL=ternary-result-unwrap-err.mjs.map

package/dist/functional/ternary-result/impl/ternary-result-unwrap-ok.mjs

@@ -2,7 +2,7 @@ import { isOk } from './ternary-result-is-ok.mjs';
 import { isWarn } from './ternary-result-is-warn.mjs';
 export function unwrapOk(result) {
     if (isOk(result) || isWarn(result)) {
-        // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+
         return result.value;
     }
     return undefined;

package/dist/functional/ternary-result/impl/ternary-result-unwrap-throw.mjs

@@ -1,35 +1,35 @@
 import { unknownToString } from '../../../others/index.mjs';
 import { isErr } from './ternary-result-is-err.mjs';
 import { isWarn } from './ternary-result-is-warn.mjs';
-/**
- * Returns the Ok value or throws if the result is Warn or Err.
- *
- * @example
- *
- * ```ts
- * const okValue = TernaryResult.ok('ready');
- *
- * assert.strictEqual(TernaryResult.unwrapThrow(okValue), 'ready');
- *
- * const throwTest = (): void => {
- *   TernaryResult.unwrapThrow(TernaryResult.warn('warn', 'warned'));
- * };
- *
- * assert.throws(throwTest, /Expected Ok/u);
- * ```
- */
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 export const unwrapThrow = (result, toStr = unknownToString) => {
     if (isErr(result)) {
         throw new Error(`Expected Ok but got Err: ${toStr(
-        // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+
         result.value)}`);
     }
     if (isWarn(result)) {
         throw new Error(`Expected Ok but got Warn: ${toStr(
-        // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+
         result.warning)}`);
     }
-    // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+
     return result.value;
 };
 //# sourceMappingURL=ternary-result-unwrap-throw.mjs.map