@siteimprove/alfa-future 0.89.5

package/CHANGELOG.md

@@ -0,0 +1,151 @@
+# @siteimprove/alfa-future
+
+## 0.89.3
+
+## 0.89.2
+
+### Patch Changes
+
+- **Changed:** Trying to fix a problem in generating provenance statements ([#1674](https://github.com/Siteimprove/alfa/pull/1674))
+
+## 0.89.1
+
+### Patch Changes
+
+- **Added:** Trying to publish Alfa packages on the npm registry ([#1673](https://github.com/Siteimprove/alfa/pull/1673))
+
+## 0.89.0
+
+## 0.88.0
+
+### Minor Changes
+
+- **Fixed:** The publish flow was updated to a new version. ([`a2f19cf9a6c7c72b8bf085597e4f1a95ac3e4eb2`](https://github.com/Siteimprove/alfa/commit/a2f19cf9a6c7c72b8bf085597e4f1a95ac3e4eb2))
+
+  Some 0.87.\* versions were generating uninstallable package. This should be fixed now.
+
+## 0.87.12
+
+## 0.87.11
+
+## 0.87.10
+
+## 0.87.7
+
+## 0.87.6
+
+## 0.87.5
+
+## 0.87.4
+
+## 0.87.3
+
+## 0.87.2
+
+## 0.87.1
+
+## 0.87.0
+
+## 0.86.2
+
+## 0.86.1
+
+## 0.86.0
+
+### Minor Changes
+
+- **Breaking:** TS resolution has been changed to `Node16`, target to `es2022`. ([#1636](https://github.com/Siteimprove/alfa/pull/1636))
+
+- **Breaking:** Alfa is now distributed as ESM rather than CJS modules; projects using it must be ESM or use dynamic `import()`. ([#1636](https://github.com/Siteimprove/alfa/pull/1636))
+
+  ⚠️ This is the last of a series of changes on the internal structure and build process of distributed packages that was started with v0.85.0.
+
+## 0.85.1
+
+## 0.85.0
+
+### Minor Changes
+
+- **Breaking:** The .js files are now built in the `dist` folder rather than in `src`. ([#1628](https://github.com/Siteimprove/alfa/pull/1628))
+
+  ⚠️ This is the first of a series of changes on the internal structure and build process of distributed packages. It is probably better to not use this version and wait until more of these internal changes have been done to jump directly to the final result. We are internally releasing these changes for validation purpose only.
+
+  This should not impact consumers, the `package.json` files should be set correctly to consume these files.
+
+## 0.84.0
+
+## 0.83.1
+
+## 0.83.0
+
+## 0.82.0
+
+### Minor Changes
+
+- **Breaking:** Node 18 is no longer supported. ([#1618](https://github.com/Siteimprove/alfa/pull/1618))
+
+## 0.81.0
+
+### Patch Changes
+
+- **Added:** Each package now contains its internal dependency graph in its `docs` directory. ([#1610](https://github.com/Siteimprove/alfa/pull/1610))
+
+## 0.80.0
+
+## 0.79.1
+
+## 0.79.0
+
+## 0.78.2
+
+## 0.78.1
+
+## 0.78.0
+
+## 0.77.0
+
+## 0.76.0
+
+## 0.75.2
+
+## 0.75.1
+
+## 0.75.0
+
+## 0.74.0
+
+## 0.73.0
+
+## 0.72.0
+
+## 0.71.1
+
+## 0.71.0
+
+## 0.70.0
+
+## 0.69.0
+
+## 0.68.0
+
+## 0.67.0
+
+## 0.66.0
+
+## 0.65.1
+
+## 0.65.0
+
+## 0.64.0
+
+## 0.63.3
+
+## 0.63.2
+
+## 0.63.1
+
+## 0.63.0
+
+## 0.62.2
+
+## 0.62.1

package/dist/future.d.ts

@@ -0,0 +1,47 @@
+import type { Applicative } from "@siteimprove/alfa-applicative";
+import type { Callback } from "@siteimprove/alfa-callback";
+import type { Continuation } from "@siteimprove/alfa-continuation";
+import type { Functor } from "@siteimprove/alfa-functor";
+import { Iterable } from "@siteimprove/alfa-iterable";
+import type { Mapper } from "@siteimprove/alfa-mapper";
+import type { Monad } from "@siteimprove/alfa-monad";
+import type { Thenable } from "@siteimprove/alfa-thenable";
+import type { Thunk } from "@siteimprove/alfa-thunk";
+/**
+ * {@link http://blog.higher-order.com/assets/trampolines.pdf}
+ *
+ * @public
+ */
+export declare abstract class Future<T> implements Functor<T>, Applicative<T>, Monad<T>, Thenable<T>, AsyncIterable<T> {
+    protected abstract step(): Future<T>;
+    then(callback: Callback<T>): void;
+    get(): T;
+    abstract isNow(): boolean;
+    abstract isDeferred(): boolean;
+    abstract isSuspended(): boolean;
+    map<U>(mapper: Mapper<T, U>): Future<U>;
+    apply<U>(mapper: Future<Mapper<T, U>>): Future<U>;
+    abstract flatMap<U>(mapper: Mapper<T, Future<U>>): Future<U>;
+    flatten<T>(this: Future<Future<T>>): Future<T>;
+    tee(callback: Callback<T>): Future<T>;
+    asyncIterator(): AsyncIterator<T>;
+    [Symbol.asyncIterator](): AsyncIterator<T>;
+    toPromise(): Promise<T>;
+}
+/**
+ * @public
+ */
+export declare namespace Future {
+    type Maybe<T> = T | Future<T>;
+    function isFuture<T>(value: AsyncIterable<T>): value is Future<T>;
+    function isFuture<T>(value: unknown): value is Future<T>;
+    function empty(): Future<void>;
+    function now<T>(value: T): Future<T>;
+    function defer<T>(continuation: Continuation<T>): Future<T>;
+    function suspend<T>(thunk: Thunk<Future<T>>): Future<T>;
+    function delay<T>(thunk: Thunk<T>): Future<T>;
+    function from<T>(promise: Promise<T> | Thunk<Promise<T>>): Future<T>;
+    function traverse<T, U>(values: Iterable<T>, mapper: Mapper<T, Future<U>, [index: number]>): Future<Iterable<U>>;
+    function sequence<T>(futures: Iterable<Future<T>>): Future<Iterable<T>>;
+}
+//# sourceMappingURL=future.d.ts.map

package/dist/future.js

@@ -0,0 +1,258 @@
+import { Array } from "@siteimprove/alfa-array";
+import { Iterable } from "@siteimprove/alfa-iterable";
+/**
+ * {@link http://blog.higher-order.com/assets/trampolines.pdf}
+ *
+ * @public
+ */
+export class Future {
+    then(callback) {
+        let step = this;
+        while (true) {
+            const next = step.step();
+            if (step !== next) {
+                step = next;
+            }
+            else {
+                return next.then(callback);
+            }
+        }
+    }
+    get() {
+        let step = this;
+        while (true) {
+            const next = step.step();
+            if (step !== next) {
+                step = next;
+            }
+            else {
+                return next.get();
+            }
+        }
+    }
+    map(mapper) {
+        return this.flatMap((value) => Now.of(mapper(value)));
+    }
+    apply(mapper) {
+        return mapper.flatMap((mapper) => this.map(mapper));
+    }
+    flatten() {
+        return this.flatMap((future) => future);
+    }
+    tee(callback) {
+        return this.map((value) => {
+            callback(value);
+            return value;
+        });
+    }
+    async *asyncIterator() {
+        yield this.toPromise();
+    }
+    [Symbol.asyncIterator]() {
+        return this.asyncIterator();
+    }
+    toPromise() {
+        return new Promise((resolve) => this.then(resolve));
+    }
+}
+/**
+ * @public
+ */
+(function (Future) {
+    function isFuture(value) {
+        return value instanceof Future;
+    }
+    Future.isFuture = isFuture;
+    function empty() {
+        return now(undefined);
+    }
+    Future.empty = empty;
+    function now(value) {
+        return Now.of(value);
+    }
+    Future.now = now;
+    function defer(continuation) {
+        return Defer.of(continuation);
+    }
+    Future.defer = defer;
+    function suspend(thunk) {
+        return Suspend.of(thunk);
+    }
+    Future.suspend = suspend;
+    function delay(thunk) {
+        return suspend(() => now(thunk()));
+    }
+    Future.delay = delay;
+    function from(promise) {
+        return Future.defer((callback) => (typeof promise === "function" ? promise() : promise).then(callback));
+    }
+    Future.from = from;
+    function traverse(values, mapper) {
+        return Iterable.reduce(values, (values, value, i) => values.flatMap((values) => mapper(value, i).map((value) => Array.append(values, value))), now(Array.empty()));
+    }
+    Future.traverse = traverse;
+    function sequence(futures) {
+        return traverse(futures, (value) => value);
+    }
+    Future.sequence = sequence;
+})(Future || (Future = {}));
+class Now extends Future {
+    static of(value) {
+        return new Now(value);
+    }
+    _value;
+    constructor(value) {
+        super();
+        this._value = value;
+    }
+    step() {
+        return this;
+    }
+    then(callback) {
+        callback(this._value);
+    }
+    get() {
+        return this._value;
+    }
+    isNow() {
+        return true;
+    }
+    isDeferred() {
+        return false;
+    }
+    isSuspended() {
+        return false;
+    }
+    map(mapper) {
+        return new Now(mapper(this._value));
+    }
+    flatMap(mapper) {
+        return Suspend.of(() => mapper(this._value));
+    }
+}
+class Defer extends Future {
+    static of(continuation) {
+        return new Defer(continuation);
+    }
+    _continuation;
+    constructor(continuation) {
+        super();
+        this._continuation = continuation;
+    }
+    step() {
+        return this;
+    }
+    then(callback) {
+        this._continuation((value) => defer(() => callback(value)));
+    }
+    get() {
+        throw new Error("Attempted to .get() from deferred future");
+    }
+    isNow() {
+        return false;
+    }
+    isDeferred() {
+        return true;
+    }
+    isSuspended() {
+        return false;
+    }
+    flatMap(mapper) {
+        return Defer.Bind.of(this._continuation, mapper);
+    }
+}
+(function (Defer) {
+    class Bind extends Future {
+        static of(continuation, mapper) {
+            return new Bind(continuation, mapper);
+        }
+        _continuation;
+        _mapper;
+        constructor(continuation, mapper) {
+            super();
+            this._continuation = continuation;
+            this._mapper = mapper;
+        }
+        step() {
+            return this;
+        }
+        then(callback) {
+            this._continuation((value) => defer(() => this._mapper(value).then(callback)));
+        }
+        get() {
+            throw new Error("Attempted to .get() from deferred future");
+        }
+        isNow() {
+            return false;
+        }
+        isDeferred() {
+            return true;
+        }
+        isSuspended() {
+            return false;
+        }
+        flatMap(mapper) {
+            return Suspend.of(() => Bind.of(this._continuation, (value) => this._mapper(value).flatMap(mapper)));
+        }
+    }
+    Defer.Bind = Bind;
+})(Defer || (Defer = {}));
+class Suspend extends Future {
+    static of(thunk) {
+        return new Suspend(thunk);
+    }
+    _thunk;
+    constructor(thunk) {
+        super();
+        this._thunk = thunk;
+    }
+    step() {
+        return this._thunk();
+    }
+    isNow() {
+        return false;
+    }
+    isDeferred() {
+        return false;
+    }
+    isSuspended() {
+        return true;
+    }
+    flatMap(mapper) {
+        return Suspend.Bind.of(this._thunk, mapper);
+    }
+}
+(function (Suspend) {
+    class Bind extends Future {
+        static of(thunk, mapper) {
+            return new Bind(thunk, mapper);
+        }
+        _thunk;
+        _mapper;
+        constructor(thunk, mapper) {
+            super();
+            this._thunk = thunk;
+            this._mapper = mapper;
+        }
+        step() {
+            return this._thunk().flatMap(this._mapper);
+        }
+        isNow() {
+            return false;
+        }
+        isDeferred() {
+            return false;
+        }
+        isSuspended() {
+            return true;
+        }
+        flatMap(mapper) {
+            return Suspend.of(() => Bind.of(this._thunk, (value) => this._mapper(value).flatMap(mapper)));
+        }
+    }
+    Suspend.Bind = Bind;
+})(Suspend || (Suspend = {}));
+async function defer(thunk) {
+    return Promise.resolve().then(thunk);
+}
+//# sourceMappingURL=future.js.map

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./future.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -0,0 +1,2 @@
+export * from "./future.js";
+//# sourceMappingURL=index.js.map

package/package.json

@@ -0,0 +1,43 @@
+{
+  "$schema": "http://json.schemastore.org/package",
+  "name": "@siteimprove/alfa-future",
+  "homepage": "https://alfa.siteimprove.com",
+  "version": "0.89.5",
+  "license": "MIT",
+  "description": "An implementation of futures, which are a lazy version of promises for dealing with possibly asynchronous control flow",
+  "repository": {
+    "type": "git",
+    "url": "github:Siteimprove/alfa",
+    "directory": "packages/alfa-future"
+  },
+  "bugs": "https://github.com/siteimprove/alfa/issues",
+  "engines": {
+    "node": ">=20.0.0"
+  },
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist/**/*.js",
+    "dist/**/*.d.ts"
+  ],
+  "dependencies": {
+    "@siteimprove/alfa-applicative": "^0.89.5",
+    "@siteimprove/alfa-array": "^0.89.5",
+    "@siteimprove/alfa-callback": "^0.89.5",
+    "@siteimprove/alfa-continuation": "^0.89.5",
+    "@siteimprove/alfa-functor": "^0.89.5",
+    "@siteimprove/alfa-iterable": "^0.89.5",
+    "@siteimprove/alfa-mapper": "^0.89.5",
+    "@siteimprove/alfa-monad": "^0.89.5",
+    "@siteimprove/alfa-thenable": "^0.89.5",
+    "@siteimprove/alfa-thunk": "^0.89.5"
+  },
+  "devDependencies": {
+    "@siteimprove/alfa-test": "^0.89.5"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://npm.pkg.github.com/"
+  }
+}