@lynx-js/react 0.118.0 → 0.120.0

package/testing-library/dist/setupFiles/common/runtime-setup.js

@@ -0,0 +1,85 @@
+import { options } from "preact";
+import { clearCommitTaskId, replaceCommitHook } from "../../../../runtime/lib/snapshot/lifecycle/patch/commit.js";
+import { deinitGlobalSnapshotPatch } from "../../../../runtime/lib/snapshot/lifecycle/patch/snapshotPatch.js";
+import { injectUpdateMainThread } from "../../../../runtime/lib/snapshot/lifecycle/patch/updateMainThread.js";
+import { injectUpdateMTRefInitValue } from "../../../../runtime/lib/snapshot/worklet/ref/updateInitValue.js";
+import { injectCalledByNative } from "../../../../runtime/lib/snapshot/lynx/calledByNative.js";
+import { flushDelayedLifecycleEvents, injectTt } from "../../../../runtime/lib/snapshot/lynx/tt.js";
+import { initElementPAPICallAlog } from "../../../../runtime/lib/snapshot/alog/elementPAPICall.js";
+import { addCtxNotFoundEventListener } from "../../../../runtime/lib/snapshot/lifecycle/patch/error.js";
+import { setRoot } from "../../../../runtime/lib/root.js";
+import { BackgroundSnapshotInstance, SnapshotInstance, backgroundSnapshotInstanceManager, snapshotInstanceManager } from "../../../../runtime/lib/snapshot/index.js";
+import { destroyWorklet } from "../../../../runtime/lib/snapshot/worklet/destroy.js";
+import { initApiEnv } from "../../../../runtime/lib/worklet-runtime/api/lynxApi.js";
+import { initEventListeners } from "../../../../runtime/lib/worklet-runtime/listeners.js";
+import { initWorklet } from "../../../../runtime/lib/worklet-runtime/workletRuntime.js";
+import { setupBackgroundDocument, setupDocument } from "../../../../runtime/lib/document.js";
+const { onInjectMainThreadGlobals, onInjectBackgroundThreadGlobals, onResetLynxTestingEnv, onSwitchedToMainThread, onSwitchedToBackgroundThread, onInitWorkletRuntime } = globalThis;
+injectCalledByNative();
+injectUpdateMainThread();
+injectUpdateMTRefInitValue();
+replaceCommitHook();
+globalThis.onInitWorkletRuntime = ()=>{
+    if (onInitWorkletRuntime) onInitWorkletRuntime();
+    lynx.setTimeout = setTimeout;
+    lynx.setInterval = setInterval;
+    lynx.clearTimeout = clearTimeout;
+    lynx.clearInterval = clearInterval;
+    initWorklet();
+    initApiEnv();
+    initEventListeners();
+    return true;
+};
+globalThis.onInjectMainThreadGlobals = (target)=>{
+    if (onInjectMainThreadGlobals) onInjectMainThreadGlobals(target);
+    snapshotInstanceManager.clear();
+    snapshotInstanceManager.nextId = 0;
+    target.__root = new SnapshotInstance('root');
+    target._document = {};
+    setupDocument(target._document);
+    target.globalPipelineOptions = void 0;
+    if (void 0 !== target.__ALOG_ELEMENT_API__ && target.__ALOG_ELEMENT_API__ && !target.__initElementPAPICallAlogInjected) {
+        initElementPAPICallAlog(target);
+        target.__initElementPAPICallAlogInjected = true;
+    }
+};
+globalThis.onInjectBackgroundThreadGlobals = (target)=>{
+    if (onInjectBackgroundThreadGlobals) onInjectBackgroundThreadGlobals(target);
+    backgroundSnapshotInstanceManager.clear();
+    backgroundSnapshotInstanceManager.nextId = 0;
+    target.__root = new BackgroundSnapshotInstance('root');
+    target._document = {};
+    setupBackgroundDocument(target._document);
+    target.globalPipelineOptions = void 0;
+    const oldLynxCoreInject = globalThis.lynxCoreInject;
+    globalThis.lynxCoreInject = target.lynxCoreInject;
+    try {
+        injectTt();
+    } finally{
+        globalThis.lynxCoreInject = oldLynxCoreInject;
+    }
+    deinitGlobalSnapshotPatch();
+    clearCommitTaskId();
+};
+globalThis.onResetLynxTestingEnv = ()=>{
+    if (onResetLynxTestingEnv) onResetLynxTestingEnv();
+    flushDelayedLifecycleEvents();
+    destroyWorklet();
+    lynxTestingEnv.switchToMainThread();
+    initEventListeners();
+    lynxTestingEnv.switchToBackgroundThread();
+    injectTt();
+    addCtxNotFoundEventListener();
+};
+globalThis.onSwitchedToMainThread = ()=>{
+    if (onSwitchedToMainThread) onSwitchedToMainThread();
+    setRoot(globalThis.__root);
+    options.document = globalThis._document;
+};
+globalThis.onSwitchedToBackgroundThread = ()=>{
+    if (onSwitchedToBackgroundThread) onSwitchedToBackgroundThread();
+    setRoot(globalThis.__root);
+    options.document = globalThis._document;
+};
+globalThis.onInjectMainThreadGlobals(globalThis.lynxTestingEnv.mainThread.globalThis);
+globalThis.onInjectBackgroundThreadGlobals(globalThis.lynxTestingEnv.backgroundThread.globalThis);

package/testing-library/dist/setupFiles/inner/rstest.js

@@ -0,0 +1,7 @@
+const { onInjectBackgroundThreadGlobals } = globalThis;
+globalThis.onInjectBackgroundThreadGlobals = (target)=>{
+    if (onInjectBackgroundThreadGlobals) onInjectBackgroundThreadGlobals(target);
+    target.lynx.requireModuleAsync = async (url, _callback)=>{
+        throw new Error('lynx.requireModuleAsync not implemented for rstest');
+    };
+};

package/testing-library/dist/setupFiles/inner/vitest.js

@@ -0,0 +1,11 @@
+const { onInjectBackgroundThreadGlobals } = globalThis;
+globalThis.onInjectBackgroundThreadGlobals = (target)=>{
+    if (onInjectBackgroundThreadGlobals) onInjectBackgroundThreadGlobals(target);
+    target.lynx.requireModuleAsync = async (url, callback)=>{
+        try {
+            callback(null, await __vite_ssr_dynamic_import__(url));
+        } catch (err) {
+            callback(err, null);
+        }
+    };
+};

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

@@ -0,0 +1,21 @@
+import "../env/rstest.js";
+import "./common/runtime-setup.js";
+import "./inner/rstest.js";
+import "./common/bootstrap.js";
+import { expect } from "@rstest/core";
+expect.addSnapshotSerializer({
+    test (val) {
+        return Boolean(val && 'object' == typeof val && Array.isArray(val.refAttr) && Object.prototype.hasOwnProperty.call(val, 'task') && 'function' == typeof val.exec);
+    },
+    print (val, serialize) {
+        const printed = serialize({
+            refAttr: Array.isArray(val.refAttr) ? [
+                ...val.refAttr
+            ] : val.refAttr,
+            task: val.task
+        });
+        if (printed.startsWith('Object')) return printed.replace(/^Object/, 'RefProxy');
+        if (printed.startsWith('{')) return `RefProxy ${printed}`;
+        return printed;
+    }
+});

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

@@ -0,0 +1,20 @@
+import "./common/runtime-setup.js";
+import "./inner/vitest.js";
+import "./common/bootstrap.js";
+import { expect } from "vitest";
+expect.addSnapshotSerializer({
+    test (val) {
+        return Boolean(val && 'object' == typeof val && Array.isArray(val.refAttr) && Object.prototype.hasOwnProperty.call(val, 'task') && 'function' == typeof val.exec);
+    },
+    print (val, serialize) {
+        const printed = serialize({
+            refAttr: Array.isArray(val.refAttr) ? [
+                ...val.refAttr
+            ] : val.refAttr,
+            task: val.task
+        });
+        if (printed.startsWith('Object')) return printed.replace(/^Object/, 'RefProxy');
+        if (printed.startsWith('{')) return `RefProxy ${printed}`;
+        return printed;
+    }
+});

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

@@ -0,0 +1,6 @@
+import { type ViteUserConfig } from 'vitest/config';
+import type { TestingLibraryOptions } from './plugins/index.js';
+/**
+ * @deprecated Use `vitestTestingLibraryPlugin` from `@lynx-js/react/testing-library/plugins` instead.
+ */
+export declare function createVitestConfig(options?: TestingLibraryOptions): ViteUserConfig;

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

@@ -1,263 +1,10 @@
 import { defineConfig } from "vitest/config";
-import { VitestPackageInstaller } from "vitest/node";
-import path from "path";
-import { fileURLToPath } from "url";
-import { createRequire } from "module";
-const vitest_config_filename = fileURLToPath(import.meta.url);
-const vitest_config_dirname = path.dirname(vitest_config_filename);
-const vitest_config_require = createRequire(import.meta.url);
-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);
-    }
-}
-const createVitestConfig = async (options)=>{
-    await ensurePackagesInstalled();
-    const runtimeOSSPkgName = '@lynx-js/react';
-    const runtimePkgName = options?.runtimePkgName ?? runtimeOSSPkgName;
-    const runtimeDir = path.dirname(vitest_config_require.resolve(`${runtimePkgName}/package.json`));
-    const runtimeOSSDir = path.dirname(vitest_config_require.resolve(`${runtimeOSSPkgName}/package.json`, {
-        paths: [
-            runtimeDir,
-            vitest_config_dirname
-        ]
-    }));
-    const preactDir = path.dirname(vitest_config_require.resolve('preact/package.json', {
-        paths: [
-            runtimeOSSDir
-        ]
-    }));
-    const generateAlias = (pkgName, pkgDir, resolveDir)=>{
-        const pkgExports = vitest_config_require(path.join(pkgDir, 'package.json')).exports;
-        const pkgAlias = [];
-        Object.keys(pkgExports).forEach((key)=>{
-            const name = path.posix.join(pkgName, key);
-            pkgAlias.push({
-                find: new RegExp('^' + name + '$'),
-                replacement: vitest_config_require.resolve(name, {
-                    paths: [
-                        resolveDir,
-                        vitest_config_dirname
-                    ]
-                })
-            });
-        });
-        return pkgAlias;
-    };
-    const runtimeOSSAlias = generateAlias(runtimeOSSPkgName, runtimeOSSDir, runtimeDir);
-    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,
-                    vitest_config_dirname
-                ]
-            })
-        },
-        {
-            find: /^react\/jsx-runtime$/,
-            replacement: vitest_config_require.resolve(path.posix.join(runtimeOSSPkgName, 'jsx-runtime'), {
-                paths: [
-                    runtimeDir,
-                    vitest_config_dirname
-                ]
-            })
-        },
-        {
-            find: /^react\/jsx-dev-runtime$/,
-            replacement: vitest_config_require.resolve(path.posix.join(runtimeOSSPkgName, 'jsx-dev-runtime'), {
-                paths: [
-                    runtimeDir,
-                    vitest_config_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_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',
-            enforce: 'pre',
-            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_config_require('@lynx-js/react/transform');
-                const relativePath = normalizeSlashes(path.relative(vitest_config_dirname, sourcePath));
-                const basename = 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, error.location);
-                });
-                if (result.warnings.length > 0) result.warnings.forEach((warning)=>{
-                    this.warn(warning.text, warning.location);
-                });
-                return {
-                    code: result.code,
-                    map: result.map
-                };
-            }
-        };
-    }
+import { vitestTestingLibraryPlugin } from "./plugins/index.js";
+function createVitestConfig(options) {
     return defineConfig({
-        server: {
-            fs: {
-                allow: [
-                    path.join(vitest_config_dirname, '..')
-                ]
-            }
-        },
         plugins: [
-            ...options?.experimental_enableReactCompiler ? [
-                transformReactCompilerPlugin()
-            ] : [],
-            transformReactLynxPlugin()
-        ],
-        test: {
-            environment: vitest_config_require.resolve('./env/vitest'),
-            globals: true,
-            setupFiles: [
-                path.join(vitest_config_dirname, 'vitest-global-setup')
-            ],
-            alias: [
-                ...runtimeOSSAlias,
-                ...runtimeAlias,
-                ...preactAlias,
-                ...reactAlias
-            ],
-            include: options?.include ?? [
-                'src/**/*.test.{js,jsx,ts,tsx}'
-            ]
-        }
+            vitestTestingLibraryPlugin(options)
+        ]
     });
-};
-function normalizeSlashes(file) {
-    return file.replaceAll(path.win32.sep, '/');
 }
 export { createVitestConfig };