modern-ts 0.8.0

package/dist/subpath/ReaderT.mjs

@@ -0,0 +1,148 @@
+import { O as o, E as u } from "../chunks/base-K-RHLZ-S.mjs";
+import { m as v, a as i, b as x, c as T, d as h, e as O, f as d, g, h as M, i as P } from "../chunks/combine-async-Dcg4ya1R.mjs";
+import { i as y } from "../chunks/base-BpECeKwU.mjs";
+import { l as R } from "../chunks/local-8JVtLN0O.mjs";
+const S = (r) => (e) => o(r), j = () => (r) => o(r), q = (r) => (e) => u(r), N = (r) => (e) => r, m = (r, e) => (t) => y(r) ? o(r) : u(e), z = m, p = (r, e) => (t) => {
+  const n = r(t);
+  return v(n, e);
+}, B = (r, e) => (t) => {
+  const n = r(t);
+  return i(n, (s) => e(s)(t));
+}, l = (r, e) => (t) => {
+  const n = r(t), s = e(t);
+  return x(n, s);
+}, A = (r) => (e, t) => {
+  const n = p(e, (s) => (c) => r(s, c));
+  return l(n, t);
+}, C = (r) => (e, t, n) => {
+  const s = A(
+    (c, a) => (_) => r(c, a, _)
+  )(e, t);
+  return l(s, n);
+}, D = (r, e) => (t) => {
+  const n = r(t);
+  return i(n, (s) => {
+    const a = e(s)(t);
+    return a.ok ? o(s) : a;
+  });
+}, F = (r, e) => (t) => {
+  const n = r(t);
+  return T(n, e);
+}, G = (r, e) => (t) => {
+  const n = r(t);
+  if (n.ok)
+    return n;
+  const s = n.error;
+  return e(s)(t);
+}, b = (r) => (e) => (t) => {
+  const n = e.map((s) => r(s)(t));
+  return h(n);
+}, H = (r) => b((e) => e)(r), I = (r) => async (e) => o(r), J = () => async (r) => o(r), K = (r) => async (e) => u(r), L = (r) => async (e) => r, w = (r, e) => async (t) => y(r) ? o(r) : u(e), Q = w, E = (r, e) => async (t) => {
+  const n = await r(t);
+  return O(n, e);
+}, U = (r, e) => async (t) => {
+  const n = await r(t);
+  return d(n, async (s) => await e(s)(t));
+}, f = (r, e) => async (t) => {
+  const n = r(t), s = e(t), [c, a] = await Promise.all([n, s]);
+  return g(c, a);
+}, $ = (r) => (e, t) => {
+  const n = E(e, (s) => (c) => r(s, c));
+  return f(n, t);
+}, V = (r) => (e, t, n) => {
+  const s = $((c, a) => (_) => r(c, a, _))(
+    e,
+    t
+  );
+  return f(s, n);
+}, W = (r, e) => async (t) => {
+  const n = await r(t);
+  return d(n, async (s) => {
+    const a = await e(s)(t);
+    return a.ok ? o(s) : a;
+  });
+}, X = (r, e) => async (t) => {
+  const n = await r(t);
+  return M(n, e);
+}, Y = (r, e) => async (t) => {
+  const n = await r(t);
+  if (n.ok)
+    return n;
+  const s = n.error;
+  return await e(s)(t);
+}, k = (r) => (e) => async (t) => {
+  const n = e.map((c) => r(c)(t)), s = await Promise.all(n);
+  return P(s);
+}, Z = (r) => k((e) => e)(r), sr = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  andThen: B,
+  andThenAsync: U,
+  ap: l,
+  apAsync: f,
+  ask: j,
+  askAsync: J,
+  fail: q,
+  failAsync: K,
+  fromMaybe: m,
+  fromMaybeAsync: w,
+  fromNullable: z,
+  fromNullableAsync: Q,
+  fromResult: N,
+  fromResultAsync: L,
+  liftA2: A,
+  liftA2Async: $,
+  liftA3: C,
+  liftA3Async: V,
+  local: R,
+  map: p,
+  mapAsync: E,
+  mapErr: F,
+  mapErrAsync: X,
+  of: S,
+  ofAsync: I,
+  orElse: G,
+  orElseAsync: Y,
+  sequence: H,
+  sequenceAsync: Z,
+  tap: D,
+  tapAsync: W,
+  traverse: b,
+  traverseAsync: k
+}, Symbol.toStringTag, { value: "Module" }));
+export {
+  sr as _,
+  B as andThen,
+  U as andThenAsync,
+  l as ap,
+  f as apAsync,
+  j as ask,
+  J as askAsync,
+  q as fail,
+  K as failAsync,
+  m as fromMaybe,
+  w as fromMaybeAsync,
+  z as fromNullable,
+  Q as fromNullableAsync,
+  N as fromResult,
+  L as fromResultAsync,
+  A as liftA2,
+  $ as liftA2Async,
+  C as liftA3,
+  V as liftA3Async,
+  R as local,
+  p as map,
+  E as mapAsync,
+  F as mapErr,
+  X as mapErrAsync,
+  S as of,
+  I as ofAsync,
+  G as orElse,
+  Y as orElseAsync,
+  H as sequence,
+  Z as sequenceAsync,
+  D as tap,
+  W as tapAsync,
+  b as traverse,
+  k as traverseAsync
+};
+//# sourceMappingURL=ReaderT.mjs.map

package/dist/subpath/ReaderT.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"ReaderT.mjs","sources":["../../src/Reader/readerT.ts","../../src/Reader/readerT-async.ts"],"sourcesContent":["// ========================================\r\n// ./src/Reader/readerT.ts\r\n// ========================================\r\nimport type {ReaderT} from './types';\r\nimport {Ok, Err} from '../Result/base';\r\nimport type {Result} from '../Result/types';\r\nimport {\r\n  map as mapResult,\r\n  andThen as andThenResult,\r\n  mapErr as mapErrResult,\r\n} from '../Result/Operators/transform';\r\nimport {ap as apResult, all as allResult} from '../Result/Operators/combine';\r\nimport {type Maybe, isSome} from '../Maybe/__export__';\r\n\r\n/**\r\n * Lifts a pure value (A) into the ReaderT context as a successful result.\r\n * This is the 'return' or 'pure' operation for ReaderT.\r\n * @typeParam R - The Environment type.\r\n * @typeParam E - The Error type.\r\n * @typeParam A - The type of the value to wrap.\r\n * @param a - The value to be wrapped in ReaderT.\r\n * @returns ReaderT<R, E, A> that always returns Ok(a).\r\n */\r\nexport const of = <R, E, A>(a: A): ReaderT<R, E, A> => {\r\n  return (_env: R) => Ok(a);\r\n};\r\n\r\n/**\r\n * Retrieves the environment (R) as a successful result.\r\n * This is the 'ask' operation in ReaderT context.\r\n * @typeParam R - The Environment type.\r\n * @typeParam E - The Error type.\r\n * @returns ReaderT<R, E, R> that returns Ok(env).\r\n */\r\nexport const ask = <R, E>(): ReaderT<R, E, R> => {\r\n  return (env: R) => Ok(env);\r\n};\r\n\r\n/**\r\n * Creates a ReaderT that immediately fails with the given error (E).\r\n * @typeParam R - The Environment type.\r\n * @typeParam E - The Error type.\r\n * @typeParam A - The type parameter (not used, but required for type consistency).\r\n * @param e - The error value.\r\n * @returns ReaderT<R, E, A> that always returns Err(e).\r\n */\r\nexport const fail = <R, E, A>(e: E): ReaderT<R, E, A> => {\r\n  return (_env: R) => Err(e);\r\n};\r\n\r\n/**\r\n * Lifts an existing Result into the ReaderT context.\r\n * @typeParam R - The Environment type.\r\n * @typeParam E - The Error type.\r\n * @typeParam A - The success value type.\r\n * @param result - The Result<A, E> to wrap.\r\n * @returns ReaderT<R, E, A> that always returns the wrapped Result.\r\n */\r\nexport const fromResult = <R, E, A>(result: Result<A, E>): ReaderT<R, E, A> => {\r\n  return (_env: R) => result;\r\n};\r\n\r\n/**\r\n * Converts a Maybe value into a ReaderT.\r\n * @typeParam R - The Environment type.\r\n * @typeParam E - The Error type.\r\n * @typeParam A - The success value type.\r\n * @param maybe - The Maybe<A> value.\r\n * @param on_none_error - The error to use if Maybe is None.\r\n * @returns ReaderT<R, E, A> that returns Ok(A) if Some, otherwise Err(on_none_error).\r\n */\r\nexport const fromMaybe = <R, E, A>(\r\n  maybe: Maybe<A>,\r\n  on_none_error: E,\r\n): ReaderT<R, E, A> => {\r\n  return (_env: R) => {\r\n    if (isSome(maybe)) {\r\n      return Ok(maybe);\r\n    }\r\n    return Err(on_none_error);\r\n  };\r\n};\r\n\r\n/**\r\n * Converts a nullable value into a ReaderT.\r\n * @typeParam R - The Environment type.\r\n * @typeParam E - The Error type.\r\n * @typeParam A - The success value type.\r\n * @param maybe - The nullable value (A | null | undefined).\r\n * @param on_none_error - The error to use if the value is null or undefined.\r\n * @returns ReaderT<R, E, A> that returns Ok(A) if value exists, otherwise Err(on_none_error).\r\n */\r\nexport const fromNullable = fromMaybe;\r\n\r\n/**\r\n * Applies a pure function (A) => B to the success value inside the ReaderT.\r\n * This is the 'map' operation (Functor) for ReaderT.\r\n * @typeParam R - The Environment type.\r\n * @typeParam E - The Error type.\r\n * @typeParam A - The type of the input value.\r\n * @typeParam B - The type of the output value.\r\n * @param reader - The source ReaderT<R, E, A>.\r\n * @param f_ab - The mapping function (A) => B.\r\n * @returns ReaderT<R, E, B> with the transformed success value.\r\n */\r\nexport const map = <R, E, A, B>(\r\n  reader: ReaderT<R, E, A>,\r\n  f_ab: (a: A) => B,\r\n): ReaderT<R, E, B> => {\r\n  return (env: R) => {\r\n    const result_a = reader(env);\r\n    return mapResult(result_a, f_ab);\r\n  };\r\n};\r\n\r\n/**\r\n * Chains two ReaderT computations. The result of the first reader (A) is used to\r\n * produce the second reader (ReaderT<R, E, B>). This is the 'flatMap' or 'bind' operation (Monad).\r\n * @typeParam R - The Environment type.\r\n * @typeParam E - The Error type.\r\n * @typeParam A - The type of the input value of the first reader.\r\n * @typeParam B - The type of the final output value.\r\n * @param reader - The initial ReaderT<R, E, A>.\r\n * @param f_next - A function that takes the result of 'reader' and returns the next ReaderT<R, E, B>.\r\n * @returns ReaderT<R, E, B> containing the result of the chained computation.\r\n */\r\nexport const andThen = <R, E, A, B>(\r\n  reader: ReaderT<R, E, A>,\r\n  f_next: (a: A) => ReaderT<R, E, B>,\r\n): ReaderT<R, E, B> => {\r\n  return (env: R) => {\r\n    const result_a = reader(env);\r\n    return andThenResult(result_a, (a: A) => {\r\n      const next_reader = f_next(a);\r\n      return next_reader(env);\r\n    });\r\n  };\r\n};\r\n\r\n/**\r\n * Applies a function contained within a ReaderT (R, E, (A) => B) to a value\r\n * contained within another ReaderT (R, E, A). This is the 'ap' operation (Applicative Functor).\r\n * @typeParam R - The Environment type.\r\n * @typeParam E - The Error type.\r\n * @typeParam A - The type of the input value.\r\n * @typeParam B - The type of the output value.\r\n * @param reader_fab - ReaderT containing the function (A) => B.\r\n * @param reader_a - ReaderT containing the input value A.\r\n * @returns ReaderT<R, E, B> containing the applied result.\r\n */\r\nexport const ap = <R, E, A, B>(\r\n  reader_fab: ReaderT<R, E, (a: A) => B>,\r\n  reader_a: ReaderT<R, E, A>,\r\n): ReaderT<R, E, B> => {\r\n  return (env: R) => {\r\n    const result_fab = reader_fab(env);\r\n    const result_a = reader_a(env);\r\n    return apResult(result_fab, result_a);\r\n  };\r\n};\r\n\r\n/**\r\n * Lifts a binary function (A, B) => C into the ReaderT context.\r\n * It combines two ReaderTs using the Applicative 'ap' operation.\r\n * @typeParam R - The Environment type.\r\n * @typeParam E - The Error type.\r\n * @typeParam A - The type of the first input value.\r\n * @typeParam B - The type of the second input value.\r\n * @typeParam C - The type of the output value.\r\n * @param f_abc - The binary function (A, B) => C.\r\n * @returns A function that takes two ReaderTs and returns a ReaderT<R, E, C>.\r\n */\r\nexport const liftA2 =\r\n  <R, E, A, B, C>(f_abc: (a: A, b: B) => C) =>\r\n  (\r\n    reader_a: ReaderT<R, E, A>,\r\n    reader_b: ReaderT<R, E, B>,\r\n  ): ReaderT<R, E, C> => {\r\n    const reader_f_bc = map(reader_a, (a: A) => (b: B) => f_abc(a, b));\r\n    return ap(reader_f_bc, reader_b);\r\n  };\r\n\r\n/**\r\n * Lifts a ternary function (A, B, C) => D into the ReaderT context.\r\n * It combines three ReaderTs using the Applicative 'ap' operation.\r\n * @typeParam R - The Environment type.\r\n * @typeParam E - The Error type.\r\n * @typeParam A - The type of the first input value.\r\n * @typeParam B - The type of the second input value.\r\n * @typeParam C - The type of the third input value.\r\n * @typeParam D - The type of the output value.\r\n * @param f_abcd - The ternary function (A, B, C) => D.\r\n * @returns A function that takes three ReaderTs and returns a ReaderT<R, E, D>.\r\n */\r\nexport const liftA3 =\r\n  <R, E, A, B, C, D>(f_abcd: (a: A, b: B, c: C) => D) =>\r\n  (\r\n    reader_a: ReaderT<R, E, A>,\r\n    reader_b: ReaderT<R, E, B>,\r\n    reader_c: ReaderT<R, E, C>,\r\n  ): ReaderT<R, E, D> => {\r\n    const reader_f_cd = liftA2<R, E, A, B, (c: C) => D>(\r\n      (a: A, b: B) => (c: C) => f_abcd(a, b, c),\r\n    )(reader_a, reader_b);\r\n\r\n    return ap(reader_f_cd, reader_c);\r\n  };\r\n\r\n/**\r\n * Performs a side effect using the result of the first ReaderT, and then returns\r\n * the original result. The side effect can fail (return Err), in which case the\r\n * entire computation fails with that error.\r\n * @typeParam R - The Environment type.\r\n * @typeParam E - The Error type.\r\n * @typeParam A - The type of the original value to be passed through.\r\n * @param reader - The source ReaderT<R, E, A>.\r\n * @param f - A function that takes A and returns a ReaderT<R, E, unknown> (the side effect).\r\n * @returns ReaderT<R, E, A> that returns the original success value or the side effect's error.\r\n */\r\nexport const tap = <R, E, A>(\r\n  reader: ReaderT<R, E, A>,\r\n  f: (a: A) => ReaderT<R, E, unknown>,\r\n): ReaderT<R, E, A> => {\r\n  return (env: R) => {\r\n    const result_a = reader(env);\r\n\r\n    return andThenResult(result_a, (a: A) => {\r\n      const side_effect_reader = f(a);\r\n      const side_effect_result = side_effect_reader(env);\r\n\r\n      if (!side_effect_result.ok) {\r\n        return side_effect_result;\r\n      }\r\n      return Ok(a);\r\n    });\r\n  };\r\n};\r\n\r\n/**\r\n * Transforms the error type (E) of a ReaderT using a mapping function.\r\n * This is the 'mapError' operation for ReaderT.\r\n * @typeParam R - The Environment type.\r\n * @typeParam E - The original Error type.\r\n * @typeParam A - The success value type.\r\n * @typeParam F - The new Error type.\r\n * @param reader - The source ReaderT<R, E, A>.\r\n * @param fn_fe - The function (E) => F to map the error.\r\n * @returns ReaderT<R, F, A> with the transformed error type.\r\n */\r\nexport const mapErr = <R, E, A, F>(\r\n  reader: ReaderT<R, E, A>,\r\n  fn_fe: (e: E) => F,\r\n): ReaderT<R, F, A> => {\r\n  return (env: R) => {\r\n    const result_a = reader(env);\r\n    return mapErrResult(result_a, fn_fe);\r\n  };\r\n};\r\n\r\n/**\r\n * Provides an alternative ReaderT to execute if the primary ReaderT fails.\r\n * This allows for error recovery or fallback behavior.\r\n * @typeParam R - The Environment type.\r\n * @typeParam E - The primary error type.\r\n * @typeParam A - The success value type.\r\n * @typeParam F - The alternative error type.\r\n * @param reader - The primary ReaderT<R, E, A>.\r\n * @param alternative_reader - A function that takes the error E and returns a recovery ReaderT<R, F, A>.\r\n * @returns ReaderT<R, F, A> that is either the success of the primary reader, or the result of the alternative reader.\r\n */\r\nexport const orElse = <R, E, A, F>(\r\n  reader: ReaderT<R, E, A>,\r\n  alternative_reader: (e: E) => ReaderT<R, F, A>,\r\n): ReaderT<R, F, A> => {\r\n  return (env: R) => {\r\n    const result_a = reader(env);\r\n    if (result_a.ok) {\r\n      return result_a as Result<A, F>;\r\n    }\r\n    const error = result_a.error;\r\n    const recovered_reader = alternative_reader(error);\r\n    return recovered_reader(env);\r\n  };\r\n};\r\n\r\n/**\r\n * Maps a list of items (T[]) to ReaderT computations and collects the results (A[])\r\n * into a single ReaderT. This is the 'traverse' operation.\r\n * @typeParam R - The Environment type.\r\n * @typeParam E - The Error type.\r\n * @typeParam T - The type of input items.\r\n * @typeParam A - The type of output values.\r\n * @param f_ta - The function (T) => ReaderT<R, E, A> to apply to each item.\r\n * @param items - The list of items T to process.\r\n * @returns ReaderT<R, E, A[]> that contains an array of results A or the first error E.\r\n */\r\nexport const traverse =\r\n  <R, E, T, A>(f_ta: (t: T) => ReaderT<R, E, A>) =>\r\n  (items: readonly T[]): ReaderT<R, E, A[]> => {\r\n    return (env: R) => {\r\n      const results: Result<A, E>[] = items.map((item) => {\r\n        const reader = f_ta(item);\r\n        return reader(env);\r\n      });\r\n      return allResult(results);\r\n    };\r\n  };\r\n\r\n/**\r\n * Sequences a list of ReaderT computations into a single ReaderT.\r\n * This is a specialization of 'traverse' where the function is the identity.\r\n * @typeParam R - The Environment type.\r\n * @typeParam E - The Error type.\r\n * @typeParam A - The success value type.\r\n * @param readers - The list of ReaderT<R, E, A> computations.\r\n * @returns ReaderT<R, E, A[]> that contains an array of results A or the first error E.\r\n */\r\nexport const sequence = <R, E, A>(\r\n  readers: readonly ReaderT<R, E, A>[],\r\n): ReaderT<R, E, A[]> => {\r\n  return traverse((reader: ReaderT<R, E, A>) => reader)(readers);\r\n};\r\n","// ========================================\r\n// ./src/Reader/readerT-async.ts\r\n// ========================================\r\n/* eslint-disable @typescript-eslint/require-await */\r\n\r\nimport type {AsyncReaderT} from './types';\r\nimport {Ok, Err} from '../Result/base';\r\nimport type {Result} from '../Result/types';\r\nimport {\r\n  mapAsync as mapResultAsync,\r\n  andThenAsync as andThenResultAsync,\r\n  mapErrAsync as mapErrResultAsync,\r\n} from '../Result/Operators/Async/transform-async';\r\nimport {\r\n  apAsync as apResultAsync,\r\n  allAsync as allResultAsync,\r\n} from '../Result/Operators/Async/combine-async';\r\nimport {type Maybe, isSome} from '../Maybe/__export__';\r\nimport {UnknownError} from '../unknown-error';\r\n\r\n/**\r\n * Creates an AsyncReaderT that ignores the environment (R) and resolves immediately\r\n * with a successful Result containing the given value (A). This is the 'return' or 'pure' operation.\r\n * @typeParam R - The Environment type.\r\n * @typeParam E - The Error type.\r\n * @typeParam A - The type of the value to wrap.\r\n * @param a - The value to be wrapped in AsyncReaderT.\r\n * @returns AsyncReaderT<R, E, A> that resolves to Ok(a).\r\n */\r\nexport const ofAsync = <R, E, A>(a: A): AsyncReaderT<R, E, A> => {\r\n  return async (_env: R) => Ok(a);\r\n};\r\n\r\n/**\r\n * Creates an AsyncReaderT that retrieves the environment (R) and resolves with it\r\n * in a successful Result. This is the 'ask' operation in ReaderT Monad.\r\n * @typeParam R - The Environment type.\r\n * @typeParam E - The Error type.\r\n * @returns AsyncReaderT<R, E, R> that resolves to Ok(env).\r\n */\r\nexport const askAsync = <R, E>(): AsyncReaderT<R, E, R> => {\r\n  return async (env: R) => Ok(env);\r\n};\r\n\r\n/**\r\n * Creates an AsyncReaderT that always fails with the given error (E), ignoring the environment.\r\n * @typeParam R - The Environment type.\r\n * @typeParam E - The Error type.\r\n * @typeParam A - The type parameter for the value (unused, for consistency).\r\n * @param e - The error value to wrap in a failed Result.\r\n * @returns AsyncReaderT<R, E, A> that resolves to Err(e).\r\n */\r\nexport const failAsync = <R, E, A>(e: E): AsyncReaderT<R, E, A> => {\r\n  return async (_env: R) => Err(e);\r\n};\r\n\r\n/**\r\n * Lifts a Result<A, E> into the AsyncReaderT context, ignoring the environment.\r\n * @typeParam R - The Environment type.\r\n * @typeParam E - The Error type.\r\n * @typeParam A - The type of the value.\r\n * @param result - The Result to lift.\r\n * @returns AsyncReaderT<R, E | UnknownError, A> that resolves to the given result.\r\n */\r\nexport const fromResultAsync = <R, E, A>(\r\n  result: Result<A, E>,\r\n): AsyncReaderT<R, E, A> => {\r\n  return async (_env: R) => result;\r\n};\r\n\r\n/**\r\n * Lifts a Maybe<A> into the AsyncReaderT context, converting it to a Result.\r\n * If the Maybe is Some, returns Ok with the value; if None, returns Err with the given error.\r\n * @typeParam R - The Environment type.\r\n * @typeParam E - The Error type.\r\n * @typeParam A - The type of the value.\r\n * @param maybe - The Maybe value to convert.\r\n * @param on_none_error - The error to use if the Maybe is None.\r\n * @returns AsyncReaderT<R, E | UnknownError, A> that resolves to Ok(a) or Err(on_none_error).\r\n */\r\nexport const fromMaybeAsync = <R, E, A>(\r\n  maybe: Maybe<A>,\r\n  on_none_error: E,\r\n): AsyncReaderT<R, E | UnknownError, A> => {\r\n  return async (_env: R) => {\r\n    if (isSome(maybe)) {\r\n      return Ok(maybe);\r\n    }\r\n    return Err(on_none_error);\r\n  };\r\n};\r\n\r\n/**\r\n * Lifts a nullable value (A | null | undefined) into the AsyncReaderT context.\r\n * If the value is not null or undefined, returns Ok with the value; otherwise returns Err.\r\n * @typeParam R - The Environment type.\r\n * @typeParam E - The Error type.\r\n * @typeParam A - The type of the value.\r\n * @param maybe - The nullable value to convert.\r\n * @param on_none_error - The error to use if the value is null or undefined.\r\n * @returns AsyncReaderT<R, E | UnknownError, A> that resolves accordingly.\r\n */\r\nexport const fromNullableAsync = fromMaybeAsync;\r\n\r\n/**\r\n * Applies a function (A) => B to the successful value inside the AsyncReaderT,\r\n * maintaining the environment context and propagating errors. This is the 'map' operation.\r\n * @typeParam R - The Environment type.\r\n * @typeParam E - The Error type.\r\n * @typeParam A - The type of the input value.\r\n * @typeParam B - The type of the output value.\r\n * @param reader - The source AsyncReaderT<R, E, A>.\r\n * @param fn - The mapping function (A) => B.\r\n * @returns AsyncReaderT<R, E | UnknownError, B> containing the mapped value or the original error.\r\n */\r\nexport const mapAsync = <R, E, A, B>(\r\n  reader: AsyncReaderT<R, E, A>,\r\n  fn: (a: A) => B,\r\n): AsyncReaderT<R, E | UnknownError | DOMException, B> => {\r\n  return async (env: R) => {\r\n    const result_a = await reader(env);\r\n    return mapResultAsync(result_a, fn);\r\n  };\r\n};\r\n\r\n/**\r\n * Chains two AsyncReaderT computations. The successful result of the first reader (A) is used to\r\n * produce the second reader (AsyncReaderT<R, E, B>). Errors are propagated.\r\n * This is the 'flatMap' or 'bind' operation (Monad).\r\n * @typeParam R - The Environment type.\r\n * @typeParam E - The Error type.\r\n * @typeParam A - The type of the input value of the first reader.\r\n * @typeParam B - The type of the final output value.\r\n * @param reader - The initial AsyncReaderT<R, E, A>.\r\n * @param f_next - A function that takes the successful result of 'reader' and returns the next AsyncReaderT<R, E, B>.\r\n * @returns AsyncReaderT<R, E | UnknownError, B> containing the final result or an error.\r\n */\r\nexport const andThenAsync = <R, E, A, B>(\r\n  reader: AsyncReaderT<R, E, A>,\r\n  f_next: (a: A, signal?: AbortSignal) => AsyncReaderT<R, E, B>,\r\n): AsyncReaderT<R, E | UnknownError | DOMException, B> => {\r\n  return async (env: R) => {\r\n    const result_a = await reader(env);\r\n    return andThenResultAsync(result_a, async (a: A) => {\r\n      const next_reader = f_next(a);\r\n      return await next_reader(env);\r\n    });\r\n  };\r\n};\r\n\r\n/**\r\n * Applies a function contained within an AsyncReaderT (R, (A) => B) to a value\r\n * contained within another AsyncReaderT (R, A), preserving the environment and propagating errors.\r\n * This is the 'ap' operation (Applicative Functor).\r\n * @typeParam R - The Environment type.\r\n * @typeParam E - The Error type.\r\n * @typeParam A - The type of the input value.\r\n * @typeParam B - The type of the output value.\r\n * @param reader_fab - AsyncReaderT containing the function (A) => B.\r\n * @param reader_a - AsyncReaderT containing the input value A.\r\n * @returns AsyncReaderT<R, E | UnknownError, B> containing the result of applying the function or an error.\r\n */\r\nexport const apAsync = <R, E, A, B>(\r\n  reader_fab: AsyncReaderT<R, E, (a: A) => B>,\r\n  reader_a: AsyncReaderT<R, E, A>,\r\n): AsyncReaderT<R, E | UnknownError | DOMException, B> => {\r\n  return async (env: R) => {\r\n    const promise_fab = reader_fab(env);\r\n    const promise_a = reader_a(env);\r\n\r\n    const [result_fab, result_a] = await Promise.all([promise_fab, promise_a]);\r\n\r\n    return apResultAsync(result_fab, result_a);\r\n  };\r\n};\r\n\r\n/**\r\n * Asynchronously lifts a binary function (A, B) => C into the AsyncReaderT context.\r\n * It combines two AsyncReaderTs using the Applicative 'ap' operation, propagating errors.\r\n * @typeParam R - The Environment type.\r\n * @typeParam E - The Error type.\r\n * @typeParam A - The type of the first input value.\r\n * @typeParam B - The type of the second input value.\r\n * @typeParam C - The type of the output value.\r\n * @param f_abc - The binary function (A, B) => C.\r\n * @returns A function that takes two AsyncReaderTs and returns an AsyncReaderT<R, E | UnknownError, C>.\r\n */\r\nexport const liftA2Async =\r\n  <A, B, C>(f_abc: (a: A, b: B) => C) =>\r\n  <R, E>(\r\n    reader_a: AsyncReaderT<R, E, A>,\r\n    reader_b: AsyncReaderT<R, E, B>,\r\n  ): AsyncReaderT<R, E | UnknownError | DOMException, C> => {\r\n    const reader_f_bc = mapAsync(reader_a, (a: A) => (b: B) => f_abc(a, b));\r\n    return apAsync(reader_f_bc, reader_b);\r\n  };\r\n\r\n/**\r\n * Asynchronously lifts a ternary function (A, B, C) => D into the AsyncReaderT context.\r\n * It combines three AsyncReaderTs using the Applicative 'ap' operation, propagating errors.\r\n * @typeParam R - The Environment type.\r\n * @typeParam E - The Error type.\r\n * @typeParam A - The type of the first input value.\r\n * @typeParam B - The type of the second input value.\r\n * @typeParam C - The type of the third input value.\r\n * @typeParam D - The type of the output value.\r\n * @param f_abcd - The ternary function (A, B, C) => D.\r\n * @returns A function that takes three AsyncReaderTs and returns an AsyncReaderT<R, E | UnknownError, D>.\r\n */\r\nexport const liftA3Async =\r\n  <A, B, C, D>(f_abcd: (a: A, b: B, c: C) => D) =>\r\n  <R, E>(\r\n    reader_a: AsyncReaderT<R, E, A>,\r\n    reader_b: AsyncReaderT<R, E, B>,\r\n    reader_c: AsyncReaderT<R, E, C>,\r\n  ): AsyncReaderT<R, E | UnknownError | DOMException, D> => {\r\n    const reader_f_cd = liftA2Async((a: A, b: B) => (c: C) => f_abcd(a, b, c))(\r\n      reader_a,\r\n      reader_b,\r\n    );\r\n    return apAsync(reader_f_cd, reader_c);\r\n  };\r\n\r\n/**\r\n * Performs a side effect using the successful result of the AsyncReaderT, and then returns\r\n * the original result, ignoring the side effect's return value. If the side effect fails,\r\n * the error is propagated.\r\n * Note: The side effect function must return an AsyncReaderT.\r\n * @typeParam R - The Environment type.\r\n * @typeParam E - The Error type.\r\n * @typeParam A - The type of the original value to be passed through.\r\n * @param reader - The source AsyncReaderT<R, E, A>.\r\n * @param f - A function that takes A and returns an AsyncReaderT<R, E, unknown> (the side effect).\r\n * @returns AsyncReaderT<R, E | UnknownError, A> containing the original value or an error.\r\n */\r\nexport const tapAsync = <R, E, A>(\r\n  reader: AsyncReaderT<R, E, A>,\r\n  f: (a: A) => AsyncReaderT<R, E, unknown>,\r\n): AsyncReaderT<R, E | UnknownError | DOMException, A> => {\r\n  return async (env: R) => {\r\n    const result_a = await reader(env);\r\n\r\n    return andThenResultAsync(result_a, async (a: A) => {\r\n      const side_effect_reader = f(a);\r\n      const side_effect_result = await side_effect_reader(env);\r\n\r\n      if (!side_effect_result.ok) {\r\n        return side_effect_result;\r\n      }\r\n      return Ok(a);\r\n    });\r\n  };\r\n};\r\n\r\n/**\r\n * Transforms the error value inside a failed AsyncReaderT using the given function.\r\n * Successful results are passed through unchanged.\r\n * @typeParam R - The Environment type.\r\n * @typeParam E - The original Error type.\r\n * @typeParam A - The value type.\r\n * @typeParam F - The new Error type.\r\n * @param reader - The source AsyncReaderT<R, E, A>.\r\n * @param fn_fe - The error transformation function (E) => Promise<F> | F.\r\n * @returns AsyncReaderT<R, F | UnknownError, A> with transformed error or original success.\r\n */\r\nexport const mapErrAsync = <R, E, A, F>(\r\n  reader: AsyncReaderT<R, E, A>,\r\n  fn_fe: (e: E) => Promise<F> | F,\r\n): AsyncReaderT<R, F | UnknownError | DOMException, A> => {\r\n  return async (env: R) => {\r\n    const result_a = await reader(env);\r\n    return mapErrResultAsync(result_a, fn_fe);\r\n  };\r\n};\r\n\r\n/**\r\n * Recovers from an error in the AsyncReaderT by executing an alternative reader.\r\n * If the original reader succeeds, its result is returned; otherwise, the error is\r\n * passed to the alternative function which returns a new reader to try.\r\n * @typeParam R - The Environment type.\r\n * @typeParam E - The original Error type.\r\n * @typeParam A - The value type.\r\n * @typeParam F - The alternative Error type.\r\n * @param reader - The original AsyncReaderT<R, E, A>.\r\n * @param alternative_reader - A function that takes the error and returns an alternative AsyncReaderT<R, F, A>.\r\n * @returns AsyncReaderT<R, F | UnknownError, A> with either the original success or the alternative result.\r\n */\r\nexport const orElseAsync = <R, E, A, F>(\r\n  reader: AsyncReaderT<R, E, A>,\r\n  alternative_reader: (e: E) => AsyncReaderT<R, F, A>,\r\n): AsyncReaderT<R, F | UnknownError, A> => {\r\n  return async (env: R) => {\r\n    const result_a = await reader(env);\r\n\r\n    if (result_a.ok) {\r\n      return result_a;\r\n    }\r\n\r\n    const error = result_a.error;\r\n    const recovered_reader = alternative_reader(error);\r\n    return await recovered_reader(env);\r\n  };\r\n};\r\n\r\n/**\r\n * Transforms a list of items (T) into an AsyncReaderT that processes each item\r\n * with the given function and collects all results into an array.\r\n * All items are processed in parallel (using Promise.all).\r\n * @typeParam R - The Environment type.\r\n * @typeParam E - The Error type.\r\n * @typeParam T - The type of input items.\r\n * @typeParam A - The type of output values.\r\n * @param f_ta - A function that transforms each item T into an AsyncReaderT<R, E, A>.\r\n * @returns A function that takes an array of T and returns an AsyncReaderT<R, E | UnknownError, A[]>\r\n *          containing all successful results, or the first error encountered.\r\n */\r\nexport const traverseAsync =\r\n  <R, E, T, A>(f_ta: (t: T) => AsyncReaderT<R, E, A>) =>\r\n  (\r\n    items: readonly T[],\r\n  ): AsyncReaderT<R, E | UnknownError | DOMException, A[]> => {\r\n    return async (env: R) => {\r\n      const promises: Promise<Result<A, E>>[] = items.map((item) => {\r\n        const reader = f_ta(item);\r\n        return reader(env);\r\n      });\r\n\r\n      const results: Result<A, E>[] = await Promise.all(promises);\r\n\r\n      return allResultAsync(results);\r\n    };\r\n  };\r\n\r\n/**\r\n * Converts a list of AsyncReaderTs into a single AsyncReaderT that contains an array of results.\r\n * All readers are executed in parallel (using Promise.all).\r\n * @typeParam R - The Environment type.\r\n * @typeParam E - The Error type.\r\n * @typeParam A - The value type.\r\n * @param readers - An array of AsyncReaderT<R, E, A> to sequence.\r\n * @returns AsyncReaderT<R, E | UnknownError, A[]> containing all successful results, or the first error.\r\n */\r\nexport const sequenceAsync = <R, E, A>(\r\n  readers: readonly AsyncReaderT<R, E, A>[],\r\n): AsyncReaderT<R, E | UnknownError | DOMException, A[]> => {\r\n  return traverseAsync((reader: AsyncReaderT<R, E, A>) => reader)(readers);\r\n};\r\n"],"names":["of","a","_env","Ok","ask","env","fail","e","Err","fromResult","result","fromMaybe","maybe","on_none_error","isSome","fromNullable","map","reader","f_ab","result_a","mapResult","andThen","f_next","andThenResult","ap","reader_fab","reader_a","result_fab","apResult","liftA2","f_abc","reader_b","reader_f_bc","b","liftA3","f_abcd","reader_c","reader_f_cd","c","tap","f","side_effect_result","mapErr","fn_fe","mapErrResult","orElse","alternative_reader","error","traverse","f_ta","items","results","item","allResult","sequence","readers","ofAsync","askAsync","failAsync","fromResultAsync","fromMaybeAsync","fromNullableAsync","mapAsync","fn","mapResultAsync","andThenAsync","andThenResultAsync","apAsync","promise_fab","promise_a","apResultAsync","liftA2Async","liftA3Async","tapAsync","mapErrAsync","mapErrResultAsync","orElseAsync","traverseAsync","promises","allResultAsync","sequenceAsync"],"mappings":"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"}

package/dist/subpath/Resource.cjs

@@ -0,0 +1,2 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const i=require("../chunks/types-B7X_LBjM.cjs"),d=require("../chunks/Errors-BWEYu-AB.cjs"),o=Symbol("Data"),f=Symbol("Cleanup"),u=Symbol("Commit"),y=Symbol("Rollback");class b{[o];[f];[u];[y];constructor(e,s,r,c){this[o]=e,this[f]=s,this[u]=r,this[y]=c}static open(e,s,r,c){return new b(e,s,r,c)}[Symbol.dispose](){this[o]!==i.NONE&&(this[y]&&this[y](this[o]),this[f]&&this[f](this[o]),this[o]=i.NONE)}}function w(t){if(t[o]===i.NONE)throw new d.UseAfterFreeError("Resource already closed/committed/rolled back.");return t[y]=void 0,t[u]&&t[u](t[o]),t[Symbol.dispose](),t}function N(t){if(t[o]===i.NONE)throw new d.UseAfterFreeError("Resource already closed/committed/rolled back.");const e=t[y];return t[y]=void 0,e&&e(t[o]),t[Symbol.dispose](),t}function A(t,e){if(t[o]===i.NONE)throw new d.UseAfterFreeError("Resource already disposed.");return e(t[o])}function E(t,e){if(t[o]===i.NONE)throw new d.UseAfterFreeError("Resource already disposed.");return e(t[o]),t}function _(t,e,s,r,c){const a=t;return a[o]=e,a[f]=s,a[u]=r,a[y]=c,a}const n=Symbol("Data"),m=Symbol("AsyncCleanup"),h=Symbol("AsyncCommit"),l=Symbol("AsyncRollback");class p{[n];[m];[h];[l];constructor(e,s,r,c){this[n]=e,this[m]=s,this[h]=r,this[l]=c}static open(e,s,r,c){return new p(e,s,r,c)}async[Symbol.asyncDispose](){this[n]!==i.NONE&&(this[l]&&await this[l](this[n]),this[m]&&await this[m](this[n]),this[n]=i.NONE)}}async function O(t){if(t[n]===i.NONE)throw new d.UseAfterFreeError("Resource already closed/committed/rolled back.");return t[h]&&await t[h](t[n]),t[l]=void 0,await t[Symbol.asyncDispose](),t}async function S(t){if(t[n]===i.NONE)throw new d.UseAfterFreeError("Resource already closed/committed/rolled back.");const e=t[l];return t[l]=void 0,e&&await e(t[n]),t[l]=void 0,await t[Symbol.asyncDispose](),t}async function k(t,e){if(t[n]===i.NONE)throw new d.UseAfterFreeError("Resource already disposed.");return await e(t[n])}async function R(t,e){if(t[n]===i.NONE)throw new d.UseAfterFreeError("Resource already disposed.");return await e(t[n]),t}function F(t,e,s,r,c){const a=t;return a[n]=e,a[m]=s,a[h]=r,a[l]=c,a}const U=Object.freeze(Object.defineProperty({__proto__:null,AsyncTxScope:p,TxScope:b,commit:w,commitAsync:O,exec:E,execAsync:R,reopen:_,reopenAsync:F,rollback:N,rollbackAsync:S,use:A,useAsync:k},Symbol.toStringTag,{value:"Module"}));exports.AsyncTxScope=p;exports.TxScope=b;exports.__exportResource__=U;exports.commit=w;exports.commitAsync=O;exports.exec=E;exports.execAsync=R;exports.reopen=_;exports.reopenAsync=F;exports.rollback=N;exports.rollbackAsync=S;exports.use=A;exports.useAsync=k;
+//# sourceMappingURL=Resource.cjs.map

package/dist/subpath/Resource.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"Resource.cjs","sources":["../../src/Resource/TxScope.ts","../../src/Resource/TxScope-async.ts"],"sourcesContent":["// ========================================\r\n// ./src/Resource/TxScope.ts\r\n// ========================================\r\n/* eslint-disable @typescript-eslint/no-unnecessary-type-assertion */\r\n\r\nimport {\r\n  type StateOpened,\r\n  type StateCommit,\r\n  type StateRollback,\r\n  type Cleaner,\r\n  type CommitUp,\r\n  type RollbackUp,\r\n  type NoneType,\r\n  NONE,\r\n} from './types';\r\nimport {UseAfterFreeError} from '../Errors';\r\n\r\n// ------ 私有符号定义 ------\r\nconst _data = Symbol('Data');\r\nconst _cleanup = Symbol('Cleanup');\r\nconst _commitup = Symbol('Commit');\r\nconst _rollbackup = Symbol('Rollback');\r\n\r\n/**\r\n * Synchronous transaction scope management class.\r\n * @typeParam T - The type of the transaction data\r\n * @typeParam S - The state type (opened, commit, or rollback)\r\n */\r\nexport class TxScope<T, S extends StateOpened | StateCommit | StateRollback> {\r\n  declare private state: S;\r\n  public [_data]: T | NoneType;\r\n  public [_cleanup]: Cleaner<T> | undefined;\r\n  public [_commitup]: CommitUp<T> | undefined;\r\n  public [_rollbackup]: RollbackUp<T> | undefined;\r\n\r\n  // ------ 构造函数 ------\r\n  private constructor(\r\n    data: T,\r\n    cleanup_fn?: Cleaner<T>,\r\n    commitup_fn?: CommitUp<T>,\r\n    rollbackup_fn?: RollbackUp<T>,\r\n  ) {\r\n    this[_data] = data;\r\n    this[_cleanup] = cleanup_fn;\r\n    this[_commitup] = commitup_fn;\r\n    this[_rollbackup] = rollbackup_fn;\r\n  }\r\n\r\n  /**\r\n   * Creates a new opened synchronous transaction scope.\r\n   * @typeParam D - The type of the transaction data\r\n   * @param data - The transaction data\r\n   * @param cleaner - Optional synchronous cleanup function\r\n   * @param commiter - Optional synchronous commit function\r\n   * @param rollbacker - Optional synchronous rollback function\r\n   * @returns A new opened synchronous transaction scope\r\n   */\r\n  static open<D>(\r\n    data: D,\r\n    cleaner?: Cleaner<D>,\r\n    commiter?: CommitUp<D>,\r\n    rollbacker?: RollbackUp<D>,\r\n  ): TxScope<D, StateOpened> {\r\n    return new TxScope(data, cleaner, commiter, rollbacker);\r\n  }\r\n\r\n  /**\r\n   * Synchronously disposes the transaction scope (cleanup with rollback).\r\n   */\r\n  [Symbol.dispose](this: TxScope<T, StateOpened>): void {\r\n    if (this[_data] === NONE) {\r\n      return;\r\n    }\r\n    // 如果事务未被 commit/rollback 清理，则在 dispose 时执行回滚。\r\n    if (this[_rollbackup]) {\r\n      this[_rollbackup](this[_data] as T);\r\n    }\r\n    if (this[_cleanup]) {\r\n      this[_cleanup](this[_data] as T);\r\n    }\r\n    this[_data] = NONE;\r\n  }\r\n}\r\n\r\n/**\r\n * Union type for synchronous transaction scope states.\r\n * @typeParam T - The type of the transaction data\r\n */\r\nexport type TxScopeType<T> =\r\n  | TxScope<T, StateOpened>\r\n  | TxScope<T, StateCommit>\r\n  | TxScope<T, StateRollback>;\r\n\r\n/**\r\n * Commits a synchronous transaction scope.\r\n * @typeParam T - The type of the transaction data\r\n * @param resource - The opened synchronous transaction scope\r\n * @returns The committed transaction scope\r\n * @throws Error if resource is already disposed/committed/rolled back\r\n */\r\nexport function commit<T>(\r\n  resource: TxScope<T, StateOpened>,\r\n): TxScope<T, StateCommit> {\r\n  if (resource[_data] === NONE) {\r\n    throw new UseAfterFreeError(\r\n      'Resource already closed/committed/rolled back.',\r\n    );\r\n  }\r\n  resource[_rollbackup] = undefined;\r\n  if (resource[_commitup]) {\r\n    resource[_commitup](resource[_data] as T);\r\n  }\r\n  resource[Symbol.dispose]();\r\n  return resource as unknown as TxScope<T, StateCommit>;\r\n}\r\n\r\n/**\r\n * Rolls back a synchronous transaction scope.\r\n * @typeParam T - The type of the transaction data\r\n * @param resource - The opened synchronous transaction scope\r\n * @returns The rolled back transaction scope\r\n * @throws Error if resource is already disposed/committed/rolled back\r\n */\r\nexport function rollback<T>(\r\n  resource: TxScope<T, StateOpened>,\r\n): TxScope<T, StateRollback> {\r\n  if (resource[_data] === NONE) {\r\n    throw new UseAfterFreeError(\r\n      'Resource already closed/committed/rolled back.',\r\n    );\r\n  }\r\n  const fn = resource[_rollbackup];\r\n  resource[_rollbackup] = undefined;\r\n  if (fn) {\r\n    fn(resource[_data] as T); // 即使这里失败了，回滚函数已经是undefined了，不会二次错误\r\n  }\r\n  resource[Symbol.dispose]();\r\n  return resource as unknown as TxScope<T, StateRollback>;\r\n}\r\n\r\n/**\r\n * Uses a synchronous transaction scope with a callback function.\r\n * @typeParam T - The type of the transaction data\r\n * @typeParam R - The return type of the callback\r\n * @param TxScope - The opened synchronous transaction scope\r\n * @param fn - Function to process the transaction data\r\n * @returns The result of the callback\r\n * @throws Error if transaction scope is already disposed\r\n */\r\nexport function use<T, R>(\r\n  TxScope: TxScope<T, StateOpened>,\r\n  fn: (data: T) => R,\r\n): R {\r\n  if (TxScope[_data] === NONE) {\r\n    throw new UseAfterFreeError('Resource already disposed.');\r\n  }\r\n  return fn(TxScope[_data] as T);\r\n}\r\n\r\n/**\r\n * Performs a side effect on a synchronous transaction scope and returns it.\r\n * @typeParam T - The type of the transaction data\r\n * @typeParam R - The return type of the side effect function\r\n * @param TxScope - The opened synchronous transaction scope\r\n * @param fn - Side effect function to execute\r\n * @returns The same transaction scope after executing the side effect\r\n * @throws Error if transaction scope is already disposed\r\n */\r\nexport function exec<T, R>(\r\n  TxScope: TxScope<T, StateOpened>,\r\n  fn: (data: T) => R,\r\n): TxScope<T, StateOpened> {\r\n  if (TxScope[_data] === NONE) {\r\n    throw new UseAfterFreeError('Resource already disposed.');\r\n  }\r\n  fn(TxScope[_data] as T);\r\n  return TxScope;\r\n}\r\n\r\n/**\r\n * Reopens a committed or rolled back synchronous transaction scope with new data.\r\n * @typeParam T - The type of the transaction data\r\n * @param TxScope - The committed or rolled back synchronous transaction scope\r\n * @param data - New data for the transaction scope\r\n * @param cleaner - Optional new cleanup function\r\n * @param commiter - Optional new commit function\r\n * @param rollbacker - Optional new rollback function\r\n * @returns The reopened synchronous transaction scope\r\n */\r\nexport function reopen<T>(\r\n  TxScope: TxScope<T, StateCommit> | TxScope<T, StateRollback>,\r\n  data: T,\r\n  cleaner?: Cleaner<T>,\r\n  commiter?: CommitUp<T>,\r\n  rollbacker?: RollbackUp<T>,\r\n): TxScope<T, StateOpened> {\r\n  const r = TxScope as unknown as TxScope<T, StateOpened>;\r\n  r[_data] = data;\r\n  r[_cleanup] = cleaner;\r\n  r[_commitup] = commiter;\r\n  r[_rollbackup] = rollbacker;\r\n  return r;\r\n}\r\n","// ========================================\r\n// ./src/Resource/TxScope-async.ts\r\n// ========================================\r\n/* eslint-disable @typescript-eslint/no-unnecessary-type-assertion */\r\n\r\nimport {\r\n  type StateOpened,\r\n  type StateCommit,\r\n  type StateRollback,\r\n  type AnyCleaner,\r\n  type AsyncCommitUp,\r\n  type AnyRollbackUp,\r\n  type NoneType,\r\n  NONE,\r\n} from './types';\r\nimport {UseAfterFreeError} from '../Errors';\r\n\r\n// ------ 私有符号定义 ------\r\nconst _data = Symbol('Data');\r\nconst _cleanup = Symbol('AsyncCleanup');\r\nconst _commitup = Symbol('AsyncCommit');\r\nconst _rollbackup = Symbol('AsyncRollback');\r\n\r\n/**\r\n * Asynchronous transaction scope management class.\r\n * @typeParam T - The type of the transaction data\r\n * @typeParam S - The state type (opened, commit, or rollback)\r\n */\r\nexport class AsyncTxScope<\r\n  T,\r\n  S extends StateOpened | StateCommit | StateRollback,\r\n> {\r\n  declare private state: S;\r\n  public [_data]: T | NoneType;\r\n  public [_cleanup]: AnyCleaner<T> | undefined;\r\n  public [_commitup]: AsyncCommitUp<T> | undefined;\r\n  public [_rollbackup]: AnyRollbackUp<T> | undefined;\r\n\r\n  // ------ 构造函数 ------\r\n  private constructor(\r\n    data: T,\r\n    cleanup_fn?: AnyCleaner<T>,\r\n    commitup_fn?: AsyncCommitUp<T>,\r\n    rollbackup_fn?: AnyRollbackUp<T>,\r\n  ) {\r\n    this[_data] = data;\r\n    this[_cleanup] = cleanup_fn;\r\n    this[_commitup] = commitup_fn;\r\n    this[_rollbackup] = rollbackup_fn;\r\n  }\r\n\r\n  /**\r\n   * Creates a new opened asynchronous transaction scope.\r\n   * @typeParam D - The type of the transaction data\r\n   * @param data - The transaction data\r\n   * @param cleaner - Optional asynchronous cleanup function\r\n   * @param commiter - Optional asynchronous commit function\r\n   * @param rollbacker - Optional asynchronous rollback function\r\n   * @returns A new opened asynchronous transaction scope\r\n   */\r\n  static open<D>(\r\n    data: D,\r\n    cleaner?: AnyCleaner<D>,\r\n    commiter?: AsyncCommitUp<D>,\r\n    rollbacker?: AnyRollbackUp<D>,\r\n  ): AsyncTxScope<D, StateOpened> {\r\n    return new AsyncTxScope(data, cleaner, commiter, rollbacker);\r\n  }\r\n\r\n  /**\r\n   * Asynchronously disposes the transaction scope (cleanup with rollback).\r\n   * @returns Promise that resolves when disposal is complete\r\n   */\r\n  async [Symbol.asyncDispose](\r\n    this: AsyncTxScope<T, StateOpened>,\r\n  ): Promise<void> {\r\n    if (this[_data] === NONE) {\r\n      return;\r\n    }\r\n    // 如果事务未被 commit/rollback 清理，则在 dispose 时执行异步回滚。\r\n    if (this[_rollbackup]) {\r\n      await this[_rollbackup](this[_data] as T); // 强制等待异步回滚\r\n    }\r\n    if (this[_cleanup]) {\r\n      await this[_cleanup](this[_data] as T); // 强制等待异步清理\r\n    }\r\n    this[_data] = NONE;\r\n  }\r\n}\r\n\r\n/**\r\n * Union type for asynchronous transaction scope states.\r\n * @typeParam T - The type of the transaction data\r\n */\r\nexport type AsyncTxScopeType<T> =\r\n  | AsyncTxScope<T, StateOpened>\r\n  | AsyncTxScope<T, StateCommit>\r\n  | AsyncTxScope<T, StateRollback>;\r\n\r\n/**\r\n * Commits an asynchronous transaction scope.\r\n * @typeParam T - The type of the transaction data\r\n * @param resource - The opened asynchronous transaction scope\r\n * @returns Promise with the committed transaction scope\r\n * @throws Error if resource is already disposed/committed/rolled back\r\n */\r\nexport async function commitAsync<T>(\r\n  resource: AsyncTxScope<T, StateOpened>,\r\n): Promise<AsyncTxScope<T, StateCommit>> {\r\n  if (resource[_data] === NONE) {\r\n    throw new UseAfterFreeError(\r\n      'Resource already closed/committed/rolled back.',\r\n    );\r\n  }\r\n  if (resource[_commitup]) {\r\n    await resource[_commitup](resource[_data] as T);\r\n  }\r\n  resource[_rollbackup] = undefined;\r\n  await resource[Symbol.asyncDispose]();\r\n  return resource as unknown as AsyncTxScope<T, StateCommit>;\r\n}\r\n\r\n/**\r\n * Rolls back an asynchronous transaction scope.\r\n * @typeParam T - The type of the transaction data\r\n * @param resource - The opened asynchronous transaction scope\r\n * @returns Promise with the rolled back transaction scope\r\n * @throws Error if resource is already disposed/committed/rolled back\r\n */\r\nexport async function rollbackAsync<T>(\r\n  resource: AsyncTxScope<T, StateOpened>,\r\n): Promise<AsyncTxScope<T, StateRollback>> {\r\n  if (resource[_data] === NONE) {\r\n    throw new UseAfterFreeError(\r\n      'Resource already closed/committed/rolled back.',\r\n    );\r\n  }\r\n  const fn = resource[_rollbackup];\r\n  resource[_rollbackup] = undefined;\r\n  if (fn) {\r\n    await fn(resource[_data] as T);\r\n  }\r\n  resource[_rollbackup] = undefined;\r\n  await resource[Symbol.asyncDispose]();\r\n  return resource as unknown as AsyncTxScope<T, StateRollback>;\r\n}\r\n\r\n/**\r\n * Uses an asynchronous transaction scope with a callback function.\r\n * @typeParam T - The type of the transaction data\r\n * @typeParam R - The return type of the callback\r\n * @param TxScope - The opened asynchronous transaction scope\r\n * @param fn - Function to process the transaction data\r\n * @returns Promise with the result of the callback\r\n * @throws Error if transaction scope is already disposed\r\n */\r\nexport async function useAsync<T, R>(\r\n  TxScope: AsyncTxScope<T, StateOpened>,\r\n  fn: (data: T) => Promise<R> | R,\r\n): Promise<R> {\r\n  if (TxScope[_data] === NONE) {\r\n    throw new UseAfterFreeError('Resource already disposed.');\r\n  }\r\n  return await fn(TxScope[_data] as T);\r\n}\r\n\r\n/**\r\n * Performs a side effect on an asynchronous transaction scope and returns it.\r\n * @typeParam T - The type of the transaction data\r\n * @typeParam R - The return type of the side effect function\r\n * @param TxScope - The opened asynchronous transaction scope\r\n * @param fn - Side effect function to execute\r\n * @returns The same transaction scope after executing the side effect\r\n * @throws Error if transaction scope is already disposed\r\n */\r\nexport async function execAsync<T, R>(\r\n  TxScope: AsyncTxScope<T, StateOpened>,\r\n  fn: (data: T) => Promise<R> | R,\r\n): Promise<AsyncTxScope<T, StateOpened>> {\r\n  if (TxScope[_data] === NONE) {\r\n    throw new UseAfterFreeError('Resource already disposed.');\r\n  }\r\n  await fn(TxScope[_data] as T);\r\n  return TxScope;\r\n}\r\n\r\n/**\r\n * Reopens a committed or rolled back asynchronous transaction scope with new data.\r\n * @typeParam T - The type of the transaction data\r\n * @param TxScope - The committed or rolled back asynchronous transaction scope\r\n * @param data - New data for the transaction scope\r\n * @param cleaner - Optional new cleanup function\r\n * @param commiter - Optional new commit function\r\n * @param rollbacker - Optional new rollback function\r\n * @returns The reopened asynchronous transaction scope\r\n */\r\nexport function reopenAsync<T>(\r\n  TxScope: AsyncTxScope<T, StateCommit> | AsyncTxScope<T, StateRollback>,\r\n  data: T,\r\n  cleaner?: AnyCleaner<T>,\r\n  commiter?: AsyncCommitUp<T>,\r\n  rollbacker?: AnyRollbackUp<T>,\r\n): AsyncTxScope<T, StateOpened> {\r\n  const r = TxScope as unknown as AsyncTxScope<T, StateOpened>;\r\n  r[_data] = data;\r\n  r[_cleanup] = cleaner;\r\n  r[_commitup] = commiter;\r\n  r[_rollbackup] = rollbacker;\r\n  return r;\r\n}\r\n"],"names":["_data","_cleanup","_commitup","_rollbackup","TxScope","data","cleanup_fn","commitup_fn","rollbackup_fn","cleaner","commiter","rollbacker","NONE","commit","resource","UseAfterFreeError","rollback","fn","use","exec","reopen","r","AsyncTxScope","commitAsync","rollbackAsync","useAsync","execAsync","reopenAsync"],"mappings":"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"}

package/dist/subpath/Resource.mjs

@@ -0,0 +1,150 @@
+import { N as s } from "../chunks/types-DE2SnSbz.mjs";
+import { U as m } from "../chunks/Errors-DwUAvFIF.mjs";
+const n = Symbol("Data"), r = Symbol("Cleanup"), h = Symbol("Commit"), y = Symbol("Rollback");
+class w {
+  [n];
+  [r];
+  [h];
+  [y];
+  // ------ 构造函数 ------
+  constructor(i, a, l, c) {
+    this[n] = i, this[r] = a, this[h] = l, this[y] = c;
+  }
+  /**
+   * Creates a new opened synchronous transaction scope.
+   * @typeParam D - The type of the transaction data
+   * @param data - The transaction data
+   * @param cleaner - Optional synchronous cleanup function
+   * @param commiter - Optional synchronous commit function
+   * @param rollbacker - Optional synchronous rollback function
+   * @returns A new opened synchronous transaction scope
+   */
+  static open(i, a, l, c) {
+    return new w(i, a, l, c);
+  }
+  /**
+   * Synchronously disposes the transaction scope (cleanup with rollback).
+   */
+  [Symbol.dispose]() {
+    this[n] !== s && (this[y] && this[y](this[n]), this[r] && this[r](this[n]), this[n] = s);
+  }
+}
+function p(t) {
+  if (t[n] === s)
+    throw new m(
+      "Resource already closed/committed/rolled back."
+    );
+  return t[y] = void 0, t[h] && t[h](t[n]), t[Symbol.dispose](), t;
+}
+function _(t) {
+  if (t[n] === s)
+    throw new m(
+      "Resource already closed/committed/rolled back."
+    );
+  const i = t[y];
+  return t[y] = void 0, i && i(t[n]), t[Symbol.dispose](), t;
+}
+function R(t, i) {
+  if (t[n] === s)
+    throw new m("Resource already disposed.");
+  return i(t[n]);
+}
+function k(t, i) {
+  if (t[n] === s)
+    throw new m("Resource already disposed.");
+  return i(t[n]), t;
+}
+function S(t, i, a, l, c) {
+  const e = t;
+  return e[n] = i, e[r] = a, e[h] = l, e[y] = c, e;
+}
+const o = Symbol("Data"), f = Symbol("AsyncCleanup"), b = Symbol("AsyncCommit"), d = Symbol("AsyncRollback");
+class u {
+  [o];
+  [f];
+  [b];
+  [d];
+  // ------ 构造函数 ------
+  constructor(i, a, l, c) {
+    this[o] = i, this[f] = a, this[b] = l, this[d] = c;
+  }
+  /**
+   * Creates a new opened asynchronous transaction scope.
+   * @typeParam D - The type of the transaction data
+   * @param data - The transaction data
+   * @param cleaner - Optional asynchronous cleanup function
+   * @param commiter - Optional asynchronous commit function
+   * @param rollbacker - Optional asynchronous rollback function
+   * @returns A new opened asynchronous transaction scope
+   */
+  static open(i, a, l, c) {
+    return new u(i, a, l, c);
+  }
+  /**
+   * Asynchronously disposes the transaction scope (cleanup with rollback).
+   * @returns Promise that resolves when disposal is complete
+   */
+  async [Symbol.asyncDispose]() {
+    this[o] !== s && (this[d] && await this[d](this[o]), this[f] && await this[f](this[o]), this[o] = s);
+  }
+}
+async function A(t) {
+  if (t[o] === s)
+    throw new m(
+      "Resource already closed/committed/rolled back."
+    );
+  return t[b] && await t[b](t[o]), t[d] = void 0, await t[Symbol.asyncDispose](), t;
+}
+async function v(t) {
+  if (t[o] === s)
+    throw new m(
+      "Resource already closed/committed/rolled back."
+    );
+  const i = t[d];
+  return t[d] = void 0, i && await i(t[o]), t[d] = void 0, await t[Symbol.asyncDispose](), t;
+}
+async function D(t, i) {
+  if (t[o] === s)
+    throw new m("Resource already disposed.");
+  return await i(t[o]);
+}
+async function C(t, i) {
+  if (t[o] === s)
+    throw new m("Resource already disposed.");
+  return await i(t[o]), t;
+}
+function $(t, i, a, l, c) {
+  const e = t;
+  return e[o] = i, e[f] = a, e[b] = l, e[d] = c, e;
+}
+const g = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  AsyncTxScope: u,
+  TxScope: w,
+  commit: p,
+  commitAsync: A,
+  exec: k,
+  execAsync: C,
+  reopen: S,
+  reopenAsync: $,
+  rollback: _,
+  rollbackAsync: v,
+  use: R,
+  useAsync: D
+}, Symbol.toStringTag, { value: "Module" }));
+export {
+  u as AsyncTxScope,
+  w as TxScope,
+  g as _,
+  p as commit,
+  A as commitAsync,
+  k as exec,
+  C as execAsync,
+  S as reopen,
+  $ as reopenAsync,
+  _ as rollback,
+  v as rollbackAsync,
+  R as use,
+  D as useAsync
+};
+//# sourceMappingURL=Resource.mjs.map

package/dist/subpath/Resource.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"Resource.mjs","sources":["../../src/Resource/TxScope.ts","../../src/Resource/TxScope-async.ts"],"sourcesContent":["// ========================================\r\n// ./src/Resource/TxScope.ts\r\n// ========================================\r\n/* eslint-disable @typescript-eslint/no-unnecessary-type-assertion */\r\n\r\nimport {\r\n  type StateOpened,\r\n  type StateCommit,\r\n  type StateRollback,\r\n  type Cleaner,\r\n  type CommitUp,\r\n  type RollbackUp,\r\n  type NoneType,\r\n  NONE,\r\n} from './types';\r\nimport {UseAfterFreeError} from '../Errors';\r\n\r\n// ------ 私有符号定义 ------\r\nconst _data = Symbol('Data');\r\nconst _cleanup = Symbol('Cleanup');\r\nconst _commitup = Symbol('Commit');\r\nconst _rollbackup = Symbol('Rollback');\r\n\r\n/**\r\n * Synchronous transaction scope management class.\r\n * @typeParam T - The type of the transaction data\r\n * @typeParam S - The state type (opened, commit, or rollback)\r\n */\r\nexport class TxScope<T, S extends StateOpened | StateCommit | StateRollback> {\r\n  declare private state: S;\r\n  public [_data]: T | NoneType;\r\n  public [_cleanup]: Cleaner<T> | undefined;\r\n  public [_commitup]: CommitUp<T> | undefined;\r\n  public [_rollbackup]: RollbackUp<T> | undefined;\r\n\r\n  // ------ 构造函数 ------\r\n  private constructor(\r\n    data: T,\r\n    cleanup_fn?: Cleaner<T>,\r\n    commitup_fn?: CommitUp<T>,\r\n    rollbackup_fn?: RollbackUp<T>,\r\n  ) {\r\n    this[_data] = data;\r\n    this[_cleanup] = cleanup_fn;\r\n    this[_commitup] = commitup_fn;\r\n    this[_rollbackup] = rollbackup_fn;\r\n  }\r\n\r\n  /**\r\n   * Creates a new opened synchronous transaction scope.\r\n   * @typeParam D - The type of the transaction data\r\n   * @param data - The transaction data\r\n   * @param cleaner - Optional synchronous cleanup function\r\n   * @param commiter - Optional synchronous commit function\r\n   * @param rollbacker - Optional synchronous rollback function\r\n   * @returns A new opened synchronous transaction scope\r\n   */\r\n  static open<D>(\r\n    data: D,\r\n    cleaner?: Cleaner<D>,\r\n    commiter?: CommitUp<D>,\r\n    rollbacker?: RollbackUp<D>,\r\n  ): TxScope<D, StateOpened> {\r\n    return new TxScope(data, cleaner, commiter, rollbacker);\r\n  }\r\n\r\n  /**\r\n   * Synchronously disposes the transaction scope (cleanup with rollback).\r\n   */\r\n  [Symbol.dispose](this: TxScope<T, StateOpened>): void {\r\n    if (this[_data] === NONE) {\r\n      return;\r\n    }\r\n    // 如果事务未被 commit/rollback 清理，则在 dispose 时执行回滚。\r\n    if (this[_rollbackup]) {\r\n      this[_rollbackup](this[_data] as T);\r\n    }\r\n    if (this[_cleanup]) {\r\n      this[_cleanup](this[_data] as T);\r\n    }\r\n    this[_data] = NONE;\r\n  }\r\n}\r\n\r\n/**\r\n * Union type for synchronous transaction scope states.\r\n * @typeParam T - The type of the transaction data\r\n */\r\nexport type TxScopeType<T> =\r\n  | TxScope<T, StateOpened>\r\n  | TxScope<T, StateCommit>\r\n  | TxScope<T, StateRollback>;\r\n\r\n/**\r\n * Commits a synchronous transaction scope.\r\n * @typeParam T - The type of the transaction data\r\n * @param resource - The opened synchronous transaction scope\r\n * @returns The committed transaction scope\r\n * @throws Error if resource is already disposed/committed/rolled back\r\n */\r\nexport function commit<T>(\r\n  resource: TxScope<T, StateOpened>,\r\n): TxScope<T, StateCommit> {\r\n  if (resource[_data] === NONE) {\r\n    throw new UseAfterFreeError(\r\n      'Resource already closed/committed/rolled back.',\r\n    );\r\n  }\r\n  resource[_rollbackup] = undefined;\r\n  if (resource[_commitup]) {\r\n    resource[_commitup](resource[_data] as T);\r\n  }\r\n  resource[Symbol.dispose]();\r\n  return resource as unknown as TxScope<T, StateCommit>;\r\n}\r\n\r\n/**\r\n * Rolls back a synchronous transaction scope.\r\n * @typeParam T - The type of the transaction data\r\n * @param resource - The opened synchronous transaction scope\r\n * @returns The rolled back transaction scope\r\n * @throws Error if resource is already disposed/committed/rolled back\r\n */\r\nexport function rollback<T>(\r\n  resource: TxScope<T, StateOpened>,\r\n): TxScope<T, StateRollback> {\r\n  if (resource[_data] === NONE) {\r\n    throw new UseAfterFreeError(\r\n      'Resource already closed/committed/rolled back.',\r\n    );\r\n  }\r\n  const fn = resource[_rollbackup];\r\n  resource[_rollbackup] = undefined;\r\n  if (fn) {\r\n    fn(resource[_data] as T); // 即使这里失败了，回滚函数已经是undefined了，不会二次错误\r\n  }\r\n  resource[Symbol.dispose]();\r\n  return resource as unknown as TxScope<T, StateRollback>;\r\n}\r\n\r\n/**\r\n * Uses a synchronous transaction scope with a callback function.\r\n * @typeParam T - The type of the transaction data\r\n * @typeParam R - The return type of the callback\r\n * @param TxScope - The opened synchronous transaction scope\r\n * @param fn - Function to process the transaction data\r\n * @returns The result of the callback\r\n * @throws Error if transaction scope is already disposed\r\n */\r\nexport function use<T, R>(\r\n  TxScope: TxScope<T, StateOpened>,\r\n  fn: (data: T) => R,\r\n): R {\r\n  if (TxScope[_data] === NONE) {\r\n    throw new UseAfterFreeError('Resource already disposed.');\r\n  }\r\n  return fn(TxScope[_data] as T);\r\n}\r\n\r\n/**\r\n * Performs a side effect on a synchronous transaction scope and returns it.\r\n * @typeParam T - The type of the transaction data\r\n * @typeParam R - The return type of the side effect function\r\n * @param TxScope - The opened synchronous transaction scope\r\n * @param fn - Side effect function to execute\r\n * @returns The same transaction scope after executing the side effect\r\n * @throws Error if transaction scope is already disposed\r\n */\r\nexport function exec<T, R>(\r\n  TxScope: TxScope<T, StateOpened>,\r\n  fn: (data: T) => R,\r\n): TxScope<T, StateOpened> {\r\n  if (TxScope[_data] === NONE) {\r\n    throw new UseAfterFreeError('Resource already disposed.');\r\n  }\r\n  fn(TxScope[_data] as T);\r\n  return TxScope;\r\n}\r\n\r\n/**\r\n * Reopens a committed or rolled back synchronous transaction scope with new data.\r\n * @typeParam T - The type of the transaction data\r\n * @param TxScope - The committed or rolled back synchronous transaction scope\r\n * @param data - New data for the transaction scope\r\n * @param cleaner - Optional new cleanup function\r\n * @param commiter - Optional new commit function\r\n * @param rollbacker - Optional new rollback function\r\n * @returns The reopened synchronous transaction scope\r\n */\r\nexport function reopen<T>(\r\n  TxScope: TxScope<T, StateCommit> | TxScope<T, StateRollback>,\r\n  data: T,\r\n  cleaner?: Cleaner<T>,\r\n  commiter?: CommitUp<T>,\r\n  rollbacker?: RollbackUp<T>,\r\n): TxScope<T, StateOpened> {\r\n  const r = TxScope as unknown as TxScope<T, StateOpened>;\r\n  r[_data] = data;\r\n  r[_cleanup] = cleaner;\r\n  r[_commitup] = commiter;\r\n  r[_rollbackup] = rollbacker;\r\n  return r;\r\n}\r\n","// ========================================\r\n// ./src/Resource/TxScope-async.ts\r\n// ========================================\r\n/* eslint-disable @typescript-eslint/no-unnecessary-type-assertion */\r\n\r\nimport {\r\n  type StateOpened,\r\n  type StateCommit,\r\n  type StateRollback,\r\n  type AnyCleaner,\r\n  type AsyncCommitUp,\r\n  type AnyRollbackUp,\r\n  type NoneType,\r\n  NONE,\r\n} from './types';\r\nimport {UseAfterFreeError} from '../Errors';\r\n\r\n// ------ 私有符号定义 ------\r\nconst _data = Symbol('Data');\r\nconst _cleanup = Symbol('AsyncCleanup');\r\nconst _commitup = Symbol('AsyncCommit');\r\nconst _rollbackup = Symbol('AsyncRollback');\r\n\r\n/**\r\n * Asynchronous transaction scope management class.\r\n * @typeParam T - The type of the transaction data\r\n * @typeParam S - The state type (opened, commit, or rollback)\r\n */\r\nexport class AsyncTxScope<\r\n  T,\r\n  S extends StateOpened | StateCommit | StateRollback,\r\n> {\r\n  declare private state: S;\r\n  public [_data]: T | NoneType;\r\n  public [_cleanup]: AnyCleaner<T> | undefined;\r\n  public [_commitup]: AsyncCommitUp<T> | undefined;\r\n  public [_rollbackup]: AnyRollbackUp<T> | undefined;\r\n\r\n  // ------ 构造函数 ------\r\n  private constructor(\r\n    data: T,\r\n    cleanup_fn?: AnyCleaner<T>,\r\n    commitup_fn?: AsyncCommitUp<T>,\r\n    rollbackup_fn?: AnyRollbackUp<T>,\r\n  ) {\r\n    this[_data] = data;\r\n    this[_cleanup] = cleanup_fn;\r\n    this[_commitup] = commitup_fn;\r\n    this[_rollbackup] = rollbackup_fn;\r\n  }\r\n\r\n  /**\r\n   * Creates a new opened asynchronous transaction scope.\r\n   * @typeParam D - The type of the transaction data\r\n   * @param data - The transaction data\r\n   * @param cleaner - Optional asynchronous cleanup function\r\n   * @param commiter - Optional asynchronous commit function\r\n   * @param rollbacker - Optional asynchronous rollback function\r\n   * @returns A new opened asynchronous transaction scope\r\n   */\r\n  static open<D>(\r\n    data: D,\r\n    cleaner?: AnyCleaner<D>,\r\n    commiter?: AsyncCommitUp<D>,\r\n    rollbacker?: AnyRollbackUp<D>,\r\n  ): AsyncTxScope<D, StateOpened> {\r\n    return new AsyncTxScope(data, cleaner, commiter, rollbacker);\r\n  }\r\n\r\n  /**\r\n   * Asynchronously disposes the transaction scope (cleanup with rollback).\r\n   * @returns Promise that resolves when disposal is complete\r\n   */\r\n  async [Symbol.asyncDispose](\r\n    this: AsyncTxScope<T, StateOpened>,\r\n  ): Promise<void> {\r\n    if (this[_data] === NONE) {\r\n      return;\r\n    }\r\n    // 如果事务未被 commit/rollback 清理，则在 dispose 时执行异步回滚。\r\n    if (this[_rollbackup]) {\r\n      await this[_rollbackup](this[_data] as T); // 强制等待异步回滚\r\n    }\r\n    if (this[_cleanup]) {\r\n      await this[_cleanup](this[_data] as T); // 强制等待异步清理\r\n    }\r\n    this[_data] = NONE;\r\n  }\r\n}\r\n\r\n/**\r\n * Union type for asynchronous transaction scope states.\r\n * @typeParam T - The type of the transaction data\r\n */\r\nexport type AsyncTxScopeType<T> =\r\n  | AsyncTxScope<T, StateOpened>\r\n  | AsyncTxScope<T, StateCommit>\r\n  | AsyncTxScope<T, StateRollback>;\r\n\r\n/**\r\n * Commits an asynchronous transaction scope.\r\n * @typeParam T - The type of the transaction data\r\n * @param resource - The opened asynchronous transaction scope\r\n * @returns Promise with the committed transaction scope\r\n * @throws Error if resource is already disposed/committed/rolled back\r\n */\r\nexport async function commitAsync<T>(\r\n  resource: AsyncTxScope<T, StateOpened>,\r\n): Promise<AsyncTxScope<T, StateCommit>> {\r\n  if (resource[_data] === NONE) {\r\n    throw new UseAfterFreeError(\r\n      'Resource already closed/committed/rolled back.',\r\n    );\r\n  }\r\n  if (resource[_commitup]) {\r\n    await resource[_commitup](resource[_data] as T);\r\n  }\r\n  resource[_rollbackup] = undefined;\r\n  await resource[Symbol.asyncDispose]();\r\n  return resource as unknown as AsyncTxScope<T, StateCommit>;\r\n}\r\n\r\n/**\r\n * Rolls back an asynchronous transaction scope.\r\n * @typeParam T - The type of the transaction data\r\n * @param resource - The opened asynchronous transaction scope\r\n * @returns Promise with the rolled back transaction scope\r\n * @throws Error if resource is already disposed/committed/rolled back\r\n */\r\nexport async function rollbackAsync<T>(\r\n  resource: AsyncTxScope<T, StateOpened>,\r\n): Promise<AsyncTxScope<T, StateRollback>> {\r\n  if (resource[_data] === NONE) {\r\n    throw new UseAfterFreeError(\r\n      'Resource already closed/committed/rolled back.',\r\n    );\r\n  }\r\n  const fn = resource[_rollbackup];\r\n  resource[_rollbackup] = undefined;\r\n  if (fn) {\r\n    await fn(resource[_data] as T);\r\n  }\r\n  resource[_rollbackup] = undefined;\r\n  await resource[Symbol.asyncDispose]();\r\n  return resource as unknown as AsyncTxScope<T, StateRollback>;\r\n}\r\n\r\n/**\r\n * Uses an asynchronous transaction scope with a callback function.\r\n * @typeParam T - The type of the transaction data\r\n * @typeParam R - The return type of the callback\r\n * @param TxScope - The opened asynchronous transaction scope\r\n * @param fn - Function to process the transaction data\r\n * @returns Promise with the result of the callback\r\n * @throws Error if transaction scope is already disposed\r\n */\r\nexport async function useAsync<T, R>(\r\n  TxScope: AsyncTxScope<T, StateOpened>,\r\n  fn: (data: T) => Promise<R> | R,\r\n): Promise<R> {\r\n  if (TxScope[_data] === NONE) {\r\n    throw new UseAfterFreeError('Resource already disposed.');\r\n  }\r\n  return await fn(TxScope[_data] as T);\r\n}\r\n\r\n/**\r\n * Performs a side effect on an asynchronous transaction scope and returns it.\r\n * @typeParam T - The type of the transaction data\r\n * @typeParam R - The return type of the side effect function\r\n * @param TxScope - The opened asynchronous transaction scope\r\n * @param fn - Side effect function to execute\r\n * @returns The same transaction scope after executing the side effect\r\n * @throws Error if transaction scope is already disposed\r\n */\r\nexport async function execAsync<T, R>(\r\n  TxScope: AsyncTxScope<T, StateOpened>,\r\n  fn: (data: T) => Promise<R> | R,\r\n): Promise<AsyncTxScope<T, StateOpened>> {\r\n  if (TxScope[_data] === NONE) {\r\n    throw new UseAfterFreeError('Resource already disposed.');\r\n  }\r\n  await fn(TxScope[_data] as T);\r\n  return TxScope;\r\n}\r\n\r\n/**\r\n * Reopens a committed or rolled back asynchronous transaction scope with new data.\r\n * @typeParam T - The type of the transaction data\r\n * @param TxScope - The committed or rolled back asynchronous transaction scope\r\n * @param data - New data for the transaction scope\r\n * @param cleaner - Optional new cleanup function\r\n * @param commiter - Optional new commit function\r\n * @param rollbacker - Optional new rollback function\r\n * @returns The reopened asynchronous transaction scope\r\n */\r\nexport function reopenAsync<T>(\r\n  TxScope: AsyncTxScope<T, StateCommit> | AsyncTxScope<T, StateRollback>,\r\n  data: T,\r\n  cleaner?: AnyCleaner<T>,\r\n  commiter?: AsyncCommitUp<T>,\r\n  rollbacker?: AnyRollbackUp<T>,\r\n): AsyncTxScope<T, StateOpened> {\r\n  const r = TxScope as unknown as AsyncTxScope<T, StateOpened>;\r\n  r[_data] = data;\r\n  r[_cleanup] = cleaner;\r\n  r[_commitup] = commiter;\r\n  r[_rollbackup] = rollbacker;\r\n  return r;\r\n}\r\n"],"names":["_data","_cleanup","_commitup","_rollbackup","TxScope","data","cleanup_fn","commitup_fn","rollbackup_fn","cleaner","commiter","rollbacker","NONE","commit","resource","UseAfterFreeError","rollback","fn","use","exec","reopen","r","AsyncTxScope","commitAsync","rollbackAsync","useAsync","execAsync","reopenAsync"],"mappings":"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"}

package/dist/subpath/Result.cjs

@@ -0,0 +1,2 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const c=require("../chunks/base-BTXL1y_I.cjs"),s=require("../chunks/helper-tsqZMRHW.cjs"),e=require("../chunks/combine-async-DcG-3p8i.cjs");function l(n,{fnOk:r=()=>{},fnErr:o=()=>{}}){return n.ok?r(n.value):o(n.error),n}function y(n,r){return n.ok||r(n.error),n}function f(n,r){return n.ok&&r(n.value),n}async function p(n,{fnOk:r=()=>{},fnErr:o=()=>{}},t){if(t?.aborted)return c.Err(s.ensureDOMException(t.reason));const a=await n;try{a.ok?await r(a.value,t):await o(a.error,t)}catch(i){return c.Err(s.wrapError(i))}return a}async function m(n,r,o){if(o?.aborted)return c.Err(s.ensureDOMException(o.reason));const t=await n;if(!t.ok)try{await r(t.error,o)}catch(a){return c.Err(s.wrapError(a))}return t}async function A(n,r,o){if(o?.aborted)return c.Err(s.ensureDOMException(o.reason));const t=await n;if(t.ok)try{await r(t.value,o)}catch(a){return c.Err(s.wrapError(a))}return t}async function E(n,r,o,t){const a=await n;if(a.ok)try{return await s.dynamicAwait(r(a.value,t))}catch(i){return s.UnknownError.from(i)}else try{return await s.dynamicAwait(o(a.error,t))}catch(i){return s.UnknownError.from(i)}}async function k(n,r,o){const t=await n;if(t.ok)try{return await s.dynamicAwait(r(t.value))}catch(a){return s.UnknownError.from(a)}else{if(o)try{return await s.dynamicAwait(o(t.error))}catch(a){return s.UnknownError.from(a)}return}}async function d(n,r,o){const t=await n;if(t.ok){if(o)try{return await s.dynamicAwait(o(t.value))}catch(a){return s.UnknownError.from(a)}return}else try{return await s.dynamicAwait(r(t.error))}catch(a){return s.UnknownError.from(a)}}async function w(n,r,o){const t=await n;if(t.ok)try{return await s.dynamicAwait(o(t.value))}catch(a){return s.UnknownError.from(a)}else try{return await s.dynamicAwait(r(t.error))}catch(a){return s.UnknownError.from(a)}}function h(n,r,o){let t=r;for(const a of n){if(!a.ok)return c.Err(a.error);t=o(t,a.value)}return c.Ok(t)}const O=n=>n.filter(r=>r.ok).map(r=>r.value),_=n=>n.filter(r=>!r.ok).map(r=>r.error);function v(n){const r=[],o=[];for(const t of n)t.ok?r.push(t.value):o.push(t.error);return[r,o]}function x(n){if(c.isOk(n)){const r=n.value;return s.isResultLike(r)?r:n}return n}function z(n){let r=n;for(;c.isOk(r);){const o=r.value;if(!s.isResultLike(o))return r;r=o}return r}async function b(n){let r=await n;for(;c.isOk(r);){let o=r.value;if(s.isPromiseLike(o)&&(o=await o),!s.isResultLike(o))return r;r=o}return r}async function P(n,r,o,t){if(t?.aborted)return c.Err(s.ensureDOMException(t.reason));let a=r;for(const i of n){const u=await c.normalizeToResult(i);if(t?.aborted)return c.Err(s.ensureDOMException(t.reason));if(!u.ok)return c.Err(u.error);try{if(a=await o(a,u.value,t),t?.aborted)return c.Err(s.ensureDOMException(t.reason))}catch(M){return c.Err(s.wrapError(M))}}return c.Ok(a)}async function T(n,r){if(r?.aborted)return Promise.reject(s.ensureDOMException(r.reason));const o=n.map(i=>c.normalizeToResult(i)),t=await Promise.all(o),a=[];for(const i of t){if(r?.aborted)return Promise.reject(s.ensureDOMException(r.reason));i.ok&&a.push(i.value)}return a}async function R(n,r){if(r?.aborted)return Promise.reject(s.ensureDOMException(r.reason));const o=n.map(i=>c.normalizeToResult(i)),t=await Promise.all(o),a=[];for(const i of t){if(r?.aborted)throw r.reason;i.ok||a.push(i.error)}return a}async function B(n,r){if(r?.aborted)return Promise.reject(s.ensureDOMException(r.reason));const o=n.map(u=>c.normalizeToResult(u)),t=await Promise.all(o),a=[],i=[];for(const u of t){if(r?.aborted)throw r.reason;u.ok?a.push(u.value):i.push(u.error)}return[a,i]}const D=Object.freeze(Object.defineProperty({__proto__:null,Err:c.Err,Ok:c.Ok,all:e.all,allAsync:e.allAsync,and:e.and,andAsync:e.andAsync,andThen:e.andThen,andThenAsync:e.andThenAsync,ap:e.ap,apAsync:e.apAsync,collectErr:_,collectErrAsync:R,collectOk:O,collectOkAsync:T,deepFlatten:z,deepFlattenAsync:b,filter:e.filter,filterAsync:e.filterAsync,flatten:x,fromPromise:c.fromPromise,ifErr:e.ifErr,ifErrAsync:d,ifOk:e.ifOk,ifOkAsync:k,isErr:c.isErr,isErrAnd:c.isErrAnd,isOk:c.isOk,isOkAnd:c.isOkAnd,map:e.map,mapAll:e.mapAll,mapAsync:e.mapAsync,mapBoth:e.mapBoth,mapBothAsync:e.mapBothAsync,mapErr:e.mapErr,mapErrAsync:e.mapErrAsync,mapOrElse:e.mapOrElse,mapOrElseAsync:w,match:e.match,matchResultAsync:E,normalizeToResult:c.normalizeToResult,or:e.or,orAsync:e.orAsync,orElse:e.orElse,orElseAsync:e.orElseAsync,partition:v,partitionAsync:B,peekBoth:l,peekBothAsync:p,peekErr:y,peekErrAsync:m,peekOk:f,peekOkAsync:A,recover:e.recover,recoverAsync:e.recoverAsync,reduce:h,reduceAsync:P,safeExecute:c.safeExecute,safeExecuteAsync:c.safeExecuteAsync,sequenceAsync:e.sequenceAsync,toPromise:c.toPromise,zip:e.zip,zipAsync:e.zipAsync},Symbol.toStringTag,{value:"Module"}));exports.Err=c.Err;exports.Ok=c.Ok;exports.fromPromise=c.fromPromise;exports.isErr=c.isErr;exports.isErrAnd=c.isErrAnd;exports.isOk=c.isOk;exports.isOkAnd=c.isOkAnd;exports.normalizeToResult=c.normalizeToResult;exports.safeExecute=c.safeExecute;exports.safeExecuteAsync=c.safeExecuteAsync;exports.toPromise=c.toPromise;exports.all=e.all;exports.allAsync=e.allAsync;exports.and=e.and;exports.andAsync=e.andAsync;exports.andThen=e.andThen;exports.andThenAsync=e.andThenAsync;exports.ap=e.ap;exports.apAsync=e.apAsync;exports.filter=e.filter;exports.filterAsync=e.filterAsync;exports.ifErr=e.ifErr;exports.ifOk=e.ifOk;exports.map=e.map;exports.mapAll=e.mapAll;exports.mapAsync=e.mapAsync;exports.mapBoth=e.mapBoth;exports.mapBothAsync=e.mapBothAsync;exports.mapErr=e.mapErr;exports.mapErrAsync=e.mapErrAsync;exports.mapOrElse=e.mapOrElse;exports.match=e.match;exports.or=e.or;exports.orAsync=e.orAsync;exports.orElse=e.orElse;exports.orElseAsync=e.orElseAsync;exports.recover=e.recover;exports.recoverAsync=e.recoverAsync;exports.sequenceAsync=e.sequenceAsync;exports.zip=e.zip;exports.zipAsync=e.zipAsync;exports.__export__=D;exports.collectErr=_;exports.collectErrAsync=R;exports.collectOk=O;exports.collectOkAsync=T;exports.deepFlatten=z;exports.deepFlattenAsync=b;exports.flatten=x;exports.ifErrAsync=d;exports.ifOkAsync=k;exports.mapOrElseAsync=w;exports.matchResultAsync=E;exports.partition=v;exports.partitionAsync=B;exports.peekBoth=l;exports.peekBothAsync=p;exports.peekErr=y;exports.peekErrAsync=m;exports.peekOk=f;exports.peekOkAsync=A;exports.reduce=h;exports.reduceAsync=P;
+//# sourceMappingURL=Result.cjs.map

package/dist/subpath/Result.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"Result.cjs","sources":["../../src/Result/Consumers/inspect.ts","../../src/Result/Consumers/branch-async.ts","../../src/Result/Operators/reduce.ts","../../src/Result/Operators/partition.ts","../../src/Result/Operators/flatten.ts","../../src/Result/Operators/Async/reduce-async.ts","../../src/Result/Operators/Async/partition-async.ts"],"sourcesContent":["// ========================================\r\n// ./src/Result/Consumers/inspect.ts\r\n// ========================================\r\n\r\nimport type {AnyResult, Result} from '../types';\r\nimport {UnknownError, ensureDOMException} from '../../unknown-error';\r\nimport {Err} from '../base';\r\nimport {wrapError} from '../../helper';\r\nimport type {MaybePromise} from '../../Utils/type-tool';\r\n\r\n/**\r\n * Returns the Result as is, regardless of its state. Used for side effects (e.g., logging) on both Success/Failure paths.\r\n * @typeParam T - The type of the success value\r\n * @typeParam E - The type of the error\r\n * @param result - The Result to peek\r\n * @param options - Options object containing optional side-effect functions\r\n * @returns The unchanged Result\r\n */\r\nexport function peekBoth<T, E>(\r\n  result: Result<T, E>,\r\n  {\r\n    fnOk = () => {},\r\n    fnErr = () => {},\r\n  }: {\r\n    fnOk?: (value: T) => void;\r\n    fnErr?: (error: E) => void;\r\n  },\r\n): Result<T, E> {\r\n  if (result.ok) {\r\n    fnOk(result.value);\r\n  } else {\r\n    fnErr(result.error);\r\n  }\r\n  return result;\r\n}\r\n\r\n/**\r\n * Executes the fnErr function as a side effect if the Result is Failure; then returns the Result as is.\r\n * @typeParam T - The type of the success value\r\n * @typeParam E - The type of the error\r\n * @param result - The Result to peek\r\n * @param fnErr - The side-effect function to execute on Failure\r\n * @returns The unchanged Result\r\n */\r\nexport function peekErr<T, E>(\r\n  result: Result<T, E>,\r\n  fnErr: (error: E) => void,\r\n): Result<T, E> {\r\n  if (!result.ok) {\r\n    fnErr(result.error);\r\n  }\r\n  return result;\r\n}\r\n\r\n/**\r\n * Executes the fnOk function as a side effect if the Result is Success; then returns the Result as is.\r\n * @typeParam T - The type of the success value\r\n * @typeParam E - The type of the error\r\n * @param result - The Result to peek\r\n * @param fnOk - The side-effect function to execute on Success\r\n * @returns The unchanged Result\r\n */\r\nexport function peekOk<T, E>(\r\n  result: Result<T, E>,\r\n  fnOk: (value: T) => void,\r\n): Result<T, E> {\r\n  if (result.ok) {\r\n    fnOk(result.value);\r\n  }\r\n  return result;\r\n}\r\n\r\n/**\r\n * Asynchronously executes side effects for both Success/Failure paths, and returns the AsyncResult unchanged.\r\n * @typeParam T - The type of the success value\r\n * @typeParam E - The type of the error\r\n * @param result_promise - The Result or Promise<Result> to peek\r\n * @param options - Options object containing optional side-effect functions\r\n * @param signal - Optional AbortSignal for cancellation\r\n * @returns A Promise containing the original Result, or an UnknownError if a side effect throws\r\n */\r\nexport async function peekBothAsync<T, E>(\r\n  result_promise: AnyResult<T, E>,\r\n  {\r\n    fnOk = () => {},\r\n    fnErr = () => {},\r\n  }: {\r\n    fnOk?: (value: T, signal?: AbortSignal) => MaybePromise<void>;\r\n    fnErr?: (error: E, signal?: AbortSignal) => MaybePromise<void>;\r\n  },\r\n  signal?: AbortSignal,\r\n): Promise<Result<T, E | DOMException | UnknownError>> {\r\n  if (signal?.aborted) return Err(ensureDOMException(signal.reason));\r\n  const result = await result_promise;\r\n\r\n  try {\r\n    if (result.ok) {\r\n      await fnOk(result.value, signal);\r\n    } else {\r\n      await fnErr(result.error, signal);\r\n    }\r\n  } catch (raw_error) {\r\n    return Err(wrapError(raw_error));\r\n  }\r\n\r\n  return result;\r\n}\r\n\r\n/**\r\n * Asynchronously executes fnErr as a side effect if the Result is Failure; then returns the Result unchanged.\r\n * @typeParam T - The type of the success value\r\n * @typeParam E - The type of the error\r\n * @param result_promise - The Result or Promise<Result> to peek\r\n * @param fnErr - The side-effect function to execute on Failure\r\n * @param signal - Optional AbortSignal for cancellation\r\n * @returns A Promise containing the original Result, or an UnknownError if fnErr throws\r\n */\r\nexport async function peekErrAsync<T, E>(\r\n  result_promise: AnyResult<T, E>,\r\n  fnErr: (error: E, signal?: AbortSignal) => MaybePromise<void>,\r\n  signal?: AbortSignal,\r\n): Promise<Result<T, E | DOMException | UnknownError>> {\r\n  if (signal?.aborted) return Err(ensureDOMException(signal.reason));\r\n  const result = await result_promise;\r\n\r\n  if (!result.ok) {\r\n    try {\r\n      await fnErr(result.error, signal);\r\n    } catch (raw_error) {\r\n      return Err(wrapError(raw_error));\r\n    }\r\n  }\r\n  return result;\r\n}\r\n\r\n/**\r\n * Asynchronously executes fnOk as a side effect if the Result is Success; then returns the Result unchanged.\r\n * @typeParam T - The type of the success value\r\n * @typeParam E - The type of the error\r\n * @param result_promise - The Result or Promise<Result> to peek\r\n * @param fnOk - The side-effect function to execute on Success\r\n * @param signal - Optional AbortSignal for cancellation\r\n * @returns A Promise containing the original Result, or an UnknownError if fnOk throws\r\n */\r\nexport async function peekOkAsync<T, E>(\r\n  result_promise: AnyResult<T, E>,\r\n  fnOk: (value: T, signal?: AbortSignal) => MaybePromise<void>,\r\n  signal?: AbortSignal,\r\n): Promise<Result<T, E | DOMException | UnknownError>> {\r\n  if (signal?.aborted) return Err(ensureDOMException(signal.reason));\r\n  const result = await result_promise;\r\n\r\n  if (result.ok) {\r\n    try {\r\n      await fnOk(result.value, signal);\r\n    } catch (raw_error) {\r\n      return Err(wrapError(raw_error));\r\n    }\r\n  }\r\n  return result;\r\n}\r\n","// ========================================\r\n// ./src/Result/Consumers/branch-async.ts\r\n// ========================================\r\nimport type {AnyResult} from '../types';\r\nimport {UnknownError} from '../../unknown-error';\r\nimport type {MaybePromise} from '../../Utils/type-tool';\r\nimport {dynamicAwait} from '../../helper';\r\n\r\n/**\r\n * Asynchronously executes different callback functions based on the Result state and returns Promise<R>.\r\n * Catches exceptions thrown by the callbacks.\r\n * @typeParam T - The type of the success value\r\n * @typeParam E - The type of the error\r\n * @typeParam R - The type of the return value\r\n * @param result_promise - The Result or Promise<Result> to match\r\n * @param onOk - The callback function for a successful state (Ok)\r\n * @param onErr - The callback function for a failure state (Err)\r\n * @param signal - Optional AbortSignal for cancellation\r\n * @returns The Promise resolving to the return value of onOk or onErr, or an UnknownError if a callback throws\r\n */\r\nexport async function matchResultAsync<T, E, R>(\r\n  result_promise: AnyResult<T, E>,\r\n  onOk: (value: T, signal?: AbortSignal) => MaybePromise<R>,\r\n  onErr: (error: E, signal?: AbortSignal) => MaybePromise<R>,\r\n  signal?: AbortSignal,\r\n): Promise<R | UnknownError> {\r\n  const result = await result_promise;\r\n\r\n  if (result.ok) {\r\n    try {\r\n      return await dynamicAwait(onOk(result.value, signal));\r\n    } catch (raw_error) {\r\n      return UnknownError.from(raw_error);\r\n    }\r\n  } else {\r\n    try {\r\n      return await dynamicAwait(onErr(result.error, signal));\r\n    } catch (raw_error) {\r\n      return UnknownError.from(raw_error);\r\n    }\r\n  }\r\n}\r\n/**\r\n * Asynchronously executes onOk if the Result is **Ok**; executes the optional onElse if **Err**.\r\n * All exceptions thrown by the callbacks are caught and wrapped as UnknownError.\r\n * @typeParam T - The type of the **Success Value** in the **Ok state**.\r\n * @typeParam E - The type of the **Error** in the **Err state**.\r\n * @typeParam R1 - The final resolved return type of the **onOk** callback.\r\n * @param result_promise - The Result object or Promise<Result> to be checked.\r\n * @param onOk - The callback executed if the Result is Ok. Returns R1 or Promise<R1>.\r\n * @returns A Promise that resolves to the result of onOk (R1), or UnknownError if a callback throws, or **void** if the Result is Err.\r\n */\r\nexport async function ifOkAsync<T, E, R1>(\r\n  result_promise: AnyResult<T, E>,\r\n  onOk: (value: T) => MaybePromise<R1>,\r\n): Promise<R1 | UnknownError | void>;\r\n\r\n/**\r\n * Asynchronously executes onOk if the Result is **Ok**; executes onElse if **Err**.\r\n * All exceptions thrown by the callbacks are caught and wrapped as UnknownError.\r\n * @typeParam T - The type of the **Success Value** in the **Ok state**.\r\n * @typeParam E - The type of the **Error** in the **Err state**.\r\n * @typeParam R1 - The final resolved return type of the **onOk** callback.\r\n * @typeParam R2 - The final resolved return type of the **onElse** callback.\r\n * @param result_promise - The Result object or Promise<Result> to be checked.\r\n * @param onOk - The callback executed if the Result is Ok. Returns R1 or Promise<R1>.\r\n * @param onElse - The callback executed if the Result is Err. Returns R2 or Promise<R2>.\r\n * @returns A Promise that resolves to the result of onOk or onElse (R1 or R2), or UnknownError if a callback throws.\r\n */\r\nexport async function ifOkAsync<T, E, R1, R2>(\r\n  result_promise: AnyResult<T, E>,\r\n  onOk: (value: T) => MaybePromise<R1>,\r\n  onElse: (error: E) => MaybePromise<R2>,\r\n): Promise<R1 | R2 | UnknownError>;\r\n\r\nexport async function ifOkAsync<T, E, R1, R2 = void>(\r\n  result_promise: AnyResult<T, E>,\r\n  onOk: (value: T) => MaybePromise<R1>,\r\n  onElse?: (error: E) => MaybePromise<R2>,\r\n): Promise<R1 | R2 | UnknownError | void> {\r\n  const result = await result_promise;\r\n\r\n  if (result.ok) {\r\n    try {\r\n      return await dynamicAwait(onOk(result.value));\r\n    } catch (raw_error) {\r\n      return UnknownError.from(raw_error);\r\n    }\r\n  } else {\r\n    if (onElse) {\r\n      try {\r\n        return await dynamicAwait(onElse(result.error));\r\n      } catch (raw_error) {\r\n        return UnknownError.from(raw_error);\r\n      }\r\n    }\r\n    return;\r\n  }\r\n}\r\n\r\n/**\r\n * Asynchronously executes onErr if the Result is **Err**; executes the optional onElse if **Ok**.\r\n * All exceptions thrown by the callbacks are caught and wrapped as UnknownError.\r\n * @typeParam T - The type of the **Success Value** in the **Ok state**.\r\n * @typeParam E - The type of the **Error** in the **Err state**.\r\n * @typeParam R1 - The final resolved return type of the **onErr** callback.\r\n * @param result_promise - The Result object or Promise<Result> to be checked.\r\n * @param onErr - The callback executed if the Result is Err. Returns R1 or Promise<R1>.\r\n * @returns A Promise that resolves to the result of onErr (R1), or UnknownError if a callback throws, or **void** if the Result is Ok.\r\n */\r\nexport async function ifErrAsync<T, E, R1>(\r\n  result_promise: AnyResult<T, E>,\r\n  onErr: (error: E) => MaybePromise<R1>,\r\n): Promise<R1 | UnknownError | void>;\r\n\r\n/**\r\n * Asynchronously executes onErr if the Result is **Err**; executes onElse if **Ok**.\r\n * All exceptions thrown by the callbacks are caught and wrapped as UnknownError.\r\n * @typeParam T - The type of the **Success Value** in the **Ok state**.\r\n * @typeParam E - The type of the **Error** in the **Err state**.\r\n * @typeParam R1 - The final resolved return type of the **onErr** callback.\r\n * @typeParam R2 - The final resolved return type of the **onElse** callback.\r\n * @param result_promise - The Result object or Promise<Result> to be checked.\r\n * @param onErr - The callback executed if the Result is Err. Returns R1 or Promise<R1>.\r\n * @param onElse - The callback executed if the Result is Ok. Returns R2 or Promise<R2>.\r\n * @returns A Promise that resolves to the result of onErr or onElse (R1 or R2), or UnknownError if a callback throws.\r\n */\r\nexport async function ifErrAsync<T, E, R1, R2>(\r\n  result_promise: AnyResult<T, E>,\r\n  onErr: (error: E) => MaybePromise<R1>,\r\n  onElse: (value: T) => MaybePromise<R2>,\r\n): Promise<R1 | R2 | UnknownError>;\r\n\r\nexport async function ifErrAsync<T, E, R1, R2 = void>(\r\n  result_promise: AnyResult<T, E>,\r\n  onErr: (error: E) => MaybePromise<R1>,\r\n  onElse?: (value: T) => MaybePromise<R2>,\r\n): Promise<R1 | R2 | UnknownError | void> {\r\n  const result = await result_promise;\r\n\r\n  if (!result.ok) {\r\n    try {\r\n      return await dynamicAwait(onErr(result.error));\r\n    } catch (raw_error) {\r\n      return UnknownError.from(raw_error);\r\n    }\r\n  } else {\r\n    if (onElse) {\r\n      try {\r\n        return await dynamicAwait(onElse(result.value));\r\n      } catch (raw_error) {\r\n        return UnknownError.from(raw_error);\r\n      }\r\n    }\r\n    return;\r\n  }\r\n}\r\n\r\n/**\r\n * Asynchronously transforms the Result into a single type R.\r\n * Uses mapFn on Success; uses defaultFn on Failure.\r\n * Catches exceptions thrown by the callbacks.\r\n * @typeParam T - The type of the success value\r\n * @typeParam E - The type of the error\r\n * @typeParam R - The type of the final return value\r\n * @param result_promise - The Result or Promise<Result> to process\r\n * @param defaultFn - The function to compute the default value on failure\r\n * @param mapFn - The function to map the success value\r\n * @returns The Promise resolving to the final return value, or an UnknownError if a callback throws\r\n */\r\nexport async function mapOrElseAsync<T, E, R>(\r\n  result_promise: AnyResult<T, E>,\r\n  defaultFn: (error: E) => MaybePromise<R>,\r\n  mapFn: (value: T) => MaybePromise<R>,\r\n): Promise<R | UnknownError> {\r\n  const result = await result_promise;\r\n\r\n  if (result.ok) {\r\n    try {\r\n      return await dynamicAwait(mapFn(result.value));\r\n    } catch (raw_error) {\r\n      return UnknownError.from(raw_error);\r\n    }\r\n  } else {\r\n    try {\r\n      return await dynamicAwait(defaultFn(result.error));\r\n    } catch (raw_error) {\r\n      return UnknownError.from(raw_error);\r\n    }\r\n  }\r\n}\r\n","// ========================================\r\n// ./src/Result/Operators/reduce.ts\r\n// ========================================\r\nimport type {Result} from '../types';\r\nimport {Ok, Err} from '../base';\r\n\r\n/**\r\n * Reduces multiple Results into a single Result, collecting all success values or the first error (short-circuit).\r\n * @typeParam T - The type of the success value\r\n * @typeParam E - The type of the error\r\n * @typeParam R - The type of the reduced result\r\n * @param results - The array of Results to reduce\r\n * @param initial - The initial value\r\n * @param reducer - The reduction function\r\n * @returns A Result containing the reduced result\r\n */\r\nexport function reduce<T, E, R>(\r\n  results: readonly Result<T, E>[],\r\n  initial: R,\r\n  reducer: (accumulator: R, value: T) => R,\r\n): Result<R, E> {\r\n  let accumulator = initial;\r\n\r\n  for (const result of results) {\r\n    if (!result.ok) {\r\n      return Err(result.error);\r\n    }\r\n    accumulator = reducer(accumulator, result.value);\r\n  }\r\n\r\n  return Ok(accumulator);\r\n}\r\n","// ========================================\r\n// ./src/Result/Operators/partition.ts\r\n// ========================================\r\nimport type {Result} from '../types';\r\n\r\n/**\r\n * Collects all success values from an array of Results.\r\n * @typeParam T - The type of the success value\r\n * @typeParam E - The type of the error\r\n * @param results - The array of Results\r\n * @returns An array of collected success values\r\n */\r\nexport const collectOk = <T, E>(results: readonly Result<T, E>[]): T[] =>\r\n  results\r\n    .filter((result): result is {ok: true; value: T} => result.ok)\r\n    .map((result) => result.value);\r\n\r\n/**\r\n * Collects all failure errors from an array of Results.\r\n * @typeParam T - The type of the success value\r\n * @typeParam E - The type of the error\r\n * @param results - The array of Results\r\n * @returns An array of collected error values\r\n */\r\nexport const collectErr = <T, E>(results: readonly Result<T, E>[]): E[] =>\r\n  results\r\n    .filter((result): result is {ok: false; error: E} => !result.ok)\r\n    .map((result) => result.error);\r\n\r\n/**\r\n * Splits an array of Results into a tuple of success values and error values.\r\n * @typeParam T - The type of the success value\r\n * @typeParam E - The type of the error\r\n * @param results - The array of Results\r\n * @returns A tuple containing the array of success values and the array of error values\r\n */\r\nexport function partition<T, E>(results: readonly Result<T, E>[]): [T[], E[]] {\r\n  const oks: T[] = [];\r\n  const errs: E[] = [];\r\n\r\n  for (const result of results) {\r\n    if (result.ok) {\r\n      oks.push(result.value);\r\n    } else {\r\n      errs.push(result.error);\r\n    }\r\n  }\r\n\r\n  return [oks, errs];\r\n}\r\n","// ========================================\r\n// ./src/Result/Operators/flatten.ts\r\n// ========================================\r\nimport type {Result} from '../types';\r\nimport {isOk} from '../base';\r\nimport {isPromiseLike, isResultLike} from '../../helper';\r\n\r\n/**\r\n * Unwraps a nested Result into a single layer (Result<T, E>).\r\n * @typeParam T - The type of the success value\r\n * @typeParam E - The type of the error\r\n * @param result - The nested Result to flatten\r\n * @returns The flattened Result\r\n */\r\nexport function flatten<T, E>(\r\n  result: Result<T | Result<T, E>, E>,\r\n): Result<T, E> {\r\n  if (isOk(result)) {\r\n    const inner_value = result.value;\r\n    if (isResultLike(inner_value)) {\r\n      return inner_value as Result<T, E>;\r\n    }\r\n    return result as Result<T, E>;\r\n  }\r\n  return result as Result<T, E>;\r\n}\r\n\r\n/**\r\n * Recursively unwraps a deeply nested Result into a single layer (Result<T, E>).\r\n * @typeParam T - The type of the success value\r\n * @typeParam E - The type of the error\r\n * @param result - The deeply nested Result to flatten\r\n * @returns The flattened Result\r\n */\r\nexport function deepFlatten<T, E>(\r\n  result: Result<T | Result<unknown, E>, E>,\r\n): Result<T, E> {\r\n  let current_result = result as Result<unknown, E>;\r\n\r\n  while (isOk(current_result)) {\r\n    const value_to_check = current_result.value;\r\n\r\n    if (!isResultLike(value_to_check)) {\r\n      return current_result as Result<T, E>;\r\n    }\r\n    current_result = value_to_check as Result<unknown, E>;\r\n  }\r\n  return current_result;\r\n}\r\n\r\n/**\r\n * Asynchronously and recursively unwraps a deeply nested Result (including nested Promises within the Result value) into a single layer.\r\n * @typeParam T - The type of the success value\r\n * @typeParam E - The type of the error\r\n * @param result_promise - The deeply nested Result or `Promise<Result<T, E>>` to flatten\r\n * @param signal - Optional AbortSignal for cancellation\r\n * @returns The Promise resolving to the flattened Result\r\n */\r\nexport async function deepFlattenAsync<T, E>(\r\n  result_promise:\r\n    | PromiseLike<Result<T | Result<unknown, E>, E>>\r\n    | Result<T | Result<unknown, E>, E>,\r\n): Promise<Result<T, E>> {\r\n  let current_result = await result_promise;\r\n\r\n  while (isOk(current_result)) {\r\n    let value_to_check = current_result.value;\r\n\r\n    if (isPromiseLike(value_to_check)) {\r\n      value_to_check = await value_to_check;\r\n    }\r\n\r\n    if (!isResultLike(value_to_check)) {\r\n      return current_result as Result<T, E>;\r\n    }\r\n    current_result = value_to_check as Result<T, E>;\r\n  }\r\n  return current_result;\r\n}\r\n","// ========================================\r\n// ./src/Result/Operators/Async/reduce-async.ts\r\n// ========================================\r\n\r\nimport type {AnyResult, AsyncResult} from '../../types';\r\nimport {UnknownError, ensureDOMException} from '../../../unknown-error';\r\nimport {Ok, Err, normalizeToResult} from '../../base';\r\nimport {wrapError} from 'src/helper';\r\nimport type {MaybePromise} from '../../../Utils/type-tool';\r\n\r\n/**\r\n * Asynchronously and sequentially reduces multiple AsyncResults into a single Result (short-circuit).\r\n * @typeParam T - The type of the success value\r\n * @typeParam E - The type of the error\r\n * @typeParam R - The type of the reduced result\r\n * @param resultPromises - The array of AsyncResults to reduce\r\n * @param initial - The initial value\r\n * @param reducer - The reduction function (can be async)\r\n * @param signal - Optional AbortSignal for cancellation\r\n * @returns An AsyncResult containing the reduced result\r\n */\r\nexport async function reduceAsync<T, E, R>(\r\n  resultPromises: readonly AnyResult<T, E>[],\r\n  initial: R,\r\n  reducer: (accumulator: R, value: T, signal?: AbortSignal) => MaybePromise<R>,\r\n  signal?: AbortSignal,\r\n): AsyncResult<R, E | UnknownError | DOMException> {\r\n  if (signal?.aborted) return Err(ensureDOMException(signal.reason));\r\n\r\n  let accumulator = initial;\r\n\r\n  for (const resultPromise of resultPromises) {\r\n    const result = await normalizeToResult(resultPromise);\r\n    if (signal?.aborted) return Err(ensureDOMException(signal.reason));\r\n\r\n    if (!result.ok) {\r\n      return Err(result.error);\r\n    }\r\n\r\n    try {\r\n      accumulator = await reducer(accumulator, result.value, signal);\r\n      if (signal?.aborted) return Err(ensureDOMException(signal.reason));\r\n    } catch (rawError) {\r\n      return Err(wrapError(rawError));\r\n    }\r\n  }\r\n\r\n  return Ok(accumulator);\r\n}\r\n","// ========================================\r\n// ./src/Result/Operators/Async/partition-async.ts\r\n// ========================================\r\n\r\nimport type {AnyResult} from '../../types';\r\nimport {UnknownError, ensureDOMException} from '../../../unknown-error';\r\nimport {normalizeToResult} from '../../base';\r\n\r\n/**\r\n * Asynchronously collects all success values from an array of AsyncResults.\r\n * @typeParam T - The type of the success value\r\n * @typeParam E - The type of the error\r\n * @param results - The array of AsyncResults\r\n * @param signal - Optional AbortSignal for cancellation\r\n * @returns A Promise of the array of collected success values\r\n */\r\nexport async function collectOkAsync<T, E>(\r\n  results: readonly AnyResult<T, E>[],\r\n  signal?: AbortSignal,\r\n): Promise<T[]> {\r\n  if (signal?.aborted) return Promise.reject(ensureDOMException(signal.reason));\r\n\r\n  const normalized_promises = results.map((r) => normalizeToResult(r));\r\n  const settled_results = await Promise.all(normalized_promises);\r\n\r\n  const oks: T[] = [];\r\n  for (const result of settled_results) {\r\n    if (signal?.aborted)\r\n      return Promise.reject(ensureDOMException(signal.reason));\r\n\r\n    if (result.ok) {\r\n      oks.push(result.value);\r\n    }\r\n  }\r\n\r\n  return oks;\r\n}\r\n\r\n/**\r\n * Asynchronously collects all failure errors from an array of AsyncResults.\r\n * @typeParam T - The type of the success value\r\n * @typeParam E - The type of the error\r\n * @param results - The array of AsyncResults\r\n * @param signal - Optional AbortSignal for cancellation\r\n * @returns A Promise of the array of collected error values\r\n */\r\nexport async function collectErrAsync<T, E>(\r\n  results: readonly AnyResult<T, E>[],\r\n  signal?: AbortSignal,\r\n): Promise<E[]> {\r\n  if (signal?.aborted) return Promise.reject(ensureDOMException(signal.reason));\r\n\r\n  const normalized_promises = results.map((r) => normalizeToResult(r));\r\n  const settled_results = await Promise.all(normalized_promises);\r\n\r\n  const errs: E[] = [];\r\n  for (const result of settled_results) {\r\n    if (signal?.aborted) throw signal.reason;\r\n\r\n    if (!result.ok) {\r\n      errs.push(result.error as E);\r\n    }\r\n  }\r\n\r\n  return errs;\r\n}\r\n\r\n/**\r\n * Asynchronously executes the Result array concurrently and partitions it into a tuple of success values and error values (non-short-circuiting).\r\n * @typeParam T - The type of the success value\r\n * @typeParam E - The type of the error\r\n * @param results - The array of AsyncResults\r\n * @param signal - Optional AbortSignal for cancellation\r\n * @returns A Promise of a tuple containing the success value array and the error value array\r\n */\r\nexport async function partitionAsync<T, E>(\r\n  results: readonly AnyResult<T, E>[],\r\n  signal?: AbortSignal,\r\n): Promise<[T[], Array<E | DOMException | UnknownError>]> {\r\n  if (signal?.aborted) return Promise.reject(ensureDOMException(signal.reason));\r\n\r\n  const normalized_promises = results.map((r) => normalizeToResult(r));\r\n  const settled_results = await Promise.all(normalized_promises);\r\n\r\n  const oks: T[] = [];\r\n  const errs: Array<E | DOMException | UnknownError> = [];\r\n\r\n  for (const result of settled_results) {\r\n    if (signal?.aborted) throw signal.reason;\r\n\r\n    if (result.ok) {\r\n      oks.push(result.value);\r\n    } else {\r\n      errs.push(result.error);\r\n    }\r\n  }\r\n\r\n  return [oks, errs];\r\n}\r\n"],"names":["peekBoth","result","fnOk","fnErr","peekErr","peekOk","peekBothAsync","result_promise","signal","Err","ensureDOMException","raw_error","wrapError","peekErrAsync","peekOkAsync","matchResultAsync","onOk","onErr","dynamicAwait","UnknownError","ifOkAsync","onElse","ifErrAsync","mapOrElseAsync","defaultFn","mapFn","reduce","results","initial","reducer","accumulator","Ok","collectOk","collectErr","partition","oks","errs","flatten","isOk","inner_value","isResultLike","deepFlatten","current_result","value_to_check","deepFlattenAsync","isPromiseLike","reduceAsync","resultPromises","resultPromise","normalizeToResult","rawError","collectOkAsync","normalized_promises","r","settled_results","collectErrAsync","partitionAsync"],"mappings":"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"}