@rsbuild/core 2.0.0-beta.2 → 2.0.0-beta.4

package/compiled/jiti/lib/jiti-cli.mjs

@@ -0,0 +1,19 @@
+#!/usr/bin/env node
+import { resolve } from "node:path";
+import nodeModule from "node:module";
+const script = process.argv.splice(2, 1)[0];
+if (!script) {
+    console.error("Usage: jiti <path> [...arguments]");
+    process.exit(1);
+}
+if (nodeModule.enableCompileCache && !process.env.NODE_DISABLE_COMPILE_CACHE) try {
+    nodeModule.enableCompileCache();
+} catch  {}
+const pwd = process.cwd();
+const { createJiti } = await import("./jiti.cjs");
+const jiti = createJiti(pwd);
+const resolved = process.argv[1] = jiti.resolve(resolve(pwd, script));
+await jiti.import(resolved).catch((error)=>{
+    console.error(error);
+    process.exit(1);
+});

package/compiled/jiti/lib/jiti-hooks.mjs

@@ -0,0 +1,89 @@
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { existsSync } from "node:fs";
+import { readFile } from "node:fs/promises";
+import { isBuiltin } from "node:module";
+import { createJiti } from "./jiti.mjs";
+let jiti;
+export async function initialize() {
+    jiti = createJiti();
+}
+export async function resolve(specifier, context, nextResolve) {
+    if (_shouldSkip(specifier)) return nextResolve(specifier, context);
+    const resolvedPath = jiti.esmResolve(specifier, {
+        parentURL: context?.parentURL,
+        conditions: context?.conditions
+    });
+    return {
+        url: resolvedPath,
+        shortCircuit: true
+    };
+}
+export async function load(url, context, nextLoad) {
+    if (_shouldSkip(url)) return nextLoad(url, context);
+    const filename = fileURLToPath(url);
+    if (url.endsWith(".js")) {
+        const pkg = await _findClosestPackageJson(dirname(filename));
+        if (pkg && "module" === pkg.type) return nextLoad(url, context);
+    }
+    const rawSource = await readFile(filename, "utf8");
+    if (url.endsWith(".json")) {
+        const pkg = await _findClosestPackageJson(dirname(filename));
+        return pkg && "module" === pkg.type ? {
+            source: `export default ${rawSource}`,
+            format: "module",
+            shortCircuit: true
+        } : {
+            source: `module.exports = ${rawSource}`,
+            format: "commonjs",
+            shortCircuit: true
+        };
+    }
+    const transpiledSource = jiti.transform({
+        source: rawSource,
+        filename: filename,
+        ts: url.endsWith("ts"),
+        retainLines: true,
+        async: true,
+        jsx: jiti.options.jsx
+    });
+    if (url.endsWith(".js") && !transpiledSource.includes("jitiImport")) return {
+        source: transpiledSource,
+        format: "commonjs",
+        shortCircuit: true
+    };
+    return {
+        source: _wrapSource(transpiledSource, filename),
+        format: "module",
+        shortCircuit: true
+    };
+}
+function _wrapSource(source, filename) {
+    const _jitiPath = new URL("jiti.mjs", import.meta.url).href;
+    return `import { createJiti as __createJiti__ } from ${JSON.stringify(_jitiPath)};async function _module(exports, require, module, __filename, __dirname, jitiImport) { ${source}\n};
+// GENERATED BY JITI ESM LOADER
+const filename = ${JSON.stringify(filename)};
+const dirname = ${JSON.stringify(dirname(filename))};
+const jiti = __createJiti__(filename);
+const module = { exports: Object.create(null) };
+await _module(module.exports, jiti, module, filename, dirname, jiti.import);
+if (module.exports && module.exports.__JITI_ERROR__) {
+  const { filename, line, column, code, message } =
+  module.exports.__JITI_ERROR__;
+  const loc = [filename, line, column].join(':');
+  const err = new Error(code + ": " + message + " " + loc);
+  Error.captureStackTrace(err, _module);
+  throw err;
+}
+export default module.exports;
+  `;
+}
+function _shouldSkip(url) {
+    return !jiti || url.endsWith(".mjs") || url.endsWith(".cjs") || !url.startsWith("./") && !url.startsWith("file://") || isBuiltin(url);
+}
+async function _findClosestPackageJson(dir) {
+    if ("/" === dir) return null;
+    const packageJsonPath = join(dir, "package.json");
+    if (existsSync(packageJsonPath)) return JSON.parse(await readFile(packageJsonPath, "utf8"));
+    return _findClosestPackageJson(dirname(dir));
+}

package/compiled/jiti/lib/jiti-native.mjs

@@ -0,0 +1,76 @@
+const isDeno = "Deno" in globalThis;
+export function createJiti(parentURL, jitiOptions) {
+    parentURL = normalizeParentURL(parentURL);
+    function jiti() {
+        throw unsupportedError("`jiti()` is not supported in native mode, use `jiti.import()` instead.");
+    }
+    jiti.resolve = ()=>{
+        throw unsupportedError("`jiti.resolve()` is not supported in native mode.");
+    };
+    jiti.esmResolve = (id, opts)=>{
+        try {
+            const importMeta = jitiOptions?.importMeta || import.meta;
+            if (isDeno) return importMeta.resolve(id);
+            const parent = normalizeParentURL(opts?.parentURL || parentURL);
+            return importMeta.resolve(id, parent);
+        } catch (error) {
+            if (opts?.try) return;
+            throw error;
+        }
+    };
+    jiti.import = async function(id, opts) {
+        for (const suffix of [
+            "",
+            "/index"
+        ])for (const ext of [
+            "",
+            ".js",
+            ".mjs",
+            ".cjs",
+            ".ts",
+            ".tsx",
+            ".mts",
+            ".cts"
+        ])try {
+            const resolved = this.esmResolve(id + suffix + ext, opts);
+            if (!resolved) continue;
+            let importAttrs;
+            if (resolved.endsWith('.json')) importAttrs = {
+                with: {
+                    type: 'json'
+                }
+            };
+            return await import(resolved, importAttrs);
+        } catch (error) {
+            if ('ERR_MODULE_NOT_FOUND' === error.code || 'ERR_UNSUPPORTED_DIR_IMPORT' === error.code) continue;
+            if (opts?.try) return;
+            throw error;
+        }
+        if (!opts?.try) {
+            const parent = normalizeParentURL(opts?.parentURL || parentURL);
+            const error = new Error(`[jiti] [ERR_MODULE_NOT_FOUND] Cannot import '${id}' from '${parent}'.`);
+            error.code = "ERR_MODULE_NOT_FOUND";
+            throw error;
+        }
+    };
+    jiti.transform = ()=>{
+        throw unsupportedError("`jiti.transform()` is not supported in native mode.");
+    };
+    jiti.evalModule = ()=>{
+        throw unsupportedError("`jiti.evalModule()` is not supported in native mode.");
+    };
+    jiti.main = void 0;
+    jiti.extensions = Object.create(null);
+    jiti.cache = Object.create(null);
+    return jiti;
+}
+export default createJiti;
+function unsupportedError(message) {
+    throw new Error(`[jiti] ${message} (import or require 'jiti' instead of 'jiti/native' for more features).`);
+}
+function normalizeParentURL(input) {
+    if (!input) return "file:///";
+    if ("string" != typeof filename || input.startsWith("file://")) return input;
+    if (input.endsWith("/")) input += "_";
+    return `file://${input}`;
+}

package/compiled/jiti/lib/jiti-register.d.mts

@@ -0,0 +1 @@
+// eslint-disable-next-line unicorn/no-empty-file

package/compiled/jiti/lib/jiti-register.mjs

@@ -0,0 +1,2 @@
+import { register } from "node:module";
+register("./jiti-hooks.mjs", import.meta.url, {});

package/compiled/jiti/lib/jiti.cjs

@@ -0,0 +1,24 @@
+const { createRequire } = require("node:module");
+const _createJiti = require("../dist/jiti.cjs");
+function onError(err) {
+    throw err;
+}
+const nativeImport = (id)=>import(id);
+let _transform;
+function lazyTransform(...args) {
+    if (!_transform) _transform = require("../dist/babel.cjs");
+    return _transform(...args);
+}
+function createJiti(id, opts = {}) {
+    if (!opts.transform) opts = {
+        ...opts,
+        transform: lazyTransform
+    };
+    return _createJiti(id, opts, {
+        onError,
+        nativeImport,
+        createRequire
+    });
+}
+module.exports = createJiti;
+module.exports.createJiti = createJiti;

package/compiled/jiti/lib/jiti.d.cts

@@ -0,0 +1,8 @@
+import * as types from "./types.js";
+declare const allExports: typeof types & {
+  /**
+   * @deprecated Please use `const { createJiti } = require("jiti")` or use ESM import.
+   */
+  (...args: Parameters<typeof types.createJiti>): types.Jiti;
+};
+export = allExports;

package/compiled/jiti/lib/jiti.d.mts

@@ -0,0 +1,8 @@
+import { createJiti } from "./types.js";
+
+export * from "./types.js";
+
+/**
+ * @deprecated Please use `import { createJiti } from "jiti"`
+ */
+export default createJiti;

package/compiled/jiti/lib/jiti.mjs

@@ -0,0 +1,23 @@
+import { createRequire } from "node:module";
+import _createJiti from "../dist/jiti.cjs";
+function onError(err) {
+    throw err;
+}
+const nativeImport = (id)=>import(id);
+let _transform;
+function lazyTransform(...args) {
+    if (!_transform) _transform = createRequire(import.meta.url)("../dist/babel.cjs");
+    return _transform(...args);
+}
+export function createJiti(id, opts = {}) {
+    if (!opts.transform) opts = {
+        ...opts,
+        transform: lazyTransform
+    };
+    return _createJiti(id, opts, {
+        onError,
+        nativeImport,
+        createRequire
+    });
+}
+export default createJiti;

package/compiled/jiti/lib/types.d.ts

@@ -0,0 +1,363 @@
+/**
+ * Creates a new {@linkcode Jiti} instance with custom options.
+ *
+ * @param id - Instance id, usually the current filename.
+ * @param userOptions - Custom options to override the default options.
+ * @returns A {@linkcode Jiti} instance.
+ *
+ * @example
+ * <caption>ESM Usage</caption>
+ *
+ * ```ts
+ * import { createJiti } from "jiti";
+ *
+ * const jiti = createJiti(import.meta.url, { debug: true });
+ * ```
+ *
+ * @example
+ * <caption>CommonJS Usage **(deprecated)**</caption>
+ *
+ * ```ts
+ * const { createJiti } = require("jiti");
+ *
+ * const jiti = createJiti(__filename, { debug: true });
+ * ```
+ *
+ * @since 2.0.0
+ */
+export declare function createJiti(id: string, userOptions?: JitiOptions): Jiti;
+
+/**
+ * Jiti instance
+ *
+ * Calling `jiti()` is similar to CommonJS {@linkcode require()} but adds
+ * extra features such as TypeScript and ESM compatibility.
+ *
+ * **Note:** It is recommended to use
+ * {@linkcode Jiti.import | await jiti.import()} instead.
+ */
+export interface Jiti extends NodeRequire {
+  /**
+   * Resolved options
+   */
+  options: JitiOptions;
+
+  /**
+   * ESM import a module with additional TypeScript and ESM compatibility.
+   *
+   * If you need the default export of module, you can use
+   * `jiti.import(id, { default: true })` as shortcut to `mod?.default ?? mod`.
+   */
+  import<T = unknown>(
+    id: string,
+    opts?: JitiResolveOptions & { default?: true },
+  ): Promise<T>;
+
+  /**
+   * Resolve with ESM import conditions.
+   */
+  esmResolve(id: string, parentURL?: string): string;
+  esmResolve<T extends JitiResolveOptions = JitiResolveOptions>(
+    id: string,
+    opts?: T,
+  ): T["try"] extends true ? string | undefined : string;
+
+  /**
+   * Transform source code
+   */
+  transform: (opts: TransformOptions) => string;
+
+  /**
+   * Evaluate transformed code as a module
+   */
+  evalModule: (source: string, options?: EvalModuleOptions) => unknown;
+}
+
+/**
+ * Jiti instance options
+ */
+export interface JitiOptions {
+  /**
+   * Filesystem source cache
+   *
+   * An string can be passed to set the custom cache directory.
+   *
+   * By default (when set to `true`), jiti uses
+   * `node_modules/.cache/jiti` (if exists) or `{TMP_DIR}/jiti`.
+   *
+   * This option can also be disabled using
+   * `JITI_FS_CACHE=false` environment variable.
+   *
+   * **Note:** It is recommended to keep this option
+   * enabled for better performance.
+   *
+   * @default true
+   */
+  fsCache?: boolean | string;
+
+  /**
+   * Rebuild the filesystem source cache
+   *
+   * This option can also be enabled using
+   * `JITI_REBUILD_FS_CACHE=true` environment variable.
+   *
+   * @default false
+   */
+  rebuildFsCache?: boolean;
+
+  /**
+   * @deprecated Use the {@linkcode fsCache} option.
+   *
+   * @default true
+   */
+  cache?: boolean | string;
+
+  /**
+   * Runtime module cache
+   *
+   * Disabling allows editing code and importing same module multiple times.
+   *
+   * When enabled, jiti integrates with Node.js native CommonJS cache store.
+   *
+   * This option can also be disabled using
+   * `JITI_MODULE_CACHE=false` environment variable.
+   *
+   * @default true
+   */
+  moduleCache?: boolean;
+
+  /**
+   * @deprecated Use the {@linkcode moduleCache} option.
+   *
+   * @default true
+   */
+  requireCache?: boolean;
+
+  /**
+   * Custom transform function
+   */
+  transform?: (opts: TransformOptions) => TransformResult;
+
+  /**
+   * Enable verbose debugging.
+   *
+   * Can also be enabled using `JITI_DEBUG=1` environment variable.
+   *
+   * @default false
+   */
+  debug?: boolean;
+
+  /**
+   * Enable sourcemaps for transformed code.
+   *
+   * Can also be disabled using `JITI_SOURCE_MAPS=0` environment variable.
+   *
+   * @default false
+   */
+  sourceMaps?: boolean;
+
+  /**
+   * Jiti combines module exports with the `default` export using an
+   * internal Proxy to improve compatibility with mixed CJS/ESM usage.
+   * You can check the current implementation
+   * {@link https://github.com/unjs/jiti/blob/main/src/utils.ts#L105 here}.
+   *
+   * Can be disabled using `JITI_INTEROP_DEFAULT=0` environment variable.
+   *
+   * @default true
+   */
+  interopDefault?: boolean;
+
+  /**
+   * Jiti hard source cache version.
+   *
+   * @internal
+   */
+  cacheVersion?: string;
+
+  /**
+   * Supported extensions to resolve.
+   *
+   * @default [".js", ".mjs", ".cjs", ".ts", ".tsx", ".mts", ".cts", ".mtsx", ".ctsx", ".json"]
+   */
+  extensions?: string[];
+
+  /**
+   * Transform options
+   */
+  transformOptions?: Omit<TransformOptions, "source">;
+
+  /**
+   * Resolve aliases
+   *
+   * You can use `JITI_ALIAS` environment variable to set aliases as
+   * a JSON string.
+   *
+   * @default {}
+   */
+  alias?: Record<string, string>;
+
+  /**
+   * List of modules (within `node_modules`) to always use native
+   * require/import for them.
+   *
+   * You can use `JITI_NATIVE_MODULES` environment variable to set
+   * native modules as a JSON string.
+   *
+   * @default []
+   */
+  nativeModules?: string[];
+
+  /**
+   * List of modules (within `node_modules`) to transform them
+   * regardless of syntax.
+   *
+   * You can use `JITI_TRANSFORM_MODULES` environment variable to set
+   * transform modules as a JSON string.
+   *
+   * @default []
+   */
+  transformModules?: string[];
+
+  /**
+   * Parent module's {@linkcode ImportMeta | import.meta} context to use
+   * for ESM resolution.
+   *
+   * (Only used for `jiti/native` import)
+   */
+  importMeta?: ImportMeta;
+
+  /**
+   * Try to use native require and import without jiti transformations first.
+   *
+   * Enabled if Bun is detected.
+   *
+   * @default false
+   */
+  tryNative?: boolean;
+
+  /**
+   * Enable JSX support Enable JSX support using
+   * {@link https://babeljs.io/docs/babel-plugin-transform-react-jsx | `@babel/plugin-transform-react-jsx`}.
+   *
+   * You can also use `JITI_JSX=1` environment variable to enable JSX support.
+   *
+   * @default false
+   */
+  jsx?: boolean | JSXOptions;
+}
+
+interface NodeRequire {
+  /**
+   * Module cache
+   */
+  cache: ModuleCache;
+
+  /**
+   * @deprecated Prefer {@linkcode Jiti.import | await jiti.import()}
+   * for better compatibility.
+   */
+  (id: string): any;
+
+  /**
+   * @deprecated Prefer {@linkcode Jiti.esmResolve | jiti.esmResolve}
+   * for better compatibility.
+   */
+  resolve: {
+    /** @deprecated */
+    (id: string, options?: { paths?: string[] | undefined }): string;
+    /** @deprecated */
+    paths(request: string): string[] | null;
+  };
+
+  /** @deprecated CommonJS API */
+  extensions: Record<
+    ".js" | ".json" | ".node",
+    (m: NodeModule, filename: string) => any | undefined
+  >;
+
+  /** @deprecated CommonJS API */
+  main: NodeModule | undefined;
+}
+
+export interface NodeModule {
+  /**
+   * `true` if the module is running during the Node.js preload.
+   */
+  isPreloading: boolean;
+  exports: any;
+  require: NodeRequire;
+  id: string;
+  filename: string;
+  loaded: boolean;
+  /**
+   * @deprecated since Node.js **v14.6.0** Please use
+   * {@linkcode NodeRequire.main | require.main} and
+   * {@linkcode NodeModule.children | module.children} instead.
+   */
+  parent: NodeModule | null | undefined;
+  children: NodeModule[];
+  /**
+   * The directory name of the module.
+   * This is usually the same as the `path.dirname()` of the `module.id`.
+   *
+   * @since Node.js **v11.14.0**
+   */
+  path: string;
+  paths: string[];
+}
+
+export type ModuleCache = Record<string, NodeModule>;
+
+export type EvalModuleOptions = Partial<{
+  id: string;
+  filename: string;
+  ext: string;
+  cache: ModuleCache;
+  /**
+   * @default true
+   */
+  async: boolean;
+  forceTranspile: boolean;
+}>;
+
+export interface TransformOptions {
+  source: string;
+  filename?: string;
+  ts?: boolean;
+  retainLines?: boolean;
+  interopDefault?: boolean;
+  /**
+   * @default false
+   */
+  async?: boolean;
+  /**
+   * @default false
+   */
+  jsx?: boolean | JSXOptions;
+  babel?: Record<string, any>;
+}
+
+export interface TransformResult {
+  code: string;
+  error?: any;
+}
+
+export interface JitiResolveOptions {
+  conditions?: string[];
+  parentURL?: string | URL;
+  try?: boolean;
+}
+
+/**
+ * @see {@link https://babeljs.io/docs/babel-plugin-transform-react-jsx#options | Reference}
+ */
+export interface JSXOptions {
+  throwIfNamespace?: boolean;
+  runtime?: "classic" | "automatic";
+  importSource?: string;
+  pragma?: string;
+  pragmaFrag?: string;
+  useBuiltIns?: boolean;
+  useSpread?: boolean;
+}