@rspack/core 2.0.8 → 2.1.0-beta.0

package/compiled/@swc/types/index.d.ts

@@ -113,6 +113,13 @@ interface JsMinifyOptions {
     safari10?: boolean;
     toplevel?: boolean;
     sourceMap?: boolean;
+    /**
+     * Serializable subset of terser-webpack-plugin's `extractComments`.
+     * `true` behaves like `'some'`.
+     */
+    extractComments?: boolean | "some" | "all" | {
+        regex: string;
+    };
     outputPath?: string;
     inlineSourcesContent?: boolean;
 }
@@ -654,7 +661,7 @@ interface JscConfig {
     };
 }
 type JscTarget = "es3" | "es5" | "es2015" | "es2016" | "es2017" | "es2018" | "es2019" | "es2020" | "es2021" | "es2022" | "es2023" | "es2024" | "esnext";
-type ParserConfig = TsParserConfig | EsParserConfig;
+type ParserConfig = TsParserConfig | EsParserConfig | FlowParserConfig;
 interface TsParserConfig {
     syntax: "typescript";
     /**
@@ -670,6 +677,37 @@ interface TsParserConfig {
      */
     dynamicImport?: boolean;
 }
+interface FlowParserConfig {
+    syntax: "flow";
+    /**
+     * Defaults to `false`.
+     */
+    jsx?: boolean;
+    /**
+     * Defaults to `false`.
+     */
+    all?: boolean;
+    /**
+     * Defaults to `false`.
+     */
+    requireDirective?: boolean;
+    /**
+     * Defaults to `false`.
+     */
+    enums?: boolean;
+    /**
+     * Defaults to `false`.
+     */
+    decorators?: boolean;
+    /**
+     * Defaults to `false`.
+     */
+    components?: boolean;
+    /**
+     * Defaults to `false`.
+     */
+    patternMatching?: boolean;
+}
 interface EsParserConfig {
     syntax: "ecmascript";
     /**
@@ -765,6 +803,7 @@ interface TransformConfig {
      * Effective only if `syntax` supports ƒ.
      */
     react?: ReactConfig;
+    reactCompiler?: boolean | ReactCompilerOptions;
     constModules?: ConstModulesConfig;
     /**
      * Defaults to null, which skips optimizer pass.
@@ -793,6 +832,92 @@ interface TransformConfig {
     verbatimModuleSyntax?: boolean;
     tsEnumIsMutable?: boolean;
 }
+interface ReactCompilerOptions {
+    /**
+     * Which functions to compile.
+     *
+     * Defaults to `"infer"`.
+     */
+    compilationMode?: "infer" | "syntax" | "annotation" | "all";
+    /**
+     * What to do when a function cannot be compiled.
+     *
+     * Defaults to `"none"`.
+     */
+    panicThreshold?: "none" | "critical_errors" | "all_errors";
+    /**
+     * React runtime version target.
+     *
+     * Defaults to `"19"`.
+     */
+    target?: "17" | "18" | "19";
+    /**
+     * Analyze and report diagnostics only; emit no transformed code.
+     *
+     * Defaults to `false`.
+     */
+    noEmit?: boolean;
+    /**
+     * Defaults to `"client"`.
+     */
+    outputMode?: "client" | "ssr" | "lint";
+    /**
+     * Compile even functions marked with opt-out directives.
+     *
+     * Defaults to `false`.
+     */
+    ignoreUseNoForget?: boolean;
+    /**
+     * Treat Flow suppression comments as opt-outs.
+     *
+     * Defaults to `true`.
+     */
+    flowSuppressions?: boolean;
+    /**
+     * Enable react-native-reanimated support.
+     *
+     * Defaults to `false`.
+     */
+    enableReanimated?: boolean;
+    /**
+     * Development mode.
+     *
+     * Defaults to `false`.
+     */
+    isDev?: boolean;
+    /**
+     * ESLint rules whose suppressions opt a function out of compilation.
+     */
+    eslintSuppressionRules?: string[];
+    /**
+     * Extra directives that opt a function out of compilation.
+     */
+    customOptOutDirectives?: string[];
+    /**
+     * Emit a gated version of each compiled function.
+     */
+    gating?: ReactCompilerGatingConfig;
+    /**
+     * Dynamically-gated compilation.
+     */
+    dynamicGating?: ReactCompilerDynamicGatingConfig;
+}
+interface ReactCompilerGatingConfig {
+    /**
+     * Module the gating import comes from.
+     */
+    source: string;
+    /**
+     * Imported specifier used as the gate.
+     */
+    importSpecifierName: string;
+}
+interface ReactCompilerDynamicGatingConfig {
+    /**
+     * Module the gating import comes from.
+     */
+    source: string;
+}
 interface ReactConfig {
     /**
      * Replace the function used when compiling JSX expressions.
@@ -1123,6 +1248,10 @@ interface Output {
      * Sourcemap (**not** base64 encoded)
      */
     map?: string;
+    /**
+     * Extracted comments collected during minification.
+     */
+    extractedComments?: string[];
 }
 interface MatchPattern {
 }
@@ -2137,4 +2266,4 @@ type WasmAnalysisOptions = {
 };
 type WasmPlugin = [wasmPackage: string, config: Record<string, any>];
 
-export type { Accessibility, AmdConfig, Argument, ArrayExpression, ArrayPattern, ArrowFunctionExpression, AssignmentExpression, AssignmentOperator, AssignmentPattern, AssignmentPatternProperty, AssignmentProperty, AwaitExpression, BaseModuleConfig, BigIntLiteral, BinaryExpression, BinaryOperator, BindingIdentifier, BlockStatement, BooleanLiteral, BreakStatement, CallExpression, CallerOptions, CatchClause, Class, ClassDeclaration, ClassExpression, ClassMember, ClassMethod, ClassMethodBase, ClassProperty, ClassPropertyBase, CommonJsConfig, ComputedPropName, ConditionalExpression, Config, ConstModulesConfig, Constructor, ContinueStatement, DebuggerStatement, Declaration, Decorator, DefaultDecl, DoWhileStatement, EmptyStatement, EnvConfig, Es6Config, EsParserConfig, ExportAllDeclaration, ExportDeclaration, ExportDefaultDeclaration, ExportDefaultExpression, ExportDefaultSpecifier, ExportNamedDeclaration, ExportNamespaceSpecifier, ExportSpecifier, ExprOrSpread, Expression, ExpressionStatement, Fn, ForInStatement, ForOfStatement, ForStatement, FunctionDeclaration, FunctionExpression, GetterProperty, GlobalPassOption, HasDecorator, HasSpan, Identifier, IfStatement, Import, ImportDeclaration, ImportDefaultSpecifier, ImportNamespaceSpecifier, ImportSpecifier, Invalid, JSXAttrValue, JSXAttribute, JSXAttributeName, JSXAttributeOrSpread, JSXClosingElement, JSXClosingFragment, JSXElement, JSXElementChild, JSXElementName, JSXEmptyExpression, JSXExpression, JSXExpressionContainer, JSXFragment, JSXMemberExpression, JSXNamespacedName, JSXObject, JSXOpeningElement, JSXOpeningFragment, JSXSpreadChild, JSXText, JsFormatOptions, JsMinifyOptions, JscConfig, JscTarget, KeyValuePatternProperty, KeyValueProperty, LabeledStatement, Literal, MatchPattern, MemberExpression, MetaProperty, MethodKind, MethodProperty, Module, ModuleConfig, ModuleDeclaration, ModuleExportName, ModuleItem, NamedExportSpecifier, NamedImportSpecifier, NewExpression, Node, NodeNextConfig, NullLiteral, NumericLiteral, ObjectExpression, ObjectPattern, ObjectPatternProperty, OptimizerConfig, OptionalChainingCall, OptionalChainingExpression, Options, Output, Param, ParenthesisExpression, ParseOptions, ParserConfig, Pattern, Plugin, PrivateMethod, PrivateName, PrivateProperty, Program, Property, PropertyName, ReactConfig, RegExpLiteral, RestElement, ReturnStatement, Script, SequenceExpression, SetterProperty, Span, SpreadElement, Statement, StaticBlock, StringLiteral, Super, SuperPropExpression, Swcrc, SwitchCase, SwitchStatement, SystemjsConfig, TaggedTemplateExpression, TemplateElement, TemplateLiteral, TerserCompressOptions, TerserEcmaVersion, TerserMangleOptions, TerserManglePropertiesOptions, ThisExpression, ThrowStatement, TransformConfig, TruePlusMinus, TryStatement, TsArrayType, TsAsExpression, TsCallSignatureDeclaration, TsConditionalType, TsConstAssertion, TsConstructSignatureDeclaration, TsConstructorType, TsEntityName, TsEnumDeclaration, TsEnumMember, TsEnumMemberId, TsExportAssignment, TsExpressionWithTypeArguments, TsExternalModuleReference, TsFnOrConstructorType, TsFnParameter, TsFunctionType, TsGetterSignature, TsImportEqualsDeclaration, TsImportType, TsIndexSignature, TsIndexedAccessType, TsInferType, TsInstantiation, TsInterfaceBody, TsInterfaceDeclaration, TsIntersectionType, TsKeywordType, TsKeywordTypeKind, TsLiteral, TsLiteralType, TsMappedType, TsMethodSignature, TsModuleBlock, TsModuleDeclaration, TsModuleName, TsModuleReference, TsNamespaceBody, TsNamespaceDeclaration, TsNamespaceExportDeclaration, TsNonNullExpression, TsOptionalType, TsParameterProperty, TsParameterPropertyParameter, TsParenthesizedType, TsParserConfig, TsPropertySignature, TsQualifiedName, TsRestType, TsSatisfiesExpression, TsSetterSignature, TsTemplateLiteralType, TsThisType, TsThisTypeOrIdent, TsTupleElement, TsTupleType, TsType, TsTypeAliasDeclaration, TsTypeAnnotation, TsTypeAssertion, TsTypeElement, TsTypeLiteral, TsTypeOperator, TsTypeOperatorOp, TsTypeParameter, TsTypeParameterDeclaration, TsTypeParameterInstantiation, TsTypePredicate, TsTypeQuery, TsTypeQueryExpr, TsTypeReference, TsUnionOrIntersectionType, TsUnionType, UmdConfig, UnaryExpression, UnaryOperator, UpdateExpression, UpdateOperator, VariableDeclaration, VariableDeclarationKind, VariableDeclarator, WasmAnalysisOptions, WasmPlugin, WhileStatement, WithStatement, YieldExpression };
+export type { Accessibility, AmdConfig, Argument, ArrayExpression, ArrayPattern, ArrowFunctionExpression, AssignmentExpression, AssignmentOperator, AssignmentPattern, AssignmentPatternProperty, AssignmentProperty, AwaitExpression, BaseModuleConfig, BigIntLiteral, BinaryExpression, BinaryOperator, BindingIdentifier, BlockStatement, BooleanLiteral, BreakStatement, CallExpression, CallerOptions, CatchClause, Class, ClassDeclaration, ClassExpression, ClassMember, ClassMethod, ClassMethodBase, ClassProperty, ClassPropertyBase, CommonJsConfig, ComputedPropName, ConditionalExpression, Config, ConstModulesConfig, Constructor, ContinueStatement, DebuggerStatement, Declaration, Decorator, DefaultDecl, DoWhileStatement, EmptyStatement, EnvConfig, Es6Config, EsParserConfig, ExportAllDeclaration, ExportDeclaration, ExportDefaultDeclaration, ExportDefaultExpression, ExportDefaultSpecifier, ExportNamedDeclaration, ExportNamespaceSpecifier, ExportSpecifier, ExprOrSpread, Expression, ExpressionStatement, FlowParserConfig, Fn, ForInStatement, ForOfStatement, ForStatement, FunctionDeclaration, FunctionExpression, GetterProperty, GlobalPassOption, HasDecorator, HasSpan, Identifier, IfStatement, Import, ImportDeclaration, ImportDefaultSpecifier, ImportNamespaceSpecifier, ImportSpecifier, Invalid, JSXAttrValue, JSXAttribute, JSXAttributeName, JSXAttributeOrSpread, JSXClosingElement, JSXClosingFragment, JSXElement, JSXElementChild, JSXElementName, JSXEmptyExpression, JSXExpression, JSXExpressionContainer, JSXFragment, JSXMemberExpression, JSXNamespacedName, JSXObject, JSXOpeningElement, JSXOpeningFragment, JSXSpreadChild, JSXText, JsFormatOptions, JsMinifyOptions, JscConfig, JscTarget, KeyValuePatternProperty, KeyValueProperty, LabeledStatement, Literal, MatchPattern, MemberExpression, MetaProperty, MethodKind, MethodProperty, Module, ModuleConfig, ModuleDeclaration, ModuleExportName, ModuleItem, NamedExportSpecifier, NamedImportSpecifier, NewExpression, Node, NodeNextConfig, NullLiteral, NumericLiteral, ObjectExpression, ObjectPattern, ObjectPatternProperty, OptimizerConfig, OptionalChainingCall, OptionalChainingExpression, Options, Output, Param, ParenthesisExpression, ParseOptions, ParserConfig, Pattern, Plugin, PrivateMethod, PrivateName, PrivateProperty, Program, Property, PropertyName, ReactCompilerDynamicGatingConfig, ReactCompilerGatingConfig, ReactCompilerOptions, ReactConfig, RegExpLiteral, RestElement, ReturnStatement, Script, SequenceExpression, SetterProperty, Span, SpreadElement, Statement, StaticBlock, StringLiteral, Super, SuperPropExpression, Swcrc, SwitchCase, SwitchStatement, SystemjsConfig, TaggedTemplateExpression, TemplateElement, TemplateLiteral, TerserCompressOptions, TerserEcmaVersion, TerserMangleOptions, TerserManglePropertiesOptions, ThisExpression, ThrowStatement, TransformConfig, TruePlusMinus, TryStatement, TsArrayType, TsAsExpression, TsCallSignatureDeclaration, TsConditionalType, TsConstAssertion, TsConstructSignatureDeclaration, TsConstructorType, TsEntityName, TsEnumDeclaration, TsEnumMember, TsEnumMemberId, TsExportAssignment, TsExpressionWithTypeArguments, TsExternalModuleReference, TsFnOrConstructorType, TsFnParameter, TsFunctionType, TsGetterSignature, TsImportEqualsDeclaration, TsImportType, TsIndexSignature, TsIndexedAccessType, TsInferType, TsInstantiation, TsInterfaceBody, TsInterfaceDeclaration, TsIntersectionType, TsKeywordType, TsKeywordTypeKind, TsLiteral, TsLiteralType, TsMappedType, TsMethodSignature, TsModuleBlock, TsModuleDeclaration, TsModuleName, TsModuleReference, TsNamespaceBody, TsNamespaceDeclaration, TsNamespaceExportDeclaration, TsNonNullExpression, TsOptionalType, TsParameterProperty, TsParameterPropertyParameter, TsParenthesizedType, TsParserConfig, TsPropertySignature, TsQualifiedName, TsRestType, TsSatisfiesExpression, TsSetterSignature, TsTemplateLiteralType, TsThisType, TsThisTypeOrIdent, TsTupleElement, TsTupleType, TsType, TsTypeAliasDeclaration, TsTypeAnnotation, TsTypeAssertion, TsTypeElement, TsTypeLiteral, TsTypeOperator, TsTypeOperatorOp, TsTypeParameter, TsTypeParameterDeclaration, TsTypeParameterInstantiation, TsTypePredicate, TsTypeQuery, TsTypeQueryExpr, TsTypeReference, TsUnionOrIntersectionType, TsUnionType, UmdConfig, UnaryExpression, UnaryOperator, UpdateExpression, UpdateOperator, VariableDeclaration, VariableDeclarationKind, VariableDeclarator, WasmAnalysisOptions, WasmPlugin, WhileStatement, WithStatement, YieldExpression };

package/compiled/@swc/types/package.json

@@ -1 +1 @@
-{"name":"@swc/types","author":"강동윤 <kdy1997.dev@gmail.com>","version":"0.1.26","license":"Apache-2.0","types":"index.d.ts","type":"commonjs"}
+{"name":"@swc/types","author":"강동윤 <kdy1997.dev@gmail.com>","version":"0.1.27","license":"Apache-2.0","types":"index.d.ts","type":"commonjs"}

package/compiled/http-proxy-middleware/index.d.ts

@@ -140,7 +140,10 @@ interface RequestHandler<TReq extends http.IncomingMessage = http.IncomingMessag
     (req: TReq, res: TRes, next?: TNext): Promise<void>;
     upgrade: (req: TReq, socket: net.Socket, head: Buffer) => void;
 }
-type Filter<TReq extends http.IncomingMessage = http.IncomingMessage> = string | string[] | ((pathname: string, req: TReq) => boolean);
+type Filter<TReq extends http.IncomingMessage = http.IncomingMessage> = string | string[] | ((pathname: string, req: TReq) => boolean | string | RegExpMatchArray | null);
+/**
+ * @see {@link https://github.com/chimurai/http-proxy-middleware/tree/master#defineplugin-helper `definePlugin()`} to define a http-proxy-middleware plugin.
+ */
 interface Plugin<TReq extends http.IncomingMessage = http.IncomingMessage, TRes extends http.ServerResponse = http.ServerResponse> {
     (proxyServer: ProxyServer<TReq, TRes>, options: Options<TReq, TRes>): void;
 }
@@ -156,9 +159,13 @@ interface OnProxyEvent<TReq extends http.IncomingMessage = http.IncomingMessage,
     econnreset?: (err: Error, req: TReq, res: TRes, target: string | Partial<URL>) => void;
 }
 type Logger = Pick<Console, 'info' | 'warn' | 'error'>;
-type PathRewriteConfig<TReq extends http.IncomingMessage = http.IncomingMessage> = {
+type PathRewriteConfig<TReq extends http.IncomingMessage = http.IncomingMessage, TRes extends http.ServerResponse = http.ServerResponse> = {
     [regexp: string]: string;
-} | ((path: string, req: TReq) => string | undefined) | ((path: string, req: TReq) => Promise<string>);
+} | ((path: string, req: TReq, 
+/** `res` is undefined in WebSocket upgrade flows. */
+res?: TRes | undefined, options?: Options<TReq, TRes>) => string | undefined) | ((path: string, req: TReq, 
+/** `res` is undefined in WebSocket upgrade flows. */
+res?: TRes | undefined, options?: Options<TReq, TRes>) => Promise<string | undefined>);
 interface Options<TReq extends http.IncomingMessage = http.IncomingMessage, TRes extends http.ServerResponse = http.ServerResponse> extends ProxyServerOptions {
     /**
      * Narrow down requests to proxy or not.
@@ -178,9 +185,13 @@ interface Options<TReq extends http.IncomingMessage = http.IncomingMessage, TRes
      *   }
      * });
      * ```
+     * @since v0.15.0
+     * @since v0.21.0 - support `async` function
+     * @since v4.1.0 - `res` and `options` parameters added to custom function
+     *
      * @link https://github.com/chimurai/http-proxy-middleware/blob/master/recipes/pathRewrite.md
      */
-    pathRewrite?: PathRewriteConfig<TReq>;
+    pathRewrite?: PathRewriteConfig<TReq, TRes>;
     /**
      * Access the internal `httpxy` server instance to customize behavior
      *
@@ -225,17 +236,24 @@ interface Options<TReq extends http.IncomingMessage = http.IncomingMessage, TRes
     on?: OnProxyEvent<TReq, TRes>;
     /**
      * Dynamically set the {@link Options.target `options.target`}.
+     *
      * @example
      * ```js
      * createProxyMiddleware({
-     *   router: async (req) => {
+     *   router: async (req, res, options) => {
      *     return 'http://127:0.0.1:3000';
      *   }
      * });
      * ```
+     *
+     * @since v0.16.0
+     * @since v4.1.0 - `res` and `options` parameters added to router function signature
+     *
+     * NOTE: `res` is undefined in WebSocket upgrade flows.
+     *
      * @link https://github.com/chimurai/http-proxy-middleware/blob/master/recipes/router.md
      */
-    router?: Record<string, ProxyServerOptions['target']> | ((req: TReq) => ProxyServerOptions['target']) | ((req: TReq) => Promise<ProxyServerOptions['target']>);
+    router?: Record<string, ProxyServerOptions['target']> | ((req: TReq, res: TRes | undefined, options: Options<TReq, TRes>) => ProxyServerOptions['target']) | ((req: TReq, res: TRes | undefined, options: Options<TReq, TRes>) => Promise<ProxyServerOptions['target']>);
     /**
      * Log information from http-proxy-middleware
      * @example
@@ -331,10 +349,26 @@ declare function createProxyMiddleware<TReq extends http.IncomingMessage = http.
 type Interceptor<TReq = http.IncomingMessage, TRes = http.ServerResponse> = (buffer: Buffer, proxyRes: http.IncomingMessage, req: TReq, res: TRes) => Promise<Buffer | string>;
 /**
  * Intercept responses from upstream.
- * Automatically decompress (deflate, gzip, brotli).
+ * Automatically decompress (deflate, gzip, brotli, zstd).
  * Give developer the opportunity to modify intercepted Buffer and http.ServerResponse
  *
  * NOTE: must set options.selfHandleResponse=true (prevent automatic call of res.end())
+ *
+ * @example
+ *
+ * ```ts
+ * createProxyMiddleware({
+ *   target: 'http://example.com',
+ *   selfHandleResponse: true, // MUST set selfHandleResponse=true
+ *   on: {
+ *     proxyRes: responseInterceptor(async (buffer, proxyRes, req, res) => {
+ *       // modify intercepted buffer and return modified buffer
+ *       const modifiedBuffer = Buffer.from(buffer.toString().replace(/Example/g, 'Demo'), 'utf8');
+ *       return modifiedBuffer;
+ *     }),
+ *   }
+ * });
+ * ```
  */
 declare function responseInterceptor<TReq extends http.IncomingMessage = http.IncomingMessage, TRes extends http.ServerResponse = http.ServerResponse>(interceptor: Interceptor<TReq, TRes>): (proxyRes: http.IncomingMessage, req: TReq, res: TRes) => Promise<void>;
 
@@ -343,9 +377,47 @@ type BodyParserLikeRequest = http.IncomingMessage & {
 };
 /**
  * Fix proxied body if bodyParser is involved.
+ *
+ * @example
+ * ```ts
+ * createProxyMiddleware({
+ *   target: 'http://example.com',
+ *   on: {
+ *     proxyReq: fixRequestBody,
+ *   }
+ * });
+ * ```
+ *
+ * Alternative solution without using `fixRequestBody()`: put `http-proxy-middleware` before `bodyParser` in the middleware stack.
+ *
+ * @see {@link https://github.com/chimurai/http-proxy-middleware/issues/40 Github issue #40 - POST request body is not proxied}
  */
 declare function fixRequestBody<TReq extends BodyParserLikeRequest = BodyParserLikeRequest>(proxyReq: http.ClientRequest, req: TReq): void;
 
+/**
+ * Helper function to define a http-proxy-middleware plugin
+ * @see proxyServer {@link ProxyServer} - proxy server instance to which the plugin is being applied
+ * @see options {@link Options} - options object passed to `createProxyMiddleware`
+ *
+ * @example defining a plugin
+ * ```js
+ * export const myPlugin = definePlugin((proxyServer, options) => {
+ *   // plugin implementation
+ * });
+ * ```
+ *
+ * @example using a plugin
+ * ```js
+ * createProxyMiddleware({
+ *   target: 'http://example.com',
+ *   plugins: [myPlugin],
+ * });
+ * ```
+ *
+ * @since 4.1.0
+ */
+declare function definePlugin<TReq extends http.IncomingMessage = http.IncomingMessage, TRes extends http.ServerResponse = http.ServerResponse>(fn: Plugin<TReq, TRes>): Plugin<TReq, TRes>;
+
 /**
  * Subscribe to {@link https://github.com/unjs/httpxy#events `httpxy` error events} to prevent server from crashing.
  * Errors are logged with {@link https://www.npmjs.com/package/debug debug} library.
@@ -378,5 +450,5 @@ declare const loggerPlugin: Plugin;
  */
 declare const proxyEventsPlugin: Plugin;
 
-export { createProxyMiddleware, debugProxyErrorsPlugin, errorResponsePlugin, fixRequestBody, loggerPlugin, proxyEventsPlugin, responseInterceptor };
+export { createProxyMiddleware, debugProxyErrorsPlugin, definePlugin, errorResponsePlugin, fixRequestBody, loggerPlugin, proxyEventsPlugin, responseInterceptor };
 export type { Filter, Options, Plugin, RequestHandler };

package/compiled/http-proxy-middleware/package.json

@@ -1 +1 @@
-{"name":"http-proxy-middleware","author":"Steven Chim","version":"4.0.0","license":"MIT","types":"index.d.ts","type":"module"}
+{"name":"http-proxy-middleware","author":"Steven Chim","version":"4.1.0","license":"MIT","types":"index.d.ts","type":"module"}

package/dist/ModuleGraph.d.ts

@@ -9,6 +9,7 @@ export default class ModuleGraph {
     getModule(dependency: Dependency): Module | null;
     getResolvedModule(dependency: Dependency): Module | null;
     getUsedExports(module: Module, runtime: string | string[]): string[] | boolean | null;
+    getProvidedExports(module: Module): true | string[] | null;
     getParentModule(dependency: Dependency): Module | null;
     getIssuer(module: Module): Module | null;
     getExportsInfo(module: Module): ExportsInfo;

package/dist/RuntimeGlobals.d.ts

@@ -348,13 +348,14 @@ export declare const isReservedRuntimeGlobal: (r: string, compilerRuntimeGlobals
 export declare function renderModulePrefix(_compilerOptions: RspackOptionsNormalized): string;
 export declare enum RuntimeVariable {
     Require = 0,
-    Modules = 1,
-    ModuleCache = 2,
-    Module = 3,
-    Exports = 4,
-    StartupExec = 5
+    Context = 1,
+    Modules = 2,
+    ModuleCache = 3,
+    Module = 4,
+    Exports = 5,
+    StartupExec = 6
 }
-export declare function renderRuntimeVariables(variable: RuntimeVariable, _compilerOptions?: RspackOptionsNormalized): string;
+export declare function renderRuntimeVariables(variable: RuntimeVariable, compilerOptions?: RspackOptionsNormalized): string;
 export declare function createCompilerRuntimeGlobals(compilerOptions?: RspackOptionsNormalized): Record<keyof typeof RuntimeGlobals, string>;
 declare const DefaultRuntimeGlobals: Record<"amdDefine" | "amdOptions" | "asyncModule" | "asyncModuleExportSymbol" | "baseURI" | "chunkCallback" | "chunkName" | "compatGetDefaultExport" | "compileWasm" | "createFakeNamespaceObject" | "createScript" | "createScriptUrl" | "currentRemoteGetScope" | "definePropertyGetters" | "ensureChunk" | "ensureChunkHandlers" | "ensureChunkIncludeEntries" | "entryModuleId" | "exports" | "externalInstallChunk" | "getChunkCssFilename" | "getChunkScriptFilename" | "getChunkUpdateCssFilename" | "getChunkUpdateScriptFilename" | "getFullHash" | "getTrustedTypesPolicy" | "getUpdateManifestFilename" | "global" | "harmonyModuleDecorator" | "hasCssModules" | "hasFetchPriority" | "hasOwnProperty" | "hmrDownloadManifest" | "hmrDownloadUpdateHandlers" | "hmrInvalidateModuleHandlers" | "hmrModuleData" | "hmrRuntimeStatePrefix" | "initializeSharing" | "instantiateWasm" | "interceptModuleExecution" | "loadScript" | "makeDeferredNamespaceObject" | "makeDeferredNamespaceObjectSymbol" | "makeNamespaceObject" | "module" | "moduleCache" | "moduleFactories" | "moduleFactoriesAddOnly" | "moduleId" | "moduleLoaded" | "nodeModuleDecorator" | "onChunksLoaded" | "prefetchChunk" | "prefetchChunkHandlers" | "preloadChunk" | "preloadChunkHandlers" | "publicPath" | "relativeUrl" | "require" | "requireScope" | "returnExportsFromRuntime" | "rspackUniqueId" | "rspackVersion" | "runtimeId" | "scriptNonce" | "shareScopeMap" | "startup" | "startupChunkDependencies" | "startupEntrypoint" | "startupNoDefault" | "startupOnlyAfter" | "startupOnlyBefore" | "system" | "systemContext" | "thisAsExports" | "uncaughtErrorHandler" | "wasmInstances", string>;
 export { DefaultRuntimeGlobals as RuntimeGlobals };

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

@@ -13,6 +13,7 @@ export type RsdoctorPluginOptions = {
         module?: boolean;
         cheap?: boolean;
     };
+    exportUsageGraph?: boolean;
 };
 declare const RsdoctorPluginImpl: {
     new (c?: RsdoctorPluginOptions | undefined): {

package/dist/config/adapterRuleUse.d.ts

@@ -1,7 +1,7 @@
 import type { AssetInfo, RawModuleRuleUse, RawOptions } from '@rspack/binding';
 import type { Compilation } from '../Compilation.js';
 import type { Compiler } from '../Compiler.js';
-import { type LoaderObject } from '../loader-runner/index.js';
+import type { LoaderObject } from '../loader-runner/index.js';
 import type { Logger } from '../logging/Logger.js';
 import type { Module } from '../Module.js';
 import type { ResolveRequest } from '../Resolver.js';

package/dist/config/defaults.d.ts

@@ -1,5 +1,5 @@
 import type { RspackOptionsNormalized } from './normalization.js';
-export declare const applyRspackOptionsDefaults: (options: RspackOptionsNormalized) => false | {
+export declare const applyRspackOptionsDefaults: (options: RspackOptionsNormalized, compilerIndex?: number) => false | {
     platform: {
         web: boolean | null | undefined;
         browser: boolean | null | undefined;

package/dist/config/normalization.d.ts

@@ -10,7 +10,7 @@
 import type { HttpUriPluginOptions } from '../builtin-plugin/index.js';
 import type { Compilation } from '../Compilation.js';
 import type WebpackError from '../lib/WebpackError.js';
-import type { Amd, AssetModuleFilename, Bail, BundlerInfoOptions, ChunkFilename, ChunkLoading, ChunkLoadingGlobal, Clean, Context, CrossOriginLoading, CssChunkFilename, CssFilename, Dependencies, DevServer, DevTool, DevtoolFallbackModuleFilenameTemplate, DevtoolModuleFilenameTemplate, DevtoolNamespace, EnabledLibraryTypes, EnabledWasmLoadingTypes, EntryDescription, Environment, Externals, ExternalsPresets, ExternalsType, Filename, GeneratorOptionsByModuleType, GlobalObject, HashDigest, HashDigestLength, HashFunction, HashSalt, HotUpdateChunkFilename, HotUpdateGlobal, HotUpdateMainFilename, Iife, ImportFunctionName, ImportMetaName, Incremental, InfrastructureLogging, LazyCompilationOptions, LibraryOptions, Loader, Mode, Name, Node, NoParseOption, Optimization, OutputModule, ParserOptionsByModuleType, Path, Performance, Plugins, PublicPath, Resolve, RspackOptions, RuleSetRules, ScriptType, SnapshotOptions, SourceMapFilename, StatsValue, StrictModuleErrorHandling, Target, TrustedTypes, UniqueName, WasmLoading, Watch, WatchOptions, WebassemblyModuleFilename, WorkerPublicPath } from './types.js';
+import type { Amd, AssetModuleFilename, Bail, BundlerInfoOptions, ChunkFilename, ChunkLoading, ChunkLoadingGlobal, Clean, Context, CrossOriginLoading, CssChunkFilename, CssFilename, Dependencies, DevServer, DevTool, DevtoolFallbackModuleFilenameTemplate, DevtoolModuleFilenameTemplate, DevtoolNamespace, EnabledLibraryTypes, EnabledWasmLoadingTypes, EntryDescription, Environment, Externals, ExternalsPresets, ExternalsType, Filename, GeneratorOptionsByModuleType, GlobalObject, HashDigest, HashDigestLength, HashFunction, HashSalt, HotUpdateChunkFilename, HotUpdateGlobal, HotUpdateMainFilename, Iife, ImportFunctionName, ImportMetaName, Incremental, InfrastructureLogging, LazyCompilationOptions, LibraryOptions, Loader, Mode, Name, Node, NoParseOption, Optimization, OutputModule, ParserOptionsByModuleType, Path, Performance, Plugins, PublicPath, Resolve, RspackOptions, RuleSetRules, ScriptType, SourceMapFilename, StatsValue, StrictModuleErrorHandling, Target, TrustedTypes, UniqueName, WasmLoading, Watch, WatchOptions, WebassemblyModuleFilename, WorkerPublicPath } from './types.js';
 export declare const getNormalizedRspackOptions: (config: RspackOptions) => RspackOptionsNormalized;
 export type EntryDynamicNormalized = () => Promise<EntryStaticNormalized>;
 export type EntryNormalized = EntryDynamicNormalized | EntryStaticNormalized;
@@ -77,22 +77,25 @@ export interface ModuleOptionsNormalized {
     generator: GeneratorOptionsByModuleType;
     noParse?: NoParseOption;
 }
-export type CacheNormalized = boolean | {
+export type CacheNormalized = false | {
     type: 'memory';
 } | {
     type: 'persistent';
     buildDependencies: string[];
-    version: string;
+    version?: string;
     snapshot: {
-        immutablePaths: (string | RegExp)[];
-        unmanagedPaths: (string | RegExp)[];
-        managedPaths: (string | RegExp)[];
+        immutablePaths?: (string | RegExp)[];
+        unmanagedPaths?: (string | RegExp)[];
+        managedPaths?: (string | RegExp)[];
     };
     storage: {
         type: 'filesystem';
-        directory: string;
+        directory?: string;
+        maxAge?: number;
+        maxGenerations?: number;
     };
     portable?: boolean;
+    readonly?: boolean;
 };
 export interface ExperimentsNormalized {
     asyncWebAssembly?: boolean;
@@ -104,6 +107,7 @@ export interface ExperimentsNormalized {
     deferImport?: boolean;
     sourceImport?: boolean;
     pureFunctions?: boolean;
+    runtimeMode?: 'webpack' | 'rspack';
 }
 export type IgnoreWarningsNormalized = ((warning: WebpackError, compilation: Compilation) => boolean)[];
 export type OptimizationRuntimeChunkNormalized = false | {
@@ -129,7 +133,6 @@ export interface RspackOptionsNormalized {
     devtool?: DevTool;
     node: Node;
     loader: Loader;
-    snapshot: SnapshotOptions;
     cache?: CacheNormalized;
     stats: StatsValue;
     optimization: Optimization;

package/dist/config/types.d.ts

@@ -932,6 +932,11 @@ export type JavascriptParserOptions = {
      * Enable magic comments for CommonJS require() expressions.
      */
     commonjsMagicComments?: boolean;
+    /**
+     * Enable or disable parsing `import { createRequire } from "module"` and evaluating createRequire().
+     * @default false
+     */
+    createRequire?: boolean | string;
     /** Whether to tolerant exportsPresence for type reexport */
     typeReexportsPresence?: 'no-tolerant' | 'tolerant' | 'tolerant-no-check';
     /** Whether to enable JSX parsing */
@@ -1342,7 +1347,6 @@ export type NodeOptions = {
  */
 export type Node = false | NodeOptions;
 export type Loader = Record<string, any>;
-export type SnapshotOptions = {};
 /**
  * Snapshot options for determining which files have been modified.
  */
@@ -1371,9 +1375,21 @@ export type CacheStorageOptions = {
     type: 'filesystem';
     /**
      * Cache directory path.
-     * @default 'node_modules/.cache/rspack'
+     * @default 'node_modules/.cache/rspack/<name>-<mode>-<compilerIndex>'
      */
     directory?: string;
+    /**
+     * Maximum age of unused filesystem cache in seconds. Must be an integer
+     * between 0 and 4294967295.
+     * @default 7 * 24 * 60 * 60
+     */
+    maxAge?: number;
+    /**
+     * Maximum number of filesystem cache generations to retain in the cache
+     * directory. Must be an integer between 0 and 4294967295.
+     * @default No generation count limit; maxAge cleanup still applies
+     */
+    maxGenerations?: number;
 };
 /**
  * Persistent cache options.
@@ -2302,6 +2318,12 @@ export type Experiments = {
      * @default false
      */
     pureFunctions?: boolean;
+    /**
+     * Select runtime proxy context behavior. `webpack` keeps the webpack startup hook,
+     * while `rspack` uses `__rspack_context`.
+     * @default "webpack"
+     */
+    runtimeMode?: 'webpack' | 'rspack';
 };
 export type Watch = boolean;
 /** Options for watch mode. */
@@ -2480,10 +2502,6 @@ export type RspackOptions = {
      * Options for the stats output.
      */
     stats?: StatsValue;
-    /**
-     * Options for snapshotting.
-     */
-    snapshot?: SnapshotOptions;
     /**
      * Optimization options.
      */