@rspack-canary/browser 1.5.0-canary-efb61069-20250820113456 → 1.5.2-canary-a37ca022-20250829094525

package/README.md

@@ -0,0 +1,15 @@
+<picture>
+  <img alt="Rspack Banner" src="https://assets.rspack.rs/rspack/rspack-banner.png">
+</picture>
+
+# @rspack/browser
+
+Rspack for running in the browser. This is still in early stage and may not follow the semver.
+
+## Documentation
+
+See <https://rspack.rs/api/javascript-api/browser> for details.
+
+## License
+
+Rspack is [MIT licensed](https://github.com/web-infra-dev/rspack/blob/main/LICENSE).

package/dist/Compiler.d.ts

@@ -94,6 +94,11 @@ declare class Compiler {
     cache: Cache;
     compilerPath: string;
     options: RspackOptionsNormalized;
+    /**
+     * Note: This is not a webpack public API, maybe removed in future.
+     * @internal
+     */
+    __internal_browser_require: (id: string) => unknown;
     constructor(context: string, options: RspackOptionsNormalized);
     get recordsInputPath(): never;
     get recordsOutputPath(): never;

package/dist/MultiWatching.d.ts

@@ -18,7 +18,7 @@ declare class MultiWatching {
      * @param compiler - the compiler
      */
     constructor(watchings: Watching[], compiler: MultiCompiler);
-    invalidate(callback: Callback<Error, void>): void;
+    invalidate(callback?: Callback<Error, void>): void;
     invalidateWithChangesAndRemovals(changedFiles?: Set<string>, removedFiles?: Set<string>, callback?: Callback<Error, void>): void;
     close(callback: Callback<Error, void>): void;
     suspend(): void;

package/dist/NativeWatchFileSystem.d.ts

@@ -16,4 +16,8 @@ export default class NativeWatchFileSystem implements WatchFileSystem {
     }, _startTime: number, options: Watchpack.WatchOptions, callback: (error: Error | null, fileTimeInfoEntries: Map<string, FileSystemInfoEntry | "ignore">, contextTimeInfoEntries: Map<string, FileSystemInfoEntry | "ignore">, changedFiles: Set<string>, removedFiles: Set<string>) => void, callbackUndelayed: (fileName: string, changeTime: number) => void): Watcher;
     getNativeWatcher(options: Watchpack.WatchOptions): binding.NativeWatcher;
     triggerEvent(kind: "change" | "remove" | "create", path: string): void;
+    formatWatchDependencies(dependencies: Iterable<string> & {
+        added?: Iterable<string>;
+        removed?: Iterable<string>;
+    }): [string[], string[]];
 }

package/dist/browser/BrowserHttpImportEsmPlugin.d.ts

@@ -0,0 +1,28 @@
+import type { Compiler } from ".";
+interface BrowserHttpImportPluginOptions {
+    /**
+     * ESM CDN domain
+     */
+    domain: string | ((request: string, packageName: string) => string);
+    /**
+     * Specify ESM CDN URL for dependencies.
+     */
+    dependencyUrl?: Record<string, string | undefined> | ((packageName: string) => string | undefined);
+    /**
+     * Specify versions for dependencies.
+     * Default to "latest" if not specified.
+     */
+    dependencyVersions?: Record<string, string | undefined>;
+}
+/**
+ * Convert imports of dependencies in node modules to http imports from esm cdn.
+ */
+export declare class BrowserHttpImportEsmPlugin {
+    private options;
+    constructor(options: BrowserHttpImportPluginOptions);
+    apply(compiler: Compiler): void;
+    resolveWithUrlIssuer(request: string, issuer: URL): string;
+    resolveNodeModule(request: string, packageName: string): string;
+    isNodeModule(request: string): boolean;
+}
+export {};

package/dist/browser/BrowserRequire.d.ts

@@ -0,0 +1,32 @@
+import type { Compiler } from "../Compiler";
+type BrowserRequire = typeof Compiler.prototype.__internal_browser_require;
+/**
+ * Represents the runtime context for CommonJS modules in a browser environment.
+ */
+interface CommonJsRuntime {
+    module: any;
+    exports: any;
+    require: BrowserRequire;
+}
+interface BrowserRequirePluginOptions {
+    /**
+     * This function defines how to execute CommonJS code.
+     */
+    execute: (code: string, runtime: CommonJsRuntime) => void;
+}
+/**
+ * This plugin inject browser-compatible `require` function to the `Compiler`.
+ * 1. It resolves the JavaScript in the memfs with Node.js resolution algorithm rather than in the host filesystem.
+ * 2. It transform ESM to CommonJS which will be executed with a user-defined `execute` function.
+ */
+export declare class BrowserRequirePlugin {
+    private options;
+    /**
+     * This is an unsafe way to execute code in the browser using `new Function`.
+     * It is your responsibility to ensure that your application is not vulnerable to attacks due to this function.
+     */
+    static unsafeExecute: (code: string, runtime: CommonJsRuntime) => void;
+    constructor(options: BrowserRequirePluginOptions);
+    apply(compiler: Compiler): void;
+}
+export {};

package/dist/browser/index.d.ts

@@ -1,4 +1,6 @@
 export * from "../index";
+export { BrowserHttpImportEsmPlugin } from "./BrowserHttpImportEsmPlugin";
+export { BrowserRequirePlugin } from "./BrowserRequire";
 export declare const builtinMemFs: {
     fs: import("memfs").IFs;
     volume: import("memfs").Volume;

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

@@ -5,7 +5,8 @@ export declare class ExternalsPlugin extends RspackBuiltinPlugin {
     #private;
     private type;
     private externals;
+    private placeInInitial?;
     name: BuiltinPluginName;
-    constructor(type: string, externals: Externals);
+    constructor(type: string, externals: Externals, placeInInitial?: boolean | undefined);
     raw(): BuiltinPlugin | undefined;
 }

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

@@ -1,22 +1,8 @@
 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];
+        _args: [currentActiveModules: () => Set<string>, entries: boolean, imports: boolean, client: string, test?: RegExp | ((module: Module) => boolean) | undefined];
         affectedHooks: "done" | "compilation" | "run" | "afterDone" | "thisCompilation" | "invalid" | "compile" | "normalModuleFactory" | "contextModuleFactory" | "initialize" | "shouldEmit" | "infrastructureLog" | "beforeRun" | "emit" | "assetEmitted" | "afterEmit" | "failed" | "shutdown" | "watchRun" | "watchClose" | "environment" | "afterEnvironment" | "afterPlugins" | "afterResolvers" | "make" | "beforeCompile" | "afterCompile" | "finishMake" | "entryOption" | "additionalPass" | undefined;
         raw(compiler: import("../..").Compiler): import("../../binding").BuiltinPlugin;
         apply(compiler: import("../..").Compiler): void;

package/dist/config/adapterRuleUse.d.ts

@@ -322,8 +322,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 | SourceMap, 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;