@seleniumhq/code-export-javascript-mocha 3.17.2 → 4.0.0-alpha.0

package/src/{command.js → command.ts}

@@ -15,11 +15,18 @@
 // specific language governing permissions and limitations
 // under the License.
 
-import { codeExport as exporter } from '@seleniumhq/side-utils'
+import {
+  codeExport as exporter,
+  ExportFlexCommandShape,
+  PrebuildEmitter,
+  ProcessedCommandEmitter,
+  ScriptShape,
+} from '@seleniumhq/side-code-export'
+import { CommandShape } from '@seleniumhq/side-model'
 import location from './location'
 import selection from './selection'
 
-export const emitters = {
+export const emitters: Record<string, ProcessedCommandEmitter> = {
   addSelection: emitSelect,
   answerOnNextPrompt: skip,
   assert: emitAssert,
@@ -114,7 +121,8 @@ export const emitters = {
   waitForElementNotVisible: emitWaitForElementNotVisible,
   webdriverAnswerOnVisiblePrompt: emitAnswerOnNextPrompt,
   waitForText: emitWaitForText,
-  webdriverChooseCancelOnVisibleConfirmation: emitChooseCancelOnNextConfirmation,
+  webdriverChooseCancelOnVisibleConfirmation:
+    emitChooseCancelOnNextConfirmation,
   webdriverChooseCancelOnVisiblePrompt: emitChooseCancelOnNextConfirmation,
   webdriverChooseOkOnVisibleConfirmation: emitChooseOkOnNextConfirmation,
   while: emitControlFlowWhile,
@@ -122,31 +130,27 @@ export const emitters = {
 
 exporter.register.preprocessors(emitters)
 
-function register(command, emitter) {
+function register(command: string, emitter: PrebuildEmitter) {
   exporter.register.emitter({ command, emitter, emitters })
 }
 
-function emit(command) {
+function emit(command: CommandShape) {
   return exporter.emit.command(command, emitters[command.command], {
     variableLookup,
     emitNewWindowHandling,
   })
 }
 
-function canEmit(commandName) {
-  return !!emitters[commandName]
-}
-
-function variableLookup(varName) {
+function variableLookup(varName: string) {
   return `vars["${varName}"]`
 }
 
-function variableSetter(varName, value) {
+function variableSetter(varName: string, value: string) {
   return varName ? `vars["${varName}"] = ${value}` : ''
 }
 
 function emitWaitForWindow() {
-  const generateMethodDeclaration = name => {
+  const generateMethodDeclaration = (name: string) => {
     return {
       body: `async function ${name}(timeout = 2) {`,
       terminatingKeyword: '}',
@@ -178,7 +182,7 @@ function emitWaitForWindow() {
   })
 }
 
-async function emitNewWindowHandling(command, emittedCommand) {
+async function emitNewWindowHandling(command: CommandShape, emittedCommand: ExportFlexCommandShape) {
   return Promise.resolve(
     `vars["windowHandles"] = await driver.getAllWindowHandles()\n${await emittedCommand}\nvars["${
       command.windowHandleName
@@ -186,17 +190,17 @@ async function emitNewWindowHandling(command, emittedCommand) {
   )
 }
 
-function emitAssert(varName, value) {
+function emitAssert(varName: string, value: string) {
   return Promise.resolve(`assert(vars["${varName}"].toString() == "${value}")`)
 }
 
-function emitAssertAlert(alertText) {
+function emitAssertAlert(alertText: string) {
   return Promise.resolve(
     `assert(await driver.switchTo().alert().getText() == "${alertText}")`
   )
 }
 
-function emitAnswerOnNextPrompt(textToSend) {
+function emitAnswerOnNextPrompt(textToSend: string) {
   const commands = [
     { level: 0, statement: `{` },
     { level: 1, statement: 'const alert = await driver.switchTo().alert()' },
@@ -207,7 +211,7 @@ function emitAnswerOnNextPrompt(textToSend) {
   return Promise.resolve({ commands })
 }
 
-async function emitCheck(locator) {
+async function emitCheck(locator: string) {
   const commands = [
     {
       level: 0,
@@ -239,7 +243,7 @@ function emitChooseOkOnNextConfirmation() {
   return Promise.resolve(`await driver.switchTo().alert().accept()`)
 }
 
-async function emitClick(target) {
+async function emitClick(target: string) {
   return Promise.resolve(
     `await driver.findElement(${await location.emit(target)}).click()`
   )
@@ -249,15 +253,15 @@ async function emitClose() {
   return Promise.resolve(`await driver.close()`)
 }
 
-function generateExpressionScript(script) {
+function generateExpressionScript(script: ScriptShape) {
   return `await driver.executeScript("return (${
     script.script
   })"${generateScriptArguments(script)})`
 }
 
-function generateScriptArguments(script) {
+function generateScriptArguments(script: ScriptShape) {
   return `${script.argv.length ? ', ' : ''}${script.argv
-    .map(varName => `vars["${varName}"]`)
+    .map((varName) => `vars["${varName}"]`)
     .join(',')}`
 }
 
@@ -276,7 +280,7 @@ function emitControlFlowElse() {
   })
 }
 
-function emitControlFlowElseIf(script) {
+function emitControlFlowElseIf(script: ScriptShape) {
   return Promise.resolve({
     commands: [
       {
@@ -296,7 +300,7 @@ function emitControlFlowEnd() {
   })
 }
 
-function emitControlFlowIf(script) {
+function emitControlFlowIf(script: ScriptShape) {
   return Promise.resolve({
     commands: [
       { level: 0, statement: `if (!!${generateExpressionScript(script)}) {` },
@@ -305,7 +309,7 @@ function emitControlFlowIf(script) {
   })
 }
 
-function emitControlFlowForEach(collectionVarName, iteratorVarName) {
+function emitControlFlowForEach(collectionVarName: string, iteratorVarName: string) {
   return Promise.resolve({
     commands: [
       {
@@ -324,7 +328,7 @@ function emitControlFlowForEach(collectionVarName, iteratorVarName) {
   })
 }
 
-function emitControlFlowRepeatIf(script) {
+function emitControlFlowRepeatIf(script: ScriptShape) {
   return Promise.resolve({
     commands: [
       {
@@ -336,7 +340,7 @@ function emitControlFlowRepeatIf(script) {
   })
 }
 
-function emitControlFlowTimes(target) {
+function emitControlFlowTimes(target: string) {
   const commands = [
     {
       level: 0,
@@ -350,7 +354,7 @@ function emitControlFlowTimes(target) {
   return Promise.resolve({ commands, endingLevelAdjustment: 1 })
 }
 
-function emitControlFlowWhile(script) {
+function emitControlFlowWhile(script: ScriptShape) {
   return Promise.resolve({
     commands: [
       { level: 0, statement: `while(!!${generateExpressionScript(script)}) {` },
@@ -359,7 +363,7 @@ function emitControlFlowWhile(script) {
   })
 }
 
-async function emitDoubleClick(target) {
+async function emitDoubleClick(target: string) {
   const commands = [
     { level: 0, statement: `{` },
     {
@@ -378,7 +382,7 @@ async function emitDoubleClick(target) {
   return Promise.resolve({ commands })
 }
 
-async function emitDragAndDrop(dragged, dropped) {
+async function emitDragAndDrop(dragged: string, dropped: string) {
   const commands = [
     { level: 0, statement: `{` },
     {
@@ -403,12 +407,12 @@ async function emitDragAndDrop(dragged, dropped) {
   return Promise.resolve({ commands })
 }
 
-async function emitEcho(message) {
+async function emitEcho(message: string) {
   const _message = message.startsWith('vars[') ? message : `"${message}"`
   return Promise.resolve(`console.log(${_message})`)
 }
 
-async function emitEditContent(locator, content) {
+async function emitEditContent(locator: string, content: string) {
   const commands = [
     { level: 0, statement: `{` },
     {
@@ -426,7 +430,7 @@ async function emitEditContent(locator, content) {
   return Promise.resolve({ commands })
 }
 
-async function emitExecuteScript(script, varName) {
+async function emitExecuteScript(script: ScriptShape, varName: string) {
   const scriptString = script.script.replace(/`/g, '\\`')
   const result = `await driver.executeScript("${scriptString}"${generateScriptArguments(
     script
@@ -434,14 +438,14 @@ async function emitExecuteScript(script, varName) {
   return Promise.resolve(variableSetter(varName, result))
 }
 
-async function emitExecuteAsyncScript(script, varName) {
+async function emitExecuteAsyncScript(script: ScriptShape, varName: string) {
   const result = `await driver.executeAsyncScript("var callback = arguments[arguments.length - 1];${
     script.script
   }.then(callback).catch(callback);${generateScriptArguments(script)}")`
   return Promise.resolve(variableSetter(varName, result))
 }
 
-async function emitMouseDown(locator) {
+async function emitMouseDown(locator: string) {
   const commands = [
     { level: 0, statement: `{` },
     {
@@ -460,7 +464,7 @@ async function emitMouseDown(locator) {
   return Promise.resolve({ commands })
 }
 
-async function emitMouseMove(locator) {
+async function emitMouseMove(locator: string) {
   const commands = [
     { level: 0, statement: `{` },
     {
@@ -496,7 +500,7 @@ async function emitMouseOut() {
   return Promise.resolve({ commands })
 }
 
-async function emitMouseUp(locator) {
+async function emitMouseUp(locator: string) {
   const commands = [
     { level: 0, statement: `{` },
     {
@@ -515,23 +519,24 @@ async function emitMouseUp(locator) {
   return Promise.resolve({ commands })
 }
 
-function emitOpen(target) {
+function emitOpen(target: string) {
   const url = /^(file|http|https):\/\//.test(target)
     ? `"${target}"`
-    : `"${global.baseUrl}${target}"`
+    : // @ts-expect-error globals yuck
+    `"${global.baseUrl}${target}"`
   return Promise.resolve(`await driver.get(${url})`)
 }
 
-async function emitPause(time) {
+async function emitPause(time: string) {
   const commands = [{ level: 0, statement: `await driver.sleep(${time})` }]
   return Promise.resolve({ commands })
 }
 
-async function emitRun(testName) {
+async function emitRun(testName: string) {
   return Promise.resolve(`${exporter.parsers.sanitizeName(testName)}()`)
 }
 
-async function emitRunScript(script) {
+async function emitRunScript(script: ScriptShape) {
   return Promise.resolve(
     `await driver.executeScript("${script.script}${generateScriptArguments(
       script
@@ -539,14 +544,14 @@ async function emitRunScript(script) {
   )
 }
 
-async function emitSetWindowSize(size) {
+async function emitSetWindowSize(size: string) {
   const [width, height] = size.split('x')
   return Promise.resolve(
     `await driver.manage().window().setRect({ width: ${width}, height: ${height} })`
   )
 }
 
-async function emitSelect(selectElement, option) {
+async function emitSelect(selectElement: string, option: string) {
   const commands = [
     { level: 0, statement: `{` },
     {
@@ -566,13 +571,13 @@ async function emitSelect(selectElement, option) {
   return Promise.resolve({ commands })
 }
 
-async function emitSelectFrame(frameLocation) {
+async function emitSelectFrame(frameLocation: string) {
   if (frameLocation === 'relative=top' || frameLocation === 'relative=parent') {
     return Promise.resolve('await driver.switchTo().defaultContent()')
   } else if (/^index=/.test(frameLocation)) {
     return Promise.resolve(
       `await driver.switchTo().frame(${Math.floor(
-        frameLocation.split('index=')[1]
+        Number(frameLocation.split('index=')?.[1])
       )})`
     )
   } else {
@@ -592,7 +597,7 @@ async function emitSelectFrame(frameLocation) {
   }
 }
 
-async function emitSelectWindow(windowLocation) {
+async function emitSelectWindow(windowLocation: string) {
   if (/^handle=/.test(windowLocation)) {
     return Promise.resolve(
       `await driver.switchTo().window(${windowLocation.split('handle=')[1]})`
@@ -630,14 +635,14 @@ async function emitSelectWindow(windowLocation) {
   }
 }
 
-function generateSendKeysInput(value) {
+function generateSendKeysInput(value: string | string[]) {
   if (typeof value === 'object') {
     return value
-      .map(s => {
+      .map((s) => {
         if (s.startsWith('vars[')) {
           return s
         } else if (s.startsWith('Key[')) {
-          const key = s.match(/\['(.*)'\]/)[1]
+          const key = s.match(/\['(.*)'\]/)?.[1]
           return `Key.${key}`
         } else {
           return `"${s}"`
@@ -653,7 +658,7 @@ function generateSendKeysInput(value) {
   }
 }
 
-async function emitSendKeys(target, value) {
+async function emitSendKeys(target: string, value: string) {
   return Promise.resolve(
     `await driver.findElement(${await location.emit(
       target
@@ -667,11 +672,11 @@ function emitSetSpeed() {
   )
 }
 
-async function emitStore(value, varName) {
+async function emitStore(value: string, varName: string) {
   return Promise.resolve(variableSetter(varName, `"${value}"`))
 }
 
-async function emitStoreAttribute(locator, varName) {
+async function emitStoreAttribute(locator: string, varName: string) {
   const attributePos = locator.lastIndexOf('@')
   const elementLocator = locator.slice(0, attributePos)
   const attributeName = locator.slice(attributePos + 1)
@@ -689,48 +694,48 @@ async function emitStoreAttribute(locator, varName) {
   return Promise.resolve({ commands })
 }
 
-async function emitStoreJson(json, varName) {
+async function emitStoreJson(json: string, varName: string) {
   return Promise.resolve(variableSetter(varName, `JSON.parse('${json}')`))
 }
 
-async function emitStoreText(locator, varName) {
+async function emitStoreText(locator: string, varName: string) {
   const result = `await driver.findElement(${await location.emit(
     locator
   )}).getText()`
   return Promise.resolve(variableSetter(varName, result))
 }
 
-async function emitStoreTitle(_, varName) {
+async function emitStoreTitle(_: string, varName: string) {
   return Promise.resolve(variableSetter(varName, 'await driver.getTitle()'))
 }
 
-async function emitStoreValue(locator, varName) {
+async function emitStoreValue(locator: string, varName: string) {
   const result = `await driver.findElement(${await location.emit(
     locator
   )}).getAttribute("value")`
   return Promise.resolve(variableSetter(varName, result))
 }
 
-async function emitStoreWindowHandle(varName) {
+async function emitStoreWindowHandle(varName: string) {
   return Promise.resolve(
     variableSetter(varName, 'await driver.getWindowHandle()')
   )
 }
 
-async function emitStoreXpathCount(locator, varName) {
+async function emitStoreXpathCount(locator: string, varName: string) {
   const result = `await driver.findElements(${await location.emit(
     locator
   )}).length`
   return Promise.resolve(variableSetter(varName, result))
 }
 
-async function emitSubmit(_locator) {
+async function emitSubmit(_locator: string) {
   return Promise.resolve(
     `raise Exception("\`submit\` is not a supported command in Selenium Webdriver. Please re-record the step in the IDE.")`
   )
 }
 
-async function emitType(target, value) {
+async function emitType(target: string, value: string) {
   return Promise.resolve(
     `await driver.findElement(${await location.emit(
       target
@@ -738,7 +743,7 @@ async function emitType(target, value) {
   )
 }
 
-async function emitUncheck(locator) {
+async function emitUncheck(locator: string) {
   const commands = [
     { level: 0, statement: `{` },
     {
@@ -756,7 +761,7 @@ async function emitUncheck(locator) {
   return Promise.resolve({ commands })
 }
 
-async function emitVerifyChecked(locator) {
+async function emitVerifyChecked(locator: string) {
   return Promise.resolve(
     `assert(await driver.findElement(${await location.emit(
       locator
@@ -764,7 +769,7 @@ async function emitVerifyChecked(locator) {
   )
 }
 
-async function emitVerifyEditable(locator) {
+async function emitVerifyEditable(locator: string) {
   const commands = [
     { level: 0, statement: `{` },
     {
@@ -779,7 +784,7 @@ async function emitVerifyEditable(locator) {
   return Promise.resolve({ commands })
 }
 
-async function emitVerifyElementPresent(locator) {
+async function emitVerifyElementPresent(locator: string) {
   const commands = [
     { level: 0, statement: `{` },
     {
@@ -794,7 +799,7 @@ async function emitVerifyElementPresent(locator) {
   return Promise.resolve({ commands })
 }
 
-async function emitVerifyElementNotPresent(locator) {
+async function emitVerifyElementNotPresent(locator: string) {
   const commands = [
     { level: 0, statement: `{` },
     {
@@ -809,7 +814,7 @@ async function emitVerifyElementNotPresent(locator) {
   return Promise.resolve({ commands })
 }
 
-async function emitVerifyNotChecked(locator) {
+async function emitVerifyNotChecked(locator: string) {
   return Promise.resolve(
     `assert(!await driver.findElement(${await location.emit(
       locator
@@ -817,7 +822,7 @@ async function emitVerifyNotChecked(locator) {
   )
 }
 
-async function emitVerifyNotEditable(locator) {
+async function emitVerifyNotEditable(locator: string) {
   const commands = [
     { level: 0, statement: `{` },
     {
@@ -832,7 +837,7 @@ async function emitVerifyNotEditable(locator) {
   return Promise.resolve({ commands })
 }
 
-async function emitVerifyNotSelectedValue(locator, expectedValue) {
+async function emitVerifyNotSelectedValue(locator: string, expectedValue: string) {
   const commands = [
     { level: 0, statement: `{` },
     {
@@ -850,7 +855,7 @@ async function emitVerifyNotSelectedValue(locator, expectedValue) {
   return Promise.resolve({ commands })
 }
 
-async function emitVerifyNotText(locator, text) {
+async function emitVerifyNotText(locator: string, text: string) {
   const commands = [
     { level: 0, statement: `{` },
     {
@@ -865,7 +870,7 @@ async function emitVerifyNotText(locator, text) {
   return Promise.resolve({ commands })
 }
 
-async function emitVerifySelectedLabel(locator, labelValue) {
+async function emitVerifySelectedLabel(locator: string, labelValue: string) {
   const commands = [
     { level: 0, statement: `{` },
     {
@@ -892,7 +897,7 @@ async function emitVerifySelectedLabel(locator, labelValue) {
   })
 }
 
-async function emitVerifyText(locator, text) {
+async function emitVerifyText(locator: string, text: string) {
   const commands = [
     {
       level: 0,
@@ -904,7 +909,7 @@ async function emitVerifyText(locator, text) {
   return Promise.resolve({ commands })
 }
 
-async function emitVerifyValue(locator, value) {
+async function emitVerifyValue(locator: string, value: string) {
   const commands = [
     { level: 0, statement: `{` },
     {
@@ -919,15 +924,15 @@ async function emitVerifyValue(locator, value) {
   return Promise.resolve({ commands })
 }
 
-async function emitVerifyTitle(title) {
+async function emitVerifyTitle(title: string) {
   return Promise.resolve(`assert(await driver.getTitle() == "${title}")`)
 }
 
 function skip() {
-  return Promise.resolve(undefined)
+  return Promise.resolve('')
 }
 
-async function emitWaitForElementPresent(locator, timeout) {
+async function emitWaitForElementPresent(locator: string, timeout: number) {
   return Promise.resolve(
     `await driver.wait(until.elementLocated(${await location.emit(
       locator
@@ -935,7 +940,7 @@ async function emitWaitForElementPresent(locator, timeout) {
   )
 }
 
-async function emitWaitForElementNotPresent(locator, timeout) {
+async function emitWaitForElementNotPresent(locator: string, timeout: number) {
   return Promise.resolve(
     `await driver.wait(until.stalenessOf(await driver.findElement(${await location.emit(
       locator
@@ -943,7 +948,7 @@ async function emitWaitForElementNotPresent(locator, timeout) {
   )
 }
 
-async function emitWaitForElementVisible(locator, timeout) {
+async function emitWaitForElementVisible(locator: string, timeout: number) {
   return Promise.resolve(
     `await driver.wait(until.elementIsVisible(await driver.findElement(${await location.emit(
       locator
@@ -951,7 +956,7 @@ async function emitWaitForElementVisible(locator, timeout) {
   )
 }
 
-async function emitWaitForElementNotVisible(locator, timeout) {
+async function emitWaitForElementNotVisible(locator: string, timeout: number) {
   return Promise.resolve(
     `await driver.wait(until.elementIsNotVisible(await driver.findElement(${await location.emit(
       locator
@@ -959,7 +964,7 @@ async function emitWaitForElementNotVisible(locator, timeout) {
   )
 }
 
-async function emitWaitForElementEditable(locator, timeout) {
+async function emitWaitForElementEditable(locator: string, timeout: number) {
   return Promise.resolve(
     `await driver.wait(until.elementIsEnabled(await driver.findElement(${await location.emit(
       locator
@@ -967,7 +972,7 @@ async function emitWaitForElementEditable(locator, timeout) {
   )
 }
 
-async function emitWaitForElementNotEditable(locator, timeout) {
+async function emitWaitForElementNotEditable(locator: string, timeout: number) {
   return Promise.resolve(
     `await driver.wait(until.elementIsDisabled(await driver.findElement(${await location.emit(
       locator
@@ -975,7 +980,7 @@ async function emitWaitForElementNotEditable(locator, timeout) {
   )
 }
 
-async function emitWaitForText(locator, text) {
+async function emitWaitForText(locator: string, text: string) {
   const timeout = 30000
   return Promise.resolve(
     `await driver.wait(until.elementTextIs(await driver.findElement(${await location.emit(
@@ -985,8 +990,8 @@ async function emitWaitForText(locator, text) {
 }
 
 export default {
-  canEmit,
   emit,
+  emitters,
+  extras: { emitNewWindowHandling, emitWaitForWindow },
   register,
-  extras: { emitWaitForWindow },
 }

package/src/{hook.js → hook.ts}

@@ -14,7 +14,7 @@
 // KIND, either express or implied.  See the License for the specific language governing permissions and limitations
 // under the License.
 
-import { codeExport as exporter } from '@seleniumhq/side-utils'
+import { HookFunctionInputs } from "@seleniumhq/side-code-export"
 
 const emitters = {
   afterAll,
@@ -28,17 +28,7 @@ const emitters = {
   inEachEnd: empty,
 }
 
-function generate(hookName) {
-  return new exporter.hook(emitters[hookName]())
-}
-
-export function generateHooks() {
-  let result = {}
-  Object.keys(emitters).forEach(hookName => {
-    result[hookName] = generate(hookName)
-  })
-  return result
-}
+export default emitters
 
 function afterAll() {
   const params = {
@@ -82,7 +72,7 @@ function beforeAll() {
 }
 
 function beforeEach() {
-  const params = {
+  const params: HookFunctionInputs = {
     startingSyntax: ({ browserName, gridUrl } = {}) => ({
       commands: [
         { level: 0, statement: 'beforeEach(async function() {' },