@nudojs/service 4.0.0 → 5.0.0-beta.0

package/dist/chunk-E4N4A4JV.js

@@ -0,0 +1,651 @@
+import {
+  collectAbsBindingsFromGraph,
+  collectEnvNames,
+  isBPathCapable,
+  locFromNode,
+  mockDirectivesToAbsSeeds
+} from "./chunk-QAFMPM2E.js";
+import {
+  builtinProtoMember,
+  builtinProtoMemberNames,
+  describeAbsMember
+} from "./chunk-YLALZXTZ.js";
+import {
+  preloadPathEnvs
+} from "./chunk-PVJIMQRI.js";
+
+// src/lsp-surface.ts
+import { dirname } from "path";
+import traverse from "@babel/traverse";
+import {
+  generalizeFromAst,
+  formatAbs,
+  formatAbsMultiline,
+  formatShape,
+  interfaceTierOf
+} from "@nudojs/core";
+import { parse, extractDirectives, extractFileDirectives } from "@nudojs/parser";
+function getCasesForFile(filePath, source) {
+  const ast = parse(source);
+  const functions = extractDirectives(ast);
+  return functions.map((fn) => {
+    const cases = fn.directives.filter((d) => d.kind === "case").map((d, i) => ({ name: d.name, index: i }));
+    return { functionName: fn.name, cases, loc: locFromNode(fn.node) };
+  });
+}
+async function getTypeAtPositionAsync(filePath, source, line, column, activeCases) {
+  const envNames = collectEnvNames(filePath, source, false);
+  if (envNames.length > 0) {
+    await preloadPathEnvs(envNames, dirname(filePath));
+  }
+  return getTypeAtPosition(filePath, source, line, column, activeCases);
+}
+async function getAbsAtPositionAsync(filePath, source, line, column, activeCases) {
+  const envNames = collectEnvNames(filePath, source, false);
+  if (envNames.length > 0) {
+    await preloadPathEnvs(envNames, dirname(filePath));
+  }
+  return getAbsAtPosition(filePath, source, line, column, activeCases);
+}
+function positionInsideCaseFunction(source, ast, line) {
+  try {
+    const enclosing = findEnclosingFunction(extractDirectives(ast), line);
+    return !!enclosing && enclosing.directives.some((d) => d.kind === "case");
+  } catch {
+    return false;
+  }
+}
+function absFromBPath(filePath, source, line, column, ast, envNames) {
+  if (!isBPathCapable(source, envNames)) return null;
+  if (positionInsideCaseFunction(source, ast, line)) return null;
+  try {
+    const seeds = mockDirectivesToAbsSeeds(extractDirectives(ast), { fromFile: filePath });
+    const ident = findIdentNameAtPosition(source, line, column, ast);
+    if (ident) {
+      const binds = collectAbsBindingsFromGraph(source, filePath, {
+        seedVars: seeds.seedVars,
+        seedFns: seeds.seedFns
+      });
+      const bound = binds.get(ident);
+      if (bound) return bound;
+    }
+  } catch {
+  }
+  return null;
+}
+function absFromCaseReplay(_filePath, _source, _line, _column, _ast, _activeCases) {
+  return null;
+}
+function getAbsAtPosition(filePath, source, line, column, activeCases) {
+  const ast = parse(source);
+  const envNames = extractFileDirectives(ast).filter((d) => d.kind === "env").flatMap((d) => d.envs);
+  const fromB = absFromBPath(filePath, source, line, column, ast, envNames);
+  if (fromB) return fromB;
+  if (positionInsideCaseFunction(source, ast, line)) {
+    const fromCase = absFromCaseReplay(filePath, source, line, column, ast, activeCases);
+    if (fromCase) return fromCase;
+  }
+  return null;
+}
+function getTypeAtPosition(filePath, source, line, column, activeCases) {
+  return getAbsAtPosition(filePath, source, line, column, activeCases);
+}
+function getHoverAtPosition(filePath, source, line, column, activeCases, opts) {
+  let file;
+  try {
+    file = parse(source);
+  } catch {
+    file = void 0;
+  }
+  const envNames = collectEnvNames(filePath, source, false);
+  const fnName = findFunctionNameAtPosition(source, line, column, file);
+  const tier = fnName !== void 0 ? interfaceTierOf(source, fnName, filePath, opts ?? {}) : void 0;
+  let gDisplay;
+  let gAbs;
+  let gMulti;
+  if (fnName) {
+    try {
+      const g = generalizeFromAst(fnName, source, file ? { file } : {});
+      if (g) {
+        gDisplay = g.display;
+        gAbs = formatAbs(g.symbolic);
+        gMulti = formatAbsMultiline(g.symbolic, fnName);
+      }
+    } catch {
+    }
+  }
+  const withTier = (info) => {
+    if (!info || !tier) return info;
+    return {
+      ...info,
+      interfaceSource: tier.source,
+      ...tier.display !== void 0 ? { interfaceDisplay: tier.display } : {}
+    };
+  };
+  const attachIntension = (info) => {
+    if (!gDisplay) return withTier(info);
+    if (!info) {
+      return withTier({ typeText: gDisplay, intension: gDisplay, abs: gAbs, absMultiline: gMulti });
+    }
+    return withTier({
+      ...info,
+      intension: gDisplay,
+      // 外延侧已有更准 Abs 时保留；否则用 symbolic 兜底
+      abs: info.abs ?? gAbs,
+      absMultiline: info.absMultiline ?? gMulti
+    });
+  };
+  const insideCaseFn = positionInsideCaseFunction(
+    source,
+    file ?? parse(source),
+    line
+  );
+  if (!insideCaseFn) {
+    const fromB = absFromBPath(
+      filePath,
+      source,
+      line,
+      column,
+      file ?? parse(source),
+      envNames
+    );
+    if (fromB) {
+      const absLine = formatAbs(fromB);
+      const absMulti = formatAbsMultiline(fromB, void 0);
+      return attachIntension({ typeText: absLine, abs: absLine, absMultiline: absMulti });
+    }
+  } else {
+    const fromCase = absFromCaseReplay(
+      filePath,
+      source,
+      line,
+      column,
+      file ?? parse(source),
+      activeCases
+    );
+    if (fromCase) {
+      const absLine = formatAbs(fromCase);
+      const absMulti = formatAbsMultiline(fromCase, void 0);
+      return attachIntension({ typeText: absLine, abs: absLine, absMultiline: absMulti });
+    }
+  }
+  const absFallback = getAbsAtPosition(filePath, source, line, column, activeCases);
+  if (absFallback) {
+    const absLine = formatAbs(absFallback);
+    const absMulti = formatAbsMultiline(absFallback, void 0);
+    return attachIntension({ typeText: absLine, abs: absLine, absMultiline: absMulti });
+  }
+  const ident = findIdentNameAtPosition(source, line, column, file);
+  if (ident && !fnName && !insideCaseFn) {
+    try {
+      if (isBPathCapable(source, []) || !/\brequire\s*\(/.test(source)) {
+        const seeds = mockDirectivesToAbsSeeds(extractDirectives(file ?? parse(source)), {
+          fromFile: filePath
+        });
+        const absBinds = collectAbsBindingsFromGraph(source, filePath, {
+          seedVars: seeds.seedVars,
+          seedFns: seeds.seedFns
+        });
+        const absBound = absBinds.get(ident);
+        if (absBound) {
+          const absLine = formatAbs(absBound);
+          const absMulti = formatAbsMultiline(absBound, ident);
+          return attachIntension({ typeText: absLine, abs: absLine, absMultiline: absMulti });
+        }
+      }
+    } catch {
+    }
+  }
+  if (tier && gDisplay) {
+    return withTier({
+      typeText: gDisplay,
+      intension: gDisplay,
+      abs: gAbs,
+      absMultiline: gMulti
+    });
+  }
+  return null;
+}
+function findIdentNameAtPosition(source, line, column, fileAst) {
+  try {
+    const ast = fileAst ?? parse(source);
+    let found;
+    traverse(ast, {
+      Identifier(path) {
+        const loc = path.node.loc;
+        if (!loc) return;
+        if (loc.start.line !== line) return;
+        if (column < loc.start.column || column > loc.end.column) return;
+        found = path.node.name;
+      }
+    });
+    return found;
+  } catch {
+    return void 0;
+  }
+}
+function findFunctionNameAtPosition(source, line, column, fileAst) {
+  try {
+    const ast = fileAst ?? parse(source);
+    let found;
+    traverse(ast, {
+      Identifier(path) {
+        const loc = path.node.loc;
+        if (!loc) return;
+        if (loc.start.line !== line) return;
+        if (column < loc.start.column || column > loc.end.column) return;
+        const parent = path.parent;
+        if (parent.type === "FunctionDeclaration" && parent.id === path.node) {
+          found = path.node.name;
+        } else if (parent.type === "CallExpression" && parent.callee === path.node) {
+          found = path.node.name;
+        }
+      }
+    });
+    return found;
+  } catch {
+    return void 0;
+  }
+}
+function findEnclosingFunction(functions, line) {
+  for (const fn of functions) {
+    const loc = fn.node.loc;
+    if (!loc) continue;
+    if (loc.start.line <= line && loc.end.line >= line) {
+      return fn;
+    }
+  }
+  return null;
+}
+function getCompletionsAtPosition(filePath, source, line, column) {
+  const textBefore = getTextBeforePosition(source, line, column);
+  const dotMatch = textBefore.match(/(\w+)\.\s*\w*$/);
+  if (!dotMatch) return getVariableCompletions(filePath, source);
+  const objName = dotMatch[1];
+  const safeSource = sanitizeSourceForParsing(source);
+  let ast;
+  try {
+    ast = parse(safeSource);
+  } catch {
+    try {
+      ast = parse(source);
+    } catch {
+      return [];
+    }
+  }
+  try {
+    const seeds = mockDirectivesToAbsSeeds(extractDirectives(ast), { fromFile: filePath });
+    const binds = collectAbsBindingsFromGraph(source, filePath, {
+      seedVars: seeds.seedVars,
+      seedFns: seeds.seedFns
+    });
+    const bound = binds.get(objName);
+    if (bound && bound.shape.k !== "unknown" && bound.shape.k !== "never") {
+      const absCompletions = getCompletionsForAbs(bound);
+      if (absCompletions.length > 0) return absCompletions;
+    }
+  } catch {
+  }
+  return [];
+}
+function sanitizeSourceForParsing(source) {
+  return source.replace(/(\w+)\.\s*$/gm, "$1._ ");
+}
+function getTextBeforePosition(source, line, column) {
+  const lines = source.split("\n");
+  if (line < 1 || line > lines.length) return "";
+  return lines[line - 1].slice(0, column);
+}
+function getVariableCompletions(filePath, source) {
+  const ast = parse(source);
+  try {
+    const seeds = mockDirectivesToAbsSeeds(extractDirectives(ast), { fromFile: filePath });
+    const binds = collectAbsBindingsFromGraph(source, filePath, {
+      seedVars: seeds.seedVars,
+      seedFns: seeds.seedFns
+    });
+    if (binds.size > 0) {
+      const completions = [];
+      for (const [name, absVal] of binds) {
+        if (name.startsWith("__export_")) continue;
+        completions.push({
+          label: name,
+          kind: absVal.shape.k === "fn" ? "method" : "variable",
+          detail: absDetail(absVal)
+        });
+      }
+      if (completions.length > 0) return completions;
+    }
+  } catch {
+  }
+  return [];
+}
+function builtinMemberAbs(className, member) {
+  return builtinProtoMember(className, member);
+}
+function builtinProtoMembers(className) {
+  return builtinProtoMemberNames(className);
+}
+function describeMember(label, a, fallbackClass) {
+  if (a) {
+    const s = describeAbsMember(a);
+    if (s) return s;
+  }
+  return `${label}(\u2026)@${fallbackClass}`;
+}
+function getPromiseCompletions() {
+  return builtinProtoMembers("Promise").map((m) => ({
+    label: m,
+    kind: "method",
+    detail: describeMember(m, builtinMemberAbs("Promise", m), "Promise")
+  }));
+}
+function getStringCompletions() {
+  const completions = [];
+  for (const m of builtinProtoMembers("String")) {
+    completions.push({
+      label: m,
+      kind: "method",
+      detail: describeMember(m, builtinMemberAbs("String", m), "String")
+    });
+  }
+  completions.push({ label: "length", kind: "property", detail: "number" });
+  return completions;
+}
+function absDetail(a) {
+  try {
+    return formatShape(a);
+  } catch {
+    return formatAbs(a);
+  }
+}
+function absIsFn(a) {
+  return a.shape.k === "fn";
+}
+function getCompletionsForAbs(a) {
+  const s = a.shape;
+  switch (s.k) {
+    case "obj": {
+      const completions = [];
+      for (const [key, slot] of Object.entries(s.slots)) {
+        completions.push({
+          label: key,
+          kind: absIsFn(slot.value) ? "method" : "property",
+          detail: absDetail(slot.value)
+        });
+      }
+      return completions;
+    }
+    case "brand":
+      return getCompletionsForAbs(s.shape);
+    case "sum":
+      return getSumCompletions(s.members);
+    case "tuple":
+      if (a.conf === "exact") return getArrayCompletionsAbs(s.elements.length);
+      return [];
+    case "arr":
+      return getArrayCompletionsAbs(void 0);
+    case "eff":
+      if (s.eff === "promise") return getPromiseCompletions();
+      return [];
+    case "prim":
+      if (s.type === "string") return getStringCompletions();
+      return [];
+    default:
+      return [];
+  }
+}
+function getArrayCompletionsAbs(tupleLen) {
+  const completions = [];
+  for (const m of builtinProtoMembers("Array")) {
+    const detail = describeMember(m, builtinMemberAbs("Array", m), "Array");
+    completions.push({ label: m, kind: "method", detail });
+  }
+  completions.push({
+    label: "length",
+    kind: "property",
+    detail: tupleLen !== void 0 ? `${tupleLen}` : "number"
+  });
+  return completions;
+}
+function getSumCompletions(members) {
+  if (members.length === 0) return [];
+  const labelsByMember = members.map((m) => getCompletionsForAbs(m));
+  const baseIdx = labelsByMember.findIndex((labels) => labels.length > 0);
+  if (baseIdx === -1) return [];
+  const common = [];
+  for (const base of labelsByMember[baseIdx]) {
+    let allPresent = true;
+    const memberTypes = [base.detail ?? base.label];
+    for (let i = 0; i < members.length; i++) {
+      if (i === baseIdx) continue;
+      const labels = labelsByMember[i];
+      if (labels.length === 0) continue;
+      const hit = labels.find((l) => l.label === base.label);
+      if (!hit) {
+        allPresent = false;
+        break;
+      }
+      memberTypes.push(hit.detail ?? hit.label);
+    }
+    if (allPresent) {
+      common.push({ ...base, detail: memberTypes.join(" | ") });
+    }
+  }
+  return common;
+}
+
+// src/semantic-tokens.ts
+import { parse as parse2 } from "@nudojs/parser";
+import {
+  interfaceTierOf as interfaceTierOf2
+} from "@nudojs/core";
+var SEMANTIC_TOKEN_TYPES = [
+  "function",
+  "variable",
+  "parameter",
+  "property",
+  "type",
+  "keyword",
+  "string",
+  "number",
+  "comment",
+  "decorator",
+  "method"
+];
+var SEMANTIC_TOKEN_MODIFIERS = [
+  "declaration",
+  "readonly",
+  "deprecated",
+  "unreachable",
+  /** handwritten：显式契约（侧车手写 / @nudo:contract） */
+  "contract",
+  /** generated：侧车 @generated 段 */
+  "generated",
+  /** derived：implicit 展示档（非义务契约） */
+  "derived"
+];
+function encodeSemanticTokens(tokens) {
+  const result = [];
+  let prevLine = 0;
+  let prevChar = 0;
+  for (const token of tokens) {
+    const deltaLine = token.line - prevLine;
+    const deltaChar = deltaLine === 0 ? token.char - prevChar : token.char;
+    result.push(deltaLine, deltaChar, token.length, token.typeIndex, token.modifierBitmask);
+    prevLine = token.line;
+    prevChar = token.char;
+  }
+  return result;
+}
+var TYPE_FUNCTION = SEMANTIC_TOKEN_TYPES.indexOf("function");
+var TYPE_VARIABLE = SEMANTIC_TOKEN_TYPES.indexOf("variable");
+var TYPE_PARAMETER = SEMANTIC_TOKEN_TYPES.indexOf("parameter");
+var TYPE_PROPERTY = SEMANTIC_TOKEN_TYPES.indexOf("property");
+var TYPE_METHOD = SEMANTIC_TOKEN_TYPES.indexOf("method");
+var MOD_DECLARATION = 1 << SEMANTIC_TOKEN_MODIFIERS.indexOf("declaration");
+var MOD_CONTRACT = 1 << SEMANTIC_TOKEN_MODIFIERS.indexOf("contract");
+var MOD_GENERATED = 1 << SEMANTIC_TOKEN_MODIFIERS.indexOf("generated");
+var MOD_DERIVED = 1 << SEMANTIC_TOKEN_MODIFIERS.indexOf("derived");
+function interfaceTierModifierBit(src) {
+  return src === "handwritten" ? MOD_CONTRACT : src === "generated" ? MOD_GENERATED : MOD_DERIVED;
+}
+function collectFunctionBindingNames(filePath, source, _ast) {
+  try {
+    const binds = collectAbsBindingsFromGraph(source, filePath);
+    if (binds.size > 0) {
+      const fns = /* @__PURE__ */ new Set();
+      for (const [name, a] of binds) {
+        if (a.shape.k === "fn") fns.add(name);
+      }
+      return fns;
+    }
+  } catch {
+  }
+  return /* @__PURE__ */ new Set();
+}
+function buildSemanticTokens(filePath, source, opts) {
+  let ast;
+  try {
+    ast = parse2(source);
+  } catch {
+    return [];
+  }
+  const functionNames = collectFunctionBindingNames(filePath, source, ast);
+  const program = ast.program ?? ast;
+  const topLevelDeclarators = /* @__PURE__ */ new Set();
+  const topLevelFnDeclNodes = /* @__PURE__ */ new Set();
+  for (const stmt of program.body ?? []) {
+    const decl = stmt.type === "ExportNamedDeclaration" || stmt.type === "ExportDefaultDeclaration" ? stmt.declaration ?? null : stmt;
+    if (decl && decl.type === "VariableDeclaration") {
+      for (const d of decl.declarations) {
+        topLevelDeclarators.add(d);
+      }
+    }
+    if (decl && decl.type === "FunctionDeclaration" && decl.id) {
+      topLevelFnDeclNodes.add(decl);
+    }
+  }
+  const tierOpts = {
+    ...opts?.loadModule ? { loadModule: opts.loadModule } : {},
+    ...opts?.autoBind !== void 0 ? { autoBind: opts.autoBind } : {}
+  };
+  const tierModCache = /* @__PURE__ */ new Map();
+  const tierModFor = (name) => {
+    const cached = tierModCache.get(name);
+    if (cached !== void 0) return cached;
+    let bit = 0;
+    try {
+      const tier = interfaceTierOf2(source, name, filePath, tierOpts);
+      if (tier) bit = interfaceTierModifierBit(tier.source);
+    } catch {
+      bit = 0;
+    }
+    tierModCache.set(name, bit);
+    return bit;
+  };
+  const tokens = [];
+  const pushIdentifier = (id, typeIndex, extraMod = 0) => {
+    const loc = id.loc;
+    const name = id.name;
+    if (!loc || typeof name !== "string") return;
+    tokens.push({
+      line: loc.start.line - 1,
+      char: loc.start.column,
+      length: name.length,
+      typeIndex,
+      modifierBitmask: MOD_DECLARATION | extraMod
+    });
+  };
+  const collectParams = (params) => {
+    for (const p of params) {
+      if (!p) continue;
+      if (p.type === "Identifier") pushIdentifier(p, TYPE_PARAMETER);
+      else if (p.type === "AssignmentPattern" && p.left?.type === "Identifier") {
+        pushIdentifier(p.left, TYPE_PARAMETER);
+      } else if (p.type === "RestElement" && p.argument?.type === "Identifier") {
+        pushIdentifier(p.argument, TYPE_PARAMETER);
+      }
+    }
+  };
+  const isFunctionValue = (name) => functionNames.has(name);
+  const visit = (node) => {
+    if (!node || typeof node !== "object") return;
+    const n = node;
+    switch (n.type) {
+      case "VariableDeclarator": {
+        const id = n.id;
+        if (id?.type === "Identifier") {
+          const isTopLevel = topLevelDeclarators.has(node);
+          const name = id.name;
+          const isFn = isTopLevel && isFunctionValue(name);
+          const typeIndex = isFn ? TYPE_FUNCTION : TYPE_VARIABLE;
+          const extraMod = isFn ? tierModFor(name) : 0;
+          pushIdentifier(id, typeIndex, extraMod);
+        }
+        break;
+      }
+      case "FunctionDeclaration":
+      case "FunctionExpression": {
+        const id = n.id;
+        if (id?.type === "Identifier") {
+          const name = id.name;
+          const isTopLevelFnDecl = n.type === "FunctionDeclaration" && topLevelFnDeclNodes.has(node);
+          const extraMod = isTopLevelFnDecl ? tierModFor(name) : 0;
+          pushIdentifier(id, TYPE_FUNCTION, extraMod);
+        }
+        collectParams(n.params ?? []);
+        break;
+      }
+      case "ArrowFunctionExpression":
+        collectParams(n.params ?? []);
+        break;
+      case "ObjectMethod": {
+        const key = n.key;
+        if (key?.type === "Identifier" && !n.computed) pushIdentifier(key, TYPE_METHOD);
+        collectParams(n.params ?? []);
+        break;
+      }
+      case "ObjectProperty": {
+        const key = n.key;
+        const value = n.value;
+        if (key?.type === "Identifier" && !n.computed) {
+          const isFn = value?.type === "FunctionExpression" || value?.type === "ArrowFunctionExpression";
+          pushIdentifier(key, isFn ? TYPE_METHOD : TYPE_PROPERTY);
+        }
+        break;
+      }
+    }
+    for (const key of Object.keys(n)) {
+      if (key === "loc" || key === "start" || key === "end" || key === "leadingComments" || key === "trailingComments" || key === "innerComments") continue;
+      const child = n[key];
+      if (Array.isArray(child)) {
+        for (const item of child) {
+          if (item && typeof item === "object" && typeof item.type === "string") {
+            visit(item);
+          }
+        }
+      } else if (child && typeof child === "object" && typeof child.type === "string") {
+        visit(child);
+      }
+    }
+  };
+  visit(program);
+  tokens.sort((a, b) => a.line - b.line || a.char - b.char);
+  return encodeSemanticTokens(tokens);
+}
+
+export {
+  getCasesForFile,
+  getTypeAtPositionAsync,
+  getAbsAtPositionAsync,
+  getAbsAtPosition,
+  getTypeAtPosition,
+  getHoverAtPosition,
+  getCompletionsAtPosition,
+  SEMANTIC_TOKEN_TYPES,
+  SEMANTIC_TOKEN_MODIFIERS,
+  encodeSemanticTokens,
+  interfaceTierModifierBit,
+  buildSemanticTokens
+};