@amulet-laboratories/astrolabe 0.4.0

package/src/adapters/vue/project.mjs

@@ -0,0 +1,116 @@
+import { existsSync, readFileSync } from 'node:fs'
+import { dirname, extname, join, resolve } from 'node:path'
+
+import { buildStack, pkgOf } from '../shared.mjs'
+
+const VITE_CONFIGS = ['vite.config.ts', 'vite.config.js', 'vite.config.mjs']
+
+// Auto-imports that come from the framework itself — drawing them as nodes
+// would bury the app's own composables and stores in library noise.
+const FRAMEWORK = /^(vue|vue-router|pinia|@vue\/|@vueuse\/|#)/
+
+/**
+ * A plain Vue app: a Vite config plus a `vue` dependency, and *not* Nuxt. The
+ * registry tries the Nuxt adapter first, so a Nuxt app (which also has `vue`)
+ * never reaches here.
+ */
+export function detect(dir) {
+  const root = resolve(dir)
+  if (!VITE_CONFIGS.some((n) => existsSync(join(root, n)))) return false
+  try {
+    const pkg = JSON.parse(readFileSync(join(root, 'package.json'), 'utf8'))
+    const deps = { ...pkg.dependencies, ...pkg.devDependencies }
+    return Boolean(deps.vue) && !deps.nuxt
+  } catch {
+    return false
+  }
+}
+
+export function loadProject(dir) {
+  const root = resolve(dir)
+  const srcDir = existsSync(join(root, 'src')) ? join(root, 'src') : root
+
+  let pkg = {}
+  try {
+    pkg = JSON.parse(readFileSync(join(root, 'package.json'), 'utf8'))
+  } catch {
+    // Unusual but not fatal.
+  }
+
+  return {
+    root,
+    srcDir,
+    name: pkg.name || root.split('/').pop(),
+    description: pkg.description || '',
+    modules: [],
+    stack: buildStack(pkg),
+    // The unplugin ecosystem commits these manifests, so a bare clone already
+    // has exact auto-import names — no build/prepare needed (unlike Nuxt's .nuxt).
+    components: readComponentManifest(root),
+    autoImports: readAutoImports(root),
+  }
+}
+
+/**
+ * Classify an import specifier from a manifest: local file vs. library.
+ * Relative specifiers resolve against `base` — the manifest's own directory,
+ * not the project root, since that's what the `./…` paths are relative to.
+ */
+function classify(base, spec) {
+  if (spec.startsWith('.')) {
+    const file = resolveLocal(resolve(base, spec))
+    return file.includes('node_modules')
+      ? { file, origin: 'library', pkg: pkgOf(file) }
+      : { file, origin: 'local', pkg: null }
+  }
+  const pkg = spec.startsWith('@') ? spec.split('/').slice(0, 2).join('/') : spec.split('/')[0]
+  return { file: spec, origin: 'library', pkg }
+}
+
+// TS import specifiers drop the extension (`./stores/user` → user.ts), so a
+// resolved path that doesn't exist as-is gets the source extensions tried.
+const SOURCE_EXTS = ['.ts', '.js', '.mts', '.vue']
+function resolveLocal(file) {
+  if (extname(file) && existsSync(file)) return file
+  return SOURCE_EXTS.map((e) => file + e).find(existsSync) ?? file
+}
+
+const firstExisting = (root, names) => names.map((n) => join(root, n)).find(existsSync)
+
+/**
+ * unplugin-vue-components writes `Name: typeof import('./…')['default']` inside a
+ * GlobalComponents interface. Pages (routes) are auto-registered here too, so
+ * we drop `src/pages/**` — those become route nodes, not component nodes.
+ */
+function readComponentManifest(root) {
+  const file = firstExisting(root, ['components.d.ts', 'src/components.d.ts'])
+  if (!file) return null
+  const base = dirname(file)
+  const raw = readFileSync(file, 'utf8')
+  const map = new Map()
+  const re = /^\s*['"]?([A-Za-z][\w.]*)['"]?\s*:\s*typeof import\('([^']+)'\)\['default'\]/gm
+  for (const [, name, spec] of raw.matchAll(re)) {
+    if (map.has(name) || /(^|\/)pages\//.test(spec)) continue
+    map.set(name, classify(base, spec))
+  }
+  return map.size ? map : null
+}
+
+/**
+ * unplugin-auto-import writes `const useFoo: typeof import('./…')['useFoo']`.
+ * Keep only the app's own `use*` auto-imports; the rest is vue/vueuse plumbing.
+ */
+function readAutoImports(root) {
+  const file = firstExisting(root, ['auto-imports.d.ts', 'src/auto-imports.d.ts'])
+  if (!file) return null
+  const base = dirname(file)
+  const map = new Map()
+  const raw = readFileSync(file, 'utf8')
+  for (const [, name, spec] of raw.matchAll(/const (\w+):\s*typeof import\('([^']+)'\)/g)) {
+    if (map.has(name) || !name.startsWith('use')) continue
+    const info = classify(base, spec)
+    if (info.origin === 'library' && FRAMEWORK.test(info.pkg ?? '')) continue
+    map.set(name, info)
+  }
+  return map.size ? map : null
+}