@nlozgachev/pipelined 0.63.0 → 0.64.0

package/dist/core.d.cts

@@ -1,5 +1,5 @@
-import { M as Maybe, R as Result, T as Task } from './Validation-KFUpea_k.cjs';
-export { E as Equality, a as Err, F as Failed, N as None, O as Ok, b as Ordering, P as Passed, S as Some, V as Validation } from './Validation-KFUpea_k.cjs';
+import { M as Maybe, R as Result, T as Task } from './Task-C_goFYQ1.cjs';
+export { E as Equality, a as Err, F as Failed, N as None, O as Ok, b as Ordering, P as Passed, S as Some, V as Validation } from './Task-C_goFYQ1.cjs';
 import { o as WithValue, i as WithLog, D as Deferred, R as RetryOptions, n as WithTimeout, j as WithMinInterval, c as WithCooldown, W as WithConcurrency, m as WithSize, d as WithDuration, k as WithN, h as WithKind, e as WithError, b as TimeoutOptions, g as WithFirst, l as WithSecond } from './InternalTypes-GFn4RTwD.cjs';
 import { D as Duration } from './Duration-DeyxG6VQ.cjs';
 import './types.cjs';
@@ -565,10 +565,10 @@ declare function interpretFn<I, E, A, O extends AllInterpretOptions<I, E>>(op: O
  *
  * const manager = Op.interpret(fetchUser, { strategy: "restartable" });
  * manager.subscribe(state => {
- *   if (Op.isPending(state)) showSpinner();
- *   if (Op.isOk(state))      render(state.value);
- *   if (Op.isErr(state))   showError(state.error);
- *   if (Op.isNil(state))     resetUI();
+ *   if (Op.is.pending(state)) showSpinner();
+ *   if (Op.is.ok(state))      render(state.value);
+ *   if (Op.is.err(state))     showError(state.error);
+ *   if (Op.is.nil(state))     resetUI();
  * });
  * manager.run(userId);
  * ```
@@ -581,18 +581,116 @@ type Op<I, E, A> = {
     readonly _factory: (input: I, signal: AbortSignal) => Deferred<Result<E, A> | null>;
 };
 declare const Op: {
-    nil: (reason: Op.NilReason) => Op.Nil;
+    make: {
+        /**
+         * Creates an Ok outcome with the given value.
+         *
+         * @example
+         * ```ts
+         * Op.make.ok(42); // { kind: "OpOk", value: 42 }
+         * ```
+         */
+        ok: <A>(value: A) => Op.Ok<A>;
+        /**
+         * Creates an Err outcome with the given error.
+         *
+         * @example
+         * ```ts
+         * Op.make.err("Something went wrong"); // { kind: "OpErr", error: "Something went wrong" }
+         * ```
+         */
+        err: <E>(error: E) => Op.Err<E>;
+        /**
+         * Creates a Nil outcome with the given cancellation/drop reason.
+         *
+         * @example
+         * ```ts
+         * Op.make.nil("aborted"); // { kind: "OpNil", reason: "aborted" }
+         * ```
+         */
+        nil: (reason: Op.NilReason) => Op.Nil;
+    };
+    is: {
+        /**
+         * Type guard that checks if an Op state is Idle.
+         *
+         * @example
+         * ```ts
+         * if (Op.is.idle(manager.state)) {
+         *   console.log("Ready to execute");
+         * }
+         * ```
+         */
+        idle: <E, A>(state: Op.State<E, A>) => state is Op.Idle;
+        /**
+         * Type guard that checks if an Op state is Pending (actively executing).
+         *
+         * @example
+         * ```ts
+         * if (Op.is.pending(manager.state)) {
+         *   showSpinner();
+         * }
+         * ```
+         */
+        pending: <E, A>(state: Op.State<E, A>) => state is Op.Pending;
+        /**
+         * Type guard that checks if an Op state is Queued (waiting in a concurrency queue).
+         *
+         * @example
+         * ```ts
+         * if (Op.is.queued(manager.state)) {
+         *   console.log("Position in queue:", manager.state.position);
+         * }
+         * ```
+         */
+        queued: <E, A>(state: Op.State<E, A>) => state is Op.Queued;
+        /**
+         * Type guard that checks if an Op state is Retrying after a failure.
+         *
+         * @example
+         * ```ts
+         * if (Op.is.retrying(manager.state)) {
+         *   console.log("Retry attempt:", manager.state.attempt);
+         * }
+         * ```
+         */
+        retrying: <E, A>(state: Op.State<E, A>) => state is Op.Retrying<E>;
+        /**
+         * Type guard that checks if an Op state or outcome is Ok.
+         *
+         * @example
+         * ```ts
+         * if (Op.is.ok(outcome)) {
+         *   render(outcome.value);
+         * }
+         * ```
+         */
+        ok: <E, A>(state: Op.State<E, A>) => state is Op.Ok<A>;
+        /**
+         * Type guard that checks if an Op state or outcome is Err.
+         *
+         * @example
+         * ```ts
+         * if (Op.is.err(outcome)) {
+         *   showError(outcome.error);
+         * }
+         * ```
+         */
+        err: <E, A>(state: Op.State<E, A>) => state is Op.Err<E>;
+        /**
+         * Type guard that checks if an Op state or outcome is Nil.
+         *
+         * @example
+         * ```ts
+         * if (Op.is.nil(outcome)) {
+         *   console.log("Skipped due to:", outcome.reason);
+         * }
+         * ```
+         */
+        nil: <E, A>(state: Op.State<E, A>) => state is Op.Nil;
+    };
     create: <E, A, I = void>(factory: (signal: AbortSignal) => (input: I) => Promise<A>, onError: (e: unknown) => E) => Op<I, E, A>;
     lift: <I, A>(f: (input: I, signal: AbortSignal) => Promise<A>) => Op<I, unknown, A>;
-    ok: <A>(value: A) => Op.Ok<A>;
-    err: <E>(error: E) => Op.Err<E>;
-    isIdle: <E, A>(state: Op.State<E, A>) => state is Op.Idle;
-    isPending: <E, A>(state: Op.State<E, A>) => state is Op.Pending;
-    isQueued: <E, A>(state: Op.State<E, A>) => state is Op.Queued;
-    isRetrying: <E, A>(state: Op.State<E, A>) => state is Op.Retrying<E>;
-    isOk: <E, A>(state: Op.State<E, A>) => state is Op.Ok<A>;
-    isErr: <E, A>(state: Op.State<E, A>) => state is Op.Err<E>;
-    isNil: <E, A>(state: Op.State<E, A>) => state is Op.Nil;
     match: <E, A, B>(cases: {
         ok: (a: A) => B;
         err: (e: E) => B;

package/dist/core.d.ts

@@ -1,5 +1,5 @@
-import { M as Maybe, R as Result, T as Task } from './Validation-C5RGZUXy.js';
-export { E as Equality, a as Err, F as Failed, N as None, O as Ok, b as Ordering, P as Passed, S as Some, V as Validation } from './Validation-C5RGZUXy.js';
+import { M as Maybe, R as Result, T as Task } from './Task-9SJCMtG4.js';
+export { E as Equality, a as Err, F as Failed, N as None, O as Ok, b as Ordering, P as Passed, S as Some, V as Validation } from './Task-9SJCMtG4.js';
 import { o as WithValue, i as WithLog, D as Deferred, R as RetryOptions, n as WithTimeout, j as WithMinInterval, c as WithCooldown, W as WithConcurrency, m as WithSize, d as WithDuration, k as WithN, h as WithKind, e as WithError, b as TimeoutOptions, g as WithFirst, l as WithSecond } from './InternalTypes-CCXa8Kvr.js';
 import { D as Duration } from './Duration-DeyxG6VQ.js';
 import './types.js';
@@ -565,10 +565,10 @@ declare function interpretFn<I, E, A, O extends AllInterpretOptions<I, E>>(op: O
  *
  * const manager = Op.interpret(fetchUser, { strategy: "restartable" });
  * manager.subscribe(state => {
- *   if (Op.isPending(state)) showSpinner();
- *   if (Op.isOk(state))      render(state.value);
- *   if (Op.isErr(state))   showError(state.error);
- *   if (Op.isNil(state))     resetUI();
+ *   if (Op.is.pending(state)) showSpinner();
+ *   if (Op.is.ok(state))      render(state.value);
+ *   if (Op.is.err(state))     showError(state.error);
+ *   if (Op.is.nil(state))     resetUI();
  * });
  * manager.run(userId);
  * ```
@@ -581,18 +581,116 @@ type Op<I, E, A> = {
     readonly _factory: (input: I, signal: AbortSignal) => Deferred<Result<E, A> | null>;
 };
 declare const Op: {
-    nil: (reason: Op.NilReason) => Op.Nil;
+    make: {
+        /**
+         * Creates an Ok outcome with the given value.
+         *
+         * @example
+         * ```ts
+         * Op.make.ok(42); // { kind: "OpOk", value: 42 }
+         * ```
+         */
+        ok: <A>(value: A) => Op.Ok<A>;
+        /**
+         * Creates an Err outcome with the given error.
+         *
+         * @example
+         * ```ts
+         * Op.make.err("Something went wrong"); // { kind: "OpErr", error: "Something went wrong" }
+         * ```
+         */
+        err: <E>(error: E) => Op.Err<E>;
+        /**
+         * Creates a Nil outcome with the given cancellation/drop reason.
+         *
+         * @example
+         * ```ts
+         * Op.make.nil("aborted"); // { kind: "OpNil", reason: "aborted" }
+         * ```
+         */
+        nil: (reason: Op.NilReason) => Op.Nil;
+    };
+    is: {
+        /**
+         * Type guard that checks if an Op state is Idle.
+         *
+         * @example
+         * ```ts
+         * if (Op.is.idle(manager.state)) {
+         *   console.log("Ready to execute");
+         * }
+         * ```
+         */
+        idle: <E, A>(state: Op.State<E, A>) => state is Op.Idle;
+        /**
+         * Type guard that checks if an Op state is Pending (actively executing).
+         *
+         * @example
+         * ```ts
+         * if (Op.is.pending(manager.state)) {
+         *   showSpinner();
+         * }
+         * ```
+         */
+        pending: <E, A>(state: Op.State<E, A>) => state is Op.Pending;
+        /**
+         * Type guard that checks if an Op state is Queued (waiting in a concurrency queue).
+         *
+         * @example
+         * ```ts
+         * if (Op.is.queued(manager.state)) {
+         *   console.log("Position in queue:", manager.state.position);
+         * }
+         * ```
+         */
+        queued: <E, A>(state: Op.State<E, A>) => state is Op.Queued;
+        /**
+         * Type guard that checks if an Op state is Retrying after a failure.
+         *
+         * @example
+         * ```ts
+         * if (Op.is.retrying(manager.state)) {
+         *   console.log("Retry attempt:", manager.state.attempt);
+         * }
+         * ```
+         */
+        retrying: <E, A>(state: Op.State<E, A>) => state is Op.Retrying<E>;
+        /**
+         * Type guard that checks if an Op state or outcome is Ok.
+         *
+         * @example
+         * ```ts
+         * if (Op.is.ok(outcome)) {
+         *   render(outcome.value);
+         * }
+         * ```
+         */
+        ok: <E, A>(state: Op.State<E, A>) => state is Op.Ok<A>;
+        /**
+         * Type guard that checks if an Op state or outcome is Err.
+         *
+         * @example
+         * ```ts
+         * if (Op.is.err(outcome)) {
+         *   showError(outcome.error);
+         * }
+         * ```
+         */
+        err: <E, A>(state: Op.State<E, A>) => state is Op.Err<E>;
+        /**
+         * Type guard that checks if an Op state or outcome is Nil.
+         *
+         * @example
+         * ```ts
+         * if (Op.is.nil(outcome)) {
+         *   console.log("Skipped due to:", outcome.reason);
+         * }
+         * ```
+         */
+        nil: <E, A>(state: Op.State<E, A>) => state is Op.Nil;
+    };
     create: <E, A, I = void>(factory: (signal: AbortSignal) => (input: I) => Promise<A>, onError: (e: unknown) => E) => Op<I, E, A>;
     lift: <I, A>(f: (input: I, signal: AbortSignal) => Promise<A>) => Op<I, unknown, A>;
-    ok: <A>(value: A) => Op.Ok<A>;
-    err: <E>(error: E) => Op.Err<E>;
-    isIdle: <E, A>(state: Op.State<E, A>) => state is Op.Idle;
-    isPending: <E, A>(state: Op.State<E, A>) => state is Op.Pending;
-    isQueued: <E, A>(state: Op.State<E, A>) => state is Op.Queued;
-    isRetrying: <E, A>(state: Op.State<E, A>) => state is Op.Retrying<E>;
-    isOk: <E, A>(state: Op.State<E, A>) => state is Op.Ok<A>;
-    isErr: <E, A>(state: Op.State<E, A>) => state is Op.Err<E>;
-    isNil: <E, A>(state: Op.State<E, A>) => state is Op.Nil;
     match: <E, A, B>(cases: {
         ok: (a: A) => B;
         err: (e: E) => B;