lurqrun 0.1.6 → 0.1.7

package/dist/chunk-ST2X2GYN.js

@@ -0,0 +1,373 @@
+import { createRequire as __lurqCreateRequire } from 'node:module'; const require = __lurqCreateRequire(import.meta.url);
+import {
+  init_esm_shims
+} from "./chunk-I3M2KJXB.js";
+
+// src/surface/references.ts
+init_esm_shims();
+import { execFileSync } from "child_process";
+import { readdirSync, readFileSync, statSync } from "fs";
+import { extname, join, relative } from "path";
+import ts from "typescript";
+var SOURCE_EXT = /* @__PURE__ */ new Set([".ts", ".tsx", ".mts", ".cts", ".js", ".jsx", ".mjs", ".cjs"]);
+var SKIP_DIRS = /* @__PURE__ */ new Set(["node_modules", ".git", "dist", "build", "out", ".next", "coverage"]);
+var SURFACE_CLAIM_KINDS = ["named", "destructured", "namespace"];
+function isRootSpecifier(ref, pkg) {
+  return ref.specifier === pkg;
+}
+function packageOfSpecifier(spec) {
+  if (!spec || spec.startsWith(".") || spec.startsWith("/")) return null;
+  if (spec.startsWith("node:")) return null;
+  const parts = spec.split("/");
+  return spec.startsWith("@") ? parts.slice(0, 2).join("/") : parts[0];
+}
+function listSourceFiles(dir, limit = 5e3) {
+  const tracked = gitSourceFiles(dir, limit);
+  if (tracked) return tracked;
+  const out = [];
+  let truncated = false;
+  const walk = (d) => {
+    if (truncated) return;
+    let entries;
+    try {
+      entries = readdirSync(d);
+    } catch {
+      return;
+    }
+    for (const e of entries) {
+      if (truncated) return;
+      if (SKIP_DIRS.has(e) || e.startsWith(".")) continue;
+      const full = join(d, e);
+      let st;
+      try {
+        st = statSync(full);
+      } catch {
+        continue;
+      }
+      if (st.isDirectory()) walk(full);
+      else if (SOURCE_EXT.has(extname(e)) && !e.endsWith(".d.ts")) {
+        if (out.length >= limit) truncated = true;
+        else out.push(full);
+      }
+    }
+  };
+  walk(dir);
+  return { files: out, truncated };
+}
+function gitSourceFiles(dir, limit) {
+  let stdout;
+  try {
+    stdout = execFileSync("git", ["ls-files", "--cached", "--others", "--exclude-standard"], {
+      cwd: dir,
+      encoding: "utf8",
+      maxBuffer: 32 * 1024 * 1024,
+      stdio: ["ignore", "pipe", "ignore"]
+    });
+  } catch {
+    return null;
+  }
+  const out = [];
+  for (const rel of stdout.split("\n")) {
+    if (!rel) continue;
+    if (!SOURCE_EXT.has(extname(rel)) || rel.endsWith(".d.ts")) continue;
+    if (rel.split("/").includes("node_modules")) continue;
+    if (out.length >= limit) return { files: out, truncated: true };
+    out.push(join(dir, rel));
+  }
+  return { files: out, truncated: false };
+}
+function loadedModule(expr) {
+  let e = expr;
+  while (ts.isParenthesizedExpression(e)) e = e.expression;
+  const awaited = ts.isAwaitExpression(e);
+  if (awaited) e = e.expression;
+  if (!ts.isCallExpression(e) || e.arguments.length !== 1) return null;
+  const arg = e.arguments[0];
+  if (!ts.isStringLiteralLike(arg)) return null;
+  if (e.expression.kind === ts.SyntaxKind.ImportKeyword) {
+    return awaited ? { spec: arg.text, loader: "import" } : null;
+  }
+  if (ts.isIdentifier(e.expression) && e.expression.text === "require") {
+    return { spec: arg.text, loader: "require" };
+  }
+  return null;
+}
+function callSiteOf(sf, node) {
+  const line = sf.getLineAndCharacterOfPosition(node.getStart(sf)).line + 1;
+  const p = node.parent;
+  if (p && (ts.isCallExpression(p) || ts.isNewExpression(p)) && p.expression === node) {
+    const args = p.arguments ?? [];
+    return { line, args: args.some(ts.isSpreadElement) ? null : args.length };
+  }
+  return { line, args: null };
+}
+function isValueUse(id) {
+  const p = id.parent;
+  if (!p) return false;
+  if (ts.isImportSpecifier(p) || ts.isImportClause(p) || ts.isNamespaceImport(p)) return false;
+  if (ts.isImportEqualsDeclaration(p) || ts.isLabeledStatement(p) || ts.isBreakOrContinueStatement(p)) return false;
+  if (ts.isPropertyAccessExpression(p) && p.name === id) return false;
+  if (ts.isQualifiedName(p) && p.right === id) return false;
+  if (ts.isBindingElement(p) && (p.name === id || p.propertyName === id)) return false;
+  if (ts.isExportSpecifier(p) && p.name === id && p.propertyName) return false;
+  const declares = ts.isVariableDeclaration(p) || ts.isParameter(p) || ts.isFunctionDeclaration(p) || ts.isFunctionExpression(p) || ts.isClassDeclaration(p) || ts.isClassExpression(p) || ts.isPropertyAssignment(p) || ts.isPropertyDeclaration(p) || ts.isPropertySignature(p) || ts.isMethodDeclaration(p) || ts.isGetAccessor(p) || ts.isSetAccessor(p) || ts.isEnumMember(p) || ts.isJsxAttribute(p) || ts.isMethodSignature(p) || ts.isInterfaceDeclaration(p) || ts.isTypeAliasDeclaration(p) || ts.isModuleDeclaration(p) || ts.isEnumDeclaration(p) || ts.isTypeParameterDeclaration(p);
+  return !(declares && p.name === id);
+}
+function isTypePosition(node) {
+  if (ts.isExpressionWithTypeArguments(node) && ts.isHeritageClause(node.parent) && node.parent.token === ts.SyntaxKind.ExtendsKeyword && ts.isClassLike(node.parent.parent)) {
+    return false;
+  }
+  return ts.isTypeNode(node);
+}
+function bindsName(id) {
+  const p = id.parent;
+  if (!p) return false;
+  if (ts.isImportClause(p) || ts.isNamespaceImport(p) || ts.isImportEqualsDeclaration(p)) return true;
+  if (ts.isImportSpecifier(p) || ts.isBindingElement(p) || ts.isVariableDeclaration(p) || ts.isParameter(p) || ts.isFunctionDeclaration(p) || ts.isFunctionExpression(p) || ts.isClassDeclaration(p) || ts.isClassExpression(p)) {
+    return p.name === id;
+  }
+  return false;
+}
+function valueUses(sf, locals) {
+  const out = /* @__PURE__ */ new Map();
+  const bindings = /* @__PURE__ */ new Map();
+  const visit = (node, inType) => {
+    if (ts.isIdentifier(node) && locals.has(node.text) && bindsName(node)) {
+      bindings.set(node.text, (bindings.get(node.text) ?? 0) + 1);
+    }
+    const nowInType = inType || isTypePosition(node);
+    if (!nowInType && ts.isIdentifier(node) && locals.has(node.text) && isValueUse(node)) {
+      const list = out.get(node.text);
+      if (list) list.push(callSiteOf(sf, node));
+      else out.set(node.text, [callSiteOf(sf, node)]);
+    }
+    ts.forEachChild(node, (c) => visit(c, nowInType));
+  };
+  visit(sf, false);
+  for (const [name, count] of bindings) {
+    const uses = out.get(name);
+    if (count > 1 && uses) out.set(name, uses.map((u) => ({ line: u.line, args: null })));
+  }
+  return out;
+}
+function collectValueIdentifiers(sf) {
+  const out = /* @__PURE__ */ new Set();
+  const visit = (node, inType) => {
+    const nowInType = inType || isTypePosition(node);
+    if (!nowInType && ts.isIdentifier(node) && node.parent && !ts.isImportSpecifier(node.parent) && !ts.isImportClause(node.parent) && !ts.isNamespaceImport(node.parent) && !ts.isPropertyAccessExpression(node.parent)) {
+      out.add(node.text);
+    }
+    if (!nowInType && ts.isPropertyAccessExpression(node) && ts.isIdentifier(node.expression)) {
+      out.add(node.expression.text);
+    }
+    ts.forEachChild(node, (c) => visit(c, nowInType));
+  };
+  visit(sf, false);
+  return out;
+}
+function scanReferences(rootDir, opts = {}) {
+  const byPackage = /* @__PURE__ */ new Map();
+  const record = (pkg, symbol, via, specifier, file, line, parent, call) => {
+    let syms = byPackage.get(pkg);
+    if (!syms) byPackage.set(pkg, syms = /* @__PURE__ */ new Map());
+    const list = syms.get(symbol);
+    const ref = {
+      symbol,
+      via,
+      specifier,
+      file,
+      line,
+      ...parent ? { parent } : {},
+      ...call ? { calls: [call] } : {}
+    };
+    if (!list) {
+      syms.set(symbol, [ref]);
+      return ref;
+    }
+    const same = list.find((r) => r.file === file && r.line === line && r.via === via);
+    if (!same) {
+      list.push(ref);
+      return ref;
+    }
+    if (call) (same.calls ??= []).push(call);
+    return same;
+  };
+  const listing = listSourceFiles(rootDir, opts.limit);
+  if (opts.stats) {
+    opts.stats.files = listing.files.length;
+    opts.stats.truncated = listing.truncated;
+  }
+  for (const file of listing.files) {
+    let text;
+    try {
+      text = readFileSync(file, "utf8");
+    } catch {
+      continue;
+    }
+    const rel = relative(rootDir, file);
+    const sf = ts.createSourceFile(file, text, ts.ScriptTarget.Latest, true);
+    const lineOf = (n) => sf.getLineAndCharacterOfPosition(n.getStart(sf)).line + 1;
+    const nsBindings = /* @__PURE__ */ new Map();
+    const defaultBindings = /* @__PURE__ */ new Map();
+    const namedBindings = /* @__PURE__ */ new Map();
+    const valueUsed = collectValueIdentifiers(sf);
+    const followed = /* @__PURE__ */ new Map();
+    const follow = (local, ref) => {
+      const list = followed.get(local);
+      if (list) list.push(ref);
+      else followed.set(local, [ref]);
+    };
+    const visit = (node) => {
+      if (ts.isImportDeclaration(node) && ts.isStringLiteral(node.moduleSpecifier)) {
+        const pkg = packageOfSpecifier(node.moduleSpecifier.text);
+        if (pkg) {
+          const clause = node.importClause;
+          if (!clause) record(pkg, "default", "side-effect", node.moduleSpecifier.text, rel, lineOf(node));
+          if (clause?.name) {
+            record(pkg, "default", "default", node.moduleSpecifier.text, rel, lineOf(clause.name));
+            defaultBindings.set(clause.name.text, { pkg, spec: node.moduleSpecifier.text });
+          }
+          if (clause?.namedBindings) {
+            if (ts.isNamespaceImport(clause.namedBindings)) {
+              nsBindings.set(clause.namedBindings.name.text, { pkg, spec: node.moduleSpecifier.text });
+            } else {
+              for (const el of clause.namedBindings.elements) {
+                const local = el.name.text;
+                const exported = el.propertyName?.text ?? local;
+                const typeOnly = clause.isTypeOnly || el.isTypeOnly || !valueUsed.has(local);
+                const ref = record(
+                  pkg,
+                  exported,
+                  typeOnly ? "type-only" : "named",
+                  node.moduleSpecifier.text,
+                  rel,
+                  lineOf(el)
+                );
+                if (!typeOnly) {
+                  follow(local, ref);
+                  namedBindings.set(local, {
+                    pkg,
+                    spec: node.moduleSpecifier.text,
+                    exported
+                  });
+                }
+              }
+            }
+          }
+        }
+      }
+      if (ts.isExportDeclaration(node) && node.moduleSpecifier && ts.isStringLiteral(node.moduleSpecifier) && node.exportClause && ts.isNamedExports(node.exportClause)) {
+        const spec = node.moduleSpecifier.text;
+        const pkg = packageOfSpecifier(spec);
+        if (pkg) {
+          for (const el of node.exportClause.elements) {
+            const exported = el.propertyName?.text ?? el.name.text;
+            const line = lineOf(el);
+            if (node.isTypeOnly || el.isTypeOnly) record(pkg, exported, "type-only", spec, rel, line);
+            else record(pkg, exported, "named", spec, rel, line, void 0, { line, args: null });
+          }
+        }
+      }
+      if (ts.isImportEqualsDeclaration(node) && !node.isTypeOnly && ts.isExternalModuleReference(node.moduleReference) && ts.isStringLiteral(node.moduleReference.expression)) {
+        const spec = node.moduleReference.expression.text;
+        const pkg = packageOfSpecifier(spec);
+        if (pkg) {
+          nsBindings.set(node.name.text, { pkg, spec, loader: "require" });
+          const ref = record(pkg, "default", "default", spec, rel, lineOf(node.name));
+          ref.loader = "require";
+          follow(node.name.text, ref);
+        }
+      }
+      if (ts.isVariableDeclaration(node) && node.initializer && ts.isIdentifier(node.initializer) && ts.isObjectBindingPattern(node.name)) {
+        const ns = nsBindings.get(node.initializer.text);
+        if (ns) {
+          for (const el of node.name.elements) {
+            const name = el.propertyName ?? el.name;
+            if (!ts.isIdentifier(name)) continue;
+            const ref = record(ns.pkg, name.text, "namespace", ns.spec, rel, lineOf(el));
+            if (ns.loader) ref.loader = ns.loader;
+            if (ts.isIdentifier(el.name)) follow(el.name.text, ref);
+          }
+        }
+      }
+      const loaded = ts.isVariableDeclaration(node) && node.initializer ? loadedModule(node.initializer) : null;
+      if (ts.isVariableDeclaration(node) && loaded) {
+        const spec = loaded.spec;
+        const viaRequire = loaded.loader === "require";
+        const pkg = packageOfSpecifier(spec);
+        if (pkg) {
+          if (ts.isIdentifier(node.name)) {
+            nsBindings.set(node.name.text, { pkg, spec, ...viaRequire ? { loader: "require" } : {} });
+            const ref = record(pkg, "default", "default", spec, rel, lineOf(node.name));
+            if (viaRequire) ref.loader = "require";
+            follow(node.name.text, ref);
+          } else if (ts.isObjectBindingPattern(node.name)) {
+            for (const el of node.name.elements) {
+              const name = el.propertyName ?? el.name;
+              if (!ts.isIdentifier(name)) continue;
+              const ref = record(pkg, name.text, "destructured", spec, rel, lineOf(el));
+              if (viaRequire) ref.loader = "require";
+              if (ts.isIdentifier(el.name)) follow(el.name.text, ref);
+            }
+          }
+        }
+      }
+      if (ts.isExpressionStatement(node)) {
+        const load = loadedModule(node.expression);
+        const pkg = load ? packageOfSpecifier(load.spec) : null;
+        if (load && pkg) {
+          const ref = record(pkg, "default", "side-effect", load.spec, rel, lineOf(node));
+          if (load.loader === "require") ref.loader = "require";
+        }
+      }
+      if (ts.isPropertyAccessExpression(node)) {
+        const load = loadedModule(node.expression);
+        const pkg = load ? packageOfSpecifier(load.spec) : null;
+        if (load && pkg) {
+          const ref = record(pkg, node.name.text, "namespace", load.spec, rel, lineOf(node), void 0, callSiteOf(sf, node));
+          if (load.loader === "require") ref.loader = "require";
+        }
+      }
+      if (ts.isPropertyAccessExpression(node) && ts.isIdentifier(node.expression)) {
+        const local = node.expression.text;
+        const ns = nsBindings.get(local);
+        const def = defaultBindings.get(local);
+        const named = namedBindings.get(local);
+        const call = callSiteOf(sf, node);
+        if (ns) {
+          const ref = record(ns.pkg, node.name.text, "namespace", ns.spec, rel, lineOf(node), void 0, call);
+          if (ns.loader) ref.loader = ns.loader;
+        } else if (def) {
+          record(def.pkg, node.name.text, "default-member", def.spec, rel, lineOf(node), void 0, call);
+        } else if (named) {
+          record(
+            named.pkg,
+            node.name.text,
+            "named-member",
+            named.spec,
+            rel,
+            lineOf(node),
+            named.exported,
+            call
+          );
+        }
+      }
+      ts.forEachChild(node, visit);
+    };
+    visit(sf);
+    if (followed.size) {
+      const uses = valueUses(sf, new Set(followed.keys()));
+      for (const [local, refs] of followed) {
+        for (const ref of refs) ref.calls = [...ref.calls ?? [], ...uses.get(local) ?? []];
+      }
+    }
+  }
+  return [...byPackage.entries()].map(([pkg, symbols]) => ({ package: pkg, symbols })).sort((a, b) => a.package.localeCompare(b.package));
+}
+
+export {
+  SURFACE_CLAIM_KINDS,
+  isRootSpecifier,
+  packageOfSpecifier,
+  scanReferences
+};

package/dist/chunk-TNTXWSYA.js

@@ -0,0 +1,19 @@
+import { createRequire as __lurqCreateRequire } from 'node:module'; const require = __lurqCreateRequire(import.meta.url);
+import {
+  init_esm_shims
+} from "./chunk-I3M2KJXB.js";
+
+// src/core/open.ts
+init_esm_shims();
+import { spawn } from "child_process";
+function openInBrowser(target) {
+  const [cmd, args] = process.platform === "darwin" ? ["open", [target]] : process.platform === "win32" ? ["cmd", ["/c", "start", "", target]] : ["xdg-open", [target]];
+  try {
+    spawn(cmd, args, { stdio: "ignore", detached: true }).unref();
+  } catch {
+  }
+}
+
+export {
+  openInBrowser
+};