as-test 1.5.2 → 1.6.0

package/bin/reporters/default.js

@@ -116,14 +116,28 @@ class DefaultReporter {
   renderFileResult(event) {
     const verdict = event.verdict ?? "none";
     const time = event.time ? ` ${chalk.dim(event.time)}` : "";
-    const file = formatSpecDisplayPath(event.file);
+    const name = formatSpecDisplayPath(event.file);
+    // A replayed (cached) result is de-emphasized: badge, filename, and tag are
+    // all dimmed so freshly-run specs stand out from unchanged ones.
+    if (event.cached) {
+      // Replayed-from-cache: keep the coloured verdict badge (white text) so it
+      // stays scannable, but dim the filename and show "(cache)" in place of the
+      // timing so freshly-run specs still stand out.
+      const badge =
+        verdict == "fail"
+          ? chalk.bgRed.white(" FAIL ")
+          : verdict == "ok"
+            ? chalk.bgGreenBright.white(" PASS ")
+            : chalk.bgBlackBright.white(" SKIP ");
+      return `${badge} ${chalk.dim(name)} ${chalk.dim("(cache)")}`;
+    }
     if (verdict == "fail")
-      return `${chalk.bgRed.white(" FAIL ")} ${file}${time}`;
+      return `${chalk.bgRed.white(" FAIL ")} ${name}${time}`;
     if (this.fileHasWarning)
-      return `${chalk.bgYellow.black(" WARN ")} ${file}${time}`;
+      return `${chalk.bgYellow.black(" WARN ")} ${name}${time}`;
     if (verdict == "ok")
-      return `${chalk.bgGreenBright.black(" PASS ")} ${file}${time}`;
-    return `${chalk.bgBlackBright.white(" SKIP ")} ${file}${time}`;
+      return `${chalk.bgGreenBright.black(" PASS ")} ${name}${time}`;
+    return `${chalk.bgBlackBright.white(" SKIP ")} ${name}${time}`;
   }
   onRunStart(event) {
     this.verboseMode = Boolean(event.verbose);
@@ -805,8 +819,18 @@ function renderTotals(stats, event) {
     skipped: stats.skippedTests,
     total: stats.failedTests + stats.passedTests + stats.skippedTests,
   };
+  const cacheSummary = computeCacheSummary(event.reports);
   const layout = createSummaryLayout([
     event.fuzzSummary,
+    // "cached" and "failed" are the same length, so the cache summary aligns in
+    // the shared first column.
+    cacheSummary
+      ? {
+          failed: cacheSummary.cached,
+          skipped: cacheSummary.skipped,
+          total: cacheSummary.total,
+        }
+      : undefined,
     filesSummary,
     suitesSummary,
     testsSummary,
@@ -821,6 +845,9 @@ function renderTotals(stats, event) {
   if (event.modeSummary) {
     renderModeSummary(event.modeSummary, layout);
   }
+  if (cacheSummary) {
+    renderCacheSummary(cacheSummary, layout);
+  }
   process.stdout.write(
     chalk.bold("Time:".padEnd(9)) +
       formatTime(stats.time) +
@@ -828,6 +855,30 @@ function renderTotals(stats, event) {
       "\n",
   );
 }
+// When the cache is active, every report carries a `cached` flag (true =
+// replayed from cache, false = freshly run). Returns the hit/miss split, or
+// undefined when the cache is off (no report sets the flag) so no line shows.
+function computeCacheSummary(reports) {
+  const flagged = reports.filter((r) => typeof r?.cached === "boolean");
+  if (!flagged.length) return undefined;
+  const cached = flagged.filter((r) => r.cached).length;
+  return { cached, skipped: flagged.length - cached, total: flagged.length };
+}
+// Renders the "Cache:" line in the shared three-column layout (cached / skipped
+// / total) so it lines up with Files/Suites/Tests/Modes.
+function renderCacheSummary(summary, layout) {
+  const cachedText = `${summary.cached} cached`;
+  const skippedText = `${summary.skipped} skipped`;
+  const totalText = `${summary.total} total`;
+  process.stdout.write(chalk.bold("Cache:".padEnd(9)));
+  process.stdout.write(
+    chalk.bold.greenBright(cachedText.padStart(layout.failedWidth)),
+  );
+  process.stdout.write(", ");
+  process.stdout.write(chalk.gray(skippedText.padStart(layout.skippedWidth)));
+  process.stdout.write(", ");
+  process.stdout.write(totalText.padStart(layout.totalWidth) + "\n");
+}
 function renderModeSummary(summary, layout) {
   renderSummaryLine("Modes:", summary, layout);
 }

package/bin/types.js

@@ -7,6 +7,13 @@ export class Config {
     this.coverageDir = "./.as-test/coverage";
     this.snapshotDir = "./.as-test/snapshots";
     this.config = "none";
+    // Incremental test cache (opt-in). false = off; "build" = skip recompiling
+    // unchanged specs; "full"/true = also replay passing run results. The object
+    // form adds `maxTime` (e.g. "1h", "30m", "7d") to expire entries older than
+    // that, forcing a rebuild+rerun. ("reachable" is accepted as a deprecated
+    // alias for "full" — reachability-based dep pruning was unsound for
+    // AssemblyScript's compile-time inlining.) Enable per run with --cache / --no-cache.
+    this.cache = false;
     this.coverage = false;
     this.features = [];
     this.env = {};
@@ -16,6 +23,17 @@ export class Config {
     this.modes = {};
   }
 }
+export class CacheOptions {
+  constructor() {
+    // Cache tier: "build" (skip rebuilds) or "full" (also replay runs).
+    // "reachable" is accepted as a deprecated alias for "full".
+    this.type = "full";
+    // Optional expiry: a duration string (e.g. "1h", "30m", "90s", "7d"). Entries
+    // built longer ago than this are treated as stale and rebuilt+rerun. Empty =
+    // no expiry.
+    this.maxTime = "";
+  }
+}
 export const INTERNAL_FEATURE_NAMES = new Set(["try-as"]);
 export function normalizeFeatureName(value) {
   const trimmed = value.trim().toLowerCase();

package/bin/util.js

@@ -217,6 +217,7 @@ const TOP_LEVEL_KEYS = new Set([
   "coverageDir",
   "snapshotDir",
   "config",
+  "cache",
   "coverage",
   "features",
   "env",
@@ -253,6 +254,7 @@ function validateConfig(raw, configPath) {
   validateStringField(raw, "coverageDir", "$", issues);
   validateStringField(raw, "snapshotDir", "$", issues);
   validateStringField(raw, "config", "$", issues);
+  validateCacheField(raw, "cache", "$", issues);
   validateCoverageField(raw, "coverage", "$", issues);
   validateFeaturesField(raw, "features", "$", issues);
   validateEnvField(raw, "env", "$", issues);
@@ -380,6 +382,46 @@ function validateCoverageField(raw, key, pathPrefix, issues) {
   if (!(key in raw) || raw[key] == undefined) return;
   validateCoverageValue(raw[key], `${pathPrefix}.${key}`, issues);
 }
+function validateCacheField(raw, key, pathPrefix, issues) {
+  if (!(key in raw) || raw[key] == undefined) return;
+  const value = raw[key];
+  const path = `${pathPrefix}.${key}`;
+  if (typeof value == "boolean") return;
+  if (value === "build" || value === "full" || value === "reachable") return;
+  if (value && typeof value == "object" && !Array.isArray(value)) {
+    const obj = value;
+    if (
+      "type" in obj &&
+      obj.type !== "build" &&
+      obj.type !== "full" &&
+      obj.type !== "reachable"
+    ) {
+      issues.push({
+        path: `${path}.type`,
+        message: 'must be "build" or "full"',
+        fix: 'set "type" to "build" or "full"',
+      });
+    }
+    if ("maxTime" in obj && obj.maxTime != undefined) {
+      if (
+        typeof obj.maxTime != "string" ||
+        parseDurationMs(obj.maxTime) == null
+      ) {
+        issues.push({
+          path: `${path}.maxTime`,
+          message: 'must be a duration like "1h", "30m", "90s", or "7d"',
+          fix: 'use a number followed by ms/s/m/h/d, e.g. "1h"',
+        });
+      }
+    }
+    return;
+  }
+  issues.push({
+    path,
+    message: 'must be a boolean, "build"/"full", or { type, maxTime }',
+    fix: 'use false, true, "build", "full", or { "type": "full", "maxTime": "1h" }',
+  });
+}
 function validateCoverageValue(value, path, issues) {
   if (typeof value == "boolean") return;
   if (!value || typeof value != "object" || Array.isArray(value)) {
@@ -758,6 +800,7 @@ function validateModesField(raw, key, pathPrefix, issues) {
     validateStringField(modeObj, "coverageDir", modePath, issues);
     validateStringField(modeObj, "snapshotDir", modePath, issues);
     validateStringField(modeObj, "config", modePath, issues);
+    validateCacheField(modeObj, "cache", modePath, issues);
     validateCoverageField(modeObj, "coverage", modePath, issues);
     validateFeaturesField(modeObj, "features", modePath, issues);
     validateFuzzField(modeObj, "fuzz", modePath, issues);
@@ -1244,6 +1287,7 @@ function mergeRootConfig(base, override) {
     merged.snapshotDir = override.snapshotDir;
   }
   if ("config" in raw) merged.config = override.config;
+  if ("cache" in raw) merged.cache = override.cache;
   if ("coverage" in raw) {
     merged.coverage = mergeCoverageConfig(
       merged.coverage,
@@ -1392,6 +1436,56 @@ export function applyMode(config, modeName) {
 function appendPathSegment(basePath, segment) {
   return join(basePath, segment);
 }
+// Parses a duration string ("500ms", "90s", "30m", "1h", "7d", "1.5h") to
+// milliseconds. Returns null when the format is unrecognized.
+export function parseDurationMs(value) {
+  const match = /^\s*(\d+(?:\.\d+)?)\s*(ms|s|m|h|d)\s*$/.exec(value);
+  if (!match) return null;
+  const amount = Number(match[1]);
+  const unit = match[2];
+  const mult =
+    unit === "ms"
+      ? 1
+      : unit === "s"
+        ? 1000
+        : unit === "m"
+          ? 60000
+          : unit === "h"
+            ? 3600000
+            : 86400000;
+  return amount * mult;
+}
+// Resolves the effective cache mode + expiry for a run. CLI flags win over
+// config: --no-cache forces off, --cache forces full. The config value may be a
+// boolean, a mode string, or an object { type, maxTime }. Default is off
+// (opt-in). maxTime (entry expiry) comes from the object form regardless of the
+// resolved mode.
+export function resolveCacheSettings(configCache, flags) {
+  if (flags.noCache) return { mode: "off", maxTimeMs: null };
+  // "reachable" is accepted for back-compat but treated as "full": reachability
+  // pruning was unsound for AssemblyScript (compile-time-inlined consts, static
+  // fields, @inline bodies, and re-export barrels can change output without
+  // being "reachable"), so it could serve stale results. The full dependency
+  // set is always correct.
+  let mode = "off";
+  let maxTimeMs = null;
+  if (configCache && typeof configCache === "object") {
+    mode = configCache.type === "build" ? "build" : "full";
+    maxTimeMs = configCache.maxTime
+      ? parseDurationMs(configCache.maxTime)
+      : null;
+  } else if (
+    configCache === true ||
+    configCache === "full" ||
+    configCache === "reachable"
+  ) {
+    mode = "full";
+  } else if (configCache === "build") {
+    mode = "build";
+  }
+  if (flags.cache) mode = "full"; // --cache forces full; maxTime (if any) kept
+  return { mode, maxTimeMs };
+}
 export function getCliVersion() {
   const candidates = [
     join(dirname(fileURLToPath(import.meta.url)), "..", "package.json"),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "as-test",
-  "version": "1.5.2",
+  "version": "1.6.0",
   "author": "Jairus Tanaka",
   "repository": {
     "type": "git",
@@ -24,7 +24,7 @@
     "husky": "^9.1.7",
     "playwright": "^1.60.0",
     "prettier": "3.8.3",
-    "try-as": "^1.1.0",
+    "try-as": "1.1.0",
     "typescript": "^6.0.3",
     "typescript-eslint": "^8.59.4",
     "vitepress": "^1.6.4"

package/transform/lib/index.js

@@ -140,7 +140,7 @@ function analyzeSourceText(sourceText) {
         ? new RegExp(`\\b${escapeRegex(runAlias)}\\s*\\(`).test(text)
         : false;
     return {
-        hasSuiteCalls: /\b(?:describe|test|it|only|xonly|todo|fuzz|xfuzz)\s*\(/.test(text),
+        hasSuiteCalls: /\b(?:x?describe|x?test|x?it|x?only|todo|x?fuzz)\s*\(/.test(text),
         hasRunCall,
         runImportPath,
         hasMockCalls: /\b(?:mockFn|unmockFn|mockImport|unmockImport)\s*\(/.test(text),
@@ -174,7 +174,7 @@ function detectRunAlias(text) {
     return null;
 }
 function looksLikeAsTestImport(specifiers) {
-    return /\b(?:describe|test|it|only|xonly|todo|fuzz|xfuzz|expect|beforeAll|afterAll|beforeEach|afterEach|mockFn|unmockFn|mockImport|unmockImport|snapshotFn|log|run)\b/.test(specifiers);
+    return /\b(?:x?describe|x?test|x?it|x?only|todo|x?fuzz|expect|beforeAll|afterAll|beforeEach|afterEach|mockFn|unmockFn|mockImport|unmockImport|snapshotFn|log|run)\b/.test(specifiers);
 }
 function stripComments(sourceText) {
     return sourceText.replace(/\/\*[\s\S]*?\*\//g, "").replace(/\/\/.*$/gm, "");