@siteimprove/alfa-hash 0.89.5

package/CHANGELOG.md

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

@@ -0,0 +1,70 @@
+import type { Equatable } from "@siteimprove/alfa-equatable";
+import type { JSON } from "@siteimprove/alfa-json";
+import { Hashable } from "./hashable.js";
+/**
+ * @public
+ */
+export declare abstract class Hash implements Equatable, Hashable {
+    /**
+     * A map from objects to their hash values. Objects are weakly referenced as
+     * to not prevent them from being garbage collected.
+     */
+    private static _objectHashes;
+    /**
+     * A map from symbols to their hash values. As there's not currently a way to
+     * weakly reference symbols, we have to instead use strong references.
+     *
+     * {@link https://github.com/tc39/proposal-symbols-as-weakmap-keys}
+     */
+    private static _symbolHashes;
+    /**
+     * The next available hash value. This is used for symbols and objects that
+     * don't implement the {@link (Hashable:interface)} interface.
+     */
+    private static _nextHash;
+    protected constructor();
+    /**
+     * Get the current hash value as a 32-bit integer.
+     *
+     * @remarks
+     * The method is limited to 32-bit integers as this is the limit of bitwise
+     * operations in JavaScript.
+     */
+    abstract finish(): number;
+    abstract write(data: Uint8Array): this;
+    writeString(data: string): this;
+    /**
+     * @remarks
+     * As JavaScript represents numbers in double-precision floating-point format,
+     * numbers in general will be written as such.
+     *
+     * {@link https://en.wikipedia.org/wiki/Double-precision_floating-point_format}
+     */
+    writeNumber(data: number): this;
+    writeInt(data: number, size?: 8 | 16 | 32, signed?: boolean): this;
+    writeInt8(data: number): this;
+    writeUint8(data: number): this;
+    writeInt16(data: number): this;
+    writeUint16(data: number): this;
+    writeInt32(data: number): this;
+    writeUint32(data: number): this;
+    writeBigInt(data: bigint, size?: 64, signed?: boolean): this;
+    writeBigInt64(data: bigint): this;
+    writeBigUint64(data: bigint): this;
+    writeFloat(data: number, size?: 32 | 64): this;
+    writeFloat32(data: number): this;
+    writeFloat64(data: number): this;
+    writeBoolean(data: boolean): this;
+    writeUndefined(): this;
+    writeNull(): this;
+    writeObject(data: object): this;
+    writeSymbol(data: symbol): this;
+    writeHashable(data: Hashable): this;
+    writeUnknown(data: unknown): this;
+    writeJSON(data: JSON): this;
+    equals(value: Hash): boolean;
+    equals(value: unknown): value is this;
+    hash(hash: Hash): void;
+    private static _getNextHash;
+}
+//# sourceMappingURL=hash.d.ts.map

package/dist/hash.js

@@ -0,0 +1,209 @@
+import { Encoder } from "@siteimprove/alfa-encoding";
+import { Hashable } from "./hashable.js";
+const { keys } = Object;
+/**
+ * A special offset used for the builtin types `true`, `false`, `undefined`, and
+ * `null`. The offset is designed to minimize the chance of collisions for data
+ * structures that rely on 5-bit partitioning. We use the first 30 bits for 6 of
+ * these partitions, leaving us 2 bits to encode the 4 builtin types.
+ */
+const builtinOffset = 0b10000_10000_10000_10000_10000_10000_00;
+/**
+ * @public
+ */
+export class Hash {
+    /**
+     * A map from objects to their hash values. Objects are weakly referenced as
+     * to not prevent them from being garbage collected.
+     */
+    static _objectHashes = new WeakMap();
+    /**
+     * A map from symbols to their hash values. As there's not currently a way to
+     * weakly reference symbols, we have to instead use strong references.
+     *
+     * {@link https://github.com/tc39/proposal-symbols-as-weakmap-keys}
+     */
+    static _symbolHashes = new Map();
+    /**
+     * The next available hash value. This is used for symbols and objects that
+     * don't implement the {@link (Hashable:interface)} interface.
+     */
+    static _nextHash = 0;
+    constructor() { }
+    writeString(data) {
+        return this.write(Encoder.encode(data));
+    }
+    /**
+     * @remarks
+     * As JavaScript represents numbers in double-precision floating-point format,
+     * numbers in general will be written as such.
+     *
+     * {@link https://en.wikipedia.org/wiki/Double-precision_floating-point_format}
+     */
+    writeNumber(data) {
+        return this.writeFloat64(data);
+    }
+    writeInt(data, size = 32, signed = true) {
+        const buffer = new ArrayBuffer(size / 8);
+        const view = new DataView(buffer);
+        switch (size) {
+            case 8:
+                signed ? view.setInt8(0, data) : view.setUint8(0, data);
+                break;
+            case 16:
+                signed ? view.setInt16(0, data) : view.setUint16(0, data);
+                break;
+            case 32:
+                signed ? view.setInt32(0, data) : view.setUint32(0, data);
+        }
+        return this.write(new Uint8Array(buffer));
+    }
+    writeInt8(data) {
+        return this.writeInt(data, 8, true);
+    }
+    writeUint8(data) {
+        return this.writeInt(data, 8, false);
+    }
+    writeInt16(data) {
+        return this.writeInt(data, 16, true);
+    }
+    writeUint16(data) {
+        return this.writeInt(data, 16, false);
+    }
+    writeInt32(data) {
+        return this.writeInt(data, 32, true);
+    }
+    writeUint32(data) {
+        return this.writeInt(data, 32, false);
+    }
+    writeBigInt(data, size = 64, signed = true) {
+        const buffer = new ArrayBuffer(size / 8);
+        const view = new DataView(buffer);
+        switch (size) {
+            case 64:
+                signed ? view.setBigInt64(0, data) : view.setBigUint64(0, data);
+        }
+        return this.write(new Uint8Array(buffer));
+    }
+    writeBigInt64(data) {
+        return this.writeBigInt(data, 64, true);
+    }
+    writeBigUint64(data) {
+        return this.writeBigInt(data, 64, false);
+    }
+    writeFloat(data, size = 32) {
+        const buffer = new ArrayBuffer(size / 8);
+        const view = new DataView(buffer);
+        switch (size) {
+            case 32:
+                view.setFloat32(0, data);
+                break;
+            case 64:
+                view.setFloat64(0, data);
+        }
+        return this.write(new Uint8Array(buffer));
+    }
+    writeFloat32(data) {
+        return this.writeFloat(data, 32);
+    }
+    writeFloat64(data) {
+        return this.writeFloat(data, 64);
+    }
+    writeBoolean(data) {
+        return this.writeUint8(builtinOffset + (data ? 1 : 0));
+    }
+    writeUndefined() {
+        return this.writeUint32(builtinOffset + 2);
+    }
+    writeNull() {
+        return this.writeUint32(builtinOffset + 3);
+    }
+    writeObject(data) {
+        let hash = Hash._objectHashes.get(data);
+        if (hash === undefined) {
+            hash = Hash._getNextHash();
+            Hash._objectHashes.set(data, hash);
+        }
+        return this.writeUint32(hash);
+    }
+    writeSymbol(data) {
+        let hash = Hash._symbolHashes.get(data);
+        if (hash === undefined) {
+            hash = Hash._getNextHash();
+            Hash._symbolHashes.set(data, hash);
+        }
+        return this.writeUint32(hash);
+    }
+    writeHashable(data) {
+        data.hash(this);
+        return this;
+    }
+    writeUnknown(data) {
+        switch (typeof data) {
+            case "string":
+                return this.writeString(data);
+            case "number":
+                return this.writeNumber(data);
+            case "bigint":
+                return this.writeBigInt(data);
+            case "boolean":
+                return this.writeBoolean(data);
+            case "symbol":
+                return this.writeSymbol(data);
+            case "undefined":
+                return this.writeUndefined();
+            case "object":
+                if (data === null) {
+                    return this.writeNull();
+                }
+                if (Hashable.isHashable(data)) {
+                    return this.writeHashable(data);
+                }
+                return this.writeObject(data);
+            case "function":
+                return this.writeObject(data);
+        }
+    }
+    writeJSON(data) {
+        switch (typeof data) {
+            case "string":
+                return this.writeString(data);
+            case "number":
+                return this.writeNumber(data);
+            case "boolean":
+                return this.writeBoolean(data);
+            case "object":
+                if (Array.isArray(data)) {
+                    for (let i = 0, n = data.length; i < n; i++) {
+                        this.writeJSON(data[i]);
+                    }
+                    this.writeUint32(data.length);
+                }
+                else if (data !== null) {
+                    for (const key of keys(data).sort()) {
+                        const value = data[key];
+                        this.writeString(key);
+                        if (value !== undefined) {
+                            this.writeJSON(value);
+                        }
+                        // Write a null byte as a separator between key/value pairs.
+                        this.writeUint8(0);
+                    }
+                }
+                return this;
+        }
+    }
+    equals(value) {
+        return value instanceof Hash && value.finish() === this.finish();
+    }
+    hash(hash) {
+        hash.writeUint32(this.finish());
+    }
+    static _getNextHash() {
+        const nextHash = Hash._nextHash;
+        // Increase the hash, wrapping around when it reaches the limit of 32 bits.
+        Hash._nextHash = (Hash._nextHash + 1) >>> 0;
+        return nextHash;
+    }
+}
+//# sourceMappingURL=hash.js.map

package/dist/hashable.d.ts

@@ -0,0 +1,14 @@
+import type { Hash } from "./hash.js";
+/**
+ * @public
+ */
+export interface Hashable {
+    hash(hash: Hash): void;
+}
+/**
+ * @public
+ */
+export declare namespace Hashable {
+    function isHashable(value: unknown): value is Hashable;
+}
+//# sourceMappingURL=hashable.d.ts.map

package/dist/hashable.js

@@ -0,0 +1,13 @@
+import { Refinement } from "@siteimprove/alfa-refinement";
+const { isFunction, isObject } = Refinement;
+/**
+ * @public
+ */
+export var Hashable;
+(function (Hashable) {
+    function isHashable(value) {
+        return isObject(value) && isFunction(value.hash);
+    }
+    Hashable.isHashable = isHashable;
+})(Hashable || (Hashable = {}));
+//# sourceMappingURL=hashable.js.map

package/dist/index.d.ts

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

package/dist/index.js

@@ -0,0 +1,3 @@
+export * from "./hash.js";
+export * from "./hashable.js";
+//# sourceMappingURL=index.js.map

package/package.json

@@ -0,0 +1,34 @@
+{
+  "$schema": "http://json.schemastore.org/package",
+  "name": "@siteimprove/alfa-hash",
+  "homepage": "https://alfa.siteimprove.com",
+  "version": "0.89.5",
+  "license": "MIT",
+  "description": "Types for modelling structures that support hashing",
+  "repository": {
+    "type": "git",
+    "url": "github:Siteimprove/alfa",
+    "directory": "packages/alfa-hash"
+  },
+  "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-encoding": "^0.89.5",
+    "@siteimprove/alfa-equatable": "^0.89.5",
+    "@siteimprove/alfa-json": "^0.89.5",
+    "@siteimprove/alfa-refinement": "^0.89.5"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://npm.pkg.github.com/"
+  }
+}