@resultsafe/core-fp-result 0.1.0

package/dist/esm/refiners/matchVariantStrict.js

@@ -0,0 +1,40 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+const matchVariantStrict = /* @__PURE__ */ __name((value) => {
+  const handlers = [];
+  const builder = /* @__PURE__ */ __name(() => ({
+    with: /* @__PURE__ */ __name((variant, fn) => {
+      const newHandlers = [...handlers, { variant, fn }];
+      return {
+        with: builder().with,
+        run: /* @__PURE__ */ __name((() => {
+          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")
+      };
+    }, "with"),
+    run: /* @__PURE__ */ __name((() => {
+      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)}`
+      );
+    }), "run")
+  }), "builder");
+  return builder();
+}, "matchVariantStrict");
+export {
+  matchVariantStrict
+};
+//# sourceMappingURL=matchVariantStrict.js.map

package/dist/esm/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,wBAChC,UAC6B;AAC7B,QAAM,WAAsD,CAAA;AAE5D,QAAM,UAAU,8BAIV;AAAA,IACJ,MAAM,wBACJ,SACA,OACG;AACH,YAAM,cAAc,CAAC,GAAG,UAAU,EAAE,SAAS,IAAI;AAEjD,aAAO;AAAA,QACL,MAAM,UAAuB;AAAA,QAC7B,KAAM,8BAAM;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,IAVM;AAAA,MAUN;AAAA,IAEJ,GApBM;AAAA,IAsBN,KAAM,8BAAM;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,IAZM;AAAA,EAYN,IAvCc;AA0ChB,SAAO,QAAA;AACT,GAhDkC;"}

package/dist/esm/refiners/refineAsyncResult.js

@@ -0,0 +1,29 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+import { isObject, hasOwn } from "../internal/object.js";
+const getPayloadKeys = /* @__PURE__ */ __name((config) => {
+  const p = config.payload;
+  if (p === "never") return [];
+  return Array.isArray(p) ? p : [p];
+}, "getPayloadKeys");
+const refineAsyncResult = /* @__PURE__ */ __name((variantMap) => (variant) => (validators) => async (value) => {
+  if (!isObject(value)) return null;
+  if (!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;
+}, "refineAsyncResult");
+export {
+  refineAsyncResult
+};
+//# sourceMappingURL=refineAsyncResult.js.map

package/dist/esm/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":[],"mappings":";;;AAUA,MAAM,iBAAiB,wBACrB,WAC8B;AAC9B,QAAM,IAAI,OAAO;AACjB,MAAI,MAAM,QAAS,QAAO,CAAA;AAC1B,SAAQ,MAAM,QAAQ,CAAC,IAAI,IAAI,CAAC,CAAC;AACnC,GANuB;AA6BhB,MAAM,oBACX,wBAA6C,eAC7C,CAAgC,YAChC,CACE,eAEF,OACE,UACsE;AACtE,MAAI,CAAC,SAAS,KAAK,EAAG,QAAO;AAC7B,MAAI,CAAC,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,GA5BA;"}

package/dist/esm/refiners/refineAsyncResultU.js

@@ -0,0 +1,31 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+import { isObject, hasOwn } from "../internal/object.js";
+const getPayloadKeys = /* @__PURE__ */ __name((config) => {
+  const p = config.payload;
+  if (p === "never") return [];
+  return Array.isArray(p) ? p : [p];
+}, "getPayloadKeys");
+const refineAsyncResultU = /* @__PURE__ */ __name((value, variant, variantMap, validators) => {
+  return (async () => {
+    if (!isObject(value)) return null;
+    if (!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;
+  })();
+}, "refineAsyncResultU");
+export {
+  refineAsyncResultU
+};
+//# sourceMappingURL=refineAsyncResultU.js.map

package/dist/esm/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":[],"mappings":";;;AAUA,MAAM,iBAAiB,wBACrB,WAC8B;AAC9B,QAAM,IAAI,OAAO;AACjB,MAAI,MAAM,QAAS,QAAO,CAAA;AAC1B,SAAQ,MAAM,QAAQ,CAAC,IAAI,IAAI,CAAC,CAAC;AACnC,GANuB;AAkChB,MAAM,qBAAqB,wBAKhC,OACA,SACA,YACA,eACsE;AAEtE,UAAQ,YAAY;AAElB,QAAI,CAAC,SAAS,KAAK,EAAG,QAAO;AAC7B,QAAI,CAAC,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,GArCkC;"}

package/dist/esm/refiners/refineResult.js

@@ -0,0 +1,24 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+import { isObject, hasOwn } from "../internal/object.js";
+import { getPayloadKeys } from "./utils/getPayloadKeys.js";
+const refineResult = /* @__PURE__ */ __name((variantMap) => (variant) => (validators) => (value) => {
+  if (!isObject(value)) return null;
+  if (!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];
+    if (!check(field)) return null;
+  }
+  return value;
+}, "refineResult");
+export {
+  refineResult
+};
+//# sourceMappingURL=refineResult.js.map

package/dist/esm/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":[],"mappings":";;;;AA+BO,MAAM,eACX,wBAA6C,eAC7C,CAAgC,YAChC,CACE,eAEF,CAAC,UAAwE;AACvE,MAAI,CAAC,SAAS,KAAK,EAAG,QAAO;AAC7B,MAAI,CAAC,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,QAAI,CAAC,MAAM,KAAK,EAAG,QAAO;AAAA,EAC5B;AAEA,SAAO;AACT,GAzBA;"}

package/dist/esm/refiners/refineResultU.js

@@ -0,0 +1,8 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+import { refineResult } from "./refineResult.js";
+const refineResultU = /* @__PURE__ */ __name((value, variant, variantMap, validators) => refineResult(variantMap)(variant)(validators)(value), "refineResultU");
+export {
+  refineResultU
+};
+//# sourceMappingURL=refineResultU.js.map

package/dist/esm/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":[],"mappings":";;;AAmCO,MAAM,gBAAgB,wBAK3B,OACA,SACA,YACA,eAEA,aAAa,UAAU,EAAE,OAAO,EAAE,UAAU,EAAE,KAAK,GAVxB;"}

package/dist/esm/refiners/refineVariantMap.js

@@ -0,0 +1,29 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+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;
+}
+__name(refineVariantMap, "refineVariantMap");
+export {
+  refineVariantMap
+};
+//# sourceMappingURL=refineVariantMap.js.map

package/dist/esm/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;AA3CgB;"}

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

@@ -0,0 +1,11 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+const getPayloadKeys = /* @__PURE__ */ __name((config) => {
+  const p = config.payload;
+  if (p === "never") return [];
+  return Array.isArray(p) ? p : [p];
+}, "getPayloadKeys");
+export {
+  getPayloadKeys
+};
+//# sourceMappingURL=getPayloadKeys.js.map

package/dist/esm/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,wBAC5B,WAC8B;AAC9B,QAAM,IAAI,OAAO;AACjB,MAAI,MAAM,QAAS,QAAO,CAAA;AAC1B,SAAQ,MAAM,QAAQ,CAAC,IAAI,IAAI,CAAC,CAAC;AACnC,GAN8B;"}

package/dist/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "@resultsafe/core-fp-result",
+  "version": "0.1.0",
+  "type": "module",
+  "sideEffects": false,
+  "main": "./cjs/index.js",
+  "module": "./esm/index.js",
+  "browser": "./umd/resultsafe-monorepo-core-fp-result.umd.js",
+  "types": "./types/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./types/index.d.ts",
+      "import": "./esm/index.js",
+      "require": "./cjs/index.js"
+    },
+    "./Ok": {
+      "types": "./types/constructors/Ok.d.ts",
+      "import": "./esm/constructors/Ok.js",
+      "require": "./cjs/constructors/Ok.js"
+    },
+    "./Err": {
+      "types": "./types/constructors/Err.d.ts",
+      "import": "./esm/constructors/Err.js",
+      "require": "./cjs/constructors/Err.js"
+    }
+  },
+  "files": [
+    "cjs",
+    "esm",
+    "types",
+    "umd",
+    "docs",
+    "README.md",
+    "LICENSE"
+  ]
+}

package/dist/types/constructors/Err.d.ts

@@ -0,0 +1,21 @@
+import type { Result } from '../shared-types.js';
+/**
+ * Создает ошибочное значение `Result` из переданного payload ошибки.
+ *
+ * @typeParam E - Тип значения ошибки.
+ * @typeParam T - The success type for the resulting `Result`.
+ * @param error - Payload ошибки для обёртки.
+ * @returns A `Result` with `ok: false` and the provided `error`.
+ * @since 0.1.0
+ * @see {@link Ok} - Creates a successful `Result`.
+ * @example
+ * ```ts
+ * import { Err } from '@resultsafe/core-fp-result';
+ *
+ * const result = Err<string, number>('boom');
+ * console.log(result.ok); // false
+ * ```
+ * @public
+ */
+export declare const Err: <E, T = never>(error: E) => Result<T, E>;
+//# sourceMappingURL=Err.d.ts.map

package/dist/types/constructors/Err.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Err.d.ts","sourceRoot":"","sources":["../../../src/constructors/Err.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,oBAAoB,CAAC;AAEjD;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,GAAG,GAAI,CAAC,EAAE,CAAC,GAAG,KAAK,EAAE,OAAO,CAAC,KAAG,MAAM,CAAC,CAAC,EAAE,CAAC,CACvB,CAAC"}

package/dist/types/constructors/Ok.d.ts

@@ -0,0 +1,21 @@
+import type { Result } from '../shared-types.js';
+/**
+ * Создает успешное значение `Result` из переданного payload.
+ *
+ * @typeParam T - Тип успешного значения.
+ * @typeParam E - The error type for the resulting `Result`.
+ * @param value - Payload успеха для обёртки.
+ * @returns A `Result` with `ok: true` and the provided `value`.
+ * @since 0.1.0
+ * @see {@link Err} - Creates an error `Result`.
+ * @example
+ * ```ts
+ * import { Ok } from '@resultsafe/core-fp-result';
+ *
+ * const result = Ok<number, string>(42);
+ * console.log(result.ok); // true
+ * ```
+ * @public
+ */
+export declare const Ok: <T, E = never>(value: T) => Result<T, E>;
+//# sourceMappingURL=Ok.d.ts.map

package/dist/types/constructors/Ok.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Ok.d.ts","sourceRoot":"","sources":["../../../src/constructors/Ok.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,oBAAoB,CAAC;AAEjD;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,EAAE,GAAI,CAAC,EAAE,CAAC,GAAG,KAAK,EAAE,OAAO,CAAC,KAAG,MAAM,CAAC,CAAC,EAAE,CAAC,CACvB,CAAC"}

package/dist/types/constructors/index.d.ts

@@ -0,0 +1,3 @@
+export { Err } from './Err.js';
+export { Ok } from './Ok.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/types/constructors/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/constructors/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,GAAG,EAAE,MAAM,UAAU,CAAC;AAC/B,OAAO,EAAE,EAAE,EAAE,MAAM,SAAS,CAAC"}

package/dist/types/guards/index.d.ts

@@ -0,0 +1,5 @@
+export { isErr } from './isErr.js';
+export { isErrAnd } from './isErrAnd.js';
+export { isOk } from './isOk.js';
+export { isOkAnd } from './isOkAnd.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/types/guards/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/guards/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AACnC,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AACzC,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AACjC,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC"}

package/dist/types/guards/isErr.d.ts

@@ -0,0 +1,24 @@
+import type { Result } from '../shared-types.js';
+/**
+ * Проверяет, находится ли `Result` в ветке ошибки.
+ *
+ * @typeParam T - Тип успешного значения.
+ * @typeParam E - Тип значения ошибки.
+ * @param result - `Result` для проверки.
+ * @returns `true` when `result.ok` equals `false`.
+ * @since 0.1.0
+ * @see {@link isOk} - Checks the success branch.
+ * @example
+ * ```ts
+ * import { Err, isErr } from '@resultsafe/core-fp-result';
+ *
+ * const result = Err('boom');
+ * console.log(isErr(result)); // true
+ * ```
+ * @public
+ */
+export declare const isErr: <T, E>(result: Result<T, E>) => result is {
+    ok: false;
+    error: E;
+};
+//# sourceMappingURL=isErr.d.ts.map

package/dist/types/guards/isErr.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"isErr.d.ts","sourceRoot":"","sources":["../../../src/guards/isErr.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,oBAAoB,CAAC;AAEjD;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,KAAK,GAAI,CAAC,EAAE,CAAC,EACxB,QAAQ,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,KACnB,MAAM,IAAI;IAAE,EAAE,EAAE,KAAK,CAAC;IAAC,KAAK,EAAE,CAAC,CAAA;CAAyB,CAAC"}

package/dist/types/guards/isErrAnd.d.ts

@@ -0,0 +1,22 @@
+import { type Result } from '../shared-types.js';
+/**
+ * Проверяет, что `Result` завершился ошибкой и удовлетворяет предикату.
+ *
+ * @typeParam T - Тип успешного значения.
+ * @typeParam E - Тип значения ошибки.
+ * @param result - `Result` для проверки.
+ * @param predicate - Предикат, применяемый к значению ошибки.
+ * @returns `true` when the value is `Err` and the predicate returns `true`.
+ * @since 0.1.0
+ * @see {@link isErr} - Performs the base error check.
+ * @example
+ * ```ts
+ * import { Err, isErrAnd } from '@resultsafe/core-fp-result';
+ *
+ * const result = Err({ code: 503 });
+ * console.log(isErrAnd(result, (error) => error.code >= 500)); // true
+ * ```
+ * @public
+ */
+export declare const isErrAnd: <T, E>(result: Result<T, E>, predicate: (error: E) => boolean) => boolean;
+//# sourceMappingURL=isErrAnd.d.ts.map

package/dist/types/guards/isErrAnd.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"isErrAnd.d.ts","sourceRoot":"","sources":["../../../src/guards/isErrAnd.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,MAAM,EAAE,MAAM,oBAAoB,CAAC;AAIjD;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,QAAQ,GAAI,CAAC,EAAE,CAAC,EAC3B,QAAQ,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,EACpB,WAAW,CAAC,KAAK,EAAE,CAAC,KAAK,OAAO,KAC/B,OAAmD,CAAC"}

package/dist/types/guards/isOk.d.ts

@@ -0,0 +1,24 @@
+import type { Result } from '../shared-types.js';
+/**
+ * Проверяет, находится ли `Result` в ветке успеха.
+ *
+ * @typeParam T - Тип успешного значения.
+ * @typeParam E - Тип значения ошибки.
+ * @param result - `Result` для проверки.
+ * @returns `true` when `result.ok` equals `true`.
+ * @since 0.1.0
+ * @see {@link isErr} - Checks the error branch.
+ * @example
+ * ```ts
+ * import { Ok, isOk } from '@resultsafe/core-fp-result';
+ *
+ * const result = Ok(10);
+ * console.log(isOk(result)); // true
+ * ```
+ * @public
+ */
+export declare const isOk: <T, E>(result: Result<T, E>) => result is {
+    ok: true;
+    value: T;
+};
+//# sourceMappingURL=isOk.d.ts.map

package/dist/types/guards/isOk.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"isOk.d.ts","sourceRoot":"","sources":["../../../src/guards/isOk.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,oBAAoB,CAAC;AAEjD;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,IAAI,GAAI,CAAC,EAAE,CAAC,EACvB,QAAQ,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,KACnB,MAAM,IAAI;IAAE,EAAE,EAAE,IAAI,CAAC;IAAC,KAAK,EAAE,CAAC,CAAA;CAAwB,CAAC"}

package/dist/types/guards/isOkAnd.d.ts

@@ -0,0 +1,22 @@
+import { type Result } from '../shared-types.js';
+/**
+ * Проверяет, что `Result` успешен и удовлетворяет предикату.
+ *
+ * @typeParam T - Тип успешного значения.
+ * @typeParam E - Тип значения ошибки.
+ * @param result - `Result` для проверки.
+ * @param predicate - Предикат, применяемый к успешному значению.
+ * @returns `true` when the value is `Ok` and the predicate returns `true`.
+ * @since 0.1.0
+ * @see {@link isOk} - Performs the base success check.
+ * @example
+ * ```ts
+ * import { Ok, isOkAnd } from '@resultsafe/core-fp-result';
+ *
+ * const result = Ok(8);
+ * console.log(isOkAnd(result, (value) => value % 2 === 0)); // true
+ * ```
+ * @public
+ */
+export declare const isOkAnd: <T, E>(result: Result<T, E>, predicate: (value: T) => boolean) => boolean;
+//# sourceMappingURL=isOkAnd.d.ts.map

package/dist/types/guards/isOkAnd.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"isOkAnd.d.ts","sourceRoot":"","sources":["../../../src/guards/isOkAnd.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,MAAM,EAAE,MAAM,oBAAoB,CAAC;AAIjD;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,OAAO,GAAI,CAAC,EAAE,CAAC,EAC1B,QAAQ,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,EACpB,WAAW,CAAC,KAAK,EAAE,CAAC,KAAK,OAAO,KAC/B,OAAkD,CAAC"}

package/dist/types/index.d.ts

@@ -0,0 +1,5 @@
+export * from './constructors/index.js';
+export * from './guards/index.js';
+export * from './methods/index.js';
+export * from './refiners/index.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/types/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,yBAAyB,CAAC;AACxC,cAAc,mBAAmB,CAAC;AAClC,cAAc,oBAAoB,CAAC;AACnC,cAAc,qBAAqB,CAAC"}

package/dist/types/internal/object.d.ts

@@ -0,0 +1,5 @@
+/** Checks that an object owns a property key. @internal */
+export declare const hasOwn: <K extends PropertyKey>(obj: Record<string, unknown>, key: K) => obj is Record<K, unknown>;
+/** Checks that a value is a non-null object record. @internal */
+export declare const isObject: (value: unknown) => value is Record<string, unknown>;
+//# sourceMappingURL=object.d.ts.map

package/dist/types/internal/object.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"object.d.ts","sourceRoot":"","sources":["../../../src/internal/object.ts"],"names":[],"mappings":"AAAA,2DAA2D;AAC3D,eAAO,MAAM,MAAM,GAAI,CAAC,SAAS,WAAW,EAC1C,KAAK,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC5B,KAAK,CAAC,KACL,GAAG,IAAI,MAAM,CAAC,CAAC,EAAE,OAAO,CAAmD,CAAC;AAE/E,iEAAiE;AACjE,eAAO,MAAM,QAAQ,GAAI,OAAO,OAAO,KAAG,KAAK,IAAI,MAAM,CAAC,MAAM,EAAE,OAAO,CAC5B,CAAC"}

package/dist/types/internal/option.d.ts

@@ -0,0 +1,10 @@
+/** Represents an empty internal option value. @internal */
+export declare const None: {
+    readonly some: false;
+};
+/** Wraps an internal option value as present. @internal */
+export declare const Some: <T>(value: T) => {
+    readonly some: true;
+    readonly value: T;
+};
+//# sourceMappingURL=option.d.ts.map

package/dist/types/internal/option.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"option.d.ts","sourceRoot":"","sources":["../../../src/internal/option.ts"],"names":[],"mappings":"AAAA,2DAA2D;AAC3D,eAAO,MAAM,IAAI;;CAA2B,CAAC;AAE7C,2DAA2D;AAC3D,eAAO,MAAM,IAAI,GAAI,CAAC,EAAE,OAAO,CAAC;;;CAAqC,CAAC"}

package/dist/types/methods/andThen.d.ts

@@ -0,0 +1,26 @@
+import { type Result } from '../shared-types.js';
+/**
+ * Цепляет вычисление, которое возвращает другой `Result`.
+ *
+ * @typeParam T - The input success type.
+ * @typeParam U - The output success type.
+ * @typeParam E - Общий тип ошибки.
+ * @param result - Исходный `Result`.
+ * @param fn - Функция, применяемая, когда `result` имеет `Ok`.
+ * @returns Преобразованный `Result` или исходный `Err`.
+ * @since 0.1.0
+ * @see {@link map} - Преобразует только успешное значение.
+ * @example
+ * ```ts
+ * import { Ok, Err, andThen } from '@resultsafe/core-fp-result';
+ *
+ * const parsed = andThen(Ok('12'), (value) => {
+ *   const n = Number(value);
+ *   return Number.isNaN(n) ? Err('invalid') : Ok(n);
+ * });
+ * console.log(parsed.ok); // true
+ * ```
+ * @public
+ */
+export declare const andThen: <T, U, E>(result: Result<T, E>, fn: (value: T) => Result<U, E>) => Result<U, E>;
+//# sourceMappingURL=andThen.d.ts.map

package/dist/types/methods/andThen.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"andThen.d.ts","sourceRoot":"","sources":["../../../src/methods/andThen.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,MAAM,EAAE,MAAM,oBAAoB,CAAC;AAIjD;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,eAAO,MAAM,OAAO,GAAI,CAAC,EAAE,CAAC,EAAE,CAAC,EAC7B,QAAQ,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,EACpB,IAAI,CAAC,KAAK,EAAE,CAAC,KAAK,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,KAC7B,MAAM,CAAC,CAAC,EAAE,CAAC,CAAiE,CAAC"}

package/dist/types/methods/err.d.ts

@@ -0,0 +1,22 @@
+import { type Option } from '../shared-types.js';
+import { type Result } from '../shared-types.js';
+/**
+ * Извлекает ветку ошибки в виде `Option`.
+ *
+ * @typeParam T - Тип успешного значения.
+ * @typeParam E - Тип значения ошибки.
+ * @param result - Исходный `Result`.
+ * @returns `Some(error)` для `Err`, иначе `None`.
+ * @since 0.1.0
+ * @see {@link ok} - Извлекает ветку успеха.
+ * @example
+ * ```ts
+ * import { Err, err } from '@resultsafe/core-fp-result';
+ *
+ * const value = err(Err('boom'));
+ * console.log(value.some); // true
+ * ```
+ * @public
+ */
+export declare const err: <T, E>(result: Result<T, E>) => Option<E>;
+//# sourceMappingURL=err.d.ts.map

package/dist/types/methods/err.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"err.d.ts","sourceRoot":"","sources":["../../../src/methods/err.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,MAAM,EAAE,MAAM,oBAAoB,CAAC;AACjD,OAAO,EAAE,KAAK,MAAM,EAAE,MAAM,oBAAoB,CAAC;AAKjD;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,GAAG,GAAI,CAAC,EAAE,CAAC,EAAE,QAAQ,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,KAAG,MAAM,CAAC,CAAC,CACd,CAAC"}

package/dist/types/methods/expect.d.ts

@@ -0,0 +1,23 @@
+import { type Result } from '../shared-types.js';
+/**
+ * Возвращает успешное значение или выбрасывает исключение с пользовательским сообщением.
+ *
+ * @typeParam T - Тип успешного значения.
+ * @typeParam E - Тип значения ошибки.
+ * @param result - Исходный `Result`.
+ * @param msg - Сообщение об ошибке, используемое когда `result` имеет `Err`.
+ * @returns Распакованное успешное значение.
+ * @throws Error - Выбрасывает исключение, когда `result` имеет `Err`.
+ * @since 0.1.0
+ * @see {@link expectErr} - Симметричный helper для ветки ошибки.
+ * @example
+ * ```ts
+ * import { Ok, expect } from '@resultsafe/core-fp-result';
+ *
+ * const value = expect(Ok(5), 'must be ok');
+ * console.log(value); // 5
+ * ```
+ * @public
+ */
+export declare const expect: <T, E>(result: Result<T, E>, msg: string) => T;
+//# sourceMappingURL=expect.d.ts.map

package/dist/types/methods/expect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"expect.d.ts","sourceRoot":"","sources":["../../../src/methods/expect.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,MAAM,EAAE,MAAM,oBAAoB,CAAC;AAIjD;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,MAAM,GAAI,CAAC,EAAE,CAAC,EAAE,QAAQ,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,KAAK,MAAM,KAAG,CAKhE,CAAC"}

package/dist/types/methods/expectErr.d.ts

@@ -0,0 +1,23 @@
+import { type Result } from '../shared-types.js';
+/**
+ * Возвращает значение ошибки или выбрасывает исключение с пользовательским сообщением.
+ *
+ * @typeParam T - Тип успешного значения.
+ * @typeParam E - Тип значения ошибки.
+ * @param result - Исходный `Result`.
+ * @param msg - Сообщение об ошибке, используемое когда `result` имеет `Ok`.
+ * @returns Распакованное значение ошибки.
+ * @throws Error - Выбрасывает исключение, когда `result` имеет `Ok`.
+ * @since 0.1.0
+ * @see {@link expect} - Симметричный helper для ветки успеха.
+ * @example
+ * ```ts
+ * import { Err, expectErr } from '@resultsafe/core-fp-result';
+ *
+ * const error = expectErr(Err('boom'), 'must be err');
+ * console.log(error); // boom
+ * ```
+ * @public
+ */
+export declare const expectErr: <T, E>(result: Result<T, E>, msg: string) => E;
+//# sourceMappingURL=expectErr.d.ts.map