as-test 0.5.1 → 0.5.3

package/bin/util.js

@@ -1,5 +1,5 @@
 import { existsSync, readFileSync } from "fs";
-import { BuildOptions, Config, RunOptions, Runtime } from "./types.js";
+import { BuildOptions, Config, CoverageOptions, ModeConfig, ReporterConfig, RunOptions, Runtime, } from "./types.js";
 import chalk from "chalk";
 import { delimiter, dirname, join } from "path";
 import { fileURLToPath } from "url";
@@ -35,9 +35,39 @@ export function loadConfig(CONFIG_PATH, warn = false) {
     else {
         const raw = JSON.parse(readFileSync(CONFIG_PATH).toString());
         const config = Object.assign(new Config(), raw);
+        config.env = parseEnvMap(raw.env);
         const runOptionsRaw = raw.runOptions ?? {};
         config.buildOptions = Object.assign(new BuildOptions(), raw.buildOptions ?? {});
+        config.buildOptions.cmd =
+            typeof config.buildOptions.cmd == "string" ? config.buildOptions.cmd : "";
+        config.buildOptions.args = Array.isArray(config.buildOptions.args)
+            ? config.buildOptions.args.filter((item) => typeof item == "string")
+            : [];
+        config.buildOptions.target =
+            typeof config.buildOptions.target == "string" && config.buildOptions.target.length
+                ? config.buildOptions.target
+                : "wasi";
         config.runOptions = Object.assign(new RunOptions(), runOptionsRaw);
+        const reporterRaw = runOptionsRaw.reporter;
+        if (typeof reporterRaw == "string") {
+            config.runOptions.reporter = reporterRaw;
+        }
+        else if (reporterRaw && typeof reporterRaw == "object") {
+            const reporterConfig = Object.assign(new ReporterConfig(), reporterRaw);
+            reporterConfig.name =
+                typeof reporterConfig.name == "string" ? reporterConfig.name : "";
+            reporterConfig.options = Array.isArray(reporterConfig.options)
+                ? reporterConfig.options.filter((value) => typeof value == "string")
+                : [];
+            reporterConfig.outDir =
+                typeof reporterConfig.outDir == "string" ? reporterConfig.outDir : "";
+            reporterConfig.outFile =
+                typeof reporterConfig.outFile == "string" ? reporterConfig.outFile : "";
+            config.runOptions.reporter = reporterConfig;
+        }
+        else {
+            config.runOptions.reporter = "";
+        }
         const runtimeRaw = runOptionsRaw.runtime;
         const runtime = new Runtime();
         const legacyRun = typeof runOptionsRaw.run == "string" && runOptionsRaw.run.length
@@ -54,9 +84,207 @@ export function loadConfig(CONFIG_PATH, warn = false) {
                     : runtime.cmd;
         runtime.cmd = cmd;
         config.runOptions.runtime = runtime;
+        config.modes = parseModes(raw.modes);
         return config;
     }
 }
+function parseModes(raw) {
+    if (!raw || typeof raw != "object" || Array.isArray(raw))
+        return {};
+    const out = {};
+    const entries = Object.entries(raw);
+    for (const [name, value] of entries) {
+        if (!value || typeof value != "object" || Array.isArray(value))
+            continue;
+        const modeRaw = value;
+        const mode = new ModeConfig();
+        if (typeof modeRaw.outDir == "string" && modeRaw.outDir.length) {
+            mode.outDir = modeRaw.outDir;
+        }
+        if (typeof modeRaw.logs == "string" && modeRaw.logs.length) {
+            mode.logs = modeRaw.logs;
+        }
+        if (typeof modeRaw.coverageDir == "string" &&
+            modeRaw.coverageDir.length) {
+            mode.coverageDir = modeRaw.coverageDir;
+        }
+        if (typeof modeRaw.snapshotDir == "string" &&
+            modeRaw.snapshotDir.length) {
+            mode.snapshotDir = modeRaw.snapshotDir;
+        }
+        if (typeof modeRaw.config == "string" && modeRaw.config.length) {
+            mode.config = modeRaw.config;
+        }
+        if (typeof modeRaw.coverage == "boolean") {
+            mode.coverage = modeRaw.coverage;
+        }
+        else if (modeRaw.coverage && typeof modeRaw.coverage == "object") {
+            mode.coverage = Object.assign(new CoverageOptions(), modeRaw.coverage);
+        }
+        if (modeRaw.buildOptions && typeof modeRaw.buildOptions == "object") {
+            const buildRaw = modeRaw.buildOptions;
+            const build = {};
+            if (typeof buildRaw.cmd == "string") {
+                build.cmd = buildRaw.cmd;
+            }
+            if (Array.isArray(buildRaw.args)) {
+                build.args = buildRaw.args.filter((item) => typeof item == "string");
+            }
+            if (typeof buildRaw.target == "string" && buildRaw.target.length) {
+                build.target = buildRaw.target;
+            }
+            mode.buildOptions = build;
+        }
+        if (modeRaw.runOptions && typeof modeRaw.runOptions == "object") {
+            const runRaw = modeRaw.runOptions;
+            const run = {};
+            if (runRaw.runtime && typeof runRaw.runtime == "object") {
+                const runtimeRaw = runRaw.runtime;
+                const runtime = new Runtime();
+                if (typeof runtimeRaw.cmd == "string" && runtimeRaw.cmd.length) {
+                    runtime.cmd = runtimeRaw.cmd;
+                }
+                else if (typeof runtimeRaw.run == "string" &&
+                    runtimeRaw.run.length) {
+                    runtime.cmd = runtimeRaw.run;
+                }
+                else {
+                    runtime.cmd = "";
+                }
+                run.runtime = runtime;
+            }
+            if (typeof runRaw.reporter == "string") {
+                run.reporter = runRaw.reporter;
+            }
+            else if (runRaw.reporter && typeof runRaw.reporter == "object") {
+                const reporter = Object.assign(new ReporterConfig(), runRaw.reporter);
+                reporter.name = typeof reporter.name == "string" ? reporter.name : "";
+                reporter.options = Array.isArray(reporter.options)
+                    ? reporter.options.filter((item) => typeof item == "string")
+                    : [];
+                reporter.outDir =
+                    typeof reporter.outDir == "string" ? reporter.outDir : "";
+                reporter.outFile =
+                    typeof reporter.outFile == "string" ? reporter.outFile : "";
+                run.reporter = reporter;
+            }
+            mode.runOptions = run;
+        }
+        if (modeRaw.env && typeof modeRaw.env == "object") {
+            const env = {};
+            for (const [key, val] of Object.entries(modeRaw.env)) {
+                if (typeof val == "string")
+                    env[key] = val;
+            }
+            mode.env = env;
+        }
+        out[name] = mode;
+    }
+    return out;
+}
+function parseEnvMap(raw) {
+    if (!raw || typeof raw != "object" || Array.isArray(raw))
+        return {};
+    const env = {};
+    for (const [key, val] of Object.entries(raw)) {
+        if (typeof val == "string")
+            env[key] = val;
+    }
+    return env;
+}
+export function resolveModeNames(rawArgs) {
+    const names = [];
+    for (let i = 0; i < rawArgs.length; i++) {
+        const arg = rawArgs[i];
+        if (arg == "--mode") {
+            const next = rawArgs[i + 1];
+            if (!next || next.startsWith("-"))
+                continue;
+            i++;
+            appendModeTokens(names, next);
+            continue;
+        }
+        if (arg.startsWith("--mode=")) {
+            appendModeTokens(names, arg.slice("--mode=".length));
+        }
+    }
+    return [...new Set(names)];
+}
+function appendModeTokens(out, value) {
+    for (const token of value.split(",")) {
+        const mode = token.trim();
+        if (!mode.length)
+            continue;
+        out.push(mode);
+    }
+}
+export function applyMode(config, modeName) {
+    if (!modeName) {
+        return {
+            config,
+            env: {
+                ...process.env,
+                ...config.env,
+            },
+        };
+    }
+    const mode = config.modes[modeName];
+    if (!mode) {
+        const known = Object.keys(config.modes);
+        const available = known.length ? known.join(", ") : "(none)";
+        throw new Error(`unknown mode "${modeName}". Available modes: ${available}`);
+    }
+    const merged = Object.assign(new Config(), config);
+    merged.buildOptions = Object.assign(new BuildOptions(), config.buildOptions);
+    merged.runOptions = Object.assign(new RunOptions(), config.runOptions);
+    merged.runOptions.runtime = Object.assign(new Runtime(), config.runOptions.runtime);
+    if (mode.outDir)
+        merged.outDir = mode.outDir;
+    else
+        merged.outDir = appendPathSegment(config.outDir, modeName);
+    if (mode.logs)
+        merged.logs = mode.logs;
+    else if (config.logs != "none")
+        merged.logs = appendPathSegment(config.logs, modeName);
+    if (mode.coverageDir)
+        merged.coverageDir = mode.coverageDir;
+    else if (config.coverageDir != "none")
+        merged.coverageDir = appendPathSegment(config.coverageDir, modeName);
+    if (mode.snapshotDir)
+        merged.snapshotDir = mode.snapshotDir;
+    if (mode.config)
+        merged.config = mode.config;
+    if (mode.coverage != undefined)
+        merged.coverage = mode.coverage;
+    if (mode.buildOptions.target)
+        merged.buildOptions.target = mode.buildOptions.target;
+    if (mode.buildOptions.cmd != undefined)
+        merged.buildOptions.cmd = mode.buildOptions.cmd;
+    if (mode.buildOptions.args) {
+        merged.buildOptions.args = [
+            ...merged.buildOptions.args,
+            ...mode.buildOptions.args,
+        ];
+    }
+    if (mode.runOptions.runtime?.cmd) {
+        merged.runOptions.runtime.cmd = mode.runOptions.runtime.cmd;
+    }
+    if (mode.runOptions.reporter != undefined) {
+        merged.runOptions.reporter = mode.runOptions.reporter;
+    }
+    return {
+        config: merged,
+        env: {
+            ...process.env,
+            ...config.env,
+            ...mode.env,
+        },
+        modeName,
+    };
+}
+function appendPathSegment(basePath, segment) {
+    return join(basePath, segment);
+}
 export function getCliVersion() {
     const candidates = [
         join(process.cwd(), "package.json"),

package/package.json

@@ -1,19 +1,17 @@
 {
   "name": "as-test",
-  "version": "0.5.1",
-  "description": "Testing framework for AssemblyScript. Compatible with WASI or Bindings",
-  "types": "assembly/index.ts",
+  "version": "0.5.3",
   "author": "Jairus Tanaka",
-  "contributors": [],
-  "license": "MIT",
-  "scripts": {
-    "test": "node ./bin/index.js test",
-    "build:transform": "tsc -p ./transform",
-    "build:cli": "tsc -p cli",
-    "build:run": "tsc -p run",
-    "prettier": "prettier -w .",
-    "release:check": "npm run build:cli && npm run build:transform && npm run test && npm pack --dry-run --cache /tmp/as-test-npm-cache",
-    "prepublishOnly": "npm run build:cli && npm run build:transform && npm run test"
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/JairusSW/as-test.git"
+  },
+  "dependencies": {
+    "as-console": "^7.0.0",
+    "as-rainbow": "^0.1.0",
+    "chalk": "^5.6.2",
+    "glob": "^13.0.3",
+    "typer-diff": "^1.1.1"
   },
   "devDependencies": {
     "@assemblyscript/wasi-shim": "^0.1.0",
@@ -23,46 +21,20 @@
     "as-test": "./",
     "assemblyscript": "^0.28.9",
     "assemblyscript-prettier": "^3.0.1",
-    "json-as": "^1.2.5",
     "prettier": "3.6.2",
+    "try-as": "^0.2.5",
     "typescript": "^5.9.3",
     "typescript-eslint": "^8.55.0"
   },
-  "dependencies": {
-    "as-console": "^7.0.0",
-    "as-rainbow": "^0.1.0",
-    "as-variant": "^0.4.1",
-    "chalk": "^5.6.2",
-    "glob": "^13.0.3",
-    "gradient-string": "^3.0.0",
-    "typer-diff": "^1.1.1",
-    "wipc-js": "^0.1.1"
-  },
-  "peerDependencies": {
-    "json-as": "^1.2.5"
-  },
-  "optionalDependencies": {
-    "try-as": "^0.2.5"
-  },
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/JairusSW/as-test.git"
+  "bin": {
+    "as-test": "./bin/index.js",
+    "ast": "./bin/index.js"
   },
-  "keywords": [
-    "assemblyscript",
-    "testing",
-    "test",
-    "as-pect",
-    "aspect"
-  ],
   "bugs": {
     "url": "https://github.com/JairusSW/as-test/issues"
   },
-  "homepage": "https://github.com/JairusSW/as-test#readme",
-  "type": "module",
-  "publishConfig": {
-    "@JairusSW:registry": "https://npm.pkg.github.com"
-  },
+  "contributors": [],
+  "description": "Testing framework for AssemblyScript. Compatible with WASI or Bindings",
   "files": [
     "assembly/**/*.ts",
     "!assembly/__tests__/**",
@@ -70,7 +42,6 @@
     "bin/**/*.js",
     "templates/**/*.js",
     "transform/lib/**/*.js",
-    "transform/lib/**/*.js.map",
     "transform/package.json",
     "CHANGELOG.md",
     "README.md",
@@ -78,8 +49,27 @@
     "as-test.config.schema.json",
     "index.ts"
   ],
-  "bin": {
-    "as-test": "./bin/index.js",
-    "ast": "./bin/index.js"
-  }
+  "homepage": "https://github.com/JairusSW/as-test#readme",
+  "keywords": [
+    "assemblyscript",
+    "testing",
+    "test",
+    "as-pect",
+    "aspect"
+  ],
+  "license": "MIT",
+  "publishConfig": {
+    "@JairusSW:registry": "https://npm.pkg.github.com"
+  },
+  "scripts": {
+    "test": "node ./bin/index.js test",
+    "build:transform": "tsc -p ./transform",
+    "build:cli": "tsc -p cli",
+    "build:run": "tsc -p run",
+    "prettier": "prettier -w .",
+    "release:check": "npm run build:cli && npm run build:transform && npm run test && npm pack --dry-run --cache /tmp/as-test-npm-cache",
+    "prepublishOnly": "npm run build:cli && npm run build:transform && npm run test"
+  },
+  "type": "module",
+  "types": "assembly/index.ts"
 }