@g_package/jest-cucumber-fusion 3.0.1 → 3.0.3

package/dist/index.cjs

@@ -58,6 +58,22 @@ var asText = (value) => {
   }
 };
 var describeValue = (value) => `${typeof value} ${asText(value)}`;
+var textOf = (value) => {
+  try {
+    return String(value);
+  } catch {
+    return describeValue(value);
+  }
+};
+var describeThrown = (thrown) => {
+  let message;
+  try {
+    message = thrown == null ? void 0 : thrown.message;
+  } catch {
+    return describeValue(thrown);
+  }
+  return textOf(message ? message : thrown);
+};
 
 // src/shared-state.js
 var STORE = /* @__PURE__ */ Symbol.for("@g_package/jest-cucumber-fusion@3");
@@ -9324,9 +9340,13 @@ var parseFeature = (featureText) => {
   try {
     return { document: parser.parse(featureText), ids };
   } catch (parseFailure) {
-    throw new Error(`Error parsing feature Gherkin: ${parseFailure.message}`, {
-      cause: parseFailure
-    });
+    throw new Error(
+      `Error parsing feature Gherkin: ${/** @type {Error} */
+      parseFailure.message}`,
+      {
+        cause: parseFailure
+      }
+    );
   }
 };
 var compilePickles = (document, absoluteFeatureFilePath, ids) => {
@@ -9334,7 +9354,8 @@ var compilePickles = (document, absoluteFeatureFilePath, ids) => {
     return compile(document, absoluteFeatureFilePath, ids);
   } catch (compileFailure) {
     throw new Error(
-      `Error parsing feature Gherkin: ${compileFailure.message}`,
+      `Error parsing feature Gherkin: ${/** @type {Error} */
+      compileFailure.message}`,
       {
         cause: compileFailure
       }
@@ -9575,13 +9596,18 @@ var starterCodeForShape = (steps) => {
 };
 var stepsByShape = (unboundSteps) => {
   const groups = /* @__PURE__ */ new Map();
-  const named = /* @__PURE__ */ new Set();
+  const named = /* @__PURE__ */ new Map();
   unboundSteps.forEach((step) => {
     const identity = `${step.keyword}\0${step.stepText}`;
-    if (named.has(identity)) return;
-    named.add(identity);
     const shape = shapeOf(step);
+    if (named.has(identity)) {
+      const position = named.get(identity);
+      const group = groups.get(shape);
+      if (group[position].stepArgument == null) group[position] = step;
+      return;
+    }
     if (!groups.has(shape)) groups.set(shape, []);
+    named.set(identity, groups.get(shape).length);
     groups.get(shape).push(step);
   });
   return [...groups.values()];
@@ -9644,7 +9670,7 @@ var answerFromTemplate = (loadedFeature, scenario, scenarioNameTemplate) => {
   } catch (templateFailure) {
     throw refuseUnusableName(
       scenario.title,
-      `the scenarioNameTemplate threw: ${templateFailure && templateFailure.message ? templateFailure.message : templateFailure}`,
+      `the scenarioNameTemplate threw: ${describeThrown(templateFailure)}`,
       "make the template total over the four variables it is handed: featureTitle, featureTags, scenarioTitle and scenarioTags. A tag list may be empty, and a title may hold any character a feature file allows."
     );
   }
@@ -9701,7 +9727,13 @@ var namedScenarios = (loadedFeature, scenarios, scenarioNameTemplate) => scenari
     )
   })
 );
-var isError = (value) => Object.prototype.toString.call(value) === "[object Error]";
+var isError = (value) => {
+  try {
+    return Object.prototype.toString.call(value) === "[object Error]";
+  } catch {
+    return false;
+  }
+};
 var decorationOf = (stepText, stepArguments, originalMessage) => `Failing step: "${stepText}"
 
 Step arguments: ${JSON.stringify(stepArguments)}
@@ -9718,13 +9750,13 @@ var decorateInPlace = (failure, decorated) => {
 var decorate = (stepText, stepArguments, failure) => {
   if (!isError(failure))
     return new Error(
-      decorationOf(
-        stepText,
-        stepArguments,
-        failure && failure.message ? failure.message : failure
-      )
+      decorationOf(stepText, stepArguments, describeThrown(failure))
     );
-  const decorated = decorationOf(stepText, stepArguments, failure.message);
+  const decorated = decorationOf(
+    stepText,
+    stepArguments,
+    textOf(failure.message)
+  );
   try {
     return decorateInPlace(failure, decorated);
   } catch {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@g_package/jest-cucumber-fusion",
-  "version": "3.0.1",
+  "version": "3.0.3",
   "description": "Write cucumber test as part of a jest run (including coverage)",
   "type": "module",
   "main": "dist/index.cjs",
@@ -21,12 +21,13 @@
     "coverage": "node --experimental-vm-modules node_modules/jest/bin/jest.js --coverage",
     "lint": "eslint . --max-warnings 0",
     "lint:secrets": "secretlint \"**/*\"",
-    "commit": "git-cz",
+    "commit": "czg",
     "semantic-release": "semantic-release",
     "fmt": "npx prettier --write .",
     "prepare": "node scripts/prepare-hooks.js",
     "build": "node scripts/build-cjs.js",
-    "prepack": "npm run build"
+    "prepack": "npm run build",
+    "typecheck": "tsc -p jsconfig.json"
   },
   "repository": {
     "type": "git",
@@ -47,10 +48,12 @@
   "devDependencies": {
     "@commitlint/cli": "^21.2.3",
     "@commitlint/config-conventional": "^21.2.3",
-    "@eslint/js": "^9.39.5",
+    "@eslint/js": "^10.0.1",
     "@secretlint/secretlint-rule-pattern": "^13.0.7",
     "@secretlint/secretlint-rule-preset-recommend": "^13.0.7",
-    "cz-conventional-changelog": "^3.3.0",
+    "@types/jest": "^30.0.0",
+    "@types/node": "^18.19.130",
+    "czg": "1.14.0",
     "esbuild": "0.28.2",
     "eslint": "^10.12.0",
     "eslint-plugin-jest": "^29.16.6",
@@ -62,16 +65,12 @@
     "prettier": "3.9.9",
     "secretlint": "^13.0.7",
     "semantic-release": "^25.0.5",
-    "tsd": "^0.33.0"
+    "tsd": "^0.33.0",
+    "typescript": "^6.0.3"
   },
   "publishConfig": {
     "access": "public"
   },
-  "config": {
-    "commitizen": {
-      "path": "./node_modules/cz-conventional-changelog"
-    }
-  },
   "release": {
     "plugins": [
       "@semantic-release/commit-analyzer",

package/src/code-suggestion.js

@@ -177,15 +177,24 @@ const starterCodeForShape = (steps) => {
 // are equal, and as ambiguous when one is wider ("(\d+)" beside a decimal capture both match
 // "1"). A step with a table and the same step without one share a shape too; parameters do not
 // make two definitions distinct.
+//
+// A step named once still counts every time it appears: when only a later appearance carries
+// a Gherkin argument, that appearance stands in for the step, so the starter code has the
+// parameter the step will receive. The text is the same, so the entry reads the same.
 const stepsByShape = (unboundSteps) => {
   const groups = new Map();
-  const named = new Set();
+  const named = new Map();
   unboundSteps.forEach((step) => {
     const identity = `${step.keyword}\u0000${step.stepText}`;
-    if (named.has(identity)) return;
-    named.add(identity);
     const shape = shapeOf(step);
+    if (named.has(identity)) {
+      const position = named.get(identity);
+      const group = groups.get(shape);
+      if (group[position].stepArgument == null) group[position] = step;
+      return;
+    }
     if (!groups.has(shape)) groups.set(shape, []);
+    named.set(identity, groups.get(shape).length);
     groups.get(shape).push(step);
   });
   return [...groups.values()];

package/src/feature-source.js

@@ -95,9 +95,15 @@ const parseFeature = (featureText) => {
   try {
     return { document: parser.parse(featureText), ids };
   } catch (parseFailure) {
-    throw new Error(`Error parsing feature Gherkin: ${parseFailure.message}`, {
-      cause: parseFailure,
-    });
+    // @cucumber/gherkin throws Errors only: plain ones, or its own exceptions, which all
+    // extend Error (dist/Errors.js). The cast states that contract for the type check rather
+    // than adding a branch for a non-Error that Gherkin never throws.
+    throw new Error(
+      `Error parsing feature Gherkin: ${/** @type {Error} */ (parseFailure).message}`,
+      {
+        cause: parseFailure,
+      },
+    );
   }
 };
 
@@ -105,8 +111,9 @@ const compilePickles = (document, absoluteFeatureFilePath, ids) => {
   try {
     return gherkin.compile(document, absoluteFeatureFilePath, ids);
   } catch (compileFailure) {
+    // Errors only, as for the parse above.
     throw new Error(
-      `Error parsing feature Gherkin: ${compileFailure.message}`,
+      `Error parsing feature Gherkin: ${/** @type {Error} */ (compileFailure).message}`,
       {
         cause: compileFailure,
       },

package/src/scenario-name.js

@@ -11,7 +11,7 @@
 //
 // Pure: no filesystem, no parser, no Jest global. The port calls it; it calls the template.
 
-import { describeValue } from "./value-description.js";
+import { describeThrown, describeValue } from "./value-description.js";
 
 // Kept as the first line of the refusal because the previous engine used it, so anything a
 // consumer greps for still matches.
@@ -73,13 +73,10 @@ const answerFromTemplate = (loadedFeature, scenario, scenarioNameTemplate) => {
   try {
     return scenarioNameTemplate(templateVariablesFor(loadedFeature, scenario));
   } catch (templateFailure) {
+    // A consumer's template can throw anything; describeThrown quotes anything.
     throw refuseUnusableName(
       scenario.title,
-      `the scenarioNameTemplate threw: ${
-        templateFailure && templateFailure.message
-          ? templateFailure.message
-          : templateFailure
-      }`,
+      `the scenarioNameTemplate threw: ${describeThrown(templateFailure)}`,
       "make the template total over the four variables it is handed: featureTitle, " +
         "featureTags, scenarioTitle and scenarioTags. A tag list may be empty, and a title " +
         "may hold any character a feature file allows.",

package/src/test-registration.js

@@ -10,6 +10,7 @@
 import { findMatchingStep } from "./step-matching.js";
 import { unmatchedStepRefusal } from "./code-suggestion.js";
 import { nameForScenario } from "./scenario-name.js";
+import { describeThrown, textOf } from "./value-description.js";
 
 // BIND BEFORE REGISTERING. Every step of every scenario is matched up front, so a refusal
 // (an unmatched step, an ambiguous one, an unsupported keyword) leaves Fusion() on the way
@@ -70,8 +71,15 @@ const namedScenarios = (loadedFeature, scenarios, scenarioNameTemplate) =>
 // match. Recognised by its tag rather than instanceof, which fails for an error made in another
 // realm (Node's own, from inside Jest's test context). Anything that cannot be rewritten (a
 // frozen error) is wrapped with the original as its cause; anything else thrown is wrapped.
-const isError = (value) =>
-  Object.prototype.toString.call(value) === "[object Error]";
+// Reading the tag can itself throw, for a Proxy whose traps throw or one that was revoked; such
+// a value is no Error, so it is wrapped like any other.
+const isError = (value) => {
+  try {
+    return Object.prototype.toString.call(value) === "[object Error]";
+  } catch {
+    return false;
+  }
+};
 
 const decorationOf = (stepText, stepArguments, originalMessage) =>
   `Failing step: "${stepText}"\n\n` +
@@ -90,13 +98,13 @@ const decorateInPlace = (failure, decorated) => {
 const decorate = (stepText, stepArguments, failure) => {
   if (!isError(failure))
     return new Error(
-      decorationOf(
-        stepText,
-        stepArguments,
-        failure && failure.message ? failure.message : failure,
-      ),
+      decorationOf(stepText, stepArguments, describeThrown(failure)),
     );
-  const decorated = decorationOf(stepText, stepArguments, failure.message);
+  const decorated = decorationOf(
+    stepText,
+    stepArguments,
+    textOf(failure.message),
+  );
   try {
     return decorateInPlace(failure, decorated);
   } catch {

package/src/value-description.js

@@ -23,4 +23,32 @@ const asText = (value) => {
 
 const describeValue = (value) => `${typeof value} ${asText(value)}`;
 
-export { describeValue };
+// How a report quotes what the consumer's code threw: its message when that is truthy,
+// otherwise the value itself, as text. textOf is the text step alone, for a value already known
+// to be the message.
+//
+// A template literal cannot make text of a Symbol, of an object with no prototype, or of an
+// object whose message getter or toString throws, so quoting those crashed the report and the
+// consumer saw a TypeError instead of their own failure (the PR #36 fuzz run). String() makes
+// the same text as a template literal for everything else and accepts a Symbol; anything still
+// unprintable is named as describeValue names it. The message is read once, so a getter that
+// answers differently each time cannot be quoted as one thing and checked as another.
+const textOf = (value) => {
+  try {
+    return String(value);
+  } catch {
+    return describeValue(value);
+  }
+};
+
+const describeThrown = (thrown) => {
+  let message;
+  try {
+    message = thrown == null ? undefined : thrown.message;
+  } catch {
+    return describeValue(thrown);
+  }
+  return textOf(message ? message : thrown);
+};
+
+export { describeThrown, describeValue, textOf };