harmonyc 0.2.0 → 0.4.1

package/README.md

@@ -1,85 +1,62 @@
-# Harmony Code
-
-A simple model-based test design tool that generates Cucumber feature files.
-
-## Setup
-
-You need to have Node.js installed. Then you can install Harmony Code in your project folder by:
-
-```bash
-npm install harmonyc
-```
-
-And then run it for all `.harmony` files in your `src` folder:
-
-```bash
-harmonyc src/**/*.harmony
-```
-
-This will generate `.feature` files next to the `.harmony` files.
-
-## Syntax
-
-A `.harmony` file is a text file with a syntax that looks like this:
-
-```
-Products API:
-+ Create:
-  + Anonymous:
-    - create product => error: unauthorized
-  + Admin:
-    - authenticate admin
-    - create product => product created
-    - Delete:
-      - delete product => product deleted
-```
-
-Compiling this with `harmonyc` will generate this `.feature` file:
-
-```gherkin
-Feature: products
-
-    Scenario: T1 - Products API - Create - Anonymous
-        When create product -- products
-        Then error: unauthorized -- products
-    
-    Scenario: T2 - Products API - Create - Admin - Delete
-        When authenticate admin -- products
-        When create product -- products
-        Then product created -- products
-        When delete product -- products
-        Then product deleted -- products
-```
-
-### Indentation
-
-The lines of a file are nodes of a tree. The tree is specified with the indentation of the lines, which is n times 2 spaces and a `+` or `-` with one more space. The `+` or `-` sign is considered to be part of the indentation.
-
-### Sequences and forks
-
-`-` means a sequence: the node follows the previous sibling node and its descendants.
-
-`+` means a fork: the node directly follows its parent node. All siblings with `+` are separate branches, they will generate separate scenarios.
-
-### Labels
-
-Label are nodes that end with `:`. You can use them to structure your test design.
-They are not included in the test case, but the test case name is generated from the labels.
-
-### Comments
-
-Lines starting with `#` or `//` are comments and are ignored.
-
-### Steps
-
-All other lines are steps. A step consists of an action, and one or more responses denoted by `=>`.
-Actions will become `When` steps, and responses will become `Then` steps.
-
-
-## Running the tests
-
-Currenlty `harmonyc` only compiles `.harmony` files to `.feature` files. To run the tests, you need to set up Cucumber or Specflow, depending on your environment.
-
-## License
-
-MIT
+# Harmony Code
+
+A test design & BDD tool that helps you separate the _what_ to test from the _how_ to automate it. You write test cases in a simple Markdown format, and then automate them with Vitest (and soon with many more frameworks and languages).
+
+(**Note**: There have been big changes since v0.2.)
+
+## Usage
+
+1. Have Node.js installed.
+2. You can compile your `*.md` files in the `src` folder by running
+
+   ```bash script
+   npx harmonyc src/**/*.md
+   ```
+
+3. Then you can run the generated tests with Vitest by running
+
+   ```bash script
+   npx vitest
+   ```
+
+## Syntax
+
+A Harmony Code file is a Markdown file with a syntax that looks like this:
+
+```markdown
+# Products API
+
+- **Create**:
+  - **Anonymous:**
+    - create product => error: unauthorized
+  - **Admin**:
+    1. authenticate admin
+    2. create product => product created
+    3. **Delete:**
+       - delete product => product deleted
+```
+
+### Actions and responses
+
+List items (either in ordered or bulleted lists) consist of an **action** and zero or more **response**s, separated by a `=>`.
+
+The generated steps contain the feature name after a `||`. Cucumber's steps are in one global namespace, but including the feature name makes it easy to scope step defintions by feature.
+
+### Sequences and forks
+
+An ordered list means a **sequence**: the list items are included int the tests in order.
+
+A bulleted list (`-` or `*` or `+`) means a **fork**: the node directly follows its parent node. All list items are separate branches, they will generate separate scenarios.
+
+### Labels
+
+Label are nodes that end with `:`. You can use them to structure your test design.
+They are not included in the test case, but the test case name is generated from the labels.
+
+### Text
+
+Paragraphs outside of lists are for humans only, they are ignored in the automated tests.
+
+## License
+
+MIT

package/Router.js

@@ -1,14 +1,11 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Routers = exports.Router = void 0;
-const xmur3_1 = require("./util/xmur3");
-class Router {
+import { xmur3 } from './util/xmur3.js';
+export class Router {
     constructor(outs, seed = 'TODO') {
         this.outs = outs;
         this.index = 0;
         this.started = new Set();
         this.covered = new Set();
-        this.random = (0, xmur3_1.xmur3)(seed);
+        this.random = xmur3(seed);
     }
     next() {
         if (this.outs.length === 0)
@@ -22,8 +19,7 @@ class Router {
         return this.outs.length - this.index;
     }
 }
-exports.Router = Router;
-class Routers {
+export class Routers {
     constructor(root) {
         this.root = root;
         this.routers = new Map();
@@ -56,4 +52,3 @@ class Routers {
         return Array.from(this.routers.values()).reduce((sum, r) => sum + r.incompleteCount, 0);
     }
 }
-exports.Routers = Routers;

package/cli.js

@@ -1,10 +1,21 @@
 #!/usr/bin/env node
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const compiler_1 = require("./compiler");
-if (process.argv.length < 3 || process.argv.includes('--help')) {
-    console.error("Usage: harmonyc <input files glob pattern>");
+import { compileFiles } from './compiler.js';
+import { parseArgs } from 'node:util';
+import { watchFiles } from './watch.js';
+const args = parseArgs({
+    options: {
+        help: { type: 'boolean' },
+        watch: { type: 'boolean' },
+    },
+    allowPositionals: true,
+});
+if (args.positionals.length === 0 || args.values.help) {
+    console.error('Usage: harmonyc <input files glob pattern>');
     process.exit(1);
 }
-const args = process.argv.slice(2);
-void (0, compiler_1.compileFiles)(args);
+if (args.values.watch) {
+    void watchFiles(args.positionals);
+}
+else {
+    void compileFiles(args.positionals);
+}

package/compile.js

@@ -1,19 +1,10 @@
-#!/usr/bin/env node
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.compileFeature = void 0;
-const indent_1 = require("./util/indent");
-const model_1 = require("./model");
-const parser_1 = require("./parser");
-function compileFeature(name, src) {
-    const root = (0, parser_1.parse)(src).setFeatureName(name);
-    const tests = (0, model_1.makeTests)(root);
-    const lines = [
-        `Feature: ${name}`,
-        '',
-        ...(0, indent_1.indent)(tests.flatMap((test) => test.toGherkin())),
-    ];
-    lines[0] = `Feature: ${name}`;
-    return lines.join('\n');
+import { NodeTest } from './languages/JavaScript.js';
+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 cg = new NodeTest(of);
+    feature.toCode(cg);
+    return of.value;
 }
-exports.compileFeature = compileFeature;

package/compiler.js

@@ -1,37 +1,18 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.compileFile = exports.compileFiles = void 0;
-const fast_glob_1 = __importDefault(require("fast-glob"));
-const fs_1 = require("fs");
-const path_1 = require("path");
-const compile_1 = require("./compile");
-function compileFiles(pattern) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const fns = yield (0, fast_glob_1.default)(pattern);
-        if (!fns.length)
-            throw new Error(`No files found for pattern: ${String(pattern)}`);
-        yield Promise.all(fns.map((fn) => compileFile(fn)));
-    });
+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);
+    if (!fns.length)
+        throw new Error(`No files found for pattern: ${String(pattern)}`);
+    await Promise.all(fns.map((fn) => compileFile(fn)));
+    console.log(`Compiled ${fns.length} file${fns.length === 1 ? '' : 's'}.`);
+    return fns;
 }
-exports.compileFiles = compileFiles;
-function compileFile(fn) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const src = (0, fs_1.readFileSync)(fn, 'utf8').toString();
-        const name = (0, path_1.basename)(fn).replace(/\.[a-z]+$/i, '');
-        const outFn = fn.replace(/\.[a-z]+$/i, '.feature');
-        (0, fs_1.writeFileSync)(outFn, (0, compile_1.compileFeature)(name, src));
-    });
+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));
 }
-exports.compileFile = compileFile;

package/config.js

@@ -0,0 +1 @@
+export {};

package/definitions.js

@@ -0,0 +1,22 @@
+import { CucumberExpression, ParameterTypeRegistry, } from '@cucumber/cucumber-expressions';
+const registry = new ParameterTypeRegistry();
+export function definitions({ marker, code, feature, }) {
+    var _a, _b;
+    const re = new RegExp(`^\s*${q(marker)}(.*?)$`, 'gm');
+    let match = re.exec(code);
+    const start = (_a = match === null || match === void 0 ? void 0 : match.index) !== null && _a !== void 0 ? _a : code.length;
+    feature.prelude += code.slice(0, start);
+    while (match) {
+        const bodyStart = match.index + match[0].length;
+        const head = match[1].trim();
+        match = re.exec(code);
+        const end = (_b = match === null || match === void 0 ? void 0 : match.index) !== null && _b !== void 0 ? _b : code.length;
+        const body = code.slice(bodyStart, end).trim();
+        if (body) {
+            feature.definitions.set(new CucumberExpression(head, registry), body);
+        }
+    }
+}
+function q(pattern) {
+    return pattern.replace(/[-\/\\^$*+?.()|[\]{}]/g, '\\$&');
+}

package/frameworks/Gherkin.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Gherkin = void 0;
+class Gherkin {
+    constructor(outFile) {
+        this.outFile = outFile;
+    }
+    feature(name, tests) {
+        this.outFile.print(`Feature: ${name}`);
+        this.outFile.print('');
+        this.outFile.indent(() => {
+            for (const test of tests) {
+                test.toCode(this);
+            }
+        });
+    }
+    test(t) {
+        this.outFile.print(`Scenario: ${t.name}`);
+        this.outFile.indent(() => {
+            for (const step of t.steps) {
+                step.toCode(this);
+            }
+        });
+        this.outFile.print('');
+    }
+    phrase(p) {
+        this.outFile.print(`${p.keyword} ${p.text} || ${p.feature}`);
+        if (p.docstring !== undefined) {
+            this.outFile.indent(() => {
+                this.outFile.print(`"""`);
+                this.outFile.print(...p.docstring.split('\n'));
+                this.outFile.print(`"""`);
+            });
+        }
+    }
+}
+exports.Gherkin = Gherkin;

package/frameworks/NodeTest.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NodeTest = void 0;
+class NodeTest {
+    constructor(outFile) {
+        this.outFile = outFile;
+        this.framework = 'vitest';
+    }
+    feature(feature) {
+        if (this.framework === 'vitest') {
+            this.outFile.print(`import { test, expect } from 'vitest';`);
+        }
+        this.outFile.print(feature.prelude);
+        for (const test of feature.tests) {
+            test.toCode(this);
+        }
+    }
+    test(t) {
+        this.outFile.print(`test('${t.name}', async () => {`);
+        this.outFile.indent(() => {
+            for (const step of t.steps) {
+                step.toCode(this);
+            }
+        });
+        this.outFile.print('})');
+        this.outFile.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'));
+    }
+}
+exports.NodeTest = NodeTest;

package/languages/Gherkin.js

@@ -0,0 +1,33 @@
+export class Gherkin {
+    constructor(outFile) {
+        this.outFile = outFile;
+    }
+    feature(feature) {
+        this.outFile.print(`Feature: ${feature.name}`);
+        this.outFile.print('');
+        this.outFile.indent(() => {
+            for (const test of feature.tests) {
+                test.toCode(this);
+            }
+        });
+    }
+    test(t) {
+        this.outFile.print(`Scenario: ${t.name}`);
+        this.outFile.indent(() => {
+            for (const step of t.steps) {
+                step.toCode(this);
+            }
+        });
+        this.outFile.print('');
+    }
+    phrase(p) {
+        this.outFile.print(`${p.keyword} ${p.text} || ${p.feature}`);
+        if (p.docstring !== undefined) {
+            this.outFile.indent(() => {
+                this.outFile.print(`"""`);
+                this.outFile.print(...p.docstring.split('\n'));
+                this.outFile.print(`"""`);
+            });
+        }
+    }
+}

package/languages/JavaScript.js

@@ -0,0 +1,31 @@
+export class NodeTest {
+    constructor(outFile) {
+        this.outFile = outFile;
+        this.framework = 'vitest';
+    }
+    feature(feature) {
+        if (this.framework === 'vitest') {
+            this.outFile.print(`import { test, expect } from 'vitest';`);
+        }
+        this.outFile.print(feature.prelude);
+        for (const test of feature.tests) {
+            test.toCode(this);
+        }
+    }
+    test(t) {
+        this.outFile.print(`test('${t.name}', async () => {`);
+        this.outFile.indent(() => {
+            for (const step of t.steps) {
+                step.toCode(this);
+            }
+        });
+        this.outFile.print('})');
+        this.outFile.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'));
+    }
+}

package/model.js

@@ -1,9 +1,19 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Test = exports.makeTests = exports.Precondition = exports.Response = exports.Action = exports.Phrase = exports.Section = exports.Label = exports.State = exports.Step = exports.Branch = void 0;
-const Router_1 = require("./Router");
-const indent_1 = require("./util/indent");
-class Branch {
+import { Routers } from './Router.js';
+export class Feature {
+    constructor(name) {
+        this.name = name;
+        this.root = new Section();
+        this.definitions = new Map();
+        this.prelude = '';
+    }
+    get tests() {
+        return makeTests(this.root);
+    }
+    toCode(cg) {
+        cg.feature(this);
+    }
+}
+export class Branch {
     constructor(children = []) {
         this.isFork = false;
         this.isEnd = false;
@@ -14,9 +24,9 @@ class Branch {
         this.isFork = isFork;
         return this;
     }
-    setFeatureName(featureName) {
+    setFeature(feature) {
         for (const child of this.children)
-            child.setFeatureName(featureName);
+            child.setFeature(feature);
         return this;
     }
     addChild(child, index = this.children.length) {
@@ -57,85 +67,107 @@ class Branch {
         return (_b = (_a = this.parent) === null || _a === void 0 ? void 0 : _a.children.indexOf(this)) !== null && _b !== void 0 ? _b : -1;
     }
 }
-exports.Branch = Branch;
-class Step extends Branch {
-    constructor(action = '', responses = [], children, isFork = false, featureName = '') {
+export class Step extends Branch {
+    constructor(action = '', responses = [], children, isFork = false) {
         super(children);
-        this.action = new Action(action, featureName);
-        this.responses = responses.map((response) => new Response(response, featureName));
+        this.action = new Action(action);
+        this.responses = responses.map((response) => new Response(response));
         this.isFork = isFork;
     }
     get phrases() {
         return [this.action, ...this.responses];
     }
-    toGherkin() {
-        return this.phrases.flatMap((phrase) => phrase.toGherkin());
+    toCode(cg) {
+        for (const phrase of this.phrases) {
+            phrase.toCode(cg);
+        }
     }
-    setFeatureName(featureName) {
-        this.action.setFeatureName(featureName);
+    setFeature(feature) {
+        this.action.setFeature(feature);
         for (const response of this.responses)
-            response.setFeatureName(featureName);
-        return super.setFeatureName(featureName);
+            response.setFeature(feature);
+        return super.setFeature(feature);
     }
 }
-exports.Step = Step;
-class State {
+export class State {
     constructor(text = '') {
         this.text = text;
     }
 }
-exports.State = State;
-class Label {
+export class Label {
     constructor(text = '') {
         this.text = text;
     }
 }
-exports.Label = Label;
-class Section extends Branch {
+export class Section extends Branch {
     constructor(label = '', children, isFork = false) {
         super(children);
         this.label = new Label(label);
         this.isFork = isFork;
     }
 }
-exports.Section = Section;
-class Phrase {
-    constructor(text = '', featureName = '') {
+export class Phrase {
+    constructor(text = '') {
         this.text = text;
-        this.featureName = featureName;
-    }
-    setFeatureName(featureName) {
-        this.featureName = featureName;
     }
-    toGherkin() {
-        return [`${this.kind === 'action' ? 'When' : 'Then'} ${this.text} -- ${this.featureName}`];
+    setFeature(feature) {
+        this.feature = feature;
+    }
+    get keyword() {
+        return this.kind === 'action' ? 'When' : 'Then';
+    }
+    toCode(cg) {
+        return cg.phrase(this);
+    }
+    definition() {
+        const key = this.kind === 'action' ? this.text : `=> ${this.text}`;
+        let args;
+        let code;
+        for (const [ce, c] of this.feature.definitions.entries()) {
+            const m = ce.match(key);
+            if (!m)
+                continue;
+            if (args !== undefined)
+                throw new Error(`Ambiguous definition: ${key}`);
+            args = m;
+            code = c;
+        }
+        if (args === undefined)
+            return undefined;
+        return code.replace(/\$([$_1-9])/g, (s, varName) => {
+            var _a;
+            if (varName.match(/[1-9]/))
+                return JSON.stringify(args[parseInt(varName) - 1].getValue(undefined));
+            else if (varName === '_')
+                return JSON.stringify((_a = this.docstring) !== null && _a !== void 0 ? _a : '');
+            else if (varName === '$')
+                return '$';
+            else
+                return s;
+        });
     }
 }
-exports.Phrase = Phrase;
-class Action extends Phrase {
+export class Action extends Phrase {
     constructor() {
         super(...arguments);
         this.kind = 'action';
     }
 }
-exports.Action = Action;
-class Response extends Phrase {
+export class Response extends Phrase {
     constructor() {
         super(...arguments);
         this.kind = 'response';
     }
 }
-exports.Response = Response;
-class Precondition extends Branch {
+export class Precondition extends Branch {
     constructor(state = '') {
         super();
         this.state = new State();
         this.state.text = state;
     }
 }
-exports.Precondition = Precondition;
-function makeTests(root) {
-    const routers = new Router_1.Routers(root);
+export function makeTests(root) {
+    const routers = new Routers(root);
     const tests = [];
     let ic = routers.getIncompleteCount();
     let newIc;
@@ -159,8 +191,7 @@ function makeTests(root) {
     tests.forEach((test, i) => (test.testNumber = `T${i + 1}`));
     return tests;
 }
-exports.makeTests = makeTests;
-class Test {
+export class Test {
     constructor(root, branches) {
         this.root = root;
         this.branches = branches;
@@ -176,12 +207,10 @@ class Test {
             .filter((b) => b instanceof Section)
             .map((s) => s.label.text);
     }
-    toGherkin() {
-        return [
-            `Scenario: ${this.testNumber}${this.labels.length > 0 ? ' - ' : ''}${this.labels.join(' - ')}`,
-            ...(0, indent_1.indent)(this.steps.flatMap((b) => b.toGherkin())),
-            '',
-        ];
+    get name() {
+        return `${this.testNumber}${this.labels.length > 0 ? ' - ' : ''}${this.labels.join(' - ')}`;
+    }
+    toCode(cg) {
+        cg.test(this);
     }
 }
-exports.Test = Test;

package/outFile.js

@@ -0,0 +1,45 @@
+import { SourceMapGenerator } from 'source-map-js';
+export class OutFile {
+    constructor(indentSpaces = 2) {
+        this.indentSpaces = indentSpaces;
+        this.lines = [];
+        this.level = 0;
+        this.sm = new SourceMapGenerator();
+    }
+    indent(fn) {
+        this.level++;
+        try {
+            fn();
+        }
+        finally {
+            this.level--;
+        }
+    }
+    print(...lines) {
+        const l = this.lines.length;
+        this.lines.push(...lines.map((line) => ' '.repeat(this.level * this.indentSpaces) + line));
+        if (this.currentLoc)
+            for (const i of lines.keys()) {
+                this.sm.addMapping({
+                    source: this.currentLoc.fileName,
+                    original: {
+                        line: this.currentLoc.line,
+                        column: this.currentLoc.column,
+                    },
+                    generated: {
+                        line: l + i,
+                        column: this.level * this.indentSpaces,
+                    },
+                });
+            }
+        return this;
+    }
+    loc({ location }) {
+        this.currentLoc = location;
+        return this;
+    }
+    get value() {
+        return (this.lines.join('\n') +
+            `\n\n//# sourceMappingURL=data:application/json,${encodeURIComponent(this.sm.toString())}`);
+    }
+}

package/package.json

@@ -1,41 +1,39 @@
-{
-  "name": "harmonyc",
-  "description": "Harmony Code - Test design compiler from high-level model to Gherkin",
-  "version": "0.2.0",
-  "author": "Bernát Kalló",
-  "bin": {
-    "harmonyc": "./cli.js"
-  },
-  "homepage": "https://github.com/harmony-ac/code#readme",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/harmony-ac/code.git"
-  },
-  "bugs": {
-    "url": "https://github.com/harmony-ac/code/issues"
-  },
-  "dependencies": {
-    "fast-glob": "^3.3.2",
-    "typescript-parsec": "0.3.4"
-  },
-  "license": "MIT",
-  "keywords": [
-    "unit test",
-    "unit testing",
-    "cucumber",
-    "bdd",
-    "behavior-driven",
-    "test design",
-    "test design automation",
-    "gherkin",
-    "cucumber",
-    "specflow",
-    "harmony.ac",
-    "test framework",
-    "model-based test",
-    "model-based testing",
-    "test model",
-    "test modeling",
-    "test modelling"
-  ]
-}
+{
+  "name": "harmonyc",
+  "description": "Harmony Code - model-driven BDD for Vitest",
+  "version": "0.4.1",
+  "author": "Bernát Kalló",
+  "type": "module",
+  "bin": {
+    "harmonyc": "./cli.js"
+  },
+  "homepage": "https://github.com/harmony-ac/code#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/harmony-ac/code.git"
+  },
+  "bugs": {
+    "url": "https://github.com/harmony-ac/code/issues"
+  },
+  "dependencies": {
+    "fast-glob": "^3.3.2",
+    "typescript-parsec": "0.3.4"
+  },
+  "license": "MIT",
+  "keywords": [
+    "unit test",
+    "unit testing",
+    "bdd",
+    "behavior-driven",
+    "test design",
+    "test design automation",
+    "harmony.ac",
+    "test framework",
+    "model-based test",
+    "model-based testing",
+    "test model",
+    "test modeling",
+    "test modelling",
+    "vitest"
+  ]
+}

package/syntax.js

@@ -0,0 +1,114 @@
+import remarkParse from 'remark-parse';
+import { unified } from 'unified';
+import { Feature, Section, Step } from './model.js';
+import { definitions } from './definitions.js';
+export function parse({ fileName, src, }) {
+    const tree = unified().use(remarkParse).parse(src);
+    const rootNodes = tree.children;
+    const feature = new Feature('');
+    const headings = [feature.root];
+    let name;
+    for (let i = 0; i < rootNodes.length; i++) {
+        const node = rootNodes[i];
+        if (node.type === 'heading') {
+            if (node.depth === 1 && name === undefined) {
+                name = textContent(node);
+            }
+            const level = node.depth;
+            const section = new Section(textContent(node), [], true);
+            setLocation(section, node, fileName);
+            const last = headings.slice(0, level).reverse().find(Boolean);
+            last.addChild(section);
+            headings[level] = section;
+            headings.length = level + 1;
+        }
+        else {
+            const last = headings[headings.length - 1];
+            for (const branch of topLevel(node))
+                last.addChild(branch);
+        }
+    }
+    feature.name = name !== null && name !== void 0 ? name : fileName;
+    feature.root.setFeature(feature);
+    return feature;
+    function topLevel(node) {
+        if (node.type === 'paragraph')
+            return [];
+        if (node.type == 'list')
+            return list(node);
+        if (node.type === 'code')
+            return code(node);
+        return [];
+    }
+    function list(node) {
+        const isFork = node.ordered === false;
+        return node.children.map((item) => listItem(item, isFork));
+    }
+    function code(node) {
+        var _a;
+        if (!((_a = node.meta) === null || _a === void 0 ? void 0 : _a.match(/harmony/)))
+            return [];
+        const code = node.value;
+        const marker = '///';
+        definitions({ marker, code, feature });
+        return [];
+    }
+    function listItem(node, isFork) {
+        const first = node.children[0];
+        const text = textContent(first);
+        let branch;
+        if (first.type === 'heading') {
+            branch = new Section(text, [], isFork);
+        }
+        else {
+            const [action, ...responses] = text.split(/(?:^| )=>(?: |$)/);
+            const step = (branch = new Step(action, responses.filter(Boolean), [], isFork));
+            setLocation(step.action, first, fileName);
+            for (const response of step.responses) {
+                // todo separate locations along =>'s
+                setLocation(response, first, fileName);
+            }
+            let i = 0;
+            for (const child of node.children.slice(1)) {
+                if (child.type === 'list')
+                    break;
+                if (child.type === 'code') {
+                    if (step.phrases[i])
+                        step.phrases[i].docstring = child.value;
+                    else
+                        break;
+                    ++i;
+                }
+            }
+        }
+        for (const child of node.children) {
+            if (child.type === 'list') {
+                for (const b of list(child))
+                    branch.addChild(b);
+            }
+        }
+        setLocation(branch, node, fileName);
+        return branch;
+    }
+}
+function textContent(node) {
+    if (!node)
+        return '';
+    if (node.type === 'text') {
+        return node.value.split(/\s+/).filter(Boolean).join(' ');
+    }
+    if (node.type === 'list')
+        return '';
+    if (!('children' in node))
+        return '';
+    return node.children.map(textContent).filter(Boolean).join(' ');
+}
+function setLocation(model, node, fileName) {
+    if (!node.position)
+        return;
+    model.location = {
+        line: node.position.start.line,
+        column: node.position.start.column,
+        fileName,
+    };
+}

package/util/indent.js

@@ -1,7 +1,5 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.indent = void 0;
-function indent(lines) {
-    return lines.map((line) => `    ${line}`);
-}
-exports.indent = indent;
+export const Indent = (n) => function* indent(lines) {
+    for (const line of lines) {
+        yield ' '.repeat(n) + line;
+    }
+};

package/util/iterators.js

@@ -0,0 +1,5 @@
+export function* flatMap(iterable, callback) {
+    for (const value of iterable) {
+        yield* callback(value);
+    }
+}

package/util/xmur3.js

@@ -1,8 +1,5 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.xmur3 = void 0;
 // https://stackoverflow.com/revisions/47593316/25 by bryc (github.com/bryc)
-function xmur3(str) {
+export function xmur3(str) {
     let h = 1779033703 ^ str.length;
     for (let i = 0; i < str.length; i++)
         (h = Math.imul(h ^ str.charCodeAt(i), 3432918353)),
@@ -13,4 +10,3 @@ function xmur3(str) {
         return (h ^= h >>> 16) >>> 0;
     };
 }
-exports.xmur3 = xmur3;

package/watch.js

@@ -0,0 +1,10 @@
+import { watch } from 'node:fs';
+import { compileFile, compileFiles } from './compiler.js';
+export async function watchFiles(patterns) {
+    const fns = await compileFiles(patterns);
+    for (const file of fns) {
+        watch(file, () => {
+            compileFile(file);
+        });
+    }
+}

package/lexer.js

@@ -1,31 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.lexer = exports.T = void 0;
-const typescript_parsec_1 = require("typescript-parsec");
-var T;
-(function (T) {
-    T[T["Newline"] = 0] = "Newline";
-    T[T["EOF"] = 1] = "EOF";
-    T[T["Comment"] = 2] = "Comment";
-    T[T["Dent"] = 3] = "Dent";
-    T[T["Seq"] = 4] = "Seq";
-    T[T["Fork"] = 5] = "Fork";
-    T[T["State"] = 6] = "State";
-    T[T["Label"] = 7] = "Label";
-    T[T["ResponseMark"] = 8] = "ResponseMark";
-    T[T["Phrase"] = 9] = "Phrase";
-    T[T["Space"] = 10] = "Space";
-})(T || (exports.T = T = {}));
-exports.lexer = (0, typescript_parsec_1.buildLexer)([
-    [false, /^\s*\n/g, T.Newline],
-    [false, /^\s*$/g, T.EOF],
-    [false, /^#.*?(?=\n|$)/g, T.Comment],
-    [false, /^\/\/.*?(?=\n|$)/g, T.Comment],
-    [true, /^ {2}/g, T.Dent],
-    [true, /^- /g, T.Seq],
-    [true, /^\+ /g, T.Fork],
-    [true, /^\[\s*.*?\s*\]/g, T.State],
-    [true, /^[^-+\s[][^\n[]*?\s*:(?=\s*(?:\n|$))/g, T.Label],
-    [true, /^\s*=>\s*/g, T.ResponseMark],
-    [true, /^[^-+\s[][^\n[]*?(?=\s*(?:\n|$|\[|=>))/g, T.Phrase],
-]);

package/parser.js

@@ -1,68 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.parse = void 0;
-const typescript_parsec_1 = require("typescript-parsec");
-const lexer_1 = require("./lexer");
-const model_1 = require("./model");
-function parse(input) {
-    const tokens = lexer_1.lexer.parse(input);
-    return (0, typescript_parsec_1.expectSingleResult)((0, typescript_parsec_1.expectEOF)(TEST_DESIGN.parse(tokens)));
-}
-exports.parse = parse;
-const PHRASE = (0, typescript_parsec_1.rule)();
-PHRASE.setPattern((0, typescript_parsec_1.apply)((0, typescript_parsec_1.tok)(lexer_1.T.Phrase), ({ text }) => text));
-const STEP = (0, typescript_parsec_1.rule)();
-STEP.setPattern((0, typescript_parsec_1.apply)((0, typescript_parsec_1.seq)(PHRASE, (0, typescript_parsec_1.rep_sc)((0, typescript_parsec_1.kright)((0, typescript_parsec_1.tok)(lexer_1.T.ResponseMark), PHRASE))), ([action, responses]) => new model_1.Step(action, responses).setFork(true)));
-const SECTION = (0, typescript_parsec_1.rule)();
-SECTION.setPattern((0, typescript_parsec_1.apply)((0, typescript_parsec_1.tok)(lexer_1.T.Label), ({ text }) => new model_1.Section(text.slice(0, -1))));
-const BRANCH = (0, typescript_parsec_1.rule)();
-BRANCH.setPattern((0, typescript_parsec_1.alt_sc)(STEP, SECTION));
-const DENTS = (0, typescript_parsec_1.rule)();
-DENTS.setPattern((0, typescript_parsec_1.apply)((0, typescript_parsec_1.opt_sc)((0, typescript_parsec_1.seq)((0, typescript_parsec_1.rep_sc)((0, typescript_parsec_1.tok)(lexer_1.T.Dent)), (0, typescript_parsec_1.alt_sc)((0, typescript_parsec_1.tok)(lexer_1.T.Seq), (0, typescript_parsec_1.tok)(lexer_1.T.Fork)))), (lineHead) => {
-    if (!lineHead)
-        return { dent: 0, isFork: true };
-    const [dents, seqOrFork] = lineHead;
-    return { dent: dents.length + 1, isFork: seqOrFork.kind === lexer_1.T.Fork };
-}));
-const LINE = (0, typescript_parsec_1.rule)();
-LINE.setPattern((0, typescript_parsec_1.apply)((0, typescript_parsec_1.seq)(DENTS, BRANCH), ([{ dent, isFork }, branch], [start, end]) => ({
-    dent,
-    branch: branch.setFork(isFork),
-})));
-const TEST_DESIGN = (0, typescript_parsec_1.rule)();
-TEST_DESIGN.setPattern((0, typescript_parsec_1.apply)((0, typescript_parsec_1.rep_sc)(LINE), (lines) => {
-    const startDent = 0;
-    let dent = startDent;
-    const root = new model_1.Section();
-    let parent = root;
-    let lineNo = 0;
-    for (const { dent: d, branch } of lines) {
-        ++lineNo;
-        if (d > dent + 1) {
-            throw new Error(`invalid indent ${d} at line ${lineNo}`);
-        }
-        else if (d === dent + 1) {
-            parent = parent.children[parent.children.length - 1];
-            ++dent;
-        }
-        else if (d < startDent) {
-            throw new Error(`invalid indent at line ${lineNo}`);
-        }
-        else
-            while (d < dent) {
-                parent = parent.parent;
-                --dent;
-            }
-        parent.addChild(branch);
-    }
-    return root;
-}));
-function inputText(start, end) {
-    let text = '';
-    let t = start;
-    while (t && t !== end) {
-        text += t.text;
-        t = t.next;
-    }
-    return text;
-}