@markuplint/pretenders 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2017-2024 Yusuke Hirao
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,138 @@
+# @markuplint/pretenders
+
+[![npm version](https://badge.fury.io/js/%40markuplint%2Fpretenders.svg)](https://www.npmjs.com/package/@markuplint/pretenders)
+[![Build Status](https://travis-ci.org/markuplint/markuplint.svg?branch=main)](https://travis-ci.org/markuplint/markuplint)
+[![Coverage Status](https://coveralls.io/repos/github/markuplint/markuplint/badge.svg?branch=main)](https://coveralls.io/github/markuplint/markuplint?branch=main)
+
+This module features both an API and a CLI that generate **[Pretenders](https://markuplint.dev/docs/guides/besides-html#pretenders) data** from the loaded components
+
+## Usage
+
+```sh
+$ npx @markuplint/pretenders "./src/**/*.jsx" --out "./pretenders.json"
+```
+
+The module analyzes components defined in files using a parser, currently supporting JSX (both `*.jsx` and `*.tsx` formats). It searches for functions or function objects that return elements and maps their function names or the variable names holding these function objects. For example, if a function object named `Foo` returns a `<div>`, the component `Foo` is considered as pretending to be a `div`. In the CLI, it exports the mapped data as a JSON file. By loading this JSON file into the Pretenders feature, the module evaluates the `Foo` component as equivalent to a `div`.
+
+```jsx
+const Foo = () => <div />;
+
+function Bar() {
+  return <span />;
+}
+```
+
+```json
+[
+  {
+    "selector": "Foo",
+    "as": "div"
+  },
+  {
+    "selector": "Bar",
+    "as": "span"
+  }
+]
+```
+
+The module is **experimental**. It uses the TypeScript compiler to identify functions or function objects in JSX files where the return values are components or HTML elements. Currently, it only performs a simplistic mapping based on function and variable names without considering dependencies between files. **Consequently, it does not handle name duplications across files or variable scopes;** components with duplicate names overwrite existing data during processing.
+
+In addition to definitions based on function and variable names, the module also infers HTML elements from properties, as exemplified by `styled-components`, and infers dependencies from arguments.
+
+```jsx
+const Foo = styled.div`
+  color: red;
+`;
+
+const Bar = styled(Foo)`
+  background-color: blue;
+`;
+```
+
+```json
+[
+  {
+    "selector": "Foo",
+    "as": "div"
+  },
+  {
+    "selector": "Bar",
+    "as": "div"
+  }
+]
+```
+
+## API
+
+### `jsxScanner(files, options)`
+
+```ts
+import { jsxScanner } from '@markuplint/pretenders';
+
+const pretenders = jsxScanner(['./src/**/*.jsx'], {
+  cwd: process.cwd(),
+  asFragment: [/(?:^|\.)provider$/i],
+  ignoreComponentNames: [],
+  taggedStylingComponent: [
+    // PropertyAccessExpression: styled.button`css-prop: value;`
+    /^styled\.(?<tagName>[a-z][\da-z]*)$/i,
+    // CallExpression: styled(Button)`css-prop: value;`
+    /^styled\s*\(\s*(?<tagName>[a-z][\da-z]*)\s*\)$/i,
+  ],
+  extendingWrapper: [],
+});
+```
+
+#### `files`
+
+Type: `string[]`
+
+An array of file paths to scan.
+
+##### `options.cwd`
+
+Type: `string`
+
+The current working directory.
+
+##### `options.asFragment`
+
+Type: `RegExp[]`
+
+A list of regular expressions to match components that should be treated as fragments.
+
+##### `options.ignoreComponentNames`
+
+Type: `string[]`
+
+A list of component names to ignore.
+
+##### `options.taggedStylingComponent`
+
+Type: `RegExp[]`
+
+A list of regular expressions to match components that are styled.
+
+##### `options.extendingWrapper`
+
+Type: `RegExp[]` | `{ identifier: RegExp, numberOfArgument: number }[]`
+
+```js
+jsxScanner(['./src/**/*.jsx'], {
+  extendingWrapper: [
+    {
+      identifier: /^namespace\.primary$/i,
+      numberOfArgument: 1,
+    },
+  ],
+});
+```
+
+```jsx
+const Foo = <div />;
+const Bar = namespace.primary(true, Foo);
+```
+
+A list of regular expressions to match components that are extended.
+`identifier` is a regular expression to match the component name.
+`numberOfArgument` is the number of arguments to pass to the component.

package/bin/pretenders.mjs

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+
+import '../lib/cli.js';

package/lib/cli.d.ts

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

package/lib/cli.js

@@ -0,0 +1,31 @@
+import path from 'node:path';
+import meow from 'meow';
+import { getFileList } from './input.js';
+import { jsxScanner } from './jsx/index.js';
+import { out } from './out.js';
+const commands = meow({
+    importMeta: import.meta,
+    flags: {
+        out: {
+            type: 'string',
+            isRequired: true,
+            shortFlag: 'O',
+        },
+        ignore: {
+            type: 'string',
+        },
+    },
+});
+if (commands.input.length === 0) {
+    commands.showHelp(1);
+}
+async function main() {
+    const files = await getFileList(commands.input);
+    const jsxFiles = files.filter(filePath => /\.[jt]sx?$/.test(filePath));
+    const pretenders = await jsxScanner(jsxFiles, {
+        ignoreComponentNames: commands.flags.ignore?.split(',').map(s => s.trim()),
+    });
+    const outFilePath = path.resolve(process.cwd(), commands.flags.out);
+    await out(outFilePath, pretenders);
+}
+await main();

package/lib/create-scanner.d.ts

@@ -0,0 +1,3 @@
+import type { PretenderScannerScanMethod } from './types.js';
+import type { PretenderScanOptions } from '@markuplint/ml-config';
+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

@@ -0,0 +1,11 @@
+import path from 'node:path';
+export function createScanner(method) {
+    return (files, options) => {
+        for (const file of files) {
+            if (!path.isAbsolute(file)) {
+                throw new ReferenceError(`A path is not an absolute path: ${file}`);
+            }
+        }
+        return method(files, options);
+    };
+}

package/lib/dependency-mapper.d.ts

@@ -0,0 +1,10 @@
+import type { Identifier, Identity } from './types.js';
+import type { Pretender } from '@markuplint/ml-config';
+type PretenderDirectorMap = Map<Identifier, [identity: Identity, filePath?: string]>;
+export declare class PretenderDirector {
+    #private;
+    add(identifier: Identifier, identity: Identity, filePath: string, line: number, col: number): void;
+    getPretenders(): Pretender[];
+}
+export declare function dependencyMapper(map: Readonly<PretenderDirectorMap>): Pretender[];
+export {};

package/lib/dependency-mapper.js

@@ -0,0 +1,86 @@
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _PretenderDirector_map;
+export class PretenderDirector {
+    constructor() {
+        _PretenderDirector_map.set(this, new Map());
+    }
+    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}`]);
+    }
+    getPretenders() {
+        return dependencyMapper(__classPrivateFieldGet(this, _PretenderDirector_map, "f"));
+    }
+}
+_PretenderDirector_map = new WeakMap();
+export function dependencyMapper(map) {
+    const linkedPretenders = [];
+    const collection = [...map.entries()];
+    for (const [identifier, [_identity, _filePath]] of collection) {
+        let identity = _identity;
+        let filePath = _filePath;
+        let elName = getElName(identity);
+        const via = [];
+        // eslint-disable-next-line no-constant-condition
+        while (true) {
+            const mappedPretender = map.get(elName);
+            if (!mappedPretender) {
+                break;
+            }
+            identity = mappedPretender[0];
+            filePath = mappedPretender[1];
+            if (elName === identifier) {
+                via.push('...[Recursive]');
+                break;
+            }
+            via.push(elName);
+            elName = getElName(identity);
+        }
+        const pretender = {
+            selector: identifier,
+            as: identity,
+        };
+        if (filePath) {
+            // @ts-ignore initialize readonly property
+            pretender.filePath = filePath;
+        }
+        if (via.length > 0) {
+            // @ts-ignore
+            pretender._via = via;
+        }
+        linkedPretenders.push(pretender);
+    }
+    return linkedPretenders.sort(propSort('selector'));
+}
+function getElName(identity) {
+    if (typeof identity === 'string') {
+        return identity;
+    }
+    return identity.element;
+}
+function propSort(propName) {
+    return (a, b) => {
+        const nameA = toLowerCase(a[propName]);
+        const nameB = toLowerCase(b[propName]);
+        if (nameA < nameB) {
+            return -1;
+        }
+        if (nameA > nameB) {
+            return 1;
+        }
+        return 0;
+    };
+}
+function toLowerCase(value) {
+    if (typeof value === 'string') {
+        // @ts-ignore
+        return value.toLowerCase();
+    }
+    return value;
+}

package/lib/index.d.ts

@@ -0,0 +1,2 @@
+export { jsxScanner } from './jsx/index.js';
+export type * from './types.js';

package/lib/index.js

@@ -0,0 +1 @@
+export { jsxScanner } from './jsx/index.js';

package/lib/input.d.ts

@@ -0,0 +1 @@
+export declare function getFileList(input: readonly string[]): Promise<string[]>;

package/lib/input.js

@@ -0,0 +1,13 @@
+import path from 'node:path';
+import { glob } from 'glob';
+export async function getFileList(input) {
+    const result = await Promise.all(input
+        .map(filePath => {
+        if (path.isAbsolute(filePath)) {
+            return filePath;
+        }
+        return path.resolve(process.cwd(), filePath);
+    })
+        .map(filePath => glob(filePath)));
+    return result.flat();
+}

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

@@ -0,0 +1,3 @@
+import type { Attr } from '../types.js';
+import type { Slot } from '@markuplint/ml-config';
+export declare function createIndentity(tagName: string, attrs: readonly Attr[], slots: readonly Slot[]): string | import("@markuplint/ml-config").OriginalNode;

package/lib/jsx/create-identify.js

@@ -0,0 +1,30 @@
+export function createIndentity(tagName, attrs, slots) {
+    if (attrs.length === 0) {
+        return tagName;
+    }
+    const availableAttrs = attrs.filter(attr => attr.nodeType !== 'spread');
+    const hasSpread = attrs.some(attr => attr.nodeType === 'spread');
+    const pretenderAttrs = availableAttrs.map(attr => {
+        const pretenderAttr = {
+            name: attr.name,
+        };
+        if (attr.nodeType === 'static' && attr.value) {
+            // @ts-ignore initialize readonly property
+            pretenderAttr.value = attr.value;
+        }
+        return pretenderAttr;
+    });
+    const identify = {
+        element: tagName,
+        slots,
+    };
+    if (pretenderAttrs.length > 0) {
+        // @ts-ignore initialize readonly property
+        identify.attrs = pretenderAttrs;
+    }
+    if (hasSpread) {
+        // @ts-ignore initialize readonly property
+        identify.inheritAttrs = true;
+    }
+    return identify;
+}

package/lib/jsx/finder.d.ts

@@ -0,0 +1,2 @@
+import type { Node, SourceFile } from 'typescript';
+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

@@ -0,0 +1,17 @@
+import ts from 'typescript';
+/* eslint-disable import/no-named-as-default-member */
+const { forEachChild } = ts;
+/* eslint-enable import/no-named-as-default-member */
+export function finder(
+// eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+sourceFile) {
+    return function find(
+    // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+    node, is, visit) {
+        if (is(node)) {
+            visit(node, sourceFile);
+            return;
+        }
+        forEachChild(node, node => find(node, is, visit));
+    };
+}

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

@@ -0,0 +1,3 @@
+import type { Attr } from '../types.js';
+import type { JsxOpeningElement, JsxSelfClosingElement, SourceFile } from 'typescript';
+export declare function getAttributes(el: JsxOpeningElement | JsxSelfClosingElement, sourceFile: SourceFile): Attr[];

package/lib/jsx/get-attributes.js

@@ -0,0 +1,44 @@
+import ts from 'typescript';
+import { finder } from './finder.js';
+/* eslint-disable import/no-named-as-default-member */
+const { isJsxAttribute, isJsxExpression, isJsxSpreadAttribute, isStringLiteral } = ts;
+/* eslint-enable import/no-named-as-default-member */
+export function getAttributes(
+// eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+el, 
+// eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+sourceFile) {
+    const find = finder(sourceFile);
+    const attrs = [];
+    find(el.attributes, isJsxAttribute, attr => {
+        find(attr, isStringLiteral, str => {
+            attrs.push({
+                nodeType: 'static',
+                name: attr.name.getText(sourceFile),
+                value: str.text,
+            });
+        });
+        find(attr, isJsxExpression, exp => {
+            attrs.push({
+                nodeType: 'dynamic',
+                name: attr.name.getText(sourceFile),
+                value: exp.getText(sourceFile),
+            });
+        });
+        if (attr.getChildCount(sourceFile) === 1) {
+            attrs.push({
+                nodeType: 'boolean',
+                name: attr.name.getText(sourceFile),
+                value: '',
+            });
+        }
+    });
+    find(el.attributes, isJsxSpreadAttribute, attr => {
+        attrs.push({
+            nodeType: 'spread',
+            name: attr.name?.getText(sourceFile) ?? 'N/A',
+            value: 'N/A',
+        });
+    });
+    return attrs;
+}

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

@@ -0,0 +1,3 @@
+import type { Slot } from '@markuplint/ml-config';
+import type { JsxOpeningElement, JsxSelfClosingElement, SourceFile } from 'typescript';
+export declare function getChildren(el: JsxOpeningElement | JsxSelfClosingElement, sourceFile: SourceFile): Slot[];

package/lib/jsx/get-children.js

@@ -0,0 +1,10 @@
+// import { finder } from './finder.js';
+export function getChildren(
+// eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+el, 
+// eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+sourceFile) {
+    const children = [];
+    // const find = finder(sourceFile);
+    return children;
+}

package/lib/jsx/index.d.ts

@@ -0,0 +1,3 @@
+import type { PretenderScanJSXOptions } from './types.js';
+import type { Pretender } from '@markuplint/ml-config';
+export declare const jsxScanner: (files: readonly string[], options?: PretenderScanJSXOptions | undefined) => Promise<Pretender[]>;

package/lib/jsx/index.js

@@ -0,0 +1,276 @@
+import path from 'node:path';
+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 { finder } from './finder.js';
+import { getAttributes } from './get-attributes.js';
+import { getChildren } from './get-children.js';
+/* eslint-disable import/no-named-as-default-member */
+const { createProgram, forEachChild, isArrowFunction, isCallExpression, isFunctionDeclaration, isJsxFragment, isJsxOpeningElement, isJsxSelfClosingElement, isReturnStatement, isTaggedTemplateExpression, isVariableDeclaration, JsxEmit, } = ts;
+/* eslint-enable import/no-named-as-default-member */
+const defaultOptions = {
+    cwd: process.cwd(),
+    asFragment: [/(?:^|\.)provider$/i],
+    ignoreComponentNames: [],
+    taggedStylingComponent: [
+        // PropertyAccessExpression: styled.button`css-prop: value;`
+        /^styled\.(?<tagName>[a-z][\da-z]*)$/i,
+        // CallExpression: styled(Button)`css-prop: value;`
+        /^styled\s*\(\s*(?<tagName>[a-z][\da-z]*)\s*\)$/i,
+    ],
+    extendingWrapper: [],
+};
+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();
+    const program = createProgram(files, {
+        jsx: JsxEmit.ReactJSX,
+        allowJs: true,
+    });
+    for (const sourceFile of program.getSourceFiles()) {
+        if (!sourceFile.isDeclarationFile) {
+            forEachChild(sourceFile, node => visit(node, sourceFile));
+        }
+    }
+    function visit(
+    // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+    root, 
+    // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+    sourceFile) {
+        const find = finder(sourceFile);
+        /**
+         * ```
+         * const Component = ...
+         * ------^
+         * ```
+         */
+        find(root, isVariableDeclaration, define);
+        /**
+         * ```
+         * function Component (...) {...}
+         * ---------^
+         * ```
+         */
+        find(root, isFunctionDeclaration, define);
+    }
+    function define(
+    // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+    dec, 
+    // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+    sourceFile) {
+        if (!dec.name) {
+            return;
+        }
+        const variableName = dec.name.getText(sourceFile);
+        if (ignoreComponentNames.includes(variableName)) {
+            return;
+        }
+        if ('jsDoc' in dec && dec.jsDoc) {
+            const jsDoc = dec.jsDoc;
+            const pretendsTag = jsDoc
+                .flatMap(doc => doc.tags ?? [])
+                .find(doc => doc.tagName.text.toLowerCase() === 'pretends');
+            if (pretendsTag && pretendsTag.comment === 'null') {
+                return;
+            }
+        }
+        const { line, column } = getPosition(sourceFile.text, dec.name.pos);
+        /**
+         * ```
+         * const Component = ...
+         * ------------------^
+         *
+         * function Component (...) {...}
+         * --------------------------^
+         * ```
+         */
+        findBody(dec, variableName, sourceFile, line, column);
+    }
+    function findBody(
+    // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+    root, name, 
+    // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+    sourceFile, line, col) {
+        const filePath = path.relative(cwd, sourceFile.fileName);
+        const find = finder(sourceFile);
+        find(root, isReturnStatement, node => {
+            /**
+             * ```
+             * return <Foo></Foo>
+             * -------^
+             * ```
+             */
+            find(node, isJsxOpeningElement, foundElement);
+            /**
+             * ```
+             * return <Foo />
+             * -------^
+             * ```
+             */
+            find(node, isJsxSelfClosingElement, foundElement);
+            /**
+             * ```
+             * return <></>
+             * -------^
+             * ```
+             */
+            find(node, isJsxFragment, foundFragment);
+        });
+        find(root, isArrowFunction, fn => {
+            /**
+             * ```
+             * (...) => <Foo></Foo>
+             * ---------^
+             * ```
+             */
+            find(fn, isJsxOpeningElement, foundElement);
+            /**
+             * ```
+             * (...) => <Foo />
+             * ---------^
+             * ```
+             */
+            find(fn, isJsxSelfClosingElement, foundElement);
+            /**
+             * ```
+             * (...) => <></>
+             * ---------^
+             * ```
+             */
+            find(fn, isJsxFragment, foundFragment);
+        });
+        find(root, isTaggedTemplateExpression, tagged => {
+            const tag = tagged.tag.getText(sourceFile);
+            /**
+             * ```
+             * styled.button`
+             * -------^
+             *  margin: ${margin};
+             *  padding: ${padding};
+             * `
+             * ```
+             */
+            for (const _pattern of taggedStylingComponent) {
+                const pattern = typeof _pattern === 'string' ? toRegexp(_pattern) : _pattern;
+                const tagName = pattern.exec(tag)?.groups?.tagName;
+                if (!tagName) {
+                    continue;
+                }
+                director.add(name, {
+                    element: tagName,
+                    slots: true,
+                    inheritAttrs: true,
+                }, filePath, line, col);
+            }
+        });
+        find(root, isCallExpression, method => {
+            const caller = method.expression.getText(sourceFile);
+            /**
+             * ```
+             * functionCaller(Button)
+             * ---------------^
+             * ```
+             *
+             * Options: `{ numberOfArgument: 2 }`
+             * ```
+             * namespace.functionCaller(true, Button)
+             * -------------------------------^
+             * ```
+             */
+            for (const _pattern of extendingWrapper) {
+                let pattern;
+                let numberOfArgument = 1;
+                if (typeof _pattern === 'string') {
+                    pattern = toRegexp(_pattern);
+                }
+                else if ('identifier' in _pattern) {
+                    pattern =
+                        typeof _pattern.identifier === 'string'
+                            ? toRegexp(_pattern.identifier)
+                            : _pattern.identifier;
+                    numberOfArgument = _pattern.numberOfArgument;
+                }
+                else {
+                    pattern = _pattern;
+                }
+                if (!pattern.test(caller)) {
+                    continue;
+                }
+                const arg = method.arguments[numberOfArgument - 1];
+                const tagName = arg?.getText(sourceFile);
+                if (!tagName) {
+                    continue;
+                }
+                director.add(name, {
+                    element: tagName,
+                    slots: true,
+                    inheritAttrs: true,
+                }, filePath, line, col);
+            }
+        });
+        function foundFragment(
+        // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+        fragment) {
+            /**
+             * ```
+             * <>
+             *   <Foo></Foo>
+             * --^
+             * </>
+             * ```
+             */
+            find(fragment, isJsxOpeningElement, foundElement);
+            /**
+             * ```
+             * <>
+             *   <Foo />
+             * --^
+             * </>
+             * ```
+             */
+            find(fragment, isJsxSelfClosingElement, foundElement);
+        }
+        function foundElement(
+        // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+        el) {
+            const tagName = el.tagName.getText(sourceFile);
+            for (const frag of asFragment) {
+                const pattern = typeof frag === 'string' ? toRegexp(frag) : frag;
+                /**
+                 * ```
+                 * <Provider>
+                 *   <Foo></Foo>
+                 * --^
+                 * </Provider>
+                 *
+                 * <Namespace.Provider>
+                 *   <Foo></Foo>
+                 * --^
+                 * </Namespace.Provider>
+                 * ```
+                 */
+                if (pattern.test(tagName)) {
+                    for (const child of el.getChildren(sourceFile)) {
+                        find(child, isJsxOpeningElement, foundElement);
+                        find(child, isJsxSelfClosingElement, foundElement);
+                    }
+                    return;
+                }
+            }
+            const attrs = getAttributes(el, sourceFile);
+            const children = getChildren(el, sourceFile);
+            const identity = createIndentity(tagName, attrs, children);
+            director.add(name, identity, filePath, line, col);
+        }
+    }
+    return Promise.resolve(director.getPretenders());
+});
+function toRegexp(pattern) {
+    const matched = pattern.match(/^\/(.+)\/([gi]*)$/i);
+    if (matched?.[1]) {
+        return new RegExp(matched[1], matched[2]);
+    }
+    return new RegExp(pattern);
+}

package/lib/jsx/types.d.ts

@@ -0,0 +1,10 @@
+import type { PretenderScanOptions } from '@markuplint/ml-config';
+export interface PretenderScanJSXOptions extends PretenderScanOptions {
+    asFragment?: readonly (Readonly<RegExp> | string)[];
+    taggedStylingComponent?: readonly (Readonly<RegExp> | string)[];
+    extendingWrapper?: readonly (string | Readonly<RegExp> | ExtendingWrapperCallerOptions)[];
+}
+export type ExtendingWrapperCallerOptions = {
+    readonly identifier: string | Readonly<RegExp>;
+    readonly numberOfArgument: number;
+};

package/lib/jsx/types.js

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

package/lib/out.d.ts

@@ -0,0 +1,2 @@
+import type { Pretender } from '@markuplint/ml-config';
+export declare function out(filePath: string, data: readonly Pretender[]): Promise<void>;

package/lib/out.js

@@ -0,0 +1,9 @@
+import { writeFile } from 'node:fs/promises';
+import { createRequire } from 'node:module';
+const require = createRequire(import.meta.url);
+export async function out(filePath, data) {
+    await writeFile(filePath, JSON.stringify({
+        version: require('../package.json').version,
+        data,
+    }, null, 2), { encoding: 'utf8' });
+}

package/lib/pretender-director.d.ts

@@ -0,0 +1,6 @@
+import type { Identifier, Identity } from './types.js';
+export declare class PretenderDirector {
+    #private;
+    add(identifier: Identifier, identity: Identity, filePath: string, line: number, col: number): void;
+    getPretenders(): import("packages/@markuplint/ml-config/lib/types.js").Pretender[];
+}

package/lib/pretender-director.js

@@ -0,0 +1,22 @@
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _PretenderDirector_map;
+import { dependencyMapper } from './dependency-mapper.js';
+export class PretenderDirector {
+    constructor() {
+        _PretenderDirector_map.set(this, new Map());
+    }
+    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}`]);
+    }
+    getPretenders() {
+        return dependencyMapper(__classPrivateFieldGet(this, _PretenderDirector_map, "f"));
+    }
+}
+_PretenderDirector_map = new WeakMap();

package/lib/types.d.ts

@@ -0,0 +1,15 @@
+import type { PretenderScanOptions, Pretender } from '@markuplint/ml-config';
+export type PretenderScannerScanMethod<O extends PretenderScanOptions = PretenderScanOptions> = 
+/**
+ * @param files Absolute file paths. If it includes a relative path, throw an error.
+ * @param options
+ */
+(files: readonly string[], options?: Readonly<O>) => Promise<Pretender[]>;
+export type Identifier = Pretender['selector'];
+export type Identity = Pretender['as'];
+export type Attr = {
+    readonly nodeType: 'static' | 'boolean' | 'dynamic' | 'spread';
+    readonly name: string;
+    readonly value: string;
+    readonly type?: string;
+};

package/lib/types.js

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

package/package.json

@@ -0,0 +1,37 @@
+{
+	"name": "@markuplint/pretenders",
+	"version": "0.0.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>",
+	"license": "MIT",
+	"private": false,
+	"type": "module",
+	"exports": {
+		".": {
+			"import": "./lib/index.js",
+			"types": "./lib/index.d.ts"
+		}
+	},
+	"bin": {
+		"pretenders": "./bin/pretenders.mjs"
+	},
+	"publishConfig": {
+		"access": "public"
+	},
+	"typedoc": {
+		"entryPoint": "./src/index.ts"
+	},
+	"scripts": {
+		"build": "tsc",
+		"clean": "tsc --build --clean"
+	},
+	"dependencies": {
+		"@markuplint/ml-config": "4.5.1",
+		"@markuplint/parser-utils": "4.5.1",
+		"glob": "10.3.12",
+		"meow": "13.2.0",
+		"typescript": "5.4.5"
+	},
+	"gitHead": "b029c86a6b3a9ea8189d2e5535e3023aaea753fd"
+}