@siteimprove/alfa-graph 0.89.5

package/CHANGELOG.md

@@ -0,0 +1,157 @@
+# @siteimprove/alfa-graph
+
+## 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
+
+### Minor Changes
+
+- **Breaking:** Optional serialization type parameters have been removed. ([#1651](https://github.com/Siteimprove/alfa/pull/1651))
+
+## 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
+
+- **Added:** Serialization options are now accepted, and passed on, by `toJSON()` on these types. ([#1622](https://github.com/Siteimprove/alfa/pull/1622))
+
+- **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/graph.d.ts

@@ -0,0 +1,63 @@
+import type { Equatable } from "@siteimprove/alfa-equatable";
+import type { Hashable, Hash } from "@siteimprove/alfa-hash";
+import { Iterable } from "@siteimprove/alfa-iterable";
+import { Serializable } from "@siteimprove/alfa-json";
+import { Map } from "@siteimprove/alfa-map";
+import { Sequence } from "@siteimprove/alfa-sequence";
+import { Set } from "@siteimprove/alfa-set";
+/**
+ * @public
+ */
+export declare class Graph<T> implements Iterable<[T, Iterable<T>]>, Equatable, Hashable, Serializable<Graph.JSON<T>> {
+    static of<T>(nodes: Map<T, Set<T>>): Graph<T>;
+    private static _empty;
+    static empty<T>(): Graph<T>;
+    private readonly _nodes;
+    private constructor();
+    get size(): number;
+    isEmpty(): this is Graph<never>;
+    nodes(): Iterable<T>;
+    neighbors(node: T): Iterable<T>;
+    has(node: T): boolean;
+    add(node: T): Graph<T>;
+    delete(node: T): Graph<T>;
+    connect(from: T, to: T): Graph<T>;
+    disconnect(from: T, to: T): Graph<T>;
+    traverse(root: T, traversal?: Graph.Traversal): Sequence<[node: T, parent: T]>;
+    path(from: T, to: T, traversal?: Graph.Traversal): Sequence<T>;
+    hasPath(from: T, to: T): boolean;
+    reverse(): Graph<T>;
+    sort(): Iterable<T>;
+    equals<T>(value: Graph<T>): boolean;
+    equals(value: unknown): value is this;
+    hash(hash: Hash): void;
+    iterator(): Iterator<[T, Iterable<T>]>;
+    [Symbol.iterator](): Iterator<[T, Iterable<T>]>;
+    toArray(): Array<[T, Array<T>]>;
+    toJSON(options?: Serializable.Options): Graph.JSON<T>;
+    toString(): string;
+}
+/**
+ * @public
+ */
+export declare namespace Graph {
+    type JSON<T> = Array<[
+        Serializable.ToJSON<T>,
+        Array<Serializable.ToJSON<T>>
+    ]>;
+    function isGraph<T>(value: Iterable<readonly [T, Iterable<T>]>): value is Graph<T>;
+    function isGraph<T>(value: unknown): value is Graph<T>;
+    function from<T>(iterable: Iterable<readonly [T, Iterable<T>]>): Graph<T>;
+    interface Traversal {
+        <T>(graph: Graph<T>, root: T): Iterable<[node: T, parent: T]>;
+    }
+    /**
+     * {@link https://en.wikipedia.org/wiki/Depth-first_search}
+     */
+    const DepthFirst: Traversal;
+    /**
+     * {@link https://en.wikipedia.org/wiki/Breadth-first_search}
+     */
+    const BreadthFirst: Traversal;
+}
+//# sourceMappingURL=graph.d.ts.map

package/dist/graph.js

@@ -0,0 +1,211 @@
+import { Iterable } from "@siteimprove/alfa-iterable";
+import { Serializable } from "@siteimprove/alfa-json";
+import { Map } from "@siteimprove/alfa-map";
+import { Sequence } from "@siteimprove/alfa-sequence";
+import { Set } from "@siteimprove/alfa-set";
+/**
+ * @public
+ */
+export class Graph {
+    static of(nodes) {
+        return new Graph(nodes);
+    }
+    static _empty = new Graph(Map.empty());
+    static empty() {
+        return this._empty;
+    }
+    _nodes;
+    constructor(nodes) {
+        this._nodes = nodes;
+    }
+    get size() {
+        return this._nodes.size;
+    }
+    isEmpty() {
+        return this._nodes.isEmpty();
+    }
+    nodes() {
+        return this._nodes.keys();
+    }
+    neighbors(node) {
+        return this._nodes.get(node).getOr([]);
+    }
+    has(node) {
+        return this._nodes.has(node);
+    }
+    add(node) {
+        if (this.has(node)) {
+            return this;
+        }
+        return new Graph(this._nodes.set(node, Set.empty()));
+    }
+    delete(node) {
+        const nodes = this._nodes;
+        if (!nodes.has(node)) {
+            return this;
+        }
+        return new Graph(nodes.delete(node).map((neighbors) => neighbors.delete(node)));
+    }
+    connect(from, to) {
+        let nodes = this._nodes;
+        if (!nodes.has(from)) {
+            nodes = nodes.set(from, Set.empty());
+        }
+        if (!nodes.has(to)) {
+            nodes = nodes.set(to, Set.empty());
+        }
+        return new Graph(nodes.set(from, nodes
+            .get(from)
+            .map((from) => from.add(to))
+            // Presence of from is guaranteed by first test.
+            .getUnsafe()));
+    }
+    disconnect(from, to) {
+        if (!this.has(from) || !this.has(to)) {
+            return this;
+        }
+        const nodes = this._nodes;
+        return new Graph(nodes.set(from, nodes
+            .get(from)
+            .map((from) => from.delete(to))
+            // presence of from is guaranteed by first test.
+            .getUnsafe()));
+    }
+    traverse(root, traversal = Graph.DepthFirst) {
+        return Sequence.from(traversal(this, root));
+    }
+    path(from, to, traversal = Graph.BreadthFirst) {
+        const parents = Map.from(traversal(this, from));
+        const path = [];
+        while (parents.has(to)) {
+            const parent = parents
+                .get(to)
+                // presence of to is guaranteed by the loop condition
+                .getUnsafe();
+            path.unshift(to);
+            to = parent;
+        }
+        return Sequence.from(path);
+    }
+    hasPath(from, to) {
+        if (!this.has(from) || !this.has(to)) {
+            return false;
+        }
+        return this.traverse(from)
+            .map(([node]) => node)
+            .includes(to);
+    }
+    reverse() {
+        let reversed = Graph.empty();
+        for (const [node, neighbors] of this._nodes) {
+            reversed = reversed.add(node);
+            for (const neighbor of neighbors) {
+                reversed = reversed.connect(neighbor, node);
+            }
+        }
+        return reversed;
+    }
+    *sort() {
+        let incoming = this.reverse();
+        const queue = incoming
+            .toArray()
+            .filter(([, edges]) => edges.length === 0)
+            .map(([node]) => node);
+        while (queue.length > 0) {
+            const next = queue.shift();
+            yield next;
+            for (const neighbor of this.neighbors(next)) {
+                incoming = incoming.disconnect(neighbor, next);
+                if (Iterable.isEmpty(incoming.neighbors(neighbor))) {
+                    queue.push(neighbor);
+                }
+            }
+        }
+    }
+    equals(value) {
+        return value instanceof Graph && value._nodes.equals(this._nodes);
+    }
+    hash(hash) {
+        hash.writeHashable(this._nodes);
+    }
+    *iterator() {
+        yield* this._nodes;
+    }
+    [Symbol.iterator]() {
+        return this.iterator();
+    }
+    toArray() {
+        return [...this].map(([node, neighbors]) => [node, [...neighbors]]);
+    }
+    toJSON(options) {
+        return this.toArray().map(([node, neighbors]) => [
+            Serializable.toJSON(node, options),
+            neighbors.map((node) => Serializable.toJSON(node, options)),
+        ]);
+    }
+    toString() {
+        const entries = this.toArray()
+            .map(([node, edges]) => {
+            const entries = edges.join(", ");
+            return `${node}${entries === "" ? "" : ` => [ ${entries} ]`}`;
+        })
+            .join(", ");
+        return `Graph {${entries === "" ? "" : ` ${entries} `}}`;
+    }
+}
+/**
+ * @public
+ */
+(function (Graph) {
+    function isGraph(value) {
+        return value instanceof Graph;
+    }
+    Graph.isGraph = isGraph;
+    function from(iterable) {
+        if (isGraph(iterable)) {
+            return iterable;
+        }
+        return Graph.of(Map.from(Iterable.map(iterable, ([node, neighbours]) => [
+            node,
+            Set.from(neighbours),
+        ])));
+    }
+    Graph.from = from;
+    /**
+     * {@link https://en.wikipedia.org/wiki/Depth-first_search}
+     */
+    Graph.DepthFirst = function* (graph, root) {
+        const stack = [...graph.neighbors(root)].map((node) => [node, root]);
+        let seen = Set.of(root);
+        while (stack.length > 0) {
+            const next = stack.pop();
+            if (seen.has(next[0])) {
+                continue;
+            }
+            yield next;
+            seen = seen.add(next[0]);
+            for (const neighbor of graph.neighbors(next[0])) {
+                stack.push([neighbor, next[0]]);
+            }
+        }
+    };
+    /**
+     * {@link https://en.wikipedia.org/wiki/Breadth-first_search}
+     */
+    Graph.BreadthFirst = function* (graph, root) {
+        const queue = [...graph.neighbors(root)].map((node) => [node, root]);
+        let seen = Set.of(root, ...graph.neighbors(root));
+        while (queue.length > 0) {
+            const next = queue.shift();
+            yield next;
+            for (const neighbor of graph.neighbors(next[0])) {
+                if (seen.has(neighbor)) {
+                    continue;
+                }
+                seen = seen.add(neighbor);
+                queue.push([neighbor, next[0]]);
+            }
+        }
+    };
+})(Graph || (Graph = {}));
+//# sourceMappingURL=graph.js.map

package/dist/index.d.ts

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

package/dist/index.js

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

package/package.json

@@ -0,0 +1,40 @@
+{
+  "$schema": "http://json.schemastore.org/package",
+  "name": "@siteimprove/alfa-graph",
+  "homepage": "https://alfa.siteimprove.com",
+  "version": "0.89.5",
+  "license": "MIT",
+  "description": "An implementation of an immutable, directed graph",
+  "repository": {
+    "type": "git",
+    "url": "github:Siteimprove/alfa",
+    "directory": "packages/alfa-graph"
+  },
+  "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-equatable": "^0.89.5",
+    "@siteimprove/alfa-hash": "^0.89.5",
+    "@siteimprove/alfa-iterable": "^0.89.5",
+    "@siteimprove/alfa-json": "^0.89.5",
+    "@siteimprove/alfa-map": "^0.89.5",
+    "@siteimprove/alfa-sequence": "^0.89.5",
+    "@siteimprove/alfa-set": "^0.89.5"
+  },
+  "devDependencies": {
+    "@siteimprove/alfa-test": "^0.89.5"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://npm.pkg.github.com/"
+  }
+}