@rspack/browser 2.0.0-beta.4 → 2.0.0-beta.6

package/dist/builtin-loader/swc/types.d.ts

@@ -24,9 +24,17 @@ export type SwcLoaderOptions = Config & {
         /**
          * Enable React Server Components support.
          */
-        reactServerComponents?: boolean;
+        reactServerComponents?: boolean | ReactServerComponentsOptions;
     };
 };
+export interface ReactServerComponentsOptions {
+    /**
+     * Whether to disable the compile-time check that reports errors when React
+     * client-only APIs (e.g. `useState`, `useEffect`) are imported in server
+     * components. Defaults to `false`.
+     */
+    disableClientApiChecks?: boolean;
+}
 export interface TerserCompressOptions {
     arguments?: boolean;
     arrows?: boolean;

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

@@ -1,5 +1,5 @@
 import { type Compiler, MultiCompiler } from '../..';
-import type { MiddlewareHandler } from '../../config/devServer';
+import type { DevServerMiddlewareHandler } from '../../config/devServer';
 export declare const LAZY_COMPILATION_PREFIX = "/_rspack/lazy/trigger";
 /**
  * Create a middleware that handles lazy compilation requests from the client.
@@ -9,4 +9,4 @@ export declare const LAZY_COMPILATION_PREFIX = "/_rspack/lazy/trigger";
  * Use this middleware when integrating lazy compilation into a
  * custom development server instead of relying on the built-in server.
  */
-export declare const lazyCompilationMiddleware: (compiler: Compiler | MultiCompiler) => MiddlewareHandler;
+export declare const lazyCompilationMiddleware: (compiler: Compiler | MultiCompiler) => DevServerMiddlewareHandler;

package/dist/checkNodeVersion.d.ts

@@ -0,0 +1 @@
+declare function checkNodeVersion(): void;

package/dist/config/devServer.d.ts

@@ -7,32 +7,24 @@
  * Copyright (c) JS Foundation and other contributors
  * https://github.com/webpack/webpack-dev-server/blob/master/LICENSE
  */
-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 '..';
+import type { ReadStream } from 'node:fs';
+import type { IncomingMessage, ServerResponse } from 'node:http';
+import type { ServerOptions } from 'node:https';
+import type { Server as ConnectApplication } from 'connect-next';
+import type { Filter as ProxyFilter, Options as ProxyOptions } from 'http-proxy-middleware';
+import type { Options as OpenOptions } from 'open';
+import type { Compiler, Configuration, LiteralUnion, MultiCompiler, MultiStats, Stats, Watching } from '..';
 type Logger = ReturnType<Compiler['getInfrastructureLogger']>;
 type MultiWatching = MultiCompiler['watch'];
-type BasicServer = import('net').Server | import('tls').Server;
-type ReadStream = import('fs').ReadStream;
-type IncomingMessage = import('http').IncomingMessage;
-type ServerResponse = import('http').ServerResponse;
-type ServerOptions = import('https').ServerOptions & {
-    spdy?: {
-        plain?: boolean | undefined;
-        ssl?: boolean | undefined;
-        'x-forwarded-for'?: string | undefined;
-        protocol?: string | undefined;
-        protocols?: string[] | undefined;
-    };
-};
+export type DevServerHost = LiteralUnion<'local-ip' | 'local-ipv4' | 'local-ipv6', string>;
+type BasicServer = import('node:net').Server | import('node:tls').Server;
+export type DevServerOpenOptions = OpenOptions;
 type ResponseData = {
     data: Buffer | ReadStream;
     byteLength: number;
 };
 type ModifyResponseData<RequestInternal extends IncomingMessage = IncomingMessage, ResponseInternal extends ServerResponse = ServerResponse> = (req: RequestInternal, res: ResponseInternal, data: Buffer | ReadStream, byteLength: number) => ResponseData;
-type Headers = {
+export type DevServerHeaders = {
     key: string;
     value: string;
 }[] | Record<string, string | string[]>;
@@ -40,7 +32,6 @@ type OutputFileSystem = import('..').OutputFileSystem & {
     statSync: import('fs').StatSyncFn;
     readFileSync: typeof import('fs').readFileSync;
 };
-type RspackConfiguration = import('..').Configuration;
 type Port = number | LiteralUnion<'auto', string>;
 type HistoryContext = {
     readonly match: RegExpMatchArray;
@@ -53,37 +44,36 @@ type Rewrite = {
     readonly to: string | RegExp | RewriteTo;
 };
 type HistoryApiFallbackOptions = {
-    readonly disableDotRule?: true | undefined;
-    readonly htmlAcceptHeaders?: readonly string[] | undefined;
-    readonly index?: string | undefined;
-    readonly logger?: typeof console.log | undefined;
-    readonly rewrites?: readonly Rewrite[] | undefined;
-    readonly verbose?: boolean | undefined;
+    readonly disableDotRule?: true;
+    readonly htmlAcceptHeaders?: readonly string[];
+    readonly index?: string;
+    readonly logger?: typeof console.log;
+    readonly rewrites?: readonly Rewrite[];
+    readonly verbose?: boolean;
 };
 type DevMiddlewareOptions<RequestInternal extends IncomingMessage = IncomingMessage, ResponseInternal extends ServerResponse = ServerResponse> = {
     mimeTypes?: {
         [key: string]: string;
-    } | undefined;
-    mimeTypeDefault?: string | undefined;
-    writeToDisk?: boolean | ((targetPath: string) => boolean) | undefined;
-    methods?: string[] | undefined;
+    };
+    mimeTypeDefault?: string;
+    writeToDisk?: boolean | ((targetPath: string) => boolean);
+    methods?: string[];
     headers?: any;
-    publicPath?: NonNullable<RspackConfiguration['output']>['publicPath'];
-    stats?: RspackConfiguration['stats'];
-    serverSideRender?: boolean | undefined;
-    outputFileSystem?: OutputFileSystem | undefined;
-    index?: string | boolean | undefined;
-    modifyResponseData?: ModifyResponseData<RequestInternal, ResponseInternal> | undefined;
-    etag?: 'strong' | 'weak' | undefined;
-    lastModified?: boolean | undefined;
+    publicPath?: NonNullable<Configuration['output']>['publicPath'];
+    stats?: Configuration['stats'];
+    serverSideRender?: boolean;
+    outputFileSystem?: OutputFileSystem;
+    index?: string | boolean;
+    modifyResponseData?: ModifyResponseData<RequestInternal, ResponseInternal>;
+    etag?: 'strong' | 'weak';
+    lastModified?: boolean;
     cacheControl?: string | number | boolean | {
         maxAge?: number;
         immutable?: boolean;
-    } | undefined;
-    cacheImmutable?: boolean | undefined;
+    };
+    cacheImmutable?: boolean;
 };
 type BasicApplication = any;
-type BonjourServer = Record<string, any>;
 type ChokidarWatchOptions = {
     [key: string]: any;
 };
@@ -93,46 +83,44 @@ type ServeIndexOptions = {
 type ServeStaticOptions = {
     [key: string]: any;
 };
-type HttpProxyMiddlewareOptionsFilter = any;
-type Request = IncomingMessage;
-type Response = ServerResponse;
 type WatchFiles = {
     paths: string | string[];
-    options?: (ChokidarWatchOptions & {
+    options?: ChokidarWatchOptions & {
         aggregateTimeout?: number;
         ignored?: ChokidarWatchOptions['ignored'];
         poll?: number | boolean;
-    }) | undefined;
+    };
 };
-type Static = {
-    directory?: string | undefined;
-    publicPath?: string | string[] | undefined;
-    serveIndex?: boolean | ServeIndexOptions | undefined;
-    staticOptions?: ServeStaticOptions | undefined;
+export type DevServerStaticItem = {
+    directory?: string;
+    publicPath?: string | string[];
+    serveIndex?: boolean | ServeIndexOptions;
+    staticOptions?: ServeStaticOptions;
     watch?: boolean | (ChokidarWatchOptions & {
         aggregateTimeout?: number;
         ignored?: ChokidarWatchOptions['ignored'];
         poll?: number | boolean;
-    }) | undefined;
+    });
 };
-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;
+export type DevServerStatic = string | boolean | DevServerStaticItem | (string | DevServerStaticItem)[];
+type ServerType<A extends BasicApplication, S extends BasicServer> = LiteralUnion<'http' | 'https' | 'http2', string> | ((arg0: ServerOptions, arg1: A) => S);
+type ServerConfiguration<A extends BasicApplication, S extends BasicServer> = {
+    type?: ServerType<A, S>;
+    options?: ServerOptions;
 };
 type WebSocketServerConfiguration = {
-    type?: string | Function | undefined;
-    options?: Record<string, any> | undefined;
+    type?: string | Function;
+    options?: Record<string, any>;
 };
 type NextFunction = (err?: any) => void;
-type ProxyConfigArrayItem = {
-    path?: HttpProxyMiddlewareOptionsFilter;
-    context?: HttpProxyMiddlewareOptionsFilter;
-} & {
-    bypass?: ByPass;
-} & HttpProxyMiddlewareOptions;
-type ByPass = (req: Request, res: Response, proxyConfig: ProxyConfigArrayItem) => any;
-type ProxyConfigArray = (ProxyConfigArrayItem | ((req?: Request, res?: Response, next?: NextFunction) => ProxyConfigArrayItem))[];
+export type DevServerProxyConfigArrayItem = {
+    /**
+     * Alias for `pathFilter` in `http-proxy-middleware` options.
+     * When both `context` and `pathFilter` are provided, `pathFilter` takes precedence.
+     */
+    context?: ProxyFilter;
+} & ProxyOptions;
+export type DevServerProxyConfigArray = (DevServerProxyConfigArrayItem | ((req?: IncomingMessage, res?: ServerResponse, next?: NextFunction) => DevServerProxyConfigArrayItem))[];
 type Callback = (stats?: Stats | MultiStats) => any;
 type DevMiddlewareContext<_RequestInternal extends IncomingMessage = IncomingMessage, _ResponseInternal extends ServerResponse = ServerResponse> = {
     state: boolean;
@@ -144,171 +132,55 @@ type DevMiddlewareContext<_RequestInternal extends IncomingMessage = IncomingMes
     logger: Logger;
     outputFileSystem: OutputFileSystem;
 };
-type Server = any;
-export type MiddlewareHandler<RequestInternal extends Request = Request, ResponseInternal extends Response = Response> = (req: RequestInternal, res: ResponseInternal, next: NextFunction) => void | Promise<void>;
-type MiddlewareObject<RequestInternal extends Request = Request, ResponseInternal extends Response = Response> = {
+export type DevServerMiddlewareHandler<RequestInternal extends IncomingMessage = IncomingMessage, ResponseInternal extends ServerResponse = ServerResponse> = (req: RequestInternal, res: ResponseInternal, next: NextFunction) => void | Promise<void>;
+type DevServerMiddlewareObject<RequestInternal extends IncomingMessage = IncomingMessage, ResponseInternal extends ServerResponse = ServerResponse> = {
     name?: string;
     path?: string;
-    middleware: MiddlewareHandler<RequestInternal, ResponseInternal>;
-};
-export type Middleware<RequestInternal extends Request = Request, ResponseInternal extends Response = Response> = MiddlewareObject<RequestInternal, ResponseInternal> | MiddlewareHandler<RequestInternal, ResponseInternal>;
-type OpenApp = {
-    name?: string | undefined;
-    arguments?: string[] | undefined;
-};
-type Open = {
-    app?: string | string[] | OpenApp | undefined;
-    target?: string | string[] | undefined;
+    middleware: DevServerMiddlewareHandler<RequestInternal, ResponseInternal>;
 };
+export type DevServerMiddleware = DevServerMiddlewareObject | DevServerMiddlewareHandler;
 type OverlayMessageOptions = boolean | ((error: Error) => void);
-type WebSocketURL = {
-    hostname?: string | undefined;
-    password?: string | undefined;
-    pathname?: string | undefined;
-    port?: string | number | undefined;
-    protocol?: string | undefined;
-    username?: string | undefined;
-};
-type ClientConfiguration = {
-    logging?: 'none' | 'error' | 'warn' | 'info' | 'log' | 'verbose' | undefined;
+export type DevServerWebSocketURL = {
+    hostname?: string;
+    password?: string;
+    pathname?: string;
+    port?: string | number;
+    protocol?: string;
+    username?: string;
+};
+export type DevServerClient = {
+    logging?: 'none' | 'error' | 'warn' | 'info' | 'log' | 'verbose';
     overlay?: boolean | {
         warnings?: OverlayMessageOptions;
         errors?: OverlayMessageOptions;
         runtimeErrors?: OverlayMessageOptions;
-    } | undefined;
-    progress?: boolean | undefined;
-    reconnect?: number | boolean | undefined;
-    webSocketTransport?: string | undefined;
-    webSocketURL?: string | WebSocketURL | undefined;
-};
-export type DevServerOptions<A extends BasicApplication = BasicApplication, S extends BasicServer = import('http').Server<typeof import('http').IncomingMessage, typeof import('http').ServerResponse>> = {
-    ipc?: string | boolean | undefined;
-    host?: string | undefined;
-    port?: Port | undefined;
-    hot?: boolean | 'only' | undefined;
-    liveReload?: boolean | undefined;
-    devMiddleware?: DevMiddlewareOptions | undefined;
-    compress?: boolean | undefined;
-    allowedHosts?: string | string[] | undefined;
-    historyApiFallback?: boolean | HistoryApiFallbackOptions | 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;
-    app?: (() => Promise<A>) | undefined;
-    webSocketServer?: string | boolean | WebSocketServerConfiguration | undefined;
-    proxy?: ProxyConfigArray | undefined;
-    open?: string | boolean | Open | (string | Open)[] | undefined;
-    setupExitSignals?: boolean | undefined;
-    client?: boolean | ClientConfiguration | undefined;
-    headers?: Headers | ((req: Request, res: Response, context: DevMiddlewareContext | undefined) => Headers) | undefined;
-    onListening?: ((devServer: Server) => void) | undefined;
-    setupMiddlewares?: ((middlewares: Middleware[], devServer: Server) => Middleware[]) | undefined;
+    };
+    progress?: boolean;
+    reconnect?: number | boolean;
+    webSocketTransport?: LiteralUnion<'ws', string>;
+    webSocketURL?: string | DevServerWebSocketURL;
+};
+export type DevServerOptions<A extends BasicApplication = ConnectApplication, S extends BasicServer = BasicServer> = {
+    ipc?: string | boolean;
+    host?: DevServerHost;
+    port?: Port;
+    hot?: boolean | 'only';
+    liveReload?: boolean;
+    devMiddleware?: DevMiddlewareOptions;
+    compress?: boolean;
+    allowedHosts?: LiteralUnion<'auto' | 'all', string> | string[];
+    historyApiFallback?: boolean | HistoryApiFallbackOptions;
+    watchFiles?: string | string[] | WatchFiles | (string | WatchFiles)[];
+    static?: DevServerStatic;
+    server?: ServerType<A, S> | ServerConfiguration<A, S>;
+    app?: () => Promise<A>;
+    webSocketServer?: boolean | LiteralUnion<'ws', string> | WebSocketServerConfiguration;
+    proxy?: DevServerProxyConfigArray;
+    open?: string | boolean | OpenOptions | (string | OpenOptions)[];
+    setupExitSignals?: boolean;
+    client?: boolean | DevServerClient;
+    headers?: DevServerHeaders | ((req: IncomingMessage, res: ServerResponse, context: DevMiddlewareContext | undefined) => DevServerHeaders);
+    onListening?: (devServer: any) => void;
+    setupMiddlewares?: (middlewares: DevServerMiddleware[], devServer: any) => DevServerMiddleware[];
 };
-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/types.d.ts

@@ -809,10 +809,10 @@ export type JavascriptParserOptions = {
      */
     dynamicImportFetchPriority?: 'low' | 'high' | 'auto';
     /**
-     * Enable or disable evaluating import.meta.
-     * @default true
+     * Enable or disable evaluating import.meta. Set to 'preserve-unknown' to preserve unknown properties for runtime evaluation.
+     * @default 'preserve-unknown'
      */
-    importMeta?: boolean;
+    importMeta?: boolean | 'preserve-unknown';
     /**
      * Enable parsing of new URL() syntax.
      * @default true
@@ -846,6 +846,8 @@ export type JavascriptParserOptions = {
     importExportsPresence?: ExportsPresence;
     /** Warn or error for conflicting re-exports */
     reexportExportsPresence?: ExportsPresence;
+    /** Handle the this context correctly according to the spec for namespace objects. */
+    strictThisContextOnImports?: boolean;
     /** Provide custom syntax for Worker parsing, commonly used to support Worklet */
     worker?: string[] | boolean;
     /** Override the module to strict or non-strict. */
@@ -1435,7 +1437,8 @@ export type StatsOptions = {
     errorsCount?: boolean;
     /**
      * Enables or disables the use of colors in the output.
-     * @default false
+     * When undefined, defaults to true if the environment supports color (TTY, FORCE_COLOR, or NO_COLOR unset), otherwise false.
+     * @default environment-dependent (see above)
      */
     colors?: boolean | StatsColorOptions;
     /**
@@ -2226,10 +2229,10 @@ export type WatchOptions = {
     stdin?: boolean;
 };
 /**
- * Options for devServer, it based on `webpack-dev-server@5`
+ * Options for dev server
  * */
 export type DevServer = DevServerOptions;
-export type { Middleware as DevServerMiddleware } from './devServer';
+export type { DevServerClient, DevServerHeaders, DevServerHost, DevServerMiddleware, DevServerMiddlewareHandler, DevServerOpenOptions, DevServerProxyConfigArray, DevServerProxyConfigArrayItem, DevServerStatic, DevServerStaticItem, DevServerWebSocketURL, } from './devServer';
 /**
  * Ignore specific warnings.
  */

package/dist/container/ContainerPlugin.d.ts

@@ -2,13 +2,14 @@ import { type BuiltinPlugin, BuiltinPluginName } from '../binding';
 import { RspackBuiltinPlugin } from '../builtin-plugin/base';
 import type { Compiler } from '../Compiler';
 import type { EntryRuntime, FilenameTemplate, LibraryOptions } from '../config';
+import { type ShareScope } from '../sharing/SharePlugin';
 export type ContainerPluginOptions = {
     exposes: Exposes;
     filename?: FilenameTemplate;
     library?: LibraryOptions;
     name: string;
     runtime?: EntryRuntime;
-    shareScope?: string;
+    shareScope?: ShareScope;
     enhanced?: boolean;
 };
 export type Exposes = (ExposesItem | ExposesObject)[] | ExposesObject;
@@ -25,7 +26,7 @@ export declare class ContainerPlugin extends RspackBuiltinPlugin {
     name: BuiltinPluginName;
     _options: {
         name: string;
-        shareScope: string;
+        shareScope: ShareScope;
         library: LibraryOptions;
         runtime: EntryRuntime | undefined;
         filename: string | undefined;

package/dist/container/ContainerReferencePlugin.d.ts

@@ -2,10 +2,11 @@ import { type BuiltinPlugin, BuiltinPluginName } from '../binding';
 import { RspackBuiltinPlugin } from '../builtin-plugin/base';
 import type { Compiler } from '../Compiler';
 import type { ExternalsType } from '../config';
+import { type ShareScope } from '../sharing/SharePlugin';
 export type ContainerReferencePluginOptions = {
     remoteType: ExternalsType;
     remotes: Remotes;
-    shareScope?: string;
+    shareScope?: ShareScope;
     enhanced?: boolean;
 };
 export type Remotes = (RemotesItem | RemotesObject)[] | RemotesObject;
@@ -16,7 +17,7 @@ export type RemotesObject = {
 };
 export type RemotesConfig = {
     external: RemotesItem | RemotesItems;
-    shareScope?: string;
+    shareScope?: ShareScope;
 };
 export declare class ContainerReferencePlugin extends RspackBuiltinPlugin {
     name: BuiltinPluginName;
@@ -24,7 +25,7 @@ export declare class ContainerReferencePlugin extends RspackBuiltinPlugin {
         remoteType: ExternalsType;
         remotes: [string, {
             external: string[];
-            shareScope: string;
+            shareScope: ShareScope;
         }][];
         enhanced: boolean;
     };

package/dist/container/ModuleFederationPlugin.d.ts

@@ -1,5 +1,6 @@
 import type { Compiler } from '../Compiler';
 import type { ExternalsType } from '../config';
+import type { ShareScope } from '../sharing/SharePlugin';
 import { type ModuleFederationManifestPluginOptions } from './ModuleFederationManifestPlugin';
 import type { ModuleFederationPluginV1Options } from './ModuleFederationPluginV1';
 import { type ModuleFederationRuntimeExperimentsOptions } from './ModuleFederationRuntimePlugin';
@@ -26,7 +27,7 @@ interface RemoteInfo {
     name?: string;
     entry?: string;
     externalType: ExternalsType;
-    shareScope: string;
+    shareScope: ShareScope;
 }
 type RemoteInfos = Record<string, RemoteInfo[]>;
 export declare function getRemoteInfos(options: ModuleFederationPluginOptions): RemoteInfos;

package/dist/container/ModuleFederationPluginV1.d.ts

@@ -1,6 +1,6 @@
 import type { Compiler } from '../Compiler';
 import type { EntryRuntime, ExternalsType, LibraryOptions } from '../config';
-import { type Shared } from '../sharing/SharePlugin';
+import { type Shared, type ShareScope } from '../sharing/SharePlugin';
 import { type Exposes } from './ContainerPlugin';
 import { type Remotes } from './ContainerReferencePlugin';
 export interface ModuleFederationPluginV1Options {
@@ -11,7 +11,7 @@ export interface ModuleFederationPluginV1Options {
     remoteType?: ExternalsType;
     remotes?: Remotes;
     runtime?: EntryRuntime;
-    shareScope?: string;
+    shareScope?: ShareScope;
     shared?: Shared;
     enhanced?: boolean;
 }

package/dist/index.d.ts

@@ -1,3 +1,4 @@
+import './checkNodeVersion';
 import * as rspackExports from './exports';
 import { rspack as rspackFn } from './rspack';
 type Rspack = typeof rspackFn & typeof rspackExports & {