@autometa/cucumber-expressions 0.0.0

package/.eslintignore

@@ -0,0 +1,3 @@
+/dist
+/out
+node_modules

package/.eslintrc.cjs

@@ -0,0 +1,4 @@
+module.exports = {
+  root: true,
+  extends: ["custom"],
+};

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) undefined Ben Aherne
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,3 @@
+# Introduction
+
+There's nothing here yet

package/dist/esm/index.js

@@ -0,0 +1,432 @@
+var __accessCheck = (obj, member, msg) => {
+  if (!member.has(obj))
+    throw TypeError("Cannot " + msg);
+};
+var __privateGet = (obj, member, getter) => {
+  __accessCheck(obj, member, "read from private field");
+  return getter ? getter.call(obj) : member.get(obj);
+};
+var __privateAdd = (obj, member, value) => {
+  if (member.has(obj))
+    throw TypeError("Cannot add the same private member more than once");
+  member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+};
+
+// src/step-matcher.ts
+import { diffWordsWithSpace } from "diff";
+import { distance } from "closest-match";
+import { AssertKey } from "@autometa/asserters";
+function checkMatch(text, it) {
+  return it.matches(text);
+}
+function limitDiffs(sameStepType, differentStepType, max) {
+  const sameDistances = sameStepType.map((it) => it.distance);
+  const maxSameStepDistance = Math.max(...sameDistances);
+  const otherStepDistance = differentStepType.map((it) => it.distance);
+  const minDifferentStepDistance = Math.min(...otherStepDistance);
+  if (maxSameStepDistance > minDifferentStepDistance) {
+    const filter = sameStepType.filter(
+      (it) => it.distance <= minDifferentStepDistance
+    );
+    if (filter.length >= max) {
+      return { same: filter.slice(0, max), other: [] };
+    }
+    const diff = max - filter.length;
+    const sameSlice = sameStepType.slice(0, diff);
+    const differentSlice = differentStepType.slice(0, max - diff);
+    return { same: sameSlice, other: differentSlice };
+  }
+  const maxIndex = Math.min(max, sameStepType.length);
+  const result = { same: sameStepType.slice(0, maxIndex), other: [] };
+  return result;
+}
+function getDiffs(text, maxResults, step) {
+  const sorted = step.map((it) => {
+    if (checkMatch(text, it)) {
+      return { merged: text, step: it, gherkin: text, distance: 0 };
+    }
+    AssertKey(it, "expression");
+    AssertKey(it, "matches");
+    const diff = getDiff(text, it);
+    const refined = refineDiff(diff);
+    const dist = distance(text, refined);
+    return { merged: refined, step: it, gherkin: text, distance: dist };
+  }).sort((a, b) => a.distance - b.distance);
+  const max = Math.min(maxResults, sorted.length);
+  return sorted.slice(0, max);
+}
+function getDiff(text, it) {
+  return diffWordsWithSpace(text, it.expression.source);
+}
+function refineDiff(diff) {
+  const strings = [];
+  for (let index = 0; index < diff.length; index++) {
+    const gherkinChange = diff[index];
+    const scopeChange = diff[index + 1];
+    if (isExpressionCandidate(gherkinChange, scopeChange)) {
+      strings.push(gherkinChange.value);
+      index++;
+      continue;
+    }
+    if (gherkinChange.value) {
+      strings.push(gherkinChange.value);
+      continue;
+    }
+  }
+  return strings.join("");
+}
+function isExpressionCandidate(change1, change2) {
+  if (change1.removed && change2.added) {
+    const scopeText = change2.value;
+    return /{.*}/.test(scopeText);
+  }
+  return false;
+}
+
+// src/search-report.ts
+import chalk from "chalk";
+var SameStepTypeMatch = class {
+  constructor(diff) {
+    this.keyword = diff.step.keyword;
+    this.text = diff.merged;
+    this.distance = diff.distance;
+  }
+  toString() {
+    const keyword = chalk.green(this.keyword);
+    const text = chalk.whiteBright(this.text);
+    const distance2 = chalk.blue(`[${this.distance}]`);
+    return `${distance2} ${keyword} ${text}`;
+  }
+};
+var DifferentStepTypeMatch = class {
+  constructor(diff) {
+    this.keyword = diff.step.keyword;
+    this.text = diff.merged;
+    this.distance = diff.distance;
+  }
+  toString() {
+    const keywordColor = chalk.ansi256(208);
+    const keyword = keywordColor(this.keyword);
+    const text = chalk.whiteBright(this.text);
+    const distance2 = chalk.blue(`[${this.distance}]`);
+    return `${distance2} ${keyword} ${text}`;
+  }
+};
+var _sameMatchTypes, sameMatchTypes_get, _differentMatchTypes, differentMatchTypes_get;
+var FuzzySearchReport = class {
+  constructor() {
+    __privateAdd(this, _sameMatchTypes);
+    __privateAdd(this, _differentMatchTypes);
+    this.matches = [];
+    this.children = [];
+  }
+  get length() {
+    return this.matches.length + this.children.length;
+  }
+  addHeading(headingText) {
+    this.headingText = headingText;
+    return this;
+  }
+  addMatch(match) {
+    this.matches.push(match);
+    return this;
+  }
+  addChild(child) {
+    this.children.push(child);
+    return this;
+  }
+  toString() {
+    const same = __privateGet(this, _sameMatchTypes, sameMatchTypes_get).map((it) => it.toString()).join("\n");
+    const sameMessage = same.length > 0 ? `Steps with matching step type:` : "";
+    const different = __privateGet(this, _differentMatchTypes, differentMatchTypes_get).map((it) => it.toString()).join("\n");
+    const differentMessage = different.length > 0 ? `Steps with different step type:` : "";
+    const messageArray = [];
+    appendSubMessage(messageArray, sameMessage);
+    appendSubMessage(messageArray, same, TAB);
+    appendSubMessage(messageArray, differentMessage);
+    appendSubMessage(messageArray, different, TAB);
+    const children = [];
+    this.children.forEach((child) => {
+      appendChild(children, child);
+    });
+    const formatChildren = children.map((it) => it.toString().replace(/^/gm, " ")).join("\n");
+    const message = messageArray.join(`
+${TAB}`);
+    const heading = chalk.bgBlackBright(this.headingText);
+    return `${heading}
+${TAB}${message}
+${formatChildren}`;
+  }
+};
+_sameMatchTypes = new WeakSet();
+sameMatchTypes_get = function() {
+  return this.matches.filter(
+    (it) => it instanceof SameStepTypeMatch
+  );
+};
+_differentMatchTypes = new WeakSet();
+differentMatchTypes_get = function() {
+  return this.matches.filter(
+    (it) => it instanceof DifferentStepTypeMatch
+  );
+};
+function appendSubMessage(arr, message, prefix) {
+  if (message && message.length > 0) {
+    const str = prefix ? `${prefix}${message}` : message;
+    arr.push(str);
+  }
+}
+function appendChild(arr, message) {
+  if (message) {
+    arr.push(message);
+  }
+}
+var SPACE = " ";
+var TAB = SPACE.repeat(2);
+function buildFuzzySearchReport({ same, other }) {
+  const report = new FuzzySearchReport();
+  same.forEach((diff) => {
+    report.addMatch(new SameStepTypeMatch(diff));
+  });
+  other.forEach((diff) => {
+    report.addMatch(new DifferentStepTypeMatch(diff));
+  });
+  return report;
+}
+
+// src/parameters.ts
+import {
+  Argument,
+  ParameterType
+} from "@cucumber/cucumber-expressions";
+import {
+  def,
+  func,
+  instance,
+  overloads,
+  string,
+  nil,
+  array
+} from "@autometa/overloaded";
+Argument.prototype.getValue = function(thisObj) {
+  const groupValues = this.group ? this.group.value ? [this.group.value] : this.group.values : null;
+  return this.parameterType.transform(thisObj, groupValues);
+};
+var regexp = instance(RegExp).or(array([instance(RegExp)]));
+function defineParameterType(registry, ...params) {
+  params.forEach((param) => {
+    const { name, regexpPattern, transform, type, primitive } = param;
+    return registerParameterType(
+      registry,
+      name,
+      regexpPattern,
+      transform,
+      type,
+      primitive
+    );
+  });
+}
+function registerParameterType(registry, name, regexpPattern, transform, type, primitive) {
+  return overloads(
+    def(
+      string(),
+      regexp,
+      func("type"),
+      func("transform"),
+      func("primitive")
+    ).matches((name2, regexp2, type2, transform2, primitive2) => {
+      const primitivePrototype = primitive2;
+      const typePrototype = type2;
+      const wrapper = (val) => {
+        const asPrimitive = primitivePrototype(val);
+        const asType = new typePrototype(asPrimitive);
+        return transform2(asType);
+      };
+      const param = new ParameterType(name2, regexp2, type2, wrapper);
+      registry.defineParameterType(param);
+    }),
+    def`allTransforms`(
+      string(),
+      instance(RegExp),
+      func("type"),
+      func("transform"),
+      nil("primitive")
+    ).matches((name2, regexp2, type2, transform2) => {
+      const typePrototype = type2;
+      const wrapper = (val) => {
+        const asType = new typePrototype(val);
+        return transform2(asType);
+      };
+      const param = new ParameterType(name2, regexp2, type2, wrapper);
+      registry.defineParameterType(param);
+    }),
+    def`transformPrimitive`(
+      string(),
+      instance(RegExp),
+      nil("type"),
+      func("transform"),
+      func("primitive")
+    ).matches((name2, regexp2, _, transform2, primitive2) => {
+      const primitivePrototype = primitive2;
+      const wrapper = (val) => {
+        const asPrimitive = primitivePrototype(val);
+        return transform2(asPrimitive);
+      };
+      const param = new ParameterType(name2, regexp2, primitive2, wrapper);
+      registry.defineParameterType(param);
+    }),
+    def`encapuslatePrimitive`(
+      string(),
+      instance(RegExp),
+      func("type"),
+      nil("transform"),
+      func("primitive")
+    ).matches((name2, regexp2, type2, _, primitive2) => {
+      const primitivePrototype = primitive2;
+      const typePrototype = type2;
+      const wrapper = (val) => {
+        const asPrimitive = primitivePrototype(val);
+        return new typePrototype(asPrimitive);
+      };
+      const param = new ParameterType(name2, regexp2, type2, wrapper);
+      registry.defineParameterType(param);
+    }),
+    def`makeType`(
+      string(),
+      instance(RegExp),
+      func("type"),
+      nil(),
+      nil()
+    ).matches((name2, pattern, type2) => {
+      const prototype = type2;
+      const transform2 = (val) => new prototype(val);
+      const param = new ParameterType(name2, pattern, null, transform2);
+      registry.defineParameterType(param);
+    }),
+    def`makePrimitive`(
+      string(),
+      instance(RegExp),
+      nil(),
+      nil(),
+      func("primitive")
+    ).matches((name2, pattern, _, __, primitive2) => {
+      const prototype = primitive2;
+      const transform2 = (val) => prototype(val);
+      const param = new ParameterType(name2, pattern, null, transform2);
+      registry.defineParameterType(param);
+    }),
+    def`transformValue`(
+      string(),
+      instance(RegExp),
+      nil(),
+      func("transform"),
+      nil()
+    ).matches((name2, pattern, _, transform2, __) => {
+      const param = new ParameterType(name2, pattern, null, transform2);
+      registry.defineParameterType(param);
+    }),
+    def`default`(string(), instance(RegExp), nil(), nil(), nil()).matches(
+      (name2, pattern, _, __, ___) => {
+        const transform2 = (val) => val;
+        const param = new ParameterType(name2, pattern, null, transform2);
+        registry.defineParameterType(param);
+      }
+    )
+  ).use([name, regexpPattern, type, transform, primitive]);
+}
+
+// src/default.parameters.ts
+import { def as def2, fallback, overloads as overloads2, string as string2 } from "@autometa/overloaded";
+import { Dates } from "@autometa/datetime";
+import { AssertIs } from "@autometa/asserters";
+import { DateTime } from "luxon";
+var strNum = /['"]-?\d+['"]/;
+var isodateRegexp = /(\d{4}-[01]\d-[0-3]\dT[0-2]\d:[0-5]\d:[0-5]\d\.\d+([+-][0-2]\d:[0-5]\d|Z))|(\d{4}-[01]\d-[0-3]\dT[0-2]\d:[0-5]\d:[0-5]\d([+-][0-2]\d:[0-5]\d|Z))|(\d{4}-[01]\d-[0-3]\dT[0-2]\d:[0-5]\d([+-][0-2]\d:[0-5]\d|Z))/;
+var shortDateRegex = /(\d{4}-[01]\d-[0-3]\dT[0-2]\d:[0-5]\d:[0-5]\d\.\d+([+-][0-2]\d:[0-5]\d|Z))|(\d{4}-[01]\d-[0-3]\dT[0-2]\d:[0-5]\d:[0-5]\d([+-][0-2]\d:[0-5]\d|Z))|(\d{4}-[01]\d-[0-3]\d)/;
+var boolTypesActive = ["active", "inactive"];
+var boolTypesEnabled = ["enabled", "disabled"];
+var boolTypes = ["true", "false"];
+var NumberParam = {
+  name: "number",
+  regexpPattern: /\d+/,
+  primitive: Number
+};
+var BooleanParam = {
+  name: "boolean",
+  regexpPattern: /true|false/,
+  primitive: Boolean
+};
+var PrimitiveParam = {
+  name: "primitive",
+  regexpPattern: [
+    /true|false/,
+    /enabled|disabled/,
+    /active|inactive/,
+    /null/,
+    /empty/,
+    /undefined/,
+    /NaN/,
+    /Infinity/,
+    /-Infinity/,
+    isodateRegexp,
+    shortDateRegex,
+    /-?\d+/,
+    /"([^"]*)"/,
+    /'([^']*)'/
+  ],
+  transform: (value) => {
+    return overloads2(
+      def2(string2({ equals: "null" })).matches((_) => null),
+      def2(string2({ equals: "undefined" })).matches((_) => void 0),
+      def2(string2({ in: boolTypes })).matches((val) => Boolean(val)),
+      def2(string2({ equals: "NaN" })).matches((_) => NaN),
+      def2(string2({ equals: "Infinity" })).matches((_) => Infinity),
+      def2(string2({ equals: "-Infinity" })).matches((_) => -Infinity),
+      def2(string2({ pattern: isodateRegexp })).matches(parseIso),
+      def2(string2({ pattern: shortDateRegex })).matches(parseDate),
+      def2(string2({ pattern: strNum })).matches(trimQuotes),
+      def2(string2({ pattern: /-?\d+/ })).matches((val) => Number(val)),
+      def2(string2({ in: boolTypesEnabled })).matches(boolEnabled),
+      def2(string2({ in: boolTypesActive })).matches(boolActive),
+      fallback((val) => {
+        AssertIs(val, "string");
+        const fromPhrase = Dates.fromPhrase(val);
+        if (fromPhrase && !isNaN(fromPhrase.getTime())) {
+          return fromPhrase;
+        }
+        return val;
+      })
+    ).use([value]);
+  }
+};
+function boolActive(val) {
+  return val === "active";
+}
+function boolEnabled(val) {
+  return val === "enabled";
+}
+function parseDate(val) {
+  return new Date(Date.parse(val));
+}
+function trimQuotes(val) {
+  return val.slice(1, -1);
+}
+function parseIso(val) {
+  return DateTime.fromISO(val).toJSDate();
+}
+export {
+  BooleanParam,
+  DifferentStepTypeMatch,
+  FuzzySearchReport,
+  NumberParam,
+  PrimitiveParam,
+  SameStepTypeMatch,
+  buildFuzzySearchReport,
+  checkMatch,
+  defineParameterType,
+  getDiff,
+  getDiffs,
+  isExpressionCandidate,
+  limitDiffs,
+  refineDiff
+};

package/dist/index.d.ts

@@ -0,0 +1,83 @@
+import { Change } from 'diff';
+import { Expression, ParameterTypeRegistry } from '@cucumber/cucumber-expressions';
+import { StepType, StepKeyword, Class } from '@autometa/types';
+
+interface Matchable {
+    matches(text: string): boolean;
+}
+interface ExpressionWrapper {
+    expression: Expression;
+}
+interface GherkinKeyword {
+    type: StepType;
+}
+type StepDiff = {
+    merged: string;
+    step: {
+        keyword: StepKeyword;
+        expression: Expression;
+        type: StepType;
+        matches: (text: string) => boolean;
+    };
+    gherkin: string;
+    distance: number;
+};
+type StepDiffs = StepDiff[];
+type LimitedStepDiffs = {
+    same: StepDiffs;
+    other: StepDiffs;
+};
+declare function checkMatch<T extends Matchable>(text: string, it: T): boolean;
+declare function limitDiffs(sameStepType: StepDiff[], differentStepType: StepDiff[], max: number): LimitedStepDiffs;
+declare function getDiffs<T extends Matchable & ExpressionWrapper>(text: string, maxResults: number, step: T[]): {
+    merged: string;
+    step: T;
+    gherkin: string;
+    distance: number;
+}[];
+declare function getDiff<T extends ExpressionWrapper>(text: string, it: T): Change[];
+declare function refineDiff(diff: Change[]): string;
+declare function isExpressionCandidate(change1: Change, change2: Change): boolean;
+
+declare class SameStepTypeMatch {
+    readonly keyword: string;
+    readonly text: string;
+    readonly distance: number;
+    constructor(diff: StepDiff);
+    toString(): string;
+}
+declare class DifferentStepTypeMatch {
+    readonly keyword: string;
+    readonly text: string;
+    readonly distance: number;
+    constructor(diff: StepDiff);
+    toString(): string;
+}
+declare class FuzzySearchReport {
+    #private;
+    headingText: string;
+    matches: (SameStepTypeMatch | DifferentStepTypeMatch)[];
+    children: FuzzySearchReport[];
+    get length(): number;
+    addHeading(headingText: string): this;
+    addMatch(match: SameStepTypeMatch | DifferentStepTypeMatch): this;
+    addChild(child: FuzzySearchReport): this;
+    toString(): string;
+}
+declare function buildFuzzySearchReport({ same, other }: LimitedStepDiffs): FuzzySearchReport;
+
+type ParamTypeDefinition = {
+    name: string;
+    regexpPattern: RegExp | RegExp[];
+    transform?: (value: unknown) => unknown;
+    type?: Class<unknown>;
+    primitive?: typeof String | typeof Number | typeof Boolean | typeof BigInt;
+};
+declare function defineParameterType<T extends ParamTypeDefinition[]>(registry: ParameterTypeRegistry, ...params: T): void;
+
+type AutoParamTypeDefinition = Omit<ParamTypeDefinition, "transform">;
+declare const NumberParam: AutoParamTypeDefinition;
+declare const BooleanParam: AutoParamTypeDefinition;
+declare const PrimitiveParam: ParamTypeDefinition;
+
+export { BooleanParam, DifferentStepTypeMatch, ExpressionWrapper, FuzzySearchReport, GherkinKeyword, LimitedStepDiffs, Matchable, NumberParam, ParamTypeDefinition, PrimitiveParam, SameStepTypeMatch, StepDiff, StepDiffs, buildFuzzySearchReport, checkMatch, defineParameterType, getDiff, getDiffs, isExpressionCandidate, limitDiffs, refineDiff };

package/dist/index.js

@@ -0,0 +1,470 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __accessCheck = (obj, member, msg) => {
+  if (!member.has(obj))
+    throw TypeError("Cannot " + msg);
+};
+var __privateGet = (obj, member, getter) => {
+  __accessCheck(obj, member, "read from private field");
+  return getter ? getter.call(obj) : member.get(obj);
+};
+var __privateAdd = (obj, member, value) => {
+  if (member.has(obj))
+    throw TypeError("Cannot add the same private member more than once");
+  member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+};
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  BooleanParam: () => BooleanParam,
+  DifferentStepTypeMatch: () => DifferentStepTypeMatch,
+  FuzzySearchReport: () => FuzzySearchReport,
+  NumberParam: () => NumberParam,
+  PrimitiveParam: () => PrimitiveParam,
+  SameStepTypeMatch: () => SameStepTypeMatch,
+  buildFuzzySearchReport: () => buildFuzzySearchReport,
+  checkMatch: () => checkMatch,
+  defineParameterType: () => defineParameterType,
+  getDiff: () => getDiff,
+  getDiffs: () => getDiffs,
+  isExpressionCandidate: () => isExpressionCandidate,
+  limitDiffs: () => limitDiffs,
+  refineDiff: () => refineDiff
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/step-matcher.ts
+var import_diff = require("diff");
+var import_closest_match = require("closest-match");
+var import_asserters = require("@autometa/asserters");
+function checkMatch(text, it) {
+  return it.matches(text);
+}
+function limitDiffs(sameStepType, differentStepType, max) {
+  const sameDistances = sameStepType.map((it) => it.distance);
+  const maxSameStepDistance = Math.max(...sameDistances);
+  const otherStepDistance = differentStepType.map((it) => it.distance);
+  const minDifferentStepDistance = Math.min(...otherStepDistance);
+  if (maxSameStepDistance > minDifferentStepDistance) {
+    const filter = sameStepType.filter(
+      (it) => it.distance <= minDifferentStepDistance
+    );
+    if (filter.length >= max) {
+      return { same: filter.slice(0, max), other: [] };
+    }
+    const diff = max - filter.length;
+    const sameSlice = sameStepType.slice(0, diff);
+    const differentSlice = differentStepType.slice(0, max - diff);
+    return { same: sameSlice, other: differentSlice };
+  }
+  const maxIndex = Math.min(max, sameStepType.length);
+  const result = { same: sameStepType.slice(0, maxIndex), other: [] };
+  return result;
+}
+function getDiffs(text, maxResults, step) {
+  const sorted = step.map((it) => {
+    if (checkMatch(text, it)) {
+      return { merged: text, step: it, gherkin: text, distance: 0 };
+    }
+    (0, import_asserters.AssertKey)(it, "expression");
+    (0, import_asserters.AssertKey)(it, "matches");
+    const diff = getDiff(text, it);
+    const refined = refineDiff(diff);
+    const dist = (0, import_closest_match.distance)(text, refined);
+    return { merged: refined, step: it, gherkin: text, distance: dist };
+  }).sort((a, b) => a.distance - b.distance);
+  const max = Math.min(maxResults, sorted.length);
+  return sorted.slice(0, max);
+}
+function getDiff(text, it) {
+  return (0, import_diff.diffWordsWithSpace)(text, it.expression.source);
+}
+function refineDiff(diff) {
+  const strings = [];
+  for (let index = 0; index < diff.length; index++) {
+    const gherkinChange = diff[index];
+    const scopeChange = diff[index + 1];
+    if (isExpressionCandidate(gherkinChange, scopeChange)) {
+      strings.push(gherkinChange.value);
+      index++;
+      continue;
+    }
+    if (gherkinChange.value) {
+      strings.push(gherkinChange.value);
+      continue;
+    }
+  }
+  return strings.join("");
+}
+function isExpressionCandidate(change1, change2) {
+  if (change1.removed && change2.added) {
+    const scopeText = change2.value;
+    return /{.*}/.test(scopeText);
+  }
+  return false;
+}
+
+// src/search-report.ts
+var import_chalk = __toESM(require("chalk"), 1);
+var SameStepTypeMatch = class {
+  constructor(diff) {
+    this.keyword = diff.step.keyword;
+    this.text = diff.merged;
+    this.distance = diff.distance;
+  }
+  toString() {
+    const keyword = import_chalk.default.green(this.keyword);
+    const text = import_chalk.default.whiteBright(this.text);
+    const distance2 = import_chalk.default.blue(`[${this.distance}]`);
+    return `${distance2} ${keyword} ${text}`;
+  }
+};
+var DifferentStepTypeMatch = class {
+  constructor(diff) {
+    this.keyword = diff.step.keyword;
+    this.text = diff.merged;
+    this.distance = diff.distance;
+  }
+  toString() {
+    const keywordColor = import_chalk.default.ansi256(208);
+    const keyword = keywordColor(this.keyword);
+    const text = import_chalk.default.whiteBright(this.text);
+    const distance2 = import_chalk.default.blue(`[${this.distance}]`);
+    return `${distance2} ${keyword} ${text}`;
+  }
+};
+var _sameMatchTypes, sameMatchTypes_get, _differentMatchTypes, differentMatchTypes_get;
+var FuzzySearchReport = class {
+  constructor() {
+    __privateAdd(this, _sameMatchTypes);
+    __privateAdd(this, _differentMatchTypes);
+    this.matches = [];
+    this.children = [];
+  }
+  get length() {
+    return this.matches.length + this.children.length;
+  }
+  addHeading(headingText) {
+    this.headingText = headingText;
+    return this;
+  }
+  addMatch(match) {
+    this.matches.push(match);
+    return this;
+  }
+  addChild(child) {
+    this.children.push(child);
+    return this;
+  }
+  toString() {
+    const same = __privateGet(this, _sameMatchTypes, sameMatchTypes_get).map((it) => it.toString()).join("\n");
+    const sameMessage = same.length > 0 ? `Steps with matching step type:` : "";
+    const different = __privateGet(this, _differentMatchTypes, differentMatchTypes_get).map((it) => it.toString()).join("\n");
+    const differentMessage = different.length > 0 ? `Steps with different step type:` : "";
+    const messageArray = [];
+    appendSubMessage(messageArray, sameMessage);
+    appendSubMessage(messageArray, same, TAB);
+    appendSubMessage(messageArray, differentMessage);
+    appendSubMessage(messageArray, different, TAB);
+    const children = [];
+    this.children.forEach((child) => {
+      appendChild(children, child);
+    });
+    const formatChildren = children.map((it) => it.toString().replace(/^/gm, " ")).join("\n");
+    const message = messageArray.join(`
+${TAB}`);
+    const heading = import_chalk.default.bgBlackBright(this.headingText);
+    return `${heading}
+${TAB}${message}
+${formatChildren}`;
+  }
+};
+_sameMatchTypes = new WeakSet();
+sameMatchTypes_get = function() {
+  return this.matches.filter(
+    (it) => it instanceof SameStepTypeMatch
+  );
+};
+_differentMatchTypes = new WeakSet();
+differentMatchTypes_get = function() {
+  return this.matches.filter(
+    (it) => it instanceof DifferentStepTypeMatch
+  );
+};
+function appendSubMessage(arr, message, prefix) {
+  if (message && message.length > 0) {
+    const str = prefix ? `${prefix}${message}` : message;
+    arr.push(str);
+  }
+}
+function appendChild(arr, message) {
+  if (message) {
+    arr.push(message);
+  }
+}
+var SPACE = " ";
+var TAB = SPACE.repeat(2);
+function buildFuzzySearchReport({ same, other }) {
+  const report = new FuzzySearchReport();
+  same.forEach((diff) => {
+    report.addMatch(new SameStepTypeMatch(diff));
+  });
+  other.forEach((diff) => {
+    report.addMatch(new DifferentStepTypeMatch(diff));
+  });
+  return report;
+}
+
+// src/parameters.ts
+var import_cucumber_expressions = require("@cucumber/cucumber-expressions");
+var import_overloaded = require("@autometa/overloaded");
+import_cucumber_expressions.Argument.prototype.getValue = function(thisObj) {
+  const groupValues = this.group ? this.group.value ? [this.group.value] : this.group.values : null;
+  return this.parameterType.transform(thisObj, groupValues);
+};
+var regexp = (0, import_overloaded.instance)(RegExp).or((0, import_overloaded.array)([(0, import_overloaded.instance)(RegExp)]));
+function defineParameterType(registry, ...params) {
+  params.forEach((param) => {
+    const { name, regexpPattern, transform, type, primitive } = param;
+    return registerParameterType(
+      registry,
+      name,
+      regexpPattern,
+      transform,
+      type,
+      primitive
+    );
+  });
+}
+function registerParameterType(registry, name, regexpPattern, transform, type, primitive) {
+  return (0, import_overloaded.overloads)(
+    (0, import_overloaded.def)(
+      (0, import_overloaded.string)(),
+      regexp,
+      (0, import_overloaded.func)("type"),
+      (0, import_overloaded.func)("transform"),
+      (0, import_overloaded.func)("primitive")
+    ).matches((name2, regexp2, type2, transform2, primitive2) => {
+      const primitivePrototype = primitive2;
+      const typePrototype = type2;
+      const wrapper = (val) => {
+        const asPrimitive = primitivePrototype(val);
+        const asType = new typePrototype(asPrimitive);
+        return transform2(asType);
+      };
+      const param = new import_cucumber_expressions.ParameterType(name2, regexp2, type2, wrapper);
+      registry.defineParameterType(param);
+    }),
+    import_overloaded.def`allTransforms`(
+      (0, import_overloaded.string)(),
+      (0, import_overloaded.instance)(RegExp),
+      (0, import_overloaded.func)("type"),
+      (0, import_overloaded.func)("transform"),
+      (0, import_overloaded.nil)("primitive")
+    ).matches((name2, regexp2, type2, transform2) => {
+      const typePrototype = type2;
+      const wrapper = (val) => {
+        const asType = new typePrototype(val);
+        return transform2(asType);
+      };
+      const param = new import_cucumber_expressions.ParameterType(name2, regexp2, type2, wrapper);
+      registry.defineParameterType(param);
+    }),
+    import_overloaded.def`transformPrimitive`(
+      (0, import_overloaded.string)(),
+      (0, import_overloaded.instance)(RegExp),
+      (0, import_overloaded.nil)("type"),
+      (0, import_overloaded.func)("transform"),
+      (0, import_overloaded.func)("primitive")
+    ).matches((name2, regexp2, _, transform2, primitive2) => {
+      const primitivePrototype = primitive2;
+      const wrapper = (val) => {
+        const asPrimitive = primitivePrototype(val);
+        return transform2(asPrimitive);
+      };
+      const param = new import_cucumber_expressions.ParameterType(name2, regexp2, primitive2, wrapper);
+      registry.defineParameterType(param);
+    }),
+    import_overloaded.def`encapuslatePrimitive`(
+      (0, import_overloaded.string)(),
+      (0, import_overloaded.instance)(RegExp),
+      (0, import_overloaded.func)("type"),
+      (0, import_overloaded.nil)("transform"),
+      (0, import_overloaded.func)("primitive")
+    ).matches((name2, regexp2, type2, _, primitive2) => {
+      const primitivePrototype = primitive2;
+      const typePrototype = type2;
+      const wrapper = (val) => {
+        const asPrimitive = primitivePrototype(val);
+        return new typePrototype(asPrimitive);
+      };
+      const param = new import_cucumber_expressions.ParameterType(name2, regexp2, type2, wrapper);
+      registry.defineParameterType(param);
+    }),
+    import_overloaded.def`makeType`(
+      (0, import_overloaded.string)(),
+      (0, import_overloaded.instance)(RegExp),
+      (0, import_overloaded.func)("type"),
+      (0, import_overloaded.nil)(),
+      (0, import_overloaded.nil)()
+    ).matches((name2, pattern, type2) => {
+      const prototype = type2;
+      const transform2 = (val) => new prototype(val);
+      const param = new import_cucumber_expressions.ParameterType(name2, pattern, null, transform2);
+      registry.defineParameterType(param);
+    }),
+    import_overloaded.def`makePrimitive`(
+      (0, import_overloaded.string)(),
+      (0, import_overloaded.instance)(RegExp),
+      (0, import_overloaded.nil)(),
+      (0, import_overloaded.nil)(),
+      (0, import_overloaded.func)("primitive")
+    ).matches((name2, pattern, _, __, primitive2) => {
+      const prototype = primitive2;
+      const transform2 = (val) => prototype(val);
+      const param = new import_cucumber_expressions.ParameterType(name2, pattern, null, transform2);
+      registry.defineParameterType(param);
+    }),
+    import_overloaded.def`transformValue`(
+      (0, import_overloaded.string)(),
+      (0, import_overloaded.instance)(RegExp),
+      (0, import_overloaded.nil)(),
+      (0, import_overloaded.func)("transform"),
+      (0, import_overloaded.nil)()
+    ).matches((name2, pattern, _, transform2, __) => {
+      const param = new import_cucumber_expressions.ParameterType(name2, pattern, null, transform2);
+      registry.defineParameterType(param);
+    }),
+    import_overloaded.def`default`((0, import_overloaded.string)(), (0, import_overloaded.instance)(RegExp), (0, import_overloaded.nil)(), (0, import_overloaded.nil)(), (0, import_overloaded.nil)()).matches(
+      (name2, pattern, _, __, ___) => {
+        const transform2 = (val) => val;
+        const param = new import_cucumber_expressions.ParameterType(name2, pattern, null, transform2);
+        registry.defineParameterType(param);
+      }
+    )
+  ).use([name, regexpPattern, type, transform, primitive]);
+}
+
+// src/default.parameters.ts
+var import_overloaded2 = require("@autometa/overloaded");
+var import_datetime = require("@autometa/datetime");
+var import_asserters2 = require("@autometa/asserters");
+var import_luxon = require("luxon");
+var strNum = /['"]-?\d+['"]/;
+var isodateRegexp = /(\d{4}-[01]\d-[0-3]\dT[0-2]\d:[0-5]\d:[0-5]\d\.\d+([+-][0-2]\d:[0-5]\d|Z))|(\d{4}-[01]\d-[0-3]\dT[0-2]\d:[0-5]\d:[0-5]\d([+-][0-2]\d:[0-5]\d|Z))|(\d{4}-[01]\d-[0-3]\dT[0-2]\d:[0-5]\d([+-][0-2]\d:[0-5]\d|Z))/;
+var shortDateRegex = /(\d{4}-[01]\d-[0-3]\dT[0-2]\d:[0-5]\d:[0-5]\d\.\d+([+-][0-2]\d:[0-5]\d|Z))|(\d{4}-[01]\d-[0-3]\dT[0-2]\d:[0-5]\d:[0-5]\d([+-][0-2]\d:[0-5]\d|Z))|(\d{4}-[01]\d-[0-3]\d)/;
+var boolTypesActive = ["active", "inactive"];
+var boolTypesEnabled = ["enabled", "disabled"];
+var boolTypes = ["true", "false"];
+var NumberParam = {
+  name: "number",
+  regexpPattern: /\d+/,
+  primitive: Number
+};
+var BooleanParam = {
+  name: "boolean",
+  regexpPattern: /true|false/,
+  primitive: Boolean
+};
+var PrimitiveParam = {
+  name: "primitive",
+  regexpPattern: [
+    /true|false/,
+    /enabled|disabled/,
+    /active|inactive/,
+    /null/,
+    /empty/,
+    /undefined/,
+    /NaN/,
+    /Infinity/,
+    /-Infinity/,
+    isodateRegexp,
+    shortDateRegex,
+    /-?\d+/,
+    /"([^"]*)"/,
+    /'([^']*)'/
+  ],
+  transform: (value) => {
+    return (0, import_overloaded2.overloads)(
+      (0, import_overloaded2.def)((0, import_overloaded2.string)({ equals: "null" })).matches((_) => null),
+      (0, import_overloaded2.def)((0, import_overloaded2.string)({ equals: "undefined" })).matches((_) => void 0),
+      (0, import_overloaded2.def)((0, import_overloaded2.string)({ in: boolTypes })).matches((val) => Boolean(val)),
+      (0, import_overloaded2.def)((0, import_overloaded2.string)({ equals: "NaN" })).matches((_) => NaN),
+      (0, import_overloaded2.def)((0, import_overloaded2.string)({ equals: "Infinity" })).matches((_) => Infinity),
+      (0, import_overloaded2.def)((0, import_overloaded2.string)({ equals: "-Infinity" })).matches((_) => -Infinity),
+      (0, import_overloaded2.def)((0, import_overloaded2.string)({ pattern: isodateRegexp })).matches(parseIso),
+      (0, import_overloaded2.def)((0, import_overloaded2.string)({ pattern: shortDateRegex })).matches(parseDate),
+      (0, import_overloaded2.def)((0, import_overloaded2.string)({ pattern: strNum })).matches(trimQuotes),
+      (0, import_overloaded2.def)((0, import_overloaded2.string)({ pattern: /-?\d+/ })).matches((val) => Number(val)),
+      (0, import_overloaded2.def)((0, import_overloaded2.string)({ in: boolTypesEnabled })).matches(boolEnabled),
+      (0, import_overloaded2.def)((0, import_overloaded2.string)({ in: boolTypesActive })).matches(boolActive),
+      (0, import_overloaded2.fallback)((val) => {
+        (0, import_asserters2.AssertIs)(val, "string");
+        const fromPhrase = import_datetime.Dates.fromPhrase(val);
+        if (fromPhrase && !isNaN(fromPhrase.getTime())) {
+          return fromPhrase;
+        }
+        return val;
+      })
+    ).use([value]);
+  }
+};
+function boolActive(val) {
+  return val === "active";
+}
+function boolEnabled(val) {
+  return val === "enabled";
+}
+function parseDate(val) {
+  return new Date(Date.parse(val));
+}
+function trimQuotes(val) {
+  return val.slice(1, -1);
+}
+function parseIso(val) {
+  return import_luxon.DateTime.fromISO(val).toJSDate();
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BooleanParam,
+  DifferentStepTypeMatch,
+  FuzzySearchReport,
+  NumberParam,
+  PrimitiveParam,
+  SameStepTypeMatch,
+  buildFuzzySearchReport,
+  checkMatch,
+  defineParameterType,
+  getDiff,
+  getDiffs,
+  isExpressionCandidate,
+  limitDiffs,
+  refineDiff
+});

package/package.json

@@ -0,0 +1,56 @@
+{
+  "name": "@autometa/cucumber-expressions",
+  "version": "0.0.0",
+  "description": "wrapper on @cucumber/cucumber-expressions",
+  "type": "module",
+  "main": "dist/index.js",
+  "module": "dist/esm/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    "import": "./dist/esm/index.js",
+    "require": "./dist/index.js",
+    "default": "./dist/esm/index.js",
+    "types": "./dist/index.d.ts"
+  },
+  "license": "MIT",
+  "devDependencies": {
+    "@types/node": "^18.11.18",
+    "@types/strip-color": "^0.1.0",
+    "@types/uuid": "^9.0.1",
+    "@typescript-eslint/eslint-plugin": "^5.54.1",
+    "@typescript-eslint/parser": "^5.54.1",
+    "eslint": "^8.37.0",
+    "eslint-config-custom": "0.5.1",
+    "eslint-config-prettier": "^8.3.0",
+    "rimraf": "^4.1.2",
+    "strip-color": "^0.1.0",
+    "tsconfig": " *",
+    "tsup": "^6.7.0",
+    "typescript": "^4.9.5",
+    "vitest": "^0.29.8"
+  },
+  "dependencies": {
+    "@autometa/asserters": "^0.0.0",
+    "@autometa/datetime": "^0.0.0",
+    "@autometa/errors": "^0.0.0",
+    "@autometa/overloaded": "^0.2.9",
+    "@autometa/types": "^0.3.1",
+    "@cucumber/cucumber-expressions": "^16.1.2",
+    "@types/diff": "^5.0.3",
+    "@types/luxon": "^3.3.1",
+    "chalk": "^5.3.0",
+    "closest-match": "^1.3.3",
+    "diff": "^5.1.0",
+    "luxon": "^3.3.0"
+  },
+  "scripts": {
+    "test": "vitest run --passWithNoTests",
+    "prettify": "prettier --config .prettierrc 'src/**/*.ts' --write",
+    "lint": "eslint . --max-warnings 0",
+    "lint:fix": "eslint . --fix",
+    "clean": "rimraf dist",
+    "build": "tsup",
+    "build:watch": "tsup --watch"
+  },
+  "readme": "# Introduction\n\nThere's nothing here yet"
+}

package/tsup.config.ts

@@ -0,0 +1,14 @@
+import { defineConfig } from "tsup";
+
+export default defineConfig({
+  clean: true, // clean up the dist folder
+  format: ["cjs", "esm"], // generate cjs and esm files
+  dts: true,
+  sourcemap: false, // generate sourcemaps
+  skipNodeModulesBundle: true,
+  entryPoints: ["src/index.ts"],
+  target: "es2020",
+  outDir: "dist",
+  legacyOutput: true,
+  external: ["dist"],
+});