harmonyc 0.16.3 → 0.17.0

package/README.md

@@ -1,6 +1,6 @@
 # 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 easy-to-read format, and then automate them with Vitest (and soon with other frameworks and languages).
+A test design & BDD tool that helps you separate _what_ you test and _how_ you automate it. You write test cases in a simple easy-to-read format, and then automate them with Vitest.
 
 ## Setup
 
@@ -10,23 +10,24 @@ You need to have Node.js installed. Then you can install Harmony Code in your pr
 npm install harmonyc
 ```
 
-Then add it to your `vitest.config.js` or `vite.config.js` file, and specify which folder to watch for `.harmony` files:
+Then add it as a plugin to your `vitest.config.js` or `vite.config.js` file, and make sure to include your `.harmony` files:
 
 ```js
 import harmony from 'harmonyc/vitest'
 
 export default {
-  plugins: [harmony({ watchDir: 'src' })],
+  plugins: [harmony()],
+  include: ['src/**/*.harmony'],
 }
 ```
 
-You can run it manually for all `.harmony` files in your `src` folder:
+This will run .harmony files in vitest.
 
-```bash
-harmonyc src/**/*.harmony
-```
+## VSCode plugin
+
+Harmony Code has a [VSCode plugin](https://marketplace.visualstudio.com/items?itemName=harmony-ac.harmony-code) that supports syntax highlighting.
 
-This will generate `.test.mjs` files next to the `.harmony` files, and generate empty definition files for you.
+Harmony Code is compatible with Vitest's VSCode plugin, so you can run and debug tests from the editor.
 
 ## Syntax
 
@@ -77,12 +78,12 @@ becomes
 
 ```javascript
 test('T1 - strings', async () => {
-  const P = new Phrases();
-  await P.When_hello_("John");
+  const P = new Phrases()
+  await P.When_hello_('John')
 })
 test('T2 - code fragment', async () => {
-  const P = new Phrases();
-  await P.When_greet__times(3);
+  const P = new Phrases()
+  await P.When_greet__times(3)
 })
 ```
 
@@ -95,6 +96,14 @@ They are not included in the test case, but the test case name is generated from
 
 Lines starting with `#` or `//` are comments and are ignored.
 
+### Switches
+
+You can generate multiple test cases by adding a `{ A / B / C }` syntax into action(s) and possibly response(s).
+
+```harmony
++ password is { "A" / "asdf" / "password123" } => !! "password is too weak"
+```
+
 ### Error matching
 
 You can use `!!` to denote an error response. This will verify that the action throws an error. You can specify the error message after the `!!`.
@@ -128,8 +137,6 @@ test('T2 - store result in variable', (context) => {
 })
 ```
 
-## Running the tests
-
 ## License
 
 MIT

package/code_generator/VitestGenerator.d.ts

@@ -3,11 +3,12 @@ import { OutFile } from './outFile.ts';
 export declare class VitestGenerator implements CodeGenerator {
     private tf;
     private sf;
+    private _sourceFileName;
     static error(message: string, stack: string): string;
     framework: string;
     phraseFns: Map<string, Phrase>;
     currentFeatureName: string;
-    constructor(tf: OutFile, sf: OutFile);
+    constructor(tf: OutFile, sf: OutFile, _sourceFileName: string);
     feature(feature: Feature): void;
     testGroup(g: TestGroup): void;
     featureVars: Map<string, string>;

package/code_generator/VitestGenerator.js

@@ -2,14 +2,15 @@ import { basename } from 'path';
 import { Arg, Response, Word, } from "../model/model.js";
 export class VitestGenerator {
     static error(message, stack) {
-        return `const e = new SyntaxError(${str(message)});
-    e.stack = undefined;
-    throw e;
+        return `const e = new SyntaxError(${str(message)});
+    e.stack = undefined;
+    throw e;
     ${stack ? `/* ${stack} */` : ''}`;
     }
-    constructor(tf, sf) {
+    constructor(tf, sf, _sourceFileName) {
         this.tf = tf;
         this.sf = sf;
+        this._sourceFileName = _sourceFileName;
         this.framework = 'vitest';
         this.phraseFns = new Map();
         this.currentFeatureName = '';
@@ -20,6 +21,7 @@ export class VitestGenerator {
         const phrasesModule = './' + basename(this.sf.name.replace(/.(js|ts)$/, ''));
         const fn = (this.currentFeatureName = pascalCase(feature.name));
         this.phraseFns = new Map();
+        // test file
         if (this.framework === 'vitest') {
             this.tf.print(`import { describe, test, expect } from "vitest";`);
         }
@@ -33,6 +35,8 @@ export class VitestGenerator {
         for (const item of feature.testGroups) {
             item.toCode(this);
         }
+        this.tf.print(``);
+        // phrases file
         this.sf.print(`export default class ${pascalCase(feature.name)}Phrases {`);
         this.sf.indent(() => {
             for (const ph of this.phraseFns.keys()) {
@@ -48,7 +52,7 @@ export class VitestGenerator {
         this.sf.print(`};`);
     }
     testGroup(g) {
-        this.tf.print(`describe(${str(g.name)}, () => {`);
+        this.tf.print(`describe(${str(g.label.text)}, () => {`, g.label.start, g.label.text);
         this.tf.indent(() => {
             for (const item of g.items) {
                 item.toCode(this);
@@ -57,11 +61,12 @@ export class VitestGenerator {
         this.tf.print('});');
     }
     test(t) {
+        var _a;
         this.resultCount = 0;
         this.featureVars = new Map();
         // avoid shadowing this import name
         this.featureVars.set(new Object(), this.currentFeatureName);
-        this.tf.print(`test(${str(t.name)}, async (context) => {`);
+        this.tf.print(`test(${str(t.name)}, async (context) => {`, (_a = t.lastStrain) === null || _a === void 0 ? void 0 : _a.start, t.testNumber);
         this.tf.indent(() => {
             this.tf.print(`context.task.meta.phrases ??= [];`);
             for (const step of t.steps) {
@@ -72,10 +77,10 @@ export class VitestGenerator {
     }
     errorStep(action, errorResponse) {
         this.declareFeatureVariables([action]);
-        this.tf.print(`context.task.meta.phrases.push(${str(errorResponse.toSingleLineString())});`);
         this.tf.print(`await expect(async () => {`);
         this.tf.indent(() => {
             action.toCode(this);
+            this.tf.print(`context.task.meta.phrases.push(${str(errorResponse.toSingleLineString())});`);
         });
         this.tf.print(`}).rejects.toThrow(${(errorResponse === null || errorResponse === void 0 ? void 0 : errorResponse.message) !== undefined
             ? str(errorResponse.message.text)
@@ -128,11 +133,12 @@ export class VitestGenerator {
         if (p instanceof Response && p.parts.length === 1 && p.saveToVariable) {
             return this.saveToVariable(p.saveToVariable);
         }
-        this.tf.print(`(context.task.meta.phrases.push(${str(p.toString())}),`);
+        const name = p.toSingleLineString();
+        this.tf.print(`(context.task.meta.phrases.push(${str(p.toString())}),`, p.start, name);
         if (p instanceof Response && p.saveToVariable) {
             this.saveToVariable(p.saveToVariable, '');
         }
-        this.tf.print(`await ${f}.${functionName(p)}(${args.join(', ')}));`);
+        this.tf.print(`await ${f}.${functionName(p)}(${args.join(', ')}));`, p.start, name);
     }
     setVariable(action) {
         this.tf.print(`(context.task.meta.variables ??= {})[${str(action.variableName)}] = ${action.value.toCode(this)};`);

package/code_generator/outFile.d.ts

@@ -1,17 +1,27 @@
+import { SourceNode } from 'source-map-js';
 import { Location } from '../model/model.ts';
-import { SourceMapGenerator } from 'source-map-js';
 export declare class OutFile {
     name: string;
+    sourceFile: string;
     lines: string[];
     level: number;
-    sm: SourceMapGenerator;
+    sm: SourceNode;
     indentSpaces: number;
-    private currentLoc;
-    constructor(name: string);
+    constructor(name: string, sourceFile: string);
     indent(fn: () => void): void;
-    print(...lines: string[]): this;
-    loc({ location }: {
-        location?: Location;
-    }): this;
+    clear(): void;
+    append(s: string): void;
+    print(line: string, start?: Location, name?: string, end?: Location): this;
+    loc(location: Location | undefined, name?: string): this;
+    get sourceMap(): import("source-map-js").RawSourceMap;
+    get valueWithoutSourceMap(): string;
     get value(): string;
+    get currentLineEnd(): {
+        line: number;
+        column: number;
+    };
+    get currentLineStart(): {
+        line: number;
+        column: number;
+    };
 }

package/code_generator/outFile.js

@@ -1,11 +1,12 @@
-import { SourceMapGenerator } from 'source-map-js';
+import { SourceNode } from 'source-map-js';
 export class OutFile {
-    constructor(name) {
+    constructor(name, sourceFile) {
         this.name = name;
+        this.sourceFile = sourceFile;
         this.lines = [];
         this.level = 0;
-        this.sm = new SourceMapGenerator();
         this.indentSpaces = 2;
+        this.sm = new SourceNode(0, 0, sourceFile);
     }
     indent(fn) {
         this.level++;
@@ -16,36 +17,59 @@ export class OutFile {
             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,
-                    },
-                });
-            }
+    clear() {
+        this.sm = new SourceNode(0, 0, this.sourceFile);
+    }
+    append(s) {
+        if (this.lines.length === 0)
+            this.lines.push('');
+        this.lines[this.lines.length - 1] += s;
+    }
+    print(line, start, name, end) {
+        const chunk = ' '.repeat(this.level * this.indentSpaces) + line + '\n';
+        this.lines.push(chunk);
+        if (start) {
+            this.sm.add(new SourceNode(start.line, start.column, this.sourceFile, chunk, name));
+        }
+        else {
+            this.sm.add(new SourceNode(null, null, null, chunk));
+        }
+        if (end) {
+            this.sm.add(new SourceNode(end.line, end.column, this.sourceFile));
+        }
         return this;
     }
-    loc({ location }) {
-        this.currentLoc = location;
+    loc(location, name) {
+        if (!location)
+            return this;
         return this;
     }
+    get sourceMap() {
+        return this.sm.toStringWithSourceMap({ file: this.name }).map.toJSON();
+    }
+    get valueWithoutSourceMap() {
+        return this.sm.toString();
+    }
     get value() {
-        let res = this.lines.join('\n');
-        if (this.currentLoc) {
-            res +=
-                `\n\n//# sour` + // not for this file ;)
-                    `ceMappingURL=data:application/json,${encodeURIComponent(this.sm.toString())}`;
-        }
+        const { code, map } = this.sm.toStringWithSourceMap({ file: this.name });
+        let res = code;
+        res +=
+            `\n//# sour` + // not for this file ;)
+                `ceMappingURL=data:application/json,${encodeURIComponent(map.toString())}`;
         return res;
     }
+    get currentLineEnd() {
+        var _a, _b;
+        return {
+            line: this.lines.length,
+            column: (_b = (_a = this.lines.at(-1)) === null || _a === void 0 ? void 0 : _a.length) !== null && _b !== void 0 ? _b : 0,
+        };
+    }
+    get currentLineStart() {
+        var _a, _b, _c;
+        return {
+            line: this.lines.length + 1,
+            column: (_c = (_b = (_a = this.lines.at(-1)) === null || _a === void 0 ? void 0 : _a.match(/^\s*/)) === null || _b === void 0 ? void 0 : _b[0].length) !== null && _c !== void 0 ? _c : 0,
+        };
+    }
 }

package/compiler/compile.js

@@ -1,10 +1,10 @@
+import { basename } from 'node:path';
 import { VitestGenerator } from "../code_generator/VitestGenerator.js";
 import { OutFile } from "../code_generator/outFile.js";
-import { parse } from "../parser/parser.js";
 import { base, phrasesFileName, testFileName } from "../filenames/filenames.js";
 import { Feature } from "../model/model.js";
-import { basename } from 'node:path';
 import { autoLabel } from "../optimizations/autoLabel/autoLabel.js";
+import { parse } from "../parser/parser.js";
 export function compileFeature(fileName, src) {
     const feature = new Feature(basename(base(fileName)));
     try {
@@ -13,20 +13,20 @@ export function compileFeature(fileName, src) {
     catch (e) {
         if (e.pos && e.errorMessage) {
             e.message =
-                e.stack = `Error in ${fileName}:${e.pos.rowBegin}:${e.pos.columnBegin}\n${e.errorMessage}`;
+                e.stack = `Error in ${fileName}:${e.pos.rowBegin}:${e.pos.columnBegin}: ${e.errorMessage}`;
         }
         else {
-            e.stack = `Error in ${fileName}\n${e.stack}`;
+            e.stack = `Error in ${fileName}: ${e.stack}`;
         }
         throw e;
     }
     feature.root.setFeature(feature);
     autoLabel(feature.root);
     const testFn = testFileName(fileName);
-    const testFile = new OutFile(testFn);
+    const testFile = new OutFile(testFn, fileName);
     const phrasesFn = phrasesFileName(fileName);
-    const phrasesFile = new OutFile(phrasesFn);
-    const cg = new VitestGenerator(testFile, phrasesFile);
+    const phrasesFile = new OutFile(phrasesFn, fileName);
+    const cg = new VitestGenerator(testFile, phrasesFile, fileName);
     feature.toCode(cg);
     return { outFile: testFile, phrasesFile };
 }

package/compiler/compiler.d.ts

@@ -7,3 +7,4 @@ export declare function compileFile(fn: string): Promise<{
     outFile: import("../code_generator/outFile.ts").OutFile;
     phrasesFile: import("../code_generator/outFile.ts").OutFile;
 } | undefined>;
+export declare function preprocess(src: string): string;

package/compiler/compiler.js

@@ -1,9 +1,9 @@
 import glob from 'fast-glob';
 import { existsSync, readFileSync, writeFileSync } from 'fs';
 import { resolve } from 'path';
-import { compileFeature } from "./compile.js";
-import { testFileName } from "../filenames/filenames.js";
 import { VitestGenerator } from "../code_generator/VitestGenerator.js";
+import { testFileName } from "../filenames/filenames.js";
+import { compileFeature } from "./compile.js";
 export async function compileFiles(pattern) {
     var _a;
     const fns = await glob(pattern);
@@ -26,10 +26,7 @@ export async function compileFiles(pattern) {
 export async function compileFile(fn) {
     var _a;
     fn = resolve(fn);
-    const src = readFileSync(fn, 'utf8')
-        .toString()
-        .replace(/\r\n/g, '\n')
-        .replace(/\r/g, '\n');
+    const src = preprocess(readFileSync(fn, 'utf8').toString());
     try {
         const { outFile, phrasesFile } = compileFeature(fn, src);
         writeFileSync(outFile.name, outFile.value);
@@ -46,3 +43,11 @@ export async function compileFile(fn) {
         return undefined;
     }
 }
+export function preprocess(src) {
+    // strip BOM
+    if (src.charCodeAt(0) === 0xfeff) {
+        src = src.slice(1);
+    }
+    src = src.replace(/\r\n?/g, '\n');
+    return src;
+}

package/model/model.d.ts

@@ -1,3 +1,4 @@
+import { Token } from 'typescript-parsec';
 export interface CodeGenerator {
     feature(feature: Feature): void;
     testGroup(group: TestGroup): void;
@@ -17,7 +18,6 @@ export interface CodeGenerator {
 export interface Location {
     line: number;
     column: number;
-    fileName: string;
 }
 export declare class Feature {
     name: string;
@@ -28,7 +28,19 @@ export declare class Feature {
     get testGroups(): (TestGroup | Test)[];
     toCode(cg: CodeGenerator): void;
 }
-export declare abstract class Branch {
+export declare abstract class Node {
+    start?: {
+        line: number;
+        column: number;
+    };
+    end?: {
+        line: number;
+        column: number;
+    };
+    at([startToken, endToken]: [Token<any> | undefined, Token<any> | undefined]): this;
+    atSameAs(other: Node): this;
+}
+export declare abstract class Branch extends Node {
     parent?: Branch;
     children: Branch[];
     isFork: boolean;
@@ -65,7 +77,7 @@ export declare class State {
     text: string;
     constructor(text?: string);
 }
-export declare class Label {
+export declare class Label extends Node {
     text: string;
     constructor(text?: string);
     get isEmpty(): boolean;
@@ -131,10 +143,9 @@ export declare class CodeLiteral extends Arg {
     toCode(cg: CodeGenerator): string;
     toDeclaration(cg: CodeGenerator, index: number): string;
 }
-export declare abstract class Phrase {
+export declare abstract class Phrase extends Node {
     parts: Part[];
     feature: Feature;
-    location?: Location;
     abstract get kind(): string;
     constructor(parts: Part[]);
     setFeature(feature: Feature): this;
@@ -186,10 +197,11 @@ export declare function makeTests(root: Branch): Test[];
 export declare class Test {
     branches: Branch[];
     testNumber?: string;
-    labels: string[];
+    labels: Label[];
     constructor(branches: Branch[]);
     get steps(): Step[];
-    get last(): Step;
+    get last(): Step | undefined;
+    get lastStrain(): Branch | undefined;
     get name(): string;
     toCode(cg: CodeGenerator): void;
     toString(): string;
@@ -197,9 +209,9 @@ export declare class Test {
 }
 export declare function makeGroups(tests: Test[]): (Test | TestGroup)[];
 export declare class TestGroup {
-    name: string;
+    label: Label;
     items: (Test | TestGroup)[];
-    constructor(name: string, items: (Test | TestGroup)[]);
+    constructor(label: Label, items: (Test | TestGroup)[]);
     toString(): string;
     toCode(cg: CodeGenerator): void;
 }

package/model/model.js

@@ -15,8 +15,38 @@ export class Feature {
         cg.feature(this);
     }
 }
-export class Branch {
+export class Node {
+    at([startToken, endToken]) {
+        while (startToken && startToken.kind === 'newline') {
+            startToken = startToken.next;
+        }
+        if (startToken) {
+            this.start = {
+                line: startToken.pos.rowBegin,
+                column: startToken.pos.columnBegin - 1,
+            };
+        }
+        if (startToken && endToken) {
+            let t = startToken;
+            while (t.next && t.next !== endToken) {
+                t = t.next;
+            }
+            this.end = {
+                line: t.pos.rowEnd,
+                column: t.pos.columnEnd - 1,
+            };
+        }
+        return this;
+    }
+    atSameAs(other) {
+        this.start = other.start;
+        this.end = other.end;
+        return this;
+    }
+}
+export class Branch extends Node {
     constructor(children = []) {
+        super();
         this.isFork = false;
         this.isEnd = false;
         this.children = children;
@@ -127,8 +157,9 @@ export class State {
         this.text = text;
     }
 }
-export class Label {
+export class Label extends Node {
     constructor(text = '') {
+        super();
         this.text = text;
     }
     get isEmpty() {
@@ -260,8 +291,9 @@ export class CodeLiteral extends Arg {
         return cg.variantParamDeclaration(index);
     }
 }
-export class Phrase {
+export class Phrase extends Node {
     constructor(parts) {
+        super();
         this.parts = parts;
     }
     setFeature(feature) {
@@ -417,16 +449,28 @@ export class Test {
         this.labels = this.branches
             .filter((b) => b instanceof Section)
             .filter((s) => !s.isEmpty)
-            .map((s) => s.label.text);
+            .map((s) => s.label);
     }
     get steps() {
         return this.branches.filter((b) => b instanceof Step);
     }
     get last() {
-        return this.steps[this.steps.length - 1];
+        return this.steps.at(-1);
+    }
+    get lastStrain() {
+        // Find the last branch that has no forks after it
+        const lastForking = this.branches.length -
+            1 -
+            this.branches
+                .slice()
+                .reverse()
+                .findIndex((b) => b.successors.length > 1);
+        if (lastForking === this.branches.length)
+            return this.branches.at(0);
+        return this.branches.at(lastForking + 1);
     }
     get name() {
-        return `${[this.testNumber, ...this.labels].join(' - ')}`;
+        return `${[this.testNumber, ...this.labels.map((x) => x.text)].join(' - ')}`;
     }
     toCode(cg) {
         cg.test(this);
@@ -445,25 +489,27 @@ export function makeGroups(tests) {
         return [];
     if (tests[0].labels.length === 0)
         return [tests[0], ...makeGroups(tests.slice(1))];
-    const name = tests[0].labels[0];
-    let count = tests.findIndex((t) => t.labels[0] !== name);
+    const label = tests[0].labels[0];
+    let count = tests.findIndex((t) => 
+    // using identity instead of text equality, which means identically named labels will not be grouped together
+    t.labels[0] !== label);
     if (count === -1)
         count = tests.length;
     if (count === 1)
         return [tests[0], ...makeGroups(tests.slice(1))];
     tests.slice(0, count).forEach((test) => test.labels.shift());
     return [
-        new TestGroup(name, makeGroups(tests.slice(0, count))),
+        new TestGroup(label, makeGroups(tests.slice(0, count))),
         ...makeGroups(tests.slice(count)),
     ];
 }
 export class TestGroup {
-    constructor(name, items) {
-        this.name = name;
+    constructor(label, items) {
+        this.label = label;
         this.items = items;
     }
     toString() {
-        return `+ ${this.name}:` + indent(this.items.join('\n'));
+        return `+ ${this.label.text}:` + indent(this.items.join('\n'));
     }
     toCode(cg) {
         cg.testGroup(this);

package/optimizations/autoLabel/autoLabel.d.ts

@@ -1,2 +1,2 @@
 import { Branch } from '../../model/model.ts';
-export declare function autoLabel(s: Branch): void;
+export declare function autoLabel(b: Branch): void;

package/optimizations/autoLabel/autoLabel.js

@@ -1,15 +1,19 @@
 import { Label, Section, Step } from "../../model/model.js";
-export function autoLabel(s) {
-    const forks = s.children.filter((c, i) => c.isFork || i === 0);
+export function autoLabel(b) {
+    const forks = b.children.filter((c, i) => c.isFork || i === 0);
     if (forks.length > 1) {
         forks
-            .filter((c) => c instanceof Step)
-            .forEach((c) => {
-            const label = c.action.toSingleLineString();
-            const autoSection = new Section(new Label(label), [], c.isFork);
-            c.replaceWith(autoSection);
-            autoSection.addChild(c);
+            .filter((child) => child instanceof Step)
+            .forEach((step) => {
+            const label = step.action.toSingleLineString();
+            const autoLabel = new Label(label);
+            autoLabel.atSameAs(step.action);
+            const autoSection = new Section(autoLabel, [], step.isFork);
+            // todo this is some redundancy with both section and label storing the position
+            autoSection.atSameAs(step);
+            step.replaceWith(autoSection);
+            autoSection.addChild(step);
         });
     }
-    s.children.forEach((c) => autoLabel(c));
+    b.children.forEach((c) => autoLabel(c));
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "harmonyc",
   "description": "Harmony Code - model-driven BDD for Vitest",
-  "version": "0.16.3",
+  "version": "0.17.0",
   "author": "Bernát Kalló",
   "type": "module",
   "bin": {
@@ -24,7 +24,9 @@
   "dependencies": {
     "fast-glob": "^3.3.2",
     "tinyrainbow": "1",
-    "typescript-parsec": "0.3.4",
+    "typescript-parsec": "0.3.4"
+  },
+  "optionalDependencies": {
     "watcher": "^2.3.1"
   },
   "license": "MIT",

package/parser/parser.d.ts

@@ -1,6 +1,6 @@
 import type { Parser, ParserOutput, Token } from 'typescript-parsec';
+import { Action, CodeLiteral, Docstring, ErrorResponse, Label, Response, Section, SetVariable, Step, StringLiteral, Switch, Word } from '../model/model.ts';
 import { T } from './lexer.ts';
-import { Action, Response, CodeLiteral, StringLiteral, Section, Step, Docstring, Word, Label, ErrorResponse, SetVariable, Switch } from '../model/model.ts';
 export declare function parse(input: string): Section;
 export declare function parse<T>(input: string, production: Parser<any, T>): T;
 export declare const NEWLINES: Parser<T, Token<T>[]>, WORDS: Parser<T, Word>, DOUBLE_QUOTE_STRING: Parser<T, StringLiteral>, BACKTICK_STRING: Parser<T, CodeLiteral>, DOCSTRING: Parser<T, Docstring>, ERROR_MARK: Parser<T, Token<T>>, VARIABLE: Parser<T, string>, SIMPLE_PART: Parser<T, Word | StringLiteral | Docstring | CodeLiteral>, SWITCH: Parser<T, Switch>, BRACES: Parser<T, Switch>, PART: Parser<T, Word | Switch | StringLiteral | Docstring | CodeLiteral>, PHRASE: Parser<T, (Word | Switch | StringLiteral | Docstring | CodeLiteral)[]>, ARG: Parser<T, StringLiteral | Docstring | CodeLiteral>, SET_VARIABLE: Parser<T, SetVariable>, ACTION: Parser<T, Action | SetVariable>, RESPONSE: Parser<T, Response>, ERROR_RESPONSE: Parser<T, ErrorResponse>, SAVE_TO_VARIABLE: Parser<T, Response>, ARROW: Parser<T, Token<T>>, RESPONSE_ITEM: Parser<T, Response | ErrorResponse>, STEP: Parser<T, Step>, LABEL: Parser<T, Label>, SECTION: Parser<T, Section>, BRANCH: Parser<T, Section | Step>, // section first, to make sure there is no colon after step

package/parser/parser.js

@@ -1,6 +1,6 @@
-import { alt_sc, apply, expectEOF, expectSingleResult, kright, opt_sc, rep_sc, seq, tok, list_sc, kleft, kmid, fail, nil, unableToConsumeToken, } from 'typescript-parsec';
+import { alt_sc, apply, expectEOF, expectSingleResult, fail, kleft, kmid, kright, list_sc, nil, opt_sc, rep_sc, seq, tok, unableToConsumeToken, } from 'typescript-parsec';
+import { Action, CodeLiteral, Docstring, ErrorResponse, Label, Response, SaveToVariable, Section, SetVariable, Step, StringLiteral, Switch, Word, } from "../model/model.js";
 import { T, lexer } from "./lexer.js";
-import { Action, Response, CodeLiteral, StringLiteral, Section, Step, Docstring, Word, Label, ErrorResponse, SaveToVariable, SetVariable, Switch, } from "../model/model.js";
 export function parse(input, production = TEST_DESIGN) {
     const tokens = lexer.parse(input);
     return expectSingleResult(expectEOF(production.parse(tokens)));
@@ -33,7 +33,7 @@ export const NEWLINES = list_sc(tok(T.Newline), nil()), WORDS = apply(tok(T.Word
 //),
 SWITCH = apply(list_sc(SIMPLE_PART, tok(T.Slash)), (cs) => new Switch(cs)), 
 //ROUTER = apply(list_sc(REPEATER, tok(T.Semicolon)), (cs) => new Router(cs)),
-BRACES = kmid(tok(T.OpeningBrace), SWITCH, tok(T.ClosingBrace)), PART = alt_sc(SIMPLE_PART, BRACES), PHRASE = rep_sc(PART), ARG = alt_sc(DOUBLE_QUOTE_STRING, BACKTICK_STRING, DOCSTRING), SET_VARIABLE = apply(seq(VARIABLE, ARG), ([variable, value]) => new SetVariable(variable, value)), ACTION = alt_sc(SET_VARIABLE, apply(PHRASE, (parts) => new Action(parts))), RESPONSE = apply(seq(PHRASE, opt_sc(VARIABLE)), ([parts, variable]) => new Response(parts, variable !== undefined ? new SaveToVariable(variable) : undefined)), ERROR_RESPONSE = apply(seq(ERROR_MARK, opt_sc(alt_sc(DOUBLE_QUOTE_STRING, DOCSTRING))), ([, parts]) => new ErrorResponse(parts)), SAVE_TO_VARIABLE = apply(VARIABLE, (variable) => new Response([], new SaveToVariable(variable))), ARROW = kright(opt_sc(NEWLINES), tok(T.ResponseArrow)), RESPONSE_ITEM = kright(ARROW, alt_sc(SAVE_TO_VARIABLE, ERROR_RESPONSE, RESPONSE)), STEP = apply(seq(ACTION, rep_sc(RESPONSE_ITEM)), ([action, responses]) => new Step(action, responses).setFork(true)), LABEL = apply(kleft(list_sc(PART, nil()), tok(T.Colon)), (words) => new Label(words.map((w) => w.toString()).join(' '))), SECTION = apply(LABEL, (text) => new Section(text)), BRANCH = alt_sc(SECTION, STEP), // section first, to make sure there is no colon after step
+BRACES = kmid(tok(T.OpeningBrace), SWITCH, tok(T.ClosingBrace)), PART = alt_sc(SIMPLE_PART, BRACES), PHRASE = rep_sc(PART), ARG = alt_sc(DOUBLE_QUOTE_STRING, BACKTICK_STRING, DOCSTRING), SET_VARIABLE = apply(seq(VARIABLE, ARG), ([variable, value]) => new SetVariable(variable, value)), ACTION = alt_sc(SET_VARIABLE, apply(PHRASE, (parts, range) => new Action(parts).at(range))), RESPONSE = apply(seq(PHRASE, opt_sc(VARIABLE)), ([parts, variable], range) => new Response(parts, variable !== undefined ? new SaveToVariable(variable) : undefined).at(range)), ERROR_RESPONSE = apply(seq(ERROR_MARK, opt_sc(alt_sc(DOUBLE_QUOTE_STRING, DOCSTRING))), ([, parts]) => new ErrorResponse(parts)), SAVE_TO_VARIABLE = apply(VARIABLE, (variable) => new Response([], new SaveToVariable(variable))), ARROW = kright(opt_sc(NEWLINES), tok(T.ResponseArrow)), RESPONSE_ITEM = kright(ARROW, alt_sc(SAVE_TO_VARIABLE, ERROR_RESPONSE, RESPONSE)), STEP = apply(seq(ACTION, rep_sc(RESPONSE_ITEM)), ([action, responses]) => new Step(action, responses).setFork(true)), LABEL = apply(kleft(list_sc(PART, nil()), tok(T.Colon)), (words, range) => new Label(words.map((w) => w.toString()).join(' ')).at(range)), SECTION = apply(LABEL, (text) => new Section(text)), BRANCH = apply(alt_sc(SECTION, STEP), (branch, range) => branch.at(range)), // section first, to make sure there is no colon after step
 DENTS = apply(alt_sc(tok(T.Plus), tok(T.Minus)), (seqOrFork) => {
     return {
         dent: (seqOrFork.text.length - 2) / 2,

package/vitest/index.d.ts

@@ -1,8 +1,7 @@
 import type { Plugin } from 'vite';
 export interface HarmonyPluginOptions {
-    watchDir: string;
 }
-export default function harmonyPlugin({ watchDir, }: HarmonyPluginOptions): Plugin;
+export default function harmonyPlugin({}?: HarmonyPluginOptions): Plugin;
 declare module 'vitest' {
     interface TaskMeta {
         phrases?: string[];

package/vitest/index.js

@@ -1,9 +1,24 @@
-import { watchFiles } from "../cli/watch.js";
 import c from 'tinyrainbow';
-import { compileFiles } from "../compiler/compiler.js";
-export default function harmonyPlugin({ watchDir, }) {
+import { compileFeature } from "../compiler/compile.js";
+import { preprocess } from "../compiler/compiler.js";
+export default function harmonyPlugin({} = {}) {
     return {
         name: 'harmony',
+        resolveId(id) {
+            if (id.endsWith('.harmony')) {
+                return id;
+            }
+        },
+        transform(code, id, options) {
+            if (!id.endsWith('.harmony'))
+                return null;
+            code = preprocess(code);
+            const { outFile } = compileFeature(id, code);
+            return {
+                code: outFile.valueWithoutSourceMap,
+                map: outFile.sourceMap,
+            };
+        },
         config(config) {
             var _a, _b;
             var _c;
@@ -14,16 +29,16 @@ export default function harmonyPlugin({ watchDir, }) {
             }
             config.test.reporters.splice(0, 0, new HarmonyReporter());
         },
-        async configureServer(server) {
-            const isWatchMode = server.config.server.watch !== null;
-            const patterns = [`${watchDir}/**/*.harmony`];
-            if (isWatchMode) {
-                await watchFiles(patterns);
-            }
-            else {
-                await compileFiles(patterns);
-            }
-        },
+        // This has been removed in favor of using transform, so no need to generate an actual file
+        // async configureServer(server) {
+        //   const isWatchMode = server.config.server.watch !== null
+        //   const patterns = [`${watchDir}/**/*.harmony`]
+        //   if (isWatchMode) {
+        //     await watchFiles(patterns)
+        //   } else {
+        //     await compileFiles(patterns)
+        //   }
+        // },
     };
 }
 class HarmonyReporter {