@lynx-js/rspeedy
Version:
A webpack/rspack-based frontend toolchain for Lynx
498 lines (497 loc) • 19.4 kB
JavaScript
import node_path, { extname, isAbsolute, join } from "node:path";
import { createRsbuild, logger, mergeRsbuildConfig, rspack, version } from "@rsbuild/core";
import node_fs from "node:fs";
import { pathToFileURL } from "node:url";
import { register } from "#register";
var __webpack_modules__ = {};
var __webpack_module_cache__ = {};
function __webpack_require__(moduleId) {
var cachedModule = __webpack_module_cache__[moduleId];
if (void 0 !== cachedModule) return cachedModule.exports;
var module = __webpack_module_cache__[moduleId] = {
exports: {}
};
__webpack_modules__[moduleId].call(module.exports, module, module.exports, __webpack_require__);
return module.exports;
}
__webpack_require__.m = __webpack_modules__;
(()=>{
__webpack_require__.n = (module)=>{
var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
__webpack_require__.d(getter, {
a: getter
});
return getter;
};
})();
(()=>{
var getProto = Object.getPrototypeOf ? (obj)=>Object.getPrototypeOf(obj) : (obj)=>obj.__proto__;
var leafPrototypes;
__webpack_require__.t = function(value, mode) {
if (1 & mode) value = this(value);
if (8 & mode) return value;
if ('object' == typeof value && value) {
if (4 & mode && value.__esModule) return value;
if (16 & mode && 'function' == typeof value.then) return value;
}
var ns = Object.create(null);
__webpack_require__.r(ns);
var def = {};
leafPrototypes = leafPrototypes || [
null,
getProto({}),
getProto([]),
getProto(getProto)
];
for(var current = 2 & mode && value; ('object' == typeof current || 'function' == typeof current) && !~leafPrototypes.indexOf(current); current = getProto(current))Object.getOwnPropertyNames(current).forEach((key)=>{
def[key] = ()=>value[key];
});
def['default'] = ()=>value;
__webpack_require__.d(ns, def);
return ns;
};
})();
(()=>{
__webpack_require__.d = (exports, getters, values)=>{
var define = (defs, kind)=>{
for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports, key)) Object.defineProperty(exports, key, {
enumerable: true,
[kind]: defs[key]
});
};
define(getters, "get");
define(values, "value");
};
})();
(()=>{
__webpack_require__.add = function(modules) {
Object.assign(__webpack_require__.m, modules);
};
})();
var __webpack_require__temp = __webpack_require__;
(()=>{
__webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
})();
(()=>{
__webpack_require__.r = (exports)=>{
if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports, Symbol.toStringTag, {
value: 'Module'
});
Object.defineProperty(exports, '__esModule', {
value: true
});
};
})();
(()=>{
var installedChunks = {
index: 0,
src_index_ts: 0
};
var installChunk = (data)=>{
var __rspack_esm_ids = data.__rspack_esm_ids;
var __webpack_modules__ = data.__webpack_modules__;
var __rspack_esm_runtime = data.__rspack_esm_runtime;
var moduleId, chunkId, i = 0;
for(moduleId in __webpack_modules__)if (__webpack_require__.o(__webpack_modules__, moduleId)) __webpack_require__.m[moduleId] = __webpack_modules__[moduleId];
if (__rspack_esm_runtime) __rspack_esm_runtime(__webpack_require__);
for(; i < __rspack_esm_ids.length; i++){
chunkId = __rspack_esm_ids[i];
if (__webpack_require__.o(installedChunks, chunkId) && installedChunks[chunkId]) installedChunks[chunkId][0]();
installedChunks[__rspack_esm_ids[i]] = 0;
}
};
__webpack_require__.C = installChunk;
})();
__webpack_require__.add({
"../../../node_modules/.pnpm/picocolors@1.1.1/node_modules/picocolors/picocolors.js" (module) {
let p = process || {}, argv = p.argv || [], env = p.env || {};
let isColorSupported = !(!!env.NO_COLOR || argv.includes("--no-color")) && (!!env.FORCE_COLOR || argv.includes("--color") || "win32" === p.platform || (p.stdout || {}).isTTY && "dumb" !== env.TERM || !!env.CI);
let formatter = (open, close, replace = open)=>(input)=>{
let string = "" + input, index = string.indexOf(close, open.length);
return ~index ? open + replaceClose(string, close, replace, index) + close : open + string + close;
};
let replaceClose = (string, close, replace, index)=>{
let result = "", cursor = 0;
do {
result += string.substring(cursor, index) + replace;
cursor = index + close.length;
index = string.indexOf(close, cursor);
}while (~index);
return result + string.substring(cursor);
};
let createColors = (enabled = isColorSupported)=>{
let f = enabled ? formatter : ()=>String;
return {
isColorSupported: enabled,
reset: f("\x1b[0m", "\x1b[0m"),
bold: f("\x1b[1m", "\x1b[22m", "\x1b[22m\x1b[1m"),
dim: f("\x1b[2m", "\x1b[22m", "\x1b[22m\x1b[2m"),
italic: f("\x1b[3m", "\x1b[23m"),
underline: f("\x1b[4m", "\x1b[24m"),
inverse: f("\x1b[7m", "\x1b[27m"),
hidden: f("\x1b[8m", "\x1b[28m"),
strikethrough: f("\x1b[9m", "\x1b[29m"),
black: f("\x1b[30m", "\x1b[39m"),
red: f("\x1b[31m", "\x1b[39m"),
green: f("\x1b[32m", "\x1b[39m"),
yellow: f("\x1b[33m", "\x1b[39m"),
blue: f("\x1b[34m", "\x1b[39m"),
magenta: f("\x1b[35m", "\x1b[39m"),
cyan: f("\x1b[36m", "\x1b[39m"),
white: f("\x1b[37m", "\x1b[39m"),
gray: f("\x1b[90m", "\x1b[39m"),
bgBlack: f("\x1b[40m", "\x1b[49m"),
bgRed: f("\x1b[41m", "\x1b[49m"),
bgGreen: f("\x1b[42m", "\x1b[49m"),
bgYellow: f("\x1b[43m", "\x1b[49m"),
bgBlue: f("\x1b[44m", "\x1b[49m"),
bgMagenta: f("\x1b[45m", "\x1b[49m"),
bgCyan: f("\x1b[46m", "\x1b[49m"),
bgWhite: f("\x1b[47m", "\x1b[49m"),
blackBright: f("\x1b[90m", "\x1b[39m"),
redBright: f("\x1b[91m", "\x1b[39m"),
greenBright: f("\x1b[92m", "\x1b[39m"),
yellowBright: f("\x1b[93m", "\x1b[39m"),
blueBright: f("\x1b[94m", "\x1b[39m"),
magentaBright: f("\x1b[95m", "\x1b[39m"),
cyanBright: f("\x1b[96m", "\x1b[39m"),
whiteBright: f("\x1b[97m", "\x1b[39m"),
bgBlackBright: f("\x1b[100m", "\x1b[49m"),
bgRedBright: f("\x1b[101m", "\x1b[49m"),
bgGreenBright: f("\x1b[102m", "\x1b[49m"),
bgYellowBright: f("\x1b[103m", "\x1b[49m"),
bgBlueBright: f("\x1b[104m", "\x1b[49m"),
bgMagentaBright: f("\x1b[105m", "\x1b[49m"),
bgCyanBright: f("\x1b[106m", "\x1b[49m"),
bgWhiteBright: f("\x1b[107m", "\x1b[49m")
};
};
module.exports = createColors();
module.exports.createColors = createColors;
}
});
const picocolors = __webpack_require__("../../../node_modules/.pnpm/picocolors@1.1.1/node_modules/picocolors/picocolors.js");
var picocolors_default = /*#__PURE__*/ __webpack_require__.n(picocolors);
const isDebug = ()=>{
if (!process.env['DEBUG']) return false;
const values = process.env['DEBUG'].toLocaleLowerCase().split(',');
return [
'rsbuild',
'rspeedy',
'*'
].some((key)=>values.includes(key));
};
const label = picocolors_default().bgCyan('lynx');
const debug = (message)=>{
if (isDebug()) {
const result = 'string' == typeof message ? message : message();
logger.level = 'verbose';
logger.debug(`${label} ${result}`);
}
};
const debugList = (prefix, messages)=>debug(()=>`${prefix} ${[
''
].concat(messages).join('\n - ')}`);
function applyDefaultRspeedyConfig(config) {
const enableChunkSplitting = getEnableChunkSplitting(config);
return mergeRsbuildConfig({
mode: (()=>{
if (config.mode) return config.mode;
const nodeEnv = process.env['NODE_ENV'];
return 'production' === nodeEnv || 'development' === nodeEnv ? nodeEnv : 'none';
})(),
output: {
filename: getFilename(config.output?.filename),
sourceMap: {
css: true
},
inlineScripts: !enableChunkSplitting,
cssModules: {
localIdentName: '[local]-[hash:base64:6]'
}
},
performance: {
profile: isDebug() ? true : void 0
},
tools: {
rsdoctor: {
experiments: {
enableNativePlugin: true
}
}
}
}, config);
}
function getEnableChunkSplitting(config) {
if (void 0 !== config.splitChunks) return false !== config.splitChunks;
const strategy = config.performance?.chunkSplit?.strategy;
return Boolean(strategy && 'all-in-one' !== strategy);
}
const DEFAULT_FILENAME = '[name].[platform].bundle';
function getFilename(filename) {
if ('string' == typeof filename) return {
bundle: filename,
template: filename
};
const finalFilename = filename?.bundle ?? filename?.template ?? DEFAULT_FILENAME;
if ('function' == typeof finalFilename) return {
bundle: finalFilename
};
return {
bundle: finalFilename,
template: finalFilename
};
}
const DEFAULT_ENTRY = './src/index.js';
function toRsbuildEntry(entry) {
if (void 0 === entry) {
debug(`Using default entry ${DEFAULT_ENTRY}`);
return {
main: DEFAULT_ENTRY
};
}
if (Array.isArray(entry) || 'string' == typeof entry) {
debug(()=>`Using single entry ${[
''
].concat(entry).join('\n - ')}`);
return {
main: entry
};
}
return Object.fromEntries(Object.entries(entry).map(([key, value])=>{
if (Array.isArray(value) || 'string' == typeof value) {
debugList(`Using multiple entries - ${key}`, value);
return [
key,
{
import: value
}
];
}
debugList(`Using multiple entries - ${key}`, value.import ?? DEFAULT_ENTRY);
if (void 0 === value.import) return [
key,
{
...value,
import: DEFAULT_ENTRY
}
];
return [
key,
value
];
}));
}
const defaultDataUriLimit = 2048;
function toRsbuildConfig(config) {
return {
dev: {
hmr: config.dev?.hmr ?? true,
lazyCompilation: false,
liveReload: config.dev?.liveReload ?? true,
watchFiles: config.dev?.watchFiles,
writeToDisk: config.dev?.writeToDisk ?? true,
progressBar: config.dev?.progressBar ?? true
},
environments: config.environments ?? {
lynx: {}
},
mode: config.mode,
output: {
assetPrefix: config.output?.assetPrefix,
charset: 'utf8',
cleanDistPath: config.output?.cleanDistPath,
copy: config.output?.copy,
cssModules: config.output?.cssModules,
dataUriLimit: config.output?.dataUriLimit ?? defaultDataUriLimit,
distPath: config.output?.distPath,
filenameHash: config.output?.filenameHash,
inlineScripts: config.output?.inlineScripts,
legalComments: config.output?.legalComments ?? 'none',
polyfill: 'off',
sourceMap: config.output?.sourceMap
},
resolve: {
alias: toRsbuildAlias(config),
aliasStrategy: config.resolve?.aliasStrategy,
dedupe: config.resolve?.dedupe,
extensions: config.resolve?.extensions
},
source: {
assetsInclude: config.source?.assetsInclude,
decorators: config.source?.decorators,
define: config.source?.define,
entry: toRsbuildEntry(config.source?.entry),
exclude: config.source?.exclude,
include: config.source?.include,
preEntry: config.source?.preEntry,
transformImport: config.source?.transformImport,
tsconfigPath: config.source?.tsconfigPath
},
splitChunks: toRsbuildSplitChunks(config),
server: {
base: config.server?.base,
compress: config.server?.compress,
cors: config.server?.cors,
headers: config.server?.headers,
host: config.server?.host ?? '0.0.0.0',
port: config.server?.port,
proxy: config.server?.proxy,
strictPort: config.server?.strictPort
},
plugins: config.plugins,
performance: {
buildCache: config.performance?.buildCache,
chunkSplit: config.performance?.chunkSplit,
removeConsole: toRsbuildRemoveConsole(config),
printFileSize: config.performance?.printFileSize ?? true
},
tools: {
bundlerChain: config.tools?.bundlerChain,
cssExtract: config.tools?.cssExtract,
cssLoader: config.tools?.cssLoader,
htmlPlugin: false,
rspack: config.tools?.rspack,
swc: config.tools?.swc
}
};
}
function toRsbuildRemoveConsole(config) {
if (config.performance?.removeConsole === true) return [
'log',
'warn',
'error',
'info',
'debug',
'profile',
'profileEnd'
];
return config.performance?.removeConsole;
}
function toRsbuildSplitChunks(config) {
if (void 0 !== config.splitChunks) return config.splitChunks;
const legacyStrategy = config.performance?.chunkSplit?.strategy;
if (legacyStrategy && 'all-in-one' !== legacyStrategy) return;
return false;
}
function toRsbuildAlias(config) {
const sourceAlias = config.source?.alias;
const resolveAlias = config.resolve?.alias;
if (void 0 === sourceAlias && void 0 === resolveAlias) return;
return {
...resolveAlias,
...sourceAlias
};
}
async function createRspeedy({ cwd = process.cwd(), rspeedyConfig = {}, loadEnv = true, environment = [], callerName = 'rspeedy' }) {
const config = applyDefaultRspeedyConfig(rspeedyConfig);
const [rspeedy, { applyDefaultPlugins }] = await Promise.all([
createRsbuild({
cwd,
loadEnv,
rsbuildConfig: toRsbuildConfig(config),
environment,
callerName
}),
import("./0~plugins.js")
]);
await applyDefaultPlugins(rspeedy, config);
const inspectConfig = rspeedy.inspectConfig.bind(rspeedy);
return Object.assign(rspeedy, {
getRspeedyConfig: ()=>config,
async inspectConfig (options) {
const result = await inspectConfig(options);
const { inspectRspeedyConfig } = await import("./0~inspect.plugin.js");
await inspectRspeedyConfig(rspeedyConfig, node_path.resolve(options.outputPath ?? rspeedy.context.distPath, '.rsbuild/rspeedy.config.js'), options.verbose ?? false);
return result;
}
});
}
function mergeRspeedyConfig(...configs) {
return mergeRsbuildConfig(...configs);
}
function defineConfig(config) {
return config;
}
const resolveConfigPath = (root, customConfig)=>{
if (customConfig) {
debug(`load custom config file ${customConfig} from ${root}`);
const customConfigPath = isAbsolute(customConfig) ? customConfig : join(root, customConfig);
if (node_fs.existsSync(customConfigPath)) return customConfigPath;
throw new Error(`Cannot find config file: ${picocolors_default().dim(customConfigPath)}`);
}
const CONFIG_FILES = [
'lynx.config.ts',
'lynx.config.js',
'lynx.config.mts',
'lynx.config.mjs'
];
for (const file of CONFIG_FILES){
debug(`load default config file ${file} from ${root}`);
const configFile = join(root, file);
if (node_fs.existsSync(configFile)) {
debug(`default config ${configFile} found`);
return configFile;
}
}
throw new Error([
`Cannot find the default config file: ${picocolors_default().dim(join(root, CONFIG_FILES[0]))}.`,
`Use custom config with ${picocolors_default().green('`--config <config>`')} options.`
].join(' '));
};
async function loadConfig(loadConfigOptions) {
let { configPath } = loadConfigOptions;
if (!configPath || !isAbsolute(configPath)) configPath = resolveConfigPath(loadConfigOptions.cwd ?? process.cwd(), configPath);
const specifier = pathToFileURL(configPath).toString();
let unregister;
unregister = shouldUseNativeImport(configPath) ? ()=>{} : register({
load: !hasNativeTSSupport(),
resolve: true
});
try {
const [exports, { validate }] = await Promise.all([
import(`${specifier}?t=${Date.now()}`),
import("./0~validate.js").then((m)=>m.validate_namespaceObject)
]);
const configExport = 'default' in exports ? exports.default : exports;
const rawContent = 'function' == typeof configExport ? await configExport({
command: process.argv[2] ?? 'build',
env: process.env['NODE_ENV'] ?? 'production'
}) : await configExport;
return {
configPath,
content: validate(rawContent, configPath)
};
} finally{
unregister();
}
}
function shouldUseNativeImport(configPath) {
return isJavaScriptPath(configPath) || isDeno();
}
function hasNativeTSSupport() {
if (isDeno()) return true;
if (process.features.typescript) return true;
if (false === process.features.typescript) return false;
const { NODE_OPTIONS } = process.env;
if (!NODE_OPTIONS) return false;
return NODE_OPTIONS.includes('--experimental-transform-types') || NODE_OPTIONS.includes('--experimental-strip-types');
}
function isJavaScriptPath(configPath) {
const ext = extname(configPath);
return [
'.js',
'.mjs',
'.cjs'
].includes(ext);
}
function isDeno() {
if ("u" > typeof Deno || process.versions?.deno) return true;
return false;
}
var package_namespaceObject = {
rE: "0.15.0"
};
const version_version = package_namespaceObject.rE;
const rspackVersion = rspack.rspackVersion;
export { __webpack_require__temp as __webpack_require__, createRspeedy, debug, defineConfig, isDebug, loadConfig, logger, mergeRspeedyConfig, rspack, rspackVersion, version as rsbuildVersion, version_version as version };