as-test 1.5.1 → 1.6.0

package/bin/selectors.js

@@ -0,0 +1,208 @@
+import { glob } from "glob";
+import chalk from "chalk";
+import * as path from "path";
+// Selector resolution runs in several places per command (the orchestrator,
+// then build/run cores per file); dedupe by text so a warning prints once per
+// process regardless of how many resolvers see the same selector.
+const reportedSelectorWarnings = new Set();
+export function emitSelectorWarnings(warnings) {
+  for (const warning of warnings) {
+    if (reportedSelectorWarnings.has(warning)) continue;
+    reportedSelectorWarnings.add(warning);
+    process.stderr.write(`${chalk.yellow.bold("WARN")} ${warning}\n`);
+  }
+}
+const GLOB_MAGIC = /[*?[\]{}]/;
+function hasGlobMagic(selector) {
+  return GLOB_MAGIC.test(selector);
+}
+function endsWithSlash(selector) {
+  return /[\\/]$/.test(selector);
+}
+function stripTrailingSlash(selector) {
+  return selector.replace(/[\\/]+$/, "");
+}
+function stripSuiteSuffix(selector) {
+  return selector.replace(/\.spec\.ts$/, "").replace(/\.ts$/, "");
+}
+function isCwdRelative(selector) {
+  return (
+    selector.startsWith("./") ||
+    selector.startsWith("../") ||
+    selector.startsWith(".\\") ||
+    selector.startsWith("..\\") ||
+    selector.startsWith("/") ||
+    selector.startsWith("~") ||
+    path.isAbsolute(selector)
+  );
+}
+// A selector with a path separator that is not merely a single trailing slash
+// (e.g. `assembly/__tests__/foo.spec.ts`, passed verbatim by the orchestrator)
+// is treated as a direct cwd-relative path rather than a test-folder alias.
+function hasInternalSlash(selector) {
+  return /[\\/]/.test(stripTrailingSlash(selector));
+}
+// The longest leading run of path segments containing no glob magic — the
+// static "test folder" of an input pattern (`assembly/__tests__/**/*.spec.ts`
+// -> `assembly/__tests__`).
+function globBase(pattern) {
+  const segments = pattern.split("/");
+  const base = [];
+  for (const segment of segments) {
+    if (hasGlobMagic(segment)) break;
+    base.push(segment);
+  }
+  return base.join("/") || ".";
+}
+function uniqueInputRoots(configuredInputs) {
+  const roots = new Set();
+  for (const pattern of configuredInputs) {
+    if (pattern.startsWith("!")) continue;
+    roots.add(globBase(pattern));
+  }
+  return [...roots];
+}
+// Turn a cwd-relative selector into the spec glob(s) it stands for.
+function cwdPatterns(selector) {
+  if (endsWithSlash(selector)) {
+    return [`${stripTrailingSlash(selector)}/**/*.spec.ts`];
+  }
+  if (/\.ts$/.test(selector)) return [selector];
+  return [`${stripSuiteSuffix(selector)}.spec.ts`];
+}
+// Turn a bare selector into the spec glob(s) it stands for, anchored to a
+// configured input root and searched recursively beneath it. A selector that
+// already carries glob magic (`rfc/*.spec.ts`, `*.spec.ts`) is appended
+// verbatim so the user's pattern controls the match; a plain folder/name has
+// the spec suffix supplied.
+function barePatterns(root, selector) {
+  if (hasGlobMagic(selector)) {
+    return [`${root}/**/${selector}`];
+  }
+  if (endsWithSlash(selector)) {
+    return [`${root}/**/${stripTrailingSlash(selector)}/**/*.spec.ts`];
+  }
+  return [`${root}/**/${stripSuiteSuffix(selector)}.spec.ts`];
+}
+// Split comma-joined bare selectors (`a,b,c`) while leaving paths and globs
+// (which can legitimately contain commas, e.g. `{a,b}`) intact.
+function expandSelectors(selectors) {
+  const expanded = [];
+  for (const selector of selectors) {
+    if (!selector) continue;
+    if (
+      selector.includes(",") &&
+      !hasInternalSlash(selector) &&
+      !endsWithSlash(selector) &&
+      !hasGlobMagic(selector)
+    ) {
+      for (const token of selector.split(",")) {
+        const trimmed = token.trim();
+        if (trimmed.length) expanded.push(trimmed);
+      }
+      continue;
+    }
+    expanded.push(selector);
+  }
+  return expanded;
+}
+async function globFiles(patterns) {
+  return glob(patterns);
+}
+async function resolveSelector(selector, inputRoots) {
+  const warnings = [];
+  const isGlob = hasGlobMagic(selector);
+  // Explicit cwd-relative selector (`./`, `../`, absolute, `~`) — resolve from
+  // the cwd only. A glob is matched verbatim; a plain path gets the spec suffix.
+  if (isCwdRelative(selector)) {
+    const files = await globFiles(isGlob ? [selector] : cwdPatterns(selector));
+    if (!files.length) {
+      const bare = selector.replace(/^\.[\\/]/, "");
+      let suggestion = null;
+      for (const root of inputRoots) {
+        const inRoot = await globFiles(barePatterns(root, bare));
+        if (inRoot.length) {
+          suggestion = bare;
+          break;
+        }
+      }
+      warnings.push(
+        suggestion
+          ? `"${selector}" not found relative to the current directory — did you mean "${suggestion}" (searches the configured test folder)?`
+          : `"${selector}" not found relative to the current directory`,
+      );
+    }
+    return { files, warnings };
+  }
+  // A plain path with an internal separator (e.g. the orchestrator's own
+  // `assembly/__tests__/foo.spec.ts`) resolves from the cwd verbatim. Globs
+  // skip this and fall through to test-folder anchoring below.
+  if (!isGlob && hasInternalSlash(selector)) {
+    const direct = await globFiles(cwdPatterns(selector));
+    if (direct.length) return { files: direct, warnings };
+    // Fall through to test-folder resolution for user shorthands like
+    // `nested/array` that aren't a real cwd path.
+  }
+  // Bare name/folder or relative glob — configured input root(s) first.
+  const perRoot = [];
+  for (const root of inputRoots) {
+    const files = await globFiles(barePatterns(root, selector));
+    if (files.length) perRoot.push({ root, files });
+  }
+  if (perRoot.length) {
+    if (perRoot.length > 1) {
+      warnings.push(
+        `selector "${selector}" matched specs under ${perRoot.length} input roots (${perRoot
+          .map((entry) => entry.root)
+          .join(", ")}) — running all of them`,
+      );
+    }
+    return { files: perRoot.flatMap((entry) => entry.files), warnings };
+  }
+  // Fall back to the cwd before giving up.
+  const cwdFiles = await globFiles(
+    isGlob ? [selector] : cwdPatterns(`./${selector}`),
+  );
+  if (cwdFiles.length) {
+    return { files: cwdFiles, warnings };
+  }
+  warnings.push(
+    inputRoots.length
+      ? `no spec files matched "${selector}" in ${inputRoots.join(", ")} or the current directory`
+      : `no spec files matched "${selector}"`,
+  );
+  return { files: [], warnings };
+}
+// Resolve configured input patterns + positional selectors into the concrete
+// set of spec files to act on, along with any human-readable warnings. With no
+// selectors this is just the configured globs (honoring `!`-negations); with
+// selectors the per-selector rules above apply and config negations are
+// intentionally bypassed so an explicit pick always wins.
+export async function resolveSpecFiles(configured, selectors) {
+  const configuredInputs = Array.isArray(configured)
+    ? configured
+    : [configured];
+  if (!selectors.length) {
+    const include = configuredInputs.filter((p) => !p.startsWith("!"));
+    const ignore = configuredInputs
+      .filter((p) => p.startsWith("!"))
+      .map((p) => p.slice(1));
+    const files = (await glob(include, { ignore })).sort((a, b) =>
+      a.localeCompare(b),
+    );
+    return { files, warnings: [] };
+  }
+  const inputRoots = uniqueInputRoots(configuredInputs);
+  const files = new Set();
+  const warnings = [];
+  for (const selector of expandSelectors(selectors)) {
+    if (!selector) continue;
+    const resolved = await resolveSelector(selector, inputRoots);
+    for (const file of resolved.files) files.add(file);
+    warnings.push(...resolved.warnings);
+  }
+  return {
+    files: [...files].sort((a, b) => a.localeCompare(b)),
+    warnings,
+  };
+}

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.1",
+  "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, "");