@resultsafe/core-fp-result 0.1.0

package/dist/cjs/methods/tapErr.js

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

package/dist/cjs/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":["isErr"],"mappings":";;AAuBO,MAAM,SAAS,CACpB,QACA,OACiB;AACjB,MAAIA,MAAAA,MAAM,MAAM,GAAG;AACjB,OAAG,OAAO,KAAK;AAAA,EACjB;AACA,SAAO;AACT;;"}

package/dist/cjs/methods/transpose.js

@@ -0,0 +1,10 @@
+"use strict";
+const option = require("../internal/option.js");
+const transpose = (result) => {
+  if (result.ok) {
+    return result.value.some === true ? option.Some({ ok: true, value: result.value.value }) : option.None;
+  }
+  return option.Some({ ok: false, error: result.error });
+};
+exports.transpose = transpose;
+//# sourceMappingURL=transpose.js.map

package/dist/cjs/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":["Some","None"],"mappings":";;AAuBO,MAAM,YAAY,CACvB,WACyB;AACzB,MAAI,OAAO,IAAI;AACb,WAAO,OAAO,MAAM,SAAS,OACzBA,OAAAA,KAAK,EAAE,IAAI,MAAM,OAAO,OAAO,MAAM,MAAA,CAAO,IAC5CC,OAAAA;AAAAA,EACN;AACA,SAAOD,OAAAA,KAAK,EAAE,IAAI,OAAO,OAAO,OAAO,OAAO;AAChD;;"}

package/dist/cjs/methods/unwrap.js

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

package/dist/cjs/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":["isOk"],"mappings":";;AAuBO,MAAM,SAAS,CAAO,WAA4B;AACvD,MAAIA,KAAAA,KAAK,MAAM,GAAG;AAChB,WAAO,OAAO;AAAA,EAChB;AACA,QAAM,IAAI,MAAM,+BAA+B;AACjD;;"}

package/dist/cjs/methods/unwrapErr.js

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

package/dist/cjs/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":["isErr"],"mappings":";;AAuBO,MAAM,YAAY,CAAO,WAA4B;AAC1D,MAAIA,MAAAA,MAAM,MAAM,GAAG;AACjB,WAAO,OAAO;AAAA,EAChB;AACA,QAAM,IAAI,MAAM,iCAAiC;AACnD;;"}

package/dist/cjs/methods/unwrapOr.js

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

package/dist/cjs/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":["isOk"],"mappings":";;AAuBO,MAAM,WAAW,CAAO,QAAsB,iBACnDA,KAAAA,KAAK,MAAM,IAAI,OAAO,QAAQ;;"}

package/dist/cjs/methods/unwrapOrElse.js

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

package/dist/cjs/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,CAC1B,QACA,OACM;AACN,MAAI,OAAO,IAAI;AACb,WAAO,OAAO;AAAA,EAChB,OAAO;AACL,WAAO,GAAG,OAAO,KAAK;AAAA,EACxB;AACF;;"}

package/dist/cjs/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "commonjs"
+}

package/dist/cjs/refiners/isTypedVariant.js

@@ -0,0 +1,9 @@
+"use strict";
+const isTypedVariant = (variant) => (value) => {
+  if (typeof value !== "object" || value === null) return false;
+  if (!("type" in value)) return false;
+  const obj = value;
+  return obj["type"] === variant;
+};
+exports.isTypedVariant = isTypedVariant;
+//# sourceMappingURL=isTypedVariant.js.map

package/dist/cjs/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,CAAmB,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;;"}

package/dist/cjs/refiners/isTypedVariantOf.js

@@ -0,0 +1,14 @@
+"use strict";
+const isTypedVariantOf = (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;
+};
+exports.isTypedVariantOf = isTypedVariantOf;
+//# sourceMappingURL=isTypedVariantOf.js.map

package/dist/cjs/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,CAAsD,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;;"}

package/dist/cjs/refiners/matchVariant.js

@@ -0,0 +1,57 @@
+"use strict";
+const matchVariant = (value) => {
+  const handlers = [];
+  const withHandler = (variant, fn) => {
+    const newHandlers = [...handlers, { variant, fn }];
+    return {
+      with: (variant2, fn2) => {
+        const newerHandlers = [
+          ...newHandlers,
+          { variant: variant2, fn: fn2 }
+        ];
+        return {
+          with: withHandler,
+          otherwise: (fallback) => ({
+            run: () => {
+              for (const h of newerHandlers) {
+                if (value.type === h.variant) {
+                  const fn3 = h.fn;
+                  return fn3(value);
+                }
+              }
+              return fallback(value);
+            }
+          })
+        };
+      },
+      otherwise: (fallback) => ({
+        run: () => {
+          for (const h of newHandlers) {
+            if (value.type === h.variant) {
+              const fn2 = h.fn;
+              return fn2(value);
+            }
+          }
+          return fallback(value);
+        }
+      })
+    };
+  };
+  const matcher = {
+    with: withHandler,
+    otherwise: (fallback) => ({
+      run: () => {
+        for (const h of handlers) {
+          if (value.type === h.variant) {
+            const fn = h.fn;
+            return fn(value);
+          }
+        }
+        return fallback(value);
+      }
+    })
+  };
+  return matcher;
+};
+exports.matchVariant = matchVariant;
+//# sourceMappingURL=matchVariant.js.map

package/dist/cjs/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,CAC1B,UACwB;AACxB,QAAM,WAAsD,CAAA;AAE5D,QAAM,cAAc,CAClB,SACA,OACwB;AACxB,UAAM,cAAc,CAAC,GAAG,UAAU,EAAE,SAAS,IAAI;AAEjD,WAAO;AAAA,MACL,MAAM,CACJ,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,CAAC,cAAqC;AAAA,YAC/C,KAAK,MAAe;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;AAAA,UAAA;AAAA,QACF;AAAA,MAEJ;AAAA,MACA,WAAW,CAAC,cAAqC;AAAA,QAC/C,KAAK,MAAe;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;AAAA,MAAA;AAAA,IACF;AAAA,EAEJ;AAEA,QAAM,UAA+B;AAAA,IACnC,MAAM;AAAA,IACN,WAAW,CAAC,cAAqC;AAAA,MAC/C,KAAK,MAAe;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;AAAA,IAAA;AAAA,EACF;AAGF,SAAO;AACT;;"}

package/dist/cjs/refiners/matchVariantStrict.js

@@ -0,0 +1,37 @@
+"use strict";
+const matchVariantStrict = (value) => {
+  const handlers = [];
+  const builder = () => ({
+    with: (variant, fn) => {
+      const newHandlers = [...handlers, { variant, fn }];
+      return {
+        with: builder().with,
+        run: (() => {
+          for (const h of newHandlers) {
+            if (value.type === h.variant) {
+              const fn2 = h.fn;
+              return fn2(value);
+            }
+          }
+          throw new Error(
+            `Unmatched variant: ${String(value.type)}`
+          );
+        })
+      };
+    },
+    run: (() => {
+      for (const h of handlers) {
+        if (value.type === h.variant) {
+          const fn = h.fn;
+          return fn(value);
+        }
+      }
+      throw new Error(
+        `Unmatched variant: ${String(value.type)}`
+      );
+    })
+  });
+  return builder();
+};
+exports.matchVariantStrict = matchVariantStrict;
+//# sourceMappingURL=matchVariantStrict.js.map

package/dist/cjs/refiners/matchVariantStrict.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"matchVariantStrict.js","sources":["../../../src/refiners/matchVariantStrict.ts"],"sourcesContent":["import type { Handler, MatchBuilder, VariantOf } from './types/index.js';\n\n/**\n * Создает строгий matcher, выбрасывающий исключение для необработанных вариантов.\n *\n * @typeParam T - Тип дискриминированного объединения.\n * @param value - Значение объединения для сопоставления.\n * @returns Строгий builder сопоставления, требующий явных обработчиков.\n * @throws Error - Выбрасывает исключение, если ни один зарегистрированный обработчик не соответствует `value.type`.\n * @since 0.1.0\n * @see {@link matchVariant} - Использует fallback-ветку вместо выброса исключения.\n * @example\n * ```ts\n * import { matchVariantStrict } from '@resultsafe/core-fp-result';\n *\n * const out = matchVariantStrict<{ type: 'ok'; value: number } | { type: 'err'; error: string }>({\n *   type: 'err',\n *   error: 'boom',\n * })\n *   .with('ok', (v) => `ok:${v.value}`)\n *   .with('err', (v) => `err:${v.error}`)\n *   .run();\n *\n * console.log(out); // err:boom\n * ```\n * @public\n */\nexport const matchVariantStrict = <T extends VariantOf>(\n  value: T,\n): MatchBuilder<T, unknown> => {\n  const handlers: readonly Handler<T['type'], T, unknown>[] = [];\n\n  const builder = <Handled extends T['type'] = never>(): MatchBuilder<\n    T,\n    unknown,\n    Handled\n  > => ({\n    with: <K extends Exclude<T['type'], Handled>>(\n      variant: K,\n      fn: (value: Extract<T, { type: K }>) => unknown,\n    ) => {\n      const newHandlers = [...handlers, { variant, fn }] as const;\n\n      return {\n        with: builder<Handled | K>().with,\n        run: (() => {\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          throw new Error(\n            `Unmatched variant: ${String((value as { type: unknown }).type)}`,\n          );\n        }) as Handled extends T['type'] ? () => unknown : never,\n      } as MatchBuilder<T, unknown, Handled | K>;\n    },\n\n    run: (() => {\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      throw new Error(\n        `Unmatched variant: ${String((value as { type: unknown }).type)}`,\n      );\n    }) as Handled extends T['type'] ? () => unknown : never,\n  });\n\n  return builder();\n};\n"],"names":["fn"],"mappings":";AA2BO,MAAM,qBAAqB,CAChC,UAC6B;AAC7B,QAAM,WAAsD,CAAA;AAE5D,QAAM,UAAU,OAIV;AAAA,IACJ,MAAM,CACJ,SACA,OACG;AACH,YAAM,cAAc,CAAC,GAAG,UAAU,EAAE,SAAS,IAAI;AAEjD,aAAO;AAAA,QACL,MAAM,UAAuB;AAAA,QAC7B,MAAM,MAAM;AACV,qBAAW,KAAK,aAAa;AAC3B,gBAAI,MAAM,SAAS,EAAE,SAAS;AAC5B,oBAAMA,MAAK,EAAE;AACb,qBAAOA,IAAG,KAAK;AAAA,YACjB;AAAA,UACF;AACA,gBAAM,IAAI;AAAA,YACR,sBAAsB,OAAQ,MAA4B,IAAI,CAAC;AAAA,UAAA;AAAA,QAEnE;AAAA,MAAA;AAAA,IAEJ;AAAA,IAEA,MAAM,MAAM;AAEV,iBAAW,KAAK,UAAU;AACxB,YAAI,MAAM,SAAS,EAAE,SAAS;AAC5B,gBAAM,KAAK,EAAE;AACb,iBAAO,GAAG,KAAK;AAAA,QACjB;AAAA,MACF;AAEA,YAAM,IAAI;AAAA,QACR,sBAAsB,OAAQ,MAA4B,IAAI,CAAC;AAAA,MAAA;AAAA,IAEnE;AAAA,EAAA;AAGF,SAAO,QAAA;AACT;;"}

package/dist/cjs/refiners/refineAsyncResult.js

@@ -0,0 +1,26 @@
+"use strict";
+const object = require("../internal/object.js");
+const getPayloadKeys = (config) => {
+  const p = config.payload;
+  if (p === "never") return [];
+  return Array.isArray(p) ? p : [p];
+};
+const refineAsyncResult = (variantMap) => (variant) => (validators) => async (value) => {
+  if (!object.isObject(value)) return null;
+  if (!object.hasOwn(value, "type")) return null;
+  const t = value["type"];
+  if (t !== variant) return null;
+  const config = variantMap[variant];
+  if (!config) return null;
+  const keys = getPayloadKeys(config);
+  for (const key of keys) {
+    const check = validators?.[key];
+    if (!check) continue;
+    const field = value[key];
+    const isValid = await check(field);
+    if (!isValid) return null;
+  }
+  return value;
+};
+exports.refineAsyncResult = refineAsyncResult;
+//# sourceMappingURL=refineAsyncResult.js.map

package/dist/cjs/refiners/refineAsyncResult.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"refineAsyncResult.js","sources":["../../../src/refiners/refineAsyncResult.ts"],"sourcesContent":["import type {\n  AsyncValidatorFn,\n  PayloadKeys,\n  VariantConfig,\n} from '../shared-types.js';\n\nimport { hasOwn, isObject } from '../internal/object.js';\nimport type { UniversalAsyncRefinedResult } from './types/index.js';\n\n/** Resolves payload keys from variant configuration. @internal */\nconst getPayloadKeys = <C extends VariantConfig>(\n  config: C,\n): readonly PayloadKeys<C>[] => {\n  const p = config.payload;\n  if (p === 'never') return [];\n  return (Array.isArray(p) ? p : [p]) as readonly PayloadKeys<C>[];\n};\n\n/**\n * Создает асинхронный refiner варианта с асинхронными валидаторами payload.\n *\n * @typeParam TMap - Тип карты конфигурации вариантов.\n * @param variantMap - Карта, описывающая допустимые варианты и поля payload.\n * @returns A curried async refiner factory bound to `variantMap`.\n * @since 0.1.0\n * @see {@link refineAsyncResultU} - Непосредственный (не-curry) вариант helper.\n * @example\n * ```ts\n * import { refineAsyncResult } from '@resultsafe/core-fp-result';\n *\n * const map = { ok: { payload: 'value' } } as const;\n * const refineOk = refineAsyncResult(map)('ok')({\n *   value: async (x: unknown) => typeof x === 'number',\n * });\n *\n * console.log(await refineOk({ type: 'ok', value: 1 })); // { type: 'ok', value: 1 }\n * ```\n * @public\n */\nexport const refineAsyncResult =\n  <TMap extends Record<string, VariantConfig>>(variantMap: TMap) =>\n  <K extends keyof TMap & string>(variant: K) =>\n  <TValidators extends Partial<Record<PayloadKeys<TMap[K]>, AsyncValidatorFn>>>(\n    validators: TValidators,\n  ) =>\n  async (\n    value: unknown,\n  ): Promise<UniversalAsyncRefinedResult<K, TMap, TValidators> | null> => {\n    if (!isObject(value)) return null;\n    if (!hasOwn(value, 'type')) return null;\n\n    const t = value['type'];\n    if (t !== variant) return null;\n\n    const config = variantMap[variant];\n    if (!config) return null;\n\n    const keys = getPayloadKeys(config);\n    for (const key of keys) {\n      const check = validators?.[key];\n      if (!check) continue;\n\n      const field = value[key as keyof typeof value];\n      const isValid = await check(field); // ✅ Асинхронная валидация\n      if (!isValid) return null;\n    }\n\n    return value as UniversalAsyncRefinedResult<K, TMap, TValidators>;\n  };\n\n/**\n * Уточняет значение асинхронно в не-curry стиле вызова.\n *\n * @typeParam TMap - Тип карты конфигурации вариантов.\n * @typeParam K - Ключ целевого варианта.\n * @typeParam TValidators - Карта асинхронных валидаторов для полей payload.\n * @param value - Значение для валидации и уточнения.\n * @param variant - Ключ целевого варианта.\n * @param variantMap - Карта конфигурации вариантов.\n * @param validators - Асинхронные валидаторы payload.\n * @returns Промис с уточненным значением или `null`.\n * @remarks\n * This export is kept for compatibility. Prefer {@link refineAsyncResultU}\n * from `refineAsyncResultU.ts` как каноническую точку входа без curry.\n * @since 0.1.0\n * @example\n * ```ts\n * import { refineAsyncResultU } from '@resultsafe/core-fp-result/src/refiners/refineAsyncResult.js';\n *\n * const map = { ok: { payload: 'value' } } as const;\n * const out = await refineAsyncResultU({ type: 'ok', value: 1 }, 'ok', map, {\n *   value: async (x: unknown) => typeof x === 'number',\n * });\n *\n * console.log(out?.type); // ok\n * ```\n * @internal\n */\nexport const refineAsyncResultU = <\n  TMap extends Record<string, VariantConfig>,\n  K extends keyof TMap & string,\n  TValidators extends Partial<Record<PayloadKeys<TMap[K]>, AsyncValidatorFn>>,\n>(\n  value: unknown,\n  variant: K,\n  variantMap: TMap,\n  validators: TValidators,\n): Promise<UniversalAsyncRefinedResult<K, TMap, TValidators> | null> =>\n  refineAsyncResult(variantMap)(variant)(validators)(value);\n\r\n\r\n"],"names":["isObject","hasOwn"],"mappings":";;AAUA,MAAM,iBAAiB,CACrB,WAC8B;AAC9B,QAAM,IAAI,OAAO;AACjB,MAAI,MAAM,QAAS,QAAO,CAAA;AAC1B,SAAQ,MAAM,QAAQ,CAAC,IAAI,IAAI,CAAC,CAAC;AACnC;AAuBO,MAAM,oBACX,CAA6C,eAC7C,CAAgC,YAChC,CACE,eAEF,OACE,UACsE;AACtE,MAAI,CAACA,OAAAA,SAAS,KAAK,EAAG,QAAO;AAC7B,MAAI,CAACC,OAAAA,OAAO,OAAO,MAAM,EAAG,QAAO;AAEnC,QAAM,IAAI,MAAM,MAAM;AACtB,MAAI,MAAM,QAAS,QAAO;AAE1B,QAAM,SAAS,WAAW,OAAO;AACjC,MAAI,CAAC,OAAQ,QAAO;AAEpB,QAAM,OAAO,eAAe,MAAM;AAClC,aAAW,OAAO,MAAM;AACtB,UAAM,QAAQ,aAAa,GAAG;AAC9B,QAAI,CAAC,MAAO;AAEZ,UAAM,QAAQ,MAAM,GAAyB;AAC7C,UAAM,UAAU,MAAM,MAAM,KAAK;AACjC,QAAI,CAAC,QAAS,QAAO;AAAA,EACvB;AAEA,SAAO;AACT;;"}

package/dist/cjs/refiners/refineAsyncResultU.js

@@ -0,0 +1,28 @@
+"use strict";
+const object = require("../internal/object.js");
+const getPayloadKeys = (config) => {
+  const p = config.payload;
+  if (p === "never") return [];
+  return Array.isArray(p) ? p : [p];
+};
+const refineAsyncResultU = (value, variant, variantMap, validators) => {
+  return (async () => {
+    if (!object.isObject(value)) return null;
+    if (!object.hasOwn(value, "type")) return null;
+    const t = value["type"];
+    if (t !== variant) return null;
+    const config = variantMap[variant];
+    if (!config) return null;
+    const keys = getPayloadKeys(config);
+    for (const key of keys) {
+      const check = validators[key];
+      if (!check) continue;
+      const field = value[key];
+      const isValid = await check(field);
+      if (!isValid) return null;
+    }
+    return value;
+  })();
+};
+exports.refineAsyncResultU = refineAsyncResultU;
+//# sourceMappingURL=refineAsyncResultU.js.map

package/dist/cjs/refiners/refineAsyncResultU.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"refineAsyncResultU.js","sources":["../../../src/refiners/refineAsyncResultU.ts"],"sourcesContent":["import type {\n  AsyncValidatorFn,\n  PayloadKeys,\n  VariantConfig,\n} from '../shared-types.js';\n\nimport { hasOwn, isObject } from '../internal/object.js';\nimport type { UniversalAsyncRefinedResult } from './types/index.js';\n\n/** Resolves payload keys from variant configuration. @internal */\nconst getPayloadKeys = <C extends VariantConfig>(\n  config: C,\n): readonly PayloadKeys<C>[] => {\n  const p = config.payload;\n  if (p === 'never') return [];\n  return (Array.isArray(p) ? p : [p]) as readonly PayloadKeys<C>[];\n};\n\n/**\n * Уточняет значение асинхронно в не-curry стиле вызова.\n *\n * @typeParam TMap - Тип карты конфигурации вариантов.\n * @typeParam K - Ключ целевого варианта.\n * @typeParam TValidators - Карта асинхронных валидаторов для полей payload.\n * @param value - Значение для валидации и уточнения.\n * @param variant - Ключ целевого варианта.\n * @param variantMap - Карта конфигурации вариантов.\n * @param validators - Асинхронные валидаторы payload.\n * @returns Промис с уточненным значением или `null`.\n * @since 0.1.0\n * @see {@link refineAsyncResult} - Curry-конструктор асинхронного refiner.\n * @example\n * ```ts\n * import { refineAsyncResultU } from '@resultsafe/core-fp-result';\n *\n * const map = { ok: { payload: 'value' } } as const;\n * const out = await refineAsyncResultU({ type: 'ok', value: 1 }, 'ok', map, {\n *   value: async (x: unknown) => typeof x === 'number',\n * });\n *\n * console.log(out?.type); // ok\n * ```\n * @public\n */\nexport const refineAsyncResultU = <\n  TMap extends Record<string, VariantConfig>,\n  K extends keyof TMap & string,\n  TValidators extends Partial<Record<PayloadKeys<TMap[K]>, AsyncValidatorFn>>,\n>(\n  value: unknown,\n  variant: K,\n  variantMap: TMap,\n  validators: TValidators,\n): Promise<UniversalAsyncRefinedResult<K, TMap, TValidators> | null> => {\n  // Императивный стиль с early returns (как в Rust)\n  return (async () => {\n    // Rust-style early returns с Option-like поведением\n    if (!isObject(value)) return null;\n    if (!hasOwn(value, 'type')) return null;\n\n    const t = value['type'];\n    if (t !== variant) return null;\n\n    const config = variantMap[variant];\n    if (!config) return null;\n\n    // Payload validation с асинхронными валидаторами\n    const keys = getPayloadKeys(config);\n    for (const key of keys) {\n      const check = validators[key as keyof TValidators];\n      if (!check) continue;\n\n      const field = value[key as string];\n      // Type-safe async validation\n      const isValid = await (check as AsyncValidatorFn)(field);\n      if (!isValid) return null;\n    }\n\n    // Safe cast после всех проверок\n    return value as UniversalAsyncRefinedResult<K, TMap, TValidators>;\n  })();\n};\n\r\n\r\n"],"names":["isObject","hasOwn"],"mappings":";;AAUA,MAAM,iBAAiB,CACrB,WAC8B;AAC9B,QAAM,IAAI,OAAO;AACjB,MAAI,MAAM,QAAS,QAAO,CAAA;AAC1B,SAAQ,MAAM,QAAQ,CAAC,IAAI,IAAI,CAAC,CAAC;AACnC;AA4BO,MAAM,qBAAqB,CAKhC,OACA,SACA,YACA,eACsE;AAEtE,UAAQ,YAAY;AAElB,QAAI,CAACA,OAAAA,SAAS,KAAK,EAAG,QAAO;AAC7B,QAAI,CAACC,OAAAA,OAAO,OAAO,MAAM,EAAG,QAAO;AAEnC,UAAM,IAAI,MAAM,MAAM;AACtB,QAAI,MAAM,QAAS,QAAO;AAE1B,UAAM,SAAS,WAAW,OAAO;AACjC,QAAI,CAAC,OAAQ,QAAO;AAGpB,UAAM,OAAO,eAAe,MAAM;AAClC,eAAW,OAAO,MAAM;AACtB,YAAM,QAAQ,WAAW,GAAwB;AACjD,UAAI,CAAC,MAAO;AAEZ,YAAM,QAAQ,MAAM,GAAa;AAEjC,YAAM,UAAU,MAAO,MAA2B,KAAK;AACvD,UAAI,CAAC,QAAS,QAAO;AAAA,IACvB;AAGA,WAAO;AAAA,EACT,GAAA;AACF;;"}

package/dist/cjs/refiners/refineResult.js

@@ -0,0 +1,21 @@
+"use strict";
+const object = require("../internal/object.js");
+const getPayloadKeys = require("./utils/getPayloadKeys.js");
+const refineResult = (variantMap) => (variant) => (validators) => (value) => {
+  if (!object.isObject(value)) return null;
+  if (!object.hasOwn(value, "type")) return null;
+  const t = value["type"];
+  if (t !== variant) return null;
+  const config = variantMap[variant];
+  if (!config) return null;
+  const keys = getPayloadKeys.getPayloadKeys(config);
+  for (const key of keys) {
+    const check = validators?.[key];
+    if (!check) continue;
+    const field = value[key];
+    if (!check(field)) return null;
+  }
+  return value;
+};
+exports.refineResult = refineResult;
+//# sourceMappingURL=refineResult.js.map

package/dist/cjs/refiners/refineResult.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"refineResult.js","sources":["../../../src/refiners/refineResult.ts"],"sourcesContent":["import type {\n  PayloadKeys,\n  ValidatorFn,\n  VariantConfig,\n} from '../shared-types.js';\n\nimport { hasOwn, isObject } from '../internal/object.js';\nimport type { UniversalRefinedResult } from './types/index.js';\nimport { getPayloadKeys } from './utils/index.js';\n\n/**\n * Создает синхронный refiner варианта с валидаторами payload.\n *\n * @typeParam TMap - Тип карты конфигурации вариантов.\n * @param variantMap - Карта, описывающая допустимые варианты и поля payload.\n * @returns A curried refiner factory bound to `variantMap`.\n * @since 0.1.0\n * @see {@link refineResultU} - Непосредственный (не-curry) вариант helper.\n * @example\n * ```ts\n * import { refineResult } from '@resultsafe/core-fp-result';\n *\n * const map = { ok: { payload: 'value' } } as const;\n * const refineOk = refineResult(map)('ok')({\n *   value: (x: unknown): x is number => typeof x === 'number',\n * });\n *\n * console.log(refineOk({ type: 'ok', value: 1 })); // { type: 'ok', value: 1 }\n * ```\n * @public\n */\nexport const refineResult =\n  <TMap extends Record<string, VariantConfig>>(variantMap: TMap) =>\n  <K extends keyof TMap & string>(variant: K) =>\n  <TValidators extends Partial<Record<PayloadKeys<TMap[K]>, ValidatorFn>>>(\n    validators: TValidators,\n  ) =>\n  (value: unknown): UniversalRefinedResult<K, TMap, TValidators> | null => {\n    if (!isObject(value)) return null;\n    if (!hasOwn(value, 'type')) return null;\n\n    const t = value['type'];\n    if (t !== variant) return null;\n\n    const config = variantMap[variant];\n    if (!config) return null;\n\n    const keys = getPayloadKeys(config);\n    for (const key of keys) {\n      const check = validators?.[key];\n      if (!check) continue;\n\n      const field = value[key as keyof typeof value];\n      if (!check(field)) return null;\n    }\n\n    return value as UniversalRefinedResult<K, TMap, TValidators>;\n  };\n\n/**\n * Уточняет значение по карте вариантов в не-curry стиле вызова.\n *\n * @typeParam TMap - Тип карты конфигурации вариантов.\n * @typeParam K - Ключ целевого варианта.\n * @typeParam TValidators - Карта валидаторов для полей payload.\n * @param value - Значение для валидации и уточнения.\n * @param variant - Ключ целевого варианта.\n * @param variantMap - Карта конфигурации вариантов.\n * @param validators - Валидаторы payload для целевого варианта.\n * @returns Уточненное значение или `null`.\n * @remarks\n * Этот экспорт сохранен для совместимости. Предпочитайте {@link refineResultU} из\n * `refineResultU.ts` как каноническую точку входа без curry.\n * @since 0.1.0\n * @example\n * ```ts\n * import { refineResultU } from '@resultsafe/core-fp-result/src/refiners/refineResult.js';\n *\n * const map = { ok: { payload: 'value' } } as const;\n * const out = refineResultU({ type: 'ok', value: 1 }, 'ok', map, {\n *   value: (x: unknown): x is number => typeof x === 'number',\n * });\n *\n * console.log(out?.type); // ok\n * ```\n * @internal\n */\nexport const refineResultU = <\n  TMap extends Record<string, VariantConfig>,\n  K extends keyof TMap & string,\n  TValidators extends Partial<Record<PayloadKeys<TMap[K]>, ValidatorFn>>,\n>(\n  value: unknown,\n  variant: K,\n  variantMap: TMap,\n  validators: TValidators,\n): UniversalRefinedResult<K, TMap, TValidators> | null =>\n  refineResult(variantMap)(variant)(validators)(value);\n\r\n\r\n"],"names":["isObject","hasOwn","getPayloadKeys"],"mappings":";;;AA+BO,MAAM,eACX,CAA6C,eAC7C,CAAgC,YAChC,CACE,eAEF,CAAC,UAAwE;AACvE,MAAI,CAACA,OAAAA,SAAS,KAAK,EAAG,QAAO;AAC7B,MAAI,CAACC,OAAAA,OAAO,OAAO,MAAM,EAAG,QAAO;AAEnC,QAAM,IAAI,MAAM,MAAM;AACtB,MAAI,MAAM,QAAS,QAAO;AAE1B,QAAM,SAAS,WAAW,OAAO;AACjC,MAAI,CAAC,OAAQ,QAAO;AAEpB,QAAM,OAAOC,eAAAA,eAAe,MAAM;AAClC,aAAW,OAAO,MAAM;AACtB,UAAM,QAAQ,aAAa,GAAG;AAC9B,QAAI,CAAC,MAAO;AAEZ,UAAM,QAAQ,MAAM,GAAyB;AAC7C,QAAI,CAAC,MAAM,KAAK,EAAG,QAAO;AAAA,EAC5B;AAEA,SAAO;AACT;;"}

package/dist/cjs/refiners/refineResultU.js

@@ -0,0 +1,5 @@
+"use strict";
+const refineResult = require("./refineResult.js");
+const refineResultU = (value, variant, variantMap, validators) => refineResult.refineResult(variantMap)(variant)(validators)(value);
+exports.refineResultU = refineResultU;
+//# sourceMappingURL=refineResultU.js.map

package/dist/cjs/refiners/refineResultU.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"refineResultU.js","sources":["../../../src/refiners/refineResultU.ts"],"sourcesContent":["import type {\n  PayloadKeys,\n  ValidatorFn,\n  VariantConfig,\n} from '../shared-types.js';\n\nimport { refineResult } from './refineResult.js';\nimport type { SyncRefinedResult } from './types/index.js';\n\n/**\n * Уточняет значение по карте вариантов в не-curry стиле вызова.\n *\n * @typeParam TMap - Тип карты конфигурации вариантов.\n * @typeParam K - Ключ целевого варианта.\n * @typeParam TValidators - Карта валидаторов для полей payload.\n * @param value - Значение для валидации и уточнения.\n * @param variant - Ключ целевого варианта.\n * @param variantMap - Карта конфигурации вариантов.\n * @param validators - Валидаторы payload для целевого варианта.\n * @returns Уточненное значение или `null`.\n * @since 0.1.0\n * @see {@link refineResult} - Curry-конструктор refiner.\n * @example\n * ```ts\n * import { refineResultU } from '@resultsafe/core-fp-result';\n *\n * const map = { ok: { payload: 'value' } } as const;\n * const out = refineResultU({ type: 'ok', value: 1 }, 'ok', map, {\n *   value: (x: unknown): x is number => typeof x === 'number',\n * });\n *\n * console.log(out?.type); // ok\n * ```\n * @public\n */\nexport const refineResultU = <\n  TMap extends Record<string, VariantConfig>,\n  K extends keyof TMap & string,\n  TValidators extends Partial<Record<PayloadKeys<TMap[K]>, ValidatorFn>>,\n>(\n  value: unknown,\n  variant: K,\n  variantMap: TMap,\n  validators: TValidators,\n): SyncRefinedResult<K, TMap, TValidators> | null =>\n  refineResult(variantMap)(variant)(validators)(value);\n\r\n\r\n"],"names":["refineResult"],"mappings":";;AAmCO,MAAM,gBAAgB,CAK3B,OACA,SACA,YACA,eAEAA,0BAAa,UAAU,EAAE,OAAO,EAAE,UAAU,EAAE,KAAK;;"}

package/dist/cjs/refiners/refineVariantMap.js

@@ -0,0 +1,25 @@
+"use strict";
+function refineVariantMap(value, variantMap, validators) {
+  if (typeof value !== "object" || value === null || !("type" in value)) {
+    return null;
+  }
+  const rawType = value.type;
+  if (typeof rawType !== "string" || !(rawType in variantMap)) return null;
+  const k = rawType;
+  const config = variantMap[k];
+  if (!config) return null;
+  const payload = config.payload;
+  const keys = payload === "never" ? [] : Array.isArray(payload) ? payload : [payload];
+  const vvs = validators[k];
+  if (vvs) {
+    const obj = value;
+    for (const key of keys) {
+      const check = vvs[key];
+      if (!check) continue;
+      if (!check(obj[key])) return null;
+    }
+  }
+  return value;
+}
+exports.refineVariantMap = refineVariantMap;
+//# sourceMappingURL=refineVariantMap.js.map

package/dist/cjs/refiners/refineVariantMap.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"refineVariantMap.js","sources":["../../../src/refiners/refineVariantMap.ts"],"sourcesContent":["import type {\n  PayloadKeys,\n  ValidatorFn,\n  VariantConfig,\n} from '../shared-types.js';\n\nimport type { SyncRefinedResultUnion } from './types/SyncRefinedResultUnion.js';\nimport type { SyncValidatorMap } from './types/SyncValidatorMap.js';\n\n/**\n * Уточняет значение дискриминированного объединения по полной карте вариантов.\n *\n * @typeParam TMap - Тип карты конфигурации вариантов.\n * @typeParam TValidators - Тип карты валидаторов по вариантам.\n * @param value - Значение для валидации и уточнения.\n * @param variantMap - Полная карта конфигурации вариантов.\n * @param validators - Валидаторы, сгруппированные по ключу варианта.\n * @returns Уточненный элемент объединения или `null`.\n * @since 0.1.0\n * @see {@link refineResult} - Refines one concrete variant key.\n * @example\n * ```ts\n * import { refineVariantMap } from '@resultsafe/core-fp-result';\n *\n * const map = {\n *   created: { payload: 'id' },\n *   failed: { payload: 'reason' },\n * } as const;\n *\n * const out = refineVariantMap({ type: 'created', id: '1' }, map, {\n *   created: { id: (x: unknown): x is string => typeof x === 'string' },\n *   failed: { reason: (x: unknown): x is string => typeof x === 'string' },\n * });\n *\n * console.log(out?.type); // created\n * ```\n * @public\n */\nexport function refineVariantMap<\n  TMap extends Record<string, VariantConfig>,\n  TValidators extends SyncValidatorMap<TMap>,\n>(\n  value: unknown,\n  variantMap: TMap,\n  validators: TValidators,\n): SyncRefinedResultUnion<TMap, TValidators> | null {\n  if (typeof value !== 'object' || value === null || !('type' in value)) {\n    return null;\n  }\n\n  const rawType = (value as { type?: unknown }).type;\n  if (typeof rawType !== 'string' || !(rawType in variantMap)) return null;\n\n  // фиксируем конкретный ключ варианта\n  type K = Extract<keyof TMap, string>;\n  const k = rawType as K;\n\n  const config = variantMap[k];\n  if (!config) return null;\n\n  // ключи payload для конкретного K\n  const payload = config.payload;\n  const keys = (\n    payload === 'never' ? [] : Array.isArray(payload) ? payload : [payload]\n  ) as readonly PayloadKeys<TMap[typeof k]>[];\n\n  // валидаторы, согласованные с конкретным K\n  const vvs = validators[k] as\n    | Partial<Record<PayloadKeys<TMap[typeof k]>, ValidatorFn>>\n    | undefined;\n\n  if (vvs) {\n    const obj = value as Record<string, unknown>;\n    for (const key of keys) {\n      const check = vvs[key];\n      if (!check) continue;\n      if (!check(obj[key as string])) return null;\n    }\n  }\n\n  return value as SyncRefinedResultUnion<TMap, TValidators>;\n}\n\r\n\r\n"],"names":[],"mappings":";AAsCO,SAAS,iBAId,OACA,YACA,YACkD;AAClD,MAAI,OAAO,UAAU,YAAY,UAAU,QAAQ,EAAE,UAAU,QAAQ;AACrE,WAAO;AAAA,EACT;AAEA,QAAM,UAAW,MAA6B;AAC9C,MAAI,OAAO,YAAY,YAAY,EAAE,WAAW,YAAa,QAAO;AAIpE,QAAM,IAAI;AAEV,QAAM,SAAS,WAAW,CAAC;AAC3B,MAAI,CAAC,OAAQ,QAAO;AAGpB,QAAM,UAAU,OAAO;AACvB,QAAM,OACJ,YAAY,UAAU,KAAK,MAAM,QAAQ,OAAO,IAAI,UAAU,CAAC,OAAO;AAIxE,QAAM,MAAM,WAAW,CAAC;AAIxB,MAAI,KAAK;AACP,UAAM,MAAM;AACZ,eAAW,OAAO,MAAM;AACtB,YAAM,QAAQ,IAAI,GAAG;AACrB,UAAI,CAAC,MAAO;AACZ,UAAI,CAAC,MAAM,IAAI,GAAa,CAAC,EAAG,QAAO;AAAA,IACzC;AAAA,EACF;AAEA,SAAO;AACT;;"}

package/dist/cjs/refiners/utils/getPayloadKeys.js

@@ -0,0 +1,8 @@
+"use strict";
+const getPayloadKeys = (config) => {
+  const p = config.payload;
+  if (p === "never") return [];
+  return Array.isArray(p) ? p : [p];
+};
+exports.getPayloadKeys = getPayloadKeys;
+//# sourceMappingURL=getPayloadKeys.js.map

package/dist/cjs/refiners/utils/getPayloadKeys.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"getPayloadKeys.js","sources":["../../../../src/refiners/utils/getPayloadKeys.ts"],"sourcesContent":["import type {\n  PayloadKeys,\n  VariantConfig,\n} from '../../shared-types.js';\n\n/**\n * Нормализует конфигурацию payload варианта в список ключей.\n *\n * @typeParam C - Тип конфигурации варианта.\n * @param config - Конфигурация варианта с определением payload.\n * @returns Ключи payload как readonly-массив.\n * @since 0.1.0\n * @example\n * ```ts\n * import { getPayloadKeys } from '@resultsafe/core-fp-result/src/refiners/utils/getPayloadKeys.js';\n *\n * const keys = getPayloadKeys({ payload: ['id', 'meta'] } as const);\n * console.log(keys.length); // 2\n * ```\n * @internal\n */\nexport const getPayloadKeys = <C extends VariantConfig>(\n  config: C,\n): readonly PayloadKeys<C>[] => {\n  const p = config.payload;\n  if (p === 'never') return [];\n  return (Array.isArray(p) ? p : [p]) as readonly PayloadKeys<C>[];\n};\n\r\n\r\n"],"names":[],"mappings":";AAqBO,MAAM,iBAAiB,CAC5B,WAC8B;AAC9B,QAAM,IAAI,OAAO;AACjB,MAAI,MAAM,QAAS,QAAO,CAAA;AAC1B,SAAQ,MAAM,QAAQ,CAAC,IAAI,IAAI,CAAC,CAAC;AACnC;;"}

package/dist/docs/api/README.md

@@ -0,0 +1,9 @@
+# API
+
+> [Back to package README](../../README.md)
+
+Содержание по модулям:
+- [Конструкторы](./constructors/index.md)
+- [Гарды](./guards/index.md)
+- [Методы](./methods/index.md)
+- [Рефайнеры](./refiners/index.md)

package/dist/docs/api/constructors/Err.md

@@ -0,0 +1,58 @@
+> [Back to package README](../../../README.md) | [Back to API index](../index.md) | [Back to module](./index.md)
+
+[**@resultsafe/core-fp-result v0.1.0**](../README.md)
+
+***
+
+[@resultsafe/core-fp-result](../README.md) / Err
+
+# Функция: Err()
+
+> **Err**\<`E`, `T`\>(`error`): `Result`\<`T`, `E`\>
+
+Создает ошибочное значение `Result` из переданного payload ошибки.
+
+## Параметры типа
+
+### E
+
+`E`
+
+Тип значения ошибки.
+
+### T
+
+`T` = `never`
+
+The success type for the resulting `Result`.
+
+## Параметры
+
+### error
+
+`E`
+
+Payload ошибки для обёртки.
+
+## Возвращает
+
+`Result`\<`T`, `E`\>
+
+A `Result` with `ok: false` and the provided `error`.
+
+## Начиная с версии
+
+0.1.0
+
+## См. также
+
+[Ok](./Ok.md) - Creates a successful `Result`.
+
+## Пример
+
+```ts
+import { Err } from '@resultsafe/core-fp-result';
+
+const result = Err<string, number>('boom');
+console.log(result.ok); // false
+```

package/dist/docs/api/constructors/Ok.md

@@ -0,0 +1,58 @@
+> [Back to package README](../../../README.md) | [Back to API index](../index.md) | [Back to module](./index.md)
+
+[**@resultsafe/core-fp-result v0.1.0**](../README.md)
+
+***
+
+[@resultsafe/core-fp-result](../README.md) / Ok
+
+# Функция: Ok()
+
+> **Ok**\<`T`, `E`\>(`value`): `Result`\<`T`, `E`\>
+
+Создает успешное значение `Result` из переданного payload.
+
+## Параметры типа
+
+### T
+
+`T`
+
+Тип успешного значения.
+
+### E
+
+`E` = `never`
+
+The error type for the resulting `Result`.
+
+## Параметры
+
+### value
+
+`T`
+
+Payload успеха для обёртки.
+
+## Возвращает
+
+`Result`\<`T`, `E`\>
+
+A `Result` with `ok: true` and the provided `value`.
+
+## Начиная с версии
+
+0.1.0
+
+## См. также
+
+[Err](./Err.md) - Creates an error `Result`.
+
+## Пример
+
+```ts
+import { Ok } from '@resultsafe/core-fp-result';
+
+const result = Ok<number, string>(42);
+console.log(result.ok); // true
+```

package/dist/docs/api/constructors/index.md

@@ -0,0 +1,7 @@
+# Конструкторы
+
+> [Back to package README](../../../README.md) | [Back to API index](../index.md)
+
+Символы модуля:
+- [Err](./Err.md)
+- [Ok](./Ok.md)

package/dist/docs/api/guards/index.md

@@ -0,0 +1,9 @@
+# Гарды
+
+> [Back to package README](../../../README.md) | [Back to API index](../index.md)
+
+Символы модуля:
+- [isErr](./isErr.md)
+- [isErrAnd](./isErrAnd.md)
+- [isOk](./isOk.md)
+- [isOkAnd](./isOkAnd.md)