harmonyc 0.18.0 → 0.18.1

package/parser/lexer_rules.d.ts

@@ -0,0 +1,33 @@
+export declare enum T {
+    Newline = "newline",
+    Comment = "comment",
+    /** the => */
+    ResponseArrow = "=>",
+    ErrorMark = "!!",
+    Words = "words",
+    Minus = "-",
+    Plus = "+",
+    Colon = ":",
+    Space = "space",
+    OpeningBracket = "[",
+    ClosingBracket = "]",
+    OpeningBrace = "{",
+    ClosingBrace = "}",
+    And = "&",
+    Slash = "/",
+    Semicolon = ";",
+    DoubleQuoteString = "double-quote string",
+    UnclosedDoubleQuoteString = "unclosed double-quote string",
+    BacktickString = "backtick string",
+    UnclosedBacktickString = "unclosed backtick string",
+    InvalidEmptyBacktickString = "invalid empty backtick string",
+    InvalidWhitespace = "invalid whitespace",
+    InvalidTab = "invalid tab",
+    MultilineString = "multiline string",
+    InvalidMultilineStringMark = "invalid multiline string mark",
+    Variable = "variable",
+    InvalidEmptyVariable = "invalid empty variable",
+    UnclosedVariable = "unclosed variable"
+}
+declare const rules: [boolean, RegExp, T][];
+export default rules;

package/parser/lexer_rules.js

@@ -0,0 +1,74 @@
+export var T;
+(function (T) {
+    T["Newline"] = "newline";
+    T["Comment"] = "comment";
+    /** the => */
+    T["ResponseArrow"] = "=>";
+    T["ErrorMark"] = "!!";
+    T["Words"] = "words";
+    T["Minus"] = "-";
+    T["Plus"] = "+";
+    T["Colon"] = ":";
+    T["Space"] = "space";
+    T["OpeningBracket"] = "[";
+    T["ClosingBracket"] = "]";
+    T["OpeningBrace"] = "{";
+    T["ClosingBrace"] = "}";
+    T["And"] = "&";
+    T["Slash"] = "/";
+    T["Semicolon"] = ";";
+    T["DoubleQuoteString"] = "double-quote string";
+    T["UnclosedDoubleQuoteString"] = "unclosed double-quote string";
+    T["BacktickString"] = "backtick string";
+    T["UnclosedBacktickString"] = "unclosed backtick string";
+    T["InvalidEmptyBacktickString"] = "invalid empty backtick string";
+    T["InvalidWhitespace"] = "invalid whitespace";
+    T["InvalidTab"] = "invalid tab";
+    T["MultilineString"] = "multiline string";
+    T["InvalidMultilineStringMark"] = "invalid multiline string mark";
+    T["Variable"] = "variable";
+    T["InvalidEmptyVariable"] = "invalid empty variable";
+    T["UnclosedVariable"] = "unclosed variable";
+})(T || (T = {}));
+const rules = [
+    // false = ignore token
+    // if multiple patterns match, the former wins
+    // patterns must be y (sticky)
+    [true, /\n/y, T.Newline],
+    [true, /\t/y, T.InvalidTab],
+    [true, /[\x00-\x1f]/y, T.InvalidWhitespace],
+    [true, /^(  )*[+]( |$)/my, T.Plus],
+    [true, /^(  )*[-]( |$)/my, T.Minus],
+    [false, / /y, T.Space],
+    [false, /(#|\/\/).*?(?=\n|$)/y, T.Comment],
+    [true, /:(?=\s*(?:\n|$))/y, T.Colon],
+    [true, /\[/y, T.OpeningBracket],
+    [true, /\]/y, T.ClosingBracket],
+    [true, /\{/y, T.OpeningBrace],
+    [true, /\}/y, T.ClosingBrace],
+    [true, /\//y, T.Slash],
+    [true, /&/y, T.And],
+    [true, /;/y, T.Semicolon],
+    [true, /!!/y, T.ErrorMark],
+    [true, /=>/y, T.ResponseArrow],
+    [
+        true,
+        /"(?:[^"\\\n]|\\(?:[bfnrtv"\\/]|u[0-9a-fA-F]{4}))*"/y,
+        T.DoubleQuoteString,
+    ],
+    [
+        true,
+        /"(?:[^"\\\n]|\\(?:[bfnrtv"\\/]|u[0-9a-fA-F]{4}))*/y,
+        T.UnclosedDoubleQuoteString,
+    ],
+    [true, /``/y, T.InvalidEmptyBacktickString],
+    [true, /`[^`]+`/y, T.BacktickString],
+    [true, /`[^`]*/y, T.UnclosedBacktickString],
+    [true, /\$\{[^}\n]+\}/y, T.Variable],
+    [true, /\$\{\}/y, T.InvalidEmptyVariable],
+    [true, /\$\{[^}\n]*/y, T.UnclosedVariable],
+    [true, /\|(?: .*|(?=\n|$))/y, T.MultilineString],
+    [true, /\|[^ \n]/y, T.InvalidMultilineStringMark],
+    [true, /.+?(?=[\[\]"`|#{}&/;]|\$\{|$|=>|!!|:\s*$)/my, T.Words],
+];
+export default rules;

package/parser/parser.d.ts

@@ -0,0 +1,18 @@
+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';
+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
+DENTS: Parser<T, {
+    dent: number;
+    isFork: boolean;
+}>, NODE: Parser<T, {
+    dent: number;
+    branch: Section | Step;
+}>, ANYTHING_BUT_NEWLINE: {
+    parse(token: Token<T> | undefined): ParserOutput<T, Token<T>>;
+}, TEXT: Parser<T, undefined>, LINE: Parser<T, {
+    dent: number;
+    branch: Section | Step;
+} | undefined>, TEST_DESIGN: Parser<T, Section>;

package/parser/parser.js

@@ -0,0 +1,76 @@
+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";
+export function parse(input, production = TEST_DESIGN) {
+    const tokens = lexer.parse(input);
+    return expectSingleResult(expectEOF(production.parse(tokens)));
+}
+function anythingBut(kind) {
+    return {
+        parse(token) {
+            if (token === undefined)
+                return { successful: false, error: unableToConsumeToken(token) };
+            if (token.kind === kind)
+                return { successful: false, error: unableToConsumeToken(token) };
+            return {
+                candidates: [
+                    {
+                        firstToken: token,
+                        nextToken: token.next,
+                        result: token,
+                    },
+                ],
+                successful: true,
+                error: undefined,
+            };
+        },
+    };
+}
+export const NEWLINES = list_sc(tok(T.Newline), nil()), WORDS = apply(tok(T.Words), ({ text }) => new Word(text.trimEnd().split(/\s+/).join(' '))), DOUBLE_QUOTE_STRING = alt_sc(apply(tok(T.DoubleQuoteString), ({ text }) => new StringLiteral(JSON.parse(text))), seq(tok(T.UnclosedDoubleQuoteString), fail('unclosed double-quote string'))), BACKTICK_STRING = apply(tok(T.BacktickString), ({ text }) => new CodeLiteral(text.slice(1, -1))), DOCSTRING = kright(opt_sc(NEWLINES), apply(list_sc(tok(T.MultilineString), tok(T.Newline)), (lines) => new Docstring(lines.map(({ text }) => text.slice(2)).join('\n')))), ERROR_MARK = tok(T.ErrorMark), VARIABLE = apply(tok(T.Variable), ({ text }) => text.slice(2, -1)), SIMPLE_PART = alt_sc(WORDS, DOUBLE_QUOTE_STRING, BACKTICK_STRING, DOCSTRING), 
+//REPEATER = apply(
+//list_sc(rep_sc(SIMPLE_PART), tok(T.And)),
+//(cs) => new Repeater(cs)
+//),
+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, 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,
+        isFork: seqOrFork.kind === T.Plus,
+    };
+}), NODE = apply(seq(DENTS, BRANCH), ([{ dent, isFork }, branch], [start, end]) => ({
+    dent,
+    branch: branch.setFork(isFork),
+})), ANYTHING_BUT_NEWLINE = anythingBut(T.Newline), TEXT = apply(seq(tok(T.Words), rep_sc(ANYTHING_BUT_NEWLINE)), () => undefined), LINE = alt_sc(NODE, TEXT), TEST_DESIGN = kmid(rep_sc(NEWLINES), apply(opt_sc(list_sc(apply(LINE, (line, [start, end]) => ({ line, start, end })), NEWLINES)), (lines) => {
+    let dent;
+    const root = new Section(new Label(''));
+    let parent = root;
+    for (const { line, start } of lines !== null && lines !== void 0 ? lines : []) {
+        if (line === undefined)
+            continue;
+        const { dent: d, branch } = line;
+        if (dent === undefined) {
+            if (d !== 0)
+                throw new Error(`invalid indent ${d} at line ${start.pos.rowBegin}: first step must not be indented`);
+            dent = 0;
+        }
+        else if (Math.round(d) !== d) {
+            throw new Error(`invalid odd indent of ${d * 2} at line ${start.pos.rowBegin}`);
+        }
+        else if (d > dent + 1) {
+            throw new Error(`invalid indent ${d} at line ${start.pos.rowBegin}`);
+        }
+        else if (d === dent + 1) {
+            parent = parent.children[parent.children.length - 1];
+            ++dent;
+        }
+        else
+            while (d < dent) {
+                parent = parent.parent;
+                --dent;
+            }
+        parent.addChild(branch);
+    }
+    return root;
+}), rep_sc(NEWLINES));

package/util/indent.d.ts

@@ -0,0 +1 @@
+export declare const Indent: (n: number) => (lines: Iterable<string>) => Generator<string, void, unknown>;

package/util/indent.js

@@ -0,0 +1,5 @@
+export const Indent = (n) => function* indent(lines) {
+    for (const line of lines) {
+        yield ' '.repeat(n) + line;
+    }
+};

package/util/iterators.d.ts

@@ -0,0 +1 @@
+export declare function flatMap<T, R>(iterable: Iterable<T>, callback: (value: T) => Iterable<R>): Generator<R, void, undefined>;

package/util/iterators.js

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

package/util/xmur3.d.ts

@@ -0,0 +1 @@
+export declare function xmur3(str: string): () => number;

package/util/xmur3.js

@@ -0,0 +1,12 @@
+// https://stackoverflow.com/revisions/47593316/25 by bryc (github.com/bryc)
+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)),
+            (h = (h << 13) | (h >>> 19));
+    return function () {
+        h = Math.imul(h ^ (h >>> 16), 2246822507);
+        h = Math.imul(h ^ (h >>> 13), 3266489909);
+        return (h ^= h >>> 16) >>> 0;
+    };
+}

package/vitest/index.d.ts

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

package/vitest/index.js

@@ -0,0 +1,84 @@
+import c from 'tinyrainbow';
+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;
+            (_a = config.test) !== null && _a !== void 0 ? _a : (config.test = {});
+            (_b = (_c = config.test).reporters) !== null && _b !== void 0 ? _b : (_c.reporters = ['default']);
+            if (!Array.isArray(config.test.reporters)) {
+                config.test.reporters = [config.test.reporters];
+            }
+            config.test.reporters.splice(0, 0, new HarmonyReporter());
+        },
+        // 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 {
+    onInit(ctx) {
+        this.ctx = ctx;
+    }
+    onCollected(files) {
+        this.files = files;
+    }
+    onTaskUpdate(packs) {
+        if (this.files)
+            for (const file of this.files)
+                addPhrases(file);
+    }
+    onFinished(files, errors) {
+        for (const file of files)
+            addPhrases(file);
+    }
+}
+function addPhrases(task, depth = 2) {
+    var _a, _b;
+    if ('tasks' in task) {
+        for (const child of task.tasks)
+            addPhrases(child, depth + 1);
+    }
+    else if (task.type === 'test' &&
+        ((_a = task.result) === null || _a === void 0 ? void 0 : _a.state) === 'fail' &&
+        ((_b = task.meta) === null || _b === void 0 ? void 0 : _b.hasOwnProperty('phrases')) &&
+        task.meta.phrases.length > 0) {
+        const x = task;
+        x.name +=
+            '\n' +
+                task.meta
+                    .phrases.map((step, i, a) => {
+                    const indent = '  '.repeat(depth);
+                    const failed = i === a.length - 1;
+                    const figure = failed ? c.red('×') : c.green('✓');
+                    return `${indent}${figure} ${step}`;
+                })
+                    .join('\n');
+        delete task.meta.phrases; // to make sure not to add them again
+    }
+}