happy-dom 5.4.0 → 6.0.2

package/src/range/RangeHowEnum.ts

@@ -0,0 +1,8 @@
+enum RangeHowEnum {
+	endToEnd = 2,
+	endToStart = 3,
+	startToEnd = 1,
+	startToStart = 0
+}
+
+export default RangeHowEnum;

package/src/range/RangeUtility.ts

@@ -0,0 +1,114 @@
+import DOMException from '../exception/DOMException';
+import DOMExceptionNameEnum from '../exception/DOMExceptionNameEnum';
+import NodeTypeEnum from '../nodes/node/NodeTypeEnum';
+import INode from '../nodes/node/INode';
+import NodeUtility from '../nodes/node/NodeUtility';
+import Range from './Range';
+import IRangeBoundaryPoint from './IRangeBoundaryPoint';
+
+/**
+ * Range utility.
+ *
+ * Based on:
+ * https://github.com/jsdom/jsdom/blob/master/lib/jsdom/living/range/boundary-point.js.
+ */
+export default class RangeUtility {
+	/**
+	 * Compares boundary points.
+	 *
+	 * Based on logic from:
+	 * https://github.com/jsdom/jsdom/blob/master/lib/jsdom/living/range/boundary-point.js
+	 *
+	 * @see https://dom.spec.whatwg.org/#concept-range-bp-after
+	 * @param pointA Point A.
+	 * @param pointB Point B.
+	 * @returns A number, -1, 0, or 1, indicating whether the corresponding boundary-point of the Range is respectively before, equal to, or after the corresponding boundary-point of sourceRange.
+	 */
+	public static compareBoundaryPointsPosition(
+		pointA: IRangeBoundaryPoint,
+		pointB: IRangeBoundaryPoint
+	): number {
+		if (pointA.node === pointB.node) {
+			if (pointA.offset === pointB.offset) {
+				return 0;
+			} else if (pointA.offset < pointB.offset) {
+				return -1;
+			}
+
+			return 1;
+		}
+
+		if (NodeUtility.isFollowing(pointA.node, pointB.node)) {
+			return this.compareBoundaryPointsPosition(pointB, pointA) === -1 ? 1 : -1;
+		}
+
+		if (NodeUtility.isInclusiveAncestor(pointA.node, pointB.node)) {
+			let child = pointB.node;
+
+			while (child.parentNode !== pointA.node) {
+				child = child.parentNode;
+			}
+
+			if (child.parentNode.childNodes.indexOf(child) < pointA.offset) {
+				return 1;
+			}
+		}
+
+		return -1;
+	}
+
+	/**
+	 * Validates a boundary point.
+	 *
+	 * @throws DOMException
+	 * @param point Boundary point.
+	 */
+	public static validateBoundaryPoint(point: IRangeBoundaryPoint): void {
+		if (point.node.nodeType === NodeTypeEnum.documentTypeNode) {
+			throw new DOMException(
+				`DocumentType Node can't be used as boundary point.`,
+				DOMExceptionNameEnum.invalidNodeTypeError
+			);
+		}
+
+		if (point.offset > NodeUtility.getNodeLength(point.node)) {
+			throw new DOMException(`Offset out of bound.`, DOMExceptionNameEnum.indexSizeError);
+		}
+	}
+
+	/**
+	 * Returns "true" if contained.
+	 *
+	 * @param node Node.
+	 * @param range Range.
+	 * @returns "true" if contained.
+	 */
+	public static isContained(node: INode, range: Range): boolean {
+		return (
+			this.compareBoundaryPointsPosition(
+				{ node, offset: 0 },
+				{ node: range.startContainer, offset: range.startOffset }
+			) === 1 &&
+			this.compareBoundaryPointsPosition(
+				{ node, offset: NodeUtility.getNodeLength(node) },
+				{ node: range.endContainer, offset: range.endOffset }
+			) === -1
+		);
+	}
+
+	/**
+	 * Returns "true" if partially contained.
+	 *
+	 * @param node Node.
+	 * @param range Range.
+	 * @returns "true" if partially contained.
+	 */
+	public static isPartiallyContained(node: INode, range: Range): boolean {
+		return (
+			(NodeUtility.isInclusiveAncestor(node, range.startContainer) &&
+				!NodeUtility.isInclusiveAncestor(node, range.endContainer)) ||
+			(!NodeUtility.isInclusiveAncestor(node, range.startContainer) &&
+				NodeUtility.isInclusiveAncestor(node, range.endContainer))
+		);
+	}
+}

package/src/selection/Selection.ts

@@ -1,140 +1,524 @@
+import Event from '../event/Event';
+import DOMException from '../exception/DOMException';
+import DOMExceptionNameEnum from '../exception/DOMExceptionNameEnum';
+import IDocument from '../nodes/document/IDocument';
 import INode from '../nodes/node/INode';
+import NodeTypeEnum from '../nodes/node/NodeTypeEnum';
+import NodeUtility from '../nodes/node/NodeUtility';
+import Range from '../range/Range';
+import RangeUtility from '../range/RangeUtility';
+import SelectionDirectionEnum from './SelectionDirectionEnum';
 
 /**
  * Selection.
  *
+ * Based on logic from:
+ * https://github.com/jsdom/jsdom/blob/master/lib/jsdom/living/selection/Selection-impl.js
+ *
  * Reference:
  * https://developer.mozilla.org/en-US/docs/Web/API/Selection.
  */
 export default class Selection {
-	public readonly anchorNode: INode = null;
-	public readonly anchorOffset: number = 0;
-	public readonly baseNode: INode = null;
-	public readonly baseOffset: number = 0;
-	public readonly extentNode: INode = null;
-	public readonly extentOffset: number = 0;
-	public readonly focusNode: INode = null;
-	public readonly focusOffset: number = 0;
-	public readonly isCollapsed: boolean = true;
-	public readonly rangeCount: number = 0;
-	public readonly type: string = 'None';
+	private readonly _ownerDocument: IDocument = null;
+	private _range: Range = null;
+	private _direction: SelectionDirectionEnum = SelectionDirectionEnum.directionless;
 
 	/**
-	 * Adds a range.
+	 * Constructor.
 	 *
-	 * @param _range Range.
+	 * @param ownerDocument Owner document.
 	 */
-	public addRange(_range: object): void {
-		// Do nothing.
+	constructor(ownerDocument: IDocument) {
+		this._ownerDocument = ownerDocument;
 	}
 
 	/**
-	 * Collapses the current selection to a single point.
+	 * Returns range count.
 	 *
-	 * @param _node Node.
-	 * @param _offset Offset.
+	 * @see https://w3c.github.io/selection-api/#dom-selection-rangecount
+	 * @returns Range count.
 	 */
-	public collapse(_node: INode, _offset?: number): void {
-		// Do nothing.
+	public get rangeCount(): number {
+		return this._range ? 1 : 0;
 	}
 
 	/**
-	 * Collapses the selection to the end.
+	 * Returns collapsed state.
+	 *
+	 * @see https://w3c.github.io/selection-api/#dom-selection-iscollapsed
+	 * @returns "true" if collapsed.
 	 */
-	public collapseToEnd(): void {
-		// Do nothing.
+	public get isCollapsed(): boolean {
+		return this._range === null || this._range.collapsed;
 	}
 
 	/**
-	 * Collapses the selection to the start.
+	 * Returns type.
+	 *
+	 * @see https://w3c.github.io/selection-api/#dom-selection-type
+	 * @returns Type.
 	 */
-	public collapseToStart(): void {
-		// Do nothing.
+	public get type(): string {
+		if (!this._range) {
+			return 'None';
+		} else if (this._range.collapsed) {
+			return 'Caret';
+		}
+
+		return 'Range';
 	}
 
 	/**
-	 * Indicates whether a specified node is part of the selection.
+	 * Returns anchor node.
 	 *
-	 * @param _node Node.
-	 * @param _partialContainer Partial container.
-	 * @returns Always returns "true" for now.
+	 * @see https://w3c.github.io/selection-api/#dom-selection-anchornode
+	 * @returns Node.
 	 */
-	public containsNode(_node: INode, _partialContainer?: INode): boolean {
-		return true;
+	public get anchorNode(): INode {
+		if (!this._range) {
+			return null;
+		}
+		return this._direction === SelectionDirectionEnum.forwards
+			? this._range.startContainer
+			: this._range.endContainer;
 	}
 
 	/**
-	 * Deletes the selected text from the document's DOM.
+	 * Returns anchor offset.
+	 *
+	 * @see https://w3c.github.io/selection-api/#dom-selection-anchoroffset
+	 * @returns Node.
 	 */
-	public deleteFromDocument(): void {
-		// Do nothing.
+	public get anchorOffset(): number {
+		if (!this._range) {
+			return null;
+		}
+		return this._direction === SelectionDirectionEnum.forwards
+			? this._range.startOffset
+			: this._range.endOffset;
 	}
 
 	/**
-	 * Moves the focus of the selection to a specified point.
+	 * Returns anchor node.
 	 *
-	 * @param _node Node.
-	 * @param _offset Offset.
+	 * @deprecated
+	 * @alias anchorNode
+	 * @returns Node.
 	 */
-	public extend(_node: INode, _offset?: number): void {
-		// Do nothing.
+	public get baseNode(): INode {
+		return this.anchorNode;
 	}
 
 	/**
-	 * Moves the focus of the selection to a specified point.
+	 * Returns anchor offset.
+	 *
+	 * @deprecated
+	 * @alias anchorOffset
+	 * @returns Node.
+	 */
+	public get baseOffset(): number {
+		return this.anchorOffset;
+	}
+
+	/**
+	 * Returns focus node.
+	 *
+	 * @see https://w3c.github.io/selection-api/#dom-selection-focusnode
+	 * @returns Node.
+	 */
+	public get focusNode(): INode {
+		return this.anchorNode;
+	}
+
+	/**
+	 * Returns focus offset.
+	 *
+	 * @see https://w3c.github.io/selection-api/#dom-selection-focusoffset
+	 * @returns Node.
+	 */
+	public get focusOffset(): number {
+		return this.anchorOffset;
+	}
+
+	/**
+	 * Returns focus node.
+	 *
+	 * @deprecated
+	 * @alias focusNode
+	 * @returns Node.
+	 */
+	public get extentNode(): INode {
+		return this.focusNode;
+	}
+
+	/**
+	 * Returns focus offset.
+	 *
+	 * @deprecated
+	 * @alias focusOffset
+	 * @returns Node.
+	 */
+	public get extentOffset(): number {
+		return this.focusOffset;
+	}
+
+	/**
+	 * Adds a range.
 	 *
-	 * @param _index Index.
+	 * @see https://w3c.github.io/selection-api/#dom-selection-addrange
+	 * @param newRange Range.
 	 */
-	public getRangeAt(_index: number): object {
-		throw new Error('Not a valid index.');
+	public addRange(newRange: Range): void {
+		if (!newRange) {
+			throw new Error('Failed to execute addRange on Selection. Parameter 1 is not of type Range.');
+		}
+		if (!this._range && newRange._ownerDocument === this._ownerDocument) {
+			this._associateRange(newRange);
+		}
+	}
+
+	/**
+	 * Returns Range.
+	 *
+	 * @see https://w3c.github.io/selection-api/#dom-selection-getrangeat
+	 * @param index Index.
+	 * @returns Range.
+	 */
+	public getRangeAt(index: number): Range {
+		if (!this._range || index !== 0) {
+			throw new DOMException('Invalid range index.', DOMExceptionNameEnum.indexSizeError);
+		}
+
+		return this._range;
 	}
 
 	/**
 	 * Removes a range from a selection.
 	 *
-	 * @param _range Range.
+	 * @see https://w3c.github.io/selection-api/#dom-selection-removerange
+	 * @param range Range.
 	 */
-	public removeRange(_range: object): void {
-		// Do nothing.
+	public removeRange(range: Range): void {
+		if (this._range !== range) {
+			throw new DOMException('Invalid range.', DOMExceptionNameEnum.notFoundError);
+		}
+		this._associateRange(null);
 	}
 
 	/**
 	 * Removes all ranges.
 	 */
 	public removeAllRanges(): void {
-		// Do nothing.
+		this._associateRange(null);
+	}
+
+	/**
+	 * Removes all ranges.
+	 *
+	 * @alias removeAllRanges()
+	 */
+	public empty(): void {
+		this.removeAllRanges();
+	}
+
+	/**
+	 * Collapses the current selection to a single point.
+	 *
+	 * @see https://w3c.github.io/selection-api/#dom-selection-collapse
+	 * @param node Node.
+	 * @param offset Offset.
+	 */
+	public collapse(node: INode, offset: number): void {
+		if (node === null) {
+			this.removeAllRanges();
+			return;
+		}
+
+		if (node.nodeType === NodeTypeEnum.documentTypeNode) {
+			throw new DOMException(
+				"DocumentType Node can't be used as boundary point.",
+				DOMExceptionNameEnum.invalidNodeTypeError
+			);
+		}
+
+		if (offset > NodeUtility.getNodeLength(node)) {
+			throw new DOMException('Invalid range index.', DOMExceptionNameEnum.indexSizeError);
+		}
+
+		if (node.ownerDocument !== this._ownerDocument) {
+			return;
+		}
+
+		const newRange = new Range();
+
+		newRange._start.node = node;
+		newRange._start.offset = offset;
+		newRange._end.node = node;
+		newRange._end.offset = offset;
+
+		this._associateRange(newRange);
+	}
+
+	/**
+	 * Collapses the current selection to a single point.
+	 *
+	 * @see https://w3c.github.io/selection-api/#dom-selection-setposition
+	 * @alias collapse()
+	 * @param node Node.
+	 * @param offset Offset.
+	 */
+	public setPosition(node: INode, offset: number): void {
+		this.collapse(node, offset);
+	}
+
+	/**
+	 * Collapses the selection to the end.
+	 *
+	 * @see https://w3c.github.io/selection-api/#dom-selection-collapsetoend
+	 */
+	public collapseToEnd(): void {
+		if (this._range === null) {
+			throw new DOMException(
+				'There is no selection to collapse.',
+				DOMExceptionNameEnum.invalidStateError
+			);
+		}
+
+		const { node, offset } = this._range._end;
+		const newRange = new Range();
+
+		newRange._start.node = node;
+		newRange._start.offset = offset;
+		newRange._end.node = node;
+		newRange._end.offset = offset;
+
+		this._associateRange(newRange);
+	}
+
+	/**
+	 * Collapses the selection to the start.
+	 *
+	 * @see https://w3c.github.io/selection-api/#dom-selection-collapsetostart
+	 */
+	public collapseToStart(): void {
+		if (!this._range) {
+			throw new DOMException(
+				'There is no selection to collapse.',
+				DOMExceptionNameEnum.invalidStateError
+			);
+		}
+
+		const { node, offset } = this._range._start;
+		const newRange = new Range();
+
+		newRange._start.node = node;
+		newRange._start.offset = offset;
+		newRange._end.node = node;
+		newRange._end.offset = offset;
+
+		this._associateRange(newRange);
+	}
+
+	/**
+	 * Indicates whether a specified node is part of the selection.
+	 *
+	 * @see https://w3c.github.io/selection-api/#dom-selection-containsnode
+	 * @param node Node.
+	 * @param [allowPartialContainment] Set to "true" to allow partial containment.
+	 * @returns Always returns "true" for now.
+	 */
+	public containsNode(node: INode, allowPartialContainment = false): boolean {
+		if (!this._range || node.ownerDocument !== this._ownerDocument) {
+			return false;
+		}
+
+		const { _start, _end } = this._range;
+
+		const startIsBeforeNode =
+			RangeUtility.compareBoundaryPointsPosition(_start, { node, offset: 0 }) === -1;
+		const endIsAfterNode =
+			RangeUtility.compareBoundaryPointsPosition(_end, {
+				node,
+				offset: NodeUtility.getNodeLength(node)
+			}) === 1;
+
+		return allowPartialContainment
+			? startIsBeforeNode || endIsAfterNode
+			: startIsBeforeNode && endIsAfterNode;
+	}
+
+	/**
+	 * Deletes the selected text from the document's DOM.
+	 *
+	 * @see https://w3c.github.io/selection-api/#dom-selection-deletefromdocument
+	 */
+	public deleteFromDocument(): void {
+		if (this._range) {
+			this._range.deleteContents();
+		}
+	}
+
+	/**
+	 * Moves the focus of the selection to a specified point.
+	 *
+	 * @see https://w3c.github.io/selection-api/#dom-selection-extend
+	 * @param node Node.
+	 * @param offset Offset.
+	 */
+	public extend(node: INode, offset: number): void {
+		if (node.ownerDocument !== this._ownerDocument) {
+			return;
+		}
+
+		if (!this._range) {
+			throw new DOMException(
+				'There is no selection to extend.',
+				DOMExceptionNameEnum.invalidStateError
+			);
+		}
+
+		const anchorNode = this.anchorNode;
+		const anchorOffset = this.anchorOffset;
+		const newRange = new Range();
+		newRange._start.node = node;
+		newRange._start.offset = 0;
+		newRange._end.node = node;
+		newRange._end.offset = 0;
+
+		if (node.ownerDocument !== this._range._ownerDocument) {
+			newRange._start.offset = offset;
+			newRange._end.offset = offset;
+		} else if (
+			RangeUtility.compareBoundaryPointsPosition(
+				{ node: anchorNode, offset: anchorOffset },
+				{ node, offset }
+			) <= 0
+		) {
+			newRange._start.node = anchorNode;
+			newRange._start.offset = anchorOffset;
+			newRange._end.node = node;
+			newRange._end.offset = offset;
+		} else {
+			newRange._start.node = node;
+			newRange._start.offset = offset;
+			newRange._end.node = anchorNode;
+			newRange._end.offset = anchorOffset;
+		}
+
+		this._associateRange(newRange);
+		this._direction =
+			RangeUtility.compareBoundaryPointsPosition(
+				{ node, offset },
+				{ node: anchorNode, offset: anchorOffset }
+			) === -1
+				? SelectionDirectionEnum.backwards
+				: SelectionDirectionEnum.forwards;
 	}
 
 	/**
 	 * Selects all children.
 	 *
+	 * @see https://w3c.github.io/selection-api/#dom-selection-selectallchildren
+	 * @param node
 	 * @param _parentNode Parent node.
 	 */
-	public selectAllChildren(_parentNode: INode): void {
-		// Do nothing.
+	public selectAllChildren(node: INode): void {
+		if (node.nodeType === NodeTypeEnum.documentTypeNode) {
+			throw new DOMException(
+				"DocumentType Node can't be used as boundary point.",
+				DOMExceptionNameEnum.invalidNodeTypeError
+			);
+		}
+
+		if (node.ownerDocument !== this._ownerDocument) {
+			return;
+		}
+
+		const length = node.childNodes.length;
+		const newRange = new Range();
+
+		newRange._start.node = node;
+		newRange._start.offset = 0;
+		newRange._end.node = node;
+		newRange._end.offset = length;
+
+		this._associateRange(newRange);
 	}
 
 	/**
 	 * Sets the selection to be a range including all or parts of two specified DOM nodes, and any content located between them.
 	 *
-	 * @param _anchorNode Anchor node.
-	 * @param _anchorOffset Anchor offset.
-	 * @param _focusNode Focus node.
-	 * @param _focusOffset Focus offset.
+	 * @see https://w3c.github.io/selection-api/#dom-selection-setbaseandextent
+	 * @param anchorNode Anchor node.
+	 * @param anchorOffset Anchor offset.
+	 * @param focusNode Focus node.
+	 * @param focusOffset Focus offset.
 	 */
 	public setBaseAndExtent(
-		_anchorNode: INode,
-		_anchorOffset: number,
-		_focusNode: INode,
-		_focusOffset: number
+		anchorNode: INode,
+		anchorOffset: number,
+		focusNode: INode,
+		focusOffset: number
 	): void {
-		// Do nothing.
+		if (
+			anchorOffset > NodeUtility.getNodeLength(anchorNode) ||
+			focusOffset > NodeUtility.getNodeLength(focusNode)
+		) {
+			throw new DOMException(
+				'Invalid anchor or focus offset.',
+				DOMExceptionNameEnum.indexSizeError
+			);
+		}
+
+		if (
+			anchorNode.ownerDocument !== this._ownerDocument ||
+			focusNode.ownerDocument !== this._ownerDocument
+		) {
+			return;
+		}
+
+		const anchor = { node: anchorNode, offset: anchorOffset };
+		const focus = { node: focusNode, offset: focusOffset };
+		const newRange = new Range();
+
+		if (RangeUtility.compareBoundaryPointsPosition(anchor, focus) === -1) {
+			newRange._start = anchor;
+			newRange._end = focus;
+		} else {
+			newRange._start = focus;
+			newRange._end = anchor;
+		}
+
+		this._associateRange(newRange);
+		this._direction =
+			RangeUtility.compareBoundaryPointsPosition(focus, anchor) === -1
+				? SelectionDirectionEnum.backwards
+				: SelectionDirectionEnum.forwards;
 	}
 
 	/**
 	 * Returns string currently being represented by the selection object.
+	 *
+	 * @returns Selection as string.
 	 */
 	public toString(): string {
-		return '';
+		return this._range ? this._range.toString() : '';
+	}
+
+	/**
+	 * Sets the current range.
+	 *
+	 * @param range Range.
+	 */
+	protected _associateRange(range: Range): void {
+		const oldRange = this._range;
+		this._range = range;
+		this._direction =
+			range === null ? SelectionDirectionEnum.directionless : SelectionDirectionEnum.forwards;
+
+		if (oldRange !== this._range) {
+			// https://w3c.github.io/selection-api/#selectionchange-event
+			this._ownerDocument.dispatchEvent(new Event('selectionchange'));
+		}
 	}
 }