refactor: move angular source to /packages rather than modules/@angular

packages/platform-browser/test/dom/dom_renderer_spec.ts

@@ -0,0 +1,98 @@
+/**
+ * @license
+ * Copyright Google Inc. 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 {CommonModule} from '@angular/common';
+import {Component, NgModule, ViewEncapsulation} from '@angular/core';
+import {TestBed} from '@angular/core/testing';
+import {BrowserModule} from '@angular/platform-browser';
+import {By} from '@angular/platform-browser/src/dom/debug/by';
+import {browserDetection} from '@angular/platform-browser/testing/browser_util';
+import {expect} from '@angular/platform-browser/testing/matchers';
+
+export function main() {
+  describe('DomRenderer', () => {
+
+    beforeEach(() => TestBed.configureTestingModule({imports: [BrowserModule, TestModule]}));
+
+    // other browsers don't support shadow dom
+    if (browserDetection.isChromeDesktop) {
+      it('should allow to style components with emulated encapsulation and no encapsulation inside of components with shadow DOM',
+         () => {
+           TestBed.overrideComponent(CmpEncapsulationNative, {
+             set: {
+               template:
+                   '<div class="native"></div><cmp-emulated></cmp-emulated><cmp-none></cmp-none>'
+             }
+           });
+
+           const fixture = TestBed.createComponent(SomeApp);
+
+           const cmp = fixture.debugElement.query(By.css('cmp-native')).nativeElement;
+
+
+           const native = cmp.shadowRoot.querySelector('.native');
+           expect(window.getComputedStyle(native).color).toEqual('rgb(255, 0, 0)');
+
+           const emulated = cmp.shadowRoot.querySelector('.emulated');
+           expect(window.getComputedStyle(emulated).color).toEqual('rgb(0, 0, 255)');
+
+           const none = cmp.shadowRoot.querySelector('.none');
+           expect(window.getComputedStyle(none).color).toEqual('rgb(0, 255, 0)');
+         });
+    }
+  });
+}
+
+@Component({
+  selector: 'cmp-native',
+  template: `<div class="native"></div>`,
+  styles: [`.native { color: red; }`],
+  encapsulation: ViewEncapsulation.Native
+})
+class CmpEncapsulationNative {
+}
+
+@Component({
+  selector: 'cmp-emulated',
+  template: `<div class="emulated"></div>`,
+  styles: [`.emulated { color: blue; }`],
+  encapsulation: ViewEncapsulation.Emulated
+})
+class CmpEncapsulationEmulated {
+}
+
+@Component({
+  selector: 'cmp-none',
+  template: `<div class="none"></div>`,
+  styles: [`.none { color: lime; }`],
+  encapsulation: ViewEncapsulation.None
+})
+class CmpEncapsulationNone {
+}
+
+@Component({
+  selector: 'some-app',
+  template: `
+	  <cmp-native></cmp-native>
+	  <cmp-emulated></cmp-emulated>
+	  <cmp-none></cmp-none>
+  `,
+})
+export class SomeApp {
+}
+
+@NgModule({
+  declarations: [
+    SomeApp,
+    CmpEncapsulationNative,
+    CmpEncapsulationEmulated,
+    CmpEncapsulationNone,
+  ],
+  imports: [CommonModule]
+})
+class TestModule {
+}

packages/platform-browser/test/dom/events/event_manager_spec.ts

@@ -0,0 +1,113 @@
+/**
+ * @license
+ * Copyright Google Inc. 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 {NgZone} from '@angular/core/src/zone/ng_zone';
+import {beforeEach, describe, expect, it} from '@angular/core/testing/testing_internal';
+import {getDOM} from '@angular/platform-browser/src/dom/dom_adapter';
+import {DomEventsPlugin} from '@angular/platform-browser/src/dom/events/dom_events';
+import {EventManager, EventManagerPlugin} from '@angular/platform-browser/src/dom/events/event_manager';
+import {el} from '../../../testing/browser_util';
+
+export function main() {
+  let domEventPlugin: DomEventsPlugin;
+  let doc: any;
+
+  describe('EventManager', () => {
+
+    beforeEach(() => {
+      doc = getDOM().supportsDOMEvents() ? document : getDOM().createHtmlDocument();
+      domEventPlugin = new DomEventsPlugin(doc);
+    });
+
+    it('should delegate event bindings to plugins that are passed in from the most generic one to the most specific one',
+       () => {
+         const element = el('<div></div>');
+         const handler = (e: any /** TODO #9100 */) => e;
+         const plugin = new FakeEventManagerPlugin(doc, ['click']);
+         const manager = new EventManager([domEventPlugin, plugin], new FakeNgZone());
+         manager.addEventListener(element, 'click', handler);
+         expect(plugin.eventHandler['click']).toBe(handler);
+       });
+
+    it('should delegate event bindings to the first plugin supporting the event', () => {
+      const element = el('<div></div>');
+      const clickHandler = (e: any /** TODO #9100 */) => e;
+      const dblClickHandler = (e: any /** TODO #9100 */) => e;
+      const plugin1 = new FakeEventManagerPlugin(doc, ['dblclick']);
+      const plugin2 = new FakeEventManagerPlugin(doc, ['click', 'dblclick']);
+      const manager = new EventManager([plugin2, plugin1], new FakeNgZone());
+      manager.addEventListener(element, 'click', clickHandler);
+      manager.addEventListener(element, 'dblclick', dblClickHandler);
+      expect(plugin2.eventHandler['click']).toBe(clickHandler);
+      expect(plugin1.eventHandler['dblclick']).toBe(dblClickHandler);
+    });
+
+    it('should throw when no plugin can handle the event', () => {
+      const element = el('<div></div>');
+      const plugin = new FakeEventManagerPlugin(doc, ['dblclick']);
+      const manager = new EventManager([plugin], new FakeNgZone());
+      expect(() => manager.addEventListener(element, 'click', null))
+          .toThrowError('No event manager plugin found for event click');
+    });
+
+    it('events are caught when fired from a child', () => {
+      const element = el('<div><div></div></div>');
+      // Workaround for https://bugs.webkit.org/show_bug.cgi?id=122755
+      getDOM().appendChild(doc.body, element);
+
+      const child = getDOM().firstChild(element);
+      const dispatchedEvent = getDOM().createMouseEvent('click');
+      let receivedEvent: any /** TODO #9100 */ = null;
+      const handler = (e: any /** TODO #9100 */) => { receivedEvent = e; };
+      const manager = new EventManager([domEventPlugin], new FakeNgZone());
+      manager.addEventListener(element, 'click', handler);
+      getDOM().dispatchEvent(child, dispatchedEvent);
+
+      expect(receivedEvent).toBe(dispatchedEvent);
+    });
+
+    it('should add and remove global event listeners', () => {
+      const element = el('<div><div></div></div>');
+      getDOM().appendChild(doc.body, element);
+      const dispatchedEvent = getDOM().createMouseEvent('click');
+      let receivedEvent: any /** TODO #9100 */ = null;
+      const handler = (e: any /** TODO #9100 */) => { receivedEvent = e; };
+      const manager = new EventManager([domEventPlugin], new FakeNgZone());
+
+      const remover = manager.addGlobalEventListener('document', 'click', handler);
+      getDOM().dispatchEvent(element, dispatchedEvent);
+      expect(receivedEvent).toBe(dispatchedEvent);
+
+      receivedEvent = null;
+      remover();
+      getDOM().dispatchEvent(element, dispatchedEvent);
+      expect(receivedEvent).toBe(null);
+    });
+  });
+}
+
+/** @internal */
+class FakeEventManagerPlugin extends EventManagerPlugin {
+  eventHandler: {[event: string]: Function} = {};
+
+  constructor(doc: any, public supportedEvents: string[]) { super(doc); }
+
+  supports(eventName: string): boolean { return this.supportedEvents.indexOf(eventName) > -1; }
+
+  addEventListener(element: any, eventName: string, handler: Function) {
+    this.eventHandler[eventName] = handler;
+    return () => { delete (this.eventHandler[eventName]); };
+  }
+}
+
+class FakeNgZone extends NgZone {
+  constructor() { super({enableLongStackTrace: false}); }
+  run(fn: Function) { fn(); }
+
+  runOutsideAngular(fn: Function) { return fn(); }
+}

packages/platform-browser/test/dom/events/hammer_gestures_spec.ts

@@ -0,0 +1,22 @@
+/**
+ * @license
+ * Copyright Google Inc. 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 {describe, expect, it} from '@angular/core/testing/testing_internal';
+import {HammerGestureConfig, HammerGesturesPlugin} from '@angular/platform-browser/src/dom/events/hammer_gestures';
+
+export function main() {
+  describe('HammerGesturesPlugin', () => {
+
+    it('should implement addGlobalEventListener', () => {
+      const plugin = new HammerGesturesPlugin(document, new HammerGestureConfig());
+
+      spyOn(plugin, 'addEventListener').and.callFake(() => {});
+
+      expect(() => plugin.addGlobalEventListener('document', 'swipe', () => {})).not.toThrowError();
+    });
+  });
+}

packages/platform-browser/test/dom/events/key_events_spec.ts

@@ -0,0 +1,71 @@
+/**
+ * @license
+ * Copyright Google Inc. 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 {describe, expect, it} from '@angular/core/testing/testing_internal';
+import {KeyEventsPlugin} from '@angular/platform-browser/src/dom/events/key_events';
+
+export function main() {
+  describe('KeyEventsPlugin', () => {
+
+    it('should ignore unrecognized events', () => {
+      expect(KeyEventsPlugin.parseEventName('keydown')).toEqual(null);
+      expect(KeyEventsPlugin.parseEventName('keyup')).toEqual(null);
+      expect(KeyEventsPlugin.parseEventName('keydown.unknownmodifier.enter')).toEqual(null);
+      expect(KeyEventsPlugin.parseEventName('keyup.unknownmodifier.enter')).toEqual(null);
+      expect(KeyEventsPlugin.parseEventName('unknownevent.control.shift.enter')).toEqual(null);
+      expect(KeyEventsPlugin.parseEventName('unknownevent.enter')).toEqual(null);
+    });
+
+    it('should correctly parse event names', () => {
+      // key with no modifier
+      expect(KeyEventsPlugin.parseEventName('keydown.enter'))
+          .toEqual({'domEventName': 'keydown', 'fullKey': 'enter'});
+      expect(KeyEventsPlugin.parseEventName('keyup.enter'))
+          .toEqual({'domEventName': 'keyup', 'fullKey': 'enter'});
+
+      // key with modifiers:
+      expect(KeyEventsPlugin.parseEventName('keydown.control.shift.enter'))
+          .toEqual({'domEventName': 'keydown', 'fullKey': 'control.shift.enter'});
+      expect(KeyEventsPlugin.parseEventName('keyup.control.shift.enter'))
+          .toEqual({'domEventName': 'keyup', 'fullKey': 'control.shift.enter'});
+
+      // key with modifiers in a different order:
+      expect(KeyEventsPlugin.parseEventName('keydown.shift.control.enter'))
+          .toEqual({'domEventName': 'keydown', 'fullKey': 'control.shift.enter'});
+      expect(KeyEventsPlugin.parseEventName('keyup.shift.control.enter'))
+          .toEqual({'domEventName': 'keyup', 'fullKey': 'control.shift.enter'});
+
+      // key that is also a modifier:
+      expect(KeyEventsPlugin.parseEventName('keydown.shift.control'))
+          .toEqual({'domEventName': 'keydown', 'fullKey': 'shift.control'});
+      expect(KeyEventsPlugin.parseEventName('keyup.shift.control'))
+          .toEqual({'domEventName': 'keyup', 'fullKey': 'shift.control'});
+
+      expect(KeyEventsPlugin.parseEventName('keydown.control.shift'))
+          .toEqual({'domEventName': 'keydown', 'fullKey': 'control.shift'});
+      expect(KeyEventsPlugin.parseEventName('keyup.control.shift'))
+          .toEqual({'domEventName': 'keyup', 'fullKey': 'control.shift'});
+
+    });
+
+    it('should alias esc to escape', () => {
+      expect(KeyEventsPlugin.parseEventName('keyup.control.esc'))
+          .toEqual(KeyEventsPlugin.parseEventName('keyup.control.escape'));
+    });
+
+    it('should implement addGlobalEventListener', () => {
+      const plugin = new KeyEventsPlugin(document);
+
+      spyOn(plugin, 'addEventListener').and.callFake(() => {});
+
+      expect(() => plugin.addGlobalEventListener('window', 'keyup.control.esc', () => {}))
+          .not.toThrowError();
+    });
+
+  });
+}

packages/platform-browser/test/dom/shared_styles_host_spec.ts

@@ -0,0 +1,59 @@
+/**
+ * @license
+ * Copyright Google Inc. 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 {beforeEach, describe, it} from '@angular/core/testing/testing_internal';
+import {getDOM} from '@angular/platform-browser/src/dom/dom_adapter';
+import {DomSharedStylesHost} from '@angular/platform-browser/src/dom/shared_styles_host';
+import {expect} from '@angular/platform-browser/testing/matchers';
+
+export function main() {
+  describe('DomSharedStylesHost', () => {
+    let doc: Document;
+    let ssh: DomSharedStylesHost;
+    let someHost: Element;
+    beforeEach(() => {
+      doc = getDOM().createHtmlDocument();
+      doc.title = '';
+      ssh = new DomSharedStylesHost(doc);
+      someHost = getDOM().createElement('div');
+    });
+
+    it('should add existing styles to new hosts', () => {
+      ssh.addStyles(['a {};']);
+      ssh.addHost(someHost);
+      expect(getDOM().getInnerHTML(someHost)).toEqual('<style>a {};</style>');
+    });
+
+    it('should add new styles to hosts', () => {
+      ssh.addHost(someHost);
+      ssh.addStyles(['a {};']);
+      expect(getDOM().getInnerHTML(someHost)).toEqual('<style>a {};</style>');
+    });
+
+    it('should add styles only once to hosts', () => {
+      ssh.addStyles(['a {};']);
+      ssh.addHost(someHost);
+      ssh.addStyles(['a {};']);
+      expect(getDOM().getInnerHTML(someHost)).toEqual('<style>a {};</style>');
+    });
+
+    it('should use the document head as default host', () => {
+      ssh.addStyles(['a {};', 'b {};']);
+      expect(doc.head).toHaveText('a {};b {};');
+    });
+
+    it('should remove style nodes on destroy', () => {
+      ssh.addStyles(['a {};']);
+      ssh.addHost(someHost);
+      expect(getDOM().getInnerHTML(someHost)).toEqual('<style>a {};</style>');
+
+      ssh.ngOnDestroy();
+      expect(getDOM().getInnerHTML(someHost)).toEqual('');
+    });
+  });
+}