@lynx-js/react 0.118.0 → 0.119.0

package/testing-library/dist/fire-event.d.ts

@@ -0,0 +1,111 @@
+export declare const fireEvent: any;
+export declare const eventMap: {
+    tap: {
+        defaultInit: {};
+    };
+    longtap: {
+        defaultInit: {};
+    };
+    bgload: {
+        defaultInit: {};
+    };
+    bgerror: {
+        defaultInit: {};
+    };
+    touchstart: {
+        defaultInit: {};
+    };
+    touchmove: {
+        defaultInit: {};
+    };
+    touchcancel: {
+        defaultInit: {};
+    };
+    touchend: {
+        defaultInit: {};
+    };
+    longpress: {
+        defaultInit: {};
+    };
+    transitionstart: {
+        defaultInit: {};
+    };
+    transitioncancel: {
+        defaultInit: {};
+    };
+    transitionend: {
+        defaultInit: {};
+    };
+    animationstart: {
+        defaultInit: {};
+    };
+    animationiteration: {
+        defaultInit: {};
+    };
+    animationcancel: {
+        defaultInit: {};
+    };
+    animationend: {
+        defaultInit: {};
+    };
+    mousedown: {
+        defaultInit: {};
+    };
+    mouseup: {
+        defaultInit: {};
+    };
+    mousemove: {
+        defaultInit: {};
+    };
+    mouseclick: {
+        defaultInit: {};
+    };
+    mousedblclick: {
+        defaultInit: {};
+    };
+    mouselongpress: {
+        defaultInit: {};
+    };
+    wheel: {
+        defaultInit: {};
+    };
+    keydown: {
+        defaultInit: {};
+    };
+    keyup: {
+        defaultInit: {};
+    };
+    focus: {
+        defaultInit: {};
+    };
+    blur: {
+        defaultInit: {};
+    };
+    layoutchange: {
+        defaultInit: {};
+    };
+    scrolltoupper: {
+        defaultInit: {};
+    };
+    scrolltolower: {
+        defaultInit: {};
+    };
+    scroll: {
+        defaultInit: {};
+    };
+    scrollend: {
+        defaultInit: {};
+    };
+    contentsizechanged: {
+        defaultInit: {};
+    };
+    scrolltoupperedge: {
+        defaultInit: {};
+    };
+    scrolltoloweredge: {
+        defaultInit: {};
+    };
+    scrolltonormalstate: {
+        defaultInit: {};
+    };
+};

package/testing-library/dist/index.d.ts

@@ -1,6 +1,5 @@
 import { act } from 'preact/test-utils';
 import { ARIARole } from 'aria-query';
-import { JSDOM } from 'jsdom';
 import { OptionsReceived } from 'pretty-format';
 import * as prettyFormat from 'pretty-format';
 
@@ -775,6 +774,7 @@ declare const initElementTree: () => {
     __AddDataset(e: LynxElement, key: string, value: string): void;
     __SetDataset(e: LynxElement, dataset: any): void;
     __SetGestureDetector(e: LynxElement, id: number, type: number, config: any, relationMap: Record<string, number[]>): void;
+    __RemoveGestureDetector(e: LynxElement, id: number): void;
     __GetDataset(e: LynxElement): DOMStringMap;
     __RemoveElement(parent: LynxElement, child: LynxElement): void;
     __InsertElementBefore(parent: LynxElement, child: LynxElement, ref?: LynxElement | undefined): void;
@@ -883,6 +883,15 @@ declare interface LynxElement extends HTMLElement {
     parentNode: LynxElement;
 }
 
+/**
+ * The host environment used to initialize `LynxTestingEnv`.
+ *
+ * @public
+ */
+declare interface LynxEnv {
+    window: Window & typeof globalThis;
+}
+
 /**
  * The `globalThis` object of Lynx dual thread environment.
  *
@@ -904,8 +913,9 @@ declare interface LynxGlobalThis {
  *
  * ```ts
  * import { LynxTestingEnv } from '@lynx-js/testing-environment';
+ * import { JSDOM } from 'jsdom';
  *
- * const lynxTestingEnv = new LynxTestingEnv(new JSDOM());
+ * const lynxTestingEnv = new LynxTestingEnv({ window: new JSDOM().window });
  *
  * lynxTestingEnv.switchToMainThread();
  * // use the main thread Element PAPI
@@ -926,8 +936,9 @@ export declare class LynxTestingEnv {
      *
      * ```ts
      * import { LynxTestingEnv } from '@lynx-js/testing-environment';
+     * import { JSDOM } from 'jsdom';
      *
-     * const lynxTestingEnv = new LynxTestingEnv(new JSDOM());
+     * const lynxTestingEnv = new LynxTestingEnv({ window: new JSDOM().window });
      *
      * lynxTestingEnv.switchToBackgroundThread();
      * // use the background thread global object
@@ -942,8 +953,9 @@ export declare class LynxTestingEnv {
      *
      * ```ts
      * import { LynxTestingEnv } from '@lynx-js/testing-environment';
+     * import { JSDOM } from 'jsdom';
      *
-     * const lynxTestingEnv = new LynxTestingEnv(new JSDOM());
+     * const lynxTestingEnv = new LynxTestingEnv({ window: new JSDOM().window });
      *
      * lynxTestingEnv.switchToMainThread();
      * // use the main thread global object
@@ -953,8 +965,8 @@ export declare class LynxTestingEnv {
      * ```
      */
     mainThread: LynxGlobalThis & ElementTreeGlobals;
-    jsdom: JSDOM;
-    constructor(jsdom?: JSDOM);
+    env: LynxEnv;
+    constructor(env?: LynxEnv);
     injectGlobals(): void;
     switchToBackgroundThread(): void;
     switchToMainThread(): void;

package/testing-library/dist/plugins/index.d.ts

@@ -0,0 +1,2 @@
+export { testingLibraryPlugin as vitestTestingLibraryPlugin } from './vitest.js';
+export type { TestingLibraryOptions } from './vitest.js';

package/testing-library/dist/plugins/index.js

@@ -0,0 +1,282 @@
+import { VitestPackageInstaller } from "vitest/node";
+import node_path from "node:path";
+import { fileURLToPath } from "node:url";
+import { createRequire } from "../881.js";
+const vitest_filename = fileURLToPath(import.meta.url);
+const vitest_dirname = node_path.dirname(vitest_filename);
+const vitest_require = createRequire(import.meta.url);
+function testingLibraryPlugin(options) {
+    const runtimeOSSPkgName = '@lynx-js/react';
+    const runtimePkgName = options?.runtimePkgName ?? runtimeOSSPkgName;
+    const runtimeDir = node_path.dirname(vitest_require.resolve(`${runtimePkgName}/package.json`));
+    const runtimeOSSDir = node_path.dirname(vitest_require.resolve(`${runtimeOSSPkgName}/package.json`, {
+        paths: [
+            runtimeDir,
+            vitest_dirname
+        ]
+    }));
+    const preactDir = node_path.dirname(vitest_require.resolve('preact/package.json', {
+        paths: [
+            runtimeOSSDir
+        ]
+    }));
+    const runtimeOSSAlias = generateAlias(runtimeOSSPkgName, runtimeOSSDir, runtimeDir);
+    let runtimeAlias = [];
+    if (runtimePkgName !== runtimeOSSPkgName) runtimeAlias = generateAlias(runtimePkgName, runtimeDir, vitest_dirname);
+    const preactAlias = generateAlias('preact', preactDir, runtimeOSSDir);
+    preactAlias.forEach((alias)=>{
+        alias.replacement = alias.replacement.replace(/\.js$/, '.mjs');
+    });
+    const reactAlias = [
+        {
+            find: /^react$/,
+            replacement: vitest_require.resolve(runtimeOSSPkgName, {
+                paths: [
+                    runtimeDir,
+                    vitest_dirname
+                ]
+            })
+        },
+        {
+            find: /^react\/jsx-runtime$/,
+            replacement: vitest_require.resolve(node_path.posix.join(runtimeOSSPkgName, 'jsx-runtime'), {
+                paths: [
+                    runtimeDir,
+                    vitest_dirname
+                ]
+            })
+        },
+        {
+            find: /^react\/jsx-dev-runtime$/,
+            replacement: vitest_require.resolve(node_path.posix.join(runtimeOSSPkgName, 'jsx-dev-runtime'), {
+                paths: [
+                    runtimeDir,
+                    vitest_dirname
+                ]
+            })
+        }
+    ];
+    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_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: node_path.join(node_path.dirname(vitest_require.resolve('react-compiler-runtime/package.json', {
+                            paths: [
+                                rootContext
+                            ]
+                        })), 'src', 'index.ts')
+                    });
+                } catch (e) {}
+                let mergedAlias = [
+                    ...reactCompilerRuntimeAlias
+                ];
+                if (config.test?.alias) mergedAlias = Array.isArray(config.test.alias) ? [
+                    ...config.test.alias,
+                    ...mergedAlias
+                ] : [
+                    ...Object.entries(config.test.alias).map(([key, value])=>({
+                            find: key,
+                            replacement: value
+                        })),
+                    ...mergedAlias
+                ];
+                config.test = config.test || {};
+                config.test.alias = mergedAlias;
+                compilerDeps = resolveCompilerDeps(rootContext);
+                const { babelPath } = compilerDeps;
+                babel = vitest_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;
+            }
+        };
+    }
+    let config;
+    function transformReactLynxPlugin() {
+        return {
+            name: 'transformReactLynxPlugin',
+            enforce: 'pre',
+            async buildStart () {
+                await ensurePackagesInstalled();
+            },
+            transform (sourceText, sourcePath) {
+                const id = sourcePath;
+                const regex = /\.(?:js|jsx|mjs|cjs|ts|tsx|mts|cts)(\?.*)?$/;
+                if (!regex.test(id)) return null;
+                const { transformReactLynxSync } = vitest_require('@lynx-js/react/transform');
+                const relativePath = normalizeSlashes(node_path.relative(config.root, sourcePath));
+                const basename = node_path.basename(sourcePath);
+                const result = transformReactLynxSync(sourceText, {
+                    mode: 'test',
+                    pluginName: '',
+                    filename: basename,
+                    sourcemap: true,
+                    snapshot: {
+                        preserveJsx: false,
+                        runtimePkg: `${runtimePkgName}/internal`,
+                        jsxImportSource: runtimePkgName,
+                        filename: relativePath,
+                        target: 'MIXED'
+                    },
+                    engineVersion: options?.engineVersion ?? '',
+                    dynamicImport: {
+                        injectLazyBundle: false,
+                        layer: 'test',
+                        runtimePkg: `${runtimePkgName}/internal`
+                    },
+                    directiveDCE: false,
+                    defineDCE: false,
+                    shake: false,
+                    compat: false,
+                    worklet: {
+                        filename: relativePath,
+                        runtimePkg: `${runtimePkgName}/internal`,
+                        target: 'MIXED'
+                    },
+                    refresh: false,
+                    cssScope: false
+                });
+                if (result.errors.length > 0) result.errors.forEach((error)=>{
+                    this.error(error.text ?? 'Unknown error', {
+                        line: 1,
+                        column: 1,
+                        ...error.location
+                    });
+                });
+                if (result.warnings.length > 0) result.warnings.forEach((warning)=>{
+                    this.warn(warning.text ?? 'Unknown warning', {
+                        line: 1,
+                        column: 1,
+                        ...warning.location
+                    });
+                });
+                return {
+                    code: result.code,
+                    map: result.map
+                };
+            },
+            config: ()=>({
+                    test: {
+                        environment: vitest_require.resolve(`${runtimeOSSDir}/testing-library/dist/env/vitest`),
+                        globals: true,
+                        setupFiles: [
+                            vitest_require.resolve('../setupFiles/vitest')
+                        ],
+                        alias: [
+                            ...runtimeOSSAlias,
+                            ...runtimeAlias,
+                            ...preactAlias,
+                            ...reactAlias
+                        ]
+                    }
+                }),
+            configResolved (_config) {
+                config = _config;
+            }
+        };
+    }
+    return [
+        ...options?.experimental_enableReactCompiler ? [
+            transformReactCompilerPlugin()
+        ] : [],
+        transformReactLynxPlugin()
+    ];
+}
+async function ensurePackagesInstalled() {
+    const installer = new VitestPackageInstaller();
+    const installed = await installer.ensureInstalled('jsdom', process.cwd());
+    if (!installed) {
+        console.log('ReactLynx Testing Library requires jsdom to be installed.');
+        process.exit(1);
+    }
+}
+function generateAlias(pkgName, pkgDir, resolveDir) {
+    const pkgExports = vitest_require(node_path.join(pkgDir, 'package.json')).exports;
+    if (!pkgExports || 'object' != typeof pkgExports) return [];
+    const pkgAlias = [];
+    Object.keys(pkgExports).forEach((key)=>{
+        const name = node_path.posix.join(pkgName, key);
+        const escapedName = name.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+        pkgAlias.push({
+            find: new RegExp('^' + escapedName + '$'),
+            replacement: vitest_require.resolve(name, {
+                paths: [
+                    resolveDir,
+                    vitest_dirname
+                ]
+            })
+        });
+    });
+    return pkgAlias;
+}
+function normalizeSlashes(file) {
+    return file.replaceAll(node_path.win32.sep, '/');
+}
+export { testingLibraryPlugin as vitestTestingLibraryPlugin };

package/testing-library/dist/plugins/vitest.d.ts

@@ -0,0 +1,26 @@
+import type { Vite } from 'vitest/node';
+export interface TestingLibraryOptions {
+    /**
+     * The package name of the ReactLynx runtime package.
+     *
+     * @default `@lynx-js/react`
+     */
+    runtimePkgName?: string;
+    /**
+     * The engine version to use for the transform.
+     *
+     * @default `''`
+     */
+    engineVersion?: string;
+    /**
+     * Enable experimental React Compiler support.
+     *
+     * Requires `@babel/core`, `babel-plugin-react-compiler`,
+     * `@babel/plugin-syntax-jsx`, and `@babel/plugin-syntax-typescript`
+     * to be installed in your project.
+     *
+     * @default `false`
+     */
+    experimental_enableReactCompiler?: boolean;
+}
+export declare function testingLibraryPlugin(options?: TestingLibraryOptions): Vite.PluginOption;

package/testing-library/dist/pure.js

@@ -14477,7 +14477,7 @@ function pure_render(ui, { queries, wrapper: WrapperComponent, enableMainThread
             });
         },
         asFragment: ()=>{
-            const { document: document1 } = lynxTestingEnv.jsdom.window;
+            const { document: document1 } = lynxTestingEnv.env.window;
             const container = lynxTestingEnv.mainThread.elementTree.root;
             if ('function' == typeof document1.createRange) return document1.createRange().createContextualFragment(container.innerHTML);
             {
@@ -14497,7 +14497,7 @@ function cleanup() {
     });
     lynxTestingEnv.mainThread.elementTree.root = void 0;
     clearPage();
-    lynxTestingEnv.jsdom.window.document.body.innerHTML = '';
+    lynxTestingEnv.env.window.document.body.innerHTML = '';
     if (isMainThread) globalThis.lynxTestingEnv.switchToMainThread();
 }
 function renderHook(renderCallback, options) {

package/testing-library/dist/rstest-config.d.ts

@@ -0,0 +1,25 @@
+import type { ExtendConfig, ExtendConfigFn } from '@rstest/core';
+export interface LynxConfigOptions {
+    /**
+     * The root path of the project.
+     *
+     * @default `process.cwd()`
+     */
+    rootPath?: string;
+    /**
+     * The path to the Lynx config file.
+     *
+     * @default `lynx.config.ts`
+     */
+    configPath?: string;
+}
+export interface RstestConfigOptions {
+    /**
+     * Customize the generated rstest config.
+     */
+    modifyRstestConfig?: (config: ExtendConfig) => ExtendConfig | Promise<ExtendConfig>;
+}
+export interface LynxRstestConfigOptions extends LynxConfigOptions, RstestConfigOptions {
+}
+export declare function withDefaultConfig(options?: RstestConfigOptions): ExtendConfigFn;
+export declare function withLynxConfig(options?: LynxRstestConfigOptions): ExtendConfigFn;

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

@@ -0,0 +1,61 @@
+import { createRequire } from "./881.js";
+const rstest_config_require = createRequire(import.meta.url);
+function createDefaultRstestConfig() {
+    return {
+        testEnvironment: 'jsdom',
+        setupFiles: [
+            rstest_config_require.resolve('./setupFiles/rstest')
+        ],
+        globals: true
+    };
+}
+function normalizeSetupFiles(setupFiles) {
+    if (!setupFiles) return [];
+    return Array.isArray(setupFiles) ? setupFiles : [
+        setupFiles
+    ];
+}
+async function applyRstestConfigModifier(config, modifyRstestConfig) {
+    if (!modifyRstestConfig) return config;
+    return await modifyRstestConfig(config);
+}
+function withDefaultConfig(options) {
+    return async ()=>await applyRstestConfigModifier(createDefaultRstestConfig(), options?.modifyRstestConfig);
+}
+function withLynxConfig(options) {
+    return async ()=>{
+        const { loadConfig } = await import("@lynx-js/rspeedy");
+        const lynxConfig = await loadConfig({
+            cwd: options?.rootPath,
+            configPath: options?.configPath
+        });
+        const { toRstestConfig } = await import("./0~123.js").then((mod)=>({
+                toRstestConfig: mod.toRstestConfig
+            }));
+        const rstestConfig = toRstestConfig({
+            rsbuildConfig: lynxConfig.content
+        });
+        const defaultConfig = createDefaultRstestConfig();
+        const setupFiles = Array.from(new Set([
+            ...normalizeSetupFiles(rstestConfig.setupFiles),
+            ...normalizeSetupFiles(defaultConfig.setupFiles)
+        ]));
+        const mergedConfig = {
+            ...rstestConfig,
+            ...defaultConfig,
+            plugins: [
+                ...rstestConfig.plugins || [],
+                {
+                    name: 'lynx-adapter:remove-useless-plugins',
+                    remove: [
+                        'lynx:rsbuild:qrcode'
+                    ],
+                    setup: ()=>{}
+                }
+            ],
+            setupFiles
+        };
+        return await applyRstestConfigModifier(mergedConfig, options?.modifyRstestConfig);
+    };
+}
+export { withDefaultConfig, withLynxConfig };

package/testing-library/dist/setupFiles/common/bootstrap.js

@@ -0,0 +1,2 @@
+globalThis.onInjectMainThreadGlobals(globalThis.lynxTestingEnv.mainThread.globalThis);
+globalThis.onInjectBackgroundThreadGlobals(globalThis.lynxTestingEnv.backgroundThread.globalThis);