harmonyc 0.5.0 → 0.6.0-1

package/compile.js

@@ -3,8 +3,9 @@ import { OutFile } from './outFile.js';
 import { parse } from './syntax.js';
 export function compileFeature(fileName, src) {
     const feature = parse({ fileName, src });
-    const of = new OutFile();
+    const outFn = `${fileName.replace(/\.[a-z]+$/i, '')}.mjs`;
+    const of = new OutFile(outFn);
     const cg = new NodeTest(of);
     feature.toCode(cg);
-    return of.value;
+    return of;
 }

package/compiler.js

@@ -1,6 +1,5 @@
 import glob from 'fast-glob';
 import { readFileSync, writeFileSync } from 'fs';
-import { basename } from 'path';
 import { compileFeature } from './compile.js';
 export async function compileFiles(pattern) {
     const fns = await glob(pattern);
@@ -12,8 +11,7 @@ export async function compileFiles(pattern) {
 }
 export async function compileFile(fn) {
     const src = readFileSync(fn, 'utf8').toString();
-    const name = basename(fn).replace(/\.[a-z]+$/i, '');
-    const outFn = `${fn.replace(/\.[a-z]+$/i, '')}.mjs`;
-    writeFileSync(outFn, compileFeature(fn, src));
-    return outFn;
+    const outFile = compileFeature(fn, src);
+    writeFileSync(outFile.name, outFile.value);
+    return outFile.name;
 }

package/js_api/js_api.js

@@ -0,0 +1,59 @@
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _FeatureContext_defs, _FeatureContext_parameterTypeRegistry;
+import { CucumberExpression, ParameterTypeRegistry, } from '@cucumber/cucumber-expressions';
+class Definition {
+    constructor(expr, fn) {
+        this.expr = expr;
+        this.fn = fn;
+    }
+}
+const features = new Map();
+class FeatureContext {
+    constructor() {
+        _FeatureContext_defs.set(this, []);
+        _FeatureContext_parameterTypeRegistry.set(this, new ParameterTypeRegistry());
+        this.Action = ((s, fn) => {
+            if (fn) {
+                const expr = new CucumberExpression(s, __classPrivateFieldGet(this, _FeatureContext_parameterTypeRegistry, "f"));
+                const def = new Definition(expr, fn);
+                __classPrivateFieldGet(this, _FeatureContext_defs, "f").push(def);
+                return;
+            }
+            // call the action
+            const matches = __classPrivateFieldGet(this, _FeatureContext_defs, "f").map((def) => def.expr.match(s));
+            const matching = [...matches.keys()].filter((i) => matches[i]);
+            if (matching.length === 0) {
+                throw new Error(`Not defined: ${s}`);
+            }
+            if (matching.length > 1) {
+                throw new Error(`Ambiguous: ${s}\n${matching
+                    .map((i) => __classPrivateFieldGet(this, _FeatureContext_defs, "f")[i].expr.source)
+                    .join('\n')}`);
+            }
+            const match = matches[matching[0]];
+            const def = __classPrivateFieldGet(this, _FeatureContext_defs, "f")[matching[0]];
+            return Promise.resolve(def.fn(...match.map((m) => m.getValue(undefined))));
+        });
+        this.Response = this.Action;
+    }
+}
+_FeatureContext_defs = new WeakMap(), _FeatureContext_parameterTypeRegistry = new WeakMap();
+export function Feature(s, fn) {
+    let ctx;
+    if (!fn) {
+        ctx = features.get(s);
+        if (!ctx)
+            throw new Error(`Feature not found: ${s}`);
+    }
+    else {
+        // redefine the feature
+        ctx = new FeatureContext();
+        features.set(s, ctx);
+    }
+    fn === null || fn === void 0 ? void 0 : fn(ctx);
+    return ctx;
+}

package/languages/JavaScript.js

@@ -1,31 +1,41 @@
+import { basename } from 'path';
 export class NodeTest {
-    constructor(outFile) {
-        this.outFile = outFile;
+    constructor(of) {
+        this.of = of;
         this.framework = 'vitest';
+        this.phrases = [];
     }
     feature(feature) {
+        const stepsModule = './' +
+            basename(this.of.name.replace(/(\.(spec|test)s?)?\.[a-z]+$/i, '.steps'));
+        this.phrases = [];
         if (this.framework === 'vitest') {
-            this.outFile.print(`import { test, expect } from 'vitest';`);
+            this.of.print(`import { test, expect } from 'vitest';`);
+            this.of.print(`import { Feature } from 'harmonyc/test';`);
+            this.of.print(`import ${JSON.stringify(stepsModule)};`);
         }
-        this.outFile.print(feature.prelude);
+        this.of.print(feature.prelude);
         for (const test of feature.tests) {
             test.toCode(this);
         }
     }
     test(t) {
-        this.outFile.print(`test('${t.name}', async () => {`);
-        this.outFile.indent(() => {
+        this.of.print(`test('${t.name}', async (context) => {`);
+        this.of.indent(() => {
             for (const step of t.steps) {
                 step.toCode(this);
             }
         });
-        this.outFile.print('})');
-        this.outFile.print('');
+        this.of.print('})');
+        this.of.print('');
     }
     phrase(p) {
-        var _a;
-        this.outFile.loc(p).print('/// ' + p.text);
-        const code = (_a = p.definition()) !== null && _a !== void 0 ? _a : `throw 'Not defined: ' + ${JSON.stringify(p.text)};`;
-        this.outFile.print(...code.split('\n'));
+        if (!this.phrases.some((x) => x.text === p.text))
+            this.phrases.push(p);
+        const feature = p.feature.name;
+        this.of.print(`await Feature(${JSON.stringify(feature)}).${capitalize(p.kind)}(${JSON.stringify(p.text)})`);
     }
 }
+function capitalize(s) {
+    return s.charAt(0).toUpperCase() + s.slice(1);
+}

package/outFile.js

@@ -1,10 +1,11 @@
 import { SourceMapGenerator } from 'source-map-js';
 export class OutFile {
-    constructor(indentSpaces = 2) {
-        this.indentSpaces = indentSpaces;
+    constructor(name) {
+        this.name = name;
         this.lines = [];
         this.level = 0;
         this.sm = new SourceMapGenerator();
+        this.indentSpaces = 2;
     }
     indent(fn) {
         this.level++;

package/package.json

@@ -1,12 +1,18 @@
 {
   "name": "harmonyc",
   "description": "Harmony Code - model-driven BDD for Vitest",
-  "version": "0.5.0",
+  "version": "0.6.0-1",
   "author": "Bernát Kalló",
   "type": "module",
   "bin": {
     "harmonyc": "./cli.js"
   },
+  "exports": {
+    "./test": {
+      "types": "./test.d.ts",
+      "default": "./dist/js_api/js_api.js"
+    }
+  },
   "homepage": "https://github.com/harmony-ac/code#readme",
   "repository": {
     "type": "git",

package/test.d.ts

@@ -0,0 +1,7 @@
+type FeatureContext = {
+  Action(s: string): Promise<void>
+  Action(s: string, fn: Function): void
+  Response(s: string): Promise<void>
+  Response(s: string, fn: Function): void
+}
+export function Feature(name: string, fn: (ctx: FeatureContext) => void): void