@nudojs/cli 0.1.0 → 0.2.1

package/dist/evaluator-api.d.ts

@@ -1,6 +1,10 @@
 import { Node } from '@babel/types';
-import { Environment, TypeValue } from '@nudojs/core';
+import { TypeValue, Environment } from '@nudojs/core';
 
+/** 值上命名成员是否可能存在（union 部分成员持有的 no-method 降 warning
+ * 用）：primitive/literal 走 wrapper 原型近似表（'x'.charCodeAt），
+ * instance 走近似方法表。诊断侧据此区分"部分成员可能有"与"确定没有"。 */
+declare function memberMayExistOn(tv: TypeValue, propName: string): boolean;
 type SourceRange = {
     start: {
         line: number;
@@ -11,6 +15,7 @@ type SourceRange = {
         column: number;
     };
 };
+declare function setCurrentSource(source: string): void;
 declare const RETURN_SIGNAL: unique symbol;
 declare const BRANCH_SIGNAL: unique symbol;
 declare const THROW_SIGNAL: unique symbol;
@@ -33,8 +38,79 @@ declare function resetMemo(): void;
 declare function setModuleResolver(resolver: ((source: string, fromDir: string) => {
     ast: Node;
     filePath: string;
+    json?: unknown;
 } | null) | null): void;
+declare function setEnvModules(modules: Record<string, Record<string, TypeValue>>): void;
+declare function resetEnvModules(): void;
+declare function setMockModules(mocks: Map<string, {
+    fromPath: string;
+    names?: string[];
+}>): void;
+declare function resetMockModules(): void;
+declare function setUnknownBuiltinHandler(handler: ((name: string, loc?: {
+    start: {
+        line: number;
+        column: number;
+    };
+    end: {
+        line: number;
+        column: number;
+    };
+}) => void) | null): void;
+declare function setSampleCount(count: number): void;
+declare function setMaxConcreteIter(count: number): void;
 declare function setNodeTypeCollector(collector: ((node: Node, tv: TypeValue) => void) | null): void;
+type CallRecord = {
+    fnName: string;
+    argTypes: TypeValue[];
+    resultType: TypeValue;
+    throws: TypeValue;
+    callLoc?: {
+        line: number;
+        column: number;
+    };
+    targetModule?: string;
+    targetExport?: string;
+    /** export names the same function value was re-exported under after its
+     * defining module (barrel `index.js`, CJS forwarding shims); usage-site
+     * records stay name-matchable against them */
+    targetAliases?: string[];
+    /** module whose evaluation created the function value (definition site).
+     * Usage-site collection transitively evaluates the library under require(),
+     * so records of the library's INTERNAL calls (no export tag) can still be
+     * attributed to the defining file — while test-local functions and builtin
+     * statics stay unattributed and cannot pollute same-name candidates. */
+    fnModule?: string;
+};
+/** usage-site 执行标记：外部调用记录的实参里携带的闭包（测试回调等）在
+ * case 合成重求值时被执行，其内部错误属于使用现场文件，与本文件分析无关。
+ * 分析侧在注入前对全部外部实参调用本函数；执行来源栈读到该标记时
+ * recordUnknown.originModule 记为标记值，分析侧据此丢弃。不按模块路径
+ * 比较——跨文件依赖（本文件 require 链上加载的模块）的执行记录是合法
+ * 的可达分析，不能误伤。 */
+declare const USAGE_SITE_MODULE = "__usage_site__";
+declare function setUsageSiteTag(tv: TypeValue, _seen?: Set<object>): void;
+declare function setCallCollector(collector: ((record: CallRecord) => void) | null): void;
+type UnknownRecord = {
+    kind: "method" | "property" | "global";
+    name: string;
+    receiverType?: TypeValue;
+    loc?: {
+        line: number;
+        column: number;
+    };
+    reason?: string;
+    origin?: {
+        line: number;
+        column: number;
+    };
+    /** 定义当前正在执行的函数的模块（执行来源栈顶）。case 合成重求值会执行
+     * 注入实参携带的使用现场闭包体，其内部错误记录属于使用现场文件——
+     * 分析侧据此丢弃（行数守卫会被同行号假阳性骗过）。 */
+    originModule?: string;
+};
+declare function setUnknownCollector(collector: ((record: UnknownRecord) => void) | null): void;
+declare function setProvenanceTracking(enabled: boolean): void;
 declare function evaluate(node: Node, env: Environment): EvalResult;
 type CallResult = {
     value: TypeValue;
@@ -54,4 +130,22 @@ declare function setCurrentFileDir(dir: string): void;
  */
 declare function narrow(test: Node, env: Environment): [trueEnv: Environment, falseEnv: Environment];
 
-export { evaluate, evaluateFunction, evaluateFunctionFull, evaluateProgram, getUnreachableRanges, narrow, resetMemo, resetUnreachableRanges, setCurrentFileDir, setModuleResolver, setNodeTypeCollector };
+type LoadedEnv = {
+    modules: Record<string, Record<string, TypeValue>>;
+};
+declare function preloadPathEnvs(envNames: string[], baseDir: string): Promise<void>;
+declare function loadEnvsAsync(envNames: string[], globalEnv: Environment, baseDir?: string): Promise<LoadedEnv>;
+declare function loadEnvs(envNames: string[], globalEnv: Environment): LoadedEnv;
+
+type NudoConfig = {
+    env?: string[];
+    mocks?: Record<string, string>;
+};
+declare function findProjectConfig(startDir: string): {
+    config: NudoConfig;
+    projectDir: string;
+} | null;
+
+declare function resolveNpmNudo(source: string, fromDir: string): string | null;
+
+export { type CallRecord, type LoadedEnv, type NudoConfig, USAGE_SITE_MODULE, type UnknownRecord, evaluate, evaluateFunction, evaluateFunctionFull, evaluateProgram, findProjectConfig, getUnreachableRanges, loadEnvs, loadEnvsAsync, memberMayExistOn, narrow, preloadPathEnvs, resetEnvModules, resetMemo, resetMockModules, resetUnreachableRanges, resolveNpmNudo, setCallCollector, setCurrentFileDir, setCurrentSource, setEnvModules, setMaxConcreteIter, setMockModules, setModuleResolver, setNodeTypeCollector, setProvenanceTracking, setSampleCount, setUnknownBuiltinHandler, setUnknownCollector, setUsageSiteTag };

package/dist/evaluator-api.js

@@ -1,26 +1,214 @@
 import {
+  USAGE_SITE_MODULE,
   evaluate,
   evaluateFunction,
   evaluateFunctionFull,
   evaluateProgram,
   getUnreachableRanges,
+  memberMayExistOn,
   narrow,
+  resetEnvModules,
   resetMemo,
+  resetMockModules,
   resetUnreachableRanges,
+  resolveNpmNudo,
+  setCallCollector,
   setCurrentFileDir,
+  setCurrentSource,
+  setEnvModules,
+  setMaxConcreteIter,
+  setMockModules,
   setModuleResolver,
-  setNodeTypeCollector
-} from "./chunk-JW3RMCNY.js";
+  setNodeTypeCollector,
+  setProvenanceTracking,
+  setSampleCount,
+  setUnknownBuiltinHandler,
+  setUnknownCollector,
+  setUsageSiteTag
+} from "./chunk-3HCPXPEW.js";
+
+// src/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";
+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 pathEnvCache = /* @__PURE__ */ new Map();
+var pathEnvByPath = /* @__PURE__ */ new Map();
+var pathEnvBaseDirs = /* @__PURE__ */ new Set();
+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.has(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, mod.defineEnv);
+  }
+}
+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) return hit;
+  }
+  return void 0;
+}
+async function preloadPathEnvs(envNames, baseDir) {
+  pathEnvBaseDirs.add(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 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)) {
+      globalEnv.bind(key, value);
+    }
+    if (def.modules) {
+      for (const [modName, exports] of Object.entries(def.modules)) {
+        allModules[modName] = { ...allModules[modName], ...exports };
+      }
+    }
+  }
+  return { modules: allModules };
+}
+
+// src/config.ts
+import { readFileSync as readFileSync2, existsSync as existsSync2 } from "fs";
+import { resolve, dirname } from "path";
+function findProjectConfig(startDir) {
+  let dir = resolve(startDir);
+  const root = resolve("/");
+  while (dir !== root) {
+    const pkgPath = resolve(dir, "package.json");
+    if (existsSync2(pkgPath)) {
+      try {
+        const pkg = JSON.parse(readFileSync2(pkgPath, "utf-8"));
+        if (pkg.nudo) {
+          return { config: pkg.nudo, projectDir: dir };
+        }
+      } catch {
+      }
+      return null;
+    }
+    const parent = dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return null;
+}
 export {
+  USAGE_SITE_MODULE,
   evaluate,
   evaluateFunction,
   evaluateFunctionFull,
   evaluateProgram,
+  findProjectConfig,
   getUnreachableRanges,
+  loadEnvs,
+  loadEnvsAsync,
+  memberMayExistOn,
   narrow,
+  preloadPathEnvs,
+  resetEnvModules,
   resetMemo,
+  resetMockModules,
   resetUnreachableRanges,
+  resolveNpmNudo,
+  setCallCollector,
   setCurrentFileDir,
+  setCurrentSource,
+  setEnvModules,
+  setMaxConcreteIter,
+  setMockModules,
   setModuleResolver,
-  setNodeTypeCollector
+  setNodeTypeCollector,
+  setProvenanceTracking,
+  setSampleCount,
+  setUnknownBuiltinHandler,
+  setUnknownCollector,
+  setUsageSiteTag
 };