@autometa/cucumber-expressions 0.4.4 → 1.0.0-rc.0

package/README.md

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

package/dist/extensions.d.ts

@@ -0,0 +1,9 @@
+import { ParameterType } from "@cucumber/cucumber-expressions";
+export interface ParameterRuntime<World> {
+    readonly world: World;
+    readonly parameterType: ParameterType<unknown>;
+}
+export type ParameterTransformFn<World> = (values: readonly string[] | null, runtime: ParameterRuntime<World>) => unknown;
+export declare function attachTransform<World>(parameterType: ParameterType<unknown>, transform: ParameterTransformFn<World>): void;
+export declare function applyCucumberExtensions(): void;
+export declare function resetCucumberExtensions(): void;

package/dist/index.cjs

@@ -0,0 +1,317 @@
+'use strict';
+
+var cucumberExpressions = require('@cucumber/cucumber-expressions');
+
+// src/parameter-types.ts
+var transformSymbol = Symbol("autometa:cucumber:transform");
+var extensionsApplied = false;
+var originalTransform;
+var originalGetValue;
+function attachTransform(parameterType, transform) {
+  parameterType[transformSymbol] = transform;
+}
+function applyCucumberExtensions() {
+  if (extensionsApplied) {
+    return;
+  }
+  originalTransform = originalTransform ?? cucumberExpressions.ParameterType.prototype.transform;
+  cucumberExpressions.ParameterType.prototype.transform = function transform(thisObj, groupValues) {
+    const transformFn = this[transformSymbol];
+    if (transformFn) {
+      return transformFn(groupValues ?? null, {
+        world: thisObj,
+        parameterType: this
+      });
+    }
+    const normalized = groupValues ? [...groupValues] : [];
+    if (!originalTransform) {
+      throw new Error("Cucumber extensions have not been initialised correctly");
+    }
+    return originalTransform.call(this, thisObj, normalized);
+  };
+  originalGetValue = originalGetValue ?? cucumberExpressions.Argument.prototype.getValue;
+  cucumberExpressions.Argument.prototype.getValue = function getValue(context) {
+    const group = this.group;
+    let values = null;
+    if (group) {
+      const childValues = group.children?.map((child) => child.value).filter((value) => value !== void 0);
+      if (childValues && childValues.length > 0) {
+        values = childValues;
+      } else if (group.value !== void 0 && group.value !== null) {
+        values = [group.value];
+      } else if (group.values) {
+        values = group.values;
+      }
+    }
+    const parameterType = this.parameterType;
+    const transformFn = parameterType?.[transformSymbol];
+    if (transformFn && parameterType) {
+      return transformFn(values, {
+        world: context,
+        parameterType
+      });
+    }
+    if (!originalGetValue) {
+      throw new Error("Cucumber extensions have not been initialised correctly");
+    }
+    return originalGetValue.call(this, context);
+  };
+  extensionsApplied = true;
+}
+function resetCucumberExtensions() {
+  if (!extensionsApplied) {
+    return;
+  }
+  if (originalTransform) {
+    cucumberExpressions.ParameterType.prototype.transform = originalTransform;
+  }
+  if (originalGetValue) {
+    cucumberExpressions.Argument.prototype.getValue = originalGetValue;
+  }
+  extensionsApplied = false;
+}
+
+// src/parameter-types.ts
+function toPatternArray(pattern) {
+  return Array.isArray(pattern) ? [...pattern] : [pattern];
+}
+function buildDefaultValue(rawValues) {
+  if (rawValues.length === 0) {
+    return void 0;
+  }
+  if (rawValues.length === 1) {
+    return rawValues[0];
+  }
+  return [...rawValues];
+}
+function resolveScopedName(name, namespace) {
+  if (!name || !namespace) {
+    return name;
+  }
+  return `${namespace}:${name}`;
+}
+function buildTransform(definition, scopedName, options) {
+  return (values, runtime) => {
+    const rawValues = values ?? [];
+    const resolved = buildDefaultValue(rawValues);
+    if (definition.transform) {
+      const context = {
+        raw: rawValues,
+        world: runtime.world,
+        name: scopedName,
+        originalName: definition.name,
+        parameterType: runtime.parameterType,
+        definition,
+        ...options?.namespace !== void 0 ? { namespace: options.namespace } : {}
+      };
+      return definition.transform(resolved, context);
+    }
+    return resolved;
+  };
+}
+function firstValue(input) {
+  return Array.isArray(input) ? input[0] : input;
+}
+function firstString(input) {
+  const value = firstValue(input);
+  if (value === void 0 || value === null) {
+    return void 0;
+  }
+  return String(value);
+}
+function parseNumberValue(input, parser) {
+  const raw = firstString(input);
+  if (raw === void 0) {
+    return null;
+  }
+  const numeric = parser(raw);
+  return Number.isNaN(numeric) ? null : numeric;
+}
+function parseBigIntValue(input) {
+  const raw = firstString(input);
+  if (raw === void 0) {
+    return null;
+  }
+  try {
+    return BigInt(raw);
+  } catch {
+    return null;
+  }
+}
+function createParameterTypes(options) {
+  applyCucumberExtensions();
+  const define = (registry, definition) => {
+    const patterns = toPatternArray(definition.pattern);
+    const scopedName = resolveScopedName(definition.name, options?.namespace);
+    const transform = buildTransform(definition, scopedName, options);
+    const parameterType = new cucumberExpressions.ParameterType(
+      scopedName,
+      patterns,
+      null,
+      // The original transform is overridden by applyCucumberExtensions.
+      (...matches) => matches.length <= 1 ? matches[0] : matches,
+      definition.useForSnippets,
+      definition.preferForRegexpMatch,
+      definition.builtin
+    );
+    attachTransform(parameterType, transform);
+    registry.defineParameterType(parameterType);
+    return parameterType;
+  };
+  define.many = (registry, ...definitions) => {
+    const list = definitions.length === 1 && Array.isArray(definitions[0]) ? definitions[0] : definitions;
+    list.forEach((definition) => {
+      define(registry, definition);
+    });
+    return registry;
+  };
+  return define;
+}
+var defineParameterType = createParameterTypes();
+var INTEGER_REGEXPS = [/-?\d+/, /\d+/];
+var FLOAT_REGEXP = /(?=.*\d.*)[-+]?\d*(?:\.(?=\d.*))?\d*(?:\d+[E][+-]?\d+)?/;
+var WORD_REGEXP = /[^\s]+/;
+var STRING_REGEXP = /"([^"\\]*(\\.[^"\\]*)*)"|'([^'\\]*(\\.[^'\\]*)*)'/;
+var ANONYMOUS_REGEXP = /.*/;
+function createDefaultParameterTypes(options) {
+  const define = createParameterTypes(options);
+  return (registry) => {
+    const defaults = [
+      {
+        name: "int",
+        pattern: INTEGER_REGEXPS,
+        transform: (value) => parseNumberValue(value, (raw) => parseInt(raw, 10)),
+        useForSnippets: true,
+        preferForRegexpMatch: true,
+        builtin: true
+      },
+      {
+        name: "float",
+        pattern: FLOAT_REGEXP,
+        transform: (value) => parseNumberValue(value, (raw) => parseFloat(raw)),
+        useForSnippets: true,
+        preferForRegexpMatch: false,
+        builtin: true
+      },
+      {
+        name: "number",
+        pattern: FLOAT_REGEXP,
+        transform: (value) => parseNumberValue(value, (raw) => parseFloat(raw)),
+        useForSnippets: true,
+        preferForRegexpMatch: false,
+        builtin: true
+      },
+      {
+        name: "word",
+        pattern: WORD_REGEXP,
+        transform: (value) => firstString(value) ?? "",
+        useForSnippets: false,
+        preferForRegexpMatch: false,
+        builtin: true
+      },
+      {
+        name: "string",
+        pattern: STRING_REGEXP,
+        transform: (_value, context) => {
+          const [doubleQuoted, singleQuoted] = context.raw;
+          const captured = doubleQuoted ?? singleQuoted ?? "";
+          return captured.replace(/\\"/g, '"').replace(/\\'/g, "'");
+        },
+        useForSnippets: true,
+        preferForRegexpMatch: false,
+        builtin: true
+      },
+      {
+        name: "",
+        pattern: ANONYMOUS_REGEXP,
+        transform: (_value, context) => context.raw[0] ?? "",
+        useForSnippets: false,
+        preferForRegexpMatch: true,
+        builtin: true
+      },
+      {
+        name: "double",
+        pattern: FLOAT_REGEXP,
+        transform: (value) => parseNumberValue(value, (raw) => parseFloat(raw)),
+        useForSnippets: false,
+        preferForRegexpMatch: false,
+        builtin: true
+      },
+      {
+        name: "bigdecimal",
+        pattern: FLOAT_REGEXP,
+        transform: (value) => {
+          const text = firstString(value);
+          return text ?? null;
+        },
+        useForSnippets: false,
+        preferForRegexpMatch: false,
+        builtin: true
+      },
+      {
+        name: "byte",
+        pattern: INTEGER_REGEXPS,
+        transform: (value) => parseNumberValue(value, (raw) => parseInt(raw, 10)),
+        useForSnippets: false,
+        preferForRegexpMatch: false,
+        builtin: true
+      },
+      {
+        name: "short",
+        pattern: INTEGER_REGEXPS,
+        transform: (value) => parseNumberValue(value, (raw) => parseInt(raw, 10)),
+        useForSnippets: false,
+        preferForRegexpMatch: false,
+        builtin: true
+      },
+      {
+        name: "long",
+        pattern: INTEGER_REGEXPS,
+        transform: (value) => parseNumberValue(value, (raw) => parseInt(raw, 10)),
+        useForSnippets: false,
+        preferForRegexpMatch: false,
+        builtin: true
+      },
+      {
+        name: "biginteger",
+        pattern: INTEGER_REGEXPS,
+        transform: (value) => parseBigIntValue(value),
+        useForSnippets: false,
+        preferForRegexpMatch: false,
+        builtin: true
+      }
+    ];
+    const prepared = defaults.map(
+      (definition) => options?.namespace && definition.preferForRegexpMatch ? { ...definition, preferForRegexpMatch: false } : definition
+    );
+    const toRegister = [];
+    prepared.forEach((definition) => {
+      const scopedName = resolveScopedName(
+        definition.name,
+        options?.namespace
+      );
+      const existing = registry.lookupByTypeName(scopedName);
+      if (existing) {
+        const transform = buildTransform(definition, scopedName, options);
+        attachTransform(existing, transform);
+        return;
+      }
+      toRegister.push(definition);
+    });
+    if (toRegister.length > 0) {
+      define.many(registry, ...toRegister);
+    }
+    return registry;
+  };
+}
+var defineDefaultParameterTypes = createDefaultParameterTypes();
+
+exports.applyCucumberExtensions = applyCucumberExtensions;
+exports.attachTransform = attachTransform;
+exports.createDefaultParameterTypes = createDefaultParameterTypes;
+exports.createParameterTypes = createParameterTypes;
+exports.defineDefaultParameterTypes = defineDefaultParameterTypes;
+exports.defineParameterType = defineParameterType;
+exports.resetCucumberExtensions = resetCucumberExtensions;
+//# sourceMappingURL=out.js.map
+//# sourceMappingURL=index.cjs.map

package/dist/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/parameter-types.ts","../src/extensions.ts"],"names":["ParameterType"],"mappings":"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","sourcesContent":["import {\n  ParameterType,\n  ParameterTypeRegistry,\n} from \"@cucumber/cucumber-expressions\";\nimport { attachTransform, applyCucumberExtensions } from \"./extensions\";\nimport type { ParameterRuntime, ParameterTransformFn } from \"./extensions\";\n\nexport interface CreateParameterTypesOptions {\n  readonly namespace?: string;\n}\n\nexport interface ParameterTransformContext<World> {\n  readonly raw: readonly string[];\n  readonly world: World;\n  readonly name: string | undefined;\n  readonly originalName: string | undefined;\n  readonly namespace?: string;\n  readonly parameterType: ParameterType<unknown>;\n  readonly definition: ParameterTypeDefinition<World>;\n}\n\nexport type ParameterTransformer<TResult, World> = (\n  value: unknown,\n  context: ParameterTransformContext<World>\n) => TResult | Promise<TResult>;\n\nexport interface ParameterTypeDefinition<World, TResult = unknown> {\n  readonly name: string;\n  readonly pattern: RegExp | readonly RegExp[];\n  readonly transform?: ParameterTransformer<TResult, World>;\n  readonly useForSnippets?: boolean;\n  readonly preferForRegexpMatch?: boolean;\n  readonly builtin?: boolean;\n}\n\nexport type ParameterTypeDefinitions<World> = ReadonlyArray<\n  ParameterTypeDefinition<World>\n>;\n\nfunction toPatternArray(pattern: RegExp | readonly RegExp[]) {\n  return Array.isArray(pattern) ? [...pattern] : [pattern];\n}\n\nfunction buildDefaultValue(rawValues: readonly string[]): unknown {\n  if (rawValues.length === 0) {\n    return undefined;\n  }\n\n  if (rawValues.length === 1) {\n    return rawValues[0];\n  }\n\n  return [...rawValues];\n}\n\nfunction resolveScopedName(name: string, namespace: string | undefined) {\n  if (!name || !namespace) {\n    return name;\n  }\n\n  return `${namespace}:${name}`;\n}\n\nfunction buildTransform<World>(\n  definition: ParameterTypeDefinition<World>,\n  scopedName: string,\n  options: CreateParameterTypesOptions | undefined\n): ParameterTransformFn<World> {\n  return (values: readonly string[] | null, runtime: ParameterRuntime<World>) => {\n    const rawValues = values ?? [];\n    const resolved = buildDefaultValue(rawValues);\n\n    if (definition.transform) {\n      const context: ParameterTransformContext<World> = {\n        raw: rawValues,\n        world: runtime.world,\n        name: scopedName,\n        originalName: definition.name,\n        parameterType: runtime.parameterType,\n        definition,\n        ...(options?.namespace !== undefined\n          ? { namespace: options.namespace }\n          : {}),\n      };\n\n      return definition.transform(resolved, context);\n    }\n\n    return resolved;\n  };\n}\n\nfunction firstValue<T>(input: unknown): T | undefined {\n  return Array.isArray(input) ? (input[0] as T | undefined) : (input as T | undefined);\n}\n\nfunction firstString(input: unknown): string | undefined {\n  const value = firstValue<unknown>(input);\n  if (value === undefined || value === null) {\n    return undefined;\n  }\n  return String(value);\n}\n\nfunction parseNumberValue(\n  input: unknown,\n  parser: (raw: string) => number\n): number | null {\n  const raw = firstString(input);\n  if (raw === undefined) {\n    return null;\n  }\n\n  const numeric = parser(raw);\n  return Number.isNaN(numeric) ? null : numeric;\n}\n\nfunction parseBigIntValue(input: unknown): bigint | null {\n  const raw = firstString(input);\n  if (raw === undefined) {\n    return null;\n  }\n\n  try {\n    return BigInt(raw);\n  } catch {\n    return null;\n  }\n}\n\nexport interface DefineParameterTypeFn<World> {\n  (\n    registry: ParameterTypeRegistry,\n    definition: ParameterTypeDefinition<World>\n  ): ParameterType<unknown>;\n  many(\n    registry: ParameterTypeRegistry,\n    ...definitions:\n      | ParameterTypeDefinitions<World>\n      | [ParameterTypeDefinition<World>]\n  ): ParameterTypeRegistry;\n}\n\nexport function createParameterTypes<World>(\n  options?: CreateParameterTypesOptions\n): DefineParameterTypeFn<World> {\n  applyCucumberExtensions();\n\n  const define = ((\n    registry: ParameterTypeRegistry,\n    definition: ParameterTypeDefinition<World>\n  ) => {\n    const patterns = toPatternArray(definition.pattern);\n    const scopedName = resolveScopedName(definition.name, options?.namespace);\n    const transform = buildTransform(definition, scopedName, options);\n    const parameterType = new ParameterType<unknown>(\n      scopedName,\n      patterns,\n      null,\n      // The original transform is overridden by applyCucumberExtensions.\n      (...matches: string[]) => (matches.length <= 1 ? matches[0] : matches),\n      definition.useForSnippets,\n      definition.preferForRegexpMatch,\n      definition.builtin\n    );\n\n    attachTransform(parameterType, transform);\n    registry.defineParameterType(parameterType);\n    return parameterType;\n  }) as DefineParameterTypeFn<World>;\n\n  define.many = (\n    registry: ParameterTypeRegistry,\n    ...definitions:\n      | ParameterTypeDefinitions<World>\n      | [ParameterTypeDefinition<World>]\n  ) => {\n    const list =\n      definitions.length === 1 && Array.isArray(definitions[0])\n        ? (definitions[0] as ParameterTypeDefinitions<World>)\n        : (definitions as ParameterTypeDefinition<World>[]);\n\n    list.forEach((definition) => {\n      define(registry, definition);\n    });\n\n    return registry;\n  };\n\n  return define;\n}\n\nexport const defineParameterType = createParameterTypes<unknown>();\n\nconst INTEGER_REGEXPS = [/-?\\d+/, /\\d+/] as const;\nconst FLOAT_REGEXP = /(?=.*\\d.*)[-+]?\\d*(?:\\.(?=\\d.*))?\\d*(?:\\d+[E][+-]?\\d+)?/;\nconst WORD_REGEXP = /[^\\s]+/;\nconst STRING_REGEXP = /\"([^\"\\\\]*(\\\\.[^\"\\\\]*)*)\"|'([^'\\\\]*(\\\\.[^'\\\\]*)*)'/;\nconst ANONYMOUS_REGEXP = /.*/;\n\nexport function createDefaultParameterTypes<World>(\n  options?: CreateParameterTypesOptions\n) {\n  const define = createParameterTypes<World>(options);\n\n  return (registry: ParameterTypeRegistry) => {\n    const defaults: ParameterTypeDefinition<World>[] = [\n      {\n        name: \"int\",\n        pattern: INTEGER_REGEXPS,\n        transform: (value: unknown) =>\n          parseNumberValue(value, (raw) => parseInt(raw, 10)),\n        useForSnippets: true,\n        preferForRegexpMatch: true,\n        builtin: true,\n      },\n      {\n        name: \"float\",\n        pattern: FLOAT_REGEXP,\n        transform: (value: unknown) =>\n          parseNumberValue(value, (raw) => parseFloat(raw)),\n        useForSnippets: true,\n        preferForRegexpMatch: false,\n        builtin: true,\n      },\n      {\n        name: \"number\",\n        pattern: FLOAT_REGEXP,\n        transform: (value: unknown) =>\n          parseNumberValue(value, (raw) => parseFloat(raw)),\n        useForSnippets: true,\n        preferForRegexpMatch: false,\n        builtin: true,\n      },\n      {\n        name: \"word\",\n        pattern: WORD_REGEXP,\n        transform: (value: unknown) => firstString(value) ?? \"\",\n        useForSnippets: false,\n        preferForRegexpMatch: false,\n        builtin: true,\n      },\n      {\n        name: \"string\",\n        pattern: STRING_REGEXP,\n        transform: (_value: unknown, context: ParameterTransformContext<World>) => {\n          const [doubleQuoted, singleQuoted] = context.raw;\n          const captured = doubleQuoted ?? singleQuoted ?? \"\";\n          return captured\n            .replace(/\\\\\"/g, '\"')\n            .replace(/\\\\'/g, \"'\");\n        },\n        useForSnippets: true,\n        preferForRegexpMatch: false,\n        builtin: true,\n      },\n      {\n        name: \"\",\n        pattern: ANONYMOUS_REGEXP,\n        transform: (_value: unknown, context: ParameterTransformContext<World>) =>\n          context.raw[0] ?? \"\",\n        useForSnippets: false,\n        preferForRegexpMatch: true,\n        builtin: true,\n      },\n      {\n        name: \"double\",\n        pattern: FLOAT_REGEXP,\n        transform: (value: unknown) =>\n          parseNumberValue(value, (raw) => parseFloat(raw)),\n        useForSnippets: false,\n        preferForRegexpMatch: false,\n        builtin: true,\n      },\n      {\n        name: \"bigdecimal\",\n        pattern: FLOAT_REGEXP,\n        transform: (value: unknown) => {\n          const text = firstString(value);\n          return text ?? null;\n        },\n        useForSnippets: false,\n        preferForRegexpMatch: false,\n        builtin: true,\n      },\n      {\n        name: \"byte\",\n        pattern: INTEGER_REGEXPS,\n        transform: (value: unknown) =>\n          parseNumberValue(value, (raw) => parseInt(raw, 10)),\n        useForSnippets: false,\n        preferForRegexpMatch: false,\n        builtin: true,\n      },\n      {\n        name: \"short\",\n        pattern: INTEGER_REGEXPS,\n        transform: (value: unknown) =>\n          parseNumberValue(value, (raw) => parseInt(raw, 10)),\n        useForSnippets: false,\n        preferForRegexpMatch: false,\n        builtin: true,\n      },\n      {\n        name: \"long\",\n        pattern: INTEGER_REGEXPS,\n        transform: (value: unknown) =>\n          parseNumberValue(value, (raw) => parseInt(raw, 10)),\n        useForSnippets: false,\n        preferForRegexpMatch: false,\n        builtin: true,\n      },\n      {\n        name: \"biginteger\",\n        pattern: INTEGER_REGEXPS,\n        transform: (value: unknown) => parseBigIntValue(value),\n        useForSnippets: false,\n        preferForRegexpMatch: false,\n        builtin: true,\n      },\n    ];\n\n    const prepared = defaults.map((definition) =>\n      options?.namespace && definition.preferForRegexpMatch\n        ? { ...definition, preferForRegexpMatch: false }\n        : definition\n    );\n\n    const toRegister: ParameterTypeDefinition<World>[] = [];\n\n    prepared.forEach((definition) => {\n      const scopedName = resolveScopedName(\n        definition.name,\n        options?.namespace\n      );\n      const existing = registry.lookupByTypeName(scopedName);\n\n      if (existing) {\n        const transform = buildTransform(definition, scopedName, options);\n        attachTransform(existing, transform);\n        return;\n      }\n\n      toRegister.push(definition);\n    });\n\n    if (toRegister.length > 0) {\n      define.many(registry, ...toRegister);\n    }\n\n    return registry;\n  };\n}\n\nexport const defineDefaultParameterTypes =\n  createDefaultParameterTypes<unknown>();\n","import { Argument, ParameterType } from \"@cucumber/cucumber-expressions\";\n\nconst transformSymbol: unique symbol = Symbol(\"autometa:cucumber:transform\");\n\nexport interface ParameterRuntime<World> {\n  readonly world: World;\n  readonly parameterType: ParameterType<unknown>;\n}\n\nexport type ParameterTransformFn<World> = (\n  values: readonly string[] | null,\n  runtime: ParameterRuntime<World>\n) => unknown;\n\ntype StoredParameterTransformFn = ParameterTransformFn<unknown>;\n\ninterface AppAwareParameterType extends ParameterType<unknown> {\n  [transformSymbol]?: StoredParameterTransformFn;\n}\n\nlet extensionsApplied = false;\nlet originalTransform: typeof ParameterType.prototype.transform | undefined;\nlet originalGetValue: typeof Argument.prototype.getValue | undefined;\n\nexport function attachTransform<World>(\n  parameterType: ParameterType<unknown>,\n  transform: ParameterTransformFn<World>\n) {\n  (parameterType as AppAwareParameterType)[transformSymbol] =\n    transform as StoredParameterTransformFn;\n}\n\nexport function applyCucumberExtensions() {\n  if (extensionsApplied) {\n    return;\n  }\n\n  originalTransform = originalTransform ?? ParameterType.prototype.transform;\n\n  ParameterType.prototype.transform = function transform(\n    this: AppAwareParameterType,\n    thisObj: unknown,\n    groupValues: readonly string[] | null\n  ) {\n    const transformFn = this[transformSymbol];\n    if (transformFn) {\n      return transformFn(groupValues ?? null, {\n        world: thisObj,\n        parameterType: this,\n      });\n    }\n    const normalized = groupValues ? [...groupValues] : [];\n    if (!originalTransform) {\n      throw new Error(\"Cucumber extensions have not been initialised correctly\");\n    }\n    return originalTransform.call(this, thisObj, normalized);\n  } as unknown as typeof ParameterType.prototype.transform;\n\n  originalGetValue = originalGetValue ?? (Argument.prototype.getValue as typeof Argument.prototype.getValue);\n\n  Argument.prototype.getValue = function getValue<T>(\n    this: Argument,\n    context?: unknown\n  ): T {\n    const group = this.group;\n    let values: readonly string[] | null = null;\n\n    if (group) {\n      const childValues = group.children\n        ?.map((child: { value?: string | undefined }) => child.value)\n        .filter((value: string | undefined): value is string => value !== undefined);\n\n      if (childValues && childValues.length > 0) {\n        values = childValues;\n      } else if (group.value !== undefined && group.value !== null) {\n        values = [group.value];\n      } else if (group.values) {\n        values = group.values;\n      }\n    }\n\n    const parameterType = this.parameterType as AppAwareParameterType | undefined;\n    const transformFn = parameterType?.[transformSymbol];\n    if (transformFn && parameterType) {\n      return transformFn(values, {\n        world: context as unknown,\n        parameterType,\n      }) as T;\n    }\n\n    if (!originalGetValue) {\n      throw new Error(\"Cucumber extensions have not been initialised correctly\");\n    }\n\n    return originalGetValue.call(this, context) as T;\n  };\n\n  extensionsApplied = true;\n}\n\nexport function resetCucumberExtensions() {\n  if (!extensionsApplied) {\n    return;\n  }\n\n  if (originalTransform) {\n    ParameterType.prototype.transform = originalTransform;\n  }\n\n  if (originalGetValue) {\n    Argument.prototype.getValue = originalGetValue;\n  }\n\n  extensionsApplied = false;\n}\n"]}

package/dist/index.d.ts

@@ -1,104 +1,5 @@
-import { Change } from 'diff';
-import { Expression, ParameterTypeRegistry } from '@cucumber/cucumber-expressions';
-import { Class } from '@autometa/types';
-import { App } from '@autometa/app';
-
-type CachedStep = {
-    keyword: string;
-    type: string;
-    expression: Expression;
-    matches: (text: string) => boolean;
-};
-
-type StepDiff = {
-    merged: string;
-    step: CachedStep;
-    gherkin: string;
-    distance: number;
-};
-type StepDiffs = StepDiff[];
-type LimitedStepDiffs = {
-    same: StepDiffs;
-    other: StepDiffs;
-};
-declare function checkMatch(text: string, it: CachedStep): boolean;
-declare function limitDiffs(sameStepType: StepDiffs, differentStepType: StepDiffs, max: number): LimitedStepDiffs;
-declare function getDiffs(text: string, maxResults: number, step: CachedStep[]): {
-    merged: string;
-    step: CachedStep;
-    gherkin: string;
-    distance: number;
-}[];
-declare function getDiff(text: string, it: CachedStep): 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 source: string;
-    readonly distance: number;
-    constructor(diff: StepDiff);
-    toString(): string;
-}
-declare class DifferentStepTypeMatch {
-    readonly keyword: string;
-    readonly text: string;
-    readonly source: string;
-    readonly distance: number;
-    constructor(diff: StepDiff);
-    toString(): string;
-}
-declare class FuzzySearchReport {
-    #private;
-    readonly depth: number;
-    headingText: string;
-    matches: (SameStepTypeMatch | DifferentStepTypeMatch)[];
-    children: FuzzySearchReport[];
-    constructor(depth?: number);
-    get length(): number;
-    addHeading(headingText: string): this;
-    addMatch(match: SameStepTypeMatch | DifferentStepTypeMatch): this;
-    addChild(child: FuzzySearchReport): this;
-    toString(): string;
-}
-declare function buildFuzzySearchReport({ same, other }: LimitedStepDiffs, depth: number): FuzzySearchReport;
-
-declare module "@cucumber/cucumber-expressions" {
-    interface ParameterType<T> {
-        transform(groupValues: string[] | null, app: App): T;
-    }
-}
-type ParamTypeDefinition = {
-    name: string;
-    regex: RegExp | RegExp[];
-    /**
-     * @deprecated use regex instead
-     */
-    regexpPattern?: RegExp | RegExp[];
-    transform?: (value: any, app: App) => unknown;
-    type?: Class<unknown>;
-    primitive?: typeof String | typeof Number | typeof Boolean | typeof BigInt | typeof Date;
-};
-declare function defineParameterType<T extends ParamTypeDefinition[]>(registry: ParameterTypeRegistry, ...params: T): void;
-
-type AutoParamTypeDefinition = Omit<ParamTypeDefinition, "transform">;
-declare const OrdinalParam: ParamTypeDefinition;
-declare const NumberParam: AutoParamTypeDefinition;
-declare const AnyParam: AutoParamTypeDefinition;
-declare const UnknownParam: AutoParamTypeDefinition;
-declare const TextParam: ParamTypeDefinition;
-declare const BooleanParam: {
-    name: string;
-    regex: RegExp;
-    primitive: BooleanConstructor;
-};
-declare const BoolParam: {
-    name: string;
-    regex: RegExp;
-    primitive: BooleanConstructor;
-};
-declare const DateParam: AutoParamTypeDefinition;
-declare const PrimitiveParam: ParamTypeDefinition;
-
-export { AnyParam, BoolParam, BooleanParam, DateParam, DifferentStepTypeMatch, FuzzySearchReport, LimitedStepDiffs, NumberParam, OrdinalParam, ParamTypeDefinition, PrimitiveParam, SameStepTypeMatch, StepDiff, StepDiffs, TextParam, UnknownParam, buildFuzzySearchReport, checkMatch, defineParameterType, getDiff, getDiffs, isExpressionCandidate, limitDiffs, refineDiff };
+export { createParameterTypes, defineParameterType, createDefaultParameterTypes, defineDefaultParameterTypes, } from "./parameter-types";
+export type { ParameterTransformContext, ParameterTransformer, ParameterTypeDefinition, ParameterTypeDefinitions, CreateParameterTypesOptions, } from "./parameter-types";
+export { attachTransform, applyCucumberExtensions, resetCucumberExtensions, } from "./extensions";
+export type { ParameterRuntime, ParameterTransformFn } from "./extensions";
+export type { CachedStep, StepDiff, StepDiffList, LimitedStepDiffs } from "./types";