@nudojs/service 4.0.0 → 5.0.0-beta.1

package/dist/chunk-J2PUE4NV.js

@@ -0,0 +1,235 @@
+// src/what-if.ts
+import { parse } from "@nudojs/parser";
+function splitTopLevelUnion(expr) {
+  const members = [];
+  let start = 0;
+  let depth = 0;
+  for (let i = 0; i < expr.length; i++) {
+    const c = expr[i];
+    if (c === "(" || c === "[" || c === "{") depth++;
+    else if (c === ")" || c === "]" || c === "}") depth--;
+    else if (c === "|" && depth === 0) {
+      members.push(expr.slice(start, i));
+      start = i + 1;
+    }
+  }
+  members.push(expr.slice(start));
+  return members.map((m) => m.trim()).filter(Boolean);
+}
+function typeExprToDirective(expr) {
+  const members = splitTopLevelUnion(expr);
+  if (members.length === 0) return "any()";
+  const mapped = members.map((m) => {
+    if (m.startsWith("T.")) return "any()";
+    if (m === "number" || m === "string" || m === "boolean") return `${m}()`;
+    if (m === "unknown" || m === "any") return "any()";
+    if (m === "null" || m === "undefined" || m === "true" || m === "false") return m;
+    if (/^-?\d+(\.\d+)?$/.test(m)) return m;
+    if (/^["']/.test(m)) return m;
+    if (/[([{]|=>/.test(m) && !m.startsWith("T.")) return m;
+    if (/^(number|string|boolean|any|array|shape|lit|union|fn)\s*\(/.test(m)) return m;
+    return "any()";
+  });
+  return mapped.length === 1 ? mapped[0] : `union(${mapped.join(", ")})`;
+}
+function declaredNames(stmt, out) {
+  if (stmt.type === "FunctionDeclaration" && stmt.id) out.add(stmt.id.name);
+  else if (stmt.type === "ClassDeclaration" && stmt.id) out.add(stmt.id.name);
+  else if (stmt.type === "VariableDeclaration") {
+    for (const decl of stmt.declarations) {
+      if (decl.id?.type === "Identifier") out.add(decl.id.name);
+    }
+  } else if (stmt.type === "ExportNamedDeclaration" && stmt.declaration) {
+    declaredNames(stmt.declaration, out);
+  }
+}
+function injectBindings(source, bindings) {
+  const applied = [];
+  const unapplied = [];
+  if (bindings.length === 0) return { source, applied, unapplied };
+  const ast = parse(source);
+  const declLines = /* @__PURE__ */ new Map();
+  for (const stmt of ast.program.body) {
+    const names = /* @__PURE__ */ new Set();
+    declaredNames(stmt, names);
+    if (names.size === 0 || !stmt.loc) continue;
+    const anchorLine = stmt.leadingComments?.[0]?.loc?.start.line ?? stmt.loc.start.line;
+    for (const name of names) {
+      if (!declLines.has(name)) declLines.set(name, anchorLine);
+    }
+  }
+  const byLine = /* @__PURE__ */ new Map();
+  for (const binding of bindings) {
+    const line = declLines.get(binding.name);
+    if (line === void 0) {
+      unapplied.push(binding.name);
+      continue;
+    }
+    const group = byLine.get(line) ?? [];
+    group.push(binding);
+    byLine.set(line, group);
+    applied.push(binding.name);
+  }
+  const insertions = [];
+  for (const [line, group] of byLine) {
+    insertions.push({
+      index: line - 1,
+      text: `// @nudo:as ${typeExprToDirective(group[0].type)}`
+    });
+  }
+  insertions.sort((a, b) => b.index - a.index);
+  const lines = source.split("\n");
+  for (const ins of insertions) lines.splice(ins.index, 0, ins.text);
+  return { source: lines.join("\n"), applied, unapplied };
+}
+
+// src/dep-contents.ts
+import { loadModuleDepsFingerprint } from "@nudojs/core/internal";
+function collectLoadDepContents(filePath, source, loadModule) {
+  const fp = loadModuleDepsFingerprint(source, loadModule, filePath);
+  const depContents = fp.contents.length > 0 ? fp.contents : fp.paths.map((path) => ({ path, content: null }));
+  return { depContents, truncated: fp.truncated };
+}
+
+// src/disk-cache.ts
+import { createHash } from "crypto";
+import { createRequire } from "module";
+import { mkdirSync, readFileSync, writeFileSync, existsSync, rmSync } from "fs";
+import { join, dirname, relative, sep, isAbsolute } from "path";
+function readServiceVersion() {
+  try {
+    const require2 = createRequire(import.meta.url);
+    for (const p of ["../package.json", "./package.json", "../../package.json"]) {
+      try {
+        const pkg = require2(p);
+        if (pkg?.name === "@nudojs/service" && pkg.version) return pkg.version;
+        if (pkg?.version && p.includes("service")) return pkg.version;
+      } catch {
+      }
+    }
+  } catch {
+  }
+  return "0";
+}
+var ANALYSIS_ABI = `nudo-check-cache-v3+${readServiceVersion()}`;
+function sha256Hex(data) {
+  return createHash("sha256").update(data).digest("hex");
+}
+function relativizePath(p, root) {
+  const norm = p.split(sep).join("/");
+  if (!root) return norm;
+  const r = relative(root, p).split(sep).join("/");
+  if (!r.startsWith("..") && !isAbsolute(r)) return r;
+  return `ext:${createHash("sha256").update(norm).digest("hex").slice(0, 16)}`;
+}
+function sanitizeCacheNamespace(ns) {
+  return ns.replace(/[^a-z0-9_-]/gi, "_").replace(/^_+|_+$/g, "") || "cache";
+}
+var DiskCache = class {
+  root;
+  ns;
+  enabled = false;
+  constructor(opts) {
+    this.root = opts.root;
+    this.ns = sanitizeCacheNamespace(opts.namespace);
+    this.enabled = !!opts.root;
+  }
+  pathFor(key) {
+    if (!/^[a-f0-9]{16,128}$/i.test(key)) {
+      throw new Error("DiskCache key must be a hex digest");
+    }
+    return join(this.root, this.ns, key.slice(0, 2), `${key}.json`);
+  }
+  get(key) {
+    if (!this.enabled || !this.root) return void 0;
+    try {
+      const p = this.pathFor(key);
+      if (!existsSync(p)) return void 0;
+      const raw = readFileSync(p, "utf8");
+      const parsed = JSON.parse(raw);
+      if (parsed?.abi !== ANALYSIS_ABI) return void 0;
+      return parsed.value;
+    } catch {
+      return void 0;
+    }
+  }
+  set(key, value) {
+    if (!this.enabled || !this.root) return;
+    try {
+      const p = this.pathFor(key);
+      mkdirSync(dirname(p), { recursive: true });
+      writeFileSync(p, JSON.stringify({ abi: ANALYSIS_ABI, value }), "utf8");
+    } catch {
+    }
+  }
+  clearNamespace() {
+    if (!this.enabled || !this.root) return;
+    try {
+      rmSync(join(this.root, this.ns), { recursive: true, force: true });
+    } catch {
+    }
+  }
+};
+function checkCacheKey(filePath, source, opts) {
+  const rel = relativizePath(filePath, opts.projectDir);
+  const sidecarSha = opts.sidecarContent != null ? sha256Hex(opts.sidecarContent) : "nosidecar";
+  const depSeg = (opts.depContents ?? []).map(
+    (d) => `${relativizePath(d.path, opts.projectDir)}\0${d.content != null ? sha256Hex(d.content) : "miss"}`
+  ).join("\n");
+  const envSeg = (opts.projectEnvNames ?? []).length > 0 ? [...opts.projectEnvNames ?? []].sort().join(",") : "-";
+  const cfgSeg = opts.analysisCfg ? `${opts.analysisCfg.mode ?? "-"}|${opts.analysisCfg.evalMissingSlot ?? "-"}|${opts.analysisCfg.callSiteBudget ?? "-"}|${opts.analysisCfg.entryThrows ?? "-"}|${opts.analysisCfg.ignoreThrows ?? "-"}` : "-";
+  return sha256Hex(
+    [
+      ANALYSIS_ABI,
+      rel,
+      opts.autoBind ? "ab1" : "ab0",
+      sha256Hex(source),
+      sidecarSha,
+      depSeg,
+      envSeg,
+      cfgSeg
+    ].join("\0")
+  );
+}
+function ifaceCacheKey(filePath, source, opts) {
+  const rel = relativizePath(filePath, opts.projectDir);
+  const sidecarSeg = opts.autoBind && opts.sidecarSource !== void 0 ? `sc:${sha256Hex(opts.sidecarSource)}` : "sc0";
+  const depSeg = (opts.depContents ?? []).map(
+    (d) => `${relativizePath(d.path, opts.projectDir)}\0${d.content != null ? sha256Hex(d.content) : "miss"}`
+  ).join("\n");
+  const envSeg = (opts.projectEnvNames ?? []).length > 0 ? [...opts.projectEnvNames ?? []].sort().join(",") : "-";
+  return sha256Hex(
+    [
+      ANALYSIS_ABI,
+      "iface",
+      rel,
+      opts.autoBind ? "ab1" : "ab0",
+      sha256Hex(source),
+      sidecarSeg,
+      depSeg,
+      envSeg
+    ].join("\0")
+  );
+}
+function extractNudoImportSpecs(source) {
+  const specs = /* @__PURE__ */ new Set();
+  const named = /@nudo:import\s*\{[^}]*\}\s*from\s*["']([^"']+)["']/g;
+  const ns = /@nudo:import\s+\*\s+as\s+\w+\s+from\s*["']([^"']+)["']/g;
+  let m;
+  while (m = named.exec(source)) specs.add(m[1]);
+  while (m = ns.exec(source)) specs.add(m[1]);
+  return [...specs];
+}
+
+export {
+  typeExprToDirective,
+  injectBindings,
+  collectLoadDepContents,
+  ANALYSIS_ABI,
+  sha256Hex,
+  relativizePath,
+  DiskCache,
+  checkCacheKey,
+  ifaceCacheKey,
+  extractNudoImportSpecs
+};