Split out a "core" package candidate (#45)

Author: davidjgoss

eslint.config.mjs

@@ -1,54 +1,74 @@
-import { fixupConfigRules, fixupPluginRules } from "@eslint/compat";
-import _import from "eslint-plugin-import";
-import simpleImportSort from "eslint-plugin-simple-import-sort";
-import n from "eslint-plugin-n";
-import typescriptEslint from "@typescript-eslint/eslint-plugin";
-import globals from "globals";
-import tsParser from "@typescript-eslint/parser";
-import path from "node:path";
-import { fileURLToPath } from "node:url";
-import js from "@eslint/js";
-import { FlatCompat } from "@eslint/eslintrc";
+import { fixupConfigRules, fixupPluginRules } from '@eslint/compat'
+import _import from 'eslint-plugin-import'
+import simpleImportSort from 'eslint-plugin-simple-import-sort'
+import n from 'eslint-plugin-n'
+import typescriptEslint from '@typescript-eslint/eslint-plugin'
+import globals from 'globals'
+import tsParser from '@typescript-eslint/parser'
+import path from 'node:path'
+import { fileURLToPath } from 'node:url'
+import js from '@eslint/js'
+import { FlatCompat } from '@eslint/eslintrc'
 
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
+const __filename = fileURLToPath(import.meta.url)
+const __dirname = path.dirname(__filename)
 const compat = new FlatCompat({
-    baseDirectory: __dirname,
-    recommendedConfig: js.configs.recommended,
-    allConfig: js.configs.all
-});
+  baseDirectory: __dirname,
+  recommendedConfig: js.configs.recommended,
+  allConfig: js.configs.all,
+})
 
-export default [...fixupConfigRules(compat.extends(
-    "eslint:recommended",
-    "plugin:import/typescript",
-    "plugin:@typescript-eslint/eslint-recommended",
-    "plugin:@typescript-eslint/recommended",
-)), {
+export default [
+  ...fixupConfigRules(
+    compat.extends(
+      'eslint:recommended',
+      'plugin:import/typescript',
+      'plugin:@typescript-eslint/eslint-recommended',
+      'plugin:@typescript-eslint/recommended'
+    )
+  ),
+  {
     plugins: {
-        import: fixupPluginRules(_import),
-        "simple-import-sort": simpleImportSort,
-        n,
-        "@typescript-eslint": fixupPluginRules(typescriptEslint),
+      import: fixupPluginRules(_import),
+      'simple-import-sort': simpleImportSort,
+      n,
+      '@typescript-eslint': fixupPluginRules(typescriptEslint),
     },
 
     languageOptions: {
-        globals: {
-            ...globals.node,
-        },
+      globals: {
+        ...globals.node,
+      },
 
-        parser: tsParser,
-        ecmaVersion: 5,
-        sourceType: "module",
+      parser: tsParser,
+      ecmaVersion: 5,
+      sourceType: 'module',
 
-        parserOptions: {
-            project: "tsconfig.json",
-        },
+      parserOptions: {
+        project: 'tsconfig.json',
+      },
     },
 
     rules: {
-        "import/no-cycle": "error",
-        "n/no-extraneous-import": "error",
-        "simple-import-sort/imports": "error",
-        "simple-import-sort/exports": "error",
+      'import/no-cycle': 'error',
+      'n/no-extraneous-import': 'error',
+      'simple-import-sort/imports': 'error',
+      'simple-import-sort/exports': 'error',
+      'import/no-relative-parent-imports': 'error',
     },
-}];
+  },
+  {
+    files: ['src/core/**/*.ts'],
+
+    rules: {
+      'no-restricted-imports': ['error', {
+        patterns: [
+          {
+            group: ['../'],
+            message: 'The core should be self-contained'
+          }
+        ]
+      }],
+    },
+  },
+]

package.json

@@ -20,7 +20,7 @@
     "docs": "typedoc",
     "exports:check": "api-extractor run --verbose",
     "exports:update": "api-extractor run --verbose --local",
-    "fix": "eslint --max-warnings 0 src --fix src && prettier --write src test",
+    "fix": "eslint --max-warnings 0 src --fix && prettier --write src test",
     "lint": "eslint --max-warnings 0 src && prettier --check src test",
     "test": "npm run test:unit && npm run test:integration",
     "test:integration": "tsc && mocha test/**/*.spec.ts",

src/runner/AmbiguousError.spec.ts renamed to src/core/AmbiguousError.spec.ts

@@ -4,7 +4,7 @@ import { SupportCodeBuilder } from './SupportCodeBuilder.js'
 
 describe('SupportCodeBuilder', () => {
   it('catches undefined parameter type errors and emits an appropriate message', () => {
-    const builder = new SupportCodeBuilder()
+    const builder = new SupportCodeBuilder(() => crypto.randomUUID())
     builder.registerStep('a {thing} happens', () => {}, {})
 
     const library = builder.build()
@@ -18,7 +18,7 @@ describe('SupportCodeBuilder', () => {
   })
 
   it('allows other errors from expression compilation to bubble', () => {
-    const builder = new SupportCodeBuilder()
+    const builder = new SupportCodeBuilder(() => crypto.randomUUID())
     // @ts-expect-error passing incorrect type to yield an error
     builder.registerStep(null, () => {}, {})
 

src/runner/AmbiguousError.ts renamed to src/core/AmbiguousError.ts

@@ -6,31 +6,37 @@ import {
 import { SourceReference } from '@cucumber/messages'
 import parse from '@cucumber/tag-expressions'
 
-import { makeId } from '../makeId.js'
-import { HookFunction, HookOptions, ParameterTypeOptions, StepFunction } from '../types.js'
 import {
   DefinedHook,
   DefinedParameterType,
   DefinedStep,
   SupportCodeLibrary,
   UndefinedParameterType,
 } from './SupportCodeLibrary.js'
+import { SupportCodeFunction } from './types.js'
 
-interface RegisteredParameterType extends ParameterTypeOptions {
+interface RegisteredParameterType {
   id: string
+  name: string
+  regexp: RegExp | string | readonly RegExp[] | readonly string[]
+  transformer?: (...match: string[]) => unknown
+  useForSnippets?: boolean
+  preferForRegexpMatch?: boolean
   sourceReference: SourceReference
 }
 
-interface RegisteredHook extends HookOptions {
+interface RegisteredHook {
   id: string
-  fn: HookFunction
+  name?: string
+  tagFilter?: string
+  fn: SupportCodeFunction
   sourceReference: SourceReference
 }
 
 interface RegisteredStep {
   id: string
   text: string
-  fn: StepFunction
+  fn: SupportCodeFunction
   sourceReference: SourceReference
 }
 
@@ -42,53 +48,39 @@ export class SupportCodeBuilder {
   private readonly beforeHooks: Array<RegisteredHook> = []
   private readonly afterHooks: Array<RegisteredHook> = []
 
-  registerParameterType(
-    options: ParameterTypeOptions,
-    sourceReference: SourceReference
-  ): SupportCodeBuilder {
+  constructor(private readonly newId: () => string) {}
+
+  registerParameterType(options: Omit<RegisteredParameterType, 'id'>): SupportCodeBuilder {
     this.parameterTypes.push({
-      id: makeId(),
+      id: this.newId(),
       ...options,
-      sourceReference,
     })
     return this
   }
 
-  registerBeforeHook(
-    options: HookOptions,
-    fn: HookFunction,
-    sourceReference: SourceReference
-  ): SupportCodeBuilder {
+  registerBeforeHook(options: Omit<RegisteredHook, 'id'>): SupportCodeBuilder {
     this.beforeHooks.push({
-      id: makeId(),
+      id: this.newId(),
       ...options,
-      fn,
-      sourceReference,
     })
     return this
   }
 
-  registerAfterHook(
-    options: HookOptions,
-    fn: HookFunction,
-    sourceReference: SourceReference
-  ): SupportCodeBuilder {
+  registerAfterHook(options: Omit<RegisteredHook, 'id'>): SupportCodeBuilder {
     this.afterHooks.push({
-      id: makeId(),
+      id: this.newId(),
       ...options,
-      fn,
-      sourceReference,
     })
     return this
   }
 
   registerStep(
     text: string,
-    fn: StepFunction,
+    fn: SupportCodeFunction,
     sourceReference: SourceReference
   ): SupportCodeBuilder {
     this.steps.push({
-      id: makeId(),
+      id: this.newId(),
       text,
       fn,
       sourceReference,

src/DataTable.spec.ts renamed to src/core/DataTable.spec.ts

@@ -2,7 +2,7 @@ import { Argument, CucumberExpression } from '@cucumber/cucumber-expressions'
 import { Envelope, HookType, SourceReference, StepDefinitionPatternType } from '@cucumber/messages'
 import parse from '@cucumber/tag-expressions'
 
-import { HookFunction, StepFunction } from '../types.js'
+import { SupportCodeFunction } from './types.js'
 
 export type UndefinedParameterType = {
   name: string
@@ -23,15 +23,15 @@ export type DefinedHook = {
   name?: string
   rawTagExpression?: string
   tagExpression?: ReturnType<typeof parse>
-  fn: HookFunction
+  fn: SupportCodeFunction
   sourceReference: SourceReference
 }
 
 export type DefinedStep = {
   id: string
   rawExpression: string
   expression: CucumberExpression
-  fn: StepFunction
+  fn: SupportCodeFunction
   sourceReference: SourceReference
 }
 
@@ -63,7 +63,7 @@ export class SupportCodeLibrary {
     return results
   }
 
-  findAllBeforeHooksBy(tags: ReadonlyArray<string>) {
+  findAllBeforeHooksBy(tags: ReadonlyArray<string>): ReadonlyArray<DefinedHook> {
     return this.beforeHooks.filter((def) => {
       if (def.tagExpression) {
         return def.tagExpression.evaluate(tags as string[])
@@ -72,7 +72,7 @@ export class SupportCodeLibrary {
     })
   }
 
-  findAllAfterHooksBy(tags: ReadonlyArray<string>) {
+  findAllAfterHooksBy(tags: ReadonlyArray<string>): ReadonlyArray<DefinedHook> {
     return this.afterHooks.filter((def) => {
       if (def.tagExpression) {
         return def.tagExpression.evaluate(tags as string[])

src/DataTable.ts renamed to src/core/DataTable.ts

@@ -1,17 +1,15 @@
 import { Group as ExpressionsGroup } from '@cucumber/cucumber-expressions'
 import { Envelope, Group as MessagesGroup, Pickle, TestCase, TestStep } from '@cucumber/messages'
 
-import { DataTable } from '../DataTable.js'
-import { makeId } from '../makeId.js'
-import { StepFunction } from '../types.js'
 import { AmbiguousError } from './AmbiguousError.js'
+import { DataTable } from './DataTable.js'
 import { SupportCodeLibrary } from './SupportCodeLibrary.js'
+import { SupportCodeFunction } from './types.js'
 import { UndefinedError } from './UndefinedError.js'
 
 export type Runnable = {
-  fn: StepFunction
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  args: ReadonlyArray<any>
+  fn: SupportCodeFunction
+  args: ReadonlyArray<unknown>
 }
 
 export interface AssembledTestPlan {
@@ -35,18 +33,19 @@ export interface AssembledStep {
 }
 
 export function makeTestPlan(
+  newId: () => string,
   pickles: ReadonlyArray<Pickle>,
   library: SupportCodeLibrary
 ): AssembledTestPlan {
   return {
     testCases: pickles.map((pickle) => {
       return {
-        id: makeId(),
+        id: newId(),
         name: pickle.name,
         steps: [
-          ...fromBeforeHooks(pickle, library),
-          ...fromPickleSteps(pickle, library),
-          ...fromAfterHooks(pickle, library),
+          ...fromBeforeHooks(newId, pickle, library),
+          ...fromPickleSteps(newId, pickle, library),
+          ...fromAfterHooks(newId, pickle, library),
         ],
         toMessage() {
           return {
@@ -64,12 +63,13 @@ export function makeTestPlan(
 }
 
 function fromBeforeHooks(
+  newId: () => string,
   pickle: Pickle,
   library: SupportCodeLibrary
 ): ReadonlyArray<AssembledStep> {
   return library.findAllBeforeHooksBy(pickle.tags.map((tag) => tag.name)).map((def) => {
     return {
-      id: makeId(),
+      id: newId(),
       name: def.name ?? '',
       always: false,
       prepare() {
@@ -88,13 +88,17 @@ function fromBeforeHooks(
   })
 }
 
-function fromAfterHooks(pickle: Pickle, library: SupportCodeLibrary): ReadonlyArray<AssembledStep> {
+function fromAfterHooks(
+  newId: () => string,
+  pickle: Pickle,
+  library: SupportCodeLibrary
+): ReadonlyArray<AssembledStep> {
   return library
     .findAllAfterHooksBy(pickle.tags.map((tag) => tag.name))
     .toReversed()
     .map((def) => {
       return {
-        id: makeId(),
+        id: newId(),
         name: def.name ?? '',
         always: true,
         prepare() {
@@ -114,13 +118,14 @@ function fromAfterHooks(pickle: Pickle, library: SupportCodeLibrary): ReadonlyAr
 }
 
 function fromPickleSteps(
+  newId: () => string,
   pickle: Pickle,
   library: SupportCodeLibrary
 ): ReadonlyArray<AssembledStep> {
   return pickle.steps.map((pickleStep) => {
     const matched = library.findAllStepsBy(pickleStep.text)
     return {
-      id: makeId(),
+      id: newId(),
       name: pickleStep.text,
       always: false,
       prepare() {

src/runner/SupportCodeBuilder.spec.ts renamed to src/core/SupportCodeBuilder.spec.ts

@@ -0,0 +1,2 @@
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export type SupportCodeFunction = (...args: any[]) => any | Promise<any>