@markuplint/pretenders 0.0.23 → 0.0.25

package/CHANGELOG.md

@@ -3,13 +3,17 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
-## [0.0.23](https://github.com/markuplint/markuplint/compare/@markuplint/pretenders@0.0.22...@markuplint/pretenders@0.0.23) (2025-08-24)
+## [0.0.25](https://github.com/markuplint/markuplint/compare/@markuplint/pretenders@0.0.24...@markuplint/pretenders@0.0.25) (2026-02-10)
 
 **Note:** Version bump only for package @markuplint/pretenders
 
+## [0.0.24](https://github.com/markuplint/markuplint/compare/@markuplint/pretenders@0.0.23...@markuplint/pretenders@0.0.24) (2025-11-05)
 
+**Note:** Version bump only for package @markuplint/pretenders
 
+## [0.0.23](https://github.com/markuplint/markuplint/compare/@markuplint/pretenders@0.0.22...@markuplint/pretenders@0.0.23) (2025-08-24)
 
+**Note:** Version bump only for package @markuplint/pretenders
 
 ## [0.0.22](https://github.com/markuplint/markuplint/compare/@markuplint/pretenders@0.0.21...@markuplint/pretenders@0.0.22) (2025-08-13)
 

package/lib/cli.d.ts

@@ -1 +1,11 @@
+/**
+ * CLI entry point for the pretenders scanner.
+ * Accepts file glob patterns as input arguments and writes discovered
+ * pretender mappings to a JSON output file.
+ *
+ * Usage: pretenders [options] <glob patterns...>
+ * Flags:
+ *   -O, --out <path>   Output file path (required)
+ *   --ignore <names>   Comma-separated list of component names to ignore
+ */
 export {};

package/lib/cli.js

@@ -1,3 +1,13 @@
+/**
+ * CLI entry point for the pretenders scanner.
+ * Accepts file glob patterns as input arguments and writes discovered
+ * pretender mappings to a JSON output file.
+ *
+ * Usage: pretenders [options] <glob patterns...>
+ * Flags:
+ *   -O, --out <path>   Output file path (required)
+ *   --ignore <names>   Comma-separated list of component names to ignore
+ */
 import path from 'node:path';
 import meow from 'meow';
 import { getFileList } from './input.js';

package/lib/create-scanner.d.ts

@@ -1,3 +1,11 @@
 import type { PretenderScannerScanMethod } from './types.js';
 import type { PretenderScanOptions } from '@markuplint/ml-config';
+/**
+ * Creates a pretender scanner by wrapping a scan method with path validation.
+ * Ensures all provided file paths are absolute before delegating to the scan method.
+ *
+ * @template O - The scan options type, extending PretenderScanOptions
+ * @param method - The underlying scan method to wrap with validation
+ * @returns A wrapped scanner function that validates file paths and then invokes the scan method
+ */
 export declare function createScanner<O extends PretenderScanOptions = PretenderScanOptions>(method: PretenderScannerScanMethod<O>): (files: readonly string[], options?: O) => Promise<import("@markuplint/ml-config").Pretender[]>;

package/lib/create-scanner.js

@@ -1,4 +1,12 @@
 import path from 'node:path';
+/**
+ * Creates a pretender scanner by wrapping a scan method with path validation.
+ * Ensures all provided file paths are absolute before delegating to the scan method.
+ *
+ * @template O - The scan options type, extending PretenderScanOptions
+ * @param method - The underlying scan method to wrap with validation
+ * @returns A wrapped scanner function that validates file paths and then invokes the scan method
+ */
 export function createScanner(method) {
     return (files, options) => {
         for (const file of files) {

package/lib/dependency-mapper.d.ts

@@ -1,10 +1,42 @@
 import type { Identifier, Identity } from './types.js';
 import type { Pretender } from '@markuplint/ml-config';
+/**
+ * Internal map structure storing component identifiers to their identity and source location.
+ */
 type PretenderDirectorMap = Map<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.
+ */
 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).
+     *
+     * @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
+     */
     add(identifier: Identifier, identity: Identity, filePath: string, line: number, col: number): 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(): Pretender[];
 }
+/**
+ * Resolves a map of component-to-identity mappings into a flat array of Pretender objects.
+ * Follows chains where one component wraps another (e.g., MyButton -> Button -> button)
+ * until a native element is reached or a recursive loop is detected.
+ *
+ * @param map - The map of component identifiers to their identity and file path
+ * @returns A sorted array of fully resolved Pretender objects
+ */
 export declare function dependencyMapper(map: Readonly<PretenderDirectorMap>): Pretender[];
 export {};

package/lib/dependency-mapper.js

@@ -4,21 +4,50 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
     return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
 };
 var _PretenderDirector_map;
+/**
+ * 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.
+ */
 export class PretenderDirector {
     constructor() {
         _PretenderDirector_map.set(this, new Map());
     }
+    /**
+     * Registers a component as a pretender mapping. If the 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
+     */
     add(identifier, identity, filePath, line, col) {
         if (__classPrivateFieldGet(this, _PretenderDirector_map, "f").has(identifier)) {
             return;
         }
         __classPrivateFieldGet(this, _PretenderDirector_map, "f").set(identifier, [identity, `${filePath}:${line}:${col}`]);
     }
+    /**
+     * 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() {
         return dependencyMapper(__classPrivateFieldGet(this, _PretenderDirector_map, "f"));
     }
 }
 _PretenderDirector_map = new WeakMap();
+/**
+ * Resolves a map of component-to-identity mappings into a flat array of Pretender objects.
+ * Follows chains where one component wraps another (e.g., MyButton -> Button -> button)
+ * until a native element is reached or a recursive loop is detected.
+ *
+ * @param map - The map of component identifiers to their identity and file path
+ * @returns A sorted array of fully resolved Pretender objects
+ */
 export function dependencyMapper(map) {
     const linkedPretenders = [];
     const collection = [...map.entries()];

package/lib/index.d.ts

@@ -1,2 +1,9 @@
+/**
+ * @module @markuplint/pretenders
+ *
+ * Provides scanning utilities for detecting component-to-element mappings (pretenders)
+ * in JSX/TSX source files. Pretenders allow markuplint to understand which native HTML
+ * elements a component renders, enabling accurate linting of component-based code.
+ */
 export { jsxScanner } from './jsx/index.js';
 export type * from './types.js';

package/lib/index.js

@@ -1 +1,8 @@
+/**
+ * @module @markuplint/pretenders
+ *
+ * Provides scanning utilities for detecting component-to-element mappings (pretenders)
+ * in JSX/TSX source files. Pretenders allow markuplint to understand which native HTML
+ * elements a component renders, enabling accurate linting of component-based code.
+ */
 export { jsxScanner } from './jsx/index.js';

package/lib/input.d.ts

@@ -1 +1,8 @@
+/**
+ * Resolves a list of file path patterns (possibly relative or glob patterns)
+ * into a flat array of matching absolute file paths.
+ *
+ * @param input - An array of file paths or glob patterns to resolve
+ * @returns A flat array of resolved absolute file paths matching the input patterns
+ */
 export declare function getFileList(input: readonly string[]): Promise<string[]>;

package/lib/input.js

@@ -1,5 +1,12 @@
 import path from 'node:path';
 import { glob } from 'glob';
+/**
+ * Resolves a list of file path patterns (possibly relative or glob patterns)
+ * into a flat array of matching absolute file paths.
+ *
+ * @param input - An array of file paths or glob patterns to resolve
+ * @returns A flat array of resolved absolute file paths matching the input patterns
+ */
 export async function getFileList(input) {
     const result = await Promise.all(input
         .map(filePath => {

package/lib/jsx/create-identify.d.ts

@@ -1,3 +1,14 @@
 import type { Attr } from '../types.js';
 import type { Slot } from '@markuplint/ml-config';
+/**
+ * Creates a pretender identity from a JSX element's tag name, attributes, and slots.
+ * If the element has no attributes, returns just the tag name string.
+ * Otherwise, returns a detailed identity object including attributes, slots,
+ * and whether the element inherits spread attributes.
+ *
+ * @param tagName - The HTML element or component tag name
+ * @param attrs - The attributes discovered on the JSX element
+ * @param slots - The child slots discovered within the JSX element
+ * @returns A simple tag name string or a detailed Identity object
+ */
 export declare function createIndentity(tagName: string, attrs: readonly Attr[], slots: readonly Slot[]): string | import("@markuplint/ml-config").OriginalNode;

package/lib/jsx/create-identify.js

@@ -1,3 +1,14 @@
+/**
+ * Creates a pretender identity from a JSX element's tag name, attributes, and slots.
+ * If the element has no attributes, returns just the tag name string.
+ * Otherwise, returns a detailed identity object including attributes, slots,
+ * and whether the element inherits spread attributes.
+ *
+ * @param tagName - The HTML element or component tag name
+ * @param attrs - The attributes discovered on the JSX element
+ * @param slots - The child slots discovered within the JSX element
+ * @returns A simple tag name string or a detailed Identity object
+ */
 export function createIndentity(tagName, attrs, slots) {
     if (attrs.length === 0) {
         return tagName;

package/lib/jsx/finder.d.ts

@@ -1,2 +1,10 @@
 import type { Node, SourceFile } from 'typescript';
+/**
+ * Creates a recursive AST node finder bound to a specific source file.
+ * The returned `find` function traverses the AST depth-first, invoking the
+ * visitor callback on the first node that matches the type guard predicate.
+ *
+ * @param sourceFile - The TypeScript source file context for the traversal
+ * @returns A `find` function that searches for nodes matching a type guard and invokes a visitor
+ */
 export declare function finder(sourceFile: SourceFile): <N extends Node>(node: Node, is: (node: Node) => node is N, visit: (node: N, sourceFile: SourceFile) => void) => void;

package/lib/jsx/finder.js

@@ -1,8 +1,26 @@
 import ts from 'typescript';
 const { forEachChild } = ts;
+/**
+ * Creates a recursive AST node finder bound to a specific source file.
+ * The returned `find` function traverses the AST depth-first, invoking the
+ * visitor callback on the first node that matches the type guard predicate.
+ *
+ * @param sourceFile - The TypeScript source file context for the traversal
+ * @returns A `find` function that searches for nodes matching a type guard and invokes a visitor
+ */
 export function finder(
 // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
 sourceFile) {
+    /**
+     * Recursively searches the AST starting from the given node.
+     * If the node matches the type guard, the visitor is called immediately
+     * and recursion stops for that branch. Otherwise, all children are traversed.
+     *
+     * @template N - The specific AST node type to find
+     * @param node - The starting AST node to search from
+     * @param is - A TypeScript type guard predicate to match desired nodes
+     * @param visit - A callback invoked with each matched node and the source file
+     */
     return function find(
     // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
     node, is, visit) {

package/lib/jsx/get-attributes.d.ts

@@ -1,3 +1,12 @@
 import type { Attr } from '../types.js';
 import type { JsxOpeningElement, JsxSelfClosingElement, SourceFile } from 'typescript';
+/**
+ * Extracts all attributes from a JSX opening or self-closing element.
+ * Classifies each attribute by its node type: static (string literal value),
+ * boolean (no value), dynamic (expression value), or spread ({...props}).
+ *
+ * @param el - The JSX opening or self-closing element to extract attributes from
+ * @param sourceFile - The TypeScript source file containing the element
+ * @returns An array of Attr objects representing all discovered attributes
+ */
 export declare function getAttributes(el: JsxOpeningElement | JsxSelfClosingElement, sourceFile: SourceFile): Attr[];

package/lib/jsx/get-attributes.js

@@ -1,6 +1,15 @@
 import ts from 'typescript';
 import { finder } from './finder.js';
 const { isJsxAttribute, isJsxExpression, isJsxSpreadAttribute, isStringLiteral } = ts;
+/**
+ * Extracts all attributes from a JSX opening or self-closing element.
+ * Classifies each attribute by its node type: static (string literal value),
+ * boolean (no value), dynamic (expression value), or spread ({...props}).
+ *
+ * @param el - The JSX opening or self-closing element to extract attributes from
+ * @param sourceFile - The TypeScript source file containing the element
+ * @returns An array of Attr objects representing all discovered attributes
+ */
 export function getAttributes(
 // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
 el, 

package/lib/jsx/get-children.d.ts

@@ -1,3 +1,11 @@
 import type { Slot } from '@markuplint/ml-config';
 import type { JsxOpeningElement, JsxSelfClosingElement, SourceFile } from 'typescript';
+/**
+ * Extracts child slot information from a JSX element.
+ * Currently returns an empty array as child slot extraction is not yet implemented.
+ *
+ * @param el - The JSX opening or self-closing element to extract children from
+ * @param sourceFile - The TypeScript source file containing the element
+ * @returns An array of Slot objects representing discovered child slots
+ */
 export declare function getChildren(el: JsxOpeningElement | JsxSelfClosingElement, sourceFile: SourceFile): Slot[];

package/lib/jsx/get-children.js

@@ -1,4 +1,12 @@
 // import { finder } from './finder.js';
+/**
+ * Extracts child slot information from a JSX element.
+ * Currently returns an empty array as child slot extraction is not yet implemented.
+ *
+ * @param el - The JSX opening or self-closing element to extract children from
+ * @param sourceFile - The TypeScript source file containing the element
+ * @returns An array of Slot objects representing discovered child slots
+ */
 export function getChildren(
 // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
 el, 

package/lib/jsx/index.d.ts

@@ -1,3 +1,23 @@
+/**
+ * @module @markuplint/pretenders/jsx
+ *
+ * JSX/TSX scanner for discovering pretender mappings. Analyzes component source
+ * files using the TypeScript compiler API to determine which native HTML elements
+ * each component renders, including support for styled-components, HOC wrappers,
+ * and fragment providers.
+ */
 import type { PretenderScanJSXOptions } from './types.js';
 import type { Pretender } from '@markuplint/ml-config';
+/**
+ * A scanner function that analyzes JSX/TSX source files to discover pretender mappings.
+ * Uses the TypeScript compiler API to parse and traverse the AST, identifying component
+ * definitions and the native HTML elements they render.
+ *
+ * Supports:
+ * - Function components (function declarations and arrow functions)
+ * - Styled-components (`styled.element` tagged templates)
+ * - HOC / wrapper function patterns
+ * - Fragment and provider component transparency
+ * - `@pretends null` JSDoc tag to opt out a component
+ */
 export declare const jsxScanner: (files: readonly string[], options?: PretenderScanJSXOptions | undefined) => Promise<Pretender[]>;

package/lib/jsx/index.js

@@ -1,3 +1,11 @@
+/**
+ * @module @markuplint/pretenders/jsx
+ *
+ * JSX/TSX scanner for discovering pretender mappings. Analyzes component source
+ * files using the TypeScript compiler API to determine which native HTML elements
+ * each component renders, including support for styled-components, HOC wrappers,
+ * and fragment providers.
+ */
 import path from 'node:path';
 import { getPosition } from '@markuplint/parser-utils/location';
 import ts from 'typescript';
@@ -8,6 +16,10 @@ import { finder } from './finder.js';
 import { getAttributes } from './get-attributes.js';
 import { getChildren } from './get-children.js';
 const { createProgram, forEachChild, isArrowFunction, isCallExpression, isFunctionDeclaration, isJsxFragment, isJsxOpeningElement, isJsxSelfClosingElement, isReturnStatement, isTaggedTemplateExpression, isVariableDeclaration, JsxEmit, } = ts;
+/**
+ * Default options for the JSX scanner, including built-in patterns
+ * for styled-components and provider components.
+ */
 const defaultOptions = {
     cwd: process.cwd(),
     asFragment: [/(?:^|\.)provider$/i],
@@ -20,6 +32,18 @@ const defaultOptions = {
     ],
     extendingWrapper: [],
 };
+/**
+ * A scanner function that analyzes JSX/TSX source files to discover pretender mappings.
+ * Uses the TypeScript compiler API to parse and traverse the AST, identifying component
+ * definitions and the native HTML elements they render.
+ *
+ * Supports:
+ * - Function components (function declarations and arrow functions)
+ * - Styled-components (`styled.element` tagged templates)
+ * - HOC / wrapper function patterns
+ * - Fragment and provider component transparency
+ * - `@pretends null` JSDoc tag to opt out a component
+ */
 export const jsxScanner = createScanner((files, options = defaultOptions) => {
     const { cwd = defaultOptions.cwd, ignoreComponentNames = defaultOptions.ignoreComponentNames, asFragment = defaultOptions.asFragment, taggedStylingComponent = defaultOptions.taggedStylingComponent, extendingWrapper = defaultOptions.extendingWrapper, } = options;
     const director = new PretenderDirector();

package/lib/jsx/types.d.ts

@@ -1,10 +1,24 @@
 import type { PretenderScanOptions } from '@markuplint/ml-config';
+/**
+ * Configuration options for the JSX pretender scanner.
+ * Extends the base scan options with JSX-specific settings for handling
+ * fragments, styled-components, and wrapper patterns.
+ */
 export interface PretenderScanJSXOptions extends PretenderScanOptions {
+    /** Patterns matching component names to treat as transparent fragments (children are scanned instead) */
     asFragment?: readonly (Readonly<RegExp> | string)[];
+    /** Patterns matching tagged template expressions for CSS-in-JS libraries (e.g., styled.button) */
     taggedStylingComponent?: readonly (Readonly<RegExp> | string)[];
+    /** Patterns matching HOC or wrapper function calls that extend another component */
     extendingWrapper?: readonly (string | Readonly<RegExp> | ExtendingWrapperCallerOptions)[];
 }
+/**
+ * Configuration for identifying a wrapper/HOC function call and which
+ * argument position contains the wrapped component reference.
+ */
 export type ExtendingWrapperCallerOptions = {
+    /** Pattern to match the wrapper function identifier */
     readonly identifier: string | Readonly<RegExp>;
+    /** The 1-based argument position that contains the wrapped component */
     readonly numberOfArgument: number;
 };

package/lib/out.d.ts

@@ -1,2 +1,9 @@
 import type { Pretender } from '@markuplint/ml-config';
+/**
+ * Writes an array of pretender mappings to a JSON file in the PretenderFileData format.
+ * The output file includes the package version and the pretender data array.
+ *
+ * @param filePath - The absolute path of the output JSON file to write
+ * @param data - The array of Pretender objects to serialize
+ */
 export declare function out(filePath: string, data: readonly Pretender[]): Promise<void>;

package/lib/out.js

@@ -1,6 +1,13 @@
 import { writeFile } from 'node:fs/promises';
 import { createRequire } from 'node:module';
 const require = createRequire(import.meta.url);
+/**
+ * Writes an array of pretender mappings to a JSON file in the PretenderFileData format.
+ * The output file includes the package version and the pretender data array.
+ *
+ * @param filePath - The absolute path of the output JSON file to write
+ * @param data - The array of Pretender objects to serialize
+ */
 export async function out(filePath, data) {
     await writeFile(filePath, JSON.stringify({
         version: require('../package.json').version,

package/lib/pretender-director.d.ts

@@ -1,6 +1,27 @@
 import type { Identifier, Identity } from './types.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.
+ */
 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).
+     *
+     * @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
+     */
     add(identifier: Identifier, identity: Identity, filePath: string, line: number, col: number): 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[];
 }

package/lib/pretender-director.js

@@ -5,16 +5,37 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
 };
 var _PretenderDirector_map;
 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.
+ */
 export class PretenderDirector {
     constructor() {
         _PretenderDirector_map.set(this, new Map());
     }
+    /**
+     * Registers a component as a pretender mapping. If the 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
+     */
     add(identifier, identity, filePath, line, col) {
         if (__classPrivateFieldGet(this, _PretenderDirector_map, "f").has(identifier)) {
             return;
         }
         __classPrivateFieldGet(this, _PretenderDirector_map, "f").set(identifier, [identity, `${filePath}:${line}:${col}`]);
     }
+    /**
+     * 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() {
         return dependencyMapper(__classPrivateFieldGet(this, _PretenderDirector_map, "f"));
     }

package/lib/types.d.ts

@@ -1,15 +1,38 @@
 import type { PretenderScanOptions, Pretender } from '@markuplint/ml-config';
+/**
+ * A scan method function signature used by pretender scanners.
+ * Accepts a list of absolute file paths and optional scan options,
+ * and returns a promise resolving to an array of discovered pretender mappings.
+ *
+ * @template O - The scan options type, extending PretenderScanOptions
+ */
 export type PretenderScannerScanMethod<O extends PretenderScanOptions = PretenderScanOptions> = 
 /**
  * @param files Absolute file paths. If it includes a relative path, throw an error.
- * @param options
+ * @param options - Optional scan configuration
  */
 (files: readonly string[], options?: Readonly<O>) => Promise<Pretender[]>;
+/**
+ * The CSS selector string that identifies a component (e.g., the component name).
+ * Derived from the `selector` property of a Pretender.
+ */
 export type Identifier = Pretender['selector'];
+/**
+ * The native HTML element identity that a component pretends to be.
+ * Can be a simple element name string or an object with detailed mapping.
+ * Derived from the `as` property of a Pretender.
+ */
 export type Identity = Pretender['as'];
+/**
+ * Represents an attribute found on a JSX element during scanning.
+ */
 export type Attr = {
+    /** The kind of attribute: static string, boolean, dynamic expression, or spread */
     readonly nodeType: 'static' | 'boolean' | 'dynamic' | 'spread';
+    /** The attribute name */
     readonly name: string;
+    /** The attribute value (empty string for boolean, 'N/A' for spread) */
     readonly value: string;
+    /** Optional type annotation for the attribute */
     readonly type?: string;
 };

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@markuplint/pretenders",
-	"version": "0.0.23",
+	"version": "0.0.25",
 	"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>",
@@ -25,11 +25,11 @@
 		"clean": "tsc --build --clean tsconfig.build.json"
 	},
 	"dependencies": {
-		"@markuplint/ml-config": "4.8.13",
-		"@markuplint/parser-utils": "4.8.9",
-		"glob": "11.0.3",
+		"@markuplint/ml-config": "4.8.15",
+		"@markuplint/parser-utils": "4.8.11",
+		"glob": "13.0.1",
 		"meow": "13.2.0",
-		"typescript": "5.9.2"
+		"typescript": "5.9.3"
 	},
-	"gitHead": "ae97eb2d31ecedf4f0800fbbf18588aad4ebca04"
+	"gitHead": "193ee7c1262bbed95424e38efdf1a8e56ff049f4"
 }