@siteimprove/alfa-dom 0.89.2

package/dist/node/attribute/predicate.js

@@ -0,0 +1,2 @@
+export * from "./predicate/has-name.js";
+//# sourceMappingURL=predicate.js.map

package/dist/node/attribute.d.ts

@@ -0,0 +1,90 @@
+import { Option } from "@siteimprove/alfa-option";
+import { Sequence } from "@siteimprove/alfa-sequence";
+import { Trampoline } from "@siteimprove/alfa-trampoline";
+import * as json from "@siteimprove/alfa-json";
+import { Namespace } from "../namespace.js";
+import { Node } from "../node.js";
+import type { Element } from "./element.js";
+import * as predicate from "./attribute/predicate.js";
+/**
+ * @public
+ */
+export declare class Attribute<N extends string = string> extends Node<"attribute"> {
+    static of<N extends string = string>(namespace: Option<Namespace>, prefix: Option<string>, name: N, value: string, externalId?: string, serializationId?: string, extraData?: any): Attribute<N>;
+    private readonly _namespace;
+    private readonly _prefix;
+    private readonly _name;
+    private readonly _value;
+    private _owner;
+    private constructor();
+    get namespace(): Option<Namespace>;
+    get prefix(): Option<string>;
+    get name(): N | Lowercase<N>;
+    get qualifiedName(): string;
+    get value(): string;
+    get owner(): Option<Element>;
+    /**
+     * {@link https://html.spec.whatwg.org/#boolean-attribute}
+     */
+    isBoolean(): boolean;
+    /**
+     * @internal
+     **/
+    protected _internalPath(options?: Node.Traversal): string;
+    /**
+     * {@link https://html.spec.whatwg.org/#space-separated-tokens}
+     */
+    tokens(separator?: string | RegExp): Sequence<string>;
+    /**
+     * {@link https://html.spec.whatwg.org/#enumerated-attribute}
+     */
+    enumerate(): Option<string>;
+    /**
+     * {@link https://html.spec.whatwg.org/#enumerated-attribute}
+     */
+    enumerate<T extends string>(valid: T, ...rest: Array<T>): Option<T>;
+    toJSON(options: Node.SerializationOptions & {
+        verbosity: json.Serializable.Verbosity.Minimal | json.Serializable.Verbosity.Low;
+    }): Attribute.MinimalJSON;
+    toJSON(options?: Node.SerializationOptions): Attribute.JSON<N>;
+    toString(): string;
+    /**
+     * @internal
+     */
+    _attachParent(): boolean;
+    /**
+     * @internal
+     */
+    _attachOwner(owner: Element): boolean;
+}
+/**
+ * @public
+ */
+export declare namespace Attribute {
+    interface MinimalJSON extends Node.JSON<"attribute"> {
+    }
+    interface JSON<N extends string = string> extends Node.JSON<"attribute"> {
+        namespace: string | null;
+        prefix: string | null;
+        name: N;
+        value: string;
+    }
+    function isAttribute(value: unknown): value is Attribute;
+    /**
+     * @internal
+     */
+    function fromAttribute<N extends string = string>(attribute: JSON<N>): Trampoline<Attribute<N>>;
+    /**
+     * @internal
+     */
+    function cloneAttribute<N extends string = string>(attribute: Attribute<N>): Trampoline<Attribute<N | Lowercase<N>>>;
+    /**
+     * Conditionally fold the case of an attribute name based on its owner; HTML
+     * attributes are case insensitive while attributes in other namespaces aren't.
+     *
+     * @internal
+     */
+    function foldCase<N extends string = string>(name: N, owner: Option<Element>): N | Lowercase<N>;
+    const hasName: typeof predicate.hasName;
+}
+//# sourceMappingURL=attribute.d.ts.map

package/dist/node/attribute.js

@@ -0,0 +1,164 @@
+import { Iterable } from "@siteimprove/alfa-iterable";
+import { None, Option } from "@siteimprove/alfa-option";
+import { Predicate } from "@siteimprove/alfa-predicate";
+import { Sequence } from "@siteimprove/alfa-sequence";
+import { Trampoline } from "@siteimprove/alfa-trampoline";
+import * as json from "@siteimprove/alfa-json";
+import { Namespace } from "../namespace.js";
+import { Node } from "../node.js";
+import * as predicate from "./attribute/predicate.js";
+const { isEmpty } = Iterable;
+const { equals, not } = Predicate;
+/**
+ * @public
+ */
+export class Attribute extends Node {
+    static of(namespace, prefix, name, value, externalId, serializationId, extraData) {
+        return new Attribute(namespace, prefix, name, value, externalId, serializationId, extraData);
+    }
+    _namespace;
+    _prefix;
+    _name;
+    _value;
+    _owner = None;
+    constructor(namespace, prefix, name, value, externalId, serializationId, extraData) {
+        super([], "attribute", externalId, serializationId, extraData);
+        this._namespace = namespace;
+        this._prefix = prefix;
+        this._name = name;
+        this._value = value;
+    }
+    get namespace() {
+        return this._namespace;
+    }
+    get prefix() {
+        return this._prefix;
+    }
+    get name() {
+        return Attribute.foldCase(this._name, this._owner);
+    }
+    get qualifiedName() {
+        return this._prefix.reduce((name, prefix) => `${prefix}:${name}`, this._name);
+    }
+    get value() {
+        return this._value;
+    }
+    get owner() {
+        return this._owner;
+    }
+    /**
+     * {@link https://html.spec.whatwg.org/#boolean-attribute}
+     */
+    isBoolean() {
+        switch (this.name) {
+            case "allowfullscreen":
+            case "allowpaymentrequest":
+            case "async":
+            case "autofocus":
+            case "autoplay":
+            case "checked":
+            case "controls":
+            case "default":
+                return true;
+            default:
+                return false;
+        }
+    }
+    /**
+     * @internal
+     **/
+    _internalPath(options) {
+        let path = this.owner.map((owner) => owner.path(options)).getOr("/");
+        path += path === "/" ? "" : "/";
+        path += `@${this.name}`;
+        return path;
+    }
+    /**
+     * {@link https://html.spec.whatwg.org/#space-separated-tokens}
+     */
+    tokens(separator = /\s+/) {
+        return Sequence.from(this._value.trim().split(separator).filter(not(isEmpty)));
+    }
+    enumerate(...valid) {
+        const value = this._value.toLowerCase();
+        return valid.length === 0 || valid.includes(value)
+            ? Option.of(value)
+            : None;
+    }
+    toJSON(options) {
+        const result = {
+            ...super.toJSON(options),
+        };
+        delete result.children;
+        const verbosity = options?.verbosity ?? json.Serializable.Verbosity.Medium;
+        if (verbosity < json.Serializable.Verbosity.Medium) {
+            return result;
+        }
+        result.namespace = this._namespace.getOr(null);
+        result.prefix = this._prefix.getOr(null);
+        result.name = this._name;
+        result.value = this._value;
+        return result;
+    }
+    toString() {
+        const name = this.qualifiedName;
+        if (this.isBoolean()) {
+            return name;
+        }
+        return `${name}="${this._value.replace(/"/g, "&quot;")}"`;
+    }
+    /**
+     * @internal
+     */
+    _attachParent() {
+        return false;
+    }
+    /**
+     * @internal
+     */
+    _attachOwner(owner) {
+        if (this._frozen || this._owner.isSome()) {
+            return false;
+        }
+        this._owner = Option.of(owner);
+        this._frozen = true;
+        return true;
+    }
+}
+/**
+ * @public
+ */
+(function (Attribute) {
+    function isAttribute(value) {
+        return value instanceof Attribute;
+    }
+    Attribute.isAttribute = isAttribute;
+    /**
+     * @internal
+     */
+    function fromAttribute(attribute) {
+        return Trampoline.done(Attribute.of(Option.from(attribute.namespace), Option.from(attribute.prefix), attribute.name, attribute.value, attribute.externalId, attribute.serializationId));
+    }
+    Attribute.fromAttribute = fromAttribute;
+    /**
+     * @internal
+     */
+    function cloneAttribute(attribute) {
+        return Trampoline.done(Attribute.of(attribute.namespace, attribute.prefix, attribute.name, attribute.value, attribute.externalId, attribute.serializationId, attribute.extraData));
+    }
+    Attribute.cloneAttribute = cloneAttribute;
+    /**
+     * Conditionally fold the case of an attribute name based on its owner; HTML
+     * attributes are case insensitive while attributes in other namespaces aren't.
+     *
+     * @internal
+     */
+    function foldCase(name, owner) {
+        return owner.some((owner) => owner.namespace.some(equals(Namespace.HTML)))
+            ? name.toLowerCase()
+            : name;
+    }
+    Attribute.foldCase = foldCase;
+    Attribute.hasName = predicate.hasName;
+})(Attribute || (Attribute = {}));
+//# sourceMappingURL=attribute.js.map

package/dist/node/comment.d.ts

@@ -0,0 +1,42 @@
+import { Trampoline } from "@siteimprove/alfa-trampoline";
+import * as json from "@siteimprove/alfa-json";
+import { Node } from "../node.js";
+/**
+ * @public
+ */
+export declare class Comment extends Node<"comment"> {
+    static of(data: string, externalId?: string, serializationId?: string, extraData?: any): Comment;
+    static empty(): Comment;
+    private readonly _data;
+    private constructor();
+    get data(): string;
+    /**
+     * @internal
+     **/
+    protected _internalPath(options?: Node.Traversal): string;
+    toJSON(options: Node.SerializationOptions & {
+        verbosity: json.Serializable.Verbosity.Minimal | json.Serializable.Verbosity.Low;
+    }): Comment.MinimalJSON;
+    toJSON(options?: Node.SerializationOptions): Comment.JSON;
+    toString(): string;
+}
+/**
+ * @public
+ */
+export declare namespace Comment {
+    interface MinimalJSON extends Node.JSON<"comment"> {
+    }
+    interface JSON extends Node.JSON<"comment"> {
+        data: string;
+    }
+    function isComment(value: unknown): value is Comment;
+    /**
+     * @internal
+     */
+    function fromComment(json: JSON): Trampoline<Comment>;
+    /**
+     * @internal
+     */
+    function cloneComment(comment: Comment): Trampoline<Comment>;
+}
+//# sourceMappingURL=comment.d.ts.map

package/dist/node/comment.js

@@ -0,0 +1,74 @@
+import { Trampoline } from "@siteimprove/alfa-trampoline";
+import * as json from "@siteimprove/alfa-json";
+import { Node } from "../node.js";
+/**
+ * @public
+ */
+export class Comment extends Node {
+    static of(data, externalId, serializationId, extraData) {
+        return new Comment(data, externalId, serializationId, extraData);
+    }
+    static empty() {
+        return new Comment("");
+    }
+    _data;
+    constructor(data, externalId, serializationId, extraData) {
+        super([], "comment", externalId, serializationId, extraData);
+        this._data = data;
+    }
+    get data() {
+        return this._data;
+    }
+    /**
+     * @internal
+     **/
+    _internalPath(options) {
+        let path = this.parent(options)
+            .map((parent) => parent.path(options))
+            .getOr("/");
+        path += path === "/" ? "" : "/";
+        path += "comment()";
+        const index = this.preceding(options).count(Comment.isComment);
+        path += `[${index + 1}]`;
+        return path;
+    }
+    toJSON(options) {
+        const result = {
+            ...super.toJSON(options),
+        };
+        delete result.children;
+        const verbosity = options?.verbosity ?? json.Serializable.Verbosity.Medium;
+        if (verbosity < json.Serializable.Verbosity.Medium) {
+            return result;
+        }
+        result.data = this._data;
+        return result;
+    }
+    toString() {
+        return `<!--${this._data}-->`;
+    }
+}
+/**
+ * @public
+ */
+(function (Comment) {
+    function isComment(value) {
+        return value instanceof Comment;
+    }
+    Comment.isComment = isComment;
+    /**
+     * @internal
+     */
+    function fromComment(json) {
+        return Trampoline.done(Comment.of(json.data, json.externalId, json.serializationId));
+    }
+    Comment.fromComment = fromComment;
+    /**
+     * @internal
+     */
+    function cloneComment(comment) {
+        return Trampoline.done(Comment.of(comment.data, comment.externalId, comment.serializationId, comment.extraData));
+    }
+    Comment.cloneComment = cloneComment;
+})(Comment || (Comment = {}));
+//# sourceMappingURL=comment.js.map

package/dist/node/document.d.ts

@@ -0,0 +1,59 @@
+import { Array } from "@siteimprove/alfa-array";
+import type { Device } from "@siteimprove/alfa-device";
+import { Iterable } from "@siteimprove/alfa-iterable";
+import { Option } from "@siteimprove/alfa-option";
+import { Trampoline } from "@siteimprove/alfa-trampoline";
+import * as json from "@siteimprove/alfa-json";
+import { Node } from "../node.js";
+import { Sheet } from "../style/sheet.js";
+import { Element } from "./element.js";
+/**
+ * @public
+ */
+export declare class Document extends Node<"document"> {
+    static of(children: Iterable<Node>, style?: Iterable<Sheet>, externalId?: string, serializationId?: string, extraData?: any): Document;
+    static empty(): Document;
+    private readonly _style;
+    private _frame;
+    private constructor();
+    get style(): Iterable<Sheet>;
+    get frame(): Option<Element>;
+    parent(options?: Node.Traversal): Option<Node>;
+    /**
+     * @internal
+     **/
+    protected _internalPath(options?: Node.Traversal): string;
+    toJSON(options: Node.SerializationOptions & {
+        verbosity: json.Serializable.Verbosity.Minimal | json.Serializable.Verbosity.Low;
+    }): Document.MinimalJSON;
+    toJSON(options?: Node.SerializationOptions): Document.JSON;
+    toString(): string;
+    /**
+     * @internal
+     */
+    _attachParent(): boolean;
+    /**
+     * @internal
+     */
+    _attachFrame(frame: Element): boolean;
+}
+/**
+ * @public
+ */
+export declare namespace Document {
+    interface MinimalJSON extends Node.JSON<"document"> {
+    }
+    interface JSON extends Node.JSON<"document"> {
+        style: Array<Sheet.JSON>;
+    }
+    function isDocument(value: unknown): value is Document;
+    /**
+     * @internal
+     */
+    function fromDocument(json: JSON, device?: Device): Trampoline<Document>;
+    /**
+     * @internal
+     */
+    function cloneDocument(options: Node.ElementReplacementOptions, device?: Device): (document: Document) => Trampoline<Document>;
+}
+//# sourceMappingURL=document.d.ts.map

package/dist/node/document.js

@@ -0,0 +1,113 @@
+import { Array } from "@siteimprove/alfa-array";
+import { Iterable } from "@siteimprove/alfa-iterable";
+import { None, Option } from "@siteimprove/alfa-option";
+import { String } from "@siteimprove/alfa-string";
+import { Trampoline } from "@siteimprove/alfa-trampoline";
+import * as json from "@siteimprove/alfa-json";
+import { Node } from "../node.js";
+import { Sheet } from "../style/sheet.js";
+import { Element } from "./element.js";
+/**
+ * @public
+ */
+export class Document extends Node {
+    static of(children, style = [], externalId, serializationId, extraData) {
+        return new Document(Array.from(children), style, externalId, serializationId, extraData);
+    }
+    static empty() {
+        return new Document([], []);
+    }
+    _style;
+    _frame = None;
+    constructor(children, style, externalId, serializationId, extraData) {
+        super(children, "document", externalId, serializationId, extraData);
+        this._style = Array.from(style);
+    }
+    get style() {
+        return this._style;
+    }
+    get frame() {
+        return this._frame;
+    }
+    parent(options = Node.Traversal.empty) {
+        return options.isSet(Node.Traversal.nested)
+            ? this.frame
+            : super.parent(options);
+    }
+    /**
+     * @internal
+     **/
+    _internalPath(options = Node.Traversal.empty) {
+        if (options.isSet(Node.Traversal.nested)) {
+            return this._frame
+                .map((frame) => frame.path(options) + "/document-node()")
+                .getOr("/");
+        }
+        return "/";
+    }
+    toJSON(options) {
+        const result = {
+            ...super.toJSON(options),
+        };
+        const verbosity = options?.verbosity ?? json.Serializable.Verbosity.Medium;
+        if (verbosity < json.Serializable.Verbosity.Medium) {
+            return result;
+        }
+        result.style = this._style.map((sheet) => sheet.toJSON());
+        return result;
+    }
+    toString() {
+        const children = this._children
+            .map((child) => String.indent(child.toString()))
+            .join("\n");
+        return `#document${children === "" ? "" : `\n${children}`}`;
+    }
+    /**
+     * @internal
+     */
+    _attachParent() {
+        return false;
+    }
+    /**
+     * @internal
+     */
+    _attachFrame(frame) {
+        if (this._frozen || this._frame.isSome()) {
+            return false;
+        }
+        this._frame = Option.of(frame);
+        this._frozen = true;
+        return true;
+    }
+}
+/**
+ * @public
+ */
+(function (Document) {
+    function isDocument(value) {
+        return value instanceof Document;
+    }
+    Document.isDocument = isDocument;
+    /**
+     * @internal
+     */
+    function fromDocument(json, device) {
+        return Trampoline.traverse(json.children ?? [], (child) => Node.fromNode(child, device)).map((children) => Document.of(children, json.style.map(Sheet.from), json.externalId, json.serializationId));
+    }
+    Document.fromDocument = fromDocument;
+    /**
+     * @internal
+     */
+    function cloneDocument(options, device) {
+        return (document) => Trampoline.traverse(document.children(), (child) => {
+            if (Element.isElement(child) && options.predicate(child)) {
+                return Trampoline.done(Array.from(options.newElements));
+            }
+            return Node.cloneNode(child, options, device).map((node) => [node]);
+        }).map((children) => {
+            return Document.of(Iterable.flatten(children), document.style, document.externalId, document.serializationId, document.extraData);
+        });
+    }
+    Document.cloneDocument = cloneDocument;
+})(Document || (Document = {}));
+//# sourceMappingURL=document.js.map

package/dist/node/element/input-type.d.ts

@@ -0,0 +1,12 @@
+import type { Element } from "../element.js";
+/**
+ * {@link https://html.spec.whatwg.org/#attr-input-type}
+ *
+ * @internal
+ */
+export type InputType = "hidden" | "search" | "tel" | "url" | "email" | "password" | "date" | "month" | "week" | "time" | "datetime-local" | "number" | "range" | "color" | "checkbox" | "radio" | "file" | "submit" | "image" | "reset" | "button" | "text";
+/**
+ * @public
+ */
+export declare function inputType(element: Element<"input">): InputType;
+//# sourceMappingURL=input-type.d.ts.map

package/dist/node/element/input-type.js

@@ -0,0 +1,10 @@
+/**
+ * @public
+ */
+export function inputType(element) {
+    return element
+        .attribute("type")
+        .flatMap((attribute) => attribute.enumerate("hidden", "search", "tel", "url", "email", "password", "date", "month", "week", "time", "datetime-local", "number", "range", "color", "checkbox", "radio", "file", "submit", "image", "reset", "button", "text"))
+        .getOr("text");
+}
+//# sourceMappingURL=input-type.js.map

package/dist/node/element/predicate/has-attribute.d.ts

@@ -0,0 +1,12 @@
+import { Predicate } from "@siteimprove/alfa-predicate";
+import type { Attribute } from "../../attribute.js";
+import type { Element } from "../../element.js";
+/**
+ * @public
+ */
+export declare function hasAttribute(predicate: Predicate<Attribute>): Predicate<Element>;
+/**
+ * @public
+ */
+export declare function hasAttribute(name: string, value?: Predicate<string>): Predicate<Element>;
+//# sourceMappingURL=has-attribute.d.ts.map

package/dist/node/element/predicate/has-attribute.js

@@ -0,0 +1,11 @@
+import { Predicate } from "@siteimprove/alfa-predicate";
+const { property } = Predicate;
+export function hasAttribute(nameOrPredicate, value = () => true) {
+    if (typeof nameOrPredicate === "function") {
+        return (element) => element.attribute(nameOrPredicate).isSome();
+    }
+    const name = nameOrPredicate;
+    const predicate = property("value", value);
+    return (element) => element.attribute(name).some(predicate);
+}
+//# sourceMappingURL=has-attribute.js.map

package/dist/node/element/predicate/has-box.d.ts

@@ -0,0 +1,9 @@
+import type { Device } from "@siteimprove/alfa-device";
+import type { Predicate } from "@siteimprove/alfa-predicate";
+import type { Rectangle } from "@siteimprove/alfa-rectangle";
+import type { Element } from "../../element.js";
+/**
+ * @public
+ */
+export declare function hasBox(predicate: Predicate<Rectangle> | undefined, device: Device): Predicate<Element>;
+//# sourceMappingURL=has-box.d.ts.map

package/dist/node/element/predicate/has-box.js

@@ -0,0 +1,7 @@
+/**
+ * @public
+ */
+export function hasBox(predicate = () => true, device) {
+    return (element) => element.getBoundingBox(device).some(predicate);
+}
+//# sourceMappingURL=has-box.js.map

package/dist/node/element/predicate/has-display-size.d.ts

@@ -0,0 +1,7 @@
+import type { Predicate } from "@siteimprove/alfa-predicate";
+import type { Element } from "../../element.js";
+/**
+ * @public
+ */
+export declare function hasDisplaySize(valueOrPredicate: number | Predicate<number>): Predicate<Element>;
+//# sourceMappingURL=has-display-size.d.ts.map

package/dist/node/element/predicate/has-display-size.js

@@ -0,0 +1,28 @@
+import { None, Option } from "@siteimprove/alfa-option";
+/**
+ * @public
+ */
+export function hasDisplaySize(valueOrPredicate) {
+    const predicate = typeof valueOrPredicate === "function"
+        ? valueOrPredicate
+        : (size) => valueOrPredicate === size;
+    return (element) => {
+        const displaySize = element
+            .attribute("size")
+            .flatMap((size) => {
+            const sizeValue = parseInt(size.value, 10);
+            if (sizeValue === sizeValue && sizeValue === (sizeValue | 0)) {
+                return Option.of(sizeValue);
+            }
+            else {
+                return None;
+            }
+        })
+            .getOrElse(() => element
+            .attribute("multiple")
+            .map(() => 4)
+            .getOr(1));
+        return predicate(displaySize);
+    };
+}
+//# sourceMappingURL=has-display-size.js.map

package/dist/node/element/predicate/has-id.d.ts

@@ -0,0 +1,16 @@
+import { Iterable } from "@siteimprove/alfa-iterable";
+import { Predicate } from "@siteimprove/alfa-predicate";
+import type { Element } from "../../element.js";
+/**
+ * @public
+ */
+export declare function hasId(predicate?: Predicate<string>): Predicate<Element>;
+/**
+ * @public
+ */
+export declare function hasId(id: string, ...rest: Array<string>): Predicate<Element>;
+/**
+ * @public
+ */
+export declare function hasId(ids: Iterable<string>): Predicate<Element>;
+//# sourceMappingURL=has-id.d.ts.map