resultar 3.4.0 → 3.5.0

package/README.md

@@ -45,7 +45,7 @@ Use it when expected failures should be impossible to miss:
 - Ignored `Result` values can be reported by a type-aware no-discard check.
 
 Resultar began as an initial fork of `neverthrow`. The v3 line keeps the explicit wrapper model,
-then leans into Resultar-specific tagged errors, strict service-boundary types, TypeScript 7-first
+then leans into Resultar-specific tagged errors, strict service-boundary types, TypeScript >=7
 diagnostics, and ESM-only packaging.
 
 ## Install
@@ -61,7 +61,7 @@ npm install resultar
 ## Requirements
 
 - Node.js 24+
-- TypeScript 7 for the canonical Resultar diagnostics workflow
+- TypeScript >=7 for the canonical Resultar diagnostics workflow
 - ESM only
 
 ```ts
@@ -738,6 +738,21 @@ const lines = ResultAsync.withResource({
 })
 ```
 
+Adapt callback and subscription APIs with `ResultAsync.fromCallback`. The callback source can
+resolve or reject once, receives the cooperative signal, and returns a synchronous unsubscribe
+function that runs after success, failure, or cancellation.
+
+```ts
+const nextValue = ResultAsync.fromCallback<number, SubscriptionError>({
+  catch: (cause) => new SubscriptionError({ cause }),
+  signal,
+  subscribe: ({ reject, resolve }) => {
+    const subscription = source.subscribe({ error: reject, next: resolve })
+    return () => subscription.unsubscribe()
+  },
+})
+```
+
 For pull-based streams, keep the runtime native: expose an `AsyncIterable<Result<T, E>>` and close
 resources in `finally`. See
 [DOCUMENTATION.md](../../DOCUMENTATION.md#resourceful-async-iterables) for the full recipe.
@@ -756,6 +771,7 @@ where the failure appears.
 | Catch thrown sync code now | `tryResult(fn, toError?)` |
 | Wrap a throwing sync function for later | `fromThrowable(fn, toError?)` |
 | Catch an existing rejecting promise | `fromPromise(promise, toError)` |
+| Adapt a callback or subscription | `ResultAsync.fromCallback({ subscribe, catch, signal? })` |
 | Catch a promise or async factory | `tryResultAsync(promiseOrFactory, toError?)` |
 | Wrap an async function for later | `fromThrowableAsync(fn, toError?)` |
 | Turn one error into another | `mapErr(fn)` |
@@ -971,11 +987,11 @@ const config = safeTry({
 
 ## No-Discard Validation
 
-Resultar values should not be ignored. Use `resultar-check` to run TypeScript 7 and Resultar
+Resultar values should not be ignored. Use `resultar-check` to run TypeScript >=7 and Resultar
 diagnostics through one command.
 
 ```sh
-pnpm add -D resultar-check typescript-7@npm:typescript@rc
+pnpm add -D resultar-check "typescript@>=7"
 ```
 
 Add a check script:
@@ -1023,8 +1039,10 @@ Configure Resultar rules in `tsconfig.json`:
 The package-local schema provides editor completion and validation for `resultar-check` plugin
 options.
 
-Oxlint is intentionally not part of the Resultar rules path; use it only for general linting if your
-project wants it.
+For fast AST-only Oxlint, ESLint, or Deno Lint feedback, use the adapter exports documented in the
+`resultar-check` package guide. Use the `resultar-check` CLI for the full TypeScript-backed rule set.
+The `examples/lint` package shows how to compare Oxlint, ESLint, and CLI counts by running the CLI
+with the same AST-only rule subset.
 
 For VS Code and Zed setup, use the editor integration section in the `resultar-check` package guide.
 
@@ -1039,6 +1057,7 @@ For VS Code and Zed setup, use the editor integration section in the `resultar-c
 | Create an `Ok(undefined)` | `unit()` or `unitAsync()` |
 | Convert throwing sync code | `tryResult` or `fromThrowable` |
 | Convert rejecting async code | `tryResultAsync`, `fromPromise`, or `fromThrowableAsync` |
+| Convert a callback subscription | `ResultAsync.fromCallback` or `fromCallback` |
 | Treat an `Err` as unrecoverable at an edge | `unwrapOrThrow()` |
 | Transform success | `map` or `asyncMap` |
 | Replace success with a known value | `as(value)` |
@@ -1105,19 +1124,17 @@ More focused material:
 - [Full guide](https://github.com/inaiat/resultar/blob/main/DOCUMENTATION.md)
 - [Type-safe error handling article, English](https://github.com/inaiat/resultar/blob/main/articles/en/type-safe.md)
 - [Artigo sobre tratamento de erros type-safe, Portuguese](https://github.com/inaiat/resultar/blob/main/articles/pt/type-safe.md)
-- [resultar-check package guide](https://github.com/inaiat/resultar/blob/main/packages/resultar-check/README.md)
+- [resultar-check package guide](https://github.com/inaiat/resultar/blob/main/packages/check/README.md)
 
 ## Repository
 
 This repository is a pnpm workspace:
 
 - `packages/resultar`: Resultar runtime package.
-- `packages/resultar-check`: TypeScript 7 plus Resultar validation.
-- `packages/resultar-lint`: deprecated compatibility wrapper.
-- `packages/resultar-tsgo`: deprecated compatibility wrapper for older installs.
+- `packages/check`: TypeScript >=7 plus Resultar validation and AST-only lint adapters.
 - `benchmarks`: benchmark package.
 - `examples/resultar`: runnable core Resultar cookbook.
-- `examples/lint`: TypeScript 7 `resultar-check` smoke example.
+- `examples/lint`: adapter parity smoke for AST-only Resultar rules across Oxlint, ESLint, and `resultar-check` CLI.
 
 Common commands:
 

package/dist/index.d.ts

@@ -742,6 +742,44 @@ interface ResultAsyncAbortSignal {
   removeEventListener: (type: "abort", listener: () => void) => void;
 }
 /**
+* Context passed to `ResultAsync.fromCallback` subscriptions.
+*/
+interface ResultAsyncCallbackContext<T> {
+  /**
+  * Completes the operation with `Ok(value)`.
+  */
+  readonly resolve: (value: T) => void;
+  /**
+  * Completes the operation with a cause mapped by the subscription's `catch` function.
+  */
+  readonly reject: (cause: unknown) => void;
+  /**
+  * Cooperative cancellation signal for the subscription.
+  */
+  readonly signal: ResultAsyncAbortSignal;
+}
+/**
+* Synchronous cleanup returned by a `ResultAsync.fromCallback` subscription.
+*/
+type ResultAsyncCallbackCleanup = () => void;
+/**
+* Options for adapting a callback or subscription API into `ResultAsync`.
+*/
+interface ResultAsyncFromCallbackOptions<T, E> {
+  /**
+  * Maps callback failures and synchronous subscription throws into the typed error channel.
+  */
+  readonly catch: (cause: unknown) => E;
+  /**
+  * Optional external signal that cancels the subscription with `AbortError`.
+  */
+  readonly signal?: ResultAsyncAbortSignal;
+  /**
+  * Registers the callback source and optionally returns a synchronous unsubscribe function.
+  */
+  readonly subscribe: (context: ResultAsyncCallbackContext<T>) => ResultAsyncCallbackCleanup | void;
+}
+/**
 * Concurrency setting for async collection helpers.
 *
 * Use a number for bounded parallelism or `'unbounded'` when every task may start immediately.
@@ -1019,7 +1057,7 @@ declare class DisposableResultAsync<T, E> implements PromiseLike<Result<T, E>>,
 * but operating in an asynchronous context.
 *
 * The class includes methods for:
-* - Creating ResultAsync instances (okAsync, errAsync, fromPromise)
+* - Creating ResultAsync instances (okAsync, errAsync, fromPromise, fromCallback)
 * - Transforming values (map, mapErr)
 * - Chaining operations (andThen, orElse)
 * - Error handling (tapError)
@@ -1082,6 +1120,13 @@ declare class ResultAsync<T, E> extends Pipeable implements PromiseLike<Result<T
   */
   static fromPromise<T, E>(this: void, promise: PromiseLike<T>, errorFn: (e: unknown) => E): ResultAsync<T, E>;
   /**
+  * Adapts a callback or subscription API into a cancellable ResultAsync.
+  *
+  * The returned cleanup function runs once after resolve, reject, cancellation, or synchronous
+  * subscription failure. Cleanup errors are ignored.
+  */
+  static fromCallback<T, E>(this: void, options: ResultAsyncFromCallbackOptions<T, E>): ResultAsync<T, E | AbortError>;
+  /**
   * Combines many ResultAsync values and stops at the first Err.
   *
   * Arrays return an Ok array, records return an Ok record with the same keys, and iterables return
@@ -1354,6 +1399,10 @@ declare const okAsync: typeof ResultAsync.okAsync;
 */
 declare const errAsync: typeof ResultAsync.errAsync;
 /**
+* Adapts a callback or subscription API into a cancellable ResultAsync.
+*/
+declare const fromCallback: typeof ResultAsync.fromCallback;
+/**
 * Converts an existing promise into a ResultAsync and maps rejection into a typed Err.
 */
 declare const fromPromise: typeof ResultAsync.fromPromise;
@@ -1628,5 +1677,4 @@ declare const matchError: <ErrorType extends Error, ReturnType>(error: ErrorType
 */
 declare const matchErrorPartial: <ErrorType extends Error, ReturnType>(error: ErrorType, handlers: PartialMatchHandlers<ErrorType, ReturnType>, fallback: (error: ErrorType) => ReturnType) => ReturnType;
 //#endregion
-export { AbortError, DisposableResult, DisposableResultAsync, type ErrResult, type OkResult, type Redacted, Result, ResultAsync, type ResultAsyncAbortSignal, type ResultAsyncConcurrency, type ResultAsyncRaceHandle, type ResultAsyncRaceTask, type ResultAsyncResourceAcquire, type ResultAsyncResourceEffect, type ResultAsyncResourceRelease, type ResultAsyncResourceReleaseContext, type ResultAsyncResourceUse, type ResultAsyncRetryContext, type ResultAsyncRetryOptions, type ResultAsyncRetryOrElseOptions, type ResultAsyncRetryTask, type ResultAsyncTimeoutOptions, type ResultAsyncWithResourceOptions, type ResultOperations, type SafeTryAsyncOptions, type SafeTryOptions, type StrictResult, type StrictResultAsync, type TaggedEnum, type TaggedEnumFactory, type TaggedErrorClass, type TaggedErrorInstance, type TaggedErrorOptions, type TryResultAsyncOptions, type TryResultOptions, createTaggedError, tryResult as default, tryResult as try, tryResult, err, errAsync, findCause, fromPromise, fromSafePromise, fromThrowable, fromThrowableAsync, isAbortError, isError, isRedacted, matchError, matchErrorPartial, ok, okAsync, redact, revealRedacted, runPromise, runSync, safeTry, taggedEnum, tryResultAsync as tryAsync, tryResultAsync, tryCatch, tryCatchAsync, unit, unitAsync };
-//# sourceMappingURL=index.d.ts.map
+export { AbortError, DisposableResult, DisposableResultAsync, type ErrResult, type OkResult, type Redacted, Result, ResultAsync, type ResultAsyncAbortSignal, type ResultAsyncCallbackCleanup, type ResultAsyncCallbackContext, type ResultAsyncConcurrency, type ResultAsyncFromCallbackOptions, type ResultAsyncRaceHandle, type ResultAsyncRaceTask, type ResultAsyncResourceAcquire, type ResultAsyncResourceEffect, type ResultAsyncResourceRelease, type ResultAsyncResourceReleaseContext, type ResultAsyncResourceUse, type ResultAsyncRetryContext, type ResultAsyncRetryOptions, type ResultAsyncRetryOrElseOptions, type ResultAsyncRetryTask, type ResultAsyncTimeoutOptions, type ResultAsyncWithResourceOptions, type ResultOperations, type SafeTryAsyncOptions, type SafeTryOptions, type StrictResult, type StrictResultAsync, type TaggedEnum, type TaggedEnumFactory, type TaggedErrorClass, type TaggedErrorInstance, type TaggedErrorOptions, type TryResultAsyncOptions, type TryResultOptions, createTaggedError, tryResult as default, tryResult as try, tryResult, err, errAsync, findCause, fromCallback, fromPromise, fromSafePromise, fromThrowable, fromThrowableAsync, isAbortError, isError, isRedacted, matchError, matchErrorPartial, ok, okAsync, redact, revealRedacted, runPromise, runSync, safeTry, taggedEnum, tryResultAsync as tryAsync, tryResultAsync, tryCatch, tryCatchAsync, unit, unitAsync };