@resultsafe/core-fp-result 0.1.0

package/dist/README.md

@@ -0,0 +1,273 @@
+# @resultsafe/core-fp-result
+<a id="top"></a>
+
+![ResultSafe Logo](https://raw.githubusercontent.com/resultsafe/monorepo/main/packages/core/fp/result/docs/assets/logo.svg)
+
+[![npm version](https://img.shields.io/npm/v/@resultsafe/core-fp-result.svg)](https://www.npmjs.com/package/@resultsafe/core-fp-result)
+[![npm downloads](https://img.shields.io/npm/dm/@resultsafe/core-fp-result.svg)](https://www.npmjs.com/package/@resultsafe/core-fp-result)
+[![license](https://img.shields.io/npm/l/@resultsafe/core-fp-result.svg)](./LICENSE)
+[![TypeScript](https://img.shields.io/badge/TypeScript-5.x-3178C6.svg)](https://www.typescriptlang.org/)
+[![docs](https://img.shields.io/badge/docs-api-informational.svg)](./docs/api/README.md)
+[![build status](https://img.shields.io/badge/build-local%20verified-success.svg)](./package.json)
+[![monorepo](https://img.shields.io/badge/monorepo-resultsafe%2Fmonorepo-0A0A0A.svg)](https://github.com/resultsafe/monorepo)
+
+A Rust-inspired Result package for explicit, composable, and type-friendly APIs in TypeScript and JavaScript.
+
+**Language:** English | [Русский](./README.ru.md)
+
+**Documentation:** [API index](./docs/api/README.md) · [Modules](./docs/api/modules.md)
+
+---
+## Contents
+
+- [Why this package](#why-this-package)
+- [Monorepo context](#monorepo-context)
+- [Key features](#key-features)
+- [Package](#package)
+- [Installation](#installation)
+- [Quick start](#quick-start)
+- [Core API overview](#core-api-overview)
+- [Build and distribution formats](#build-and-distribution-formats)
+- [Monorepo and package structure](#monorepo-and-package-structure)
+- [When to use this project](#when-to-use-this-project)
+- [Documentation links](#documentation-links)
+- [License](#license)
+
+---
+
+## Why this package
+
+`@resultsafe/core-fp-result` provides explicit success/error flows instead of hidden control paths and exception-first branching.
+
+Its core package, [`@resultsafe/core-fp-result`](https://www.npmjs.com/package/@resultsafe/core-fp-result), provides a Rust-inspired `Result` API for TypeScript and JavaScript with:
+
+- explicit `Ok` / `Err`
+- predictable functional composition
+- safe branching through guards and matching
+- disciplined extraction APIs
+- advanced refinement utilities for typed variants and strict matching
+
+The goal is not to imitate Rust mechanically, but to bring the same clarity of intent to Node.js libraries: explicit values, predictable branching, and APIs organized for long-term maintenance.
+
+---
+
+## Monorepo context
+
+`@resultsafe/core-fp-result` is the TypeScript/JavaScript package inside the multilingual `resultsafe/monorepo`.
+
+The monorepo applies shared Rust-inspired design concepts across language-specific packages. TypeScript/JavaScript is the current production package track, while Python is planned as a separate package track with the same conceptual model.
+
+---
+
+## Key features
+
+- Rust-inspired `Result` model for TypeScript and JavaScript.
+- Explicit constructors via `Ok` and `Err`.
+- Composable transformations with APIs such as `map`, `mapErr`, `andThen`, and `orElse`.
+- Safe branching through guards like `isOk`, `isErr`, `isOkAnd`, `isErrAnd`, and matching helpers.
+- Controlled extraction with `unwrap`, `unwrapOr`, `unwrapErr`, `expect`, and `expectErr`.
+- Advanced refinement layer for typed variants, strict matching, and result narrowing.
+- Coherent module structure instead of a flat utility dump.
+- Type output for TypeScript users for better DX and safer integrations.
+- Flexible distribution formats with Types, ESM, CJS, and UMD builds.
+
+---
+
+## Package
+
+### `@resultsafe/core-fp-result`
+
+A focused Result library for explicit error handling and FP-style composition.
+
+It is designed for developers who want:
+
+- clear success/error modeling
+- predictable transformations
+- explicit branching and extraction
+- better readability in error-heavy flows
+- a structured Rust-inspired API surface in TypeScript/JavaScript
+
+---
+
+## Installation
+
+### Package
+
+```bash
+pnpm add @resultsafe/core-fp-result
+
+# Alternative
+npm install @resultsafe/core-fp-result
+```
+
+### Monorepo
+
+```bash
+pnpm install
+```
+
+---
+
+## Quick start
+
+A typical Result flow starts with explicit constructors and then composes through functions rather than implicit exception paths.
+
+```ts
+import {
+  Ok,
+  map,
+  unwrapOr,
+} from "@resultsafe/core-fp-result";
+
+const initial = Ok(21);
+const doubled = map(initial, (value) => value * 2);
+const finalValue = unwrapOr(doubled, 0);
+
+console.log(finalValue); // 42
+```
+
+### Basic `Ok` / `Err` example
+
+```ts
+import { Ok, Err, match } from "@resultsafe/core-fp-result";
+
+const parsePort = (input: string) => {
+  const port = Number(input);
+  return Number.isInteger(port) && port > 0
+    ? Ok(port)
+    : Err("Invalid port");
+};
+
+const result = parsePort("3000");
+const message = match(result, (value) => `Port: ${value}`, (error) => `Error: ${error}`);
+
+console.log(message);
+```
+
+---
+
+## Core API overview
+
+### Constructors
+
+- `Ok`
+- `Err`
+
+### Guards
+
+- `isOk`
+- `isOkAnd`
+- `isErr`
+- `isErrAnd`
+
+### Methods
+
+- `andThen`
+- `err`
+- `expect`
+- `expectErr`
+- `flatten`
+- `inspect`
+- `inspectErr`
+- `map`
+- `mapErr`
+- `match`
+- `ok`
+- `orElse`
+- `tap`
+- `tapErr`
+- `transpose`
+- `unwrap`
+- `unwrapErr`
+- `unwrapOr`
+- `unwrapOrElse`
+
+### Refiners
+
+- `isTypedVariant`
+- `isTypedVariantOf`
+- `matchVariant`
+- `matchVariantStrict`
+- `refineAsyncResult`
+- `refineAsyncResultU`
+- `refineResult`
+- `refineResultU`
+- `refineVariantMap`
+
+### Type aliases
+
+- `Handler`
+- `MatchBuilder`
+- `Matcher`
+- `SyncRefinedResult`
+- `SyncRefinedResultUnion`
+- `SyncValidatorMap`
+- `UniversalAsyncRefinedResult`
+- `UniversalRefinedResult`
+- `VariantOf`
+
+---
+
+## Build and distribution formats
+
+- Types: `build:types`
+- ESM: `build:esm`
+- CJS: `build:cjs`
+- UMD: `build:umd`
+
+This package ships typed declarations and multiple runtime module formats for broad compatibility.
+
+---
+
+## Monorepo and package structure
+
+```txt
+src/
+  constructors/
+  guards/
+  methods/
+  refiners/
+    types/
+    utils/
+  internal/
+  index.ts
+```
+
+---
+
+## When to use this project
+
+Use this project when you want:
+
+- explicit success/error modeling
+- predictable FP-style composition
+- visible control flow
+- stronger type-guided result handling in TypeScript
+- advanced refinement tools for typed variants and strict result matching
+
+---
+
+## Documentation links
+
+- [API entry (README)](./docs/api/README.md)
+- [API entry (index)](./docs/api/index.md)
+- [Modules](./docs/api/modules.md)
+- [Constructors module](./docs/api/constructors/index.md)
+- [Guards module](./docs/api/guards/index.md)
+- [Methods module](./docs/api/methods/index.md)
+- [Refiners module](./docs/api/refiners/index.md)
+- [Type aliases module](./docs/api/type-aliases/index.md)
+
+---
+Back to top: [@resultsafe/core-fp-result](#top)
+
+---
+## Author
+
+Denis Savasteev
+
+---
+
+## License
+
+[MIT](./LICENSE)

package/dist/cjs/constructors/Err.js

@@ -0,0 +1,4 @@
+"use strict";
+const Err = (error) => ({ ok: false, error });
+exports.Err = Err;
+//# sourceMappingURL=Err.js.map

package/dist/cjs/constructors/Err.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Err.js","sources":["../../../src/constructors/Err.ts"],"sourcesContent":["import type { Result } from '../shared-types.js';\n\n/**\n * Создает ошибочное значение `Result` из переданного payload ошибки.\n *\n * @typeParam E - Тип значения ошибки.\n * @typeParam T - The success type for the resulting `Result`.\n * @param error - Payload ошибки для обёртки.\n * @returns A `Result` with `ok: false` and the provided `error`.\n * @since 0.1.0\n * @see {@link Ok} - Creates a successful `Result`.\n * @example\n * ```ts\n * import { Err } from '@resultsafe/core-fp-result';\n *\n * const result = Err<string, number>('boom');\n * console.log(result.ok); // false\n * ```\n * @public\n */\nexport const Err = <E, T = never>(error: E): Result<T, E> =>\n  ({ ok: false, error }) as const;\n\r\n\r\n"],"names":[],"mappings":";AAoBO,MAAM,MAAM,CAAe,WAC/B,EAAE,IAAI,OAAO,MAAA;;"}

package/dist/cjs/constructors/Ok.js

@@ -0,0 +1,4 @@
+"use strict";
+const Ok = (value) => ({ ok: true, value });
+exports.Ok = Ok;
+//# sourceMappingURL=Ok.js.map

package/dist/cjs/constructors/Ok.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Ok.js","sources":["../../../src/constructors/Ok.ts"],"sourcesContent":["import type { Result } from '../shared-types.js';\n\n/**\n * Создает успешное значение `Result` из переданного payload.\n *\n * @typeParam T - Тип успешного значения.\n * @typeParam E - The error type for the resulting `Result`.\n * @param value - Payload успеха для обёртки.\n * @returns A `Result` with `ok: true` and the provided `value`.\n * @since 0.1.0\n * @see {@link Err} - Creates an error `Result`.\n * @example\n * ```ts\n * import { Ok } from '@resultsafe/core-fp-result';\n *\n * const result = Ok<number, string>(42);\n * console.log(result.ok); // true\n * ```\n * @public\n */\nexport const Ok = <T, E = never>(value: T): Result<T, E> =>\n  ({ ok: true, value }) as const;\n\r\n\r\n"],"names":[],"mappings":";AAoBO,MAAM,KAAK,CAAe,WAC9B,EAAE,IAAI,MAAM,MAAA;;"}

package/dist/cjs/guards/isErr.js

@@ -0,0 +1,4 @@
+"use strict";
+const isErr = (result) => result.ok === false;
+exports.isErr = isErr;
+//# sourceMappingURL=isErr.js.map

package/dist/cjs/guards/isErr.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"isErr.js","sources":["../../../src/guards/isErr.ts"],"sourcesContent":["import type { Result } from '../shared-types.js';\n\n/**\n * Проверяет, находится ли `Result` в ветке ошибки.\n *\n * @typeParam T - Тип успешного значения.\n * @typeParam E - Тип значения ошибки.\n * @param result - `Result` для проверки.\n * @returns `true` when `result.ok` equals `false`.\n * @since 0.1.0\n * @see {@link isOk} - Checks the success branch.\n * @example\n * ```ts\n * import { Err, isErr } from '@resultsafe/core-fp-result';\n *\n * const result = Err('boom');\n * console.log(isErr(result)); // true\n * ```\n * @public\n */\nexport const isErr = <T, E>(\n  result: Result<T, E>,\n): result is { ok: false; error: E } => result.ok === false;\n\r\n\r\n"],"names":[],"mappings":";AAoBO,MAAM,QAAQ,CACnB,WACsC,OAAO,OAAO;;"}

package/dist/cjs/guards/isErrAnd.js

@@ -0,0 +1,5 @@
+"use strict";
+const isErr = require("./isErr.js");
+const isErrAnd = (result, predicate) => isErr.isErr(result) && predicate(result.error);
+exports.isErrAnd = isErrAnd;
+//# sourceMappingURL=isErrAnd.js.map

package/dist/cjs/guards/isErrAnd.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"isErrAnd.js","sources":["../../../src/guards/isErrAnd.ts"],"sourcesContent":["import { type Result } from '../shared-types.js';\n\nimport { isErr } from './isErr.js';\n\n/**\n * Проверяет, что `Result` завершился ошибкой и удовлетворяет предикату.\n *\n * @typeParam T - Тип успешного значения.\n * @typeParam E - Тип значения ошибки.\n * @param result - `Result` для проверки.\n * @param predicate - Предикат, применяемый к значению ошибки.\n * @returns `true` when the value is `Err` and the predicate returns `true`.\n * @since 0.1.0\n * @see {@link isErr} - Performs the base error check.\n * @example\n * ```ts\n * import { Err, isErrAnd } from '@resultsafe/core-fp-result';\n *\n * const result = Err({ code: 503 });\n * console.log(isErrAnd(result, (error) => error.code >= 500)); // true\n * ```\n * @public\n */\nexport const isErrAnd = <T, E>(\n  result: Result<T, E>,\n  predicate: (error: E) => boolean,\n): boolean => isErr(result) && predicate(result.error);\n\r\n\r\n"],"names":["isErr"],"mappings":";;AAuBO,MAAM,WAAW,CACtB,QACA,cACYA,MAAAA,MAAM,MAAM,KAAK,UAAU,OAAO,KAAK;;"}

package/dist/cjs/guards/isOk.js

@@ -0,0 +1,4 @@
+"use strict";
+const isOk = (result) => result.ok === true;
+exports.isOk = isOk;
+//# sourceMappingURL=isOk.js.map

package/dist/cjs/guards/isOk.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"isOk.js","sources":["../../../src/guards/isOk.ts"],"sourcesContent":["import type { Result } from '../shared-types.js';\n\n/**\n * Проверяет, находится ли `Result` в ветке успеха.\n *\n * @typeParam T - Тип успешного значения.\n * @typeParam E - Тип значения ошибки.\n * @param result - `Result` для проверки.\n * @returns `true` when `result.ok` equals `true`.\n * @since 0.1.0\n * @see {@link isErr} - Checks the error branch.\n * @example\n * ```ts\n * import { Ok, isOk } from '@resultsafe/core-fp-result';\n *\n * const result = Ok(10);\n * console.log(isOk(result)); // true\n * ```\n * @public\n */\nexport const isOk = <T, E>(\n  result: Result<T, E>,\n): result is { ok: true; value: T } => result.ok === true;\n\r\n\r\n"],"names":[],"mappings":";AAoBO,MAAM,OAAO,CAClB,WACqC,OAAO,OAAO;;"}

package/dist/cjs/guards/isOkAnd.js

@@ -0,0 +1,5 @@
+"use strict";
+const isOk = require("./isOk.js");
+const isOkAnd = (result, predicate) => isOk.isOk(result) && predicate(result.value);
+exports.isOkAnd = isOkAnd;
+//# sourceMappingURL=isOkAnd.js.map

package/dist/cjs/guards/isOkAnd.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"isOkAnd.js","sources":["../../../src/guards/isOkAnd.ts"],"sourcesContent":["import { type Result } from '../shared-types.js';\n\nimport { isOk } from './isOk.js';\n\n/**\n * Проверяет, что `Result` успешен и удовлетворяет предикату.\n *\n * @typeParam T - Тип успешного значения.\n * @typeParam E - Тип значения ошибки.\n * @param result - `Result` для проверки.\n * @param predicate - Предикат, применяемый к успешному значению.\n * @returns `true` when the value is `Ok` and the predicate returns `true`.\n * @since 0.1.0\n * @see {@link isOk} - Performs the base success check.\n * @example\n * ```ts\n * import { Ok, isOkAnd } from '@resultsafe/core-fp-result';\n *\n * const result = Ok(8);\n * console.log(isOkAnd(result, (value) => value % 2 === 0)); // true\n * ```\n * @public\n */\nexport const isOkAnd = <T, E>(\n  result: Result<T, E>,\n  predicate: (value: T) => boolean,\n): boolean => isOk(result) && predicate(result.value);\n\r\n\r\n"],"names":["isOk"],"mappings":";;AAuBO,MAAM,UAAU,CACrB,QACA,cACYA,KAAAA,KAAK,MAAM,KAAK,UAAU,OAAO,KAAK;;"}

package/dist/cjs/index.js

@@ -0,0 +1,70 @@
+"use strict";
+const Err = require("./constructors/Err.js");
+const Ok = require("./constructors/Ok.js");
+const isErr = require("./guards/isErr.js");
+const isErrAnd = require("./guards/isErrAnd.js");
+const isOk = require("./guards/isOk.js");
+const isOkAnd = require("./guards/isOkAnd.js");
+const andThen = require("./methods/andThen.js");
+const err = require("./methods/err.js");
+const expect = require("./methods/expect.js");
+const expectErr = require("./methods/expectErr.js");
+const flatten = require("./methods/flatten.js");
+const inspect = require("./methods/inspect.js");
+const inspectErr = require("./methods/inspectErr.js");
+const map = require("./methods/map.js");
+const mapErr = require("./methods/mapErr.js");
+const match = require("./methods/match.js");
+const ok = require("./methods/ok.js");
+const orElse = require("./methods/orElse.js");
+const tap = require("./methods/tap.js");
+const tapErr = require("./methods/tapErr.js");
+const transpose = require("./methods/transpose.js");
+const unwrap = require("./methods/unwrap.js");
+const unwrapErr = require("./methods/unwrapErr.js");
+const unwrapOr = require("./methods/unwrapOr.js");
+const unwrapOrElse = require("./methods/unwrapOrElse.js");
+const isTypedVariant = require("./refiners/isTypedVariant.js");
+const isTypedVariantOf = require("./refiners/isTypedVariantOf.js");
+const matchVariant = require("./refiners/matchVariant.js");
+const matchVariantStrict = require("./refiners/matchVariantStrict.js");
+const refineAsyncResult = require("./refiners/refineAsyncResult.js");
+const refineAsyncResultU = require("./refiners/refineAsyncResultU.js");
+const refineResult = require("./refiners/refineResult.js");
+const refineResultU = require("./refiners/refineResultU.js");
+const refineVariantMap = require("./refiners/refineVariantMap.js");
+exports.Err = Err.Err;
+exports.Ok = Ok.Ok;
+exports.isErr = isErr.isErr;
+exports.isErrAnd = isErrAnd.isErrAnd;
+exports.isOk = isOk.isOk;
+exports.isOkAnd = isOkAnd.isOkAnd;
+exports.andThen = andThen.andThen;
+exports.err = err.err;
+exports.expect = expect.expect;
+exports.expectErr = expectErr.expectErr;
+exports.flatten = flatten.flatten;
+exports.inspect = inspect.inspect;
+exports.inspectErr = inspectErr.inspectErr;
+exports.map = map.map;
+exports.mapErr = mapErr.mapErr;
+exports.match = match.match;
+exports.ok = ok.ok;
+exports.orElse = orElse.orElse;
+exports.tap = tap.tap;
+exports.tapErr = tapErr.tapErr;
+exports.transpose = transpose.transpose;
+exports.unwrap = unwrap.unwrap;
+exports.unwrapErr = unwrapErr.unwrapErr;
+exports.unwrapOr = unwrapOr.unwrapOr;
+exports.unwrapOrElse = unwrapOrElse.unwrapOrElse;
+exports.isTypedVariant = isTypedVariant.isTypedVariant;
+exports.isTypedVariantOf = isTypedVariantOf.isTypedVariantOf;
+exports.matchVariant = matchVariant.matchVariant;
+exports.matchVariantStrict = matchVariantStrict.matchVariantStrict;
+exports.refineAsyncResult = refineAsyncResult.refineAsyncResult;
+exports.refineAsyncResultU = refineAsyncResultU.refineAsyncResultU;
+exports.refineResult = refineResult.refineResult;
+exports.refineResultU = refineResultU.refineResultU;
+exports.refineVariantMap = refineVariantMap.refineVariantMap;
+//# sourceMappingURL=index.js.map

package/dist/cjs/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/cjs/internal/object.js

@@ -0,0 +1,6 @@
+"use strict";
+const hasOwn = (obj, key) => Object.prototype.hasOwnProperty.call(obj, key);
+const isObject = (value) => typeof value === "object" && value !== null;
+exports.hasOwn = hasOwn;
+exports.isObject = isObject;
+//# sourceMappingURL=object.js.map

package/dist/cjs/internal/object.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"object.js","sources":["../../../src/internal/object.ts"],"sourcesContent":["/** Checks that an object owns a property key. @internal */\nexport const hasOwn = <K extends PropertyKey>(\n  obj: Record<string, unknown>,\n  key: K,\n): obj is Record<K, unknown> => Object.prototype.hasOwnProperty.call(obj, key);\n\n/** Checks that a value is a non-null object record. @internal */\nexport const isObject = (value: unknown): value is Record<string, unknown> =>\n  typeof value === 'object' && value !== null;\n"],"names":[],"mappings":";AACO,MAAM,SAAS,CACpB,KACA,QAC8B,OAAO,UAAU,eAAe,KAAK,KAAK,GAAG;AAGtE,MAAM,WAAW,CAAC,UACvB,OAAO,UAAU,YAAY,UAAU;;;"}

package/dist/cjs/internal/option.js

@@ -0,0 +1,6 @@
+"use strict";
+const None = { some: false };
+const Some = (value) => ({ some: true, value });
+exports.None = None;
+exports.Some = Some;
+//# sourceMappingURL=option.js.map

package/dist/cjs/internal/option.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"option.js","sources":["../../../src/internal/option.ts"],"sourcesContent":["/** Represents an empty internal option value. @internal */\nexport const None = { some: false } as const;\n\n/** Wraps an internal option value as present. @internal */\nexport const Some = <T>(value: T) => ({ some: true, value }) as const;\n"],"names":[],"mappings":";AACO,MAAM,OAAO,EAAE,MAAM,MAAA;AAGrB,MAAM,OAAO,CAAI,WAAc,EAAE,MAAM,MAAM,MAAA;;;"}

package/dist/cjs/methods/andThen.js

@@ -0,0 +1,5 @@
+"use strict";
+const isOk = require("../guards/isOk.js");
+const andThen = (result, fn) => isOk.isOk(result) ? fn(result.value) : result;
+exports.andThen = andThen;
+//# sourceMappingURL=andThen.js.map

package/dist/cjs/methods/andThen.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"andThen.js","sources":["../../../src/methods/andThen.ts"],"sourcesContent":["import { type Result } from '../shared-types.js';\n\nimport { isOk } from '../guards/isOk.js';\n\n/**\n * Цепляет вычисление, которое возвращает другой `Result`.\n *\n * @typeParam T - The input success type.\n * @typeParam U - The output success type.\n * @typeParam E - Общий тип ошибки.\n * @param result - Исходный `Result`.\n * @param fn - Функция, применяемая, когда `result` имеет `Ok`.\n * @returns Преобразованный `Result` или исходный `Err`.\n * @since 0.1.0\n * @see {@link map} - Преобразует только успешное значение.\n * @example\n * ```ts\n * import { Ok, Err, andThen } from '@resultsafe/core-fp-result';\n *\n * const parsed = andThen(Ok('12'), (value) => {\n *   const n = Number(value);\n *   return Number.isNaN(n) ? Err('invalid') : Ok(n);\n * });\n * console.log(parsed.ok); // true\n * ```\n * @public\n */\nexport const andThen = <T, U, E>(\n  result: Result<T, E>,\n  fn: (value: T) => Result<U, E>,\n): Result<U, E> => (isOk(result) ? fn(result.value) : (result as Result<U, E>));\n\r\n\r\n"],"names":["isOk"],"mappings":";;AA2BO,MAAM,UAAU,CACrB,QACA,OACkBA,KAAAA,KAAK,MAAM,IAAI,GAAG,OAAO,KAAK,IAAK;;"}

package/dist/cjs/methods/err.js

@@ -0,0 +1,6 @@
+"use strict";
+const isErr = require("../guards/isErr.js");
+const option = require("../internal/option.js");
+const err = (result) => isErr.isErr(result) ? option.Some(result.error) : option.None;
+exports.err = err;
+//# sourceMappingURL=err.js.map

package/dist/cjs/methods/err.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"err.js","sources":["../../../src/methods/err.ts"],"sourcesContent":["import { type Option } from '../shared-types.js';\nimport { type Result } from '../shared-types.js';\n\nimport { isErr } from '../guards/isErr.js';\nimport { None, Some } from '../internal/option.js';\n\n/**\n * Извлекает ветку ошибки в виде `Option`.\n *\n * @typeParam T - Тип успешного значения.\n * @typeParam E - Тип значения ошибки.\n * @param result - Исходный `Result`.\n * @returns `Some(error)` для `Err`, иначе `None`.\n * @since 0.1.0\n * @see {@link ok} - Извлекает ветку успеха.\n * @example\n * ```ts\n * import { Err, err } from '@resultsafe/core-fp-result';\n *\n * const value = err(Err('boom'));\n * console.log(value.some); // true\n * ```\n * @public\n */\nexport const err = <T, E>(result: Result<T, E>): Option<E> =>\n  isErr(result) ? Some(result.error) : None;\n\r\n\r\n"],"names":["isErr","Some","None"],"mappings":";;;AAwBO,MAAM,MAAM,CAAO,WACxBA,YAAM,MAAM,IAAIC,YAAK,OAAO,KAAK,IAAIC,OAAAA;;"}

package/dist/cjs/methods/expect.js

@@ -0,0 +1,10 @@
+"use strict";
+const isOk = require("../guards/isOk.js");
+const expect = (result, msg) => {
+  if (isOk.isOk(result)) {
+    return result.value;
+  }
+  throw new Error(msg);
+};
+exports.expect = expect;
+//# sourceMappingURL=expect.js.map

package/dist/cjs/methods/expect.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"expect.js","sources":["../../../src/methods/expect.ts"],"sourcesContent":["import { type Result } from '../shared-types.js';\n\nimport { isOk } from '../guards/isOk.js';\n\n/**\n * Возвращает успешное значение или выбрасывает исключение с пользовательским сообщением.\n *\n * @typeParam T - Тип успешного значения.\n * @typeParam E - Тип значения ошибки.\n * @param result - Исходный `Result`.\n * @param msg - Сообщение об ошибке, используемое когда `result` имеет `Err`.\n * @returns Распакованное успешное значение.\n * @throws Error - Выбрасывает исключение, когда `result` имеет `Err`.\n * @since 0.1.0\n * @see {@link expectErr} - Симметричный helper для ветки ошибки.\n * @example\n * ```ts\n * import { Ok, expect } from '@resultsafe/core-fp-result';\n *\n * const value = expect(Ok(5), 'must be ok');\n * console.log(value); // 5\n * ```\n * @public\n */\nexport const expect = <T, E>(result: Result<T, E>, msg: string): T => {\n  if (isOk(result)) {\n    return result.value;\n  }\n  throw new Error(msg);\n};\n\r\n\r\n"],"names":["isOk"],"mappings":";;AAwBO,MAAM,SAAS,CAAO,QAAsB,QAAmB;AACpE,MAAIA,KAAAA,KAAK,MAAM,GAAG;AAChB,WAAO,OAAO;AAAA,EAChB;AACA,QAAM,IAAI,MAAM,GAAG;AACrB;;"}

package/dist/cjs/methods/expectErr.js

@@ -0,0 +1,10 @@
+"use strict";
+const isErr = require("../guards/isErr.js");
+const expectErr = (result, msg) => {
+  if (isErr.isErr(result)) {
+    return result.error;
+  }
+  throw new Error(msg);
+};
+exports.expectErr = expectErr;
+//# sourceMappingURL=expectErr.js.map

package/dist/cjs/methods/expectErr.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"expectErr.js","sources":["../../../src/methods/expectErr.ts"],"sourcesContent":["import { type Result } from '../shared-types.js';\n\nimport { isErr } from '../guards/isErr.js';\n\n/**\n * Возвращает значение ошибки или выбрасывает исключение с пользовательским сообщением.\n *\n * @typeParam T - Тип успешного значения.\n * @typeParam E - Тип значения ошибки.\n * @param result - Исходный `Result`.\n * @param msg - Сообщение об ошибке, используемое когда `result` имеет `Ok`.\n * @returns Распакованное значение ошибки.\n * @throws Error - Выбрасывает исключение, когда `result` имеет `Ok`.\n * @since 0.1.0\n * @see {@link expect} - Симметричный helper для ветки успеха.\n * @example\n * ```ts\n * import { Err, expectErr } from '@resultsafe/core-fp-result';\n *\n * const error = expectErr(Err('boom'), 'must be err');\n * console.log(error); // boom\n * ```\n * @public\n */\nexport const expectErr = <T, E>(result: Result<T, E>, msg: string): E => {\n  if (isErr(result)) {\n    return result.error;\n  }\n  throw new Error(msg);\n};\n\r\n\r\n"],"names":["isErr"],"mappings":";;AAwBO,MAAM,YAAY,CAAO,QAAsB,QAAmB;AACvE,MAAIA,MAAAA,MAAM,MAAM,GAAG;AACjB,WAAO,OAAO;AAAA,EAChB;AACA,QAAM,IAAI,MAAM,GAAG;AACrB;;"}

package/dist/cjs/methods/flatten.js

@@ -0,0 +1,4 @@
+"use strict";
+const flatten = (result) => result.ok ? result.value : { ok: false, error: result.error };
+exports.flatten = flatten;
+//# sourceMappingURL=flatten.js.map

package/dist/cjs/methods/flatten.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"flatten.js","sources":["../../../src/methods/flatten.ts"],"sourcesContent":["import { type Result } from '../shared-types.js';\n\n/**\n * Схлопывает вложенный `Result<Result<T, E>, E>` на один уровень.\n *\n * @typeParam T - The inner success value type.\n * @typeParam E - The shared error value type.\n * @param result - Вложенный `Result` для схлопывания.\n * @returns A single-layer `Result<T, E>`.\n * @since 0.1.0\n * @see {@link andThen} - Chains computations that already return `Result`.\n * @example\n * ```ts\n * import { Ok, flatten } from '@resultsafe/core-fp-result';\n *\n * const value = flatten(Ok(Ok(3)));\n * console.log(value.ok); // true\n * ```\n * @public\n */\nexport const flatten = <T, E>(result: Result<Result<T, E>, E>): Result<T, E> =>\n  result.ok ? result.value : { ok: false, error: result.error };\n\r\n\r\n"],"names":[],"mappings":";AAoBO,MAAM,UAAU,CAAO,WAC5B,OAAO,KAAK,OAAO,QAAQ,EAAE,IAAI,OAAO,OAAO,OAAO,MAAA;;"}

package/dist/cjs/methods/inspect.js

@@ -0,0 +1,10 @@
+"use strict";
+const isOk = require("../guards/isOk.js");
+const inspect = (result, fn) => {
+  if (isOk.isOk(result)) {
+    fn(result.value);
+  }
+  return result;
+};
+exports.inspect = inspect;
+//# sourceMappingURL=inspect.js.map

package/dist/cjs/methods/inspect.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"inspect.js","sources":["../../../src/methods/inspect.ts"],"sourcesContent":["import { type Result } from '../shared-types.js';\n\nimport { isOk } from '../guards/isOk.js';\n\n/**\n * Выполняет побочный эффект для успешного значения и возвращает исходный `Result`.\n *\n * @typeParam T - Тип успешного значения.\n * @typeParam E - Тип значения ошибки.\n * @param result - Исходный `Result`.\n * @param fn - Функция побочного эффекта для ветки успеха.\n * @returns Тот же экземпляр `Result`.\n * @since 0.1.0\n * @see {@link tap} - Эквивалентный helper для ветки успеха.\n * @example\n * ```ts\n * import { Ok, inspect } from '@resultsafe/core-fp-result';\n *\n * const result = inspect(Ok(1), (value) => console.log(value)); // 1\n * console.log(result.ok); // true\n * ```\n * @public\n */\nexport const inspect = <T, E>(\n  result: Result<T, E>,\n  fn: (value: T) => void,\n): Result<T, E> => {\n  if (isOk(result)) {\n    fn(result.value);\n  }\n  return result;\n};\n\r\n\r\n"],"names":["isOk"],"mappings":";;AAuBO,MAAM,UAAU,CACrB,QACA,OACiB;AACjB,MAAIA,KAAAA,KAAK,MAAM,GAAG;AAChB,OAAG,OAAO,KAAK;AAAA,EACjB;AACA,SAAO;AACT;;"}

package/dist/cjs/methods/inspectErr.js

@@ -0,0 +1,10 @@
+"use strict";
+const isErr = require("../guards/isErr.js");
+const inspectErr = (result, fn) => {
+  if (isErr.isErr(result)) {
+    fn(result.error);
+  }
+  return result;
+};
+exports.inspectErr = inspectErr;
+//# sourceMappingURL=inspectErr.js.map

package/dist/cjs/methods/inspectErr.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"inspectErr.js","sources":["../../../src/methods/inspectErr.ts"],"sourcesContent":["import { type Result } from '../shared-types.js';\n\nimport { isErr } from '../guards/isErr.js';\n\n/**\n * Выполняет побочный эффект для значения ошибки и возвращает исходный `Result`.\n *\n * @typeParam T - Тип успешного значения.\n * @typeParam E - Тип значения ошибки.\n * @param result - Исходный `Result`.\n * @param fn - Функция побочного эффекта для ветки ошибки.\n * @returns Тот же экземпляр `Result`.\n * @since 0.1.0\n * @see {@link tapErr} - Эквивалентный helper для ветки ошибки.\n * @example\n * ```ts\n * import { Err, inspectErr } from '@resultsafe/core-fp-result';\n *\n * const result = inspectErr(Err('boom'), (error) => console.log(error)); // boom\n * console.log(result.ok); // false\n * ```\n * @public\n */\nexport const inspectErr = <T, E>(\n  result: Result<T, E>,\n  fn: (error: E) => void,\n): Result<T, E> => {\n  if (isErr(result)) {\n    fn(result.error);\n  }\n  return result;\n};\n\r\n\r\n"],"names":["isErr"],"mappings":";;AAuBO,MAAM,aAAa,CACxB,QACA,OACiB;AACjB,MAAIA,MAAAA,MAAM,MAAM,GAAG;AACjB,OAAG,OAAO,KAAK;AAAA,EACjB;AACA,SAAO;AACT;;"}

package/dist/cjs/methods/map.js

@@ -0,0 +1,5 @@
+"use strict";
+const isOk = require("../guards/isOk.js");
+const map = (result, fn) => isOk.isOk(result) ? { ok: true, value: fn(result.value) } : result;
+exports.map = map;
+//# sourceMappingURL=map.js.map

package/dist/cjs/methods/map.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"map.js","sources":["../../../src/methods/map.ts"],"sourcesContent":["import { type Result } from '../shared-types.js';\n\nimport { isOk } from '../guards/isOk.js';\n\n/**\n * Преобразует успешное значение, сохраняя ветку ошибки.\n *\n * @typeParam T - Тип входного успешного значения.\n * @typeParam U - Тип выходного успешного значения.\n * @typeParam E - Тип значения ошибки.\n * @param result - Исходный `Result`.\n * @param fn - Функция преобразования успешного значения.\n * @returns Преобразованный `Ok` или исходный `Err`.\n * @since 0.1.0\n * @see {@link mapErr} - Преобразует ветку ошибки.\n * @example\n * ```ts\n * import { Ok, map } from '@resultsafe/core-fp-result';\n *\n * const result = map(Ok(2), (value) => value * 10);\n * console.log(result.ok); // true\n * ```\n * @public\n */\nexport const map = <T, U, E>(\n  result: Result<T, E>,\n  fn: (value: T) => U,\n): Result<U, E> =>\n  isOk(result)\n    ? { ok: true, value: fn(result.value) }\n    : (result as Result<U, E>);\n\r\n\r\n"],"names":["isOk"],"mappings":";;AAwBO,MAAM,MAAM,CACjB,QACA,OAEAA,KAAAA,KAAK,MAAM,IACP,EAAE,IAAI,MAAM,OAAO,GAAG,OAAO,KAAK,MACjC;;"}

package/dist/cjs/methods/mapErr.js

@@ -0,0 +1,5 @@
+"use strict";
+const isErr = require("../guards/isErr.js");
+const mapErr = (result, fn) => isErr.isErr(result) ? { ok: false, error: fn(result.error) } : result;
+exports.mapErr = mapErr;
+//# sourceMappingURL=mapErr.js.map

package/dist/cjs/methods/mapErr.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mapErr.js","sources":["../../../src/methods/mapErr.ts"],"sourcesContent":["import { type Result } from '../shared-types.js';\n\nimport { isErr } from '../guards/isErr.js';\n\n/**\n * Преобразует значение ошибки, сохраняя ветку успеха.\n *\n * @typeParam T - Тип успешного значения.\n * @typeParam E - Тип входного значения ошибки.\n * @typeParam F - Тип выходного значения ошибки.\n * @param result - Исходный `Result`.\n * @param fn - Функция преобразования значения ошибки.\n * @returns Преобразованный `Err` или исходный `Ok`.\n * @since 0.1.0\n * @see {@link map} - Transforms the success branch.\n * @example\n * ```ts\n * import { Err, mapErr } from '@resultsafe/core-fp-result';\n *\n * const result = mapErr(Err('e1'), (error) => `mapped:${error}`);\n * console.log(result.ok); // false\n * ```\n * @public\n */\nexport const mapErr = <T, E, F>(\n  result: Result<T, E>,\n  fn: (error: E) => F,\n): Result<T, F> =>\n  isErr(result)\n    ? { ok: false, error: fn(result.error) }\n    : (result as Result<T, F>);\n\r\n\r\n"],"names":["isErr"],"mappings":";;AAwBO,MAAM,SAAS,CACpB,QACA,OAEAA,MAAAA,MAAM,MAAM,IACR,EAAE,IAAI,OAAO,OAAO,GAAG,OAAO,KAAK,MAClC;;"}

package/dist/cjs/methods/match.js

@@ -0,0 +1,11 @@
+"use strict";
+const match = (result, okFn, errFn) => {
+  if (result.ok) {
+    return okFn(result.value);
+  } else {
+    const { error } = result;
+    return errFn(error);
+  }
+};
+exports.match = match;
+//# sourceMappingURL=match.js.map

package/dist/cjs/methods/match.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"match.js","sources":["../../../src/methods/match.ts"],"sourcesContent":["import { type Result } from '../shared-types.js';\n\n/**\n * Выполняет сопоставление `Result` в единое выходное значение.\n *\n * @typeParam T - Тип успешного значения.\n * @typeParam E - Тип значения ошибки.\n * @typeParam U - The output type returned by both handlers.\n * @param result - Исходный `Result`.\n * @param okFn - Обработчик для ветки успеха.\n * @param errFn - Обработчик для ветки ошибки.\n * @returns Выходное значение, полученное от выбранного обработчика.\n * @since 0.1.0\n * @see {@link unwrapOrElse} - Similar shape with default fallback semantics.\n * @example\n * ```ts\n * import { Ok, match } from '@resultsafe/core-fp-result';\n *\n * const value = match(Ok(3), (x) => `ok:${x}`, (e) => `err:${e}`);\n * console.log(value); // ok:3\n * ```\n * @public\n */\nexport const match = <T, E, U>(\n  result: Result<T, E>,\n  okFn: (value: T) => U,\n  errFn: (error: E) => U,\n): U => {\n  if (result.ok) {\n    return okFn(result.value);\n  } else {\n    const { error } = result;\n    return errFn(error);\n  }\n};\n\r\n\r\n"],"names":[],"mappings":";AAuBO,MAAM,QAAQ,CACnB,QACA,MACA,UACM;AACN,MAAI,OAAO,IAAI;AACb,WAAO,KAAK,OAAO,KAAK;AAAA,EAC1B,OAAO;AACL,UAAM,EAAE,UAAU;AAClB,WAAO,MAAM,KAAK;AAAA,EACpB;AACF;;"}

package/dist/cjs/methods/ok.js

@@ -0,0 +1,6 @@
+"use strict";
+const isOk = require("../guards/isOk.js");
+const option = require("../internal/option.js");
+const ok = (result) => isOk.isOk(result) ? option.Some(result.value) : option.None;
+exports.ok = ok;
+//# sourceMappingURL=ok.js.map

package/dist/cjs/methods/ok.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ok.js","sources":["../../../src/methods/ok.ts"],"sourcesContent":["import { type Option } from '../shared-types.js';\nimport { type Result } from '../shared-types.js';\n\nimport { isOk } from '../guards/isOk.js';\nimport { None, Some } from '../internal/option.js';\n\n/**\n * Извлекает успешную ветку в виде `Option`.\n *\n * @typeParam T - Тип успешного значения.\n * @typeParam E - Тип значения ошибки.\n * @param result - Исходный `Result`.\n * @returns `Some(value)` для `Ok`, иначе `None`.\n * @since 0.1.0\n * @see {@link err} - Извлекает ветку ошибки.\n * @example\n * ```ts\n * import { Ok, ok } from '@resultsafe/core-fp-result';\n *\n * const value = ok(Ok(10));\n * console.log(value.some); // true\n * ```\n * @public\n */\nexport const ok = <T, E>(result: Result<T, E>): Option<T> =>\n  isOk(result) ? Some(result.value) : None;\n\r\n\r\n"],"names":["isOk","Some","None"],"mappings":";;;AAwBO,MAAM,KAAK,CAAO,WACvBA,UAAK,MAAM,IAAIC,YAAK,OAAO,KAAK,IAAIC,OAAAA;;"}

package/dist/cjs/methods/orElse.js

@@ -0,0 +1,5 @@
+"use strict";
+const isErr = require("../guards/isErr.js");
+const orElse = (result, fn) => isErr.isErr(result) ? fn(result.error) : result;
+exports.orElse = orElse;
+//# sourceMappingURL=orElse.js.map

package/dist/cjs/methods/orElse.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"orElse.js","sources":["../../../src/methods/orElse.ts"],"sourcesContent":["import { type Result } from '../shared-types.js';\n\nimport { isErr } from '../guards/isErr.js';\n\n/**\n * Восстанавливается из ошибки, преобразуя `Err` в другой `Result`.\n *\n * @typeParam T - Тип успешного значения.\n * @typeParam E - Тип входного значения ошибки.\n * @typeParam F - Тип выходного значения ошибки.\n * @param result - Исходный `Result`.\n * @param fn - Функция восстановления, применяемая для `Err`.\n * @returns Восстановленный `Result` или исходный `Ok`.\n * @since 0.1.0\n * @see {@link andThen} - Цепляет ветку успеха.\n * @example\n * ```ts\n * import { Err, Ok, orElse } from '@resultsafe/core-fp-result';\n *\n * const result = orElse(Err('network'), () => Ok('cached'));\n * console.log(result.ok); // true\n * ```\n * @public\n */\nexport const orElse = <T, E, F>(\n  result: Result<T, E>,\n  fn: (error: E) => Result<T, F>,\n): Result<T, F> =>\n  isErr(result) ? fn(result.error) : (result as Result<T, F>);\n\r\n\r\n"],"names":["isErr"],"mappings":";;AAwBO,MAAM,SAAS,CACpB,QACA,OAEAA,MAAAA,MAAM,MAAM,IAAI,GAAG,OAAO,KAAK,IAAK;;"}

package/dist/cjs/methods/tap.js

@@ -0,0 +1,9 @@
+"use strict";
+const tap = (result, fn) => {
+  if (result.ok) {
+    fn(result.value);
+  }
+  return result;
+};
+exports.tap = tap;
+//# sourceMappingURL=tap.js.map

package/dist/cjs/methods/tap.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tap.js","sources":["../../../src/methods/tap.ts"],"sourcesContent":["import type { Result } from '../shared-types.js';\n\n/**\n * Выполняет побочный эффект для значения `Ok` и возвращает входной `Result`.\n *\n * @typeParam T - Тип успешного значения.\n * @typeParam E - Тип значения ошибки.\n * @param result - Исходный `Result`.\n * @param fn - Колбэк побочного эффекта для ветки успеха.\n * @returns Неизмененный `Result`.\n * @since 0.1.0\n * @see {@link tapErr} - Executes a side effect for the error branch.\n * @example\n * ```ts\n * import { Ok, tap } from '@resultsafe/core-fp-result';\n *\n * const result = tap(Ok(1), (value) => console.log(value)); // 1\n * console.log(result.ok); // true\n * ```\n * @public\n */\nexport const tap = <T, E>(\n  result: Result<T, E>,\n  fn: (value: T) => void,\n): Result<T, E> => {\n  if (result.ok) {\n    fn(result.value);\n  }\n  return result;\n};\n\r\n\r\n"],"names":[],"mappings":";AAqBO,MAAM,MAAM,CACjB,QACA,OACiB;AACjB,MAAI,OAAO,IAAI;AACb,OAAG,OAAO,KAAK;AAAA,EACjB;AACA,SAAO;AACT;;"}