cli: esm support

bin/cucumber-es.mjs

@@ -0,0 +1,6 @@
+#!/usr/bin/env node
+
+(async () => {
+  const run = await import('../lib/cli/run.js')
+  await run.default.default((path) => import(path))
+})()

features/esm.feature

@@ -0,0 +1,37 @@
+Feature: ES modules support
+
+  cucumber-js works with native ES modules, via a separate executable
+  called `cucumber-es`.
+
+  @esm
+  Scenario: native module syntax works when using cucumber-es
+    Given a file named "features/a.feature" with:
+      """
+      Feature:
+        Scenario:
+          Given a step passes
+      """
+    And a file named "features/step_definitions/cucumber_steps.js" with:
+      """
+      import {Given} from '@cucumber/cucumber'
+
+      Given(/^a step passes$/, function() {});
+      """
+    When I run cucumber-es
+    Then it passes
+
+  Scenario: native module syntax doesn't work when using cucumber-js
+    Given a file named "features/a.feature" with:
+      """
+      Feature:
+        Scenario:
+          Given a step passes
+      """
+    And a file named "features/step_definitions/cucumber_steps.js" with:
+      """
+      import {Given} from '@cucumber/cucumber'
+
+      Given(/^a step passes$/, function() {});
+      """
+    When I run cucumber-js
+    Then it fails

features/step_definitions/cli_steps.ts

@@ -16,6 +16,16 @@ When('my env includes {string}', function (this: World, envString: string) {
   this.sharedEnv = this.parseEnvString(envString)
 })
 
+When(
+  /^I run cucumber-es(?: with `(|.+)`)?$/,
+  { timeout: 10000 },
+  async function (this: World, args: string) {
+    const renderedArgs = Mustache.render(valueOrDefault(args, ''), this)
+    const stringArgs = stringArgv(renderedArgs)
+    return await this.run(this.localEsmExecutablePath, stringArgs)
+  }
+)
+
 When(
   /^I run cucumber-js(?: with `(|.+)`)?$/,
   { timeout: 10000 },

features/support/hooks.ts

@@ -13,7 +13,7 @@ Before('@debug', function (this: World) {
   this.debug = true
 })
 
-Before('@spawn', function (this: World) {
+Before('@spawn or @esm', function (this: World) {
   this.spawn = true
 })
 
@@ -41,6 +41,18 @@ Before(function (
   )
   fsExtra.ensureSymlinkSync(projectPath, tmpDirCucumberPath)
   this.localExecutablePath = path.join(projectPath, 'bin', 'cucumber-js')
+  this.localEsmExecutablePath = path.join(projectPath, 'bin', 'cucumber-es.mjs')
+})
+
+Before('@esm', function (this: World) {
+  if (process.platform === 'win32') {
+    return 'skipped'
+  }
+  fsExtra.writeJSONSync(path.join(this.tmpDir, 'package.json'), {
+    name: 'feature-test-pickle',
+    type: 'module',
+  })
+  return undefined
 })
 
 Before('@global-install', function (this: World) {

features/support/world.ts

@@ -34,6 +34,7 @@ export class World {
   public lastRun: ILastRun
   public verifiedLastRunError: boolean
   public localExecutablePath: string
+  public localEsmExecutablePath: string
   public globalExecutablePath: string
   public reportServer: FakeReportServer
 

package.json

@@ -162,6 +162,10 @@
     "lib": "./lib"
   },
   "main": "./lib/index.js",
+  "exports": {
+    "import": "./wrapper.mjs",
+    "require": "./lib/index.js"
+  },
   "types": "./lib/index.d.ts",
   "engines": {
     "node": ">=10"
@@ -282,11 +286,13 @@
     }
   },
   "bin": {
-    "cucumber-js": "./bin/cucumber-js"
+    "cucumber-js": "./bin/cucumber-js",
+    "cucumber-es": "./bin/cucumber-es.mjs"
   },
   "license": "MIT",
   "files": [
     "bin/",
-    "lib/"
+    "lib/",
+    "wrapper.mjs"
   ]
 }

src/cli/index.ts

@@ -50,22 +50,30 @@ interface IGetSupportCodeLibraryRequest {
   supportCodePaths: string[]
 }
 
+export type ISupportCodeImporter = (path: string) => Promise<any>
+
 export default class Cli {
   private readonly argv: string[]
   private readonly cwd: string
+  private readonly importer: ISupportCodeImporter
   private readonly stdout: IFormatterStream
 
   constructor({
     argv,
     cwd,
+    importer,
     stdout,
   }: {
     argv: string[]
     cwd: string
+    importer?: ISupportCodeImporter
     stdout: IFormatterStream
   }) {
     this.argv = argv
     this.cwd = cwd
+    this.importer =
+      // eslint-disable-next-line @typescript-eslint/no-var-requires
+      importer ?? (async (path) => await Promise.resolve(require(path)))
     this.stdout = stdout
   }
 
@@ -139,14 +147,18 @@ export default class Cli {
     }
   }
 
-  getSupportCodeLibrary({
+  async getSupportCodeLibrary({
     newId,
     supportCodeRequiredModules,
     supportCodePaths,
-  }: IGetSupportCodeLibraryRequest): ISupportCodeLibrary {
-    supportCodeRequiredModules.map((module) => require(module))
+  }: IGetSupportCodeLibraryRequest): Promise<ISupportCodeLibrary> {
+    for (const requiredModule of supportCodeRequiredModules) {
+      await this.importer(requiredModule)
+    }
     supportCodeLibraryBuilder.reset(this.cwd, newId)
-    supportCodePaths.forEach((codePath) => require(codePath))
+    for (const codePath of supportCodePaths) {
+      await this.importer(codePath)
+    }
     return supportCodeLibraryBuilder.finalize()
   }
 
@@ -165,7 +177,7 @@ export default class Cli {
       configuration.predictableIds && configuration.parallel <= 1
         ? incrementing()
         : uuid()
-    const supportCodeLibrary = this.getSupportCodeLibrary({
+    const supportCodeLibrary = await this.getSupportCodeLibrary({
       newId,
       supportCodePaths: configuration.supportCodePaths,
       supportCodeRequiredModules: configuration.supportCodeRequiredModules,

src/cli/run.ts

@@ -1,4 +1,4 @@
-import Cli, { ICliRunResult } from './'
+import Cli, { ICliRunResult, ISupportCodeImporter } from './'
 import VError from 'verror'
 import publishBanner from './publish_banner'
 
@@ -11,11 +11,14 @@ function displayPublishAdvertisementBanner(): void {
   console.error(publishBanner)
 }
 
-export default async function run(): Promise<void> {
+export default async function run(
+  importer?: ISupportCodeImporter
+): Promise<void> {
   const cwd = process.cwd()
   const cli = new Cli({
     argv: process.argv,
     cwd,
+    importer,
     stdout: process.stdout,
   })
 

tsconfig.json

@@ -1,14 +1,14 @@
 {
   "compilerOptions": {
     "esModuleInterop": true,
-    "lib": ["es2017"],
+    "lib": ["es2018"],
     "module": "commonjs",
     "noImplicitAny": true,
     "noImplicitReturns": true,
     "noImplicitThis": true,
     "resolveJsonModule": true,
     "sourceMap": true,
-    "target": "es2017",
+    "target": "es2018",
     "typeRoots": [
       "./node_modules/@types",
       "./src/types"

wrapper.mjs

@@ -0,0 +1,38 @@
+import cucumber from './lib/index.js'
+
+export const Cli = cucumber.Cli
+export const parseGherkinMessageStream = cucumber.parseGherkinMessageStream
+export const PickleFilter = cucumber.PickleFilter
+export const Runtime = cucumber.Runtime
+export const supportCodeLibraryBuilder = cucumber.supportCodeLibraryBuilder
+export const Status = cucumber.Status
+export const DataTable = cucumber.DataTable
+
+export const Formatter = cucumber.Formatter
+export const FormatterBuilder = cucumber.FormatterBuilder
+export const JsonFormatter = cucumber.JsonFormatter
+export const ProgressFormatter = cucumber.ProgressFormatter
+export const RerunFormatter = cucumber.RerunFormatter
+export const SnippetsFormatter = cucumber.SnippetsFormatter
+export const SummaryFormatter = cucumber.SummaryFormatter
+export const UsageFormatter = cucumber.UsageFormatter
+export const UsageJsonFormatter = cucumber.UsageJsonFormatter
+export const formatterHelpers = cucumber.formatterHelpers
+
+export const After = cucumber.After
+export const AfterAll = cucumber.AfterAll
+export const AfterStep = cucumber.AfterStep
+export const Before = cucumber.Before
+export const BeforeAll = cucumber.BeforeAll
+export const BeforeStep = cucumber.BeforeStep
+export const defineParameterType = cucumber.defineParameterType
+export const defineStep = cucumber.defineStep
+export const Given = cucumber.Given
+export const setDefaultTimeout = cucumber.setDefaultTimeout
+export const setDefinitionFunctionWrapper = cucumber.setDefinitionFunctionWrapper
+export const setWorldConstructor = cucumber.setWorldConstructor
+export const Then = cucumber.Then
+export const When = cucumber.When
+
+export const World = cucumber.World
+