@lynx-js/react 0.114.2 → 0.114.4

package/testing-library/dist/vitest.config.js

@@ -51,6 +51,123 @@ const createVitestConfig = async (options)=>{
     let runtimeAlias = [];
     if (runtimePkgName !== runtimeOSSPkgName) runtimeAlias = generateAlias(runtimePkgName, runtimeDir, vitest_config_dirname);
     const preactAlias = generateAlias('preact', preactDir, runtimeOSSDir);
+    preactAlias.forEach((alias)=>{
+        alias.replacement = alias.replacement.replace(/\.js$/, '.mjs');
+    });
+    const reactAlias = [
+        {
+            find: /^react$/,
+            replacement: vitest_config_require.resolve(runtimeOSSPkgName, {
+                paths: [
+                    runtimeDir
+                ]
+            })
+        },
+        {
+            find: /^react\/jsx-runtime$/,
+            replacement: vitest_config_require.resolve(path.posix.join(runtimeOSSPkgName, 'jsx-runtime'), {
+                paths: [
+                    runtimeDir
+                ]
+            })
+        },
+        {
+            find: /^react\/jsx-dev-runtime$/,
+            replacement: vitest_config_require.resolve(path.posix.join(runtimeOSSPkgName, 'jsx-dev-runtime'), {
+                paths: [
+                    runtimeDir
+                ]
+            })
+        }
+    ];
+    function transformReactCompilerPlugin() {
+        let rootContext, compilerDeps, babel;
+        function resolveCompilerDeps(rootContext) {
+            const missingBabelPackages = [];
+            const [babelPath, babelPluginReactCompilerPath, babelPluginSyntaxJsxPath, babelPluginSyntaxTypescriptPath] = [
+                '@babel/core',
+                'babel-plugin-react-compiler',
+                '@babel/plugin-syntax-jsx',
+                "@babel/plugin-syntax-typescript"
+            ].map((name)=>{
+                try {
+                    return vitest_config_require.resolve(name, {
+                        paths: [
+                            rootContext
+                        ]
+                    });
+                } catch  {
+                    missingBabelPackages.push(name);
+                }
+                return '';
+            });
+            if (missingBabelPackages.length > 0) throw new Error(`With \`experimental_enableReactCompiler\` enabled, you need to install \`${missingBabelPackages.join('`, `')}\` in your project root to use React Compiler.`);
+            return {
+                babelPath,
+                babelPluginReactCompilerPath,
+                babelPluginSyntaxJsxPath,
+                babelPluginSyntaxTypescriptPath
+            };
+        }
+        return {
+            name: 'transformReactCompilerPlugin',
+            enforce: 'pre',
+            config (config) {
+                rootContext = config.root;
+                const reactCompilerRuntimeAlias = [];
+                try {
+                    reactCompilerRuntimeAlias.push({
+                        find: /^react-compiler-runtime$/,
+                        replacement: path.join(path.dirname(vitest_config_require.resolve('react-compiler-runtime/package.json', {
+                            paths: [
+                                rootContext
+                            ]
+                        })), 'src', 'index.ts')
+                    });
+                } catch (e) {}
+                config.test.alias.push(...reactCompilerRuntimeAlias);
+                compilerDeps = resolveCompilerDeps(rootContext);
+                const { babelPath } = compilerDeps;
+                babel = vitest_config_require(babelPath);
+            },
+            async transform (sourceText, sourcePath) {
+                if (/\.(?:jsx|tsx)$/.test(sourcePath)) {
+                    const { babelPluginReactCompilerPath, babelPluginSyntaxJsxPath, babelPluginSyntaxTypescriptPath } = compilerDeps;
+                    const isTSX = sourcePath.endsWith('.tsx');
+                    try {
+                        const result = babel.transformSync(sourceText, {
+                            plugins: [
+                                [
+                                    babelPluginReactCompilerPath,
+                                    {
+                                        target: '17'
+                                    }
+                                ],
+                                babelPluginSyntaxJsxPath,
+                                isTSX ? [
+                                    babelPluginSyntaxTypescriptPath,
+                                    {
+                                        isTSX: true
+                                    }
+                                ] : null
+                            ].filter(Boolean),
+                            filename: sourcePath,
+                            ast: false,
+                            sourceMaps: true
+                        });
+                        if (result?.code != null && result?.map != null) return {
+                            code: result.code,
+                            map: result.map
+                        };
+                        this.error(`babel-plugin-react-compiler transform failed for ${sourcePath}: ${result ? 'missing code or map' : 'no result'}`);
+                    } catch (e) {
+                        this.error(e);
+                    }
+                }
+                return null;
+            }
+        };
+    }
     function transformReactLynxPlugin() {
         return {
             name: 'transformReactLynxPlugin',
@@ -74,6 +191,7 @@ const createVitestConfig = async (options)=>{
                         filename: relativePath,
                         target: 'MIXED'
                     },
+                    engineVersion: options?.engineVersion ?? '',
                     directiveDCE: false,
                     defineDCE: false,
                     shake: false,
@@ -108,6 +226,9 @@ const createVitestConfig = async (options)=>{
             }
         },
         plugins: [
+            ...options?.experimental_enableReactCompiler ? [
+                transformReactCompilerPlugin()
+            ] : [],
             transformReactLynxPlugin()
         ],
         test: {
@@ -119,7 +240,11 @@ const createVitestConfig = async (options)=>{
             alias: [
                 ...runtimeOSSAlias,
                 ...runtimeAlias,
-                ...preactAlias
+                ...preactAlias,
+                ...reactAlias
+            ],
+            include: options?.include ?? [
+                'src/**/*.test.{js,jsx,ts,tsx}'
             ]
         }
     });

package/testing-library/types/vitest-config.d.ts

@@ -4,9 +4,17 @@ export interface CreateVitestConfigOptions {
   /**
    * The package name of the ReactLynx runtime package.
    *
-   * @default `@lynx-js/react`
+   * @defaultValue `@lynx-js/react`
    */
   runtimePkgName?: string;
+  /**
+   * Enable React Compiler for this build.
+   *
+   * @link https://react.dev/learn/react-compiler
+   *
+   * @defaultValue false
+   */
+  experimental_enableReactCompiler?: boolean;
 }
 
 export function createVitestConfig(options?: CreateVitestConfigOptions): Promise<ViteUserConfig>;