harmonyc 0.16.0 → 0.16.2

package/cli/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/cli/run.d.ts

@@ -0,0 +1,2 @@
+export declare function run(patterns: string[]): void;
+export declare function runWatch(patterns: string[]): void;

package/cli/watch.d.ts

@@ -0,0 +1 @@
+export declare function watchFiles(patterns: string[]): Promise<string[]>;

package/code_generator/VitestGenerator.d.ts

@@ -0,0 +1,31 @@
+import { Action, CodeGenerator, ErrorResponse, Feature, Phrase, Response, SaveToVariable, SetVariable, Test, TestGroup } from '../model/model.ts';
+import { OutFile } from './outFile.ts';
+export declare class VitestGenerator implements CodeGenerator {
+    private tf;
+    private sf;
+    static error(message: string): string;
+    framework: string;
+    phraseFns: Map<string, Phrase>;
+    currentFeatureName: string;
+    constructor(tf: OutFile, sf: OutFile);
+    feature(feature: Feature): void;
+    testGroup(g: TestGroup): void;
+    featureVars: Map<string, string>;
+    resultCount: number;
+    test(t: Test): void;
+    errorStep(action: Action, errorResponse: ErrorResponse): void;
+    extraArgs: string[];
+    step(action: Action, responses: Response[]): void;
+    private declareFeatureVariables;
+    phrase(p: Phrase): void;
+    setVariable(action: SetVariable): void;
+    saveToVariable(s: SaveToVariable, what?: string): void;
+    stringLiteral(text: string, { withVariables }: {
+        withVariables: boolean;
+    }): string;
+    codeLiteral(src: string): string;
+    private paramName;
+    stringParamDeclaration(index: number): string;
+    variantParamDeclaration(index: number): string;
+}
+export declare function functionName(phrase: Phrase): string;

package/code_generator/outFile.d.ts

@@ -0,0 +1,17 @@
+import { Location } from '../model/model.ts';
+import { SourceMapGenerator } from 'source-map-js';
+export declare class OutFile {
+    name: string;
+    lines: string[];
+    level: number;
+    sm: SourceMapGenerator;
+    indentSpaces: number;
+    private currentLoc;
+    constructor(name: string);
+    indent(fn: () => void): void;
+    print(...lines: string[]): this;
+    loc({ location }: {
+        location?: Location;
+    }): this;
+    get value(): string;
+}

package/code_generator/test_phrases.d.ts

@@ -0,0 +1,11 @@
+export declare class TestPhrases {
+    private context;
+    constructor(context: any);
+    When_goodbye(): void;
+    When_hello(): string;
+    When_greet_(name: string): void;
+    Then__is_(x: string, y: string): Promise<void>;
+    Then_last_char(s: string): string;
+    Then_last_char_of_greeting(): any;
+    Then_(s: string, r: string): void;
+}

package/compiler/compile.d.ts

@@ -0,0 +1,9 @@
+import { OutFile } from '../code_generator/outFile.ts';
+export interface CompiledFeature {
+    name: string;
+    code: Record<string, string>;
+}
+export declare function compileFeature(fileName: string, src: string): {
+    outFile: OutFile;
+    phrasesFile: OutFile;
+};

package/compiler/compiler.d.ts

@@ -0,0 +1,9 @@
+export declare function compileFiles(pattern: string | string[]): Promise<{
+    fns: string[];
+    outFns: string[];
+}>;
+export declare function compileFile(fn: string): Promise<{
+    phrasesFileAction: string;
+    outFile: import("../code_generator/outFile.ts").OutFile;
+    phrasesFile: import("../code_generator/outFile.ts").OutFile;
+} | undefined>;

package/filenames/filenames.d.ts

@@ -0,0 +1,3 @@
+export declare function base(fn: string): string;
+export declare function testFileName(fn: string): string;
+export declare function phrasesFileName(fn: string): string;

package/model/Router.d.ts

@@ -0,0 +1,22 @@
+import type { Branch } from './model.ts';
+export declare class Router<N> {
+    outs: N[];
+    index: number;
+    random: () => number;
+    started: Set<N>;
+    covered: Set<N>;
+    constructor(outs: N[], seed?: string);
+    next(): N;
+    get incompleteCount(): number;
+}
+type N = Branch;
+export declare class Routers {
+    private root;
+    routers: Map<Branch, Router<Branch>>;
+    constructor(root: N);
+    discover(branch: N): void;
+    get(branch: N): Router<Branch>;
+    nextWalk(): Branch[];
+    getIncompleteCount(): number;
+}
+export {};

package/model/model.d.ts

@@ -0,0 +1,205 @@
+export interface CodeGenerator {
+    feature(feature: Feature): void;
+    testGroup(group: TestGroup): void;
+    test(test: Test): void;
+    phrase(phrase: Phrase): void;
+    step(action: Action, responses: Response[]): void;
+    errorStep(action: Action, errorResponse: ErrorResponse): void;
+    setVariable(action: SetVariable): void;
+    saveToVariable(response: SaveToVariable): void;
+    stringLiteral(text: string, opts: {
+        withVariables: boolean;
+    }): string;
+    codeLiteral(src: string): string;
+    stringParamDeclaration(index: number): string;
+    variantParamDeclaration(index: number): string;
+}
+export interface Location {
+    line: number;
+    column: number;
+    fileName: string;
+}
+export declare class Feature {
+    name: string;
+    root: Section;
+    prelude: string;
+    constructor(name: string);
+    get tests(): Test[];
+    get testGroups(): (TestGroup | Test)[];
+    toCode(cg: CodeGenerator): void;
+}
+export declare abstract class Branch {
+    parent?: Branch;
+    children: Branch[];
+    isFork: boolean;
+    isEnd: boolean;
+    location?: Location;
+    abstract get isEmpty(): boolean;
+    constructor(children?: Branch[]);
+    setFork(isFork: boolean): this;
+    setFeature(feature: Feature): this;
+    addChild<C extends Branch>(child: C, index?: number): C;
+    get isLeaf(): boolean;
+    get successors(): Branch[];
+    get nextNonForkAncestorSibling(): Branch | undefined;
+    get nextSibling(): Branch | undefined;
+    get siblingIndex(): number;
+    toString(): string;
+    replaceWith(newBranch: Branch): this;
+    switch(_i: number): this;
+}
+export declare class Step extends Branch {
+    action: Action;
+    responses: Response[];
+    state?: State;
+    constructor(action: Action, responses?: Response[], children?: Branch[], isFork?: boolean);
+    get phrases(): Phrase[];
+    toCode(cg: CodeGenerator): void;
+    setFeature(feature: Feature): this;
+    headToString(): string;
+    toString(): string;
+    get isEmpty(): boolean;
+    switch(i: number): this;
+}
+export declare class State {
+    text: string;
+    constructor(text?: string);
+}
+export declare class Label {
+    text: string;
+    constructor(text?: string);
+    get isEmpty(): boolean;
+}
+export declare class Section extends Branch {
+    label: Label;
+    constructor(label?: Label, children?: Branch[], isFork?: boolean);
+    toString(): string;
+    get isEmpty(): boolean;
+}
+export declare abstract class Part {
+    toSingleLineString(): string;
+}
+export declare class DummyKeyword extends Part {
+    text: string;
+    constructor(text?: string);
+    toString(): string;
+}
+export declare class Word extends Part {
+    text: string;
+    constructor(text?: string);
+    toString(): string;
+}
+export declare class Repeater extends Part {
+    choices: Part[][];
+    constructor(choices: Part[][]);
+    toString(): string;
+    toSingleLineString(): string;
+}
+export declare class Switch extends Part {
+    choices: Part[];
+    constructor(choices: Part[]);
+    toString(): string;
+    toSingleLineString(): string;
+}
+export declare class Router extends Part {
+    choices: Repeater[];
+    constructor(choices: Repeater[]);
+    toString(): string;
+    toSingleLineString(): string;
+}
+export declare abstract class Arg extends Part {
+    abstract toCode(cg: CodeGenerator): string;
+    abstract toDeclaration(cg: CodeGenerator, index: number): string;
+}
+export declare class StringLiteral extends Arg {
+    text: string;
+    constructor(text?: string);
+    toString(): string;
+    toSingleLineString(): string;
+    toCode(cg: CodeGenerator): string;
+    toDeclaration(cg: CodeGenerator, index: number): string;
+}
+export declare class Docstring extends StringLiteral {
+    toCode(cg: CodeGenerator): string;
+    toString(): string;
+    toSingleLineString(): string;
+}
+export declare class CodeLiteral extends Arg {
+    src: string;
+    constructor(src?: string);
+    toString(): string;
+    toCode(cg: CodeGenerator): string;
+    toDeclaration(cg: CodeGenerator, index: number): string;
+}
+export declare abstract class Phrase {
+    parts: Part[];
+    feature: Feature;
+    location?: Location;
+    abstract get kind(): string;
+    constructor(parts: Part[]);
+    setFeature(feature: Feature): this;
+    get keyword(): "When" | "Then";
+    get args(): Arg[];
+    get isEmpty(): boolean;
+    abstract toCode(cg: CodeGenerator): void;
+    toString(): string;
+    toSingleLineString(): string;
+    switch(i: number): Phrase;
+}
+export declare class Action extends Phrase {
+    kind: string;
+    toCode(cg: CodeGenerator): void;
+}
+export declare class Response extends Phrase {
+    saveToVariable?: SaveToVariable | undefined;
+    kind: string;
+    constructor(parts: Part[], saveToVariable?: SaveToVariable | undefined);
+    get isEmpty(): boolean;
+    toString(): string;
+    toSingleLineString(): string;
+    toCode(cg: CodeGenerator): void;
+}
+export declare class ErrorResponse extends Response {
+    message: StringLiteral | undefined;
+    constructor(message: StringLiteral | undefined);
+    toCode(cg: CodeGenerator): void;
+}
+export declare class SetVariable extends Action {
+    variableName: string;
+    value: Arg;
+    constructor(variableName: string, value: Arg);
+    toCode(cg: CodeGenerator): void;
+}
+export declare class SaveToVariable extends Part {
+    variableName: string;
+    constructor(variableName: string);
+    toCode(cg: CodeGenerator): void;
+    toString(): string;
+    get words(): string[];
+}
+export declare class Precondition extends Branch {
+    state: State;
+    constructor(state?: string);
+    get isEmpty(): boolean;
+}
+export declare function makeTests(root: Branch): Test[];
+export declare class Test {
+    branches: Branch[];
+    testNumber?: string;
+    labels: string[];
+    constructor(branches: Branch[]);
+    get steps(): Step[];
+    get last(): Step;
+    get name(): string;
+    toCode(cg: CodeGenerator): void;
+    toString(): string;
+    switch(j: number): Test;
+}
+export declare function makeGroups(tests: Test[]): (Test | TestGroup)[];
+export declare class TestGroup {
+    name: string;
+    items: (Test | TestGroup)[];
+    constructor(name: string, items: (Test | TestGroup)[]);
+    toString(): string;
+    toCode(cg: CodeGenerator): void;
+}

package/optimizations/autoLabel/autoLabel.d.ts

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

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "harmonyc",
   "description": "Harmony Code - model-driven BDD for Vitest",
-  "version": "0.16.0",
+  "version": "0.16.2",
   "author": "Bernát Kalló",
   "type": "module",
   "bin": {

package/parser/lexer.d.ts

@@ -0,0 +1,21 @@
+import { Token, Lexer, TokenPosition } from 'typescript-parsec';
+export { T } from './lexer_rules.js';
+declare class TokenImpl<T> implements Token<T> {
+    private readonly lexer;
+    private readonly input;
+    kind: T;
+    text: string;
+    pos: TokenPosition;
+    keep: boolean;
+    private nextToken;
+    constructor(lexer: LexerImpl<T>, input: string, kind: T, text: string, pos: TokenPosition, keep: boolean);
+    get next(): Token<T> | undefined;
+}
+declare class LexerImpl<T> implements Lexer<T> {
+    rules: [boolean, RegExp, T][];
+    constructor(rules: [boolean, RegExp, T][]);
+    parse(input: string): TokenImpl<T> | undefined;
+    parseNext(input: string, indexStart: number, rowBegin: number, columnBegin: number): TokenImpl<T> | undefined;
+    parseNextAvailable(input: string, index: number, rowBegin: number, columnBegin: number): TokenImpl<T> | undefined;
+}
+export declare const lexer: LexerImpl<import("./lexer_rules.js").T>;

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/parser.d.ts

@@ -0,0 +1,18 @@
+import type { Parser, ParserOutput, Token } from 'typescript-parsec';
+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
+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/util/indent.d.ts

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

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/xmur3.d.ts

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

package/vitest/index.d.ts

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

package/test.d.ts

@@ -1,7 +0,0 @@
-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