@itmetsam/samurai-framework 0.19.0 → 0.21.0

package/dist/steps/edit.js

@@ -1,12 +1,9 @@
 import ts from "typescript";
 import { stepToSource } from "./emit.js";
 import { parseSpec } from "./parse.js";
-const lineStart = (source, offset) => source.lastIndexOf("\n", offset - 1) + 1;
-function lineEnd(source, offset) {
-    const newline = source.indexOf("\n", offset);
-    return newline === -1 ? source.length : newline + 1;
-}
-const indentOf = (source, offset) => /^[ \t]*/.exec(source.slice(lineStart(source, offset)))[0];
+import { OUTPUT_MATCHERS } from "./parse/expectation.js";
+import { declareList } from "./test-options.js";
+import { indentOf, lineEnd, lineStart, splice } from "./text.js";
 function pickTest(source, test) {
     const found = parseSpec(source)[test];
     if (!found)
@@ -19,9 +16,6 @@ function pickStep(parsed, index) {
         throw new RangeError(`Test "${parsed.name}" has no step ${index}`);
     return step;
 }
-function splice(source, from, to, text) {
-    return source.slice(0, from) + text + source.slice(to);
-}
 /** Inserts statement text so it becomes step `index`, copying the indentation of the steps around it */
 function insertCode(source, parsed, index, code) {
     if (index < 0 || index > parsed.steps.length) {
@@ -52,11 +46,58 @@ function removeStep(source, parsed, index) {
     const { anchor, end } = pickStep(parsed, index);
     return splice(source, lineStart(source, anchor), lineEnd(source, end), "");
 }
+const VALUE_FIXTURES = { env: "env", secret: "secrets", input: "inputs" };
 /** The fixtures a step's statement reads */
 function fixturesOf(step) {
+    if (step.kind === "saveOutput")
+        return ["outputs"];
     if (step.kind !== "fill" || step.value.kind === "literal")
         return [];
-    return [step.value.kind === "env" ? "env" : "secrets"];
+    return [VALUE_FIXTURES[step.value.kind]];
+}
+/** The output a step saves, if any */
+function outputOf(step) {
+    if (step.kind === "saveOutput")
+        return step.name;
+    return step.kind === "fill" || step.kind === "expect"
+        ? step.output
+        : undefined;
+}
+/** Refuses a step that reads an input the test doesn't declare: the default has to be set first */
+function checkInputs(parsed, step) {
+    if (step.kind !== "fill" || step.value.kind !== "input")
+        return;
+    const { name } = step.value;
+    if (!parsed.inputs?.some((input) => input.name === name))
+        throw new Error(`applyEdit(): input "${name}" is not declared`);
+}
+/** Refuses an output the runtime can't save: from a negated check, or from a matcher that doesn't take one */
+function checkOutput(step) {
+    if (step.kind !== "expect" || step.output === undefined)
+        return;
+    if (step.not)
+        throw new Error("applyEdit(): output can't be saved from a negated check");
+    if (!OUTPUT_MATCHERS.includes(step.expectation.matcher))
+        throw new Error(`applyEdit(): output can't be saved from ${step.expectation.matcher}`);
+}
+/** Adds the output a step saves to the test's `outputs`, when it isn't there yet */
+function withOutput(source, parsed, step) {
+    const name = outputOf(step);
+    const outputs = parsed.outputs ?? [];
+    if (name === undefined || outputs.includes(name))
+        return source;
+    return declareList(source, parsed, "outputs", [...outputs, name]);
+}
+/**
+ * Puts a step's statement in at `[from, to)` of the body, then what it needs: its fixtures, its output and
+ * the `generatedFile` import. Each goes before the last in the file, so the parsed offsets stay valid
+ */
+function withStep(source, parsed, step, place) {
+    checkInputs(parsed, step);
+    checkOutput(step);
+    const next = withOutput(withFixtures(place(source, stepToSource(step)), parsed, step), parsed, step);
+    // Last: the import shifts every offset
+    return usesGeneratedFile(step) ? withGeneratedFileImport(next) : next;
 }
 /** Adds the fixtures the step reads to the test's parameters, when they aren't there yet */
 function withFixtures(source, parsed, step) {
@@ -102,26 +143,27 @@ function withGeneratedFileImport(source) {
 }
 /**
  * Applies one edit and returns the new source. Only the touched statement changes, plus the test's parameters
- * when the step reads a fixture (`env`, `secrets`) they don't have yet: everything else, formatting and
- * comments included, stays byte for byte.
+ * when the step reads a fixture (`env`, `secrets`, `inputs`, `outputs`) they don't have yet, and its `outputs`
+ * when the step saves one not declared yet: everything else, formatting and comments included, stays byte for
+ * byte. A step that reads an undeclared input is refused: `declare` it, with its default, first.
  */
 export function applyEdit(source, edit) {
     const parsed = pickTest(source, edit.test);
     switch (edit.op) {
         case "replace": {
             const { start, end } = pickStep(parsed, edit.index);
-            // The parameters come before the body: adding to them leaves the step's offsets valid
-            const next = withFixtures(splice(source, start, end, stepToSource(edit.step)), parsed, edit.step);
-            // Last: the import shifts every offset
-            return usesGeneratedFile(edit.step)
-                ? withGeneratedFileImport(next)
-                : next;
+            return withStep(source, parsed, edit.step, (text, code) => splice(text, start, end, code));
         }
-        case "insert": {
-            const next = withFixtures(insertCode(source, parsed, edit.index, stepToSource(edit.step)), parsed, edit.step);
-            return usesGeneratedFile(edit.step)
-                ? withGeneratedFileImport(next)
-                : next;
+        case "insert":
+            return withStep(source, parsed, edit.step, (text, code) => insertCode(text, parsed, edit.index, code));
+        case "declare": {
+            let next = source;
+            for (const key of ["inputs", "outputs"]) {
+                const list = edit[key];
+                if (list)
+                    next = declareList(next, pickTest(next, edit.test), key, list);
+            }
+            return next;
         }
         case "remove":
             return removeStep(source, parsed, edit.index);

package/dist/steps/emit.d.ts

@@ -1,6 +1,8 @@
 import type { FileEntry, LocatorCall, LocatorSpec, Step, TextValue } from "./model.js";
 /** The argument of `setInputFiles` / `dropFiles`: one entry bare, else an array */
 export declare function filesToSource(files: readonly FileEntry[]): string;
+/** A name that can follow a `.` or stand as an object key unquoted */
+export declare const IDENTIFIER: RegExp;
 export declare function callToSource(call: LocatorCall): string;
 export declare function locatorToSource({ chain, fallbacks }: LocatorSpec): string;
 export declare function valueToSource(value: TextValue): string;

package/dist/steps/emit.js

@@ -15,7 +15,8 @@ export function filesToSource(files) {
         ? fileEntryToSource(files[0])
         : `[${files.map(fileEntryToSource).join(", ")}]`;
 }
-const IDENTIFIER = /^[A-Za-z_$][\w$]*$/;
+/** A name that can follow a `.` or stand as an object key unquoted */
+export const IDENTIFIER = /^[A-Za-z_$][\w$]*$/;
 function textOptions(call) {
     const parts = [
         call.match !== undefined && `match: ${str(call.match)}`,
@@ -48,17 +49,38 @@ export function locatorToSource({ chain, fallbacks }) {
 export function valueToSource(value) {
     if (value.kind === "literal")
         return str(value.value);
-    const object = value.kind === "env" ? "env" : "secrets";
+    const object = value.kind === "env"
+        ? "env"
+        : value.kind === "secret"
+            ? "secrets"
+            : "inputs";
     return IDENTIFIER.test(value.name)
         ? `${object}.${value.name}`
         : `${object}[${str(value.name)}]`;
 }
+/**
+ * A regex literal for a pattern. The source goes through `RegExp`, which escapes a `/` and a line break and leaves
+ * text that is already escaped alone, so a pattern typed by hand still makes a literal that compiles.
+ */
+function regexToSource({ source, flags }) {
+    let escaped = source;
+    try {
+        escaped = new RegExp(source, flags).source;
+    }
+    catch {
+        // Not a valid pattern: written unchanged
+    }
+    return `/${escaped}/${flags}`;
+}
 function matcherToSource(expected) {
     return typeof expected === "string"
         ? str(expected)
-        : `/${expected.regex.source}/${expected.regex.flags}`;
+        : regexToSource(expected.regex);
 }
-function expectationToSource(expectation) {
+/** The `{ output }` option a fill or a check ends with, as its last argument */
+const outputOption = (output) => output === undefined ? "" : `, { output: ${str(output)} }`;
+function expectationToSource(expectation, output) {
+    const tail = outputOption(output);
     switch (expectation.matcher) {
         case "toBeVisible":
         case "toBeHidden":
@@ -66,13 +88,13 @@ function expectationToSource(expectation) {
         case "toBeChecked":
             return `${expectation.matcher}()`;
         case "toHaveAttribute":
-            return `toHaveAttribute(${str(expectation.name)}, ${matcherToSource(expectation.expected)})`;
+            return `toHaveAttribute(${str(expectation.name)}, ${matcherToSource(expectation.expected)}${tail})`;
         case "toHaveCSS":
             return `toHaveCSS(${str(expectation.name)}, ${matcherToSource(expectation.expected)})`;
         case "toHaveCount":
             return `toHaveCount(${expectation.expected})`;
         default:
-            return `${expectation.matcher}(${matcherToSource(expectation.expected)})`;
+            return `${expectation.matcher}(${matcherToSource(expectation.expected)}${tail})`;
     }
 }
 /** The statement for a step, on one line */
@@ -83,11 +105,11 @@ export function stepToSource(step) {
         case "click":
             return `await ${locatorToSource(step.locator)}.click();`;
         case "fill":
-            return `await ${locatorToSource(step.locator)}.fill(${valueToSource(step.value)});`;
+            return `await ${locatorToSource(step.locator)}.fill(${valueToSource(step.value)}${outputOption(step.output)});`;
         case "press":
             return `await ${locatorToSource(step.locator)}.press(${str(step.key)});`;
         case "expect":
-            return `await expect(${locatorToSource(step.locator)})${step.not ? ".not" : ""}.${expectationToSource(step.expectation)};`;
+            return `await expect(${locatorToSource(step.locator)})${step.not ? ".not" : ""}.${expectationToSource(step.expectation, step.output)};`;
         case "expectPage":
             return `await expect(page)${step.not ? ".not" : ""}.${expectationToSource(step.expectation)};`;
         case "waitForNetworkIdle":
@@ -99,6 +121,8 @@ export function stepToSource(step) {
         case "setInputFiles":
         case "dropFiles":
             return `await ${locatorToSource(step.locator)}.${step.kind}(${filesToSource(step.files)});`;
+        case "saveOutput":
+            return `await outputs.save(${str(step.name)}, ${locatorToSource(step.locator)}${step.pattern ? `, ${regexToSource(step.pattern)}` : ""});`;
         case "custom":
             return step.code;
     }

package/dist/steps/index.d.ts

@@ -3,4 +3,4 @@ export { applyEdit, type StepEdit } from "./edit.js";
 export { stepToSource, locatorToSource, callToSource, filesToSource, valueToSource, } from "./emit.js";
 export { formatSize, humanSize, parseSize, sizeFromSource } from "./files.js";
 export { locatorFromSpec } from "./build.js";
-export type { Expectation, FileEntry, GeneratedFileSpec, LocatorCall, LocatorSpec, PageExpectation, ParsedStep, ParsedTest, Step, TextMatcher, TextValue, UnparsedTest, } from "./model.js";
+export type { Expectation, FileEntry, GeneratedFileSpec, LocatorCall, LocatorSpec, PageExpectation, ParsedStep, ParsedTest, Step, TextMatcher, TestInput, TextValue, UnparsedTest, } from "./model.js";

package/dist/steps/model.d.ts

@@ -39,6 +39,11 @@ export type TextValue = {
 } | {
     kind: "secret";
     name: string;
+}
+/** One of the test's declared `inputs`, `inputs.name` */
+ | {
+    kind: "input";
+    name: string;
 };
 /** What an assertion expects of text: a string or a regular expression */
 export type TextMatcher = string | {
@@ -95,15 +100,33 @@ export type Step = {
 } | {
     kind: "click";
     locator: LocatorSpec;
-} | {
+}
+/** `output` saves the typed value as that output, `{ output: "name" }` */
+ | {
     kind: "fill";
     locator: LocatorSpec;
     value: TextValue;
+    output?: string;
 } | {
     kind: "expect";
     locator: LocatorSpec;
     not: boolean;
     expectation: Expectation;
+    /**
+     * Saves what passed as that output. Read only with `toHaveText`, `toContainText`, `toHaveValue` and
+     * `toHaveAttribute`, never with `not`: any other shape is `custom`
+     */
+    output?: string;
+}
+/** Saves an element's text as an output, `outputs.save(name, locator, /pattern/)`: the first group, else the whole match */
+ | {
+    kind: "saveOutput";
+    name: string;
+    locator: LocatorSpec;
+    pattern?: {
+        source: string;
+        flags: string;
+    };
 }
 /** An assertion on the page, `expect(page).toHaveURL(…)` */
  | {
@@ -187,6 +210,22 @@ export interface ParsedTest {
     modifier?: Modifier;
     /** The `{ reason }` written with the `skip` or `fixme` that applies, when it is a string literal */
     reason?: string;
+    /** The `inputs` of the test's options object, in source order; undefined without the key */
+    inputs?: TestInput[];
+    /** The `outputs` of the test's options object; undefined without the key */
+    outputs?: string[];
+    /** The range of the test's options object (`test(title, { … }, fn)`), when it has one */
+    options?: {
+        start: number;
+        end: number;
+    };
+    /** Offset just after the title argument, where an options object goes */
+    titleEnd: number;
+}
+/** A declared input and the value it gets when nothing supplies one */
+export interface TestInput {
+    name: string;
+    default: string;
 }
 /** A `test` or `describe` call the codec can't read: its title isn't a plain string, or its function isn't written inline */
 export interface UnparsedTest {
@@ -194,5 +233,6 @@ export interface UnparsedTest {
     /** The statement's range, as for `ParsedTest` */
     start: number;
     end: number;
-    reason: "dynamic-title" | "not-inline";
+    /** `dynamic-options`: the options object isn't a literal the codec can read (`{ inputs: defaults }`, a variable) */
+    reason: "dynamic-title" | "not-inline" | "dynamic-options";
 }

package/dist/steps/parse/expectation.d.ts

@@ -1,6 +1,13 @@
 import ts from "typescript";
 import type { Expectation, PageExpectation, TextValue } from "../model.js";
-/** `env.NAME`, `env["NAME"]`, `secrets.NAME`, `secrets["NAME"]` or a string literal */
+/** `env.NAME`, `secrets.NAME`, `inputs.NAME` (or `env["NAME"]` and so on) or a string literal */
 export declare function readValue(node: ts.Expression | undefined): TextValue | undefined;
+/** `/source/flags` */
+export declare function readRegex(node: ts.Expression | undefined): {
+    source: string;
+    flags: string;
+} | undefined;
+/** The matchers that take `{ output }` as their last argument */
+export declare const OUTPUT_MATCHERS: readonly string[];
 export declare function readExpectation(matcher: string, args: readonly ts.Expression[]): Expectation | undefined;
 export declare function readPageExpectation(matcher: string, args: readonly ts.Expression[]): PageExpectation | undefined;

package/dist/steps/parse/expectation.js

@@ -1,7 +1,7 @@
 import ts from "typescript";
 import { stringOf } from "./literals.js";
 const TEXT_MATCHERS = ["toHaveText", "toContainText", "toHaveValue"];
-/** `env.NAME`, `env["NAME"]`, `secrets.NAME`, `secrets["NAME"]` or a string literal */
+/** `env.NAME`, `secrets.NAME`, `inputs.NAME` (or `env["NAME"]` and so on) or a string literal */
 export function readValue(node) {
     if (!node)
         return undefined;
@@ -26,25 +26,31 @@ export function readValue(node) {
         return { kind: "env", name };
     if (object.text === "secrets")
         return { kind: "secret", name };
+    if (object.text === "inputs")
+        return { kind: "input", name };
     return undefined;
 }
+/** `/source/flags` */
+export function readRegex(node) {
+    if (!node || !ts.isRegularExpressionLiteral(node))
+        return undefined;
+    const end = node.text.lastIndexOf("/");
+    return { source: node.text.slice(1, end), flags: node.text.slice(end + 1) };
+}
 function readTextMatcher(node) {
     if (!node)
         return undefined;
     const literal = stringOf(node);
     if (literal !== undefined)
         return literal;
-    if (ts.isRegularExpressionLiteral(node)) {
-        const end = node.text.lastIndexOf("/");
-        return {
-            regex: {
-                source: node.text.slice(1, end),
-                flags: node.text.slice(end + 1),
-            },
-        };
-    }
-    return undefined;
+    const regex = readRegex(node);
+    return regex && { regex };
 }
+/** The matchers that take `{ output }` as their last argument */
+export const OUTPUT_MATCHERS = [
+    ...TEXT_MATCHERS,
+    "toHaveAttribute",
+];
 export function readExpectation(matcher, args) {
     if (matcher === "toBeVisible" ||
         matcher === "toBeHidden" ||

package/dist/steps/parse/step.js

@@ -1,8 +1,58 @@
 import ts from "typescript";
 import { readLocator } from "./call.js";
-import { readExpectation, readPageExpectation, readValue, } from "./expectation.js";
+import { OUTPUT_MATCHERS, readExpectation, readPageExpectation, readRegex, readValue, } from "./expectation.js";
 import { readFiles } from "./file-entry.js";
 import { readObject, stringOf } from "./literals.js";
+/**
+ * The name in a trailing `{ output: "name" }`: undefined without one, null when the argument is there but
+ * isn't exactly that
+ */
+function outputOf(node) {
+    if (!node)
+        return undefined;
+    const output = readObject(node, ["output"])?.output;
+    return typeof output === "string" ? output : null;
+}
+/** `outputs.save("name", locator)` or `outputs.save("name", locator, /pattern/)` */
+function readSaveOutput(args) {
+    const name = stringOf(args[0]);
+    const locator = args[1] && readLocator(args[1]);
+    const pattern = readRegex(args[2]);
+    if (name === undefined ||
+        !locator ||
+        args.length > 3 ||
+        (args.length === 3 && !pattern))
+        return undefined;
+    return {
+        kind: "saveOutput",
+        name,
+        locator,
+        ...(pattern && { pattern }),
+    };
+}
+/** `expect(locator)…matcher(…)`, with a trailing `{ output }` only on the matchers that take one and never with `not` */
+function readLocatorExpect(subject, negated, matcher, args) {
+    const locator = readLocator(subject);
+    if (!locator)
+        return undefined;
+    const last = args[args.length - 1];
+    const takesOutput = OUTPUT_MATCHERS.includes(matcher) &&
+        !!last &&
+        ts.isObjectLiteralExpression(last);
+    const output = takesOutput ? outputOf(last) : undefined;
+    if (output === null || (output !== undefined && negated))
+        return undefined;
+    const expectation = readExpectation(matcher, takesOutput ? args.slice(0, -1) : args);
+    return expectation
+        ? {
+            kind: "expect",
+            locator,
+            not: negated,
+            expectation,
+            ...(output !== undefined && { output }),
+        }
+        : undefined;
+}
 /** The step a statement stands for, or undefined when it is outside the recorder's set */
 export function readStep(statement) {
     if (!ts.isExpressionStatement(statement) ||
@@ -58,12 +108,10 @@ export function readStep(statement) {
                 ? { kind: "expectPage", not: negated, expectation }
                 : undefined;
         }
-        const locator = readLocator(arg);
-        const expectation = readExpectation(name.text, args);
-        return locator && expectation
-            ? { kind: "expect", locator, not: negated, expectation }
-            : undefined;
+        return readLocatorExpect(arg, negated, name.text, args);
     }
+    if (ts.isIdentifier(target) && target.text === "outputs")
+        return name.text === "save" ? readSaveOutput(args) : undefined;
     const locator = readLocator(target);
     if (!locator)
         return undefined;
@@ -73,9 +121,17 @@ export function readStep(statement) {
         const key = stringOf(args[0]);
         return key === undefined ? undefined : { kind: "press", locator, key };
     }
-    if (name.text === "fill" && args.length === 1) {
+    if (name.text === "fill" && (args.length === 1 || args.length === 2)) {
         const value = readValue(args[0]);
-        return value ? { kind: "fill", locator, value } : undefined;
+        const output = outputOf(args[1]);
+        return value && output !== null
+            ? {
+                kind: "fill",
+                locator,
+                value,
+                ...(output !== undefined && { output }),
+            }
+            : undefined;
     }
     if ((name.text === "setInputFiles" || name.text === "dropFiles") &&
         args.length === 1) {

package/dist/steps/parse.js

@@ -1,6 +1,7 @@
 import ts from "typescript";
-import { readObject, stringOf } from "./parse/literals.js";
+import { stringOf } from "./parse/literals.js";
 import { readStep } from "./parse/step.js";
+import { readTestOptions } from "./test-options.js";
 function parseStatement(source, statement, sourceFile) {
     const start = statement.getStart(sourceFile);
     const end = statement.end;
@@ -58,21 +59,19 @@ function calleeOf(expression) {
     return undefined;
 }
 /**
- * The callback of `test(title, fn)` and `describe(title, fn)`, and for a skip or fixme also of
- * `(title, { reason }, fn)` with the reason when it is a literal
+ * The callback of `test(title, fn)` and `describe(title, fn)`, and of `(title, options, fn)` with what the
+ * options say and where they sit. Undefined when the options object isn't one the codec can read
  */
-function callbackOf(node, modifier) {
+function argumentsOf(node, kind, modifier) {
     const [, second, third] = node.arguments;
-    if ((modifier === "skip" || modifier === "fixme") &&
-        second &&
-        ts.isObjectLiteralExpression(second)) {
-        const reason = readObject(second, ["reason"])?.reason;
-        return {
-            callback: third,
-            ...(typeof reason === "string" && { reason }),
-        };
-    }
-    return { callback: second };
+    if (node.arguments.length < 3)
+        return { callback: second };
+    const options = readTestOptions(second, kind, modifier);
+    return (options && {
+        callback: third,
+        options,
+        range: { start: second.getStart(), end: second.end },
+    });
 }
 /** What the runner applies to a test (see `modifierOf` in the runner): the innermost `skip` or `fixme` with its reason, else `only` */
 function effectiveMark(own, describes) {
@@ -128,12 +127,18 @@ export function parseSpecFile(source) {
             !(callee.name === "test" && isConditionForm(node, callee))) {
             const kind = callee.name;
             const title = stringOf(node.arguments[0]);
-            const { callback, reason } = callbackOf(node, callee.modifier);
-            const body = callbackBody(callback);
             if (title === undefined) {
                 unparsed.push(unreadable(node, kind, "dynamic-title"));
                 return;
             }
+            const args = argumentsOf(node, kind, callee.modifier);
+            if (!args) {
+                unparsed.push(unreadable(node, kind, "dynamic-options"));
+                return;
+            }
+            const { callback, options = {}, range } = args;
+            const { reason, inputs, outputs } = options;
+            const body = callbackBody(callback);
             if (!body) {
                 unparsed.push(unreadable(node, kind, "not-inline"));
                 return;
@@ -154,6 +159,10 @@ export function parseSpecFile(source) {
                     removable: isRemovable(node),
                     fixtures: callbackFixtures(callback, sourceFile),
                     ...effectiveMark(mark, describes),
+                    ...(inputs && { inputs }),
+                    ...(outputs && { outputs }),
+                    ...(range && { options: range }),
+                    titleEnd: node.arguments[0].end,
                 });
                 return;
             }

package/dist/steps/test-options.d.ts

@@ -0,0 +1,25 @@
+import ts from "typescript";
+import type { Modifier } from "../types/test.js";
+import type { ParsedTest, TestInput } from "./model.js";
+/** What a `test()` or `describe()` options object says, as far as the codec reads it */
+export interface TestOptionsRead {
+    reason?: string;
+    inputs?: TestInput[];
+    outputs?: string[];
+}
+type ListKey = "inputs" | "outputs";
+/**
+ * The options object of a test or describe call: a describe takes only `reason`, a test also `inputs` and
+ * `outputs`. Undefined when the object isn't a literal the codec can read, so the call is left unparsed. An
+ * empty list is left out, as the runtime leaves it out. A `reason` counts only for skip and fixme, and one that
+ * isn't a string literal is passed over, as before
+ */
+export declare function readTestOptions(node: ts.Expression, kind: "test" | "describe", modifier: Modifier | undefined): TestOptionsRead | undefined;
+/**
+ * Sets one list of the test's options object: replaces it, adds it (making the object when there is none) or,
+ * for an empty list, removes it, and the whole object when nothing but empty lists would be left. The rest of
+ * the object, its layout and a `reason`, stays as it is; an unchanged list leaves the source as it is. Throws for
+ * names the runtime rejects, before writing
+ */
+export declare function declareList(source: string, parsed: ParsedTest, key: ListKey, list: TestInput[] | string[]): string;
+export {};