as-test 1.0.15 → 1.1.0

package/bin/types.js

@@ -60,6 +60,7 @@ export class Runtime {
 }
 export class ModeConfig {
     constructor() {
+        this.default = true;
         this.config = new Config();
     }
 }

package/bin/util.js

@@ -175,7 +175,7 @@ const FUZZ_OPTION_KEYS = new Set([
     "corpusDir",
     "crashDir",
 ]);
-const MODE_KEYS = new Set([...TOP_LEVEL_KEYS].filter((key) => key != "modes"));
+const MODE_KEYS = new Set([...TOP_LEVEL_KEYS, "default"].filter((key) => key != "modes"));
 function validateConfig(raw, configPath) {
     const issues = [];
     validateUnknownKeys(raw, TOP_LEVEL_KEYS, "$", issues);
@@ -653,6 +653,13 @@ function validateModesField(raw, key, pathPrefix, issues) {
         validateUnknownKeys(modeObj, MODE_KEYS, modePath, issues);
         validateStringField(modeObj, "$schema", modePath, issues);
         validateInputField(modeObj, "input", modePath, issues);
+        if ("default" in modeObj && typeof modeObj.default != "boolean") {
+            issues.push({
+                path: `${modePath}.default`,
+                message: "must be a boolean",
+                fix: 'set "default" to true or false',
+            });
+        }
         validateOutputField(modeObj, "output", modePath, issues);
         validateStringField(modeObj, "outDir", modePath, issues);
         validateStringField(modeObj, "logs", modePath, issues);
@@ -799,6 +806,9 @@ function parseModes(raw, configDir) {
         }
         if (!value || typeof value != "object" || Array.isArray(value))
             continue;
+        mode.default =
+            !("default" in value) ||
+                Boolean(value.default);
         mode.config = parseConfigRaw(value, join(configDir, `__mode__.${name}.json`));
         out[name] = mode;
     }
@@ -977,6 +987,70 @@ function outputOverridesField(raw, field) {
     }
     return typeof output.snapshots == "string" && output.snapshots.length > 0;
 }
+function mergeCoverageIgnoreOptions(base, override, raw) {
+    const merged = Object.assign(new CoverageIgnoreOptions(), base);
+    merged.labels = [...base.labels];
+    merged.names = [...base.names];
+    merged.locations = [...base.locations];
+    merged.snippets = [...base.snippets];
+    if ("labels" in raw)
+        merged.labels = [...override.labels];
+    if ("names" in raw)
+        merged.names = [...override.names];
+    if ("locations" in raw)
+        merged.locations = [...override.locations];
+    if ("snippets" in raw)
+        merged.snippets = [...override.snippets];
+    return merged;
+}
+function mergeCoverageConfig(base, override, raw) {
+    if (typeof raw == "boolean")
+        return override;
+    if (!raw || typeof raw != "object" || Array.isArray(raw))
+        return cloneCoverageOptions(base);
+    const mergedBase = typeof base == "boolean"
+        ? Object.assign(new CoverageOptions(), { enabled: base })
+        : cloneCoverageOptions(base);
+    const overrideOptions = typeof override == "boolean"
+        ? Object.assign(new CoverageOptions(), { enabled: override })
+        : cloneCoverageOptions(override);
+    const rawObject = raw;
+    if ("enabled" in rawObject)
+        mergedBase.enabled = overrideOptions.enabled;
+    if ("includeSpecs" in rawObject)
+        mergedBase.includeSpecs = overrideOptions.includeSpecs;
+    if ("include" in rawObject)
+        mergedBase.include = [...overrideOptions.include];
+    if ("exclude" in rawObject)
+        mergedBase.exclude = [...overrideOptions.exclude];
+    if (rawObject.ignore && typeof rawObject.ignore == "object" && !Array.isArray(rawObject.ignore)) {
+        mergedBase.ignore = mergeCoverageIgnoreOptions(mergedBase.ignore, overrideOptions.ignore, rawObject.ignore);
+    }
+    return mergedBase;
+}
+function mergeReporterConfigByRaw(base, override, raw) {
+    if (typeof raw == "string")
+        return override;
+    if (!raw || typeof raw != "object" || Array.isArray(raw)) {
+        return cloneReporterConfig(base);
+    }
+    const mergedBase = typeof base == "string"
+        ? new ReporterConfig()
+        : cloneReporterConfig(base);
+    const overrideConfig = typeof override == "string"
+        ? new ReporterConfig()
+        : cloneReporterConfig(override);
+    const rawObject = raw;
+    if ("name" in rawObject)
+        mergedBase.name = overrideConfig.name;
+    if ("options" in rawObject)
+        mergedBase.options = [...overrideConfig.options];
+    if ("outDir" in rawObject)
+        mergedBase.outDir = overrideConfig.outDir;
+    if ("outFile" in rawObject)
+        mergedBase.outFile = overrideConfig.outFile;
+    return mergedBase;
+}
 function mergeBuildOptions(base, override, raw) {
     const merged = cloneBuildOptions(base);
     if ("cmd" in raw)
@@ -986,10 +1060,7 @@ function mergeBuildOptions(base, override, raw) {
     if ("target" in raw)
         merged.target = override.target;
     if ("env" in raw) {
-        merged.env = {
-            ...merged.env,
-            ...override.env,
-        };
+        merged.env = { ...override.env };
     }
     return merged;
 }
@@ -1005,13 +1076,10 @@ function mergeRunOptions(base, override, raw) {
         }
     }
     if ("reporter" in raw) {
-        merged.reporter = cloneReporterConfig(override.reporter);
+        merged.reporter = mergeReporterConfigByRaw(merged.reporter, override.reporter, raw.reporter);
     }
     if ("env" in raw) {
-        merged.env = {
-            ...merged.env,
-            ...override.env,
-        };
+        merged.env = { ...override.env };
     }
     return merged;
 }
@@ -1052,13 +1120,11 @@ function mergeRootConfig(base, override) {
     }
     if ("config" in raw)
         merged.config = override.config;
-    if ("coverage" in raw)
-        merged.coverage = cloneCoverageOptions(override.coverage);
+    if ("coverage" in raw) {
+        merged.coverage = mergeCoverageConfig(merged.coverage, override.coverage, raw.coverage);
+    }
     if ("env" in raw) {
-        merged.env = {
-            ...merged.env,
-            ...override.env,
-        };
+        merged.env = { ...override.env };
     }
     if (raw.buildOptions && typeof raw.buildOptions == "object" && !Array.isArray(raw.buildOptions)) {
         merged.buildOptions = mergeBuildOptions(merged.buildOptions, override.buildOptions, raw.buildOptions);
@@ -1116,6 +1182,11 @@ export function resolveModeNames(rawArgs) {
     }
     return [...new Set(names)];
 }
+export function getDefaultModeNames(config) {
+    return Object.entries(config.modes)
+        .filter(([, mode]) => mode.default !== false)
+        .map(([name]) => name);
+}
 function appendModeTokens(out, value) {
     for (const token of value.split(",")) {
         const mode = token.trim();

package/lib/build/index.d.ts

@@ -0,0 +1 @@
+export declare function instantiate(imports: WebAssembly.Imports): Promise<WebAssembly.Instance>;