@rspack-debug/core 1.4.11 → 1.6.4

package/dist/builtin-plugin/index.d.ts

@@ -26,6 +26,7 @@ export * from "./EnableLibraryPlugin";
 export * from "./EnableWasmLoadingPlugin";
 export * from "./EnsureChunkConditionsPlugin";
 export * from "./EntryPlugin";
+export * from "./EsmLibraryPlugin";
 export * from "./EvalDevToolModulePlugin";
 export * from "./EvalSourceMapDevToolPlugin";
 export * from "./ExternalsPlugin";
@@ -39,6 +40,7 @@ export * from "./HttpUriPlugin";
 export * from "./html-plugin/index";
 export * from "./IgnorePlugin";
 export * from "./InferAsyncModulesPlugin";
+export * from "./InlineExportsPlugin";
 export * from "./JavascriptModulesPlugin";
 export * from "./JsLoaderRspackPlugin";
 export * from "./JsonModulesPlugin";
@@ -58,6 +60,7 @@ export * from "./NaturalChunkIdsPlugin";
 export * from "./NaturalModuleIdsPlugin";
 export * from "./NodeTargetPlugin";
 export * from "./NoEmitOnErrorsPlugin";
+export * from "./NormalModuleReplacementPlugin";
 export * from "./OccurrenceChunkIdsPlugin";
 export * from "./ProgressPlugin";
 export * from "./ProvidePlugin";
@@ -75,6 +78,7 @@ export * from "./SourceMapDevToolPlugin";
 export * from "./SplitChunksPlugin";
 export * from "./SubresourceIntegrityPlugin";
 export * from "./SwcJsMinimizerPlugin";
+export * from "./URLPlugin";
 export * from "./WarnCaseSensitiveModulesPlugin";
 export * from "./WebWorkerTemplatePlugin";
 export * from "./WorkerPlugin";

package/dist/builtin-plugin/lazy-compilation/lazyCompilation.d.ts

@@ -1,23 +1,9 @@
 import type { Module } from "../../Module";
 export declare const BuiltinLazyCompilationPlugin: {
-    new (module: (args: {
-        module: string;
-        path: string;
-    }) => {
-        active: boolean;
-        data: string;
-        client: string;
-    }, cacheable: boolean, entries: boolean, imports: boolean, test?: RegExp | ((module: Module) => boolean) | undefined): {
+    new (currentActiveModules: () => Set<string>, entries: boolean, imports: boolean, client: string, test?: RegExp | ((module: Module) => boolean) | undefined): {
         name: string;
-        _args: [module: (args: {
-            module: string;
-            path: string;
-        }) => {
-            active: boolean;
-            data: string;
-            client: string;
-        }, cacheable: boolean, entries: boolean, imports: boolean, test?: RegExp | ((module: Module) => boolean) | undefined];
-        affectedHooks: "done" | "compilation" | "afterDone" | "thisCompilation" | "invalid" | "compile" | "normalModuleFactory" | "contextModuleFactory" | "initialize" | "shouldEmit" | "infrastructureLog" | "beforeRun" | "run" | "emit" | "assetEmitted" | "afterEmit" | "failed" | "shutdown" | "watchRun" | "watchClose" | "environment" | "afterEnvironment" | "afterPlugins" | "afterResolvers" | "make" | "beforeCompile" | "afterCompile" | "finishMake" | "entryOption" | "additionalPass" | undefined;
+        _args: [currentActiveModules: () => Set<string>, entries: boolean, imports: boolean, client: string, test?: RegExp | ((module: Module) => boolean) | undefined];
+        affectedHooks: keyof import("../..").CompilerHooks | undefined;
         raw(compiler: import("../..").Compiler): import("@rspack/binding").BuiltinPlugin;
         apply(compiler: import("../..").Compiler): void;
     };

package/dist/config/adapterRuleUse.d.ts

@@ -15,19 +15,50 @@ export interface ComposeJsUseOptions {
     experiments: RawOptions["experiments"];
     compiler: Compiler;
 }
-export interface SourceMap {
+export interface RawSourceMap {
+    /**
+     * The version of the source map format, always 3
+     */
     version: number;
+    /**
+     * A list of original sources used by the mappings field
+     */
     sources: string[];
+    /**
+     * A string with the encoded mapping data
+     */
     mappings: string;
-    file?: string;
+    /**
+     * The filename of the generated code that this source map is associated with
+     */
+    file: string;
+    /**
+     * An optional source root string, used for relocating source files on a server
+     * or removing repeated values in the sources entry.
+     */
     sourceRoot?: string;
+    /**
+     * An array containing the actual content of the original source files
+     */
     sourcesContent?: string[];
-    names?: string[];
+    /**
+     * A list of symbol names which may be used by the mappings field.
+     */
+    names: string[];
+    /**
+     * A unique identifier for debugging purposes
+     */
+    debugId?: string;
+    /**
+     * An array of indices into the sources array, indicating which sources
+     * should be ignored by debuggers
+     */
+    ignoreList?: number[];
 }
 export interface AdditionalData {
     [index: string]: any;
 }
-export type LoaderContextCallback = (err?: Error | null, content?: string | Buffer, sourceMap?: string | SourceMap, additionalData?: AdditionalData) => void;
+export type LoaderContextCallback = (err?: Error | null, content?: string | Buffer, sourceMap?: string | RawSourceMap, additionalData?: AdditionalData) => void;
 export type ErrorWithDetails = Error & {
     details?: string;
 };
@@ -48,10 +79,13 @@ export interface Diagnostic {
     sourceCode?: string;
     /**
      * Location to the source code.
-     *
      * If `sourceCode` is not provided, location will be omitted.
      */
     location?: DiagnosticLocation;
+    /**
+     * Optional filename to show.
+     * If provided, it becomes the `StatsError.file` value in stats.
+     */
     file?: string;
     severity: "error" | "warning";
 }
@@ -322,8 +356,32 @@ export interface LoaderContext<OptionsType = {}> {
      */
     __internal__setParseMeta: (key: string, value: string) => void;
 }
-export type LoaderDefinitionFunction<OptionsType = {}, ContextAdditions = {}> = (this: LoaderContext<OptionsType> & ContextAdditions, content: string, sourceMap?: string | SourceMap, additionalData?: AdditionalData) => string | void | Buffer | Promise<string | Buffer>;
-export type PitchLoaderDefinitionFunction<OptionsType = {}, ContextAdditions = {}> = (this: LoaderContext<OptionsType> & ContextAdditions, remainingRequest: string, previousRequest: string, data: object) => string | void | Buffer | Promise<string | Buffer>;
+export type LoaderDefinitionFunction<OptionsType = {}, ContextAdditions = {}> = (this: LoaderContext<OptionsType> & ContextAdditions, content: string, sourceMap?: string | RawSourceMap, additionalData?: AdditionalData) => string | void | Buffer | Promise<string | Buffer | void>;
+export type PitchLoaderDefinitionFunction<OptionsType = {}, ContextAdditions = {}> = (this: LoaderContext<OptionsType> & ContextAdditions, remainingRequest: string, previousRequest: string, data: object) => string | void | Buffer | Promise<string | Buffer | void>;
+/**
+ * Defines a loader for Rspack.
+ * A loader is a transformer that converts various types of modules into Rspack
+ * supported types. By using different kinds of loaders, you can extend Rspack to
+ * process additional module types, including JSX, Markdown, Sass, Less, and more.
+ *
+ * @template OptionsType - The type of options that the loader accepts
+ * @template ContextAdditions - Additional properties to add to the loader context
+ *
+ * @example
+ * ```ts
+ * import type { LoaderDefinition } from '@rspack/core';
+ *
+ * type MyLoaderOptions = {
+ *   foo: string;
+ * };
+ *
+ * const myLoader: LoaderDefinition<MyLoaderOptions> = function(source) {
+ *   return someOperation(source);
+ * };
+ *
+ * export default myLoader;
+ * ```
+ */
 export type LoaderDefinition<OptionsType = {}, ContextAdditions = {}> = LoaderDefinitionFunction<OptionsType, ContextAdditions> & {
     raw?: false;
     pitch?: PitchLoaderDefinitionFunction;

package/dist/config/defaults.d.ts

@@ -1,12 +1,3 @@
-/**
- * The following code is modified based on
- * https://github.com/webpack/webpack/blob/4b4ca3b/lib/config/defaults.js
- *
- * MIT Licensed
- * Author Tobias Koppers @sokra
- * Copyright (c) JS Foundation and other contributors
- * https://github.com/webpack/webpack/blob/main/LICENSE
- */
 import type { RspackOptionsNormalized } from "./normalization";
 export declare const applyRspackOptionsDefaults: (options: RspackOptionsNormalized) => void;
 export declare const applyRspackOptionsBaseDefaults: (options: RspackOptionsNormalized) => void;

package/dist/config/devServer.d.ts

@@ -7,7 +7,11 @@
  * Copyright (c) JS Foundation and other contributors
  * https://github.com/webpack/webpack-dev-server/blob/master/LICENSE
  */
-import type { Compiler, MultiCompiler, MultiStats, Stats, Watching } from "..";
+import type * as http from "node:http";
+import type * as net from "node:net";
+import type * as stream from "node:stream";
+import type * as url from "node:url";
+import type { Compiler, LiteralUnion, MultiCompiler, MultiStats, Stats, Watching } from "..";
 type Logger = ReturnType<Compiler["getInfrastructureLogger"]>;
 type MultiWatching = MultiCompiler["watch"];
 type BasicServer = import("net").Server | import("tls").Server;
@@ -28,17 +32,16 @@ type ResponseData = {
     byteLength: number;
 };
 type ModifyResponseData<RequestInternal extends IncomingMessage = IncomingMessage, ResponseInternal extends ServerResponse = ServerResponse> = (req: RequestInternal, res: ResponseInternal, data: Buffer | ReadStream, byteLength: number) => ResponseData;
-type Headers = Array<{
+type Headers = {
     key: string;
     value: string;
-}> | Record<string, string | string[]>;
+}[] | Record<string, string | string[]>;
 type OutputFileSystem = import("..").OutputFileSystem & {
-    createReadStream?: typeof import("fs").createReadStream;
     statSync: import("fs").StatSyncFn;
     readFileSync: typeof import("fs").readFileSync;
 };
 type RspackConfiguration = import("..").Configuration;
-type Port = number | string | "auto";
+type Port = number | LiteralUnion<"auto", string>;
 type HistoryContext = {
     readonly match: RegExpMatchArray;
     readonly parsedUrl: import("url").Url;
@@ -80,7 +83,7 @@ type DevMiddlewareOptions<RequestInternal extends IncomingMessage = IncomingMess
     cacheImmutable?: boolean | undefined;
 };
 type BasicApplication = any;
-type BonjourServer = any;
+type BonjourServer = Record<string, any>;
 type ChokidarWatchOptions = {
     [key: string]: any;
 };
@@ -112,7 +115,7 @@ type Static = {
         poll?: number | boolean;
     }) | undefined;
 };
-type ServerType<A extends BasicApplication = BasicApplication, S extends BasicServer = import("http").Server<typeof import("http").IncomingMessage, typeof import("http").ServerResponse>> = "http" | "https" | "spdy" | "http2" | string | ((arg0: ServerOptions, arg1: A) => S);
+type ServerType<A extends BasicApplication = BasicApplication, S extends BasicServer = import("http").Server<typeof import("http").IncomingMessage, typeof import("http").ServerResponse>> = LiteralUnion<"http" | "https" | "spdy" | "http2", string> | ((arg0: ServerOptions, arg1: A) => S);
 type ServerConfiguration<A extends BasicApplication = BasicApplication, S extends BasicServer = import("http").Server<typeof import("http").IncomingMessage, typeof import("http").ServerResponse>> = {
     type?: ServerType<A, S> | undefined;
     options?: ServerOptions | undefined;
@@ -123,16 +126,14 @@ type WebSocketServerConfiguration = {
 };
 type NextFunction = (err?: any) => void;
 type ProxyConfigArrayItem = {
-    path?: HttpProxyMiddlewareOptionsFilter | undefined;
-    context?: HttpProxyMiddlewareOptionsFilter | undefined;
+    path?: HttpProxyMiddlewareOptionsFilter;
+    context?: HttpProxyMiddlewareOptionsFilter;
 } & {
     bypass?: ByPass;
-} & {
-    [key: string]: any;
-};
+} & HttpProxyMiddlewareOptions;
 type ByPass = (req: Request, res: Response, proxyConfig: ProxyConfigArrayItem) => any;
-type ProxyConfigArray = (ProxyConfigArrayItem | ((req?: Request | undefined, res?: Response | undefined, next?: NextFunction | undefined) => ProxyConfigArrayItem))[];
-type Callback = (stats?: Stats | MultiStats | undefined) => any;
+type ProxyConfigArray = (ProxyConfigArrayItem | ((req?: Request, res?: Response, next?: NextFunction) => ProxyConfigArrayItem))[];
+type Callback = (stats?: Stats | MultiStats) => any;
 type DevMiddlewareContext<_RequestInternal extends IncomingMessage = IncomingMessage, _ResponseInternal extends ServerResponse = ServerResponse> = {
     state: boolean;
     stats: Stats | MultiStats | undefined;
@@ -190,7 +191,7 @@ export type DevServerOptions<A extends BasicApplication = BasicApplication, S ex
     compress?: boolean | undefined;
     allowedHosts?: string | string[] | undefined;
     historyApiFallback?: boolean | HistoryApiFallbackOptions | undefined;
-    bonjour?: boolean | Record<string, never> | BonjourServer | undefined;
+    bonjour?: boolean | BonjourServer | undefined;
     watchFiles?: string | string[] | WatchFiles | (string | WatchFiles)[] | undefined;
     static?: string | boolean | Static | (string | Static)[] | undefined;
     server?: ServerType<A, S> | ServerConfiguration<A, S> | undefined;
@@ -200,8 +201,114 @@ export type DevServerOptions<A extends BasicApplication = BasicApplication, S ex
     open?: string | boolean | Open | (string | Open)[] | undefined;
     setupExitSignals?: boolean | undefined;
     client?: boolean | ClientConfiguration | undefined;
-    headers?: Headers | ((req: Request, res: Response, context: DevMiddlewareContext<Request, Response> | undefined) => Headers) | undefined;
+    headers?: Headers | ((req: Request, res: Response, context: DevMiddlewareContext | undefined) => Headers) | undefined;
     onListening?: ((devServer: Server) => void) | undefined;
     setupMiddlewares?: ((middlewares: Middleware[], devServer: Server) => Middleware[]) | undefined;
 };
+interface HttpProxyMiddlewareOptions extends HttpProxyServerOptions {
+    pathRewrite?: {
+        [regexp: string]: string;
+    } | ((path: string, req: Request) => string) | ((path: string, req: Request) => Promise<string>);
+    router?: {
+        [hostOrPath: string]: HttpProxyServerOptions["target"];
+    } | ((req: Request) => HttpProxyServerOptions["target"]) | ((req: Request) => Promise<HttpProxyServerOptions["target"]>);
+    logLevel?: "debug" | "info" | "warn" | "error" | "silent";
+    logProvider?: LogProviderCallback;
+    onError?: OnErrorCallback;
+    onProxyRes?: OnProxyResCallback;
+    onProxyReq?: OnProxyReqCallback;
+    onProxyReqWs?: OnProxyReqWsCallback;
+    onOpen?: OnOpenCallback;
+    onClose?: OnCloseCallback;
+}
+interface LogProvider {
+    log: Logger;
+    debug?: Logger;
+    info?: Logger;
+    warn?: Logger;
+    error?: Logger;
+}
+type LogProviderCallback = (provider: LogProvider) => LogProvider;
+type OnErrorCallback = (err: Error, req: Request, res: Response, target?: string | Partial<url.Url>) => void;
+type OnProxyResCallback = (proxyRes: http.IncomingMessage, req: Request, res: Response) => void;
+type OnProxyReqCallback = (proxyReq: http.ClientRequest, req: Request, res: Response, options: HttpProxyServerOptions) => void;
+type OnProxyReqWsCallback = (proxyReq: http.ClientRequest, req: Request, socket: net.Socket, options: HttpProxyServerOptions, head: any) => void;
+type OnCloseCallback = (proxyRes: Response, proxySocket: net.Socket, proxyHead: any) => void;
+type OnOpenCallback = (proxySocket: net.Socket) => void;
+interface HttpProxyServerOptions {
+    /** URL string to be parsed with the url module. */
+    target?: HttpProxyTarget | undefined;
+    /** URL string to be parsed with the url module. */
+    forward?: HttpProxyTargetUrl | undefined;
+    /** Object to be passed to http(s).request. */
+    agent?: any;
+    /** Object to be passed to https.createServer(). */
+    ssl?: any;
+    /** If you want to proxy websockets. */
+    ws?: boolean | undefined;
+    /** Adds x- forward headers. */
+    xfwd?: boolean | undefined;
+    /** Verify SSL certificate. */
+    secure?: boolean | undefined;
+    /** Explicitly specify if we are proxying to another proxy. */
+    toProxy?: boolean | undefined;
+    /** Specify whether you want to prepend the target's path to the proxy path. */
+    prependPath?: boolean | undefined;
+    /** Specify whether you want to ignore the proxy path of the incoming request. */
+    ignorePath?: boolean | undefined;
+    /** Local interface string to bind for outgoing connections. */
+    localAddress?: string | undefined;
+    /** Changes the origin of the host header to the target URL. */
+    changeOrigin?: boolean | undefined;
+    /** specify whether you want to keep letter case of response header key */
+    preserveHeaderKeyCase?: boolean | undefined;
+    /** Basic authentication i.e. 'user:password' to compute an Authorization header. */
+    auth?: string | undefined;
+    /** Rewrites the location hostname on (301 / 302 / 307 / 308) redirects, Default: null. */
+    hostRewrite?: string | undefined;
+    /** Rewrites the location host/ port on (301 / 302 / 307 / 308) redirects based on requested host/ port.Default: false. */
+    autoRewrite?: boolean | undefined;
+    /** Rewrites the location protocol on (301 / 302 / 307 / 308) redirects to 'http' or 'https'.Default: null. */
+    protocolRewrite?: string | undefined;
+    /** rewrites domain of set-cookie headers. */
+    cookieDomainRewrite?: false | string | {
+        [oldDomain: string]: string;
+    } | undefined;
+    /** rewrites path of set-cookie headers. Default: false */
+    cookiePathRewrite?: false | string | {
+        [oldPath: string]: string;
+    } | undefined;
+    /** object with extra headers to be added to target requests. */
+    headers?: {
+        [header: string]: string;
+    } | undefined;
+    /** Timeout (in milliseconds) when proxy receives no response from target. Default: 120000 (2 minutes) */
+    proxyTimeout?: number | undefined;
+    /** Timeout (in milliseconds) for incoming requests */
+    timeout?: number | undefined;
+    /** Specify whether you want to follow redirects. Default: false */
+    followRedirects?: boolean | undefined;
+    /** If set to true, none of the webOutgoing passes are called and it's your responsibility to appropriately return the response by listening and acting on the proxyRes event */
+    selfHandleResponse?: boolean | undefined;
+    /** Buffer */
+    buffer?: stream.Stream | undefined;
+    /** Explicitly set the method type of the ProxyReq */
+    method?: string | undefined;
+}
+interface HttpProxyTargetDetailed {
+    host: string;
+    port: number;
+    protocol?: string | undefined;
+    hostname?: string | undefined;
+    socketPath?: string | undefined;
+    key?: string | undefined;
+    passphrase?: string | undefined;
+    pfx?: Buffer | string | undefined;
+    cert?: string | undefined;
+    ca?: string | undefined;
+    ciphers?: string | undefined;
+    secureProtocol?: string | undefined;
+}
+type HttpProxyTarget = HttpProxyTargetUrl | HttpProxyTargetDetailed;
+type HttpProxyTargetUrl = string | Partial<url.Url>;
 export {};

package/dist/config/index.d.ts

@@ -1,4 +1,5 @@
 export * from "./adapter";
+export type { RawSourceMap } from "./adapterRuleUse";
 export * from "./defaults";
 export * from "./normalization";
 export type * from "./types";

package/dist/config/normalization.d.ts

@@ -76,6 +76,7 @@ export interface ModuleOptionsNormalized {
     parser: ParserOptionsByModuleType;
     generator: GeneratorOptionsByModuleType;
     noParse?: NoParseOption;
+    unsafeCache?: boolean | RegExp;
 }
 export type ExperimentCacheNormalized = boolean | {
     type: "memory";
@@ -84,9 +85,9 @@ export type ExperimentCacheNormalized = boolean | {
     buildDependencies: string[];
     version: string;
     snapshot: {
-        immutablePaths: Array<string | RegExp>;
-        unmanagedPaths: Array<string | RegExp>;
-        managedPaths: Array<string | RegExp>;
+        immutablePaths: (string | RegExp)[];
+        unmanagedPaths: (string | RegExp)[];
+        managedPaths: (string | RegExp)[];
     };
     storage: {
         type: "filesystem";
@@ -95,13 +96,24 @@ export type ExperimentCacheNormalized = boolean | {
 };
 export interface ExperimentsNormalized {
     cache?: ExperimentCacheNormalized;
+    /**
+     * @deprecated This option is deprecated and will be removed in future versions.
+     *
+     * Please use the Configuration top-level `lazyCompilation` option instead.
+     */
     lazyCompilation?: false | LazyCompilationOptions;
     asyncWebAssembly?: boolean;
     outputModule?: boolean;
     topLevelAwait?: boolean;
     css?: boolean;
+    /**
+     * @deprecated This option is deprecated, layers is enabled since v1.6.0
+     */
     layers?: boolean;
     incremental?: false | Incremental;
+    /**
+     * @deprecated This option is deprecated, as it has a huge regression in some edge cases where the chunk graph has lots of cycles. We will improve performance of build_chunk_graph.
+     */
     parallelCodeSplitting?: boolean;
     futureDefaults?: boolean;
     rspackFuture?: RspackFutureOptions;
@@ -111,7 +123,9 @@ export interface ExperimentsNormalized {
     inlineConst?: boolean;
     inlineEnum?: boolean;
     typeReexportsPresence?: boolean;
+    lazyBarrel?: boolean;
     nativeWatcher?: boolean;
+    deferImport?: boolean;
 }
 export type IgnoreWarningsNormalized = ((warning: WebpackError, compilation: Compilation) => boolean)[];
 export type OptimizationRuntimeChunkNormalized = false | {
@@ -143,6 +157,7 @@ export interface RspackOptionsNormalized {
     optimization: Optimization;
     plugins: Plugins;
     experiments: ExperimentsNormalized;
+    lazyCompilation?: false | LazyCompilationOptions;
     watch?: Watch;
     watchOptions: WatchOptions;
     devServer?: DevServer;