chore: remove experimental test packages for patch branch (#17192)

Because we moved so much around on master, it was easier to delete some
code on the patch branch than to get it all functioning.

Author: jelbourn

src/cdk-experimental/testing/dispatch-events.ts

@@ -0,0 +1,59 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import {
+  createFakeEvent,
+  createKeyboardEvent,
+  createMouseEvent,
+  createTouchEvent,
+  ModifierKeys
+} from './event-objects';
+
+/**
+ * Utility to dispatch any event on a Node.
+ * @docs-private
+ */
+export function dispatchEvent(node: Node | Window, event: Event): Event {
+  node.dispatchEvent(event);
+  return event;
+}
+
+/**
+ * Shorthand to dispatch a fake event on a specified node.
+ * @docs-private
+ */
+export function dispatchFakeEvent(node: Node | Window, type: string, canBubble?: boolean): Event {
+  return dispatchEvent(node, createFakeEvent(type, canBubble));
+}
+
+/**
+ * Shorthand to dispatch a keyboard event with a specified key code.
+ * @docs-private
+ */
+export function dispatchKeyboardEvent(node: Node, type: string, keyCode?: number, key?: string,
+                                      target?: Element, modifiers?: ModifierKeys): KeyboardEvent {
+  return dispatchEvent(node,
+      createKeyboardEvent(type, keyCode, key, target, modifiers)) as KeyboardEvent;
+}
+
+/**
+ * Shorthand to dispatch a mouse event on the specified coordinates.
+ * @docs-private
+ */
+export function dispatchMouseEvent(node: Node, type: string, x = 0, y = 0,
+  event = createMouseEvent(type, x, y)): MouseEvent {
+  return dispatchEvent(node, event) as MouseEvent;
+}
+
+/**
+ * Shorthand to dispatch a touch event on the specified coordinates.
+ * @docs-private
+ */
+export function dispatchTouchEvent(node: Node, type: string, x = 0, y = 0) {
+  return dispatchEvent(node, createTouchEvent(type, x, y));
+}

src/cdk-experimental/testing/element-focus.ts

@@ -0,0 +1,41 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import {dispatchFakeEvent} from './dispatch-events';
+
+function triggerFocusChange(element: HTMLElement, event: 'focus' | 'blur') {
+  let eventFired = false;
+  const handler = () => eventFired = true;
+  element.addEventListener(event, handler);
+  element[event]();
+  element.removeEventListener(event, handler);
+  if (!eventFired) {
+    dispatchFakeEvent(element, event);
+  }
+}
+
+/**
+ * Patches an elements focus and blur methods to emit events consistently and predictably.
+ * This is necessary, because some browsers, like IE11, will call the focus handlers asynchronously,
+ * while others won't fire them at all if the browser window is not focused.
+ * @docs-private
+ */
+export function patchElementFocus(element: HTMLElement) {
+  element.focus = () => dispatchFakeEvent(element, 'focus');
+  element.blur = () => dispatchFakeEvent(element, 'blur');
+}
+
+/** @docs-private */
+export function triggerFocus(element: HTMLElement) {
+  triggerFocusChange(element, 'focus');
+}
+
+/** @docs-private */
+export function triggerBlur(element: HTMLElement) {
+  triggerFocusChange(element, 'blur');
+}

src/cdk-experimental/testing/event-objects.ts

@@ -0,0 +1,135 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+/** Modifier keys that may be held while typing. */
+export interface ModifierKeys {
+  control?: boolean;
+  alt?: boolean;
+  shift?: boolean;
+  meta?: boolean;
+}
+
+/**
+ * Creates a browser MouseEvent with the specified options.
+ * @docs-private
+ */
+export function createMouseEvent(type: string, x = 0, y = 0, button = 0) {
+  const event = document.createEvent('MouseEvent');
+  const originalPreventDefault = event.preventDefault;
+
+  event.initMouseEvent(type,
+    true, /* canBubble */
+    true, /* cancelable */
+    window, /* view */
+    0, /* detail */
+    x, /* screenX */
+    y, /* screenY */
+    x, /* clientX */
+    y, /* clientY */
+    false, /* ctrlKey */
+    false, /* altKey */
+    false, /* shiftKey */
+    false, /* metaKey */
+    button, /* button */
+    null /* relatedTarget */);
+
+  // `initMouseEvent` doesn't allow us to pass the `buttons` and
+  // defaults it to 0 which looks like a fake event.
+  Object.defineProperty(event, 'buttons', {get: () => 1});
+
+  // IE won't set `defaultPrevented` on synthetic events so we need to do it manually.
+  event.preventDefault = function() {
+    Object.defineProperty(event, 'defaultPrevented', { get: () => true });
+    return originalPreventDefault.apply(this, arguments);
+  };
+
+  return event;
+}
+
+/**
+ * Creates a browser TouchEvent with the specified pointer coordinates.
+ * @docs-private
+ */
+export function createTouchEvent(type: string, pageX = 0, pageY = 0) {
+  // In favor of creating events that work for most of the browsers, the event is created
+  // as a basic UI Event. The necessary details for the event will be set manually.
+  const event = document.createEvent('UIEvent');
+  const touchDetails = {pageX, pageY};
+
+  event.initUIEvent(type, true, true, window, 0);
+
+  // Most of the browsers don't have a "initTouchEvent" method that can be used to define
+  // the touch details.
+  Object.defineProperties(event, {
+    touches: {value: [touchDetails]},
+    targetTouches: {value: [touchDetails]},
+    changedTouches: {value: [touchDetails]}
+  });
+
+  return event;
+}
+
+/**
+ * Dispatches a keydown event from an element.
+ * @docs-private
+ */
+export function createKeyboardEvent(type: string, keyCode: number = 0, key: string = '',
+                                    target?: Element, modifiers: ModifierKeys = {}) {
+  const event = document.createEvent('KeyboardEvent') as any;
+  const originalPreventDefault = event.preventDefault;
+
+  // Firefox does not support `initKeyboardEvent`, but supports `initKeyEvent`.
+  if (event.initKeyEvent) {
+    event.initKeyEvent(type, true, true, window, modifiers.control, modifiers.alt, modifiers.shift,
+        modifiers.meta, keyCode);
+  } else {
+    // `initKeyboardEvent` expects to receive modifiers as a whitespace-delimited string
+    // See https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent/initKeyboardEvent
+    const modifiersStr = (modifiers.control ? 'Control ' : '' + modifiers.alt ? 'Alt ' : '' +
+        modifiers.shift ? 'Shift ' : '' + modifiers.meta ? 'Meta' : '').trim();
+    event.initKeyboardEvent(type,
+        true, /* canBubble */
+        true, /* cancelable */
+        window, /* view */
+        0, /* char */
+        key, /* key */
+        0, /* location */
+        modifiersStr, /* modifiersList */
+        false /* repeat */);
+  }
+
+  // Webkit Browsers don't set the keyCode when calling the init function.
+  // See related bug https://bugs.webkit.org/show_bug.cgi?id=16735
+  Object.defineProperties(event, {
+    keyCode: { get: () => keyCode },
+    key: { get: () => key },
+    target: { get: () => target },
+    ctrlKey: { get: () => !!modifiers.control },
+    altKey: { get: () => !!modifiers.alt },
+    shiftKey: { get: () => !!modifiers.shift },
+    metaKey: { get: () => !!modifiers.meta }
+  });
+
+  // IE won't set `defaultPrevented` on synthetic events so we need to do it manually.
+  event.preventDefault = function() {
+    Object.defineProperty(event, 'defaultPrevented', { get: () => true });
+    return originalPreventDefault.apply(this, arguments);
+  };
+
+  return event;
+}
+
+/**
+ * Creates a fake event object with any desired event type.
+ * @docs-private
+ */
+export function createFakeEvent(type: string, canBubble = false, cancelable = true) {
+  const event = document.createEvent('Event');
+  event.initEvent(type, canBubble, cancelable);
+  return event;
+}

src/cdk/testing/tests/harnesses/fake-overlay-harness.ts renamed to src/cdk-experimental/testing/tests/harnesses/fake-overlay-harness.ts

@@ -0,0 +1,79 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import {dispatchFakeEvent, dispatchKeyboardEvent} from './dispatch-events';
+import {triggerFocus} from './element-focus';
+import {ModifierKeys} from './event-objects';
+
+/**
+ * Checks whether the given Element is a text input element.
+ * @docs-private
+ */
+export function isTextInput(element: Element): element is HTMLInputElement | HTMLTextAreaElement {
+  return element.nodeName.toLowerCase() === 'input' ||
+      element.nodeName.toLowerCase() === 'textarea' ;
+}
+
+/**
+ * Focuses an input, sets its value and dispatches
+ * the `input` event, simulating the user typing.
+ * @param element Element onto which to set the value.
+ * @param keys The keys to send to the element.
+ * @docs-private
+ */
+export function typeInElement(
+    element: HTMLElement, ...keys: (string | {keyCode?: number, key?: string})[]): void;
+
+/**
+ * Focuses an input, sets its value and dispatches
+ * the `input` event, simulating the user typing.
+ * @param element Element onto which to set the value.
+ * @param modifiers Modifier keys that are held while typing.
+ * @param keys The keys to send to the element.
+ * @docs-private
+ */
+export function typeInElement(element: HTMLElement, modifiers: ModifierKeys,
+                              ...keys: (string | {keyCode?: number, key?: string})[]): void;
+
+export function typeInElement(element: HTMLElement, ...modifiersAndKeys: any) {
+  const first = modifiersAndKeys[0];
+  let modifiers: ModifierKeys;
+  let rest: (string | {keyCode?: number, key?: string})[];
+  if (typeof first !== 'string' && first.keyCode === undefined && first.key === undefined) {
+    modifiers = first;
+    rest = modifiersAndKeys.slice(1);
+  } else {
+    modifiers = {};
+    rest = modifiersAndKeys;
+  }
+  const keys: {keyCode?: number, key?: string}[] = rest
+      .map(k => typeof k === 'string' ?
+          k.split('').map(c => ({keyCode: c.toUpperCase().charCodeAt(0), key: c})) : [k])
+      .reduce((arr, k) => arr.concat(k), []);
+
+  triggerFocus(element);
+  for (const key of keys) {
+    dispatchKeyboardEvent(element, 'keydown', key.keyCode, key.key, element, modifiers);
+    dispatchKeyboardEvent(element, 'keypress', key.keyCode, key.key, element, modifiers);
+    if (isTextInput(element) && key.key && key.key.length === 1) {
+      element.value += key.key;
+      dispatchFakeEvent(element, 'input');
+    }
+    dispatchKeyboardEvent(element, 'keyup', key.keyCode, key.key, element, modifiers);
+  }
+}
+
+/**
+ * Clears the text in an input or textarea element.
+ * @docs-private
+ */
+export function clearElement(element: HTMLInputElement | HTMLTextAreaElement) {
+  triggerFocus(element as HTMLElement);
+  element.value = '';
+  dispatchFakeEvent(element, 'input');
+}