react-reinspect 0.1.7 → 0.1.9

package/dist/lib/wrapInspectableMap.d.ts

@@ -1,6 +1,6 @@
 import type { ComponentType } from 'react';
 import { type WithReinspectOptions } from './withReinspect';
-type ComponentMap = Record<string, ComponentType<any>>;
+type ComponentMap = Record<string, ComponentType<unknown>>;
 type WrapInspectableMapOptions<T extends ComponentMap> = Partial<Record<keyof T, WithReinspectOptions>> | ((key: keyof T, component: T[keyof T]) => WithReinspectOptions | undefined);
 export declare function wrapInspectableMap<T extends ComponentMap>(componentMap: T, options?: WrapInspectableMapOptions<T>): {
     [K in keyof T]: T[K];

package/dist/lib/wrapInspectableMap.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"wrapInspectableMap.d.ts","sourceRoot":"","sources":["../../src/reinspect/wrapInspectableMap.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,OAAO,CAAA;AAC1C,OAAO,EAAiB,KAAK,oBAAoB,EAAE,MAAM,iBAAiB,CAAA;AAI1E,KAAK,YAAY,GAAG,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC,GAAG,CAAC,CAAC,CAAA;AAEtD,KAAK,yBAAyB,CAAC,CAAC,SAAS,YAAY,IACjD,OAAO,CAAC,MAAM,CAAC,MAAM,CAAC,EAAE,oBAAoB,CAAC,CAAC,GAC9C,CAAC,CAAC,GAAG,EAAE,MAAM,CAAC,EAAE,SAAS,EAAE,CAAC,CAAC,MAAM,CAAC,CAAC,KAAK,oBAAoB,GAAG,SAAS,CAAC,CAAA;AAE/E,wBAAgB,kBAAkB,CAAC,CAAC,SAAS,YAAY,EACvD,YAAY,EAAE,CAAC,EACf,OAAO,CAAC,EAAE,yBAAyB,CAAC,CAAC,CAAC,GACrC;KAAG,CAAC,IAAI,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;CAAE,CAY1B"}
+{"version":3,"file":"wrapInspectableMap.d.ts","sourceRoot":"","sources":["../../src/reinspect/wrapInspectableMap.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,OAAO,CAAA;AAC1C,OAAO,EAAiB,KAAK,oBAAoB,EAAE,MAAM,iBAAiB,CAAA;AAE1E,KAAK,YAAY,GAAG,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC,OAAO,CAAC,CAAC,CAAA;AAE1D,KAAK,yBAAyB,CAAC,CAAC,SAAS,YAAY,IACjD,OAAO,CAAC,MAAM,CAAC,MAAM,CAAC,EAAE,oBAAoB,CAAC,CAAC,GAC9C,CAAC,CAAC,GAAG,EAAE,MAAM,CAAC,EAAE,SAAS,EAAE,CAAC,CAAC,MAAM,CAAC,CAAC,KAAK,oBAAoB,GAAG,SAAS,CAAC,CAAA;AAE/E,wBAAgB,kBAAkB,CAAC,CAAC,SAAS,YAAY,EACvD,YAAY,EAAE,CAAC,EACf,OAAO,CAAC,EAAE,yBAAyB,CAAC,CAAC,CAAC,GACrC;KAAG,CAAC,IAAI,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;CAAE,CAgB1B"}

package/dist/lib/wrapMarker.d.ts

@@ -1,11 +1,14 @@
 import type { ComponentType } from 'react';
 import type { AutoDiscoverScope } from './types';
+type ComponentProps = Record<string, unknown>;
 export type ReinspectWrapSource = 'manual' | 'auto';
-export interface ReinspectWrappedMetadata {
+export interface ReinspectWrappedMetadata<P extends object = ComponentProps> {
     source: ReinspectWrapSource;
     scope: AutoDiscoverScope;
-    original: ComponentType<any>;
+    original: ComponentType<P>;
 }
 export declare const REINSPECT_WRAPPED_SYMBOL: unique symbol;
-export declare function getReinspectWrappedMetadata(component: ComponentType<any>): ReinspectWrappedMetadata | undefined;
+export declare function getReinspectWrappedMetadata<P extends object>(component: ComponentType<P>): ReinspectWrappedMetadata<P> | undefined;
+export declare function setReinspectWrappedMetadata<P extends object>(component: ComponentType<P>, metadata: ReinspectWrappedMetadata<P>): void;
+export {};
 //# sourceMappingURL=wrapMarker.d.ts.map

package/dist/lib/wrapMarker.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"wrapMarker.d.ts","sourceRoot":"","sources":["../../src/reinspect/wrapMarker.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,OAAO,CAAA;AAC1C,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,SAAS,CAAA;AAEhD,MAAM,MAAM,mBAAmB,GAAG,QAAQ,GAAG,MAAM,CAAA;AAEnD,MAAM,WAAW,wBAAwB;IACvC,MAAM,EAAE,mBAAmB,CAAA;IAC3B,KAAK,EAAE,iBAAiB,CAAA;IAExB,QAAQ,EAAE,aAAa,CAAC,GAAG,CAAC,CAAA;CAC7B;AAED,eAAO,MAAM,wBAAwB,eAAkC,CAAA;AAEvE,wBAAgB,2BAA2B,CAEzC,SAAS,EAAE,aAAa,CAAC,GAAG,CAAC,GAC5B,wBAAwB,GAAG,SAAS,CAQtC"}
+{"version":3,"file":"wrapMarker.d.ts","sourceRoot":"","sources":["../../src/reinspect/wrapMarker.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,OAAO,CAAA;AAC1C,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,SAAS,CAAA;AAEhD,KAAK,cAAc,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;AAE7C,MAAM,MAAM,mBAAmB,GAAG,QAAQ,GAAG,MAAM,CAAA;AAEnD,MAAM,WAAW,wBAAwB,CAAC,CAAC,SAAS,MAAM,GAAG,cAAc;IACzE,MAAM,EAAE,mBAAmB,CAAA;IAC3B,KAAK,EAAE,iBAAiB,CAAA;IACxB,QAAQ,EAAE,aAAa,CAAC,CAAC,CAAC,CAAA;CAC3B;AAED,eAAO,MAAM,wBAAwB,eAAkC,CAAA;AAMvE,wBAAgB,2BAA2B,CAAC,CAAC,SAAS,MAAM,EAC1D,SAAS,EAAE,aAAa,CAAC,CAAC,CAAC,GAC1B,wBAAwB,CAAC,CAAC,CAAC,GAAG,SAAS,CAEzC;AAED,wBAAgB,2BAA2B,CAAC,CAAC,SAAS,MAAM,EAC1D,SAAS,EAAE,aAAa,CAAC,CAAC,CAAC,EAC3B,QAAQ,EAAE,wBAAwB,CAAC,CAAC,CAAC,GACpC,IAAI,CAEN"}

package/dist/plugin/internal/autoDiscoverTransform.d.ts

@@ -0,0 +1,26 @@
+export type AutoDiscoverScope = 'first-party' | 'third-party';
+export type AutoDiscoverIncludeMode = 'first-party' | 'all';
+export interface AutoDiscoverResolutionOptions {
+    include: AutoDiscoverIncludeMode;
+    thirdPartyAllowlist?: readonly string[];
+}
+export interface AutoDiscoverTransformResult {
+    code: string;
+    modified: boolean;
+    map: {
+        version: number;
+        sources: string[];
+        names: string[];
+        mappings: string;
+        file?: string | undefined;
+        sourceRoot?: string | undefined;
+        sourcesContent?: string[] | undefined;
+    } | null;
+}
+export declare function isSupportedSourceFile(id: string): boolean;
+export declare function isFirstPartyModule(id: string): boolean;
+export declare function shouldSkipThirdPartyModule(id: string): boolean;
+export declare function normalizeModuleId(id: string): string;
+export declare function resolveAutoDiscoverScope(normalizedId: string, options: AutoDiscoverResolutionOptions): AutoDiscoverScope | null;
+export declare function transformModuleForAutoDiscover(code: string, fileId: string, scope: AutoDiscoverScope): AutoDiscoverTransformResult;
+//# sourceMappingURL=autoDiscoverTransform.d.ts.map

package/dist/plugin/internal/autoDiscoverTransform.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"autoDiscoverTransform.d.ts","sourceRoot":"","sources":["../../../src/plugin/internal/autoDiscoverTransform.ts"],"names":[],"mappings":"AAKA,MAAM,MAAM,iBAAiB,GAAG,aAAa,GAAG,aAAa,CAAA;AAC7D,MAAM,MAAM,uBAAuB,GAAG,aAAa,GAAG,KAAK,CAAA;AAE3D,MAAM,WAAW,6BAA6B;IAC5C,OAAO,EAAE,uBAAuB,CAAA;IAChC,mBAAmB,CAAC,EAAE,SAAS,MAAM,EAAE,CAAA;CACxC;AAiBD,MAAM,WAAW,2BAA2B;IAC1C,IAAI,EAAE,MAAM,CAAA;IACZ,QAAQ,EAAE,OAAO,CAAA;IACjB,GAAG,EAAE;QACH,OAAO,EAAE,MAAM,CAAA;QACf,OAAO,EAAE,MAAM,EAAE,CAAA;QACjB,KAAK,EAAE,MAAM,EAAE,CAAA;QACf,QAAQ,EAAE,MAAM,CAAA;QAChB,IAAI,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;QACzB,UAAU,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;QAC/B,cAAc,CAAC,EAAE,MAAM,EAAE,GAAG,SAAS,CAAA;KACtC,GAAG,IAAI,CAAA;CACT;AAuQD,wBAAgB,qBAAqB,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAMzD;AAED,wBAAgB,kBAAkB,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAEtD;AAED,wBAAgB,0BAA0B,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAE9D;AAaD,wBAAgB,iBAAiB,CAAC,EAAE,EAAE,MAAM,GAAG,MAAM,CAGpD;AAED,wBAAgB,wBAAwB,CACtC,YAAY,EAAE,MAAM,EACpB,OAAO,EAAE,6BAA6B,GACrC,iBAAiB,GAAG,IAAI,CAyB1B;AAED,wBAAgB,8BAA8B,CAC5C,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,iBAAiB,GACvB,2BAA2B,CA+P7B"}

package/dist/plugin/internal/autoDiscoverTransform.js

@@ -0,0 +1,397 @@
+import path from 'node:path';
+import { parse } from '@babel/parser';
+import { generate } from '@babel/generator';
+import * as t from '@babel/types';
+const AUTO_WRAP_IMPORT_SOURCE = 'react-reinspect/internal/auto-wrap';
+const AUTO_WRAP_IMPORT_NAME = 'autoWrapInspectable';
+const DEFAULT_EXPORT_LOCAL_IDENTIFIER = '__reinspect_default_component';
+const SUPPORTED_FILE_PATTERN = /\.[cm]?[jt]sx?$/;
+const MAX_NODE_VISITS = 12_000;
+const THIRD_PARTY_SKIP_PATTERNS = [
+    '/node_modules/react/',
+    '/node_modules/react-dom/',
+    '/node_modules/scheduler/',
+    '/node_modules/@vite/',
+    '/node_modules/vite/',
+    '/node_modules/@react-refresh/',
+];
+function isPascalCaseIdentifier(name) {
+    return /^[A-Z][A-Za-z0-9]*$/.test(name);
+}
+function inferFallbackName(filePath) {
+    const baseName = path.basename(filePath).replace(/\.[^.]+$/, '');
+    const tokens = baseName
+        .replace(/[^A-Za-z0-9]+/g, ' ')
+        .trim()
+        .split(/\s+/)
+        .filter(Boolean);
+    if (tokens.length === 0) {
+        return 'Component';
+    }
+    return tokens
+        .map((token) => token.slice(0, 1).toUpperCase() + token.slice(1))
+        .join('');
+}
+function unwrapExpression(node) {
+    let currentNode = node;
+    while (t.isParenthesizedExpression(currentNode) ||
+        t.isTSAsExpression(currentNode) ||
+        t.isTSTypeAssertion(currentNode) ||
+        t.isTSNonNullExpression(currentNode) ||
+        t.isTSInstantiationExpression(currentNode) ||
+        t.isTypeCastExpression(currentNode)) {
+        currentNode = currentNode.expression;
+    }
+    return currentNode;
+}
+function isReactCreateElementCall(node) {
+    const callee = unwrapExpression(node.callee);
+    if (t.isIdentifier(callee)) {
+        return callee.name === 'createElement';
+    }
+    if (t.isMemberExpression(callee) &&
+        t.isIdentifier(callee.object) &&
+        callee.object.name === 'React' &&
+        t.isIdentifier(callee.property)) {
+        return callee.property.name === 'createElement';
+    }
+    return false;
+}
+function isAstNode(value) {
+    return (typeof value === 'object' &&
+        value !== null &&
+        'type' in value &&
+        typeof value.type === 'string');
+}
+function containsRenderableReactNode(node) {
+    if (!node) {
+        return false;
+    }
+    const stack = [node];
+    let visitedCount = 0;
+    while (stack.length > 0) {
+        const nextNode = stack.pop();
+        if (!nextNode) {
+            continue;
+        }
+        visitedCount += 1;
+        if (visitedCount > MAX_NODE_VISITS) {
+            return false;
+        }
+        if (t.isJSXElement(nextNode) || t.isJSXFragment(nextNode)) {
+            return true;
+        }
+        if (t.isCallExpression(nextNode) && isReactCreateElementCall(nextNode)) {
+            return true;
+        }
+        const visitorKeys = t.VISITOR_KEYS[nextNode.type] ?? [];
+        for (const visitorKey of visitorKeys) {
+            const value = nextNode[visitorKey];
+            if (Array.isArray(value)) {
+                for (const item of value) {
+                    if (isAstNode(item)) {
+                        stack.push(item);
+                    }
+                }
+                continue;
+            }
+            if (isAstNode(value)) {
+                stack.push(value);
+            }
+        }
+    }
+    return false;
+}
+function isComponentFunction(node) {
+    if (t.isBlockStatement(node.body)) {
+        return containsRenderableReactNode(node.body);
+    }
+    return containsRenderableReactNode(node.body);
+}
+function isMemoForwardRefCallee(callee) {
+    const expression = unwrapExpression(callee);
+    if (t.isIdentifier(expression)) {
+        return expression.name === 'memo' || expression.name === 'forwardRef';
+    }
+    if (t.isMemberExpression(expression) &&
+        t.isIdentifier(expression.object) &&
+        expression.object.name === 'React' &&
+        t.isIdentifier(expression.property)) {
+        return (expression.property.name === 'memo' ||
+            expression.property.name === 'forwardRef');
+    }
+    return false;
+}
+function isMemoForwardRefCall(node) {
+    const callee = unwrapExpression(node.callee);
+    if (!isMemoForwardRefCallee(callee)) {
+        return false;
+    }
+    if (node.arguments.length === 0) {
+        return false;
+    }
+    const firstArgument = node.arguments[0];
+    if (!t.isExpression(firstArgument)) {
+        return false;
+    }
+    const componentCandidate = unwrapExpression(firstArgument);
+    if (t.isArrowFunctionExpression(componentCandidate) ||
+        t.isFunctionExpression(componentCandidate)) {
+        return isComponentFunction(componentCandidate);
+    }
+    if (t.isIdentifier(componentCandidate)) {
+        return isPascalCaseIdentifier(componentCandidate.name);
+    }
+    return true;
+}
+function isWrappedInitializer(node) {
+    const expression = unwrapExpression(node);
+    if (!t.isCallExpression(expression)) {
+        return false;
+    }
+    const callee = unwrapExpression(expression.callee);
+    return (t.isIdentifier(callee) &&
+        (callee.name === AUTO_WRAP_IMPORT_NAME || callee.name === 'withReinspect'));
+}
+function isComponentInitializer(node) {
+    const expression = unwrapExpression(node);
+    if (t.isArrowFunctionExpression(expression) || t.isFunctionExpression(expression)) {
+        return isComponentFunction(expression);
+    }
+    if (t.isCallExpression(expression)) {
+        return isMemoForwardRefCall(expression);
+    }
+    return false;
+}
+function createAutoWrapCall(expression, componentName, scope, fallbackName) {
+    const metadataProperties = [
+        t.objectProperty(t.identifier('scope'), t.stringLiteral(scope)),
+        t.objectProperty(t.identifier('fallbackName'), t.stringLiteral(fallbackName)),
+    ];
+    if (componentName) {
+        metadataProperties.unshift(t.objectProperty(t.identifier('componentName'), t.stringLiteral(componentName)));
+    }
+    return t.callExpression(t.identifier(AUTO_WRAP_IMPORT_NAME), [
+        expression,
+        t.objectExpression(metadataProperties),
+    ]);
+}
+function createFunctionWrapAssignment(name, scope, fallbackName) {
+    return t.expressionStatement(t.assignmentExpression('=', t.identifier(name), createAutoWrapCall(t.identifier(name), name, scope, fallbackName)));
+}
+function functionDeclarationToExpression(node) {
+    const expression = t.functionExpression(node.id, node.params, node.body, node.generator, node.async);
+    if (node.typeParameters) {
+        expression.typeParameters = node.typeParameters;
+    }
+    if (node.returnType) {
+        expression.returnType = node.returnType;
+    }
+    return expression;
+}
+export function isSupportedSourceFile(id) {
+    if (id.startsWith('\0') || id.startsWith('/@')) {
+        return false;
+    }
+    return SUPPORTED_FILE_PATTERN.test(id);
+}
+export function isFirstPartyModule(id) {
+    return id.includes('/src/') && !id.includes('/node_modules/');
+}
+export function shouldSkipThirdPartyModule(id) {
+    return THIRD_PARTY_SKIP_PATTERNS.some((pattern) => id.includes(pattern));
+}
+function isInThirdPartyAllowlist(moduleId, allowlist) {
+    if (!allowlist || allowlist.length === 0) {
+        return false;
+    }
+    return allowlist.some((pattern) => moduleId.includes(pattern));
+}
+export function normalizeModuleId(id) {
+    const withoutQuery = id.split('?')[0] ?? '';
+    return withoutQuery.split(path.sep).join('/');
+}
+export function resolveAutoDiscoverScope(normalizedId, options) {
+    if (normalizedId.includes('/node_modules/react-reinspect/')) {
+        return null;
+    }
+    if (normalizedId.includes('/src/reinspect/')) {
+        return null;
+    }
+    if (isFirstPartyModule(normalizedId)) {
+        return 'first-party';
+    }
+    if (options.include !== 'all') {
+        return null;
+    }
+    if (shouldSkipThirdPartyModule(normalizedId) &&
+        !isInThirdPartyAllowlist(normalizedId, options.thirdPartyAllowlist)) {
+        return null;
+    }
+    return 'third-party';
+}
+export function transformModuleForAutoDiscover(code, fileId, scope) {
+    let ast;
+    try {
+        ast = parse(code, {
+            sourceType: 'module',
+            plugins: ['typescript', 'jsx'],
+        });
+    }
+    catch {
+        return { code, modified: false, map: null };
+    }
+    const program = ast.program;
+    const fallbackName = inferFallbackName(fileId);
+    let modified = false;
+    let autoWrapImportDeclaration;
+    let hasAutoWrapImport = false;
+    for (const statement of program.body) {
+        if (!t.isImportDeclaration(statement)) {
+            continue;
+        }
+        if (statement.source.value !== AUTO_WRAP_IMPORT_SOURCE) {
+            continue;
+        }
+        autoWrapImportDeclaration = statement;
+        hasAutoWrapImport = statement.specifiers.some((specifier) => t.isImportSpecifier(specifier) &&
+            t.isIdentifier(specifier.imported) &&
+            specifier.imported.name === AUTO_WRAP_IMPORT_NAME);
+    }
+    for (let index = 0; index < program.body.length; index += 1) {
+        const statement = program.body[index];
+        if (t.isFunctionDeclaration(statement) && statement.id) {
+            if (isPascalCaseIdentifier(statement.id.name) &&
+                isComponentFunction(statement)) {
+                program.body.splice(index + 1, 0, createFunctionWrapAssignment(statement.id.name, scope, fallbackName));
+                index += 1;
+                modified = true;
+            }
+            continue;
+        }
+        if (t.isExportNamedDeclaration(statement) &&
+            statement.declaration &&
+            t.isFunctionDeclaration(statement.declaration) &&
+            statement.declaration.id &&
+            isPascalCaseIdentifier(statement.declaration.id.name) &&
+            isComponentFunction(statement.declaration)) {
+            program.body.splice(index + 1, 0, createFunctionWrapAssignment(statement.declaration.id.name, scope, fallbackName));
+            index += 1;
+            modified = true;
+            continue;
+        }
+        const processVariableDeclaration = (declaration) => {
+            let declarationChanged = false;
+            for (const declarator of declaration.declarations) {
+                if (!t.isIdentifier(declarator.id) || !declarator.init) {
+                    continue;
+                }
+                if (!isPascalCaseIdentifier(declarator.id.name)) {
+                    continue;
+                }
+                if (!isComponentInitializer(declarator.init)) {
+                    continue;
+                }
+                if (isWrappedInitializer(declarator.init)) {
+                    continue;
+                }
+                declarator.init = createAutoWrapCall(declarator.init, declarator.id.name, scope, fallbackName);
+                declarationChanged = true;
+            }
+            return declarationChanged;
+        };
+        if (t.isVariableDeclaration(statement)) {
+            if (processVariableDeclaration(statement)) {
+                modified = true;
+            }
+            continue;
+        }
+        if (t.isExportNamedDeclaration(statement) &&
+            statement.declaration &&
+            t.isVariableDeclaration(statement.declaration)) {
+            if (processVariableDeclaration(statement.declaration)) {
+                modified = true;
+            }
+            continue;
+        }
+        if (!t.isExportDefaultDeclaration(statement)) {
+            continue;
+        }
+        const declaration = statement.declaration;
+        if (t.isFunctionDeclaration(declaration)) {
+            if (declaration.id &&
+                isPascalCaseIdentifier(declaration.id.name) &&
+                isComponentFunction(declaration)) {
+                const localName = declaration.id.name;
+                const replacementStatements = [
+                    declaration,
+                    createFunctionWrapAssignment(localName, scope, fallbackName),
+                    t.exportDefaultDeclaration(t.identifier(localName)),
+                ];
+                program.body.splice(index, 1, ...replacementStatements);
+                index += replacementStatements.length - 1;
+                modified = true;
+                continue;
+            }
+            if (!declaration.id && isComponentFunction(declaration)) {
+                const localIdentifier = t.identifier(DEFAULT_EXPORT_LOCAL_IDENTIFIER);
+                const wrappedValue = createAutoWrapCall(functionDeclarationToExpression(declaration), undefined, scope, fallbackName);
+                const replacementStatements = [
+                    t.variableDeclaration('const', [
+                        t.variableDeclarator(localIdentifier, wrappedValue),
+                    ]),
+                    t.exportDefaultDeclaration(localIdentifier),
+                ];
+                program.body.splice(index, 1, ...replacementStatements);
+                index += replacementStatements.length - 1;
+                modified = true;
+            }
+            continue;
+        }
+        if (!t.isExpression(declaration)) {
+            continue;
+        }
+        if (!isComponentInitializer(declaration) || isWrappedInitializer(declaration)) {
+            continue;
+        }
+        const localIdentifier = t.identifier(DEFAULT_EXPORT_LOCAL_IDENTIFIER);
+        const wrappedValue = createAutoWrapCall(declaration, undefined, scope, fallbackName);
+        const replacementStatements = [
+            t.variableDeclaration('const', [
+                t.variableDeclarator(localIdentifier, wrappedValue),
+            ]),
+            t.exportDefaultDeclaration(localIdentifier),
+        ];
+        program.body.splice(index, 1, ...replacementStatements);
+        index += replacementStatements.length - 1;
+        modified = true;
+    }
+    if (!modified) {
+        return { code, modified: false, map: null };
+    }
+    if (autoWrapImportDeclaration) {
+        if (!hasAutoWrapImport) {
+            autoWrapImportDeclaration.specifiers.push(t.importSpecifier(t.identifier(AUTO_WRAP_IMPORT_NAME), t.identifier(AUTO_WRAP_IMPORT_NAME)));
+        }
+    }
+    else {
+        let insertIndex = 0;
+        while (insertIndex < program.body.length &&
+            t.isImportDeclaration(program.body[insertIndex])) {
+            insertIndex += 1;
+        }
+        program.body.splice(insertIndex, 0, t.importDeclaration([
+            t.importSpecifier(t.identifier(AUTO_WRAP_IMPORT_NAME), t.identifier(AUTO_WRAP_IMPORT_NAME)),
+        ], t.stringLiteral(AUTO_WRAP_IMPORT_SOURCE)));
+    }
+    const output = generate(ast, {
+        jsescOption: { minimal: true },
+        sourceMaps: true,
+        sourceFileName: fileId,
+    }, code);
+    return {
+        code: output.code,
+        modified: true,
+        map: output.map ?? null,
+    };
+}

package/dist/plugin/reinspectAutoDiscoverPlugin.d.ts

@@ -1,11 +1,8 @@
 import type { Plugin } from 'vite';
-type AutoDiscoverScope = 'first-party' | 'third-party';
-export interface AutoDiscoverTransformResult {
-    code: string;
-    modified: boolean;
+import { type AutoDiscoverIncludeMode } from './internal/autoDiscoverTransform';
+export interface ReinspectAutoDiscoverPluginOptions {
+    include?: AutoDiscoverIncludeMode;
+    thirdPartyAllowlist?: readonly string[];
 }
-export declare function shouldSkipThirdPartyModule(id: string): boolean;
-export declare function transformModuleForAutoDiscover(code: string, fileId: string, scope: AutoDiscoverScope): AutoDiscoverTransformResult;
-export declare function reinspectAutoDiscoverPlugin(): Plugin;
-export {};
+export declare function reinspectAutoDiscoverPlugin(options?: ReinspectAutoDiscoverPluginOptions): Plugin;
 //# sourceMappingURL=reinspectAutoDiscoverPlugin.d.ts.map

package/dist/plugin/reinspectAutoDiscoverPlugin.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"reinspectAutoDiscoverPlugin.d.ts","sourceRoot":"","sources":["../../src/plugin/reinspectAutoDiscoverPlugin.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,MAAM,CAAA;AAElC,KAAK,iBAAiB,GAAG,aAAa,GAAG,aAAa,CAAA;AAgBtD,MAAM,WAAW,2BAA2B;IAC1C,IAAI,EAAE,MAAM,CAAA;IACZ,QAAQ,EAAE,OAAO,CAAA;CAClB;AAmQD,wBAAgB,0BAA0B,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAE9D;AAED,wBAAgB,8BAA8B,CAC5C,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,iBAAiB,GACvB,2BAA2B,CAwP7B;AAED,wBAAgB,2BAA2B,IAAI,MAAM,CA2CpD"}
+{"version":3,"file":"reinspectAutoDiscoverPlugin.d.ts","sourceRoot":"","sources":["../../src/plugin/reinspectAutoDiscoverPlugin.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,MAAM,CAAA;AAClC,OAAO,EAKL,KAAK,uBAAuB,EAC7B,MAAM,kCAAkC,CAAA;AAEzC,MAAM,WAAW,kCAAkC;IACjD,OAAO,CAAC,EAAE,uBAAuB,CAAA;IACjC,mBAAmB,CAAC,EAAE,SAAS,MAAM,EAAE,CAAA;CACxC;AAWD,wBAAgB,2BAA2B,CACzC,OAAO,CAAC,EAAE,kCAAkC,GAC3C,MAAM,CAqCR"}