chore(types): add in types inherited from selenium-webdriver

- add element.ts to the gulp task for 'gulp types'
- clang clean up
- separate out selenium-webdriver types and extend them in protractor
- remove webdriver types for index.d.ts file

Author: cnishina

gulpfile.js

@@ -72,7 +72,7 @@ gulp.task('default',['prepublish']);
 
 gulp.task('types', function(done) {
   var folder = 'built';
-  var files = ['ptor', 'browser', 'locators', 'expectedConditions'];
+  var files = ['ptor', 'browser', 'element', 'locators', 'expectedConditions'];
   var outputFile = path.resolve(folder, 'index.d.ts');
   var contents = '';
   files.forEach(file => {
@@ -104,8 +104,29 @@ var parseTypingsFile = function(folder, file) {
       if (line.indexOf('export') !== -1) {
         line = line.replace('export', '').trim();
       }
+
+      // Remove webdriver types and plugins for now
+      line = removeTypes(line,'webdriver.ActionSequence');
+      line = removeTypes(line,'webdriver.promise.Promise');
+      line = removeTypes(line,'webdriver.util.Condition');
+      line = removeTypes(line,'webdriver.WebDriver');
+      line = removeTypes(line,'webdriver.Locator');
+      line = removeTypes(line,'webdriver.WebElement');
+      line = removeTypes(line,'Plugins');
       contents += line + '\n';
     }
+
   }
   return contents;
 }
+
+var removeTypes = function(line, webdriverType) {
+  var tempLine = line.trim();
+  if (tempLine.startsWith('/**') || tempLine.startsWith('*')) {
+    return line;
+  }
+  if (line.indexOf(webdriverType) !== -1) {
+    return line.replace(new RegExp(webdriverType,'g'), 'any');
+  }
+  return line;
+}

lib/browser.ts

@@ -4,7 +4,7 @@ import * as url from 'url';
 import * as util from 'util';
 
 import {ElementArrayFinder, ElementFinder, build$, build$$} from './element';
-import * as EC from './expectedConditions';
+import {ExpectedConditions_} from './expectedConditions';
 import {Locator, ProtractorBy} from './locators';
 import {Logger} from './logger2';
 import {Plugins} from './plugins';
@@ -30,6 +30,23 @@ for (let foo in webdriver) {
   exports[foo] = webdriver[foo];
 }
 
+// explicitly extend selenium webdriver to define functions that
+// are supported per the website
+export class Webdriver {
+  actions: () => webdriver.ActionSequence = webdriver.WebDriver.actions;
+  wait:
+      (condition: webdriver.promise.Promise|webdriver.util.Condition|Function,
+       opt_timeout?: number,
+       opt_message?:
+           string) => webdriver.promise.Promise = webdriver.WebDriver.wait;
+  sleep: (ms: number) => webdriver.promise.Promise = webdriver.WebDriver.sleep;
+  getCurrentUrl:
+      () => webdriver.promise.Promise = webdriver.WebDriver.getCurrentUrl;
+  getTitle: () => webdriver.promise.Promise = webdriver.WebDriver.getTitle;
+  takeScreenshot:
+      () => webdriver.promise.Promise = webdriver.WebDriver.takeScreenshot;
+}
+
 /**
  * Mix a function from one object onto another. The function will still be
  * called in the context of the original object.
@@ -85,7 +102,7 @@ function buildElementHelper(browser: Browser): ElementHelper {
  * @param {boolean=} opt_untrackOutstandingTimeouts Whether Protractor should
  *     stop tracking outstanding $timeouts.
  */
-export class Browser {
+export class Browser extends Webdriver {
   /**
    * @type {ProtractorBy}
    */
@@ -94,7 +111,7 @@ export class Browser {
   /**
    * @type {ExpectedConditions}
    */
-  static ExpectedConditions = new EC.ExpectedConditions();
+  static ExpectedConditions = new ExpectedConditions_();
 
   /**
    * The wrapped webdriver instance. Use this to interact with pages that do
@@ -225,6 +242,7 @@ export class Browser {
   constructor(
       webdriverInstance: webdriver.WebDriver, opt_baseUrl?: string,
       opt_rootElement?: string, opt_untrackOutstandingTimeouts?: boolean) {
+    super();
     // These functions should delegate to the webdriver instance, but should
     // wait for Angular to sync up before performing the action. This does not
     // include functions which are overridden by protractor below.
@@ -281,7 +299,7 @@ export class Browser {
    *
    * Set by the runner.
    *
-   * @return {q.Promise} A promise which resolves to the capabilities object.
+   * @return {webdriver.promise.Promise} A promise which resolves to the capabilities object.
    */
   getProcessedConfig: () => webdriver.promise.Promise;
 

lib/element.ts

@@ -14,6 +14,41 @@ let WEB_ELEMENT_FUNCTIONS = [
   'serialize', 'takeScreenshot'
 ];
 
+// explicitly extend selenium webdriver to define functions that
+// are supported per the website
+export class WebdriverWebElement {
+  getDriver: () => webdriver.WebDriver = webdriver.WebElement.getDriver;
+  getId: () => webdriver.promise.Promise = webdriver.WebElement.getId;
+  getRawId: () => webdriver.promise.Promise = webdriver.WebElement.getRawId;
+  serialize: () => webdriver.promise.Promise = webdriver.WebElement.seralize;
+  findElement: (subLocator: Locator) => webdriver.promise.Promise =
+      webdriver.WebElement.findElement;
+  click: () => webdriver.promise.Promise = webdriver.WebElement.click;
+  sendKeys: (...args: (string|webdriver.promise.Promise)[]) =>
+      webdriver.promise.Promise = webdriver.WebElement.sendKeys;
+  getTagName: () => webdriver.promise.Promise = webdriver.WebElement.getTagName;
+  getCssValue: (cssStyleProperty: string) => webdriver.promise.Promise =
+      webdriver.WebElement.getCssValue;
+  getAttribute: (attributeName: string) => webdriver.promise.Promise =
+      webdriver.WebElement.getAttribute;
+  getText: () => webdriver.promise.Promise = webdriver.WebElement.getText;
+  getSize: () => webdriver.promise.Promise = webdriver.WebElement.getSize;
+  getLocation:
+      () => webdriver.promise.Promise = webdriver.WebElement.getLocation;
+  isEnabled: () => webdriver.promise.Promise = webdriver.WebElement.isEnabled;
+  isSelected: () => webdriver.promise.Promise = webdriver.WebElement.isSelected;
+  submit: () => webdriver.promise.Promise = webdriver.WebElement.submit;
+  clear: () => webdriver.promise.Promise = webdriver.WebElement.clear;
+  isDisplayed:
+      () => webdriver.promise.Promise = webdriver.WebElement.isDisplayed;
+  takeScreenshot: (opt_scroll?: boolean) => webdriver.promise.Promise =
+      webdriver.WebElement.takeScreenshot;
+  getOuterHtml:
+      () => webdriver.promise.Promise = webdriver.WebElement.getOuterHtml;
+  getInnerHtml:
+      () => webdriver.promise.Promise = webdriver.WebElement.getInnerHtml;
+}
+
 /**
  * ElementArrayFinder is used for operations on an array of elements (as opposed
  * to a single element).
@@ -379,7 +414,7 @@ export class ElementArrayFinder {
    *
    * @return {webdriver.Locator}
    */
-  locator(): any { return this.locator_; }
+  locator(): Locator { return this.locator_; }
 
   /**
    * Apply an action function to every element in the ElementArrayFinder,
@@ -661,12 +696,14 @@ export class ElementArrayFinder {
  *     that this is branched from.
  * @return {ElementFinder}
  */
-export class ElementFinder {
+export class ElementFinder extends WebdriverWebElement {
   parentElementArrayFinder: ElementArrayFinder;
   elementArrayFinder_: ElementArrayFinder;
-  then: Function = null;
+  then: (fn: Function, errorFn: Function) => webdriver.promise.Promise = null;
 
-  constructor(private browser_: Browser, elementArrayFinder: ElementArrayFinder) {
+  constructor(
+      private browser_: Browser, elementArrayFinder: ElementArrayFinder) {
+    super();
     if (!elementArrayFinder) {
       throw new Error('BUG: elementArrayFinder cannot be empty');
     }
@@ -680,6 +717,7 @@ export class ElementFinder {
        *
        * @param {function(webdriver.promise.Promise)} fn Function which takes
        *     the value of the underlying actionResult.
+       * @param {function(Error)} errorFn
        *
        * @return {webdriver.promise.Promise} Promise which contains the results of
        *     evaluating fn.
@@ -731,10 +769,12 @@ export class ElementFinder {
     });
   }
 
-  static fromWebElement_(ptor: any, webElem: any, locator: any): ElementFinder {
+  static fromWebElement_(
+      browser: Browser, webElem: webdriver.WebElement,
+      locator: Locator): ElementFinder {
     let getWebElements =
         () => { return webdriver.promise.fulfilled([webElem]); };
-    return new ElementArrayFinder(ptor, getWebElements, locator)
+    return new ElementArrayFinder(browser, getWebElements, locator)
         .toElementFinder_();
   }
 
@@ -802,7 +842,7 @@ export class ElementFinder {
    * @param {webdriver.Locator} subLocator
    * @return {ElementArrayFinder}
    */
-  all(subLocator: any): ElementArrayFinder {
+  all(subLocator: Locator): ElementArrayFinder {
     return this.elementArrayFinder_.all(subLocator);
   }
 
@@ -833,7 +873,7 @@ export class ElementFinder {
    * @param {webdriver.Locator} subLocator
    * @return {ElementFinder}
    */
-  element(subLocator: any): ElementFinder {
+  element(subLocator: Locator): ElementFinder {
     return this.all(subLocator).toElementFinder_();
   }
 

lib/expectedConditions.ts

@@ -1,5 +1,6 @@
-import {protractor} from './ptor';
 import {ElementFinder} from './element';
+import {protractor} from './ptor';
+
 let webdriver = require('selenium-webdriver');
 
 /* globals browser */
@@ -44,7 +45,7 @@ let webdriver = require('selenium-webdriver');
  *
  * @constructor
  */
-export class ExpectedConditions {
+export class ExpectedConditions_ {
   /**
    * Negates the result of a promise.
    *
@@ -189,7 +190,8 @@ export class ExpectedConditions {
    * @return {!function} An expected condition that returns a promise
    *     representing whether the text is present in the element.
    */
-  textToBePresentInElement(elementFinder: ElementFinder, text: string): Function {
+  textToBePresentInElement(elementFinder: ElementFinder, text: string):
+      Function {
     var hasText = () => {
       return elementFinder.getText().then((actualText: string): boolean => {
         return actualText.indexOf(text) > -1;
@@ -213,7 +215,8 @@ export class ExpectedConditions {
    * @return {!function} An expected condition that returns a promise
    *     representing whether the text is present in the element's value.
    */
-  textToBePresentInElementValue(elementFinder: ElementFinder, text: string): Function {
+  textToBePresentInElementValue(elementFinder: ElementFinder, text: string):
+      Function {
     var hasText = () => {
       return elementFinder.getAttribute('value').then(
           (actualText: string): boolean => {

lib/globals.d.ts

@@ -35,6 +35,9 @@ declare interface String { startsWith: Function; }
 
 declare namespace webdriver {
   var error: any;
+
+  class ActionSequence {}
+
   class WebDriver {
     findElements: Function;
     getSession: Function;
@@ -61,12 +64,14 @@ declare namespace webdriver {
   }
 
   namespace promise {
-    interface Promise {
-      controlFlow: Function,
-      then: Function
-    }
+  interface Promise {
+    controlFlow: Function, then: Function
+  }
   }
 
+  namespace util {
+  interface Condition {}
+  }
   class Capabilities {
     get: Function;
   }

lib/locators.ts

@@ -2,13 +2,22 @@ import * as util from 'util';
 let webdriver: any = require('selenium-webdriver');
 let clientSideScripts: any = require('./clientsidescripts');
 
-/**
- * webdriver's By is an enum of locator functions, so we must set it to
- * a prototype before inheriting from it.
- */
-export class WebdriverBy {}
-WebdriverBy.prototype = webdriver.By;
+// explicitly extend selenium webdriver to define functions that
+// are supported per the website
+export class WebdriverBy {
+  className: (className: string) => Locator = webdriver.By.className;
+  css: (css: string) => Locator = webdriver.By.css;
+  id: (id: string) => Locator = webdriver.By.id;
+  linkText: (linkText: string) => Locator = webdriver.By.linkText;
+  js: (js: string) => Locator = webdriver.By.js;
+  name: (name: string) => Locator = webdriver.By.name;
+  partialLinkText:
+      (partialText: string) => Locator = webdriver.By.partialLinkText;
+  tagName: (tagName: string) => Locator = webdriver.By.tagName;
+  xpath: (xpath: string) => Locator = webdriver.By.xpath;
+}
 
+// interface for webdriver.Locator
 export interface Locator {
   findElementsOverride?:
       (driver: webdriver.WebDriver, using: webdriver.WebElement,
@@ -27,17 +36,6 @@ export interface Locator {
 export class ProtractorBy extends WebdriverBy {
   [key: string]: any;
 
-  className: (className: string) => Locator = webdriver.By.className;
-  css: (css: string) => Locator = webdriver.By.css;
-  id: (id: string) => Locator = webdriver.By.id;
-  linkText: (linkText: string) => Locator = webdriver.By.linkText;
-  js: (js: string) => Locator = webdriver.By.js;
-  name: (name: string) => Locator = webdriver.By.name;
-  partialLinkText:
-      (partialText: string) => Locator = webdriver.By.partialLinkText;
-  tagName: (tagName: string) => Locator = webdriver.By.tagName;
-  xpath: (xpath: string) => Locator = webdriver.By.xpath;
-
   /**
    * Add a locator to this instance of ProtractorBy. This locator can then be
    * used with element(by.locatorName(args)).