npm - @autometa/cucumber-expressions - Versions diffs - 0.4.3 → 1.0.0-rc.0 - Mend

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

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (21) hide show

package/README.md +1 -1
package/dist/extensions.d.ts +9 -0
package/dist/index.cjs +317 -0
package/dist/index.cjs.map +1 -0
package/dist/index.d.ts +5 -104
package/dist/index.js +279 -552
package/dist/index.js.map +1 -1
package/dist/parameter-types.d.ts +31 -0
package/dist/types.d.ts +18 -0
package/package.json +37 -34
package/.eslintignore +0 -3
package/.eslintrc.cjs +0 -4
package/.turbo/turbo-coverage.log +0 -45
package/.turbo/turbo-lint$colon$fix.log +0 -4
package/.turbo/turbo-prettify.log +0 -0
package/.turbo/turbo-test.log +0 -50
package/CHANGELOG.md +0 -228
package/dist/esm/index.js +0 -538
package/dist/esm/index.js.map +0 -1
package/dist/index.d.cts +0 -104
package/tsup.config.ts +0 -14

package/dist/index.js.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"sources":["../src/index.ts","../src/step-matcher.ts","../src/search-report.ts","../src/parameters.ts","../src/default.parameters.ts"],"sourcesContent":["export * from \"./step-matcher\";\nexport * from \"./search-report\";\nexport * from \"./parameters\";\nexport * from \"./default.parameters\";\n","import { diffWordsWithSpace, Change } from \"diff\";\nimport { distance } from \"closest-match\";\nimport { CachedStep } from \"./types\";\nexport type StepDiff = {\n merged: string;\n step: CachedStep;\n gherkin: string;\n distance: number;\n};\nexport type StepDiffs = StepDiff[];\nexport type LimitedStepDiffs = { same: StepDiffs; other: StepDiffs };\nexport function checkMatch(text: string, it: CachedStep): boolean {\n return it.matches(text);\n}\nexport function limitDiffs(\n sameStepType: StepDiffs,\n differentStepType: StepDiffs,\n max: number\n): LimitedStepDiffs {\n const sameDistances = sameStepType.map((it) => it.distance);\n const maxSameStepDistance = Math.max(...sameDistances);\n const otherStepDistance = differentStepType.map((it) => it.distance);\n const minDifferentStepDistance = Math.min(...otherStepDistance);\n // Prioritize same-type steps for search. Only\n // consider other-type steps when the lowest\n // other score is lower than the highest same scoreF\n if (maxSameStepDistance > minDifferentStepDistance) {\n const filter = sameStepType.filter(\n (it) => it.distance <= minDifferentStepDistance\n );\n if (filter.length >= max) {\n return { same: filter.slice(0, max), other: [] };\n }\n const diff = max - filter.length;\n const sameSlice = sameStepType.slice(0, diff);\n const differentSlice = differentStepType.slice(0, max - diff);\n return { same: sameSlice, other: differentSlice };\n }\n const maxIndex = Math.min(max, sameStepType.length);\n return { same: sameStepType.slice(0, maxIndex), other: [] };\n}\n\nfunction removeWhitespaceFromQuotedSubstrings(inputString: string): string {\n const regex = /([\"'])([^\"']?)\\1/g;\n let modifiedString = inputString;\n\n let match;\n while ((match = regex.exec(inputString))) {\n const quotedSubstring = match[0];\n const strippedSubstring = match[2].replace(/\\s+/g, \"\"); // Remove whitespace\n modifiedString = modifiedString.replace(\n quotedSubstring,\n `${match[1]}${strippedSubstring}${match[1]}`\n );\n }\n\n return modifiedString;\n}\n\nexport function getDiffs(text: string, maxResults: number, step: CachedStep[]) {\n const sorted = step\n .map((it) => {\n if (checkMatch(text, it)) {\n return { merged: text, step: it, gherkin: text, distance: 0 };\n }\n const collapsed = removeWhitespaceFromQuotedSubstrings(text);\n const diff = getDiff(collapsed, it);\n const refined = refineDiff(diff);\n const dist = distance(collapsed, refined);\n return { merged: refined, step: it, gherkin: text, distance: dist };\n })\n .sort((a, b) => a.distance - b.distance);\n const max = Math.min(maxResults, sorted.length);\n return sorted.slice(0, max);\n}\n\nexport function getDiff(text: string, it: CachedStep) {\n return diffWordsWithSpace(text, it.expression.source);\n}\n\nexport function refineDiff(diff: Change[]) {\n const strings: string[] = [];\n for (let index = 0; index < diff.length; index++) {\n const gherkinChange = diff[index];\n const scopeChange = diff[index + 1];\n if (isExpressionCandidate(gherkinChange, scopeChange)) {\n strings.push(gherkinChange.value);\n const extra = extractTextAfterPlaceholder(scopeChange.value);\n if (extra) {\n strings.push(extra);\n }\n index++;\n continue;\n }\n if (gherkinChange.removed === true) {\n continue;\n }\n if (gherkinChange.value) {\n strings.push(gherkinChange.value);\n\n continue;\n }\n }\n return strings.join(\"\");\n}\n\nfunction extractTextAfterPlaceholder(inputString: string): string \| null {\n // Define a regular expression to match the pattern\n const regex = /\\{[^{}]+\\}(.+)?/;\n\n // Use regex.exec to find a match in the input string\n const match = regex.exec(inputString);\n\n // Check if a match was found\n if (match && match[1]) {\n return match[1]; // Extract and trim the matched text (including leading spaces if present)\n } else {\n return null; // No match found or nothing after curly braces\n }\n}\n\nexport function isExpressionCandidate(change1: Change, change2: Change) {\n if (change1 && change1.removed && change2 && change2.added) {\n const scopeText = change2.value;\n return /{.}/.test(scopeText);\n }\n return false;\n}\n","import type { LimitedStepDiffs, StepDiff } from \"./step-matcher\";\nimport chalk from \"colors-cli\";\nexport class SameStepTypeMatch {\n readonly keyword: string;\n readonly text: string;\n readonly source: string;\n readonly distance: number;\n constructor(diff: StepDiff) {\n this.keyword = diff.step.keyword;\n this.text = diff.merged;\n this.source = diff.step.expression.source;\n this.distance = diff.distance;\n }\n toString() {\n const keyword = chalk.green(this.keyword);\n const text = chalk.white(this.source);\n const distance = chalk.blue(`[${this.distance}]`);\n return `${distance} ${keyword} ${text}`;\n }\n}\nexport class DifferentStepTypeMatch {\n readonly keyword: string;\n readonly text: string;\n readonly source: string;\n readonly distance: number;\n constructor(diff: StepDiff) {\n this.keyword = diff.step.keyword;\n this.text = diff.merged;\n this.source = diff.step.expression.source;\n this.distance = diff.distance;\n }\n toString() {\n const keywordColor = chalk.cyan_bt;\n const keyword = keywordColor(this.keyword);\n const text = chalk.white(this.source);\n const distance = chalk.blue(`[${this.distance}]`);\n return `${distance} ${keyword} ${text}`;\n }\n}\nexport class FuzzySearchReport {\n headingText: string;\n matches: (SameStepTypeMatch \| DifferentStepTypeMatch)[] = [];\n children: FuzzySearchReport[] = [];\n constructor(readonly depth: number = 0) {}\n get length() {\n const childLength: number = this.children\n .map((it) => it.length)\n .reduce<number>((a: number, b: number) => a + b, 0);\n return this.matches.length + childLength;\n }\n addHeading(headingText: string) {\n this.headingText = headingText;\n return this;\n }\n addMatch(match: SameStepTypeMatch \| DifferentStepTypeMatch) {\n this.matches.push(match);\n return this;\n }\n addChild(child: FuzzySearchReport) {\n this.children.push(child);\n return this;\n }\n get #sameMatchTypes() {\n return this.matches.filter(\n (it) => it instanceof SameStepTypeMatch\n ) as SameStepTypeMatch[];\n }\n get #differentMatchTypes() {\n return this.matches.filter(\n (it) => it instanceof DifferentStepTypeMatch\n ) as DifferentStepTypeMatch[];\n }\n\n toString() {\n if (this.length === 0) {\n return \"\";\n }\n const same = this.#sameMatchTypes\n .filter((it) => it.distance < 10)\n .map((it) => it.toString())\n .join(\"\\n\");\n const sameMessage =\n same.length > 0 ? chalk.italic(`Steps with matching step type:`) : \"\";\n const different = this.#differentMatchTypes\n .filter((it) => it.distance < 10)\n .map((it) => it.toString())\n .join(\"\\n\");\n const differentMessage =\n different.length > 0\n ? chalk.italic(`Steps with different step type:`)\n : \"\";\n\n const messageArray: string[] = [];\n appendSubMessage(messageArray, sameMessage);\n appendSubMessage(messageArray, same);\n appendSubMessage(messageArray, differentMessage);\n appendSubMessage(messageArray, different);\n const children: FuzzySearchReport[] = [];\n this.children.forEach((child) => {\n appendChild(children, child);\n });\n const formatChildren: string = children\n .map((it) => it.toString())\n .join(\"\\n\");\n const message = messageArray.join(`\\n`).trim();\n const heading = this.headingText && chalk.black(this.headingText);\n return `${heading ?? \"\"}\n${message.replace(/\\r\\n\|\\n\|\\r/gm, `\\n${TAB}`)}\n${formatChildren.replace(/\\r\\n\|\\n\|\\r/gm, `\\n${TAB}`)}`;\n }\n}\nfunction appendSubMessage(arr: string[], message: string, prefix?: string) {\n if (message && message.length > 0) {\n const str = prefix ? `${prefix ?? \"\"}${message ?? \"\"}` : message ?? \"\";\n arr.push(str);\n }\n}\nfunction appendChild(arr: FuzzySearchReport[], message: FuzzySearchReport) {\n if (message) {\n arr.push(message);\n }\n}\nconst SPACE = \" \";\nconst TAB = SPACE.repeat(2);\n\nexport function buildFuzzySearchReport(\n { same, other }: LimitedStepDiffs,\n depth: number\n) {\n const report = new FuzzySearchReport(depth);\n same.forEach((diff) => {\n report.addMatch(new SameStepTypeMatch(diff));\n });\n other.forEach((diff) => {\n report.addMatch(new DifferentStepTypeMatch(diff));\n });\n return report;\n}\n","import {\n Argument,\n ParameterType,\n ParameterTypeRegistry,\n} from \"@cucumber/cucumber-expressions\";\nimport { Class } from \"@autometa/types\";\nimport {\n def,\n func,\n instance,\n overloads,\n string,\n nil,\n array,\n} from \"@autometa/overloaded\";\nimport { App } from \"@autometa/app\";\ndeclare module \"@cucumber/cucumber-expressions\" {\n interface ParameterType<T> {\n transform(groupValues: string[] \| null, app: App): T;\n }\n}\nParameterType.prototype.transform = function transform(\n this: ParameterType<unknown> \| undefined,\n value: string[] \| null,\n app: App\n) {\n return (\n this as unknown as { transformFn: (...args: unknown[]) => unknown }\n ).transformFn.apply(this, [...(value ?? []), app]);\n} as unknown as typeof ParameterType.prototype.transform;\n\n// todo - this has a bug when dealing with {string} - does not remove quotes\nArgument.prototype.getValue = function getValue<T>(this: Argument, app: App) {\n if (this.group.children.length > 0) {\n const value = this.group.children\n .filter((it) => it.value !== undefined)\n .map((child) => child.value);\n\n if (value.length > 0) {\n return this.parameterType.transform(value, app) as T;\n }\n }\n const groupValues = this.group\n ? this.group.value\n ? [this.group.value]\n : this.group.values\n : null;\n return this.parameterType.transform(groupValues, app) as T;\n};\ntype PrimitiveConstructor =\n \| typeof Number\n \| typeof String\n \| typeof Boolean\n \| typeof BigInt;\n\nexport type ParamTypeDefinition = {\n name: string;\n regex: RegExp \| RegExp[];\n /*\n @deprecated use regex instead\n /\n regexpPattern?: RegExp \| RegExp[];\n // eslint-disable-next-line @typescript-eslint/no-explicit-any\n transform?: (value: any, app: App) => unknown;\n type?: Class<unknown>;\n primitive?:\n \| typeof String\n \| typeof Number\n \| typeof Boolean\n \| typeof BigInt\n \| typeof Date;\n};\n\nconst regexp = instance(RegExp).or(array([instance(RegExp)]));\n\nexport function defineParameterType<T extends ParamTypeDefinition[]>(\n registry: ParameterTypeRegistry,\n ...params: T\n) {\n params.forEach((param) => {\n const { name, regex, regexpPattern, transform, type, primitive } =\n param as ParamTypeDefinition;\n return registerParameterType(\n registry,\n name,\n regexpPattern ?? regex,\n transform,\n type,\n primitive\n );\n });\n}\nfunction registerParameterType(\n registry: ParameterTypeRegistry,\n name: string,\n regexpPattern: RegExp \| RegExp[],\n transform: ((value: unknown, app: App) => unknown) \| undefined,\n type: Class<unknown> \| undefined,\n primitive:\n \| NumberConstructor\n \| StringConstructor\n \| BooleanConstructor\n \| BigIntConstructor\n \| DateConstructor\n \| undefined\n): void {\n return overloads(\n def(\n string(),\n regexp,\n func(\"type\"),\n func(\"transform\"),\n func(\"primitive\")\n ).matches((name, regexp, type, transform, primitive) => {\n const primitivePrototype = primitive as unknown as PrimitiveConstructor;\n const typePrototype = type as unknown as Class<unknown>;\n const wrapper = (val: unknown) => {\n const asPrimitive = primitivePrototype(val);\n const asType = new typePrototype(asPrimitive);\n return transform(asType);\n };\n const param = new ParameterType(name, regexp, type, wrapper);\n registry.defineParameterType(param);\n }),\n def`allTransforms`(\n string(),\n regexp,\n func(\"type\"),\n func(\"transform\"),\n nil(\"primitive\")\n ).matches((name, regexp, type, transform) => {\n const typePrototype = type as unknown as Class<unknown>;\n const wrapper = (val: unknown) => {\n const asType = new typePrototype(val);\n return transform(asType);\n };\n const param = new ParameterType(name, regexp, type, wrapper);\n registry.defineParameterType(param);\n }),\n def`transformPrimitive`(\n string(),\n regexp,\n nil(\"type\"),\n func(\"transform\"),\n func(\"primitive\")\n ).matches((name, regexp, _, transform, primitive) => {\n const primitivePrototype = primitive as unknown as PrimitiveConstructor;\n const wrapper = (val: unknown) => {\n const asPrimitive = fromPrimitive(val, primitivePrototype);\n return transform(asPrimitive);\n };\n const param = new ParameterType(name, regexp, primitive, wrapper);\n registry.defineParameterType(param);\n }),\n def`encapsulatePrimitive`(\n string(),\n regexp,\n func(\"type\"),\n nil(\"transform\"),\n func(\"primitive\")\n ).matches((name, regexp, type, _, primitive) => {\n const primitivePrototype = primitive as unknown as PrimitiveConstructor;\n const typePrototype = type as unknown as Class<unknown>;\n const wrapper = (val: unknown) => {\n const asPrimitive = fromPrimitive(val, primitivePrototype);\n return new typePrototype(asPrimitive);\n };\n const param = new ParameterType(name, regexp, type, wrapper);\n registry.defineParameterType(param);\n }),\n def`makeType`(string(), regexp, func(\"type\"), nil(), nil()).matches(\n (name, pattern, type) => {\n const prototype = type as unknown as Class<unknown>;\n const transform = (val: unknown) => new prototype(val);\n const param = new ParameterType(name, pattern, null, transform);\n registry.defineParameterType(param);\n }\n ),\n def`makePrimitive`(\n string(),\n regexp,\n nil(),\n nil(),\n func(\"primitive\")\n ).matches((name, pattern, _, __, primitive) => {\n const prototype = primitive as unknown as PrimitiveConstructor;\n const transform = (val: unknown) => fromPrimitive(val, prototype);\n const param = new ParameterType(name, pattern, null, transform);\n registry.defineParameterType(param);\n }),\n def`transformValue`(\n string(),\n regexp,\n nil(),\n func(\"transform\"),\n nil()\n ).matches((name, pattern, _, transform, __) => {\n const param = new ParameterType(name, pattern, null, transform);\n registry.defineParameterType(param);\n }),\n def`default`(string(), instance(RegExp), nil(), nil(), nil()).matches(\n (name, pattern, _, __, ___) => {\n const transform = (val: unknown) => val;\n const param = new ParameterType(name, pattern, null, transform);\n registry.defineParameterType(param);\n }\n )\n ).use([name, regexpPattern, type, transform, primitive]);\n}\n\nfunction fromPrimitive(value: unknown, primitive: PrimitiveConstructor) {\n if (primitive === String) {\n return value;\n }\n if (primitive === Number) {\n return parseFloat(value as string);\n }\n if (primitive === Boolean) {\n return value === \"true\";\n }\n return primitive(value);\n}\n","import { def, fallback, overloads, string } from \"@autometa/overloaded\";\nimport { ParamTypeDefinition } from \"./parameters\";\nimport { Dates } from \"@autometa/datetime\";\nimport { AssertIs } from \"@autometa/asserters\";\nimport { DateTime } from \"luxon\";\ntype AutoParamTypeDefinition = Omit<ParamTypeDefinition, \"transform\">;\nconst strNum = /['\"]-?\\d+['\"]/;\n\nconst isodateRegexp =\n /(\\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))/;\nconst shortDateRegex =\n /(\\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)/;\nconst boolTypesActive = [\"active\", \"inactive\"];\nconst boolTypesEnabled = [\"enabled\", \"disabled\"];\nconst boolTypes = [\"true\", \"false\"];\n\nexport const OrdinalParam: ParamTypeDefinition = {\n name: \"ordinal\",\n regex: /(\\d+)(?:st\|nd\|rd\|th)/,\n transform: (value: string) => parseInt(value, 10),\n};\n\nexport const NumberParam: AutoParamTypeDefinition = {\n name: \"number\",\n regex: /\\d+/,\n primitive: Number,\n};\n\nexport const AnyParam: AutoParamTypeDefinition = {\n name: \"any\",\n regex: /./,\n};\nexport const UnknownParam: AutoParamTypeDefinition = {\n name: \"unknown\",\n regex: /./,\n};\nexport const TextParam: ParamTypeDefinition = {\n name: \"text\",\n regex: /\"([^\"\\\\](\\\\.[^\"\\\\]))\"\|'([^'\\\\](\\\\.[^'\\\\]))'/,\n primitive: String,\n transform: (value: string) => {\n const asStr = value as string;\n return asStr.replace(/^\"(.)\"$/, \"$1\").replace(/^'(.)'$/, \"$1\");\n },\n};\n\nexport const BooleanParam = {\n name: \"boolean\",\n regex: /true\|false/,\n primitive: Boolean,\n};\nexport const BoolParam = {\n name: \"bool\",\n regex: /true\|false/,\n primitive: Boolean,\n};\nexport const DateParam: AutoParamTypeDefinition = {\n name: \"date\",\n regex: [isodateRegexp, shortDateRegex],\n type: Date,\n};\n\nexport const PrimitiveParam: ParamTypeDefinition = {\n name: \"primitive\",\n regex: [\n /true\|false/,\n /enabled\|disabled/,\n /active\|inactive/,\n /null/,\n /empty/,\n /undefined\|missing/,\n /NaN/,\n /Infinity/,\n /-Infinity/,\n isodateRegexp,\n shortDateRegex,\n /-?(\\d\\.?\\d+\|\\d{1,3}(,\\d{3})(\\.\\d+)?)/, // Comma delimited number, e.g. \"1\", \"1,000\", \"1,000.00\"\n /-?(\\d,?\\d+\|\\d{1,3}(.\\d{3})(,\\d+))/, // Period delimited number, e.g. \"1\", \"1.000,00\"\n /\"([^\"])\"/,\n /'([^'])'/,\n ],\n transform: (value: unknown) => {\n return overloads(\n def(string({ equals: \"null\" })).matches((_) => null),\n def(string({ in: [\"undefined\", \"missing\"] })).matches((_) => undefined),\n def(string({ in: boolTypes })).matches((val) => val === \"true\"),\n def(string({ equals: \"NaN\" })).matches((_) => NaN),\n def(string({ equals: \"Infinity\" })).matches((_) => Infinity),\n def(string({ equals: \"-Infinity\" })).matches((_) => -Infinity),\n def(string({ pattern: isodateRegexp })).matches(parseIso),\n def(string({ pattern: shortDateRegex })).matches(parseDate),\n def(string({ pattern: strNum })).matches(trimQuotes),\n def(string({ pattern: /^-?(\\d{1,3}(,\\d{3})(\\.\\d+)?)/ })).matches(\n (val) => {\n const asStr = val.replace(/,/g, \"\");\n return parseFloat(asStr);\n }\n ),\n // def(string({ pattern: /-?(\\d{1,3}(\\.\\d{3})(,\\d+)?)/ })).matches(\n // (val) =>{\n // const asStr = val.replace(/\\./g, \"\").replace(/,/g, \".\");\n // return Number(asStr);\n // }\n // ),\n def(string({ in: boolTypesEnabled })).matches(boolEnabled),\n def(string({ in: boolTypesActive })).matches(boolActive),\n fallback((val) => {\n AssertIs(val, \"string\");\n const fromPhrase = Dates.fromPhrase(val);\n if (fromPhrase && !isNaN(fromPhrase.getTime())) {\n return fromPhrase;\n }\n return val.replace(/^\"(.)\"$/, \"$1\").replace(/^'(.*)'$/, \"$1\");\n })\n ).use([value]);\n },\n};\n\nfunction boolActive(val: string): boolean {\n return val === \"active\";\n}\n\nfunction boolEnabled(val: string): boolean {\n return val === \"enabled\";\n}\n\nfunction parseDate(val: string): Date {\n return new Date(Date.parse(val));\n}\n\nfunction trimQuotes(val: string): string {\n return val.slice(1, -1);\n}\n\nfunction parseIso(val: string): Date {\n return DateTime.fromISO(val).toJSDate();\n}\n"],"mappings":"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","names":["chalk","distance","transform","name","regexp","type","primitive","import_overloaded"]}
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/parameter-types.d.ts ADDED Viewed

@@ -0,0 +1,31 @@
+import { ParameterType, ParameterTypeRegistry } from "@cucumber/cucumber-expressions";
+export interface CreateParameterTypesOptions {
+    readonly namespace?: string;
+}
+export interface ParameterTransformContext<World> {
+    readonly raw: readonly string[];
+    readonly world: World;
+    readonly name: string | undefined;
+    readonly originalName: string | undefined;
+    readonly namespace?: string;
+    readonly parameterType: ParameterType<unknown>;
+    readonly definition: ParameterTypeDefinition<World>;
+}
+export type ParameterTransformer<TResult, World> = (value: unknown, context: ParameterTransformContext<World>) => TResult | Promise<TResult>;
+export interface ParameterTypeDefinition<World, TResult = unknown> {
+    readonly name: string;
+    readonly pattern: RegExp | readonly RegExp[];
+    readonly transform?: ParameterTransformer<TResult, World>;
+    readonly useForSnippets?: boolean;
+    readonly preferForRegexpMatch?: boolean;
+    readonly builtin?: boolean;
+}
+export type ParameterTypeDefinitions<World> = ReadonlyArray<ParameterTypeDefinition<World>>;
+export interface DefineParameterTypeFn<World> {
+    (registry: ParameterTypeRegistry, definition: ParameterTypeDefinition<World>): ParameterType<unknown>;
+    many(registry: ParameterTypeRegistry, ...definitions: ParameterTypeDefinitions<World> | [ParameterTypeDefinition<World>]): ParameterTypeRegistry;
+}
+export declare function createParameterTypes<World>(options?: CreateParameterTypesOptions): DefineParameterTypeFn<World>;
+export declare const defineParameterType: DefineParameterTypeFn<unknown>;
+export declare function createDefaultParameterTypes<World>(options?: CreateParameterTypesOptions): (registry: ParameterTypeRegistry) => ParameterTypeRegistry;
+export declare const defineDefaultParameterTypes: (registry: ParameterTypeRegistry) => ParameterTypeRegistry;

package/dist/types.d.ts ADDED Viewed

@@ -0,0 +1,18 @@
+import type { Expression } from "@cucumber/cucumber-expressions";
+export interface CachedStep {
+    readonly keyword: string;
+    readonly type: string;
+    readonly expression: Expression;
+    matches(text: string): boolean;
+}
+export interface StepDiff {
+    readonly merged: string;
+    readonly step: CachedStep;
+    readonly gherkin: string;
+    readonly distance: number;
+}
+export type StepDiffList = StepDiff[];
+export interface LimitedStepDiffs {
+    readonly matchingType: StepDiffList;
+    readonly otherTypes: StepDiffList;
+}

package/package.json CHANGED Viewed

@@ -1,60 +1,63 @@
 {
   "name": "@autometa/cucumber-expressions",
-  "version": "0.4.3",
-  "description": "wrapper on @cucumber/cucumber-expressions",
+  "version": "1.0.0-rc.0",
+  "description": "Cucumber expression helpers and parameter utilities for Autometa",
   "type": "module",
-  "main": "dist/index.js",
-  "module": "dist/esm/index.js",
+  "main": "dist/index.cjs",
+  "module": "dist/index.js",
   "types": "dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
   "exports": {
-    "import": "./dist/esm/index.js",
-    "require": "./dist/index.js",
-    "default": "./dist/esm/index.js",
+    "import": "./dist/index.js",
+    "require": "./dist/index.cjs",
+    "default": "./dist/index.js",
     "types": "./dist/index.d.ts"
   },
   "license": "MIT",
+  "dependencies": {
+    "@cucumber/cucumber-expressions": "^16.1.2",
+    "colorette": "^2.0.19",
+    "diff": "^5.1.0",
+    "luxon": "^3.3.0",
+    "@autometa/app": "1.0.0-rc.0",
+    "@autometa/asserters": "1.0.0-rc.0",
+    "@autometa/datetime": "1.0.0-rc.0",
+    "@autometa/errors": "1.0.0-rc.0",
+    "@autometa/overloaded": "1.0.0-rc.0",
+    "@autometa/types": "1.0.0-rc.0"
+  },
   "devDependencies": {
+    "@types/diff": "^5.0.3",
     "@types/node": "^18.11.18",
-    "@types/strip-color": "^0.1.0",
-    "@types/uuid": "^9.0.5",
     "@typescript-eslint/eslint-plugin": "^5.54.1",
     "@typescript-eslint/parser": "^5.54.1",
-    "@vitest/coverage-istanbul": "^1.4.0",
-    "@vitest/coverage-v8": "^1.4.0",
     "eslint": "^8.37.0",
     "eslint-config-prettier": "^8.3.0",
-    "istanbul": "^0.4.5",
     "rimraf": "^4.1.2",
-    "strip-color": "^0.1.0",
+    "strip-ansi": "^7.1.0",
     "tsup": "^7.2.0",
     "typescript": "^4.9.5",
     "vitest": "1.4.0",
     "eslint-config-custom": "0.6.0",
-    "tsconfig": "0.7.0"
-  },
-  "dependencies": {
-    "@cucumber/cucumber-expressions": "^16.1.2",
-    "@types/diff": "^5.0.3",
-    "@types/luxon": "^3.3.1",
-    "closest-match": "^1.3.3",
-    "colors-cli": "^1.0.32",
-    "diff": "^5.1.0",
-    "luxon": "^3.3.0",
-    "@autometa/asserters": "^0.1.8",
-    "@autometa/datetime": "^0.1.16",
-    "@autometa/overloaded": "^0.3.2",
-    "@autometa/errors": "^0.2.2",
-    "@autometa/types": "^0.4.1",
-    "@autometa/app": "^0.4.1"
+    "tsconfig": "0.7.0",
+    "tsup-config": "0.1.0"
   },
   "scripts": {
+    "type-check": "tsc --noEmit -p tsconfig.dev.json",
+    "type-check:watch": "tsc --noEmit --watch -p tsconfig.dev.json",
+    "build": "tsup && pnpm run build:types",
+    "build:types": "rimraf tsconfig.types.tsbuildinfo && tsc --build tsconfig.types.json",
+    "build:watch": "tsup --watch",
+    "dev": "tsup --watch",
     "test": "vitest run --passWithNoTests",
-    "coverage": "vitest run --coverage",
-    "prettify": "prettier --config .prettierrc 'src/**/*.ts' --write",
+    "test:watch": "vitest --passWithNoTests",
+    "test:ui": "vitest --ui --passWithNoTests",
+    "coverage": "vitest run --coverage --passWithNoTests",
     "lint": "eslint . --max-warnings 0",
     "lint:fix": "eslint . --fix",
-    "clean": "rimraf dist",
-    "build": "tsup",
-    "build:watch": "tsup --watch"
+    "prettify": "prettier --config .prettierrc 'src/**/*.ts' --write",
+    "clean": "rimraf dist"
   }
 }

package/.eslintignore DELETED Viewed

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

package/.eslintrc.cjs DELETED Viewed

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

package/.turbo/turbo-coverage.log DELETED Viewed

@@ -1,45 +0,0 @@
-> @autometa/cucumber-expressions@0.1.2 coverage /Users/ben.aherne/Documents/GitHub/autometa/packages/cucumber-expressions
-> vitest run --coverage
- RUN  v0.29.8 /Users/ben.aherne/Documents/GitHub/autometa/packages/cucumber-expressions
-      Coverage enabled with istanbul
- ✓ src/step-matchers.spec.ts  (13 tests) 47ms
-stdout | src/search-report.spec.ts > SearchReport > should format the match with same step type
-Scenario: a test scenario
-  Steps with matching step type:
-    [4] Given I have {int} blue grapes in my {string}
-stdout | src/search-report.spec.ts > SearchReport > should format the match with different step type
-Scenario: a test scenario
-  Steps with different step type:
-    [4] When I have {int} blue grapes in my {string}
-stdout | src/search-report.spec.ts > SearchReport > should format the match with same and different step type
-Scenario: a test scenario
-  Steps with matching step type:
-    [4] Given I have {int} blue grapes in my {string}
-  Steps with different step type:
-    [4] When I have {int} blue grapes in my {string}
-stdout | src/search-report.spec.ts > SearchReport > should format the match with steps and children with steps
-Feature: a test feature
-  Steps with matching step type:
-    [4] Given I have {int} blue grapes in my {string}
-  Steps with different step type:
-    [2] When I have {int} blue grapes in my {string}
- Scenario: a test scenario
-   Steps with matching step type:
-     [4] Given I have {int} blue grapes in my {string}
-   Steps with different step type:
-     [2] When I have {int} blue grapes in my {string}
- ✓ src/search-report.spec.ts  (6 tests) 73ms
- ✓ src/parameters.spec.ts  (15 tests) 2785ms
- ELIFECYCLE  Command failed.

package/.turbo/turbo-lint$colon$fix.log DELETED Viewed

@@ -1,4 +0,0 @@
-> @autometa/cucumber-expressions@0.3.11 lint:fix /Users/ben.aherne/Documents/GitHub/autometa/packages/cucumber-expressions
-> eslint . --fix "--max-warnings=0"

package/.turbo/turbo-prettify.log DELETED Viewed

File without changes

package/.turbo/turbo-test.log DELETED Viewed

@@ -1,50 +0,0 @@
-> @autometa/cucumber-expressions@0.4.1 test /Users/ben.aherne/Documents/GitHub/autometa/packages/cucumber-expressions
-> vitest run --passWithNoTests
- RUN  v1.4.0 /Users/ben.aherne/Documents/GitHub/autometa/packages/cucumber-expressions
- ✓ src/step-matchers.spec.ts  (13 tests) 45ms
- ✓ src/search-report.spec.ts  (6 tests) 6ms
-stdout | src/search-report.spec.ts > SearchReport > should format the match with same step type
-Scenario: a test scenario
-Steps with matching step type:
-  [4] Given I have {int} blue grapes in my {string}
-stdout | src/search-report.spec.ts > SearchReport > should format the match with different step type
-Scenario: a test scenario
-Steps with different step type:
-  [4] When I have {int} blue grapes in my {string}
-stdout | src/search-report.spec.ts > SearchReport > should format the match with same and different step type
-Scenario: a test scenario
-Steps with matching step type:
-  [4] Given I have {int} blue grapes in my {string}
-  Steps with different step type:
-  [4] When I have {int} blue grapes in my {string}
-stdout | src/search-report.spec.ts > SearchReport > should format the match with steps and children with steps
-Feature: a test feature
-Steps with matching step type:
-  [4] Given I have {int} blue grapes in my {string}
-  Steps with different step type:
-  [2] When I have {int} blue grapes in my {string}
-Scenario: a test scenario
-  Steps with matching step type:
-    [4] Given I have {int} blue grapes in my {string}
-    Steps with different step type:
-    [2] When I have {int} blue grapes in my {string}
- ✓ src/parameters.spec.ts  (15 tests) 2496ms
- ✓ src/default.parameters.spec.ts  (19 tests) 7233ms
- Test Files  4 passed (4)
-      Tests  53 passed (53)
-   Start at  13:56:48
-   Duration  11.91s (transform 1.96s, setup 0ms, collect 8.78s, tests 9.78s, environment 1ms, prepare 3.77s)

package/CHANGELOG.md DELETED Viewed

@@ -1,228 +0,0 @@
-# @autometa/cucumber-expressions
-## 0.4.3
-### Patch Changes
-- Updated dependencies [da669a3]
-  - @autometa/app@0.4.1
-## 0.4.2
-### Patch Changes
-- Updated dependencies [7440e9f]
-  - @autometa/app@0.4.0
-## 0.4.1
-### Patch Changes
-- Updated dependencies [1d3f84e]
-  - @autometa/app@0.3.5
-## 0.4.0
-### Minor Changes
-- 884c9dd: Add support to access App instance from cucumber expression transformer
-## 0.3.11
-### Patch Changes
-- Updated dependencies [3fe2ad4]
-  - @autometa/errors@0.2.2
-  - @autometa/asserters@0.1.8
-  - @autometa/datetime@0.1.16
-## 0.3.10
-### Patch Changes
-- Updated dependencies [3493bb6]
-  - @autometa/errors@0.2.1
-  - @autometa/asserters@0.1.7
-  - @autometa/datetime@0.1.15
-## 0.3.9
-### Patch Changes
-- Updated dependencies [0c070cb]
-  - @autometa/asserters@0.1.6
-  - @autometa/datetime@0.1.14
-## 0.3.8
-### Patch Changes
-- Updated dependencies [6fe8f64]
-  - @autometa/datetime@0.1.13
-## 0.3.7
-### Patch Changes
-- Updated dependencies [b5ce008]
-  - @autometa/errors@0.2.0
-  - @autometa/asserters@0.1.5
-  - @autometa/datetime@0.1.12
-## 0.3.6
-### Patch Changes
-- 04ed85d: feat: added HTP client based on axios
-- Updated dependencies [04ed85d]
-  - @autometa/overloaded@0.3.2
-  - @autometa/asserters@0.1.4
-  - @autometa/datetime@0.1.11
-  - @autometa/errors@0.1.4
-## 0.3.5
-### Patch Changes
-- 020b205: Fix: strings like 'abc123' parsed as numbers in expressions
-## 0.3.4
-### Patch Changes
-- bc3d616: fix: update primitive constructor initialization
-## 0.3.3
-### Patch Changes
-- f8b311e: Fix: Boolean expressions incorrectly parsed
-## 0.3.2
-### Patch Changes
-- Updated dependencies [6dd05a6]
-  - @autometa/datetime@0.1.10
-## 0.3.1
-### Patch Changes
-- 4ee4e99: Fixes strings like 'abc2bd' being parsed as NaN in `primitive` expression type. Not supports comma and decimal delimters (EU, US respectively
-## 0.3.0
-### Minor Changes
-- 329c6b8: Fix: asJson missing from new tables, 'missing' missing from primitive regex's
-## 0.2.2
-### Patch Changes
-- Release Bump
-- Updated dependencies
-  - @autometa/datetime@0.1.9
-## 0.2.1
-### Patch Changes
-- @autometa/datetime@0.1.8
-## 0.2.0
-### Minor Changes
-- 51d88780: Feat: Add Async Test Event support to new runner
-## 0.1.10
-### Patch Changes
-- 5b44aa88: Fix: miscalculated Levenshtein distance when comparing a gherkin step literal to a cucumber expression with a string expression
-## 0.1.9
-### Patch Changes
-- 4af1139a: Fix: fuzzy search for step names prints malformed strings
-## 0.1.8
-### Patch Changes
-- 4bbb87e4: Fix: step search returns literal strings instead of expressions when no exact match is found
-## 0.1.7
-### Patch Changes
-- 53f958e1: Fix: steps not executing onStepEnded event when an error was thrown
-- Updated dependencies [53f958e1]
-  - @autometa/asserters@0.1.3
-  - @autometa/datetime@0.1.7
-  - @autometa/errors@0.1.3
-  - @autometa/types@0.4.1
-## 0.1.6
-### Patch Changes
-- Updated dependencies [12bd4b1e]
-  - @autometa/errors@0.1.2
-  - @autometa/asserters@0.1.2
-  - @autometa/datetime@0.1.6
-## 0.1.5
-### Patch Changes
-- Updated dependencies [e243e8b4]
-  - @autometa/overloaded@0.3.1
-  - @autometa/datetime@0.1.5
-## 0.1.4
-### Patch Changes
-- @autometa/datetime@0.1.4
-## 0.1.3
-### Patch Changes
-- Updated dependencies [e8f02f3a]
-  - @autometa/errors@0.1.1
-  - @autometa/datetime@0.1.3
-  - @autometa/asserters@0.1.1
-## 0.1.2
-### Patch Changes
-- Updated dependencies [a50e99e]
-  - @autometa/datetime@0.1.2
-## 0.1.1
-### Patch Changes
-- Updated dependencies [bf23fc4]
-  - @autometa/datetime@0.1.1
-## 0.1.0
-### Minor Changes
-- 554b77e: Releasing packages
-### Patch Changes
-- Updated dependencies [554b77e]
-  - @autometa/overloaded@0.3.0
-  - @autometa/asserters@0.1.0
-  - @autometa/datetime@0.1.0
-  - @autometa/errors@0.1.0
-  - @autometa/types@0.4.0