@xstd/async-function 0.0.0-stage → 1.1.0

package/CONTRIBUTING.md

@@ -0,0 +1,127 @@
+# Contributing
+
+This projet is open to everyone. Feel free to test the library, share it, improve it, and create merge requests.
+
+## Getting started
+
+### Tools
+
+#### [nvm](https://github.com/nvm-sh/nvm)
+
+We recommend using [nvm](https://github.com/nvm-sh/nvm) to manage your Node.js versions.
+
+```shell
+curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.40.3/install.sh | bash
+```
+
+#### [Node](https://nodejs.org)
+
+```shell
+nvm use
+
+# Verify the Node.js version:
+node -v
+```
+
+#### [Yarn](https://yarnpkg.com)
+
+```shell
+corepack enable yarn
+
+# Verify Yarn version:
+yarn -v
+
+# Install the dependencies:
+yarn install
+```
+
+### Code
+
+- The source code is located in the `src` directory.
+- The projet uses [prettier](https://prettier.io/) to format the code. You'll want to enable and configure it in your IDE.
+- The tests run with [vitest](https://vitest.dev)
+
+### Commands
+
+- `fb:build`: builds the library.
+  - converts the typescript files into javascript files, copies the scss files, and assembles all the assets to create a package ready to be published.
+  - some files are handled differently:
+    - `*.protected.{ts,scss}` or `**/*.protected/**`: these files are exported under `package-name/protected`
+      - this is indented to expose parts of the code that should be restricted to advanced users only, or shared to other libraries requiring _internal_ control.
+    - `*.private.{ts,scss}` or `/*.private/**`: these files are **not** exported.
+      - this is indented to consume parts of the code internally, and not expose them publicly.
+- `fb:format`: formats the code using `prettier`.
+- `fb:test`: runs the tests using `vitest`.
+- `fb:test:coverage`: runs the tests with coverage.
+  - by default, 100% code coverage is required, to enforce good quality.
+- `fb:bench`: runs the bench tests.
+- `fb:typedoc`: generates the documentation.
+  - if the library exposes publicly only a few and/or simple parts, the documentation may be defined in the `README.md` instead.
+
+### To create a PR
+
+1. fork the repository
+1. add the feature/fix by modifying the code in the `src/` directory
+1. add/write some tests until 100% code coverage is reached (run the tests with `yarn fb:test:coverage`)
+1. format the code, using the command `yarn fb:format`
+1. commit and push your work following the [Conventional Commits](https://www.conventionalcommits.org/en/v1.0.0/) convention
+1. create a PR from your repository to the upstream repository, explaining clearly what was added/fixed.
+
+## Release Workflow
+
+> The `release.yml` workflow runs on `pull_request` and `push` events on the `main` and `develop` branches.
+> It invokes the `yarn fb:ci:release` used to build and publish the package.
+> Note that the `publish` step runs only if the equivalent stable version (`x.y.z`) does not already exist on npm
+
+### 1. Pull Request to `main` or `develop`
+
+- The `dev` label is added to the PR
+- Impacted packages are published as: `x.y.z-dev.<timestamp>`
+- npm dist-tag: `dev`
+
+> Use the `dev` versions only if required.
+
+### 2. Push to `develop`
+
+- Impacted packages are published as: `x.y.z-rc.<timestamp>`
+- npm dist-tag: `rc`
+
+### 3. Push to `main`
+
+- Stable publication: `x.y.z`
+- npm dist-tag: `latest`
+
+### Graph
+
+```mermaid
+flowchart LR
+  EVENT("WORKFLOW TRIGGER")
+  HAS_DEV_TAG{"has &quotdev&quot tag ?"}
+  SKIP_BUILD(["skip build"])
+  BUILD_DEV_PACKAGES["build &quotdev&quot package"]
+  PUBLISH_DEV_PACKAGES["publish &quotdev&quot package"]
+  BUILD_RC_PACKAGES["build &quotrc&quot package"]
+  PUBLISH_RC_PACKAGES["publish &quotrc&quot package"]
+  BUILD_PROD_PACKAGES["build &quotprod&quot package"]
+  PUBLISH_PROD_PACKAGES["publish &quotprod&quot package"]
+  TARGET_BRANCH{"branch"}
+
+  EVENT -- "pull_request" --> HAS_DEV_TAG
+  HAS_DEV_TAG -- "no" --> SKIP_BUILD
+  HAS_DEV_TAG -- "yes" --> BUILD_DEV_PACKAGES
+  BUILD_DEV_PACKAGES --> PUBLISH_DEV_PACKAGES
+
+  EVENT -- "push" --> TARGET_BRANCH
+
+  TARGET_BRANCH -- "develop" --> BUILD_RC_PACKAGES
+  BUILD_RC_PACKAGES --> PUBLISH_RC_PACKAGES
+
+  TARGET_BRANCH -- "main" --> BUILD_PROD_PACKAGES
+  BUILD_PROD_PACKAGES --> PUBLISH_PROD_PACKAGES
+```
+
+## Important Rules
+
+- if an equivalent **stable** version already exists on npm: the release is skipped
+- the `package.json` file in the repo must keep stable versions (`x.y.z`)
+- `-dev` / `-rc` suffixes are generated in CI

package/LICENSE

@@ -0,0 +1,21 @@
+The MIT License
+
+Copyright (c) 2026 Valentin Richard
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

package/README.md

@@ -1,3 +1,284 @@
-# Temporary Holding Version
+[![npm (scoped)](https://img.shields.io/npm/v/@xstd/async-function.svg)](https://www.npmjs.com/package/@xstd/async-function)
+![npm](https://img.shields.io/npm/dm/@xstd/async-function.svg)
+![NPM](https://img.shields.io/npm/l/@xstd/async-function.svg)
+![npm type definitions](https://img.shields.io/npm/types/@xstd/async-function.svg)
+![coverage](https://img.shields.io/badge/coverage-100%25-green)
+![AI generation](https://img.shields.io/badge/AI_generation-low-yellow)
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+<picture>
+  <source height="64" media="(prefers-color-scheme: dark)" srcset="https://github.com/xstd-js/website/blob/main/assets/logo/png/logo-large-dark.png?raw=true">
+  <source height="64" media="(prefers-color-scheme: light)" srcset="https://github.com/xstd-js/website/blob/main/assets/logo/png/logo-large-light.png?raw=true">
+  <img height="64" alt="Shows a black logo in light color mode and a white one in dark color mode." src="https://github.com/xstd-js/website/blob/main/assets/logo/png/logo-large-light.png?raw=true">
+</picture>
+
+## @xstd/async-function
+
+Universal API around async functions
+
+## 📦 Installation
+
+```shell
+yarn add @xstd/async-function
+# or
+npm install @xstd/async-function --save
+```
+
+## 🚀 Usage
+
+```ts
+import { AsyncFunction } from '@xstd/async-function';
+
+const fetchJson = new AsyncFunction(async (signal, url: string) => {
+  const response = await fetch(url, { signal });
+  return response.json();
+});
+
+// transform the resolved value, like Promise.then, but it stays callable:
+const fetchUser = fetchJson
+  .then((data) => (data as { user: unknown }).user)
+  .catch((error) => {
+    console.error(error);
+    return null;
+  });
+
+// deduplicate concurrent calls for the same key:
+const getUser = fetchUser.shareConcurentCalls({ keyGenerator: ([id]) => id as string });
+
+const controller = new AbortController();
+const user = await getUser.call(controller.signal, '42');
+
+setTimeout(() => controller.abort(), 3000); // aborts the pending call
+```
+
+## 📜 Documentation
+
+### `AsyncFunction`
+
+Represents an asynchronous and abortable function with configurable arguments and specific return value.
+
+- **Type parameters**
+  - `GArguments extends readonly unknown[]` — The tuple type of arguments passed to the function.
+  - `GReturn` — The type of the return value.
+
+Every call requires a leading `AbortSignal` argument, making the function abortable and composable.
+
+```ts
+import { AsyncFunction } from '@xstd/async-function';
+
+const fetchJson = new AsyncFunction(async (signal, url: string) => {
+  const response = await fetch(url, { signal });
+  return response.json();
+});
+
+const data = await fetchJson.call(new AbortController().signal, 'https://example.com/data.json');
+```
+
+#### Constructor
+
+```ts
+new AsyncFunction<GArguments, GReturn>(call: AsyncFunctionLike<GArguments, GReturn>)
+```
+
+Creates an instance of the `AsyncFunction` class.
+
+- **Parameters**
+  - `call: AsyncFunctionLike<GArguments, GReturn>` — A call function, or an existing `AsyncFunction`, which defines the action to perform on invocation. It receives the call's `AbortSignal` as first argument, followed by the call's arguments, and returns the result (or a promise of it). If an `AsyncFunction` is provided, its underlying call function is reused instead of being wrapped.
+
+```ts
+// from a call function:
+const fnc = new AsyncFunction(async (signal, url: string) => fetch(url, { signal }));
+
+// from an existing AsyncFunction (reuses its underlying call function):
+const copy = new AsyncFunction(fnc);
+```
+
+#### Static methods
+
+##### `AsyncFunction.of`
+
+```ts
+AsyncFunction.of<GArguments, GReturn>(input: AsyncFunctionLike<GArguments, GReturn>): AsyncFunction<GArguments, GReturn>
+```
+
+Returns the given input if it is already an `AsyncFunction`, otherwise wraps it into a new `AsyncFunction` instance.
+
+- **Parameters**
+  - `input: AsyncFunctionLike<GArguments, GReturn>` — An `AsyncFunction` instance or a plain call function to wrap.
+- **Returns** The `AsyncFunction` instance corresponding to `input`.
+
+```ts
+AsyncFunction.of(asyncFunction); // returns asyncFunction
+AsyncFunction.of(async (signal) => 42); // returns a new AsyncFunction wrapping the function
+```
+
+##### `AsyncFunction.fromSendAndReceive`
+
+```ts
+AsyncFunction.fromSendAndReceive<GArguments, GReturn>(
+  options: AsyncFunctionFromSendAndReceiveOptions<GArguments, GReturn>,
+): AsyncFunction<GArguments, GReturn>
+```
+
+Creates an async function that concurrently triggers a "send" (push) operation and waits for a "receive" (pull) result, returning the received value once both complete. This is ideal for command-response, RPC, or event-driven patterns where you must initiate an action and await its corresponding outcome.
+
+The returned async function is abortable — cancellation via `AbortSignal` will propagate to both the send and receive operations.
+
+- **Parameters** `options` — Configuration object containing the send and receive async functions.
+  - `send: AsyncFunctionLike<GArguments, void>` — The "push" async function to trigger (e.g., sending a command or message). Must not return a value.
+  - `receive: AsyncFunctionLike<GArguments, GReturn>` — The "pull" async function to await (e.g., listening for a response or event). Returns the result.
+- **Returns** An async function that, when called, returns a promise resolving to the value from `receive`. The promise is rejected if either operation fails or is aborted.
+
+```ts
+const fnc = AsyncFunction.fromSendAndReceive({
+  send: new AsyncFunction((signal) => sendMessage('hello', { signal })),
+  receive: new AsyncFunction((signal) => waitForResponse({ signal })),
+});
+
+const result = await fnc.call(signal); // returns response from waitForResponse()
+```
+
+```ts
+const controller = new AbortController();
+const result = await fnc.call(controller.signal);
+// cancel mid-operation:
+controller.abort(); // both send and receive will be aborted.
+```
+
+#### Instance methods
+
+##### `call`
+
+```ts
+call(signal: AbortSignal, ...args: GArguments): Promise<GReturn>
+```
+
+Executes the async function with the provided arguments and options.
+
+- **Parameters**
+  - `signal: AbortSignal` — A signal to abort the action execution.
+  - `...args: GArguments` — The arguments to be provided to the async function.
+- **Returns** A promise that resolves with the result of the async function.
+
+##### `transform`
+
+```ts
+transform<GReturn>(transformFnc: TransformAsyncFunctionFunction<this, GReturn>): GReturn
+```
+
+Applies a transformation function to the current instance and returns the result.
+
+- **Parameters**
+  - `transformFnc` — A function that takes the current instance and returns a transformed value.
+- **Returns** The result of applying the transformation function to the current instance.
+
+##### `mapArguments`
+
+```ts
+mapArguments<GNewArguments extends readonly unknown[]>(
+  mapFnc: MapFunctionArguments<GArguments, GNewArguments>,
+): AsyncFunction<GNewArguments, GReturn>
+```
+
+Maps and transforms the arguments of the current async function using the provided mapping function.
+
+- **Type parameters**
+  - `GNewArguments` — The tuple type of the new arguments to be provided to the async function.
+- **Parameters**
+  - `mapFnc` — A function that receives the arguments for the new async function and transforms them into arguments for the current async function.
+- **Returns** A new async function instance that uses the specified mapping function to map its arguments.
+
+```ts
+const fnc = new AsyncFunction(async (signal, a: number, b: number) => a + b);
+const doubled = fnc.mapArguments(
+  (...args: [number]) => [args[0], args[0]] satisfies [number, number],
+);
+const result = await doubled.call(signal, 21); // 42
+```
+
+##### `then`
+
+```ts
+then(onFulfilled?: undefined, onRejectedFunction?: undefined): AsyncFunction<GArguments, GReturn>
+then<GNewReturn>(
+  onFulfilled: AsyncFunctionThenOnFulfilledFunction<GReturn, GNewReturn>,
+  onRejectedFunction?: AsyncFunctionThenOnRejectedFunction<GNewReturn> | undefined,
+): AsyncFunction<GArguments, GNewReturn>
+then<GNewReturn>(
+  onFulfilled: undefined,
+  onRejectedFunction: AsyncFunctionThenOnRejectedFunction<GNewReturn>,
+): AsyncFunction<GArguments, GReturn | GNewReturn>
+```
+
+Chains handlers on the outcome of this async function, like `Promise.then`, but returns a new `AsyncFunction` instead of a `Promise`.
+
+The handlers are applied on each call of the returned async function. The `AbortSignal` received by the call is forwarded to `onFulfilled` and `onRejectedFunction`. If no handler is provided, the value or error is passed through unchanged.
+
+- **Type parameters**
+  - `GNewReturn` — The new type of the return value.
+- **Parameters**
+  - `onFulfilled` — A function invoked with the resolved value and the call's `AbortSignal`, returning the new value (or a promise of it).
+  - `onRejectedFunction` — A function invoked with the thrown error and the call's `AbortSignal`, returning a fallback value (or a promise of it). Defaults to re-throwing the error.
+- **Returns** A new async function resolving with the transformed value.
+
+```ts
+const fnc = new AsyncFunction(async (signal, url: string) => fetch(url, { signal }));
+const status = fnc.then((response) => response.status);
+
+const result = await status.call(signal, 'https://example.com'); // e.g. 200
+```
+
+##### `catch`
+
+```ts
+catch(onRejectedFunction?: undefined): AsyncFunction<GArguments, GReturn>
+catch<GNewReturn>(
+  onRejectedFunction: AsyncFunctionThenOnRejectedFunction<GNewReturn>,
+): AsyncFunction<GArguments, GReturn | GNewReturn>
+```
+
+Handles the errors thrown by this async function, like `Promise.catch`, but returns a new `AsyncFunction` instead of a `Promise`.
+
+The rejection handler is applied on each call of the returned async function. The `AbortSignal` received by the call is forwarded to `onRejectedFunction`. The resolved values are passed through unchanged.
+
+- **Type parameters**
+  - `GNewReturn` — The new type of the return value in case of error.
+- **Parameters**
+  - `onRejectedFunction` — A function invoked with the thrown error and the call's `AbortSignal`, returning a fallback value (or a promise of it). If `undefined`, errors are passed through unchanged.
+- **Returns** A new async function resolving with the original value, or the fallback value when an error occurs.
+
+```ts
+const fnc = new AsyncFunction(async (signal) => fetch('https://example.com', { signal }));
+const safe = fnc.catch((error) => null);
+
+const result = await safe.call(signal); // Response, or null if the request failed
+```
+
+##### `shareConcurentCalls` (experimental)
+
+```ts
+shareConcurentCalls(options: ShareConcurentCallsOptions<GArguments>): AsyncFunction<GArguments, GReturn>
+```
+
+Returns a new async function that deduplicates concurrent calls sharing the same key: while a call is in-flight, subsequent calls with the same key await the same underlying promise instead of triggering a new call.
+
+The first call starts the underlying call with its own `AbortController`. Each caller may abort its own wait without affecting the shared call. When the last consumer settles, the shared controller is aborted, the entry is removed, and a subsequent call starts a new one.
+
+- **Parameters** `options` — Configuration object.
+  - `keyGenerator: (args: GArguments) => string` — A function that generates a cache key from the call's arguments. Calls producing the same key share their result.
+- **Returns** A new async function sharing concurrent calls with identical keys.
+
+```ts
+const loadUser = new AsyncFunction(async (signal, id: string) =>
+  fetchUser(id, { signal }),
+).shareConcurentCalls({ keyGenerator: ([id]) => id });
+
+// 'fetchUser' is called once, both calls await the same result:
+const [a, b] = await Promise.all([loadUser.call(signal, 'a'), loadUser.call(signal, 'a')]);
+```
+
+#### Types
+
+| Type                                     | Description                                                                                                                                  |
+| ---------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------- |
+| `CallAsyncFunction<GArguments, GReturn>` | `(signal: AbortSignal, ...args: GArguments) => PromiseLike<GReturn> \| GReturn` — the shape of the underlying call function.                 |
+| `AsyncFunctionLike<GArguments, GReturn>` | `AsyncFunction<GArguments, GReturn> \| CallAsyncFunction<GArguments, GReturn>` — accepted by the constructor, `of` and `fromSendAndReceive`. |

package/package.json

@@ -1,6 +1,24 @@
 {
   "name": "@xstd/async-function",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "1.1.0",
+  "type": "module",
+  "description": "Universal API around async functions",
+  "keywords": [],
+  "author": "Valentin Richard",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/xstd-js/async-function.git"
+  },
+  "main": "./src/index.js",
+  "types": "./src/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./src/index.d.ts",
+      "default": "./src/index.js"
+    }
+  },
+  "dependencies": {
+    "@xstd/abortable": "^1.2.3"
+  }
 }

package/src/async-function.d.ts

@@ -0,0 +1,154 @@
+import { type AsyncFunctionLike } from './types/async-function-like.ts';
+import { type MapFunctionArguments } from './types/methods/map-arguments/map-function-arguments.ts';
+import { type ShareConcurentCallsOptions } from './types/methods/share-concurent-calls/share-concurent-calls-options.js';
+import { type AsyncFunctionThenOnFulfilledFunction } from './types/methods/then/async-function.then.on-fulfilled-function.ts';
+import { type AsyncFunctionThenOnRejectedFunction } from './types/methods/then/async-function.then.on-rejected-function.ts';
+import { type TransformAsyncFunctionFunction } from './types/methods/transform/transform-async-function-function.ts';
+import { type AsyncFunctionFromSendAndReceiveOptions } from './types/static-methods/from-send-and-receive/async-function-from-send-and-receive-options.ts';
+/**
+ * Represents an asynchronous and abortable function with configurable arguments and specific return value.
+ *
+ * @template GArguments The tuple type of arguments passed to the function.
+ * @template GReturn The type of the return value.
+ */
+export declare class AsyncFunction<GArguments extends readonly unknown[], GReturn> {
+    #private;
+    /**
+     * Returns the given input if it is already an `AsyncFunction`, otherwise wraps it into a new `AsyncFunction` instance.
+     *
+     * @template GArguments The tuple type of arguments passed to the function.
+     * @template GReturn The type of the return value.
+     * @param {AsyncFunctionLike<GArguments, GReturn>} input An `AsyncFunction` instance or a plain call function to wrap.
+     * @returns {AsyncFunction<GArguments, GReturn>} The `AsyncFunction` instance corresponding to `input`.
+     *
+     * @example
+     * ```ts
+     * AsyncFunction.of(asyncFunction); // returns asyncFunction
+     * AsyncFunction.of(async (signal) => 42); // returns a new AsyncFunction wrapping the function
+     * ```
+     */
+    static of<GArguments extends readonly unknown[], GReturn>(input: AsyncFunctionLike<GArguments, GReturn>): AsyncFunction<GArguments, GReturn>;
+    /**
+     * Creates an async function that concurrently triggers a "send" (push) operation and waits for a "receive" (pull) result,
+     * returning the received value once both complete. This is ideal for command-response, RPC, or event-driven patterns
+     * where you must initiate an action and await its corresponding outcome.
+     *
+     * The returned async function is abortable - cancellation via `AbortSignal` will propagate to both the send and receive operations.
+     *
+     * @template GArguments The tuple type of arguments passed to the send and receive async functions.
+     * @template GReturn The type of value returned by the receive operation.
+     * @param {AsyncFunctionFromSendAndReceiveOptions<GReturn>} options Configuration object containing the send and receive async functions.
+     * @param {AsyncFunction<GArguments, void>} options.send  The "push" async function to trigger (e.g., sending a command or message). Must not return a value.
+     * @param {AsyncFunction<GArguments, GReturn>} options.receive The "pull" async function to await (e.g., listening for a response or event). Returns the result.
+     * @returns {AsyncFunction<GArguments, GReturn>} An async function that, when called, returns a promise resolving to the value from `receive`.
+     *   The promise is rejected if either operation fails or is aborted.
+     *
+     * @example
+     *
+     * ```ts
+     * const fnc = AsyncFunction.fromSendAndReceive({
+     *   send: new AsyncFunction((signal) => sendMessage("hello", { signal })),
+     *   receive: new AsyncFunction((signal) => waitForResponse({ signal ))
+     * });
+     *
+     * const result = await fnc.call(signal); // returns response from waitForResponse()
+     * ```
+     *
+     * @example with abortion
+     *
+     * ```ts
+     * const controller = new AbortController();
+     * const result = await fnc.call(controller.signal);
+     * // cancel mid-operation:
+     * controller.abort(); // both send and receive will be aborted.
+     * ```
+     */
+    static fromSendAndReceive<GArguments extends readonly unknown[], GReturn>({ send, receive, }: AsyncFunctionFromSendAndReceiveOptions<GArguments, GReturn>): AsyncFunction<GArguments, GReturn>;
+    /**
+     * Creates an instance of the `AsyncFunction` class.
+     *
+     * @param {AsyncFunctionLike<GArguments, GReturn>} call A call function, or an existing `AsyncFunction`, to be invoked, which defines the action to perform on invocation. If an `AsyncFunction` is provided, its underlying call function is reused instead of being wrapped.
+     */
+    constructor(call: AsyncFunctionLike<GArguments, GReturn>);
+    /**
+     * Executes the specified async function with the provided arguments and options.
+     *
+     * @param {AbortSignal} signal A signal to abort the action execution.
+     * @param {...GArguments} args The arguments to be provided to the async function.
+     * @return {Promise<GReturn>} A promise that resolves with the result of the async function.
+     */
+    call(signal: AbortSignal, ...args: GArguments): Promise<GReturn>;
+    /**
+     * Applies a transformation function to the current instance and returns the result.
+     *
+     * @param {TransformAsyncFunctionFunction<this, GReturn>} transformFnc A function that takes the current instance and returns a transformed value.
+     * @return {GReturn} The result of applying the transformation function to the current instance.
+     */
+    transform<GReturn>(transformFnc: TransformAsyncFunctionFunction<this, GReturn>): GReturn;
+    /**
+     * Maps and transforms the arguments of the current async function using the provided mapping function.
+     *
+     * @template GNewArguments The tuple type of the new arguments to be provided to the async function.
+     * @param {MapFunctionArguments<GArguments, GNewArguments>} mapFnc A function that receives the arguments for the new async function and transforms them into arguments for the current async function.
+     * @return {AsyncFunction<GNewArguments, GReturn>} A new async function instance that uses the specified mapping function to map its arguments.
+     */
+    mapArguments<GNewArguments extends readonly unknown[]>(mapFnc: MapFunctionArguments<GArguments, GNewArguments>): AsyncFunction<GNewArguments, GReturn>;
+    /**
+     * Creates a new async function with the same behaviour as this one (neither a fulfilment nor a rejection handler provided).
+     *
+     * @returns {AsyncFunction<GArguments, GReturn>} A new async function equivalent to this one.
+     */
+    then(onFulfilled?: undefined, onRejectedFunction?: undefined): AsyncFunction<GArguments, GReturn>;
+    /**
+     * Transforms the resolved value of this async function, and optionally handles its errors.
+     *
+     * @template GNewReturn The new type of the return value.
+     * @param {AsyncFunctionThenOnFulfilledFunction<GReturn, GNewReturn>} onFulfilled A function invoked with the resolved value and the call's `AbortSignal`, returning the new value (or a promise of it).
+     * @param {AsyncFunctionThenOnRejectedFunction<GNewReturn>} onRejectedFunction An optional function invoked with the thrown error and the call's `AbortSignal`, returning a fallback value (or a promise of it). Defaults to re-throwing the error.
+     * @returns {AsyncFunction<GArguments, GNewReturn>} A new async function resolving with the transformed value.
+     */
+    then<GNewReturn>(onFulfilled: AsyncFunctionThenOnFulfilledFunction<GReturn, GNewReturn>, onRejectedFunction?: AsyncFunctionThenOnRejectedFunction<GNewReturn> | undefined): AsyncFunction<GArguments, GNewReturn>;
+    /**
+     * Handles the errors thrown by this async function without transforming its resolved value.
+     *
+     * @template GNewReturn The new type of the return value in case of error.
+     * @param {undefined} onFulfilled Must be left `undefined`.
+     * @param {AsyncFunctionThenOnRejectedFunction<GNewReturn>} onRejectedFunction A function invoked with the thrown error and the call's `AbortSignal`, returning a fallback value (or a promise of it).
+     * @returns {AsyncFunction<GArguments, GReturn | GNewReturn>} A new async function resolving with the original value, or the fallback value when an error occurs.
+     */
+    then<GNewReturn>(onFulfilled: undefined, onRejectedFunction: AsyncFunctionThenOnRejectedFunction<GNewReturn>): AsyncFunction<GArguments, GReturn | GNewReturn>;
+    /**
+     * Creates a new async function with the same behaviour as this one (no rejection handler provided).
+     *
+     * @returns {AsyncFunction<GArguments, GReturn>} A new async function equivalent to this one.
+     */
+    catch(onRejectedFunction?: undefined): AsyncFunction<GArguments, GReturn>;
+    /**
+     * Handles the errors thrown by this async function, like `Promise.catch`, but returns a new `AsyncFunction` instead of a `Promise`.
+     *
+     * @template GNewReturn The new type of the return value in case of error.
+     * @param {AsyncFunctionThenOnRejectedFunction<GNewReturn>} onRejectedFunction A function invoked with the thrown error and the call's `AbortSignal`, returning a fallback value (or a promise of it).
+     * @returns {AsyncFunction<GArguments, GReturn | GNewReturn>} A new async function resolving with the original value, or the fallback value when an error occurs.
+     */
+    catch<GNewReturn>(onRejectedFunction: AsyncFunctionThenOnRejectedFunction<GNewReturn>): AsyncFunction<GArguments, GReturn | GNewReturn>;
+    /**
+     * Returns a new async function that deduplicates concurrent calls sharing the same key: while a call is in-flight, subsequent calls with the same key await the same underlying promise instead of triggering a new call.
+     *
+     * The first call starts the underlying call with its own `AbortController`. Each caller may abort its own wait without affecting the shared call. When the last consumer settles, the shared controller is aborted, the entry is removed, and a subsequent call starts a new one.
+     *
+     * @experimental
+     * @param {ShareConcurentCallsOptions<GArguments>} options Configuration object.
+     * @param {ShareConcurentCallsKeyGenerator<GArguments>} options.keyGenerator A function that generates a cache key from the call's arguments. Calls producing the same key share their result.
+     * @returns {AsyncFunction<GArguments, GReturn>} A new async function sharing concurrent calls with identical keys.
+     *
+     * @example
+     * ```ts
+     * const loadUser = new AsyncFunction(async (signal, id: string) => fetchUser(id, { signal }))
+     *   .shareConcurentCalls({ keyGenerator: ([id]) => id });
+     *
+     * // 'fetchUser' is called once, both calls await the same result:
+     * const [a, b] = await Promise.all([loadUser.call(signal, 'a'), loadUser.call(signal, 'a')]);
+     * ```
+     */
+    shareConcurentCalls({ keyGenerator, }: ShareConcurentCallsOptions<GArguments>): AsyncFunction<GArguments, GReturn>;
+}

package/src/async-function.js

@@ -0,0 +1,231 @@
+import { abortify } from '@xstd/abortable';
+import {} from './types/async-function-like.js';
+import {} from './types/call-async-function.js';
+import {} from './types/methods/map-arguments/map-function-arguments.js';
+import {} from './types/methods/share-concurent-calls/share-concurent-calls-options.js';
+import {} from './types/methods/then/async-function.then.on-fulfilled-function.js';
+import {} from './types/methods/then/async-function.then.on-rejected-function.js';
+import { DEFAULT_ASYNC_FUNCTION_THEN_ON_FULFILLED_FUNCTION } from './types/methods/then/default.async-function.then.on-fulfilled-function.private.js';
+import { DEFAULT_ASYNC_FUNCTION_THEN_ON_REJECTED_FUNCTION } from './types/methods/then/default.async-function.then.on-rejected-function.private.js';
+import {} from './types/methods/transform/transform-async-function-function.js';
+import {} from './types/static-methods/from-send-and-receive/async-function-from-send-and-receive-options.js';
+/**
+ * Represents an asynchronous and abortable function with configurable arguments and specific return value.
+ *
+ * @template GArguments The tuple type of arguments passed to the function.
+ * @template GReturn The type of the return value.
+ */
+export class AsyncFunction {
+    /**
+     * Returns the given input if it is already an `AsyncFunction`, otherwise wraps it into a new `AsyncFunction` instance.
+     *
+     * @template GArguments The tuple type of arguments passed to the function.
+     * @template GReturn The type of the return value.
+     * @param {AsyncFunctionLike<GArguments, GReturn>} input An `AsyncFunction` instance or a plain call function to wrap.
+     * @returns {AsyncFunction<GArguments, GReturn>} The `AsyncFunction` instance corresponding to `input`.
+     *
+     * @example
+     * ```ts
+     * AsyncFunction.of(asyncFunction); // returns asyncFunction
+     * AsyncFunction.of(async (signal) => 42); // returns a new AsyncFunction wrapping the function
+     * ```
+     */
+    static of(input) {
+        return input instanceof AsyncFunction ? input : new AsyncFunction(input);
+    }
+    /**
+     * Creates an async function that concurrently triggers a "send" (push) operation and waits for a "receive" (pull) result,
+     * returning the received value once both complete. This is ideal for command-response, RPC, or event-driven patterns
+     * where you must initiate an action and await its corresponding outcome.
+     *
+     * The returned async function is abortable - cancellation via `AbortSignal` will propagate to both the send and receive operations.
+     *
+     * @template GArguments The tuple type of arguments passed to the send and receive async functions.
+     * @template GReturn The type of value returned by the receive operation.
+     * @param {AsyncFunctionFromSendAndReceiveOptions<GReturn>} options Configuration object containing the send and receive async functions.
+     * @param {AsyncFunction<GArguments, void>} options.send  The "push" async function to trigger (e.g., sending a command or message). Must not return a value.
+     * @param {AsyncFunction<GArguments, GReturn>} options.receive The "pull" async function to await (e.g., listening for a response or event). Returns the result.
+     * @returns {AsyncFunction<GArguments, GReturn>} An async function that, when called, returns a promise resolving to the value from `receive`.
+     *   The promise is rejected if either operation fails or is aborted.
+     *
+     * @example
+     *
+     * ```ts
+     * const fnc = AsyncFunction.fromSendAndReceive({
+     *   send: new AsyncFunction((signal) => sendMessage("hello", { signal })),
+     *   receive: new AsyncFunction((signal) => waitForResponse({ signal ))
+     * });
+     *
+     * const result = await fnc.call(signal); // returns response from waitForResponse()
+     * ```
+     *
+     * @example with abortion
+     *
+     * ```ts
+     * const controller = new AbortController();
+     * const result = await fnc.call(controller.signal);
+     * // cancel mid-operation:
+     * controller.abort(); // both send and receive will be aborted.
+     * ```
+     */
+    static fromSendAndReceive({ send, receive, }) {
+        send = AsyncFunction.of(send);
+        receive = AsyncFunction.of(receive);
+        return new AsyncFunction(async (signal, ...args) => {
+            const controller = new AbortController();
+            const sharedSignal = AbortSignal.any([signal, controller.signal]);
+            try {
+                return (await Promise.all([
+                    receive.#call(sharedSignal, ...args),
+                    send.#call(sharedSignal, ...args),
+                ]))[0];
+            }
+            finally {
+                controller.abort();
+            }
+        });
+    }
+    /**
+     * The underlying call function invoked when this async function is called.
+     */
+    #call;
+    /**
+     * Creates an instance of the `AsyncFunction` class.
+     *
+     * @param {AsyncFunctionLike<GArguments, GReturn>} call A call function, or an existing `AsyncFunction`, to be invoked, which defines the action to perform on invocation. If an `AsyncFunction` is provided, its underlying call function is reused instead of being wrapped.
+     */
+    constructor(call) {
+        this.#call = call instanceof AsyncFunction ? call.#call : call;
+    }
+    /**
+     * Executes the specified async function with the provided arguments and options.
+     *
+     * @param {AbortSignal} signal A signal to abort the action execution.
+     * @param {...GArguments} args The arguments to be provided to the async function.
+     * @return {Promise<GReturn>} A promise that resolves with the result of the async function.
+     */
+    call(signal, ...args) {
+        return Promise.try(this.#call, signal, ...args);
+    }
+    /* TRANSFORM */
+    /**
+     * Applies a transformation function to the current instance and returns the result.
+     *
+     * @param {TransformAsyncFunctionFunction<this, GReturn>} transformFnc A function that takes the current instance and returns a transformed value.
+     * @return {GReturn} The result of applying the transformation function to the current instance.
+     */
+    transform(transformFnc) {
+        return transformFnc(this);
+    }
+    /* ARGUMENTS BASED */
+    /**
+     * Maps and transforms the arguments of the current async function using the provided mapping function.
+     *
+     * @template GNewArguments The tuple type of the new arguments to be provided to the async function.
+     * @param {MapFunctionArguments<GArguments, GNewArguments>} mapFnc A function that receives the arguments for the new async function and transforms them into arguments for the current async function.
+     * @return {AsyncFunction<GNewArguments, GReturn>} A new async function instance that uses the specified mapping function to map its arguments.
+     */
+    mapArguments(mapFnc) {
+        return new AsyncFunction((signal, ...args) => {
+            return this.#call(signal, ...mapFnc(...args));
+        });
+    }
+    /**
+     * Chains handlers on the outcome of this async function, like `Promise.then`, but returns a new `AsyncFunction` instead of a `Promise`.
+     *
+     * The handlers are applied on each call of the returned async function. The `AbortSignal` received by the call is forwarded to `onFulfilled` and `onRejectedFunction`. If no handler is provided, the value or error is passed through unchanged.
+     *
+     * @template GNewReturn The new type of the return value.
+     * @param {AsyncFunctionThenOnFulfilledFunction<GReturn, GNewReturn> | undefined} onFulfilled A function invoked with the resolved value and the call's `AbortSignal`, returning the new value (or a promise of it).
+     * @param {AsyncFunctionThenOnRejectedFunction<GNewReturn> | undefined} onRejectedFunction A function invoked with the thrown error and the call's `AbortSignal`, returning a fallback value (or a promise of it).
+     * @returns {AsyncFunction<GArguments, GNewReturn>} A new async function resolving with the transformed value.
+     *
+     * @example
+     * ```ts
+     * const fnc = new AsyncFunction(async (signal, url: string) => fetch(url, { signal }));
+     * const status = fnc.then((response) => response.status);
+     *
+     * const result = await status.call(signal, 'https://example.com'); // e.g. 200
+     * ```
+     */
+    then(onFulfilled = DEFAULT_ASYNC_FUNCTION_THEN_ON_FULFILLED_FUNCTION, onRejectedFunction = DEFAULT_ASYNC_FUNCTION_THEN_ON_REJECTED_FUNCTION) {
+        return new AsyncFunction((signal, ...args) => {
+            return this.call(signal, ...args).then((value) => {
+                return onFulfilled(value, signal);
+            }, (error) => {
+                return onRejectedFunction(error, signal);
+            });
+        });
+    }
+    /**
+     * Handles the errors thrown by this async function, like `Promise.catch`, but returns a new `AsyncFunction` instead of a `Promise`.
+     *
+     * The rejection handler is applied on each call of the returned async function. The `AbortSignal` received by the call is forwarded to `onRejectedFunction`. The resolved values are passed through unchanged.
+     *
+     * @template GNewReturn The new type of the return value in case of error.
+     * @param {AsyncFunctionThenOnRejectedFunction<GNewReturn> | undefined} onRejectedFunction A function invoked with the thrown error and the call's `AbortSignal`, returning a fallback value (or a promise of it). If `undefined`, errors are passed through unchanged.
+     * @returns {AsyncFunction<GArguments, GReturn | GNewReturn>} A new async function resolving with the original value, or the fallback value when an error occurs.
+     *
+     * @example
+     * ```ts
+     * const fnc = new AsyncFunction(async (signal) => fetch('https://example.com', { signal }));
+     * const safe = fnc.catch((error) => null);
+     *
+     * const result = await safe.call(signal); // Response, or null if the request failed
+     * ```
+     */
+    catch(onRejectedFunction) {
+        return this.then(undefined, onRejectedFunction);
+    }
+    /* CONCURRENT */
+    /**
+     * Returns a new async function that deduplicates concurrent calls sharing the same key: while a call is in-flight, subsequent calls with the same key await the same underlying promise instead of triggering a new call.
+     *
+     * The first call starts the underlying call with its own `AbortController`. Each caller may abort its own wait without affecting the shared call. When the last consumer settles, the shared controller is aborted, the entry is removed, and a subsequent call starts a new one.
+     *
+     * @experimental
+     * @param {ShareConcurentCallsOptions<GArguments>} options Configuration object.
+     * @param {ShareConcurentCallsKeyGenerator<GArguments>} options.keyGenerator A function that generates a cache key from the call's arguments. Calls producing the same key share their result.
+     * @returns {AsyncFunction<GArguments, GReturn>} A new async function sharing concurrent calls with identical keys.
+     *
+     * @example
+     * ```ts
+     * const loadUser = new AsyncFunction(async (signal, id: string) => fetchUser(id, { signal }))
+     *   .shareConcurentCalls({ keyGenerator: ([id]) => id });
+     *
+     * // 'fetchUser' is called once, both calls await the same result:
+     * const [a, b] = await Promise.all([loadUser.call(signal, 'a'), loadUser.call(signal, 'a')]);
+     * ```
+     */
+    shareConcurentCalls({ keyGenerator, }) {
+        const map = new Map();
+        return new AsyncFunction(async (signal, ...args) => {
+            signal.throwIfAborted();
+            const key = keyGenerator(args);
+            let entry = map.get(key);
+            if (entry === undefined) {
+                const controller = new AbortController();
+                entry = {
+                    controller,
+                    promise: this.call(controller.signal, ...args),
+                    consumers: 1,
+                };
+                map.set(key, entry);
+            }
+            else {
+                entry.consumers++;
+            }
+            try {
+                return await abortify(entry.promise, { signal });
+            }
+            finally {
+                entry.consumers--;
+                if (entry.consumers === 0) {
+                    entry.controller.abort();
+                    map.delete(key);
+                }
+            }
+        });
+    }
+}
+//# sourceMappingURL=async-function.js.map

package/src/async-function.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"async-function.js","sourceRoot":"","sources":["../../src/async-function.ts"],"names":[],"mappings":"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"}

package/src/index.d.ts

@@ -0,0 +1,9 @@
+export * from './async-function.ts';
+export * from './types/async-function-like.ts';
+export * from './types/call-async-function.ts';
+export * from './types/static-methods/from-send-and-receive/async-function-from-send-and-receive-options.ts';
+export * from './types/methods/transform/transform-async-function-function.ts';
+export * from './types/methods/then/async-function.then.on-fulfilled-function.ts';
+export * from './types/methods/then/async-function.then.on-rejected-function.ts';
+export * from './types/methods/share-concurent-calls/share-concurent-calls-options.ts';
+export * from './types/methods/map-arguments/map-function-arguments.ts';

package/src/index.js

@@ -0,0 +1,10 @@
+export * from './async-function.js';
+export * from './types/async-function-like.js';
+export * from './types/call-async-function.js';
+export * from './types/static-methods/from-send-and-receive/async-function-from-send-and-receive-options.js';
+export * from './types/methods/transform/transform-async-function-function.js';
+export * from './types/methods/then/async-function.then.on-fulfilled-function.js';
+export * from './types/methods/then/async-function.then.on-rejected-function.js';
+export * from './types/methods/share-concurent-calls/share-concurent-calls-options.js';
+export * from './types/methods/map-arguments/map-function-arguments.js';
+//# sourceMappingURL=index.js.map

package/src/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,qBAAqB,CAAC;AACpC,cAAc,gCAAgC,CAAC;AAC/C,cAAc,gCAAgC,CAAC;AAC/C,cAAc,8FAA8F,CAAC;AAC7G,cAAc,gEAAgE,CAAC;AAC/E,cAAc,mEAAmE,CAAC;AAClF,cAAc,kEAAkE,CAAC;AACjF,cAAc,wEAAwE,CAAC;AACvF,cAAc,yDAAyD,CAAC"}

package/src/types/async-function-like.d.ts

@@ -0,0 +1,3 @@
+import { type AsyncFunction } from '../async-function.ts';
+import { type CallAsyncFunction } from './call-async-function.ts';
+export type AsyncFunctionLike<GArguments extends readonly unknown[], GReturn> = AsyncFunction<GArguments, GReturn> | CallAsyncFunction<GArguments, GReturn>;

package/src/types/async-function-like.js

@@ -0,0 +1,3 @@
+import {} from '../async-function.js';
+import {} from './call-async-function.js';
+//# sourceMappingURL=async-function-like.js.map

package/src/types/async-function-like.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"async-function-like.js","sourceRoot":"","sources":["../../../src/types/async-function-like.ts"],"names":[],"mappings":"AAAA,OAAO,EAAsB,MAAM,sBAAsB,CAAC;AAC1D,OAAO,EAA0B,MAAM,0BAA0B,CAAC"}

package/src/types/call-async-function.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Represents an interface for calling an async function with specific arguments and result.
+ *
+ * @template GArguments The tuple type representing the arguments to be provided to the function.
+ * @template GReturn The type of the value returned by the async function.
+ *
+ * @param {AbortSignal} signal A signal to abort the async function execution.
+ * @param {...GArguments} args The arguments to be provided to the function.
+ * @returns {PromiseLike<GReturn> | GReturn} The result of the async function execution, which can be either a resolved value or a Promise-like object resolving the value.
+ */
+export interface CallAsyncFunction<GArguments extends readonly unknown[], GReturn> {
+    (signal: AbortSignal, ...args: GArguments): PromiseLike<GReturn> | GReturn;
+}

package/src/types/call-async-function.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=call-async-function.js.map

package/src/types/call-async-function.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"call-async-function.js","sourceRoot":"","sources":["../../../src/types/call-async-function.ts"],"names":[],"mappings":""}

package/src/types/methods/map-arguments/map-function-arguments.d.ts

@@ -0,0 +1,3 @@
+export interface MapFunctionArguments<GArguments extends readonly unknown[], GNewArguments extends readonly unknown[]> {
+    (...args: GNewArguments): GArguments;
+}

package/src/types/methods/map-arguments/map-function-arguments.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=map-function-arguments.js.map

package/src/types/methods/map-arguments/map-function-arguments.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"map-function-arguments.js","sourceRoot":"","sources":["../../../../../src/types/methods/map-arguments/map-function-arguments.ts"],"names":[],"mappings":""}

package/src/types/methods/share-concurent-calls/share-concurent-calls-options.d.ts

@@ -0,0 +1,6 @@
+export interface ShareConcurentCallsOptions<GArguments extends readonly unknown[]> {
+    readonly keyGenerator: ShareConcurentCallsKeyGenerator<GArguments>;
+}
+export interface ShareConcurentCallsKeyGenerator<GArguments extends readonly unknown[]> {
+    (args: GArguments): string;
+}

package/src/types/methods/share-concurent-calls/share-concurent-calls-options.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=share-concurent-calls-options.js.map

package/src/types/methods/share-concurent-calls/share-concurent-calls-options.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"share-concurent-calls-options.js","sourceRoot":"","sources":["../../../../../src/types/methods/share-concurent-calls/share-concurent-calls-options.ts"],"names":[],"mappings":""}

package/src/types/methods/then/async-function.then.on-fulfilled-function.d.ts

@@ -0,0 +1,3 @@
+export interface AsyncFunctionThenOnFulfilledFunction<GReturn, GNewReturn> {
+    (value: GReturn, signal: AbortSignal): PromiseLike<GNewReturn> | GNewReturn;
+}

package/src/types/methods/then/async-function.then.on-fulfilled-function.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=async-function.then.on-fulfilled-function.js.map

package/src/types/methods/then/async-function.then.on-fulfilled-function.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"async-function.then.on-fulfilled-function.js","sourceRoot":"","sources":["../../../../../src/types/methods/then/async-function.then.on-fulfilled-function.ts"],"names":[],"mappings":""}

package/src/types/methods/then/async-function.then.on-rejected-function.d.ts

@@ -0,0 +1,3 @@
+export interface AsyncFunctionThenOnRejectedFunction<GNewReturn> {
+    (error: unknown, signal: AbortSignal): PromiseLike<GNewReturn> | GNewReturn;
+}

package/src/types/methods/then/async-function.then.on-rejected-function.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=async-function.then.on-rejected-function.js.map

package/src/types/methods/then/async-function.then.on-rejected-function.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"async-function.then.on-rejected-function.js","sourceRoot":"","sources":["../../../../../src/types/methods/then/async-function.then.on-rejected-function.ts"],"names":[],"mappings":""}

package/src/types/methods/then/default.async-function.then.on-fulfilled-function.private.d.ts

@@ -0,0 +1,2 @@
+import { type AsyncFunctionThenOnFulfilledFunction } from './async-function.then.on-fulfilled-function.ts';
+export declare const DEFAULT_ASYNC_FUNCTION_THEN_ON_FULFILLED_FUNCTION: AsyncFunctionThenOnFulfilledFunction<any, any>;

package/src/types/methods/then/default.async-function.then.on-fulfilled-function.private.js

@@ -0,0 +1,3 @@
+import {} from './async-function.then.on-fulfilled-function.js';
+export const DEFAULT_ASYNC_FUNCTION_THEN_ON_FULFILLED_FUNCTION = (value) => value;
+//# sourceMappingURL=default.async-function.then.on-fulfilled-function.private.js.map

package/src/types/methods/then/default.async-function.then.on-fulfilled-function.private.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"default.async-function.then.on-fulfilled-function.private.js","sourceRoot":"","sources":["../../../../../src/types/methods/then/default.async-function.then.on-fulfilled-function.private.ts"],"names":[],"mappings":"AAAA,OAAO,EAA6C,MAAM,gDAAgD,CAAC;AAE3G,MAAM,CAAC,MAAM,iDAAiD,GAAmD,CAC/G,KAAU,EACL,EAAE,CAAC,KAAK,CAAC"}

package/src/types/methods/then/default.async-function.then.on-rejected-function.private.d.ts

@@ -0,0 +1,2 @@
+import { type AsyncFunctionThenOnRejectedFunction } from './async-function.then.on-rejected-function.ts';
+export declare const DEFAULT_ASYNC_FUNCTION_THEN_ON_REJECTED_FUNCTION: AsyncFunctionThenOnRejectedFunction<any>;

package/src/types/methods/then/default.async-function.then.on-rejected-function.private.js

@@ -0,0 +1,5 @@
+import {} from './async-function.then.on-rejected-function.js';
+export const DEFAULT_ASYNC_FUNCTION_THEN_ON_REJECTED_FUNCTION = (error) => {
+    throw error;
+};
+//# sourceMappingURL=default.async-function.then.on-rejected-function.private.js.map

package/src/types/methods/then/default.async-function.then.on-rejected-function.private.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"default.async-function.then.on-rejected-function.private.js","sourceRoot":"","sources":["../../../../../src/types/methods/then/default.async-function.then.on-rejected-function.private.ts"],"names":[],"mappings":"AAAA,OAAO,EAA4C,MAAM,+CAA+C,CAAC;AAEzG,MAAM,CAAC,MAAM,gDAAgD,GAA6C,CACxG,KAAU,EACL,EAAE;IACP,MAAM,KAAK,CAAC;AACd,CAAC,CAAC"}

package/src/types/methods/transform/transform-async-function-function.d.ts

@@ -0,0 +1,4 @@
+import { type AsyncFunction } from '../../../async-function.ts';
+export interface TransformAsyncFunctionFunction<GSelf extends AsyncFunction<any, any>, GReturn> {
+    (self: GSelf): GReturn;
+}

package/src/types/methods/transform/transform-async-function-function.js

@@ -0,0 +1,2 @@
+import {} from '../../../async-function.js';
+//# sourceMappingURL=transform-async-function-function.js.map

package/src/types/methods/transform/transform-async-function-function.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"transform-async-function-function.js","sourceRoot":"","sources":["../../../../../src/types/methods/transform/transform-async-function-function.ts"],"names":[],"mappings":"AAAA,OAAO,EAAsB,MAAM,4BAA4B,CAAC"}

package/src/types/static-methods/from-send-and-receive/async-function-from-send-and-receive-options.d.ts

@@ -0,0 +1,5 @@
+import { type AsyncFunctionLike } from '../../async-function-like.ts';
+export interface AsyncFunctionFromSendAndReceiveOptions<GArguments extends readonly unknown[], GReturn> {
+    readonly send: AsyncFunctionLike<GArguments, void>;
+    readonly receive: AsyncFunctionLike<GArguments, GReturn>;
+}

package/src/types/static-methods/from-send-and-receive/async-function-from-send-and-receive-options.js

@@ -0,0 +1,2 @@
+import {} from '../../async-function-like.js';
+//# sourceMappingURL=async-function-from-send-and-receive-options.js.map

package/src/types/static-methods/from-send-and-receive/async-function-from-send-and-receive-options.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"async-function-from-send-and-receive-options.js","sourceRoot":"","sources":["../../../../../src/types/static-methods/from-send-and-receive/async-function-from-send-and-receive-options.ts"],"names":[],"mappings":"AAAA,OAAO,EAA0B,MAAM,8BAA8B,CAAC"}