@siteimprove/alfa-option 0.89.5

package/CHANGELOG.md

@@ -0,0 +1,169 @@
+# @siteimprove/alfa-option
+
+## 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
+
+### Minor Changes
+
+- **Changed:** Types have been tightened a bit. ([#1634](https://github.com/Siteimprove/alfa/pull/1634))
+
+  This was needed to update to TypeScript 5.5, due to the improved [inferrence of type predicates](https://devblogs.microsoft.com/typescript/announcing-typescript-5-5/#inferred-type-predicates)
+
+## 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
+
+### Minor Changes
+
+- **Breaking:** Moved `Maybe` type out of `Option` namespace ([#1402](https://github.com/Siteimprove/alfa/pull/1402))
+
+  The type was moved while adding the function `Maybe.toOption`. The type is an internal convenience type that is only used when it's not possible or practical to use `Option`. To migrate, import `Maybe` from the `alfa-option` package and replace `Option.Maybe` with `Maybe`.
+
+## 0.62.2
+
+## 0.62.1

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./maybe.js";
+export * from "./none.js";
+export * from "./option.js";
+export * from "./some.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -0,0 +1,5 @@
+export * from "./maybe.js";
+export * from "./none.js";
+export * from "./option.js";
+export * from "./some.js";
+//# sourceMappingURL=index.js.map

package/dist/maybe.d.ts

@@ -0,0 +1,15 @@
+import { Option } from "./option.js";
+/**
+ * @remarks
+ * Should only be used when it's not possible or practical to use `Option<T>`
+ *
+ * @internal
+ */
+export type Maybe<T> = T | Option<T>;
+/**
+ * @internal
+ */
+export declare namespace Maybe {
+    function toOption<T>(maybe: Maybe<T>): Option<T>;
+}
+//# sourceMappingURL=maybe.d.ts.map

package/dist/maybe.js

@@ -0,0 +1,12 @@
+import { Option } from "./option.js";
+/**
+ * @internal
+ */
+export var Maybe;
+(function (Maybe) {
+    function toOption(maybe) {
+        return Option.isOption(maybe) ? maybe : Option.of(maybe);
+    }
+    Maybe.toOption = toOption;
+})(Maybe || (Maybe = {}));
+//# sourceMappingURL=maybe.js.map

package/dist/none.d.ts

@@ -0,0 +1,21 @@
+import type * as json from "@siteimprove/alfa-json";
+import type { Option } from "./option.js";
+/**
+ * @public
+ */
+export interface None extends Option<never> {
+}
+/**
+ * @public
+ */
+export declare const None: None;
+/**
+ * @public
+ */
+export declare namespace None {
+    interface JSON {
+        [key: string]: json.JSON;
+        type: "none";
+    }
+}
+//# sourceMappingURL=none.d.ts.map

package/dist/none.js

@@ -0,0 +1,101 @@
+import { Comparable, Comparison } from "@siteimprove/alfa-comparable";
+const { compareComparable } = Comparable;
+/**
+ * @public
+ */
+export const None = new (class None {
+    isSome() {
+        return false;
+    }
+    isNone() {
+        return true;
+    }
+    map() {
+        return this;
+    }
+    forEach() {
+        return;
+    }
+    apply() {
+        return this;
+    }
+    flatMap() {
+        return this;
+    }
+    flatten() {
+        return this;
+    }
+    reduce(reducer, accumulator) {
+        return accumulator;
+    }
+    filter() {
+        return this;
+    }
+    reject() {
+        return this;
+    }
+    includes() {
+        return false;
+    }
+    some() {
+        return false;
+    }
+    none() {
+        return true;
+    }
+    every() {
+        return true;
+    }
+    and() {
+        return this;
+    }
+    andThen() {
+        return this;
+    }
+    or(option) {
+        return option;
+    }
+    orElse(option) {
+        return option();
+    }
+    /**
+     * @internal
+     */
+    getUnsafe(message = "Attempted to .getUnsafe() from None") {
+        throw new Error(message);
+    }
+    getOr(value) {
+        return value;
+    }
+    getOrElse(value) {
+        return value();
+    }
+    tee() {
+        return this;
+    }
+    compare(option) {
+        return this.compareWith(option, compareComparable);
+    }
+    compareWith(option) {
+        return option.isNone() ? Comparison.Equal : Comparison.Less;
+    }
+    equals(value) {
+        return value instanceof None;
+    }
+    hash(hash) {
+        hash.writeBoolean(false);
+    }
+    *[Symbol.iterator]() { }
+    toArray() {
+        return [];
+    }
+    toJSON() {
+        return {
+            type: "none",
+        };
+    }
+    toString() {
+        return "None";
+    }
+})();
+//# sourceMappingURL=none.js.map

package/dist/option.d.ts

@@ -0,0 +1,74 @@
+import type { Callback } from "@siteimprove/alfa-callback";
+import type { Comparable, Comparison } from "@siteimprove/alfa-comparable";
+import { type Comparer } from "@siteimprove/alfa-comparable";
+import type { Equatable } from "@siteimprove/alfa-equatable";
+import type { Foldable } from "@siteimprove/alfa-foldable";
+import type { Hashable } from "@siteimprove/alfa-hash";
+import type { Serializable } from "@siteimprove/alfa-json";
+import type { Mapper } from "@siteimprove/alfa-mapper";
+import type { Monad } from "@siteimprove/alfa-monad";
+import type { Predicate } from "@siteimprove/alfa-predicate";
+import type { Reducer } from "@siteimprove/alfa-reducer";
+import type { Refinement } from "@siteimprove/alfa-refinement";
+import type { Thunk } from "@siteimprove/alfa-thunk";
+import { None } from "./none.js";
+import { Some } from "./some.js";
+/**
+ * @public
+ */
+export interface Option<T> extends Monad<T>, Foldable<T>, Iterable<T>, Equatable, Hashable, Serializable<Option.JSON<T>> {
+    isSome(): this is Some<T>;
+    isNone(): this is None;
+    map<U>(mapper: Mapper<T, U>): Option<U>;
+    forEach(mapper: Mapper<T, void>): void;
+    apply<U>(mapper: Option<Mapper<T, U>>): Option<U>;
+    flatMap<U>(mapper: Mapper<T, Option<U>>): Option<U>;
+    flatten<T>(this: Option<Option<T>>): Option<T>;
+    reduce<U>(reducer: Reducer<T, U>, accumulator: U): U;
+    filter<U extends T>(refinement: Refinement<T, U>): Option<U>;
+    filter(predicate: Predicate<T>): Option<T>;
+    reject<U extends T>(refinement: Refinement<T, U>): Option<Exclude<T, U>>;
+    reject(predicate: Predicate<T>): Option<T>;
+    includes(value: T): boolean;
+    some<U extends T>(refinement: Refinement<T, U>): this is Some<U>;
+    some(predicate: Predicate<T>): boolean;
+    none<U extends T>(refinement: Refinement<T, U>): this is Option<Exclude<T, U>>;
+    none(predicate: Predicate<T>): boolean;
+    every<U extends T>(refinement: Refinement<T, U>): this is Option<U>;
+    every(predicate: Predicate<T>): boolean;
+    and<U>(option: Option<U>): Option<U>;
+    andThen<U>(option: Mapper<T, Option<U>>): Option<U>;
+    or<U>(option: Option<U>): Option<T | U>;
+    orElse<U>(option: Thunk<Option<U>>): Option<T | U>;
+    /**
+     * This may throw an exception. Use only when you can provide an external
+     * guarantee that it won't be used on None. E.g. in tests, or when some
+     * condition exists that TypeScript cannot see (document it!)
+     *
+     * @internal
+     */
+    getUnsafe(message?: string): T;
+    getOr<U>(value: U): T | U;
+    getOrElse<U>(value: Thunk<U>): T | U;
+    tee(callback: Callback<T>): Option<T>;
+    compare<T>(this: Option<Comparable<T>>, option: Option<T>): Comparison;
+    compareWith<U = T>(option: Option<U>, comparer: Comparer<T, U>): Comparison;
+    toArray(): Array<T>;
+    toJSON(options?: Serializable.Options): Option.JSON<T>;
+}
+/**
+ * @public
+ */
+export declare namespace Option {
+    type JSON<T> = Some.JSON<T> | None.JSON;
+    function isOption<T>(value: Iterable<T>): value is Option<T>;
+    function isOption<T>(value: unknown): value is Option<T>;
+    function isSome<T>(value: Iterable<T>): value is Some<T>;
+    function isSome<T>(value: unknown): value is Some<T>;
+    function isNone<T>(value: Iterable<T>): value is None;
+    function isNone(value: unknown): value is None;
+    function of<T>(value: T): Some<T>;
+    function empty<T>(): None;
+    function from<T>(value: T | null | undefined): Option<NonNullable<T>>;
+}
+//# sourceMappingURL=option.d.ts.map

package/dist/option.js

@@ -0,0 +1,34 @@
+import {} from "@siteimprove/alfa-comparable";
+import { None } from "./none.js";
+import { Some } from "./some.js";
+/**
+ * @public
+ */
+export var Option;
+(function (Option) {
+    function isOption(value) {
+        return isSome(value) || isNone(value);
+    }
+    Option.isOption = isOption;
+    function isSome(value) {
+        return Some.isSome(value);
+    }
+    Option.isSome = isSome;
+    function isNone(value) {
+        return value === None;
+    }
+    Option.isNone = isNone;
+    function of(value) {
+        return Some.of(value);
+    }
+    Option.of = of;
+    function empty() {
+        return None;
+    }
+    Option.empty = empty;
+    function from(value) {
+        return value === null || value === undefined ? None : Some.of(value);
+    }
+    Option.from = from;
+})(Option || (Option = {}));
+//# sourceMappingURL=option.js.map

package/dist/some.d.ts

@@ -0,0 +1,71 @@
+import type { Callback } from "@siteimprove/alfa-callback";
+import { Comparable, type Comparer, Comparison } from "@siteimprove/alfa-comparable";
+import type { Hash } from "@siteimprove/alfa-hash";
+import { Serializable } from "@siteimprove/alfa-json";
+import type { Mapper } from "@siteimprove/alfa-mapper";
+import { Predicate } from "@siteimprove/alfa-predicate";
+import type { Reducer } from "@siteimprove/alfa-reducer";
+import type { Refinement } from "@siteimprove/alfa-refinement";
+import type * as json from "@siteimprove/alfa-json";
+import type { Option } from "./option.js";
+import { None } from "./none.js";
+/**
+ * @public
+ */
+export declare class Some<T> implements Option<T> {
+    static of<T>(value: T): Some<T>;
+    private readonly _value;
+    private constructor();
+    isSome(): this is Some<T>;
+    isNone(): this is None;
+    map<U>(mapper: Mapper<T, U>): Some<U>;
+    forEach(mapper: Mapper<T, void>): void;
+    apply<U>(mapper: Option<Mapper<T, U>>): Option<U>;
+    flatMap<U>(mapper: Mapper<T, Option<U>>): Option<U>;
+    flatten<T>(this: Some<Option<T>>): Option<T>;
+    reduce<U>(reducer: Reducer<T, U>, accumulator: U): U;
+    filter<U extends T>(refinement: Refinement<T, U>): Option<U>;
+    filter(predicate: Predicate<T>): Option<T>;
+    reject<U extends T>(refinement: Refinement<T, U>): Option<Exclude<T, U>>;
+    reject(predicate: Predicate<T>): Option<T>;
+    includes(value: T): boolean;
+    some<U extends T>(refinement: Refinement<T, U>): this is Some<U>;
+    some(predicate: Predicate<T>): boolean;
+    none<U extends T>(refinement: Refinement<T, U>): this is Some<Exclude<T, U>>;
+    none(predicate: Predicate<T>): boolean;
+    every<U extends T>(refinement: Refinement<T, U>): this is Some<U>;
+    every(predicate: Predicate<T>): boolean;
+    and<U>(option: Option<U>): Option<U>;
+    andThen<U>(option: Mapper<T, Option<U>>): Option<U>;
+    or(): Some<T>;
+    orElse(): Some<T>;
+    get(): T;
+    /**
+     * @internal
+     */
+    getUnsafe(): T;
+    getOr(): T;
+    getOrElse(): T;
+    tee(callback: Callback<T>): this;
+    compare<T>(this: Option<Comparable<T>>, option: Option<T>): Comparison;
+    compareWith<U = T>(option: Option<U>, comparer: Comparer<T, U>): Comparison;
+    equals(value: unknown): value is this;
+    hash(hash: Hash): void;
+    [Symbol.iterator](): Iterator<T>;
+    toArray(): [T];
+    toJSON(options?: Serializable.Options): Some.JSON<T>;
+    toString(): string;
+}
+/**
+ * @public
+ */
+export declare namespace Some {
+    interface JSON<T> {
+        [key: string]: json.JSON;
+        type: "some";
+        value: Serializable.ToJSON<T>;
+    }
+    function isSome<T>(value: Iterable<T>): value is Some<T>;
+    function isSome<T>(value: unknown): value is Some<T>;
+}
+//# sourceMappingURL=some.d.ts.map

package/dist/some.js

@@ -0,0 +1,131 @@
+import { Comparable, Comparison, } from "@siteimprove/alfa-comparable";
+import { Equatable } from "@siteimprove/alfa-equatable";
+import { Serializable } from "@siteimprove/alfa-json";
+import { Predicate } from "@siteimprove/alfa-predicate";
+import { None } from "./none.js";
+const { not, test } = Predicate;
+const { compareComparable } = Comparable;
+/**
+ * @public
+ */
+export class Some {
+    static of(value) {
+        return new Some(value);
+    }
+    _value;
+    constructor(value) {
+        this._value = value;
+    }
+    isSome() {
+        return true;
+    }
+    isNone() {
+        return false;
+    }
+    map(mapper) {
+        return new Some(mapper(this._value));
+    }
+    forEach(mapper) {
+        mapper(this._value);
+    }
+    apply(mapper) {
+        return mapper.map((mapper) => mapper(this._value));
+    }
+    flatMap(mapper) {
+        return mapper(this._value);
+    }
+    flatten() {
+        return this._value;
+    }
+    reduce(reducer, accumulator) {
+        return reducer(accumulator, this._value);
+    }
+    filter(predicate) {
+        return test(predicate, this._value) ? this : None;
+    }
+    reject(predicate) {
+        return this.filter(not(predicate));
+    }
+    includes(value) {
+        return Equatable.equals(value, this._value);
+    }
+    some(predicate) {
+        return test(predicate, this._value);
+    }
+    none(predicate) {
+        return test(not(predicate), this._value);
+    }
+    every(predicate) {
+        return test(predicate, this._value);
+    }
+    and(option) {
+        return option;
+    }
+    andThen(option) {
+        return option(this._value);
+    }
+    or() {
+        return this;
+    }
+    orElse() {
+        return this;
+    }
+    get() {
+        return this._value;
+    }
+    /**
+     * @internal
+     */
+    getUnsafe() {
+        return this._value;
+    }
+    getOr() {
+        return this._value;
+    }
+    getOrElse() {
+        return this._value;
+    }
+    tee(callback) {
+        callback(this._value);
+        return this;
+    }
+    compare(option) {
+        return this.compareWith(option, compareComparable);
+    }
+    compareWith(option, comparer) {
+        return option.isSome()
+            ? comparer(this._value, option._value)
+            : Comparison.Greater;
+    }
+    equals(value) {
+        return value instanceof Some && Equatable.equals(value._value, this._value);
+    }
+    hash(hash) {
+        hash.writeBoolean(true).writeUnknown(this._value);
+    }
+    *[Symbol.iterator]() {
+        yield this._value;
+    }
+    toArray() {
+        return [this._value];
+    }
+    toJSON(options) {
+        return {
+            type: "some",
+            value: Serializable.toJSON(this._value, options),
+        };
+    }
+    toString() {
+        return `Some { ${this._value} }`;
+    }
+}
+/**
+ * @public
+ */
+(function (Some) {
+    function isSome(value) {
+        return value instanceof Some;
+    }
+    Some.isSome = isSome;
+})(Some || (Some = {}));
+//# sourceMappingURL=some.js.map

package/package.json

@@ -0,0 +1,45 @@
+{
+  "$schema": "http://json.schemastore.org/package",
+  "name": "@siteimprove/alfa-option",
+  "homepage": "https://alfa.siteimprove.com",
+  "version": "0.89.5",
+  "license": "MIT",
+  "description": "An implementation of optional values, which are values that may or may not be present",
+  "repository": {
+    "type": "git",
+    "url": "github:Siteimprove/alfa",
+    "directory": "packages/alfa-option"
+  },
+  "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-callback": "^0.89.5",
+    "@siteimprove/alfa-comparable": "^0.89.5",
+    "@siteimprove/alfa-equatable": "^0.89.5",
+    "@siteimprove/alfa-foldable": "^0.89.5",
+    "@siteimprove/alfa-hash": "^0.89.5",
+    "@siteimprove/alfa-json": "^0.89.5",
+    "@siteimprove/alfa-mapper": "^0.89.5",
+    "@siteimprove/alfa-monad": "^0.89.5",
+    "@siteimprove/alfa-predicate": "^0.89.5",
+    "@siteimprove/alfa-reducer": "^0.89.5",
+    "@siteimprove/alfa-refinement": "^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/"
+  }
+}