as-test 1.3.0 → 1.4.1

package/bin/dependency-graph.js

@@ -0,0 +1,132 @@
+import * as path from "path";
+const MODE_KEY_DEFAULT = "__default__";
+function modeKey(mode) {
+  return mode ?? MODE_KEY_DEFAULT;
+}
+function specKey(mode, specEntry) {
+  // NUL delimiter: it cannot appear in a mode name or a filesystem path, so
+  // the (mode, path) key can never collide. Written as an escape (not a raw
+  // NUL byte) to keep this file text — a literal NUL flags it binary to git/grep.
+  return `${modeKey(mode)}\u0000${path.resolve(specEntry)}`;
+}
+// asc reads many files we never care about for watch purposes — its own
+// bundled stdlib and the package on disk. They never change between runs and
+// would balloon both indices.
+function isUninterestingForWatch(absPath) {
+  const normalized = absPath.replace(/\\/g, "/");
+  if (normalized.includes("/node_modules/assemblyscript/")) return true;
+  if (normalized.includes("/node_modules/binaryen/")) return true;
+  return false;
+}
+export class DependencyGraph {
+  constructor() {
+    // (mode, spec entry) -> set of absolute paths asc loaded for that build
+    this.specToFiles = new Map();
+    // absolute path -> set of (mode, spec entry) keys that depend on it
+    this.fileToSpecs = new Map();
+    // mode-prefixed key -> the absolute spec path (so we can return it cheaply)
+    this.specPaths = new Map();
+    // mode-prefixed key -> mode name (or undefined for default)
+    this.specModes = new Map();
+  }
+  recordBuild(specEntry, mode, files) {
+    const absSpec = path.resolve(specEntry);
+    const key = specKey(mode, absSpec);
+    const prior = this.specToFiles.get(key);
+    if (prior) {
+      for (const file of prior) {
+        const set = this.fileToSpecs.get(file);
+        if (!set) continue;
+        set.delete(key);
+        if (set.size === 0) this.fileToSpecs.delete(file);
+      }
+    }
+    const next = new Set();
+    next.add(absSpec);
+    for (const file of files) {
+      const abs = path.resolve(file);
+      if (isUninterestingForWatch(abs)) continue;
+      next.add(abs);
+    }
+    this.specToFiles.set(key, next);
+    this.specPaths.set(key, absSpec);
+    this.specModes.set(key, mode);
+    for (const file of next) {
+      let set = this.fileToSpecs.get(file);
+      if (!set) {
+        set = new Set();
+        this.fileToSpecs.set(file, set);
+      }
+      set.add(key);
+    }
+  }
+  // Returns the set of absolute spec entry paths whose dependency set
+  // contains the changed file (across all recorded modes).
+  specsAffectedBy(changedFile) {
+    const abs = path.resolve(changedFile);
+    const keys = this.fileToSpecs.get(abs);
+    const out = new Set();
+    if (!keys) return out;
+    for (const key of keys) {
+      const spec = this.specPaths.get(key);
+      if (spec) out.add(spec);
+    }
+    return out;
+  }
+  // Returns the set of (modeKey, absoluteSpecPath) tuples affected by the
+  // changed file. Useful when builds must be re-run per mode rather than
+  // once per spec.
+  affectedEntries(changedFile) {
+    const abs = path.resolve(changedFile);
+    const keys = this.fileToSpecs.get(abs);
+    const out = [];
+    if (!keys) return out;
+    for (const key of keys) {
+      const spec = this.specPaths.get(key);
+      if (!spec) continue;
+      out.push({ mode: this.specModes.get(key), spec });
+    }
+    return out;
+  }
+  knownSpecs(mode) {
+    const prefix = modeKey(mode) + "\u0000";
+    const out = new Set();
+    for (const [key, spec] of this.specPaths) {
+      if (key.startsWith(prefix)) out.add(spec);
+    }
+    return out;
+  }
+  hasSpec(specEntry, mode) {
+    return this.specToFiles.has(specKey(mode, path.resolve(specEntry)));
+  }
+  forget(specEntry, mode) {
+    const key = specKey(mode, path.resolve(specEntry));
+    const prior = this.specToFiles.get(key);
+    if (prior) {
+      for (const file of prior) {
+        const set = this.fileToSpecs.get(file);
+        if (!set) continue;
+        set.delete(key);
+        if (set.size === 0) this.fileToSpecs.delete(file);
+      }
+    }
+    this.specToFiles.delete(key);
+    this.specPaths.delete(key);
+    this.specModes.delete(key);
+  }
+  clear() {
+    this.specToFiles.clear();
+    this.fileToSpecs.clear();
+    this.specPaths.clear();
+    this.specModes.clear();
+  }
+  // Returns every recorded absolute file path (across all modes/specs).
+  // Used by the watch loop to extend its watched-directory set.
+  allRecordedFiles() {
+    const out = new Set();
+    for (const set of this.specToFiles.values()) {
+      for (const file of set) out.add(file);
+    }
+    return out;
+  }
+}