Merge branch 'master' into task/1221-add-support-for-target-and-target-within

Author: capricorn86

.github/workflows/release.yml

@@ -107,8 +107,9 @@ jobs:
 
       - name: Configures Git
         run: |
-         git config --local user.email "[email protected]"
-         git config --local user.name "GitHub Action"
+          git config --global user.name "${{ github.actor }}"
+          git config --global user.email "$(git log --format='%ae' HEAD^!)"
+          git remote set-url origin https://${{ secrets.GIT_REPOSITORY_URL_USERNAME }}:${{ secrets.GIT_REPOSITORY_URL_ACCESS_TOKEN }}@github.com/capricorn86/happy-dom.git
 
       - name: Creates release branch
         run: |

packages/happy-dom/src/event/EventTarget.ts

@@ -208,7 +208,7 @@ export default abstract class EventTarget implements IEventTarget {
 					if ((<IEventListener>listener).handleEvent) {
 						WindowErrorUtility.captureError(
 							window,
-							(<IEventListener>listener).handleEvent.bind(this, event)
+							(<IEventListener>listener).handleEvent.bind(listener, event)
 						);
 					} else {
 						WindowErrorUtility.captureError(

packages/happy-dom/src/mutation-observer/MutationObserver.ts

@@ -1,4 +1,3 @@
-import DOMException from '../exception/DOMException.js';
 import * as PropertySymbol from '../PropertySymbol.js';
 import INode from '../nodes/node/INode.js';
 import Node from '../nodes/node/Node.js';
@@ -34,13 +33,50 @@ export default class MutationObserver {
 	 */
 	public observe(target: INode, options: IMutationObserverInit): void {
 		if (!target) {
-			throw new DOMException(
+			throw new TypeError(
 				`Failed to execute 'observe' on 'MutationObserver': The first parameter "target" should be of type "Node".`
 			);
 		}
 
+		if (options && (options.attributeFilter || options.attributeOldValue)) {
+			if (options.attributes === undefined) {
+				options = Object.assign({}, options, {
+					attributes: true,
+					attributeFilter: options.attributeFilter,
+					attributeOldValue: options.attributeOldValue
+				});
+			}
+
+			if (!options.attributes && options.attributeOldValue) {
+				throw new TypeError(
+					`Failed to execute 'observe' on 'MutationObserver': The options object may only set 'attributeOldValue' to true when 'attributes' is true or not present.`
+				);
+			}
+
+			if (!options.attributes && options.attributeFilter) {
+				throw new TypeError(
+					`Failed to execute 'observe' on 'MutationObserver': The options object may only set 'attributeFilter' when 'attributes' is true or not present.`
+				);
+			}
+		}
+
+		if (options && options.characterDataOldValue) {
+			if (options.characterData === undefined) {
+				options = Object.assign({}, options, {
+					characterData: true,
+					characterDataOldValue: options.characterDataOldValue
+				});
+			}
+
+			if (!options.characterData && options.characterDataOldValue) {
+				throw new TypeError(
+					`Failed to execute 'observe' on 'MutationObserver': The options object may only set 'characterDataOldValue' to true when 'characterData' is true or not present.`
+				);
+			}
+		}
+
 		if (!options || (!options.childList && !options.attributes && !options.characterData)) {
-			throw new DOMException(
+			throw new TypeError(
 				`Failed to execute 'observe' on 'MutationObserver': The options object must set at least one of 'attributes', 'characterData', or 'childList' to true.`
 			);
 		}

packages/happy-dom/test/event/EventTarget.test.ts

@@ -103,6 +103,19 @@ describe('EventTarget', () => {
 			eventTarget.dispatchEvent(dispatchedEvent);
 			expect(scope).toBe(eventTarget);
 		});
+
+		it('Event listener with handleEvent is called in the scope of the listener when calling dispatchEvent().', () => {
+			let scope = null;
+			const listener = {
+				handleEvent(): void {
+					scope = this;
+				}
+			};
+			const dispatchedEvent = new Event(EVENT_TYPE);
+			eventTarget.addEventListener(EVENT_TYPE, listener);
+			eventTarget.dispatchEvent(dispatchedEvent);
+			expect(scope).toBe(listener);
+		});
 	});
 
 	describe('removeEventListener()', () => {

packages/happy-dom/test/mutation-observer/MutationObserver.test.ts

@@ -40,6 +40,33 @@ describe('MutationObserver', () => {
 			]);
 		});
 
+		it('Throws TypeError for invalid options.', async () => {
+			const div = document.createElement('div');
+			const observer = new MutationObserver(() => {});
+			expect(() => observer.observe(div, {})).toThrow(TypeError);
+		});
+
+		it('Allows to omit "attributes" if "attributeOldValue" or "attributeFilter" is specified.', async () => {
+			const div = document.createElement('div');
+			const observer = new MutationObserver(() => {});
+			expect(() => observer.observe(div, { attributes: false, attributeOldValue: true })).toThrow();
+			expect(() =>
+				observer.observe(div, { attributes: false, attributeFilter: ['style', 'class'] })
+			).toThrow();
+
+			expect(() => observer.observe(div, { attributeOldValue: true })).not.toThrow();
+			expect(() => observer.observe(div, { attributeFilter: ['style', 'class'] })).not.toThrow();
+		});
+
+		it('Allows to omit "characterData" if "characterDataOldValue" is specified.', async () => {
+			const text = document.createTextNode('old');
+			const observer = new MutationObserver(() => {});
+			expect(() =>
+				observer.observe(text, { characterData: false, characterDataOldValue: true })
+			).toThrow();
+			expect(() => observer.observe(text, { characterDataOldValue: true })).not.toThrow();
+		});
+
 		it('Observes attributes and old attribute values.', async () => {
 			let records: MutationRecord[] = [];
 			const div = document.createElement('div');