@lynx-js/react-alias-rsbuild-plugin/dist/index.js

A rsbuild plugin for making alias in ReactLynx

import { createRequire } from "node:module";
import external_node_path_default from "node:path";
const S_PLUGIN_REACT_ALIAS = Symbol.for('@lynx-js/plugin-react-alias');
function pluginReactAlias(options) {
    const { LAYERS, lazy, rootPath } = options ?? {};
    return {
        name: 'lynx:react-alias',
        setup (api) {
            const hasAlias = api.useExposed(S_PLUGIN_REACT_ALIAS);
            if (hasAlias) return;
            api.expose(S_PLUGIN_REACT_ALIAS, true);
            const require = createRequire(import.meta.url);
            const reactLynxDir = external_node_path_default.dirname(require.resolve('@lynx-js/react/package.json', {
                paths: [
                    rootPath ?? api.context.rootPath
                ]
            }));
            const resolve = createLazyResolver(reactLynxDir, lazy ? [
                'lazy',
                'import'
            ] : [
                'import'
            ]);
            api.modifyRsbuildConfig((config, { mergeRsbuildConfig })=>mergeRsbuildConfig(config, {
                    source: {
                        include: [
                            reactLynxDir
                        ]
                    }
                }));
            api.modifyBundlerChain(async (chain)=>{
                const [jsxRuntimeBackground, jsxRuntimeMainThread, jsxDevRuntimeBackground, jsxDevRuntimeMainThread, reactLepusBackground, reactLepusMainThread] = await Promise.all([
                    resolve('@lynx-js/react/jsx-runtime'),
                    resolve('@lynx-js/react/lepus/jsx-runtime'),
                    resolve('@lynx-js/react/jsx-dev-runtime'),
                    resolve('@lynx-js/react/lepus/jsx-dev-runtime'),
                    resolve('@lynx-js/react'),
                    resolve('@lynx-js/react/lepus')
                ]);
                const jsxRuntime = {
                    background: jsxRuntimeBackground,
                    mainThread: jsxRuntimeMainThread
                };
                const jsxDevRuntime = {
                    background: jsxDevRuntimeBackground,
                    mainThread: jsxDevRuntimeMainThread
                };
                const reactLepus = {
                    background: reactLepusBackground,
                    mainThread: reactLepusMainThread
                };
                chain.module.rule('react:jsx-runtime:main-thread').issuerLayer(LAYERS.MAIN_THREAD).resolve.alias.set('react/jsx-runtime', jsxRuntime.mainThread).set('react/jsx-dev-runtime', jsxDevRuntime.mainThread).set('@lynx-js/react/jsx-runtime', jsxRuntime.mainThread).set('@lynx-js/react/jsx-dev-runtime', jsxDevRuntime.mainThread).set('@lynx-js/react/lepus$', reactLepus.mainThread).set('@lynx-js/react/lepus/jsx-runtime', jsxRuntime.mainThread).set('@lynx-js/react/lepus/jsx-dev-runtime', jsxDevRuntime.mainThread).end().end().end().rule('react:jsx-runtime:background').issuerLayer(LAYERS.BACKGROUND).resolve.alias.set('react/jsx-runtime', jsxRuntime.background).set('react/jsx-dev-runtime', jsxDevRuntime.background).set('@lynx-js/react/jsx-runtime', jsxRuntime.background).set('@lynx-js/react/jsx-dev-runtime', jsxDevRuntime.background).set('@lynx-js/react/lepus$', reactLepus.background).end().end().end().end();
                const transformedEntries = [
                    'experimental/lazy/import',
                    'internal',
                    'legacy-react-runtime',
                    'runtime-components',
                    'worklet-runtime/bindings'
                ];
                await Promise.all(transformedEntries.map((entry)=>`@lynx-js/react/${entry}`).map((entry)=>resolve(entry).then((value)=>{
                        chain.resolve.alias.set(`${entry}$`, value);
                    })));
                chain.resolve.alias.set('react$', reactLepus.background).set('@lynx-js/react$', reactLepus.background);
                const preactEntries = [
                    'preact',
                    'preact/compat',
                    'preact/debug',
                    'preact/devtools',
                    'preact/hooks',
                    'preact/test-utils',
                    'preact/jsx-runtime',
                    'preact/jsx-dev-runtime',
                    'preact/compat',
                    'preact/compat/client',
                    'preact/compat/server',
                    'preact/compat/jsx-runtime',
                    'preact/compat/jsx-dev-runtime',
                    'preact/compat/scheduler'
                ];
                await Promise.all(preactEntries.map((entry)=>resolve(entry).then((value)=>{
                        chain.resolve.alias.set(`${entry}$`, value);
                    })));
            });
        }
    };
}
function createLazyResolver(directory, conditionNames) {
    let lazyExports;
    let resolverLazy;
    return async (request)=>{
        if (!lazyExports) lazyExports = {};
        if (void 0 === lazyExports[request]) {
            if (!resolverLazy) {
                const { ResolverFactory } = await import("unrs-resolver");
                const resolver = new ResolverFactory({
                    conditionNames
                });
                resolverLazy = (dir, req)=>resolver.sync(dir, req);
            }
            const resolveResult = resolverLazy(directory, request);
            if (resolveResult.error) throw new Error(resolveResult.error);
            if (!resolveResult.path) throw new Error(`Failed to resolve ${request}`);
            lazyExports[request] = resolveResult.path;
        }
        return lazyExports[request];
    };
}
export { createLazyResolver, pluginReactAlias };