@siteimprove/alfa-network 0.89.5

package/CHANGELOG.md

@@ -0,0 +1,151 @@
+# @siteimprove/alfa-network
+
+## 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/index.d.ts

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

package/dist/index.js

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

package/dist/network.d.ts

@@ -0,0 +1,66 @@
+import type { Equatable } from "@siteimprove/alfa-equatable";
+import { Graph } from "@siteimprove/alfa-graph";
+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 Network<N, E> implements Iterable<[N, Iterable<[N, Iterable<E>]>]>, Equatable, Hashable, Serializable<Network.JSON<N, E>> {
+    static of<N, E>(nodes: Map<N, Map<N, Set<E>>>): Network<N, E>;
+    private static _empty;
+    static empty<N, E>(): Network<N, E>;
+    private readonly _nodes;
+    private constructor();
+    get size(): number;
+    isEmpty(): this is Network<N, never>;
+    nodes(): Iterable<N>;
+    neighbors(node: N): Iterable<[N, Iterable<E>]>;
+    edges(from: N, to: N): Iterable<E>;
+    has(node: N): boolean;
+    add(node: N): Network<N, E>;
+    delete(node: N): Network<N, E>;
+    connect(from: N, to: N, ...edges: Array<E>): Network<N, E>;
+    disconnect(from: N, to: N, ...edges: Array<E>): Network<N, E>;
+    traverse(root: N, traversal?: Network.Traversal): Sequence<[node: N, edges: Iterable<E>, parent: N]>;
+    path(from: N, to: N, traversal?: Network.Traversal): Sequence<[node: N, edges: Iterable<E>]>;
+    hasPath(from: N, to: N): boolean;
+    reverse(): Network<N, E>;
+    sort(): Iterable<N>;
+    equals<N, E>(value: Network<N, E>): boolean;
+    equals(value: unknown): value is this;
+    hash(hash: Hash): void;
+    iterator(): Iterator<[N, Iterable<[N, Iterable<E>]>]>;
+    [Symbol.iterator](): Iterator<[N, Iterable<[N, Iterable<E>]>]>;
+    toArray(): Array<[N, Array<[N, Array<E>]>]>;
+    toGraph(): Graph<N>;
+    toJSON(): Network.JSON<N, E>;
+    toString(): string;
+}
+/**
+ * @public
+ */
+export declare namespace Network {
+    type JSON<N, E> = Array<[
+        Serializable.ToJSON<N>,
+        Array<[Serializable.ToJSON<N>, Array<Serializable.ToJSON<E>>]>
+    ]>;
+    function isNetwork<N, E>(value: Iterable<readonly [N, Iterable<readonly [N, Iterable<E>]>]>): value is Network<N, E>;
+    function isNetwork<N, E>(value: unknown): value is Network<N, E>;
+    function from<N, E>(iterable: Iterable<readonly [N, Iterable<readonly [N, Iterable<E>]>]>): Network<N, E>;
+    interface Traversal {
+        <N, E>(network: Network<N, E>, root: N): Iterable<[node: N, edges: Iterable<E>, parent: N]>;
+    }
+    /**
+     * {@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=network.d.ts.map

package/dist/network.js

@@ -0,0 +1,263 @@
+import { Graph } from "@siteimprove/alfa-graph";
+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 Network {
+    static of(nodes) {
+        return new Network(nodes);
+    }
+    static _empty = new Network(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([]);
+    }
+    edges(from, to) {
+        return this._nodes
+            .get(from)
+            .flatMap((neighbors) => neighbors.get(to))
+            .getOr([]);
+    }
+    has(node) {
+        return this._nodes.has(node);
+    }
+    add(node) {
+        if (this.has(node)) {
+            return this;
+        }
+        return new Network(this._nodes.set(node, Map.empty()));
+    }
+    delete(node) {
+        const nodes = this._nodes;
+        if (!nodes.has(node)) {
+            return this;
+        }
+        return new Network(nodes.delete(node).map((neighbors) => neighbors.delete(node)));
+    }
+    connect(from, to, ...edges) {
+        if (edges.length === 0) {
+            return this;
+        }
+        let nodes = this._nodes;
+        if (!nodes.has(from)) {
+            nodes = nodes.set(from, Map.empty());
+        }
+        if (!nodes.has(to)) {
+            nodes = nodes.set(to, Map.empty());
+        }
+        return new Network(nodes.set(from, nodes
+            .get(from)
+            .map((from) => from.set(to, from
+            .get(to)
+            .map((existing) => edges.reduce((edges, edge) => edges.add(edge), existing))
+            .getOrElse(() => Set.from(edges))))
+            // The presence of from is guaranteed by the second test.
+            .getUnsafe()));
+    }
+    disconnect(from, to, ...edges) {
+        if (!this.has(from) || !this.has(to)) {
+            return this;
+        }
+        const nodes = this._nodes;
+        return new Network(nodes.set(from, nodes
+            .get(from)
+            .map((from) => {
+            if (edges.length === 0) {
+                return from.delete(to);
+            }
+            for (let existing of from.get(to)) {
+                existing = edges.reduce((edges, edge) => edges.delete(edge), existing);
+                if (existing.size === 0) {
+                    return from.delete(to);
+                }
+                return from.set(to, existing);
+            }
+            return from;
+        })
+            // The presence of from is guaranteed by the initial test.
+            .getUnsafe()));
+    }
+    traverse(root, traversal = Network.DepthFirst) {
+        return Sequence.from(traversal(this, root));
+    }
+    path(from, to, traversal = Network.BreadthFirst) {
+        const parents = Map.from(Iterable.map(traversal(this, from), ([node, edges, parent]) => [
+            node,
+            [edges, parent],
+        ]));
+        const path = [];
+        while (parents.has(to)) {
+            // The presence of to is guaranteed by the loop condition.
+            const [edges, parent] = parents.get(to).getUnsafe();
+            path.unshift([to, edges]);
+            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 = Network.empty();
+        for (const [node, neighbors] of this._nodes) {
+            reversed = reversed.add(node);
+            for (const [neighbor, edges] of neighbors) {
+                reversed = reversed.connect(neighbor, node, ...edges);
+            }
+        }
+        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 Network && 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].map(([node, edges]) => [node, [...edges]]),
+        ]);
+    }
+    toGraph() {
+        return Graph.from(Iterable.map(this, ([node, neighbors]) => [
+            node,
+            Iterable.map(neighbors, ([node]) => node),
+        ]));
+    }
+    toJSON() {
+        return this.toArray().map(([node, neighbors]) => [
+            Serializable.toJSON(node),
+            neighbors.map(([node, edges]) => [
+                Serializable.toJSON(node),
+                edges.map((edge) => Serializable.toJSON(edge)),
+            ]),
+        ]);
+    }
+    toString() {
+        const entries = this.toArray()
+            .map(([node, neighbors]) => {
+            const entries = neighbors
+                .map(([node, edges]) => {
+                const entries = edges.join(", ");
+                return `${node}${entries === "" ? "" : ` (${entries})`}`;
+            })
+                .join(", ");
+            return `${node}${entries === "" ? "" : ` => [ ${entries} ]`}`;
+        })
+            .join(", ");
+        return `Network {${entries === "" ? "" : ` ${entries} `}}`;
+    }
+}
+/**
+ * @public
+ */
+(function (Network) {
+    function isNetwork(value) {
+        return value instanceof Network;
+    }
+    Network.isNetwork = isNetwork;
+    function from(iterable) {
+        if (isNetwork(iterable)) {
+            return iterable;
+        }
+        return Network.of(Map.from(Iterable.map(iterable, ([node, neighbors]) => [
+            node,
+            Map.from(Iterable.flatMap(neighbors, function* ([node, edges]) {
+                const set = Set.from(edges);
+                if (set.size > 0) {
+                    yield [node, set];
+                }
+            })),
+        ])));
+    }
+    Network.from = from;
+    /**
+     * {@link https://en.wikipedia.org/wiki/Depth-first_search}
+     */
+    Network.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}
+     */
+    Network.BreadthFirst = function* (graph, root) {
+        const queue = [
+            ...graph.neighbors(root),
+        ].map((node) => [...node, root]);
+        let seen = Set.of(root, ...[...graph.neighbors(root)].map(([node]) => node));
+        while (queue.length > 0) {
+            const next = queue.shift();
+            yield next;
+            for (const neighbor of graph.neighbors(next[0])) {
+                if (seen.has(neighbor[0])) {
+                    continue;
+                }
+                seen = seen.add(neighbor[0]);
+                queue.push([...neighbor, next[0]]);
+            }
+        }
+    };
+})(Network || (Network = {}));
+//# sourceMappingURL=network.js.map

package/package.json

@@ -0,0 +1,41 @@
+{
+  "$schema": "http://json.schemastore.org/package",
+  "name": "@siteimprove/alfa-network",
+  "homepage": "https://alfa.siteimprove.com",
+  "version": "0.89.5",
+  "license": "MIT",
+  "description": "An implementation of an immutable, directed graph that allows for multiple, unique edges",
+  "repository": {
+    "type": "git",
+    "url": "github:Siteimprove/alfa",
+    "directory": "packages/alfa-network"
+  },
+  "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-graph": "^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/"
+  }
+}