@shrkcrft/framework-scanners 0.1.0-alpha.10

package/dist/extractors/solid-extractor.js

@@ -0,0 +1,164 @@
+import { createHash } from 'node:crypto';
+import * as nodePath from 'node:path';
+import * as ts from 'typescript';
+import { EdgeKind, NodeKind } from '@shrkcrft/graph';
+export const SOLID_EXTRACTOR_SOURCE = 'solid-extractor@v1';
+const SOLID_PRIMITIVE_RE = /^create[A-Z]/;
+const FAST_FILTER_NEEDLES = [
+    "from 'solid-js'",
+    'from "solid-js"',
+    'createSignal',
+    'createEffect',
+    'createMemo',
+];
+/**
+ * Solid extractor.
+ *
+ * Detection (heuristic — no type info):
+ *   - Top-level `function Component()` / `const Component = (...)` with a
+ *     name starting with an uppercase letter and a body that produces
+ *     JSX → component entity.
+ *   - Uses of `createSignal`, `createEffect`, `createMemo`,
+ *     `createStore`, etc. → primitive-usage entities, linked to the
+ *     enclosing component via UsesHook edges.
+ *
+ * Same shape as the React extractor; lives separately because the
+ * detection heuristics (Solid uses primitives instead of hooks) and
+ * fast-filter needles differ.
+ */
+export const solidExtractor = {
+    framework: 'solid',
+    label: 'Solid',
+    fileMatches({ path, content }) {
+        if (!/\.(?:t|j)sx?$/.test(path))
+            return false;
+        for (const needle of FAST_FILTER_NEEDLES) {
+            if (content.includes(needle))
+                return true;
+        }
+        return false;
+    },
+    extract(input) {
+        const nodes = [];
+        const edges = [];
+        const sf = parse(input);
+        if (!sf)
+            return { nodes, edges };
+        const components = [];
+        const primitivesUsed = new Set();
+        for (const stmt of sf.statements)
+            visitTopLevel(stmt, input, components);
+        const enclosingComponent = (n) => {
+            for (const c of components)
+                if (isAncestor(c.node, n))
+                    return c.id;
+            return undefined;
+        };
+        const visit = (n) => {
+            if (ts.isCallExpression(n) && ts.isIdentifier(n.expression) && SOLID_PRIMITIVE_RE.test(n.expression.text)) {
+                const name = n.expression.text;
+                primitivesUsed.add(name);
+                const compId = enclosingComponent(n);
+                if (compId) {
+                    const primId = `framework:solid:primitive-usage:${input.filePath}#${name}`;
+                    edges.push(edge(compId, primId, EdgeKind.UsesHook, { hook: name }));
+                }
+            }
+            ts.forEachChild(n, visit);
+        };
+        ts.forEachChild(sf, visit);
+        for (const c of components) {
+            nodes.push({
+                id: c.id,
+                kind: NodeKind.FrameworkEntity,
+                label: c.name,
+                path: input.filePath,
+                tags: ['solid', 'component'],
+                data: { framework: 'solid', subtype: 'component', name: c.name },
+            });
+            edges.push(edge(input.fileNodeId, c.id, EdgeKind.FrameworkDeclares, { subtype: 'component' }));
+        }
+        for (const prim of primitivesUsed) {
+            const id = `framework:solid:primitive-usage:${input.filePath}#${prim}`;
+            nodes.push({
+                id,
+                kind: NodeKind.FrameworkEntity,
+                label: prim,
+                path: input.filePath,
+                tags: ['solid', 'primitive-usage'],
+                data: { framework: 'solid', subtype: 'primitive-usage', primitive: prim },
+            });
+            edges.push(edge(input.fileNodeId, id, EdgeKind.FrameworkDeclares, { subtype: 'primitive-usage' }));
+        }
+        return { nodes, edges };
+    },
+};
+function visitTopLevel(stmt, input, out) {
+    if (ts.isVariableStatement(stmt)) {
+        for (const decl of stmt.declarationList.declarations) {
+            if (!ts.isIdentifier(decl.name))
+                continue;
+            const name = decl.name.text;
+            if (!/^[A-Z]/.test(name))
+                continue;
+            const init = decl.initializer;
+            if (!init)
+                continue;
+            if (containsJsx(init)) {
+                out.push({ id: `framework:solid:component:${input.filePath}#${name}`, name, node: init });
+            }
+        }
+        return;
+    }
+    if (ts.isFunctionDeclaration(stmt) && stmt.name && /^[A-Z]/.test(stmt.name.text)) {
+        if (containsJsx(stmt)) {
+            out.push({ id: `framework:solid:component:${input.filePath}#${stmt.name.text}`, name: stmt.name.text, node: stmt });
+        }
+    }
+}
+function containsJsx(node) {
+    let found = false;
+    const visit = (n) => {
+        if (found)
+            return;
+        if (ts.isJsxElement(n) || ts.isJsxSelfClosingElement(n) || ts.isJsxFragment(n)) {
+            found = true;
+            return;
+        }
+        ts.forEachChild(n, visit);
+    };
+    visit(node);
+    return found;
+}
+function isAncestor(ancestor, descendant) {
+    let cur = descendant;
+    while (cur) {
+        if (cur === ancestor)
+            return true;
+        cur = cur.parent;
+    }
+    return false;
+}
+function edge(from, to, kind, data) {
+    return {
+        id: createHash('sha1').update(`${from}|${to}|${kind}`).digest('hex'),
+        from,
+        to,
+        kind,
+        source: SOLID_EXTRACTOR_SOURCE,
+        ...(data ? { data } : {}),
+    };
+}
+function parse(input) {
+    const ext = nodePath.extname(input.filePath).toLowerCase();
+    const kind = ext === '.tsx' ? ts.ScriptKind.TSX
+        : ext === '.jsx' ? ts.ScriptKind.JSX
+            : ext === '.js' || ext === '.mjs' || ext === '.cjs' ? ts.ScriptKind.JS
+                : ts.ScriptKind.TS;
+    try {
+        return ts.createSourceFile(input.filePath, input.content, ts.ScriptTarget.Latest, true, kind);
+    }
+    catch {
+        return undefined;
+    }
+}

package/dist/extractors/spring-extractor.d.ts

@@ -0,0 +1,27 @@
+import type { IFrameworkExtractor } from '../extractor-api/framework-extractor.js';
+export declare const SPRING_EXTRACTOR_SOURCE = "spring-extractor@v1";
+/**
+ * Spring extractor.
+ *
+ * Regex-based — Java/Kotlin sources are not AST-parsed. Detection:
+ *
+ *   - **Bean / stereotype classes**: `@Controller`, `@RestController`,
+ *     `@Service`, `@Repository`, `@Component`, `@Configuration`
+ *     immediately preceding a `class`/`interface`/`record` declaration
+ *     → one entity per matched class with subtype = the annotation name
+ *     lower-cased.
+ *
+ *   - **Routes**: `@RequestMapping`, `@GetMapping`/`@PostMapping`/etc.
+ *     on a method (or class). Method-level mappings combine with their
+ *     enclosing class's `@RequestMapping` base path. Method derived
+ *     from the annotation type (`@GetMapping` → GET); for
+ *     `@RequestMapping` the optional `method = RequestMethod.GET`
+ *     argument is captured, otherwise the route is tagged `ANY`.
+ *
+ * Out of scope:
+ *   - `@PathVariable`, `@RequestBody`, `@RequestParam` parameter binding.
+ *   - WebFlux's `RouterFunction` programmatic routes.
+ *   - Spring Security `SecurityFilterChain` configuration.
+ */
+export declare const springExtractor: IFrameworkExtractor;
+//# sourceMappingURL=spring-extractor.d.ts.map

package/dist/extractors/spring-extractor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"spring-extractor.d.ts","sourceRoot":"","sources":["../../src/extractors/spring-extractor.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAGV,mBAAmB,EACpB,MAAM,yCAAyC,CAAC;AAEjD,eAAO,MAAM,uBAAuB,wBAAwB,CAAC;AAmC7D;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,eAAO,MAAM,eAAe,EAAE,mBAkH7B,CAAC"}

package/dist/extractors/spring-extractor.js

@@ -0,0 +1,279 @@
+import { createHash } from 'node:crypto';
+import { EdgeKind, NodeKind } from '@shrkcrft/graph';
+export const SPRING_EXTRACTOR_SOURCE = 'spring-extractor@v1';
+const STEREOTYPES = new Set([
+    'Controller',
+    'RestController',
+    'Service',
+    'Repository',
+    'Component',
+    'Configuration',
+]);
+const ROUTE_ANNOTATIONS = new Map([
+    ['RequestMapping', undefined],
+    ['GetMapping', 'GET'],
+    ['PostMapping', 'POST'],
+    ['PutMapping', 'PUT'],
+    ['DeleteMapping', 'DELETE'],
+    ['PatchMapping', 'PATCH'],
+]);
+const FAST_FILTER_NEEDLES = [
+    'org.springframework',
+    '@Controller',
+    '@RestController',
+    '@Service',
+    '@Repository',
+    '@Component',
+    '@RequestMapping',
+    '@GetMapping',
+    '@PostMapping',
+    '@PutMapping',
+    '@DeleteMapping',
+    '@PatchMapping',
+];
+/**
+ * Spring extractor.
+ *
+ * Regex-based — Java/Kotlin sources are not AST-parsed. Detection:
+ *
+ *   - **Bean / stereotype classes**: `@Controller`, `@RestController`,
+ *     `@Service`, `@Repository`, `@Component`, `@Configuration`
+ *     immediately preceding a `class`/`interface`/`record` declaration
+ *     → one entity per matched class with subtype = the annotation name
+ *     lower-cased.
+ *
+ *   - **Routes**: `@RequestMapping`, `@GetMapping`/`@PostMapping`/etc.
+ *     on a method (or class). Method-level mappings combine with their
+ *     enclosing class's `@RequestMapping` base path. Method derived
+ *     from the annotation type (`@GetMapping` → GET); for
+ *     `@RequestMapping` the optional `method = RequestMethod.GET`
+ *     argument is captured, otherwise the route is tagged `ANY`.
+ *
+ * Out of scope:
+ *   - `@PathVariable`, `@RequestBody`, `@RequestParam` parameter binding.
+ *   - WebFlux's `RouterFunction` programmatic routes.
+ *   - Spring Security `SecurityFilterChain` configuration.
+ */
+export const springExtractor = {
+    framework: 'spring',
+    label: 'Spring',
+    fileMatches({ path, content }) {
+        if (!path.endsWith('.java') && !path.endsWith('.kt'))
+            return false;
+        for (const needle of FAST_FILTER_NEEDLES) {
+            if (content.includes(needle))
+                return true;
+        }
+        return false;
+    },
+    extract(input) {
+        const nodes = [];
+        const edges = [];
+        const lines = input.content.split('\n');
+        // First pass: locate class/interface/record declarations and the
+        // annotations immediately preceding them. We track the most recent
+        // class's `@RequestMapping` base path so method-level mappings can
+        // combine with it.
+        let currentClassEntity;
+        let currentClassBasePath = '';
+        for (let i = 0; i < lines.length; i += 1) {
+            const raw = lines[i];
+            const trimmed = raw.trimStart();
+            if (trimmed.length === 0)
+                continue;
+            // Class declaration (column-0, optionally indented inside files
+            // — we accept both for Kotlin's `class` at any indent).
+            const classMatch = /^(?:public\s+|private\s+|internal\s+|protected\s+|abstract\s+|final\s+|sealed\s+|open\s+|data\s+)*\s*(class|interface|record)\s+([A-Za-z_]\w*)/.exec(trimmed);
+            if (classMatch) {
+                const className = classMatch[2];
+                // Look backwards for annotations on this class.
+                const { stereotype, basePath } = scanClassAnnotations(lines, i);
+                currentClassBasePath = basePath;
+                if (stereotype) {
+                    const e = makeEntity(input, stereotype.toLowerCase(), className, {
+                        className,
+                        stereotype,
+                        ...(basePath ? { basePath } : {}),
+                    });
+                    nodes.push(e);
+                    edges.push(edge(input.fileNodeId, e.id, EdgeKind.FrameworkDeclares, {
+                        subtype: stereotype.toLowerCase(),
+                        line: i + 1,
+                    }));
+                    currentClassEntity = e;
+                }
+                else if (basePath) {
+                    // Class without a stereotype but with `@RequestMapping` —
+                    // still emit a bean entity tagged `mapping` so routes can
+                    // attach to something.
+                    const e = makeEntity(input, 'mapping', className, {
+                        className,
+                        ...(basePath ? { basePath } : {}),
+                    });
+                    nodes.push(e);
+                    edges.push(edge(input.fileNodeId, e.id, EdgeKind.FrameworkDeclares, {
+                        subtype: 'mapping',
+                        line: i + 1,
+                    }));
+                    currentClassEntity = e;
+                }
+                else {
+                    currentClassEntity = undefined;
+                }
+                continue;
+            }
+            // Method-level route annotation followed by a method declaration.
+            const ann = /^@(\w+)(?:\(([^)]*)\))?/.exec(trimmed);
+            if (!ann)
+                continue;
+            const annName = ann[1];
+            if (!ROUTE_ANNOTATIONS.has(annName))
+                continue;
+            const annArgs = ann[2] ?? '';
+            // Scan forward through additional annotations to the method/fn
+            // declaration line. Skip emitting a route if the annotation is
+            // actually class-level (e.g. `@RequestMapping("/users")` above a
+            // `class UserController`) — that base path is already captured
+            // via `scanClassAnnotations`.
+            let handlerName;
+            let nextIsClass = false;
+            for (let j = i + 1; j < lines.length; j += 1) {
+                const t = lines[j].trimStart();
+                if (!t)
+                    continue;
+                if (t.startsWith('@'))
+                    continue;
+                if (t.startsWith('//') || t.startsWith('/*'))
+                    continue;
+                if (/^(?:public\s+|private\s+|internal\s+|protected\s+|abstract\s+|final\s+|sealed\s+|open\s+|data\s+)*\s*(class|interface|record)\s+/.test(t)) {
+                    nextIsClass = true;
+                    break;
+                }
+                handlerName = extractMethodName(t);
+                break;
+            }
+            if (nextIsClass)
+                continue;
+            const finalHandler = handlerName ?? 'handler';
+            const methodPath = parseRoutePath(annArgs);
+            const methodMethod = ROUTE_ANNOTATIONS.get(annName)
+                ?? parseRequestMethod(annArgs)
+                ?? 'ANY';
+            const finalPath = combinePaths(currentClassBasePath, methodPath);
+            const route = makeRouteEntity(input, currentClassEntity?.label ?? '?', finalHandler, methodMethod, finalPath);
+            nodes.push(route);
+            if (currentClassEntity) {
+                edges.push(edge(currentClassEntity.id, route.id, EdgeKind.HandlesRoute, {
+                    method: methodMethod,
+                    path: finalPath,
+                    handler: finalHandler,
+                }));
+            }
+            edges.push(edge(input.fileNodeId, route.id, EdgeKind.FrameworkDeclares, { subtype: 'route', line: i + 1 }));
+        }
+        return { nodes, edges };
+    },
+};
+/**
+ * Walk backwards from a class-declaration line to collect its
+ * stereotype + `@RequestMapping` base path. Stops at the first
+ * non-annotation, non-blank line.
+ */
+function scanClassAnnotations(lines, classLineIndex) {
+    let stereotype;
+    let basePath = '';
+    for (let j = classLineIndex - 1; j >= 0; j -= 1) {
+        const t = lines[j].trimStart();
+        if (!t)
+            continue;
+        if (!t.startsWith('@'))
+            break;
+        const m = /^@(\w+)(?:\(([^)]*)\))?/.exec(t);
+        if (!m)
+            continue;
+        const name = m[1];
+        if (STEREOTYPES.has(name))
+            stereotype = name;
+        if (name === 'RequestMapping' || ROUTE_ANNOTATIONS.has(name)) {
+            const p = parseRoutePath(m[2] ?? '');
+            if (p)
+                basePath = p;
+        }
+    }
+    return { stereotype, basePath };
+}
+/**
+ * Extract the route path from an annotation argument list. Handles
+ * `("/path")`, `(value = "/path")`, `(path = "/path")`.
+ */
+function parseRoutePath(args) {
+    const m1 = /^\s*"([^"]*)"/.exec(args);
+    if (m1)
+        return m1[1];
+    const m2 = /(?:value|path)\s*=\s*"([^"]*)"/.exec(args);
+    if (m2)
+        return m2[1];
+    return '';
+}
+function parseRequestMethod(args) {
+    const m = /method\s*=\s*RequestMethod\.([A-Z]+)/.exec(args);
+    if (m)
+        return m[1];
+    return undefined;
+}
+function extractMethodName(line) {
+    // Java: `public ReturnType name(...)` or `ReturnType name(...)`. Kotlin: `fun name(...)`.
+    let m = /^(?:public\s+|protected\s+|private\s+|static\s+|final\s+|synchronized\s+)*\s*[\w<>\[\],\s]+?\s+([A-Za-z_]\w*)\s*\(/.exec(line);
+    if (m)
+        return m[1];
+    m = /^(?:public\s+|private\s+|internal\s+|protected\s+|override\s+|suspend\s+|inline\s+)*\s*fun\s+([A-Za-z_]\w*)\s*\(/.exec(line);
+    if (m)
+        return m[1];
+    return undefined;
+}
+function combinePaths(base, leaf) {
+    const b = base.replace(/\/$/, '');
+    const l = leaf.startsWith('/') ? leaf : '/' + leaf;
+    if (!b)
+        return l || '/';
+    if (!leaf)
+        return b || '/';
+    return b + l;
+}
+function makeEntity(input, subtype, label, extra) {
+    return {
+        id: `framework:spring:${subtype}:${input.filePath}#${label}`,
+        kind: NodeKind.FrameworkEntity,
+        label,
+        path: input.filePath,
+        tags: ['spring', subtype],
+        data: { framework: 'spring', subtype, ...extra },
+    };
+}
+function makeRouteEntity(input, className, handler, method, path) {
+    return {
+        id: `framework:spring:route:${input.filePath}#${className}.${handler}#${method}:${path}`,
+        kind: NodeKind.FrameworkEntity,
+        label: `${method} ${path}`,
+        path: input.filePath,
+        tags: ['spring', 'route'],
+        data: {
+            framework: 'spring',
+            subtype: 'route',
+            controller: className,
+            handler,
+            method,
+            path,
+        },
+    };
+}
+function edge(from, to, kind, data) {
+    return {
+        id: createHash('sha1').update(`${from}|${to}|${kind}`).digest('hex'),
+        from,
+        to,
+        kind,
+        source: SPRING_EXTRACTOR_SOURCE,
+        ...(data ? { data } : {}),
+    };
+}

package/dist/extractors/svelte-extractor.d.ts

@@ -0,0 +1,17 @@
+import type { IFrameworkExtractor } from '../extractor-api/framework-extractor.js';
+export declare const SVELTE_EXTRACTOR_SOURCE = "svelte-extractor@v1";
+/**
+ * Svelte extractor.
+ *
+ * Detection sources:
+ *   1. `.svelte` files — always a component. Component name from filename.
+ *   2. `.svelte.ts` / `.svelte.js` (Svelte 5 runes in module files) — emits a
+ *      module-level entity.
+ *
+ * Lightweight metadata: store usages (`$store` syntax) and Svelte 5 runes
+ * (`$state`, `$derived`, etc.) inside the `<script>` block.
+ *
+ * Out of scope: slot detection, action detection, transition detection.
+ */
+export declare const svelteExtractor: IFrameworkExtractor;
+//# sourceMappingURL=svelte-extractor.d.ts.map

package/dist/extractors/svelte-extractor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"svelte-extractor.d.ts","sourceRoot":"","sources":["../../src/extractors/svelte-extractor.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAGV,mBAAmB,EACpB,MAAM,yCAAyC,CAAC;AAEjD,eAAO,MAAM,uBAAuB,wBAAwB,CAAC;AAO7D;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,eAAe,EAAE,mBAoC7B,CAAC"}

package/dist/extractors/svelte-extractor.js

@@ -0,0 +1,104 @@
+import { createHash } from 'node:crypto';
+import { EdgeKind, NodeKind } from '@shrkcrft/graph';
+export const SVELTE_EXTRACTOR_SOURCE = 'svelte-extractor@v1';
+const STORE_RE = /\$([A-Za-z_][A-Za-z0-9_]*)/g;
+const SCRIPT_OPEN_RE = /<script\b[^>]*>/i;
+const SCRIPT_CLOSE_RE = /<\/script>/i;
+const RUNES_RE = /\$(state|derived|effect|props|bindable|inspect)\s*\(/g;
+/**
+ * Svelte extractor.
+ *
+ * Detection sources:
+ *   1. `.svelte` files — always a component. Component name from filename.
+ *   2. `.svelte.ts` / `.svelte.js` (Svelte 5 runes in module files) — emits a
+ *      module-level entity.
+ *
+ * Lightweight metadata: store usages (`$store` syntax) and Svelte 5 runes
+ * (`$state`, `$derived`, etc.) inside the `<script>` block.
+ *
+ * Out of scope: slot detection, action detection, transition detection.
+ */
+export const svelteExtractor = {
+    framework: 'svelte',
+    label: 'Svelte',
+    fileMatches({ path }) {
+        return path.endsWith('.svelte') || path.endsWith('.svelte.ts') || path.endsWith('.svelte.js');
+    },
+    extract(input) {
+        const nodes = [];
+        const edges = [];
+        const filename = input.filePath.split('/').pop();
+        const name = filename
+            .replace(/\.svelte$/, '')
+            .replace(/\.svelte\.(?:t|j)s$/, '');
+        const isModule = filename.endsWith('.svelte.ts') || filename.endsWith('.svelte.js');
+        const subtype = isModule ? 'module' : 'component';
+        const script = isModule ? input.content : extractScriptBlock(input.content);
+        const runes = collectRunes(script);
+        const stores = collectStoreUsages(script);
+        const entity = {
+            id: `framework:svelte:${subtype}:${input.filePath}#${name}`,
+            kind: NodeKind.FrameworkEntity,
+            label: name,
+            path: input.filePath,
+            tags: ['svelte', subtype],
+            data: {
+                framework: 'svelte',
+                subtype,
+                name,
+                ...(runes.length > 0 ? { runes } : {}),
+                ...(stores.length > 0 ? { stores } : {}),
+            },
+        };
+        nodes.push(entity);
+        edges.push(edge(input.fileNodeId, entity.id, EdgeKind.FrameworkDeclares, { subtype }));
+        return { nodes, edges };
+    },
+};
+function extractScriptBlock(content) {
+    const open = content.search(SCRIPT_OPEN_RE);
+    if (open < 0)
+        return '';
+    const after = content.slice(open).indexOf('>');
+    if (after < 0)
+        return '';
+    const start = open + after + 1;
+    const closeIdx = content.slice(start).search(SCRIPT_CLOSE_RE);
+    if (closeIdx < 0)
+        return content.slice(start);
+    return content.slice(start, start + closeIdx);
+}
+function collectRunes(script) {
+    const found = new Set();
+    let m;
+    RUNES_RE.lastIndex = 0;
+    while ((m = RUNES_RE.exec(script)) !== null)
+        found.add('$' + m[1]);
+    return [...found].sort();
+}
+function collectStoreUsages(script) {
+    const found = new Set();
+    let m;
+    STORE_RE.lastIndex = 0;
+    while ((m = STORE_RE.exec(script)) !== null) {
+        const name = m[1];
+        // Filter Svelte 5 runes ($state, $derived, etc.) — those aren't stores.
+        if (['state', 'derived', 'effect', 'props', 'bindable', 'inspect'].includes(name))
+            continue;
+        // Filter common JS globals.
+        if (name === 'this' || name === 'else')
+            continue;
+        found.add('$' + name);
+    }
+    return [...found].sort().slice(0, 20);
+}
+function edge(from, to, kind, data) {
+    return {
+        id: createHash('sha1').update(`${from}|${to}|${kind}`).digest('hex'),
+        from,
+        to,
+        kind,
+        source: SVELTE_EXTRACTOR_SOURCE,
+        ...(data ? { data } : {}),
+    };
+}

package/dist/extractors/vue-extractor.d.ts

@@ -0,0 +1,18 @@
+import type { IFrameworkExtractor } from '../extractor-api/framework-extractor.js';
+export declare const VUE_EXTRACTOR_SOURCE = "vue-extractor@v1";
+/**
+ * Vue extractor.
+ *
+ * Detection sources (in order):
+ *   1. `.vue` SFC files — always a component, named after the filename.
+ *   2. `.ts` / `.tsx` / `.js` / `.jsx` files containing
+ *      `defineComponent(` or `defineAsyncComponent(` — emits a
+ *      component entity per call.
+ *
+ * For SFC files we also detect Composition API hook usages from the
+ * `<script>` block via regex (lightweight — no template parsing).
+ *
+ * Out of scope: template parsing, <style> block detection, scoped slots.
+ */
+export declare const vueExtractor: IFrameworkExtractor;
+//# sourceMappingURL=vue-extractor.d.ts.map

package/dist/extractors/vue-extractor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vue-extractor.d.ts","sourceRoot":"","sources":["../../src/extractors/vue-extractor.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAGV,mBAAmB,EACpB,MAAM,yCAAyC,CAAC;AAEjD,eAAO,MAAM,oBAAoB,qBAAqB,CAAC;AASvD;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,YAAY,EAAE,mBAkB1B,CAAC"}