@markuplint/pretenders 5.0.0-dev.5 → 5.0.0-rc.1

package/lib/jsx/index.js

@@ -11,7 +11,7 @@ import { getPosition } from '@markuplint/parser-utils/location';
 import ts from 'typescript';
 import { createScanner } from '../create-scanner.js';
 import { PretenderDirector } from '../pretender-director.js';
-import { createIndentity } from './create-identify.js';
+import { createIdentity } from './create-identify.js';
 import { finder } from './finder.js';
 import { getAttributes } from './get-attributes.js';
 import { getChildren } from './get-children.js';
@@ -43,6 +43,10 @@ const defaultOptions = {
  * - HOC / wrapper function patterns
  * - Fragment and provider component transparency
  * - `@pretends null` JSDoc tag to opt out a component
+ *
+ * @param files - Absolute file paths to scan (relative paths cause a `ReferenceError`)
+ * @param options - JSX scanner configuration (fragment patterns, styled-components, wrappers, etc.)
+ * @returns Discovered pretender mappings for all components found in the given files
  */
 export const jsxScanner = createScanner((files, options = defaultOptions) => {
     const { cwd = defaultOptions.cwd, ignoreComponentNames = defaultOptions.ignoreComponentNames, asFragment = defaultOptions.asFragment, taggedStylingComponent = defaultOptions.taggedStylingComponent, extendingWrapper = defaultOptions.extendingWrapper, } = options;
@@ -51,6 +55,10 @@ export const jsxScanner = createScanner((files, options = defaultOptions) => {
         jsx: JsxEmit.ReactJSX,
         allowJs: true,
     });
+    // Trigger the binder so that parent pointers are set on AST nodes.
+    // getChildren() relies on node.parent to navigate from JsxOpeningElement
+    // to its containing JsxElement for children slot detection.
+    program.getTypeChecker();
     for (const sourceFile of program.getSourceFiles()) {
         if (!sourceFile.isDeclarationFile) {
             forEachChild(sourceFile, node => visit(node, sourceFile));
@@ -184,7 +192,7 @@ export const jsxScanner = createScanner((files, options = defaultOptions) => {
                     element: tagName,
                     slots: true,
                     inheritAttrs: true,
-                }, filePath, line, col);
+                }, filePath, line, col, `${filePath}#${name}`);
             }
         });
         find(root, isCallExpression, method => {
@@ -229,7 +237,7 @@ export const jsxScanner = createScanner((files, options = defaultOptions) => {
                     element: tagName,
                     slots: true,
                     inheritAttrs: true,
-                }, filePath, line, col);
+                }, filePath, line, col, `${filePath}#${name}`);
             }
         });
         function foundFragment(
@@ -283,8 +291,8 @@ export const jsxScanner = createScanner((files, options = defaultOptions) => {
             }
             const attrs = getAttributes(el, sourceFile);
             const children = getChildren(el, sourceFile);
-            const identity = createIndentity(tagName, attrs, children);
-            director.add(name, identity, filePath, line, col);
+            const identity = createIdentity(tagName, attrs, children);
+            director.add(name, identity, filePath, line, col, `${filePath}#${name}`);
         }
     }
     return Promise.resolve(director.getPretenders());

package/lib/pretender-director.d.ts

@@ -1,27 +1,36 @@
-import type { Identifier, Identity } from './types.js';
+import type { Identifier, Identity, ImportPath } from './types.js';
+/**
+ * Internal map structure storing component mappings keyed by import path (or identifier as fallback).
+ * The value tuple includes the component identifier (name), its identity, and an optional source location.
+ */
+export type PretenderDirectorMap = Map<string, [identifier: Identifier, identity: Identity, filePath?: string]>;
 /**
  * Collects and manages pretender mappings discovered during source file scanning.
  * Acts as a registry where component-to-element relationships are added during
  * traversal, then resolved into a flat list of pretenders with dependency linking.
+ *
+ * The internal map uses import paths as keys when available, falling back to
+ * component identifiers (names) for backward compatibility with name-based scanners.
  */
 export declare class PretenderDirector {
     #private;
     /**
-     * Registers a component as a pretender mapping. If the identifier is already
-     * registered, the call is silently ignored (first definition wins).
+     * Registers a component as a pretender mapping. If the key (import path or identifier)
+     * is already registered, the call is silently ignored (first definition wins).
      *
      * @param identifier - The component selector (e.g., component name)
      * @param identity - The native HTML element the component renders as
      * @param filePath - The relative file path where the component is defined
      * @param line - The line number of the component declaration
      * @param col - The column number of the component declaration
+     * @param importPath - Optional import path for uniquely identifying the component across files
      */
-    add(identifier: Identifier, identity: Identity, filePath: string, line: number, col: number): void;
+    add(identifier: Identifier, identity: Identity, filePath: string, line: number, col: number, importPath?: ImportPath): void;
     /**
      * Resolves all registered mappings into a sorted array of Pretender objects.
      * Follows component-to-component chains to determine the final native element identity.
      *
      * @returns A sorted array of resolved Pretender objects
      */
-    getPretenders(): import("packages/@markuplint/ml-config/lib/types.js").Pretender[];
+    getPretenders(): import("@markuplint/ml-config").Pretender[];
 }

package/lib/pretender-director.js

@@ -3,24 +3,33 @@ import { dependencyMapper } from './dependency-mapper.js';
  * Collects and manages pretender mappings discovered during source file scanning.
  * Acts as a registry where component-to-element relationships are added during
  * traversal, then resolved into a flat list of pretenders with dependency linking.
+ *
+ * The internal map uses import paths as keys when available, falling back to
+ * component identifiers (names) for backward compatibility with name-based scanners.
  */
 export class PretenderDirector {
     #map = new Map();
+    #nameIndex = new Map();
     /**
-     * Registers a component as a pretender mapping. If the identifier is already
-     * registered, the call is silently ignored (first definition wins).
+     * Registers a component as a pretender mapping. If the key (import path or identifier)
+     * is already registered, the call is silently ignored (first definition wins).
      *
      * @param identifier - The component selector (e.g., component name)
      * @param identity - The native HTML element the component renders as
      * @param filePath - The relative file path where the component is defined
      * @param line - The line number of the component declaration
      * @param col - The column number of the component declaration
+     * @param importPath - Optional import path for uniquely identifying the component across files
      */
-    add(identifier, identity, filePath, line, col) {
-        if (this.#map.has(identifier)) {
+    add(identifier, identity, filePath, line, col, importPath) {
+        const key = importPath ?? identifier;
+        if (this.#map.has(key)) {
             return;
         }
-        this.#map.set(identifier, [identity, `${filePath}:${line}:${col}`]);
+        this.#map.set(key, [identifier, identity, `${filePath}:${line}:${col}`]);
+        if (!this.#nameIndex.has(identifier)) {
+            this.#nameIndex.set(identifier, key);
+        }
     }
     /**
      * Resolves all registered mappings into a sorted array of Pretender objects.
@@ -29,6 +38,6 @@ export class PretenderDirector {
      * @returns A sorted array of resolved Pretender objects
      */
     getPretenders() {
-        return dependencyMapper(this.#map);
+        return dependencyMapper(this.#map, this.#nameIndex);
     }
 }

package/lib/scan.d.ts

@@ -0,0 +1,20 @@
+import type { Pretender } from '@markuplint/ml-config';
+/**
+ * Options for the unified {@link scan} function.
+ */
+export interface ScanOptions {
+    /** Component names to exclude from scanning results */
+    readonly ignoreComponentNames?: readonly string[];
+}
+/**
+ * Dispatches files to the appropriate scanner based on file extension,
+ * runs both scanners in parallel, and merges + sorts the results.
+ *
+ * - `.js`, `.jsx`, `.ts`, `.tsx` → {@link jsxScanner}
+ * - `.vue`, `.svelte`, `.astro` → {@link templateScanner} (delegates to parser component-scanners)
+ *
+ * @param files - Absolute file paths to scan
+ * @param options - Optional scan configuration
+ * @returns All discovered pretender mappings, sorted by selector
+ */
+export declare function scan(files: readonly string[], options?: ScanOptions): Promise<Pretender[]>;

package/lib/scan.js

@@ -0,0 +1,24 @@
+import { propSort } from './dependency-mapper.js';
+import { jsxScanner } from './jsx/index.js';
+import { templateScanner } from './template/index.js';
+/**
+ * Dispatches files to the appropriate scanner based on file extension,
+ * runs both scanners in parallel, and merges + sorts the results.
+ *
+ * - `.js`, `.jsx`, `.ts`, `.tsx` → {@link jsxScanner}
+ * - `.vue`, `.svelte`, `.astro` → {@link templateScanner} (delegates to parser component-scanners)
+ *
+ * @param files - Absolute file paths to scan
+ * @param options - Optional scan configuration
+ * @returns All discovered pretender mappings, sorted by selector
+ */
+export async function scan(files, options) {
+    const jsxFiles = files.filter(filePath => /\.[jt]sx?$/.test(filePath));
+    const templateFiles = files.filter(filePath => /\.(?:vue|svelte|astro)$/.test(filePath));
+    const ignoreComponentNames = options?.ignoreComponentNames ? [...options.ignoreComponentNames] : undefined;
+    const [jsxPretenders, templatePretenders] = await Promise.all([
+        jsxFiles.length > 0 ? jsxScanner(jsxFiles, { ignoreComponentNames }) : Promise.resolve([]),
+        templateFiles.length > 0 ? templateScanner(templateFiles, { ignoreComponentNames }) : Promise.resolve([]),
+    ]);
+    return [...jsxPretenders, ...templatePretenders].toSorted(propSort('selector'));
+}

package/lib/scanner-loader.d.ts

@@ -0,0 +1,8 @@
+import type { ComponentScanner } from './component-scanner.js';
+/**
+ * Dynamically imports the appropriate component scanner for the given file extension.
+ *
+ * @param ext - The file extension (e.g., `.vue`, `.svelte`, `.astro`)
+ * @returns The component scanner, or `null` if unavailable
+ */
+export declare function getScanner(ext: string): Promise<ComponentScanner | null>;

package/lib/scanner-loader.js

@@ -0,0 +1,56 @@
+/**
+ * Maps file extensions to their corresponding parser package's component-scanner subpath.
+ */
+const SCANNER_PACKAGES = {
+    '.vue': '@markuplint/vue-parser/component-scanner',
+    '.svelte': '@markuplint/svelte-parser/component-scanner',
+    '.astro': '@markuplint/astro-parser/component-scanner',
+};
+/**
+ * Cache of loaded component scanners.
+ */
+const scannerCache = new Map();
+/**
+ * Checks if an error is a Node.js ERR_MODULE_NOT_FOUND error.
+ *
+ * @param error - The caught error value
+ * @returns `true` if the error has code `ERR_MODULE_NOT_FOUND`
+ */
+function isModuleNotFoundError(error) {
+    return (error instanceof Error && 'code' in error && error.code === 'ERR_MODULE_NOT_FOUND');
+}
+/**
+ * Dynamically imports the appropriate component scanner for the given file extension.
+ *
+ * @param ext - The file extension (e.g., `.vue`, `.svelte`, `.astro`)
+ * @returns The component scanner, or `null` if unavailable
+ */
+export async function getScanner(ext) {
+    const cached = scannerCache.get(ext);
+    if (cached !== undefined) {
+        return cached;
+    }
+    const pkg = SCANNER_PACKAGES[ext];
+    if (!pkg) {
+        scannerCache.set(ext, null);
+        return null;
+    }
+    try {
+        const mod = await import(pkg);
+        scannerCache.set(ext, mod.componentScanner);
+        return mod.componentScanner;
+    }
+    catch (error) {
+        if (isModuleNotFoundError(error)) {
+            const parserPkg = pkg.replace('/component-scanner', '');
+            // eslint-disable-next-line no-console
+            console.warn(`Parser package "${parserPkg}" is not installed. Skipping ${ext} files.`);
+        }
+        else {
+            // eslint-disable-next-line no-console
+            console.warn(`Failed to load component scanner for ${ext}:`, error instanceof Error ? error.message : error);
+        }
+        scannerCache.set(ext, null);
+        return null;
+    }
+}

package/lib/template/derive-name.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Derives a PascalCase component name from a file path.
+ *
+ * Rules:
+ * - `BaseButton.vue` → `BaseButton` (remove extension)
+ * - `base-button.vue` → `BaseButton` (kebab-case → PascalCase)
+ * - `Card/index.vue` → `Card` (parent directory name for index files)
+ *
+ * @param filePath - The component file path to derive a name from
+ * @returns The PascalCase component name
+ */
+export declare function deriveName(filePath: string): string;

package/lib/template/derive-name.js

@@ -0,0 +1,27 @@
+import path from 'node:path';
+/**
+ * Derives a PascalCase component name from a file path.
+ *
+ * Rules:
+ * - `BaseButton.vue` → `BaseButton` (remove extension)
+ * - `base-button.vue` → `BaseButton` (kebab-case → PascalCase)
+ * - `Card/index.vue` → `Card` (parent directory name for index files)
+ *
+ * @param filePath - The component file path to derive a name from
+ * @returns The PascalCase component name
+ */
+export function deriveName(filePath) {
+    const parsed = path.parse(filePath);
+    const baseName = parsed.name;
+    const nameToConvert = baseName === 'index' ? path.basename(parsed.dir) || 'index' : baseName;
+    return toPascalCase(nameToConvert);
+}
+function toPascalCase(str) {
+    if (str.includes('-')) {
+        return str
+            .split('-')
+            .map(segment => segment.charAt(0).toUpperCase() + segment.slice(1))
+            .join('');
+    }
+    return str.charAt(0).toUpperCase() + str.slice(1);
+}

package/lib/template/detect-slots.d.ts

@@ -0,0 +1,14 @@
+import type { MLASTDocument } from '@markuplint/ml-ast';
+/**
+ * Detects whether a parsed component template contains slot usage.
+ *
+ * Supports:
+ * - Vue: `<slot>` element (`nodeName === 'slot'`)
+ * - Svelte 4: `<slot>` element (parsed as psblock `#ps:SlotElement`)
+ * - Svelte 5: `{@render children()}` (parsed as psblock `#ps:RenderTag`)
+ * - Astro: `<slot />` element (`nodeName === 'slot'`)
+ *
+ * @param doc - The parsed MLAST document to search
+ * @returns `true` if the template contains any slot or children render usage
+ */
+export declare function detectSlots(doc: MLASTDocument): boolean;

package/lib/template/detect-slots.js

@@ -0,0 +1,23 @@
+/**
+ * Detects whether a parsed component template contains slot usage.
+ *
+ * Supports:
+ * - Vue: `<slot>` element (`nodeName === 'slot'`)
+ * - Svelte 4: `<slot>` element (parsed as psblock `#ps:SlotElement`)
+ * - Svelte 5: `{@render children()}` (parsed as psblock `#ps:RenderTag`)
+ * - Astro: `<slot />` element (`nodeName === 'slot'`)
+ *
+ * @param doc - The parsed MLAST document to search
+ * @returns `true` if the template contains any slot or children render usage
+ */
+export function detectSlots(doc) {
+    for (const node of doc.nodeList) {
+        if (node.type === 'starttag' && node.nodeName === 'slot') {
+            return true;
+        }
+        if (node.type === 'psblock' && (node.nodeName === '#ps:SlotElement' || node.nodeName === '#ps:RenderTag')) {
+            return true;
+        }
+    }
+    return false;
+}

package/lib/template/extract-attrs.d.ts

@@ -0,0 +1,13 @@
+import type { MLASTElement } from '@markuplint/ml-ast';
+import type { PretenderAttr } from '@markuplint/ml-config';
+/**
+ * Extracts static attributes from an MLAST element node as PretenderAttr entries.
+ *
+ * Only includes attributes with type `'attr'` (regular HTML attributes).
+ * Spread attributes are skipped. Boolean attributes (no value) are included
+ * without a `value` property.
+ *
+ * @param element - The MLAST element node to extract attributes from
+ * @returns Static attributes suitable for pretender definitions
+ */
+export declare function extractAttrs(element: MLASTElement): readonly PretenderAttr[];

package/lib/template/extract-attrs.js

@@ -0,0 +1,26 @@
+/**
+ * Extracts static attributes from an MLAST element node as PretenderAttr entries.
+ *
+ * Only includes attributes with type `'attr'` (regular HTML attributes).
+ * Spread attributes are skipped. Boolean attributes (no value) are included
+ * without a `value` property.
+ *
+ * @param element - The MLAST element node to extract attributes from
+ * @returns Static attributes suitable for pretender definitions
+ */
+export function extractAttrs(element) {
+    const result = [];
+    for (const attr of element.attributes) {
+        if (attr.type !== 'attr') {
+            continue;
+        }
+        const value = attr.value.raw;
+        if (value === '') {
+            result.push({ name: attr.nodeName });
+        }
+        else {
+            result.push({ name: attr.nodeName, value });
+        }
+    }
+    return result;
+}

package/lib/template/extract-root.d.ts

@@ -0,0 +1,11 @@
+import type { MLASTDocument, MLASTElement } from '@markuplint/ml-ast';
+/**
+ * Extracts the first substantive element at depth=0 from a parsed document.
+ *
+ * Skips text nodes, comments, preprocessor-specific blocks (frontmatter, etc.),
+ * and end tags. Returns the first `starttag` node found at depth 0.
+ *
+ * @param doc - The parsed MLAST document to search
+ * @returns The root element, or `null` if only text/comments exist (Fragment-like).
+ */
+export declare function extractRoot(doc: MLASTDocument): MLASTElement | null;

package/lib/template/extract-root.js

@@ -0,0 +1,17 @@
+/**
+ * Extracts the first substantive element at depth=0 from a parsed document.
+ *
+ * Skips text nodes, comments, preprocessor-specific blocks (frontmatter, etc.),
+ * and end tags. Returns the first `starttag` node found at depth 0.
+ *
+ * @param doc - The parsed MLAST document to search
+ * @returns The root element, or `null` if only text/comments exist (Fragment-like).
+ */
+export function extractRoot(doc) {
+    for (const node of doc.nodeList) {
+        if (node.type === 'starttag' && node.depth === 0 && !node.isFragment) {
+            return node;
+        }
+    }
+    return null;
+}

package/lib/template/index.d.ts

@@ -0,0 +1,13 @@
+import type { PretenderScanTemplateOptions } from './types.js';
+/**
+ * Template scanner for Vue, Svelte, and Astro component files.
+ *
+ * Delegates to each parser package's component-scanner subpath export
+ * via dynamic import, keeping framework-specific scanning logic co-located
+ * with the parser that understands the framework best.
+ *
+ * @param files - Absolute file paths to scan (relative paths cause a `ReferenceError`)
+ * @param options - Template scanner configuration (cwd, component names to ignore)
+ * @returns Discovered pretender mappings for all components found in the given files
+ */
+export declare const templateScanner: (files: readonly string[], options?: PretenderScanTemplateOptions | undefined) => Promise<import("@markuplint/ml-config").Pretender[]>;

package/lib/template/index.js

@@ -0,0 +1,57 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { createScanner } from '../create-scanner.js';
+import { PretenderDirector } from '../pretender-director.js';
+import { getScanner } from '../scanner-loader.js';
+import { deriveName } from './derive-name.js';
+/**
+ * Template scanner for Vue, Svelte, and Astro component files.
+ *
+ * Delegates to each parser package's component-scanner subpath export
+ * via dynamic import, keeping framework-specific scanning logic co-located
+ * with the parser that understands the framework best.
+ *
+ * @param files - Absolute file paths to scan (relative paths cause a `ReferenceError`)
+ * @param options - Template scanner configuration (cwd, component names to ignore)
+ * @returns Discovered pretender mappings for all components found in the given files
+ */
+export const templateScanner = createScanner(async (files, options) => {
+    const cwd = options?.cwd ?? process.cwd();
+    const ignoreComponentNames = options?.ignoreComponentNames ?? [];
+    const director = new PretenderDirector();
+    for (const filePath of files) {
+        const componentName = deriveName(filePath);
+        if (ignoreComponentNames.includes(componentName)) {
+            continue;
+        }
+        const ext = path.extname(filePath).toLowerCase();
+        const scanner = await getScanner(ext);
+        if (!scanner) {
+            continue;
+        }
+        let sourceCode;
+        try {
+            sourceCode = fs.readFileSync(filePath, 'utf8');
+        }
+        catch (error) {
+            // eslint-disable-next-line no-console
+            console.warn(`Failed to read component file: ${filePath}`, error instanceof Error ? error.message : error);
+            continue;
+        }
+        const scan = scanner.scanComponent(sourceCode);
+        if (!scan?.rootElement) {
+            continue;
+        }
+        const relFilePath = path.relative(cwd, filePath);
+        const attrs = scan.attrs.map(a => a.value === undefined ? { name: a.name } : { name: a.name, value: a.value });
+        const identity = attrs.length > 0 || scan.hasSlots
+            ? {
+                element: scan.rootElement,
+                ...(attrs.length > 0 ? { attrs } : {}),
+                slots: scan.hasSlots ? true : null,
+            }
+            : scan.rootElement;
+        director.add(componentName, identity, relFilePath, scan.line ?? 1, scan.col ?? 1, relFilePath);
+    }
+    return director.getPretenders();
+});

package/lib/template/parse-component.d.ts

@@ -0,0 +1,22 @@
+import type { MLASTDocument } from '@markuplint/ml-ast';
+type FrameworkType = 'vue' | 'svelte' | 'astro';
+/**
+ * Determines the framework type from the file extension.
+ *
+ * @param filePath - The file path to check
+ * @returns The framework type, or `null` if the extension is not recognized
+ */
+export declare function getFrameworkType(filePath: string): FrameworkType | null;
+/**
+ * Checks if an error is a Node.js ERR_MODULE_NOT_FOUND error.
+ */
+export declare function isModuleNotFoundError(error: unknown): boolean;
+/**
+ * Parses a component file into an MLASTDocument using the appropriate framework parser.
+ *
+ * @param filePath - The absolute path to the component file
+ * @returns The parsed document, or `null` if the file extension is not supported
+ *          or the required parser package is not installed.
+ */
+export declare function parseComponent(filePath: string): Promise<MLASTDocument | null>;
+export {};

package/lib/template/parse-component.js

@@ -0,0 +1,74 @@
+import fs from 'node:fs';
+import path from 'node:path';
+const EXTENSION_MAP = {
+    '.vue': 'vue',
+    '.svelte': 'svelte',
+    '.astro': 'astro',
+};
+/**
+ * Determines the framework type from the file extension.
+ *
+ * @param filePath - The file path to check
+ * @returns The framework type, or `null` if the extension is not recognized
+ */
+export function getFrameworkType(filePath) {
+    const ext = path.extname(filePath).toLowerCase();
+    return EXTENSION_MAP[ext] ?? null;
+}
+const PARSER_PACKAGES = {
+    vue: '@markuplint/vue-parser',
+    svelte: '@markuplint/svelte-parser',
+    astro: '@markuplint/astro-parser',
+};
+/**
+ * Checks if an error is a Node.js ERR_MODULE_NOT_FOUND error.
+ */
+export function isModuleNotFoundError(error) {
+    return (error instanceof Error && 'code' in error && error.code === 'ERR_MODULE_NOT_FOUND');
+}
+/**
+ * Dynamically imports the appropriate parser for the given framework.
+ *
+ * @returns The parser, or `null` if the parser package is not installed.
+ */
+async function getParser(framework) {
+    const pkg = PARSER_PACKAGES[framework];
+    try {
+        const mod = await import(pkg);
+        return mod.parser;
+    }
+    catch (error) {
+        if (isModuleNotFoundError(error)) {
+            // eslint-disable-next-line no-console
+            console.warn(`Parser package "${pkg}" is not installed. Skipping ${framework} files.`);
+            return null;
+        }
+        throw error;
+    }
+}
+/**
+ * Parses a component file into an MLASTDocument using the appropriate framework parser.
+ *
+ * @param filePath - The absolute path to the component file
+ * @returns The parsed document, or `null` if the file extension is not supported
+ *          or the required parser package is not installed.
+ */
+export async function parseComponent(filePath) {
+    const framework = getFrameworkType(filePath);
+    if (!framework) {
+        return null;
+    }
+    const parser = await getParser(framework);
+    if (!parser) {
+        return null;
+    }
+    try {
+        const sourceCode = fs.readFileSync(filePath, 'utf8');
+        return parser.parse(sourceCode);
+    }
+    catch (error) {
+        // eslint-disable-next-line no-console
+        console.warn(`Failed to parse component: ${filePath}`, error instanceof Error ? error.message : error);
+        return null;
+    }
+}

package/lib/template/types.d.ts

@@ -0,0 +1,6 @@
+import type { PretenderScanOptions } from '@markuplint/ml-config';
+/**
+ * Options for the template scanner.
+ */
+export interface PretenderScanTemplateOptions extends PretenderScanOptions {
+}

package/lib/template/types.js

@@ -0,0 +1 @@
+export {};

package/lib/types.d.ts

@@ -23,6 +23,13 @@ export type Identifier = Pretender['selector'];
  * Derived from the `as` property of a Pretender.
  */
 export type Identity = Pretender['as'];
+/**
+ * An import path string used to uniquely identify a component across files.
+ * When provided, this is used as the map key instead of the component name,
+ * enabling disambiguation of identically named components from different locations
+ * (e.g., `../A/Button.vue` vs `../B/Button.vue`).
+ */
+export type ImportPath = string;
 /**
  * Represents an attribute found on a JSX element during scanning.
  */

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@markuplint/pretenders",
-	"version": "5.0.0-dev.5+e96392f56",
+	"version": "5.0.0-rc.1",
 	"description": "It loads components and then creates the pretenders data from them.",
 	"repository": "git@github.com:markuplint/markuplint.git",
 	"author": "Yusuke Hirao <yusukehirao@me.com>",
@@ -28,11 +28,18 @@
 		"clean": "tsc --build --clean tsconfig.build.json"
 	},
 	"dependencies": {
-		"@markuplint/ml-config": "5.0.0-dev.5+e96392f56",
-		"@markuplint/parser-utils": "5.0.0-dev.5+e96392f56",
+		"@markuplint/ml-ast": "5.0.0-rc.1",
+		"@markuplint/ml-config": "5.0.0-rc.1",
+		"@markuplint/parser-utils": "5.0.0-rc.1",
+		"es-module-lexer": "2.0.0",
 		"glob": "13.0.6",
 		"meow": "14.1.0",
-		"typescript": "5.9.3"
+		"typescript": "6.0.2"
 	},
-	"gitHead": "e96392f56e4bc8165ba59622b41c822703a96372"
+	"optionalDependencies": {
+		"@markuplint/astro-parser": "5.0.0-rc.1",
+		"@markuplint/svelte-parser": "5.0.0-rc.1",
+		"@markuplint/vue-parser": "5.0.0-rc.1"
+	},
+	"gitHead": "0d6b4324d9a7d6b9e1ba57d4a57e45d36975cba9"
 }