@resultsafe/core-fp-result 0.1.0

package/dist/esm/guards/isOkAnd.js

@@ -0,0 +1,8 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+import { isOk } from "./isOk.js";
+const isOkAnd = /* @__PURE__ */ __name((result, predicate) => isOk(result) && predicate(result.value), "isOkAnd");
+export {
+  isOkAnd
+};
+//# sourceMappingURL=isOkAnd.js.map

package/dist/esm/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":[],"mappings":";;;AAuBO,MAAM,UAAU,wBACrB,QACA,cACY,KAAK,MAAM,KAAK,UAAU,OAAO,KAAK,GAH7B;"}

package/dist/esm/index.js

@@ -0,0 +1,71 @@
+import { Err } from "./constructors/Err.js";
+import { Ok } from "./constructors/Ok.js";
+import { isErr } from "./guards/isErr.js";
+import { isErrAnd } from "./guards/isErrAnd.js";
+import { isOk } from "./guards/isOk.js";
+import { isOkAnd } from "./guards/isOkAnd.js";
+import { andThen } from "./methods/andThen.js";
+import { err } from "./methods/err.js";
+import { expect } from "./methods/expect.js";
+import { expectErr } from "./methods/expectErr.js";
+import { flatten } from "./methods/flatten.js";
+import { inspect } from "./methods/inspect.js";
+import { inspectErr } from "./methods/inspectErr.js";
+import { map } from "./methods/map.js";
+import { mapErr } from "./methods/mapErr.js";
+import { match } from "./methods/match.js";
+import { ok } from "./methods/ok.js";
+import { orElse } from "./methods/orElse.js";
+import { tap } from "./methods/tap.js";
+import { tapErr } from "./methods/tapErr.js";
+import { transpose } from "./methods/transpose.js";
+import { unwrap } from "./methods/unwrap.js";
+import { unwrapErr } from "./methods/unwrapErr.js";
+import { unwrapOr } from "./methods/unwrapOr.js";
+import { unwrapOrElse } from "./methods/unwrapOrElse.js";
+import { isTypedVariant } from "./refiners/isTypedVariant.js";
+import { isTypedVariantOf } from "./refiners/isTypedVariantOf.js";
+import { matchVariant } from "./refiners/matchVariant.js";
+import { matchVariantStrict } from "./refiners/matchVariantStrict.js";
+import { refineAsyncResult } from "./refiners/refineAsyncResult.js";
+import { refineAsyncResultU } from "./refiners/refineAsyncResultU.js";
+import { refineResult } from "./refiners/refineResult.js";
+import { refineResultU } from "./refiners/refineResultU.js";
+import { refineVariantMap } from "./refiners/refineVariantMap.js";
+export {
+  Err,
+  Ok,
+  andThen,
+  err,
+  expect,
+  expectErr,
+  flatten,
+  inspect,
+  inspectErr,
+  isErr,
+  isErrAnd,
+  isOk,
+  isOkAnd,
+  isTypedVariant,
+  isTypedVariantOf,
+  map,
+  mapErr,
+  match,
+  matchVariant,
+  matchVariantStrict,
+  ok,
+  orElse,
+  refineAsyncResult,
+  refineAsyncResultU,
+  refineResult,
+  refineResultU,
+  refineVariantMap,
+  tap,
+  tapErr,
+  transpose,
+  unwrap,
+  unwrapErr,
+  unwrapOr,
+  unwrapOrElse
+};
+//# sourceMappingURL=index.js.map

package/dist/esm/index.js.map

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

package/dist/esm/internal/object.js

@@ -0,0 +1,9 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+const hasOwn = /* @__PURE__ */ __name((obj, key) => Object.prototype.hasOwnProperty.call(obj, key), "hasOwn");
+const isObject = /* @__PURE__ */ __name((value) => typeof value === "object" && value !== null, "isObject");
+export {
+  hasOwn,
+  isObject
+};
+//# sourceMappingURL=object.js.map

package/dist/esm/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,wBACpB,KACA,QAC8B,OAAO,UAAU,eAAe,KAAK,KAAK,GAAG,GAHvD;AAMf,MAAM,WAAW,wBAAC,UACvB,OAAO,UAAU,YAAY,UAAU,MADjB;"}

package/dist/esm/internal/option.js

@@ -0,0 +1,9 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+const None = { some: false };
+const Some = /* @__PURE__ */ __name((value) => ({ some: true, value }), "Some");
+export {
+  None,
+  Some
+};
+//# sourceMappingURL=option.js.map

package/dist/esm/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,wBAAI,WAAc,EAAE,MAAM,MAAM,MAAA,IAAhC;"}

package/dist/esm/methods/andThen.js

@@ -0,0 +1,8 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+import { isOk } from "../guards/isOk.js";
+const andThen = /* @__PURE__ */ __name((result, fn) => isOk(result) ? fn(result.value) : result, "andThen");
+export {
+  andThen
+};
+//# sourceMappingURL=andThen.js.map

package/dist/esm/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":[],"mappings":";;;AA2BO,MAAM,UAAU,wBACrB,QACA,OACkB,KAAK,MAAM,IAAI,GAAG,OAAO,KAAK,IAAK,QAHhC;"}

package/dist/esm/methods/err.js

@@ -0,0 +1,9 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+import { isErr } from "../guards/isErr.js";
+import { Some, None } from "../internal/option.js";
+const err = /* @__PURE__ */ __name((result) => isErr(result) ? Some(result.error) : None, "err");
+export {
+  err
+};
+//# sourceMappingURL=err.js.map

package/dist/esm/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":[],"mappings":";;;;AAwBO,MAAM,MAAM,wBAAO,WACxB,MAAM,MAAM,IAAI,KAAK,OAAO,KAAK,IAAI,MADpB;"}

package/dist/esm/methods/expect.js

@@ -0,0 +1,13 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+import { isOk } from "../guards/isOk.js";
+const expect = /* @__PURE__ */ __name((result, msg) => {
+  if (isOk(result)) {
+    return result.value;
+  }
+  throw new Error(msg);
+}, "expect");
+export {
+  expect
+};
+//# sourceMappingURL=expect.js.map

package/dist/esm/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":[],"mappings":";;;AAwBO,MAAM,SAAS,wBAAO,QAAsB,QAAmB;AACpE,MAAI,KAAK,MAAM,GAAG;AAChB,WAAO,OAAO;AAAA,EAChB;AACA,QAAM,IAAI,MAAM,GAAG;AACrB,GALsB;"}

package/dist/esm/methods/expectErr.js

@@ -0,0 +1,13 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+import { isErr } from "../guards/isErr.js";
+const expectErr = /* @__PURE__ */ __name((result, msg) => {
+  if (isErr(result)) {
+    return result.error;
+  }
+  throw new Error(msg);
+}, "expectErr");
+export {
+  expectErr
+};
+//# sourceMappingURL=expectErr.js.map

package/dist/esm/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":[],"mappings":";;;AAwBO,MAAM,YAAY,wBAAO,QAAsB,QAAmB;AACvE,MAAI,MAAM,MAAM,GAAG;AACjB,WAAO,OAAO;AAAA,EAChB;AACA,QAAM,IAAI,MAAM,GAAG;AACrB,GALyB;"}

package/dist/esm/methods/flatten.js

@@ -0,0 +1,7 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+const flatten = /* @__PURE__ */ __name((result) => result.ok ? result.value : { ok: false, error: result.error }, "flatten");
+export {
+  flatten
+};
+//# sourceMappingURL=flatten.js.map

package/dist/esm/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,wBAAO,WAC5B,OAAO,KAAK,OAAO,QAAQ,EAAE,IAAI,OAAO,OAAO,OAAO,MAAA,GADjC;"}

package/dist/esm/methods/inspect.js

@@ -0,0 +1,13 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+import { isOk } from "../guards/isOk.js";
+const inspect = /* @__PURE__ */ __name((result, fn) => {
+  if (isOk(result)) {
+    fn(result.value);
+  }
+  return result;
+}, "inspect");
+export {
+  inspect
+};
+//# sourceMappingURL=inspect.js.map

package/dist/esm/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":[],"mappings":";;;AAuBO,MAAM,UAAU,wBACrB,QACA,OACiB;AACjB,MAAI,KAAK,MAAM,GAAG;AAChB,OAAG,OAAO,KAAK;AAAA,EACjB;AACA,SAAO;AACT,GARuB;"}

package/dist/esm/methods/inspectErr.js

@@ -0,0 +1,13 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+import { isErr } from "../guards/isErr.js";
+const inspectErr = /* @__PURE__ */ __name((result, fn) => {
+  if (isErr(result)) {
+    fn(result.error);
+  }
+  return result;
+}, "inspectErr");
+export {
+  inspectErr
+};
+//# sourceMappingURL=inspectErr.js.map

package/dist/esm/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":[],"mappings":";;;AAuBO,MAAM,aAAa,wBACxB,QACA,OACiB;AACjB,MAAI,MAAM,MAAM,GAAG;AACjB,OAAG,OAAO,KAAK;AAAA,EACjB;AACA,SAAO;AACT,GAR0B;"}

package/dist/esm/methods/map.js

@@ -0,0 +1,8 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+import { isOk } from "../guards/isOk.js";
+const map = /* @__PURE__ */ __name((result, fn) => isOk(result) ? { ok: true, value: fn(result.value) } : result, "map");
+export {
+  map
+};
+//# sourceMappingURL=map.js.map

package/dist/esm/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":[],"mappings":";;;AAwBO,MAAM,MAAM,wBACjB,QACA,OAEA,KAAK,MAAM,IACP,EAAE,IAAI,MAAM,OAAO,GAAG,OAAO,KAAK,MACjC,QANY;"}

package/dist/esm/methods/mapErr.js

@@ -0,0 +1,8 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+import { isErr } from "../guards/isErr.js";
+const mapErr = /* @__PURE__ */ __name((result, fn) => isErr(result) ? { ok: false, error: fn(result.error) } : result, "mapErr");
+export {
+  mapErr
+};
+//# sourceMappingURL=mapErr.js.map

package/dist/esm/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":[],"mappings":";;;AAwBO,MAAM,SAAS,wBACpB,QACA,OAEA,MAAM,MAAM,IACR,EAAE,IAAI,OAAO,OAAO,GAAG,OAAO,KAAK,MAClC,QANe;"}

package/dist/esm/methods/match.js

@@ -0,0 +1,14 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+const match = /* @__PURE__ */ __name((result, okFn, errFn) => {
+  if (result.ok) {
+    return okFn(result.value);
+  } else {
+    const { error } = result;
+    return errFn(error);
+  }
+}, "match");
+export {
+  match
+};
+//# sourceMappingURL=match.js.map

package/dist/esm/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,wBACnB,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,GAXqB;"}

package/dist/esm/methods/ok.js

@@ -0,0 +1,9 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+import { isOk } from "../guards/isOk.js";
+import { Some, None } from "../internal/option.js";
+const ok = /* @__PURE__ */ __name((result) => isOk(result) ? Some(result.value) : None, "ok");
+export {
+  ok
+};
+//# sourceMappingURL=ok.js.map

package/dist/esm/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":[],"mappings":";;;;AAwBO,MAAM,KAAK,wBAAO,WACvB,KAAK,MAAM,IAAI,KAAK,OAAO,KAAK,IAAI,MADpB;"}

package/dist/esm/methods/orElse.js

@@ -0,0 +1,8 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+import { isErr } from "../guards/isErr.js";
+const orElse = /* @__PURE__ */ __name((result, fn) => isErr(result) ? fn(result.error) : result, "orElse");
+export {
+  orElse
+};
+//# sourceMappingURL=orElse.js.map

package/dist/esm/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":[],"mappings":";;;AAwBO,MAAM,SAAS,wBACpB,QACA,OAEA,MAAM,MAAM,IAAI,GAAG,OAAO,KAAK,IAAK,QAJhB;"}

package/dist/esm/methods/tap.js

@@ -0,0 +1,12 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+const tap = /* @__PURE__ */ __name((result, fn) => {
+  if (result.ok) {
+    fn(result.value);
+  }
+  return result;
+}, "tap");
+export {
+  tap
+};
+//# sourceMappingURL=tap.js.map

package/dist/esm/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,wBACjB,QACA,OACiB;AACjB,MAAI,OAAO,IAAI;AACb,OAAG,OAAO,KAAK;AAAA,EACjB;AACA,SAAO;AACT,GARmB;"}

package/dist/esm/methods/tapErr.js

@@ -0,0 +1,13 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+import { isErr } from "../guards/isErr.js";
+const tapErr = /* @__PURE__ */ __name((result, fn) => {
+  if (isErr(result)) {
+    fn(result.error);
+  }
+  return result;
+}, "tapErr");
+export {
+  tapErr
+};
+//# sourceMappingURL=tapErr.js.map

package/dist/esm/methods/tapErr.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tapErr.js","sources":["../../../src/methods/tapErr.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 * @param result - Исходный `Result`.\n * @param fn - Колбэк побочного эффекта для ветки ошибки.\n * @returns Неизмененный `Result`.\n * @since 0.1.0\n * @see {@link tap} - Executes a side effect for the success branch.\n * @example\n * ```ts\n * import { Err, tapErr } from '@resultsafe/core-fp-result';\n *\n * const result = tapErr(Err('boom'), (error) => console.log(error)); // boom\n * console.log(result.ok); // false\n * ```\n * @public\n */\nexport const tapErr = <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":[],"mappings":";;;AAuBO,MAAM,SAAS,wBACpB,QACA,OACiB;AACjB,MAAI,MAAM,MAAM,GAAG;AACjB,OAAG,OAAO,KAAK;AAAA,EACjB;AACA,SAAO;AACT,GARsB;"}

package/dist/esm/methods/transpose.js

@@ -0,0 +1,13 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+import { Some, None } from "../internal/option.js";
+const transpose = /* @__PURE__ */ __name((result) => {
+  if (result.ok) {
+    return result.value.some === true ? Some({ ok: true, value: result.value.value }) : None;
+  }
+  return Some({ ok: false, error: result.error });
+}, "transpose");
+export {
+  transpose
+};
+//# sourceMappingURL=transpose.js.map

package/dist/esm/methods/transpose.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"transpose.js","sources":["../../../src/methods/transpose.ts"],"sourcesContent":["import { type Option } from '../shared-types.js';\nimport { type Result } from '../shared-types.js';\n\nimport { None, Some } from '../internal/option.js';\n\n/**\n * Преобразует `Result<Option<T>, E>` в `Option<Result<T, E>>`.\n *\n * @typeParam T - The success value type inside `Option`.\n * @typeParam E - Тип значения ошибки.\n * @param result - Исходный `Result`, содержащий `Option`.\n * @returns Транспонированный `Option<Result<T, E>>`.\n * @since 0.1.0\n * @see {@link flatten} - Collapses nested `Result` values.\n * @example\n * ```ts\n * import { Ok, transpose } from '@resultsafe/core-fp-result';\n *\n * const value = transpose(Ok({ some: true, value: 2 }));\n * console.log(value.some); // true\n * ```\n * @public\n */\nexport const transpose = <T, E>(\n  result: Result<Option<T>, E>,\n): Option<Result<T, E>> => {\n  if (result.ok) {\n    return result.value.some === true\n      ? Some({ ok: true, value: result.value.value })\n      : None;\n  }\n  return Some({ ok: false, error: result.error });\n};\n\r\n\r\n"],"names":[],"mappings":";;;AAuBO,MAAM,YAAY,wBACvB,WACyB;AACzB,MAAI,OAAO,IAAI;AACb,WAAO,OAAO,MAAM,SAAS,OACzB,KAAK,EAAE,IAAI,MAAM,OAAO,OAAO,MAAM,MAAA,CAAO,IAC5C;AAAA,EACN;AACA,SAAO,KAAK,EAAE,IAAI,OAAO,OAAO,OAAO,OAAO;AAChD,GATyB;"}

package/dist/esm/methods/unwrap.js

@@ -0,0 +1,13 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+import { isOk } from "../guards/isOk.js";
+const unwrap = /* @__PURE__ */ __name((result) => {
+  if (isOk(result)) {
+    return result.value;
+  }
+  throw new Error("Called unwrap on an Err value");
+}, "unwrap");
+export {
+  unwrap
+};
+//# sourceMappingURL=unwrap.js.map

package/dist/esm/methods/unwrap.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"unwrap.js","sources":["../../../src/methods/unwrap.ts"],"sourcesContent":["import { type Result } from '../shared-types.js';\n\nimport { isOk } from '../guards/isOk.js';\n\n/**\n * Возвращает успешное значение или выбрасывает исключение, если результат `Err`.\n *\n * @typeParam T - Тип успешного значения.\n * @typeParam E - Тип значения ошибки.\n * @param result - Исходный `Result`.\n * @returns Payload успеха.\n * @throws Error - Выбрасывает исключение при вызове на `Err`.\n * @since 0.1.0\n * @see {@link unwrapOr} - Возвращает fallback вместо выброса исключения.\n * @example\n * ```ts\n * import { Ok, unwrap } from '@resultsafe/core-fp-result';\n *\n * const value = unwrap(Ok(9));\n * console.log(value); // 9\n * ```\n * @public\n */\nexport const unwrap = <T, E>(result: Result<T, E>): T => {\n  if (isOk(result)) {\n    return result.value;\n  }\n  throw new Error('Called unwrap on an Err value');\n};\n\r\n\r\n"],"names":[],"mappings":";;;AAuBO,MAAM,SAAS,wBAAO,WAA4B;AACvD,MAAI,KAAK,MAAM,GAAG;AAChB,WAAO,OAAO;AAAA,EAChB;AACA,QAAM,IAAI,MAAM,+BAA+B;AACjD,GALsB;"}

package/dist/esm/methods/unwrapErr.js

@@ -0,0 +1,13 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+import { isErr } from "../guards/isErr.js";
+const unwrapErr = /* @__PURE__ */ __name((result) => {
+  if (isErr(result)) {
+    return result.error;
+  }
+  throw new Error("Called unwrapErr on an Ok value");
+}, "unwrapErr");
+export {
+  unwrapErr
+};
+//# sourceMappingURL=unwrapErr.js.map

package/dist/esm/methods/unwrapErr.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"unwrapErr.js","sources":["../../../src/methods/unwrapErr.ts"],"sourcesContent":["import { type Result } from '../shared-types.js';\n\nimport { isErr } from '../guards/isErr.js';\n\n/**\n * Возвращает значение ошибки или выбрасывает исключение, если результат `Ok`.\n *\n * @typeParam T - Тип успешного значения.\n * @typeParam E - Тип значения ошибки.\n * @param result - Исходный `Result`.\n * @returns Payload ошибки.\n * @throws Error - Выбрасывает исключение при вызове на `Ok`.\n * @since 0.1.0\n * @see {@link unwrapOrElse} - Возвращает fallback успеха без выброса исключения.\n * @example\n * ```ts\n * import { Err, unwrapErr } from '@resultsafe/core-fp-result';\n *\n * const error = unwrapErr(Err('boom'));\n * console.log(error); // boom\n * ```\n * @public\n */\nexport const unwrapErr = <T, E>(result: Result<T, E>): E => {\n  if (isErr(result)) {\n    return result.error;\n  }\n  throw new Error('Called unwrapErr on an Ok value');\n};\n\r\n\r\n"],"names":[],"mappings":";;;AAuBO,MAAM,YAAY,wBAAO,WAA4B;AAC1D,MAAI,MAAM,MAAM,GAAG;AACjB,WAAO,OAAO;AAAA,EAChB;AACA,QAAM,IAAI,MAAM,iCAAiC;AACnD,GALyB;"}

package/dist/esm/methods/unwrapOr.js

@@ -0,0 +1,8 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+import { isOk } from "../guards/isOk.js";
+const unwrapOr = /* @__PURE__ */ __name((result, defaultValue) => isOk(result) ? result.value : defaultValue, "unwrapOr");
+export {
+  unwrapOr
+};
+//# sourceMappingURL=unwrapOr.js.map

package/dist/esm/methods/unwrapOr.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"unwrapOr.js","sources":["../../../src/methods/unwrapOr.ts"],"sourcesContent":["import { type Result } from '../shared-types.js';\n\nimport { isOk } from '../guards/isOk.js';\n\n/**\n * Возвращает успешное значение или переданный fallback по умолчанию.\n *\n * @typeParam T - Тип успешного значения.\n * @typeParam E - Тип значения ошибки.\n * @param result - Исходный `Result`.\n * @param defaultValue - Fallback-значение для `Err`.\n * @returns Payload успеха или `defaultValue`.\n * @since 0.1.0\n * @see {@link unwrapOrElse} - Вычисляет fallback лениво.\n * @example\n * ```ts\n * import { Err, unwrapOr } from '@resultsafe/core-fp-result';\n *\n * const value = unwrapOr(Err('boom'), 0);\n * console.log(value); // 0\n * ```\n * @public\n */\nexport const unwrapOr = <T, E>(result: Result<T, E>, defaultValue: T): T =>\n  isOk(result) ? result.value : defaultValue;\n\r\n\r\n"],"names":[],"mappings":";;;AAuBO,MAAM,WAAW,wBAAO,QAAsB,iBACnD,KAAK,MAAM,IAAI,OAAO,QAAQ,cADR;"}

package/dist/esm/methods/unwrapOrElse.js

@@ -0,0 +1,13 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+const unwrapOrElse = /* @__PURE__ */ __name((result, fn) => {
+  if (result.ok) {
+    return result.value;
+  } else {
+    return fn(result.error);
+  }
+}, "unwrapOrElse");
+export {
+  unwrapOrElse
+};
+//# sourceMappingURL=unwrapOrElse.js.map

package/dist/esm/methods/unwrapOrElse.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"unwrapOrElse.js","sources":["../../../src/methods/unwrapOrElse.ts"],"sourcesContent":["import { type Result } from '../shared-types.js';\n\n/**\n * Возвращает успешное значение или вычисляет fallback из ошибки.\n *\n * @typeParam T - Тип успешного значения.\n * @typeParam E - Тип значения ошибки.\n * @param result - Исходный `Result`.\n * @param fn - Функция-поставщик fallback для `Err`.\n * @returns Payload успеха или вычисленный fallback.\n * @since 0.1.0\n * @see {@link unwrapOr} - Использует eager fallback-значение.\n * @example\n * ```ts\n * import { Err, unwrapOrElse } from '@resultsafe/core-fp-result';\n *\n * const value = unwrapOrElse(Err('fatal'), (error) => error.length);\n * console.log(value); // 5\n * ```\n * @public\n */\nexport const unwrapOrElse = <T, E>(\n  result: Result<T, E>,\n  fn: (error: E) => T,\n): T => {\n  if (result.ok) {\n    return result.value;\n  } else {\n    return fn(result.error);\n  }\n};\n\r\n\r\n"],"names":[],"mappings":";;AAqBO,MAAM,eAAe,wBAC1B,QACA,OACM;AACN,MAAI,OAAO,IAAI;AACb,WAAO,OAAO;AAAA,EAChB,OAAO;AACL,WAAO,GAAG,OAAO,KAAK;AAAA,EACxB;AACF,GAT4B;"}

package/dist/esm/refiners/isTypedVariant.js

@@ -0,0 +1,12 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+const isTypedVariant = /* @__PURE__ */ __name((variant) => (value) => {
+  if (typeof value !== "object" || value === null) return false;
+  if (!("type" in value)) return false;
+  const obj = value;
+  return obj["type"] === variant;
+}, "isTypedVariant");
+export {
+  isTypedVariant
+};
+//# sourceMappingURL=isTypedVariant.js.map

package/dist/esm/refiners/isTypedVariant.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"isTypedVariant.js","sources":["../../../src/refiners/isTypedVariant.ts"],"sourcesContent":["/**\n * Создает runtime type guard для варианта дискриминированного объединения.\n *\n * @typeParam K - The discriminant literal type.\n * @param variant - Значение дискриминанта для сопоставления.\n * @returns A predicate that checks `{ type: K }` shape.\n * @since 0.1.0\n * @see {@link isTypedVariantOf} - Расширяет проверку ключами payload.\n * @example\n * ```ts\n * import { isTypedVariant } from '@resultsafe/core-fp-result';\n *\n * const isCreated = isTypedVariant('created');\n * console.log(isCreated({ type: 'created' })); // true\n * ```\n * @public\n */\nexport const isTypedVariant =\n  <K extends string>(variant: K) =>\n  (value: unknown): value is { type: K } => {\n    if (typeof value !== 'object' || value === null) return false;\n    if (!('type' in value)) return false;\n\n    const obj = value as Record<string, unknown>;\n    return obj['type'] === variant;\n  };\n"],"names":[],"mappings":";;AAiBO,MAAM,iBACX,wBAAmB,YACnB,CAAC,UAAyC;AACxC,MAAI,OAAO,UAAU,YAAY,UAAU,KAAM,QAAO;AACxD,MAAI,EAAE,UAAU,OAAQ,QAAO;AAE/B,QAAM,MAAM;AACZ,SAAO,IAAI,MAAM,MAAM;AACzB,GAPA;"}

package/dist/esm/refiners/isTypedVariantOf.js

@@ -0,0 +1,17 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+const isTypedVariantOf = /* @__PURE__ */ __name((variant) => (value) => {
+  if (typeof value !== "object" || value === null) return false;
+  if (!("type" in value)) return false;
+  const obj = value;
+  if (obj["type"] !== variant) return false;
+  const requiredKeys = Object.keys({});
+  for (const key of requiredKeys) {
+    if (!(key in obj)) return false;
+  }
+  return true;
+}, "isTypedVariantOf");
+export {
+  isTypedVariantOf
+};
+//# sourceMappingURL=isTypedVariantOf.js.map

package/dist/esm/refiners/isTypedVariantOf.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"isTypedVariantOf.js","sources":["../../../src/refiners/isTypedVariantOf.ts"],"sourcesContent":["/**\n * Создает runtime type guard для варианта с дополнительными ключами payload.\n *\n * @typeParam K - The discriminant literal type.\n * @typeParam T - The required payload record shape.\n * @param variant - Значение дискриминанта для сопоставления.\n * @returns A predicate that checks variant and payload key presence.\n * @since 0.1.0\n * @see {@link isTypedVariant} - Проверяет только дискриминант.\n * @example\n * ```ts\n * import { isTypedVariantOf } from '@resultsafe/core-fp-result';\n *\n * const isCreated = isTypedVariantOf<'created', { id: unknown }>('created');\n * console.log(isCreated({ type: 'created', id: 1 })); // true\n * ```\n * @public\n */\nexport const isTypedVariantOf =\n  <K extends string, T extends Record<string, unknown>>(variant: K) =>\n  (value: unknown): value is { type: K } & T => {\n    // Rust-style early returns with Option-like behavior\n    if (typeof value !== 'object' || value === null) return false;\n    if (!('type' in value)) return false;\n\n    const obj = value as Record<string, unknown>;\n    if (obj['type'] !== variant) return false;\n\n    // Type-safe key checking (like Rust's HashMap.contains_key)\n    const requiredKeys = Object.keys({} as T) as Array<keyof T>;\n    for (const key of requiredKeys) {\n      if (!(key in obj)) return false;\n    }\n\n    return true;\n  };\n"],"names":[],"mappings":";;AAkBO,MAAM,mBACX,wBAAsD,YACtD,CAAC,UAA6C;AAE5C,MAAI,OAAO,UAAU,YAAY,UAAU,KAAM,QAAO;AACxD,MAAI,EAAE,UAAU,OAAQ,QAAO;AAE/B,QAAM,MAAM;AACZ,MAAI,IAAI,MAAM,MAAM,QAAS,QAAO;AAGpC,QAAM,eAAe,OAAO,KAAK,EAAO;AACxC,aAAW,OAAO,cAAc;AAC9B,QAAI,EAAE,OAAO,KAAM,QAAO;AAAA,EAC5B;AAEA,SAAO;AACT,GAhBA;"}

package/dist/esm/refiners/matchVariant.js

@@ -0,0 +1,60 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+const matchVariant = /* @__PURE__ */ __name((value) => {
+  const handlers = [];
+  const withHandler = /* @__PURE__ */ __name((variant, fn) => {
+    const newHandlers = [...handlers, { variant, fn }];
+    return {
+      with: /* @__PURE__ */ __name((variant2, fn2) => {
+        const newerHandlers = [
+          ...newHandlers,
+          { variant: variant2, fn: fn2 }
+        ];
+        return {
+          with: withHandler,
+          otherwise: /* @__PURE__ */ __name((fallback) => ({
+            run: /* @__PURE__ */ __name(() => {
+              for (const h of newerHandlers) {
+                if (value.type === h.variant) {
+                  const fn3 = h.fn;
+                  return fn3(value);
+                }
+              }
+              return fallback(value);
+            }, "run")
+          }), "otherwise")
+        };
+      }, "with"),
+      otherwise: /* @__PURE__ */ __name((fallback) => ({
+        run: /* @__PURE__ */ __name(() => {
+          for (const h of newHandlers) {
+            if (value.type === h.variant) {
+              const fn2 = h.fn;
+              return fn2(value);
+            }
+          }
+          return fallback(value);
+        }, "run")
+      }), "otherwise")
+    };
+  }, "withHandler");
+  const matcher = {
+    with: withHandler,
+    otherwise: /* @__PURE__ */ __name((fallback) => ({
+      run: /* @__PURE__ */ __name(() => {
+        for (const h of handlers) {
+          if (value.type === h.variant) {
+            const fn = h.fn;
+            return fn(value);
+          }
+        }
+        return fallback(value);
+      }, "run")
+    }), "otherwise")
+  };
+  return matcher;
+}, "matchVariant");
+export {
+  matchVariant
+};
+//# sourceMappingURL=matchVariant.js.map

package/dist/esm/refiners/matchVariant.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"matchVariant.js","sources":["../../../src/refiners/matchVariant.ts"],"sourcesContent":["import type { Handler, Matcher, VariantOf } from './types/index.js';\n\n/**\n * Создает цепочный matcher для значения дискриминированного объединения.\n *\n * @typeParam T - Тип дискриминированного объединения.\n * @param value - Значение объединения для сопоставления.\n * @returns Fluent matcher с ветками `with` и `otherwise`.\n * @since 0.1.0\n * @see {@link matchVariantStrict} - Требует исчерпывающего сопоставления во время выполнения.\n * @example\n * ```ts\n * import { matchVariant } from '@resultsafe/core-fp-result';\n *\n * const out = matchVariant<{ type: 'ok'; value: number } | { type: 'err'; error: string }>({\n *   type: 'ok',\n *   value: 1,\n * })\n *   .with('ok', (v) => `ok:${v.value}`)\n *   .otherwise(() => 'fallback')\n *   .run();\n *\n * console.log(out); // ok:1\n * ```\n * @public\n */\nexport const matchVariant = <T extends VariantOf>(\n  value: T,\n): Matcher<T, unknown> => {\n  const handlers: readonly Handler<T['type'], T, unknown>[] = [];\n\n  const withHandler = <K extends T['type']>(\n    variant: K,\n    fn: (value: Extract<T, { type: K }>) => unknown,\n  ): Matcher<T, unknown> => {\n    const newHandlers = [...handlers, { variant, fn }] as const;\n\n    return {\n      with: <K2 extends T['type']>(\n        variant2: K2,\n        fn2: (value: Extract<T, { type: K2 }>) => unknown,\n      ): Matcher<T, unknown> => {\n        const newerHandlers = [\n          ...newHandlers,\n          { variant: variant2, fn: fn2 },\n        ] as const;\n\n        return {\n          with: withHandler,\n          otherwise: (fallback: (value: T) => unknown) => ({\n            run: (): unknown => {\n              for (const h of newerHandlers) {\n                if (value.type === h.variant) {\n                  const fn = h.fn as (input: T) => unknown;\n                  return fn(value);\n                }\n              }\n              return fallback(value);\n            },\n          }),\n        } as Matcher<T, unknown>;\n      },\n      otherwise: (fallback: (value: T) => unknown) => ({\n        run: (): unknown => {\n          for (const h of newHandlers) {\n            if (value.type === h.variant) {\n              const fn = h.fn as (input: T) => unknown;\n              return fn(value);\n            }\n          }\n          return fallback(value);\n        },\n      }),\n    } as Matcher<T, unknown>;\n  };\n\n  const matcher: Matcher<T, unknown> = {\n    with: withHandler,\n    otherwise: (fallback: (value: T) => unknown) => ({\n      run: (): unknown => {\n        /* v8 ignore start -- unreachable with current immutable root handler list */\n        for (const h of handlers) {\n          if (value.type === h.variant) {\n            const fn = h.fn as (input: T) => unknown;\n            return fn(value);\n          }\n        }\n        /* v8 ignore stop */\n        return fallback(value);\n      },\n    }),\n  };\n\n  return matcher;\n};\n"],"names":["fn"],"mappings":";;AA0BO,MAAM,eAAe,wBAC1B,UACwB;AACxB,QAAM,WAAsD,CAAA;AAE5D,QAAM,cAAc,wBAClB,SACA,OACwB;AACxB,UAAM,cAAc,CAAC,GAAG,UAAU,EAAE,SAAS,IAAI;AAEjD,WAAO;AAAA,MACL,MAAM,wBACJ,UACA,QACwB;AACxB,cAAM,gBAAgB;AAAA,UACpB,GAAG;AAAA,UACH,EAAE,SAAS,UAAU,IAAI,IAAA;AAAA,QAAI;AAG/B,eAAO;AAAA,UACL,MAAM;AAAA,UACN,WAAW,wBAAC,cAAqC;AAAA,YAC/C,KAAK,6BAAe;AAClB,yBAAW,KAAK,eAAe;AAC7B,oBAAI,MAAM,SAAS,EAAE,SAAS;AAC5B,wBAAMA,MAAK,EAAE;AACb,yBAAOA,IAAG,KAAK;AAAA,gBACjB;AAAA,cACF;AACA,qBAAO,SAAS,KAAK;AAAA,YACvB,GARK;AAAA,UAQL,IATS;AAAA,QAUX;AAAA,MAEJ,GAvBM;AAAA,MAwBN,WAAW,wBAAC,cAAqC;AAAA,QAC/C,KAAK,6BAAe;AAClB,qBAAW,KAAK,aAAa;AAC3B,gBAAI,MAAM,SAAS,EAAE,SAAS;AAC5B,oBAAMA,MAAK,EAAE;AACb,qBAAOA,IAAG,KAAK;AAAA,YACjB;AAAA,UACF;AACA,iBAAO,SAAS,KAAK;AAAA,QACvB,GARK;AAAA,MAQL,IATS;AAAA,IAUX;AAAA,EAEJ,GA3CoB;AA6CpB,QAAM,UAA+B;AAAA,IACnC,MAAM;AAAA,IACN,WAAW,wBAAC,cAAqC;AAAA,MAC/C,KAAK,6BAAe;AAElB,mBAAW,KAAK,UAAU;AACxB,cAAI,MAAM,SAAS,EAAE,SAAS;AAC5B,kBAAM,KAAK,EAAE;AACb,mBAAO,GAAG,KAAK;AAAA,UACjB;AAAA,QACF;AAEA,eAAO,SAAS,KAAK;AAAA,MACvB,GAVK;AAAA,IAUL,IAXS;AAAA,EAYX;AAGF,SAAO;AACT,GApE4B;"}