@nudojs/service 3.0.0 → 5.0.0-beta.0

package/dist/chunk-K3ZPOTP2.js

@@ -0,0 +1,199 @@
+import {
+  collectDtsFiles,
+  depsCacheRoot,
+  dtsClosureHash,
+  harvestCacheKey,
+  materializeHarvestJson,
+  readHarvestDisk,
+  resolvePackageRoot,
+  serializeHarvestJson,
+  writeHarvestDisk
+} from "./chunk-U7JYTRIB.js";
+import {
+  BoundedLruMap,
+  loadEnvs
+} from "./chunk-PVJIMQRI.js";
+
+// src/harvest-node.ts
+import { existsSync, statSync, readFileSync } from "fs";
+import { join } from "path";
+import { harvestDts } from "@nudojs/harvester";
+import { createEnvironment } from "@nudojs/core";
+var HARVEST_NODE_DEFAULT_MAX_FILES = 12;
+var HARVEST_NODE_DEFAULT_MAX_MS = 2500;
+var NODE_HARVEST_CACHE_MAX = 32;
+var nodeHarvestCache = new BoundedLruMap(NODE_HARVEST_CACHE_MAX);
+function notFoundCacheKey(fromDir) {
+  return `not-found|@types/node|${fromDir ?? ""}`;
+}
+function nodeHarvestCacheKey(root, maxFiles, maxMs) {
+  let sig = "nostat";
+  try {
+    const st = statSync(join(root, "package.json"));
+    sig = `${st.size}:${Math.floor(st.mtimeMs)}`;
+  } catch {
+  }
+  return `${root}|${maxFiles}|${maxMs}|${sig}`;
+}
+function clearNodeHarvestCache() {
+  nodeHarvestCache.clear();
+}
+function getNodeHarvestCacheSize() {
+  return nodeHarvestCache.size;
+}
+function isHarvestNodeDisabled(env = process.env) {
+  return env.NUDO_HARVEST_NODE === "off";
+}
+function readPkgVersion(root) {
+  try {
+    const raw = JSON.parse(readFileSync(join(root, "package.json"), "utf8"));
+    return raw.version;
+  } catch {
+    return void 0;
+  }
+}
+function handwrittenNodeEnv() {
+  try {
+    const loaded = loadEnvs(["node"], createEnvironment());
+    return {
+      modules: loaded.modules,
+      globals: loaded.globals,
+      stats: {
+        files: 0,
+        symbols: Object.keys(loaded.globals).length,
+        skipped: 0
+      }
+    };
+  } catch {
+    return null;
+  }
+}
+function degradeToHandwritten(error, reason, cached = false) {
+  const env = handwrittenNodeEnv();
+  if (env) {
+    return {
+      ok: true,
+      env,
+      root: "@nudojs/env",
+      files: 0,
+      stats: env.stats,
+      cached,
+      degraded: true
+    };
+  }
+  return { ok: false, error, reason, ...cached ? { cached: true } : {} };
+}
+function harvestNodeTypes(fromDir, maxFiles = HARVEST_NODE_DEFAULT_MAX_FILES, maxMs = HARVEST_NODE_DEFAULT_MAX_MS) {
+  if (isHarvestNodeDisabled()) {
+    return {
+      ok: false,
+      error: "harvest disabled via NUDO_HARVEST_NODE=off",
+      reason: "disabled"
+    };
+  }
+  const root = resolvePackageRoot("@types/node", fromDir) ?? resolvePackageRoot("node", fromDir);
+  if (!root || !existsSync(root)) {
+    const missKey = notFoundCacheKey(fromDir);
+    const miss = nodeHarvestCache.get(missKey);
+    if (miss) {
+      return miss.ok ? { ...miss, cached: true } : { ...miss, cached: true };
+    }
+    const result = degradeToHandwritten("@types/node not found", "not-found");
+    nodeHarvestCache.set(missKey, result);
+    return result;
+  }
+  const key = nodeHarvestCacheKey(root, maxFiles, maxMs);
+  const hit = nodeHarvestCache.get(key);
+  if (hit) {
+    return hit.ok ? { ...hit, cached: true } : { ...hit, cached: true };
+  }
+  const dts = collectDtsFiles(root, maxFiles);
+  if (dts.length === 0) {
+    const result = degradeToHandwritten(`no .d.ts under ${root}`, "no-dts");
+    nodeHarvestCache.set(key, result);
+    return result;
+  }
+  const diskRoot = depsCacheRoot();
+  const dtsHash = dtsClosureHash(dts);
+  const pkgVersion = readPkgVersion(root);
+  const diskKey = harvestCacheKey("@types/node", {
+    dtsHash,
+    maxFiles,
+    ...pkgVersion !== void 0 ? { pkgVersion } : {}
+  });
+  if (diskRoot) {
+    const diskHit = readHarvestDisk(diskRoot, diskKey);
+    const env = diskHit ? materializeHarvestJson(diskHit) : null;
+    if (env) {
+      const stats = {
+        files: env.stats.files,
+        symbols: env.stats.symbols,
+        skipped: env.stats.skipped
+      };
+      const result = {
+        ok: true,
+        env,
+        root,
+        files: stats.files,
+        stats,
+        cached: true
+      };
+      nodeHarvestCache.set(key, result);
+      return result;
+    }
+  }
+  try {
+    const env = harvestDts(dts, { maxMs });
+    const stats = {
+      files: env.stats.files,
+      symbols: env.stats.symbols,
+      skipped: env.stats.skipped
+    };
+    if (diskRoot) {
+      writeHarvestDisk(
+        diskRoot,
+        diskKey,
+        serializeHarvestJson("@types/node", env, {
+          dtsHash,
+          maxFiles,
+          ...pkgVersion !== void 0 ? { pkgVersion } : {}
+        })
+      );
+    }
+    const result = {
+      ok: true,
+      env,
+      root,
+      files: stats.files,
+      stats,
+      cached: false
+    };
+    nodeHarvestCache.set(key, result);
+    return result;
+  } catch (e) {
+    const result = degradeToHandwritten(
+      `harvest failed: ${e.message}`,
+      "failed"
+    );
+    nodeHarvestCache.set(key, result);
+    return result;
+  }
+}
+function summarizeNodeEnv(env) {
+  return {
+    modules: Object.keys(env.modules).sort(),
+    globals: Object.keys(env.globals).sort().slice(0, 50),
+    symbolCount: env.stats.symbols
+  };
+}
+
+export {
+  HARVEST_NODE_DEFAULT_MAX_FILES,
+  HARVEST_NODE_DEFAULT_MAX_MS,
+  clearNodeHarvestCache,
+  getNodeHarvestCacheSize,
+  isHarvestNodeDisabled,
+  handwrittenNodeEnv,
+  harvestNodeTypes,
+  summarizeNodeEnv
+};

package/dist/chunk-LFZRUXGK.js

@@ -0,0 +1,89 @@
+import {
+  analysisConfig,
+  findProjectConfig,
+  matchesEmitAllowlist
+} from "./chunk-YLALZXTZ.js";
+
+// src/target-path.ts
+function isNudoTargetPath(path) {
+  const lower = path.toLowerCase();
+  if (lower.endsWith(".d.ts")) return false;
+  if (lower.endsWith(".nudo.js") || lower.endsWith(".nudo.mjs") || lower.endsWith(".nudo.ts") || lower.endsWith(".nudo.draft.js") || lower.endsWith(".nudo.draft.mjs") || lower.endsWith(".nudo.draft.ts")) {
+    return false;
+  }
+  return lower.endsWith(".js") || lower.endsWith(".mjs") || lower.endsWith(".ts");
+}
+
+// src/analysis-scope.ts
+import { dirname } from "path";
+import { existsSync } from "fs";
+import { sidecarPathOf } from "@nudojs/core";
+var NOISY_WARNING_CODES = /* @__PURE__ */ new Set([
+  "nudo:unknown-recv",
+  "nudo:builtin-unknown",
+  "nudo:no-signature"
+]);
+function filterDiagnosticsByLevel(diags, level) {
+  if (level === "verbose") return diags;
+  if (level === "off") return [];
+  if (level === "errors") return diags.filter((d) => d.severity === "error");
+  return diags.filter((d) => {
+    if (d.severity === "error") return true;
+    if (d.severity === "info") return false;
+    if (d.severity === "warning" && d.code && NOISY_WARNING_CODES.has(d.code)) return false;
+    return d.severity === "warning";
+  });
+}
+function diagnosticsLevelForFile(filePath) {
+  return analysisConfig(findProjectConfig(dirname(filePath))?.config).diagnostics;
+}
+function hasNudoDirectives(source) {
+  return /@nudo:(case|mock|pure|skip|sample|contract|import|env|mock-module|as|replace)\b/.test(source);
+}
+function stripCommentsAndStrings(source) {
+  return source.replace(/\/\*[\s\S]*?\*\//g, " ").replace(/\/\/[^\n]*/g, " ").replace(/'(?:\\.|[^'\\])*'|"(?:\\.|[^"\\])*"|`(?:\\.|[^`\\])*`/g, '""');
+}
+function hasExport(source) {
+  const s = stripCommentsAndStrings(source);
+  return /(^|[\s;}])export\b/.test(s) || /\bmodule\.exports\b/.test(s) || /\bexports\s*[.[]/.test(s) || /Object\.assign\s*\(\s*(module\.)?exports\b/.test(s);
+}
+function shouldAnalyzeFile(filePath, source, config) {
+  if (!isNudoTargetPath(filePath)) return false;
+  const proj = findProjectConfig(dirname(filePath));
+  const cfg = config ?? analysisConfig(proj?.config);
+  const projectDir = proj?.projectDir;
+  if (cfg.exclude.length > 0 && projectDir) {
+    if (matchesEmitAllowlist(filePath, projectDir, cfg.exclude)) return false;
+  } else if (cfg.exclude.length > 0 && !projectDir) {
+    const norm = filePath.replace(/\\/g, "/");
+    if (cfg.exclude.some((p) => simpleExcludeHit(p, norm))) return false;
+  }
+  if (cfg.include.length > 0 && projectDir) {
+    if (!matchesEmitAllowlist(filePath, projectDir, cfg.include)) return false;
+  }
+  if (cfg.mode === "all") return true;
+  const text = source;
+  if (text !== void 0 && hasNudoDirectives(text)) return true;
+  if (cfg.mode === "directives") return false;
+  if (text !== void 0 && hasExport(text)) return true;
+  try {
+    if (existsSync(sidecarPathOf(filePath))) return true;
+  } catch {
+  }
+  return false;
+}
+function simpleExcludeHit(pattern, path) {
+  const bare = pattern.replace(/^\*\*/, "").replace(/^\//, "").replace(/\/\*\*$/, "").replace(/^\*\//, "");
+  if (!bare || bare.includes("*")) {
+    return /\/(node_modules|dist|coverage)\//.test("/" + path + "/");
+  }
+  return path.includes(`/${bare}/`) || path.endsWith(`/${bare}`);
+}
+
+export {
+  isNudoTargetPath,
+  filterDiagnosticsByLevel,
+  diagnosticsLevelForFile,
+  hasNudoDirectives,
+  shouldAnalyzeFile
+};

package/dist/chunk-PVJIMQRI.js

@@ -0,0 +1,246 @@
+// src/evaluator/env-loader.ts
+import { readFileSync, existsSync, statSync, mkdirSync, writeFileSync } from "fs";
+import { resolve as resolvePath, join as joinPath } from "path";
+import { pathToFileURL } from "url";
+import { createRequire } from "module";
+import { createHash } from "crypto";
+import { tmpdir } from "os";
+import { defineEnv as defineEsEnv } from "@nudojs/env/es";
+import { defineEnv as defineWebEnv } from "@nudojs/env/web";
+import { defineEnv as defineNodeEnv } from "@nudojs/env/node";
+
+// src/lru-map.ts
+var BoundedLruMap = class {
+  map = /* @__PURE__ */ new Map();
+  max;
+  constructor(max) {
+    this.max = max;
+  }
+  get size() {
+    return this.map.size;
+  }
+  /** 当前上限（可动态收紧；收紧时立刻按 LRU 压到新上限） */
+  getMax() {
+    return this.max;
+  }
+  setMax(max) {
+    this.max = max;
+    this.trim();
+  }
+  has(key) {
+    return this.map.has(key);
+  }
+  get(key) {
+    const hit = this.map.get(key);
+    if (hit === void 0) return void 0;
+    this.map.delete(key);
+    this.map.set(key, hit);
+    return hit;
+  }
+  /** 命中不改变 LRU 序（只读探测） */
+  peek(key) {
+    return this.map.get(key);
+  }
+  set(key, value) {
+    if (this.max <= 0) return;
+    while (this.map.size >= this.max && !this.map.has(key)) {
+      const oldest = this.map.keys().next().value;
+      if (oldest === void 0) break;
+      this.map.delete(oldest);
+    }
+    this.map.delete(key);
+    this.map.set(key, value);
+  }
+  delete(key) {
+    return this.map.delete(key);
+  }
+  clear() {
+    this.map.clear();
+  }
+  keys() {
+    return this.map.keys();
+  }
+  values() {
+    return this.map.values();
+  }
+  entries() {
+    return this.map.entries();
+  }
+  /** 压到当前 max（调低上限时收内存） */
+  trim() {
+    while (this.map.size > this.max) {
+      const oldest = this.map.keys().next().value;
+      if (oldest === void 0) break;
+      this.map.delete(oldest);
+    }
+  }
+};
+
+// src/evaluator/env-loader.ts
+var envFactories = {
+  es: defineEsEnv,
+  web: defineWebEnv,
+  node: defineNodeEnv
+};
+var impliedDeps = {
+  web: ["es"],
+  node: ["es"]
+};
+function resolveEnvNames(names) {
+  const resolved = /* @__PURE__ */ new Set();
+  const visit = (name) => {
+    if (resolved.has(name)) return;
+    const deps = impliedDeps[name];
+    if (deps) deps.forEach(visit);
+    resolved.add(name);
+  };
+  names.forEach(visit);
+  return [...resolved];
+}
+var PATH_ENV_CACHE_MAX = 64;
+var PATH_ENV_BY_PATH_MAX = 64;
+var PATH_ENV_BASE_DIRS_MAX = 64;
+var pathEnvCache = new BoundedLruMap(PATH_ENV_CACHE_MAX);
+var pathEnvByPath = new BoundedLruMap(PATH_ENV_BY_PATH_MAX);
+var pathEnvBaseDirs = /* @__PURE__ */ new Set();
+function addPathEnvBaseDir(baseDir) {
+  pathEnvBaseDirs.delete(baseDir);
+  pathEnvBaseDirs.add(baseDir);
+  while (pathEnvBaseDirs.size > PATH_ENV_BASE_DIRS_MAX) {
+    const oldest = pathEnvBaseDirs.values().next().value;
+    if (oldest === void 0) break;
+    pathEnvBaseDirs.delete(oldest);
+  }
+}
+function getPathEnvCacheSizes() {
+  return {
+    byKey: pathEnvCache.size,
+    byPath: pathEnvByPath.size,
+    baseDirs: pathEnvBaseDirs.size
+  };
+}
+function isPathEnvName(name, baseDir) {
+  if (name in envFactories) return false;
+  if (name.includes("/") || name.startsWith("./") || name.startsWith("../")) return true;
+  const resolved = resolvePath(baseDir, name);
+  return resolved.endsWith(".ts") && existsSync(resolved);
+}
+function rewriteBareImports(text) {
+  const require2 = createRequire(import.meta.url);
+  let rewrote = false;
+  const out = text.replace(/(["'])(@nudojs\/[a-z0-9-]+)\1/g, (_m, quote, spec) => {
+    try {
+      const entry = require2.resolve(spec);
+      const url = pathToFileURL(entry).href;
+      rewrote = true;
+      return `${quote}${url}${quote}`;
+    } catch {
+      return `${quote}${spec}${quote}`;
+    }
+  });
+  return rewrote ? out : null;
+}
+async function importPathEnv(resolvedPath, mtimeMs) {
+  const cacheKey = `${resolvedPath}:${mtimeMs}`;
+  if (pathEnvCache.get(cacheKey)) return;
+  let mod = null;
+  try {
+    const url = pathToFileURL(resolvedPath).href + `?mtime=${mtimeMs}`;
+    mod = await import(url);
+  } catch {
+    mod = null;
+  }
+  if (!mod) {
+    try {
+      const text = readFileSync(resolvedPath, "utf-8");
+      const rewritten = rewriteBareImports(text);
+      if (rewritten === null) return;
+      const cacheDir = joinPath(tmpdir(), "nudo-env");
+      mkdirSync(cacheDir, { recursive: true });
+      const hash = createHash("md5").update(`${resolvedPath}:${mtimeMs}`).digest("hex").slice(0, 16);
+      const copyPath = joinPath(cacheDir, `${hash}.ts`);
+      writeFileSync(copyPath, rewritten, "utf-8");
+      mod = await import(pathToFileURL(copyPath).href);
+    } catch {
+      return;
+    }
+  }
+  if (mod && typeof mod.defineEnv === "function") {
+    pathEnvCache.set(cacheKey, mod.defineEnv);
+    pathEnvByPath.set(resolvedPath, {
+      factory: mod.defineEnv,
+      mtimeMs
+    });
+  }
+}
+function lookupPathEnv(name) {
+  if (pathEnvByPath.size === 0) return void 0;
+  const candidates = name.startsWith("/") ? [name] : [name, ...[...pathEnvBaseDirs].map((d) => resolvePath(d, name))];
+  for (const candidate of candidates) {
+    const hit = pathEnvByPath.get(candidate);
+    if (!hit) continue;
+    try {
+      const { mtimeMs } = statSync(candidate);
+      if (mtimeMs !== hit.mtimeMs) {
+        pathEnvByPath.delete(candidate);
+        return void 0;
+      }
+    } catch {
+      pathEnvByPath.delete(candidate);
+      return void 0;
+    }
+    return hit.factory;
+  }
+  return void 0;
+}
+function clearPathEnvCaches() {
+  pathEnvCache.clear();
+  pathEnvByPath.clear();
+  pathEnvBaseDirs.clear();
+}
+async function preloadPathEnvs(envNames, baseDir) {
+  addPathEnvBaseDir(baseDir);
+  for (const name of envNames) {
+    if (!isPathEnvName(name, baseDir)) continue;
+    const resolved = resolvePath(baseDir, name);
+    if (!existsSync(resolved)) continue;
+    try {
+      const { mtimeMs } = statSync(resolved);
+      await importPathEnv(resolved, mtimeMs);
+    } catch {
+    }
+  }
+}
+async function loadEnvsAsync(envNames, globalEnv, baseDir = process.cwd()) {
+  await preloadPathEnvs(envNames, baseDir);
+  return loadEnvs(envNames, globalEnv);
+}
+function loadEnvs(envNames, globalEnv) {
+  const allModules = {};
+  const allGlobals = {};
+  const resolved = resolveEnvNames(envNames);
+  for (const name of resolved) {
+    const factory = envFactories[name] ?? lookupPathEnv(name);
+    if (!factory) continue;
+    const def = factory();
+    for (const [key, value] of Object.entries(def.globals)) {
+      allGlobals[key] = value;
+      globalEnv.bind(key, value);
+    }
+    if (def.modules) {
+      for (const [modName, exports] of Object.entries(def.modules)) {
+        allModules[modName] = { ...allModules[modName], ...exports };
+      }
+    }
+  }
+  return { modules: allModules, globals: allGlobals };
+}
+
+export {
+  BoundedLruMap,
+  getPathEnvCacheSizes,
+  clearPathEnvCaches,
+  preloadPathEnvs,
+  loadEnvsAsync,
+  loadEnvs
+};