@rspack-debug/browser 0.0.0-alpha.0 → 1.6.4

package/dist/ResolverFactory.d.ts

@@ -0,0 +1,17 @@
+import binding from "./binding";
+import { type Resolve } from "./config";
+import { Resolver } from "./Resolver";
+export type ResolveOptionsWithDependencyType = Resolve & {
+    dependencyType?: string;
+    resolveToContext?: boolean;
+};
+export type WithOptions = {
+    withOptions: (options: ResolveOptionsWithDependencyType) => ResolverWithOptions;
+};
+export type ResolverWithOptions = Resolver & WithOptions;
+export declare class ResolverFactory {
+    #private;
+    static __to_binding(resolver_factory: ResolverFactory): binding.JsResolverFactory;
+    constructor(pnp: boolean, resolveOptions: Resolve, loaderResolveOptions: Resolve);
+    get(type: string, resolveOptions?: ResolveOptionsWithDependencyType): ResolverWithOptions;
+}

package/dist/RspackError.d.ts

@@ -0,0 +1,12 @@
+import type binding from "./binding";
+export type { RspackError } from "./binding";
+export type RspackSeverity = binding.JsRspackSeverity;
+export declare class NonErrorEmittedError extends Error {
+    constructor(error: Error);
+}
+export declare class DeadlockRiskError extends Error {
+    constructor(message: string);
+}
+export declare class ValidationError extends Error {
+    constructor(message: string);
+}

package/dist/RuleSetCompiler.d.ts

@@ -0,0 +1,9 @@
+declare class RuleSetCompiler {
+    references: Map<string, any>;
+    /**
+     * builtin references that should be serializable and passed to Rust.
+     */
+    builtinReferences: Map<string, any>;
+    constructor();
+}
+export { RuleSetCompiler };

package/dist/RuntimeGlobals.d.ts

@@ -0,0 +1,328 @@
+/**
+ * The following code is modified based on
+ * https://github.com/webpack/webpack/blob/v5.88.2/lib/RuntimeGlobals.js
+ *
+ * MIT Licensed
+ * Author Tobias Koppers \@sokra
+ * Copyright (c) JS Foundation and other contributors
+ * https://github.com/webpack/webpack/blob/main/LICENSE
+ */
+import type { JsRuntimeGlobals } from "./binding";
+export declare function __from_binding_runtime_globals(runtimeRequirements: JsRuntimeGlobals): Set<string>;
+export declare function __to_binding_runtime_globals(runtimeRequirements: Set<string>): JsRuntimeGlobals;
+export declare const RuntimeGlobals: {
+    /**
+     * the internal require function
+     */
+    readonly require: "__webpack_require__";
+    /**
+     * access to properties of the internal require function/object
+     */
+    readonly requireScope: "__webpack_require__.*";
+    /**
+     * the internal exports object
+     */
+    readonly exports: "__webpack_exports__";
+    /**
+     * top-level this need to be the exports object
+     */
+    readonly thisAsExports: "top-level-this-exports";
+    /**
+     * runtime need to return the exports of the last entry module
+     */
+    readonly returnExportsFromRuntime: "return-exports-from-runtime";
+    /**
+     * the internal module object
+     */
+    readonly module: "module";
+    /**
+     * the internal module object
+     */
+    readonly moduleId: "module.id";
+    /**
+     * the internal module object
+     */
+    readonly moduleLoaded: "module.loaded";
+    /**
+     * the bundle public path
+     */
+    readonly publicPath: "__webpack_require__.p";
+    /**
+     * the module id of the entry point
+     */
+    readonly entryModuleId: "__webpack_require__.s";
+    /**
+     * the module cache
+     */
+    readonly moduleCache: "__webpack_require__.c";
+    /**
+     * the module functions
+     */
+    readonly moduleFactories: "__webpack_require__.m";
+    /**
+     * the module functions, with only write access
+     */
+    readonly moduleFactoriesAddOnly: "__webpack_require__.m (add only)";
+    /**
+     * the chunk ensure function
+     */
+    readonly ensureChunk: "__webpack_require__.e";
+    /**
+     * an object with handlers to ensure a chunk
+     */
+    readonly ensureChunkHandlers: "__webpack_require__.f";
+    /**
+     * a runtime requirement if ensureChunkHandlers should include loading of chunk needed for entries
+     */
+    readonly ensureChunkIncludeEntries: "__webpack_require__.f (include entries)";
+    /**
+     * the chunk prefetch function
+     */
+    readonly prefetchChunk: "__webpack_require__.E";
+    /**
+     * an object with handlers to prefetch a chunk
+     */
+    readonly prefetchChunkHandlers: "__webpack_require__.F";
+    /**
+     * the chunk preload function
+     */
+    readonly preloadChunk: "__webpack_require__.G";
+    /**
+     * an object with handlers to preload a chunk
+     */
+    readonly preloadChunkHandlers: "__webpack_require__.H";
+    /**
+     * the exported property define getters function
+     */
+    readonly definePropertyGetters: "__webpack_require__.d";
+    /**
+     * define compatibility on export
+     */
+    readonly makeNamespaceObject: "__webpack_require__.r";
+    /**
+     * create a fake namespace object
+     */
+    readonly createFakeNamespaceObject: "__webpack_require__.t";
+    /**
+     * compatibility get default export
+     */
+    readonly compatGetDefaultExport: "__webpack_require__.n";
+    /**
+     * ES modules decorator
+     */
+    readonly harmonyModuleDecorator: "__webpack_require__.hmd";
+    /**
+     * node.js module decorator
+     */
+    readonly nodeModuleDecorator: "__webpack_require__.nmd";
+    /**
+     * the webpack hash
+     */
+    readonly getFullHash: "__webpack_require__.h";
+    /**
+     * an object containing all installed WebAssembly.Instance export objects keyed by module id
+     */
+    readonly wasmInstances: "__webpack_require__.w";
+    /**
+     * instantiate a wasm instance from module exports object, id, hash and importsObject
+     */
+    readonly instantiateWasm: "__webpack_require__.v";
+    /**
+     * the uncaught error handler for the webpack runtime
+     */
+    readonly uncaughtErrorHandler: "__webpack_require__.oe";
+    /**
+     * the script nonce
+     */
+    readonly scriptNonce: "__webpack_require__.nc";
+    /**
+     * function to load a script tag.
+     * Arguments: (url: string, done: (event) =\> void), key?: string | number, chunkId?: string | number) =\> void
+     * done function is called when loading has finished or timeout occurred.
+     * It will attach to existing script tags with data-webpack == uniqueName + ":" + key or src == url.
+     */
+    readonly loadScript: "__webpack_require__.l";
+    /**
+     * function to promote a string to a TrustedScript using webpack's Trusted
+     * Types policy
+     * Arguments: (script: string) =\> TrustedScript
+     */
+    readonly createScript: "__webpack_require__.ts";
+    /**
+     * function to promote a string to a TrustedScriptURL using webpack's Trusted
+     * Types policy
+     * Arguments: (url: string) =\> TrustedScriptURL
+     */
+    readonly createScriptUrl: "__webpack_require__.tu";
+    /**
+     * function to return webpack's Trusted Types policy
+     * Arguments: () =\> TrustedTypePolicy
+     */
+    readonly getTrustedTypesPolicy: "__webpack_require__.tt";
+    /**
+     * a flag when a chunk has a fetch priority
+     */
+    readonly hasFetchPriority: "has fetch priority";
+    /**
+     * the chunk name of the chunk with the runtime
+     */
+    readonly chunkName: "__webpack_require__.cn";
+    /**
+     * the runtime id of the current runtime
+     */
+    readonly runtimeId: "__webpack_require__.j";
+    /**
+     * the filename of the script part of the chunk
+     */
+    readonly getChunkScriptFilename: "__webpack_require__.u";
+    /**
+     * the filename of the css part of the chunk
+     */
+    readonly getChunkCssFilename: "__webpack_require__.k";
+    /**
+     * a flag when a module/chunk/tree has css modules
+     */
+    readonly hasCssModules: "has css modules";
+    /**
+     * the filename of the script part of the hot update chunk
+     */
+    readonly getChunkUpdateScriptFilename: "__webpack_require__.hu";
+    /**
+     * the filename of the css part of the hot update chunk
+     */
+    readonly getChunkUpdateCssFilename: "__webpack_require__.hk";
+    /**
+     * startup signal from runtime
+     * This will be called when the runtime chunk has been loaded.
+     */
+    readonly startup: "__webpack_require__.x";
+    /**
+     * @deprecated
+     * creating a default startup function with the entry modules
+     */
+    readonly startupNoDefault: "__webpack_require__.x (no default handler)";
+    /**
+     * startup signal from runtime but only used to add logic after the startup
+     */
+    readonly startupOnlyAfter: "__webpack_require__.x (only after)";
+    /**
+     * startup signal from runtime but only used to add sync logic before the startup
+     */
+    readonly startupOnlyBefore: "__webpack_require__.x (only before)";
+    /**
+     * global callback functions for installing chunks
+     */
+    readonly chunkCallback: "webpackChunk";
+    /**
+     * method to startup an entrypoint with needed chunks.
+     * Signature: (moduleId: Id, chunkIds: Id[]) =\> any.
+     * Returns the exports of the module or a Promise
+     */
+    readonly startupEntrypoint: "__webpack_require__.X";
+    /**
+     * register deferred code, which will run when certain
+     * chunks are loaded.
+     * Signature: (chunkIds: Id[], fn: () =\> any, priority: int \>= 0 = 0) =\> any
+     * Returned value will be returned directly when all chunks are already loaded
+     * When (priority & 1) it will wait for all other handlers with lower priority to
+     * be executed before itself is executed
+     */
+    readonly onChunksLoaded: "__webpack_require__.O";
+    /**
+     * method to install a chunk that was loaded somehow
+     * Signature: (\{ id, ids, modules, runtime \}) =\> void
+     */
+    readonly externalInstallChunk: "__webpack_require__.C";
+    /**
+     * interceptor for module executions
+     */
+    readonly interceptModuleExecution: "__webpack_require__.i";
+    /**
+     * the global object
+     */
+    readonly global: "__webpack_require__.g";
+    /**
+     * an object with all share scopes
+     */
+    readonly shareScopeMap: "__webpack_require__.S";
+    /**
+     * The sharing init sequence function (only runs once per share scope).
+     * Has one argument, the name of the share scope.
+     * Creates a share scope if not existing
+     */
+    readonly initializeSharing: "__webpack_require__.I";
+    /**
+     * The current scope when getting a module from a remote
+     */
+    readonly currentRemoteGetScope: "__webpack_require__.R";
+    /**
+     * the filename of the HMR manifest
+     */
+    readonly getUpdateManifestFilename: "__webpack_require__.hmrF";
+    /**
+     * function downloading the update manifest
+     */
+    readonly hmrDownloadManifest: "__webpack_require__.hmrM";
+    /**
+     * array with handler functions to download chunk updates
+     */
+    readonly hmrDownloadUpdateHandlers: "__webpack_require__.hmrC";
+    /**
+     * object with all hmr module data for all modules
+     */
+    readonly hmrModuleData: "__webpack_require__.hmrD";
+    /**
+     * array with handler functions when a module should be invalidated
+     */
+    readonly hmrInvalidateModuleHandlers: "__webpack_require__.hmrI";
+    /**
+     * the prefix for storing state of runtime modules when hmr is enabled
+     */
+    readonly hmrRuntimeStatePrefix: "__webpack_require__.hmrS";
+    /**
+     * the AMD define function
+     */
+    readonly amdDefine: "__webpack_require__.amdD";
+    /**
+     * the AMD options
+     */
+    readonly amdOptions: "__webpack_require__.amdO";
+    /**
+     * the System polyfill object
+     */
+    readonly system: "__webpack_require__.System";
+    /**
+     * the shorthand for Object.prototype.hasOwnProperty
+     * using of it decreases the compiled bundle size
+     */
+    readonly hasOwnProperty: "__webpack_require__.o";
+    /**
+     * the System.register context object
+     */
+    readonly systemContext: "__webpack_require__.y";
+    /**
+     * the baseURI of current document
+     */
+    readonly baseURI: "__webpack_require__.b";
+    /**
+     * a RelativeURL class when relative URLs are used
+     */
+    readonly relativeUrl: "__webpack_require__.U";
+    /**
+     * Creates an async module. The body function must be a async function.
+     * "module.exports" will be decorated with an AsyncModulePromise.
+     * The body function will be called.
+     * To handle async dependencies correctly do this: "([a, b, c] = await handleDependencies([a, b, c]));".
+     * If "hasAwaitAfterDependencies" is truthy, "handleDependencies()" must be called at the end of the body function.
+     * Signature: function(
+     * module: Module,
+     * body: (handleDependencies: (deps: AsyncModulePromise[]) =\> Promise\<any[]\> & () =\> void,
+     * hasAwaitAfterDependencies?: boolean
+     * ) =\> void
+     */
+    readonly asyncModule: "__webpack_require__.a";
+    readonly asyncModuleExportSymbol: "__webpack_require__.aE";
+    readonly makeDeferredNamespaceObject: "__webpack_require__.z";
+    readonly makeDeferredNamespaceObjectSymbol: "__webpack_require__.zS";
+};
+export declare const isReservedRuntimeGlobal: (r: string) => boolean;

package/dist/RuntimeModule.d.ts

@@ -0,0 +1,32 @@
+import type { JsAddingRuntimeModule } from "./binding";
+import type { Chunk } from "./Chunk";
+import type { ChunkGraph } from "./ChunkGraph";
+import type { Compilation } from "./Compilation";
+export declare enum RuntimeModuleStage {
+    NORMAL = 0,
+    BASIC = 5,
+    ATTACH = 10,
+    TRIGGER = 20
+}
+export declare class RuntimeModule {
+    static STAGE_NORMAL: RuntimeModuleStage;
+    static STAGE_BASIC: RuntimeModuleStage;
+    static STAGE_ATTACH: RuntimeModuleStage;
+    static STAGE_TRIGGER: RuntimeModuleStage;
+    static __to_binding(module: RuntimeModule): JsAddingRuntimeModule;
+    private _name;
+    private _stage;
+    fullHash: boolean;
+    dependentHash: boolean;
+    protected chunk: Chunk | null;
+    protected compilation: Compilation | null;
+    protected chunkGraph: ChunkGraph | null;
+    constructor(name: string, stage?: RuntimeModuleStage);
+    attach(compilation: Compilation, chunk: Chunk, chunkGraph: ChunkGraph): void;
+    get name(): string;
+    get stage(): RuntimeModuleStage;
+    identifier(): string;
+    readableIdentifier(): string;
+    shouldIsolate(): boolean;
+    generate(): string;
+}

package/dist/Stats.d.ts

@@ -0,0 +1,17 @@
+import type { Compilation } from "./Compilation";
+import type { StatsOptions, StatsValue } from "./config";
+import type { StatsCompilation } from "./stats/statsFactoryUtils";
+export type { StatsAsset, StatsChunk, StatsCompilation, StatsError, StatsModule } from "./stats/statsFactoryUtils";
+export declare class Stats {
+    #private;
+    constructor(compilation: Compilation);
+    get compilation(): Compilation;
+    get hash(): Readonly<string | null>;
+    get startTime(): number | undefined;
+    get endTime(): number | undefined;
+    hasErrors(): boolean;
+    hasWarnings(): boolean;
+    toJson(opts?: StatsValue, forToString?: boolean): StatsCompilation;
+    toString(opts?: StatsValue): string;
+}
+export declare function normalizeStatsPreset(options?: StatsValue): StatsOptions;

package/dist/Template.d.ts

@@ -0,0 +1,77 @@
+/**
+ * The following code is modified based on
+ * https://github.com/webpack/webpack/blob/4b4ca3b/lib/Template.js
+ *
+ * MIT Licensed
+ * Author Tobias Koppers @sokra
+ * Copyright (c) JS Foundation and other contributors
+ * https://github.com/webpack/webpack/blob/main/LICENSE
+ */
+declare class Template {
+    /**
+     *
+     * @param fn a runtime function (.runtime.js) "template"
+     * @returns the updated and normalized function string
+     */
+    static getFunctionContent(fn: Function): string;
+    /**
+     * @param str the string converted to identifier
+     * @returns created identifier
+     */
+    static toIdentifier(str: any): string;
+    /**
+     *
+     * @param str string to be converted to commented in bundle code
+     * @returns returns a commented version of string
+     */
+    static toComment(str: string): string;
+    /**
+     *
+     * @param str string to be converted to "normal comment"
+     * @returns returns a commented version of string
+     */
+    static toNormalComment(str: string): string;
+    /**
+     * @param str string path to be normalized
+     * @returns normalized bundle-safe path
+     */
+    static toPath(str: string): string;
+    /**
+     * @param num number to convert to ident
+     * @returns returns single character ident
+     */
+    static numberToIdentifier(num: number): string;
+    /**
+     * @param num number to convert to ident
+     * @returns returns single character ident
+     */
+    static numberToIdentifierContinuation(num: number): string;
+    /**
+     *
+     * @param s string to convert to identity
+     * @returns converted identity
+     */
+    static indent(s: string | string[]): string;
+    /**
+     *
+     * @param s string to create prefix for
+     * @param prefix prefix to compose
+     * @returns returns new prefix string
+     */
+    static prefix(s: string | string[], prefix: string): string;
+    /**
+     *
+     * @param str string or string collection
+     * @returns returns a single string from array
+     */
+    static asString(str: string | string[]): string;
+    /**
+     * @param modules a collection of modules to get array bounds for
+     * @returns returns the upper and lower array bounds
+     * or false if not every module has a number based id
+     */
+    static getModulesArrayBounds(modules: {
+        id: string | number;
+    }[]): [number, number] | false;
+}
+export { Template };

package/dist/VirtualModulesPlugin.d.ts

@@ -0,0 +1,12 @@
+import type { Compiler } from "./Compiler";
+export declare class VirtualModulesPlugin {
+    #private;
+    constructor(modules?: Record<string, string>);
+    apply(compiler: Compiler): void;
+    writeModule(filePath: string, contents: string): void;
+    private getVirtualFileStore;
+    static __internal__take_virtual_files(compiler: Compiler): {
+        path: string;
+        content: string;
+    }[] | undefined;
+}

package/dist/Watching.d.ts

@@ -0,0 +1,56 @@
+/**
+ * The following code is modified based on
+ * https://github.com/webpack/webpack/blob/4b4ca3b/lib/Watching.js
+ *
+ * MIT Licensed
+ * Author Tobias Koppers @sokra
+ * Copyright (c) JS Foundation and other contributors
+ * https://github.com/webpack/webpack/blob/main/LICENSE
+ */
+import type { Callback } from "@rspack/lite-tapable";
+import type { Compiler } from ".";
+import { Stats } from ".";
+import type { WatchOptions } from "./config";
+import type { Watcher } from "./util/fs";
+export declare class Watching {
+    #private;
+    watcher?: Watcher;
+    pausedWatcher?: Watcher;
+    compiler: Compiler;
+    handler: Callback<Error, Stats>;
+    callbacks: Callback<Error, void>[];
+    watchOptions: WatchOptions;
+    lastWatcherStartTime: number;
+    running: boolean;
+    blocked: boolean;
+    isBlocked: () => boolean;
+    onChange: () => void;
+    onInvalid: () => void;
+    invalid: boolean;
+    startTime?: number;
+    suspended: boolean;
+    constructor(compiler: Compiler, watchOptions: WatchOptions, handler: Callback<Error, Stats>);
+    watch(files: Iterable<string> & {
+        added?: Iterable<string>;
+        removed?: Iterable<string>;
+    }, dirs: Iterable<string> & {
+        added?: Iterable<string>;
+        removed?: Iterable<string>;
+    }, missing: Iterable<string> & {
+        added?: Iterable<string>;
+        removed?: Iterable<string>;
+    }): void;
+    close(callback?: () => void): void;
+    invalidate(callback?: Callback<Error, void>): void;
+    /**
+     * @internal This is not a public API yet, still unstable, might change in the future
+     */
+    invalidateWithChangesAndRemovals(changedFiles?: Set<string>, removedFiles?: Set<string>, callback?: Callback<Error, void>): void;
+    /**
+     * The reason why this is _done instead of #done, is that in Webpack,
+     * it will rewrite this function to another function
+     */
+    private _done;
+    suspend(): void;
+    resume(): void;
+}

package/dist/binding.d.ts

@@ -0,0 +1,8 @@
+/**
+ * We manually create binding.d.ts and re-export everything of the dts generated by napi to fix the cjs-esm interop
+ */
+
+import * as binding from "./napi-binding";
+
+export * from "./napi-binding"
+export default binding;

package/dist/browser/BrowserHttpImportEsmPlugin.d.ts

@@ -0,0 +1,48 @@
+import type { Compiler } from ".";
+interface ResolvedRequest {
+    request: string;
+    issuer: string;
+    packageName: string;
+}
+interface ProcessedRequest extends ResolvedRequest {
+    url: URL;
+}
+interface BrowserHttpImportPluginOptions {
+    /**
+     * ESM CDN domain
+     */
+    domain: string | ((resolvedRequest: ResolvedRequest) => string);
+    /**
+     * Specify ESM CDN URL for dependencies.
+     * If a record is provided, it will be used to map package names to their CDN URLs.
+     *
+     * Once this function resolves a dependency, other options are ignored.
+     */
+    dependencyUrl?: Record<string, string | undefined> | ((resolvedRequest: ResolvedRequest) => string | undefined);
+    /**
+     * Specify versions for dependencies.
+     * Default to "latest" if not specified.
+     */
+    dependencyVersions?: Record<string, string | undefined>;
+    /**
+     * You can attach additional queries supported by the CDN to the `request.url`.
+     *
+     * For example, to specify the external dependencies under esm.sh, you can do:
+     *
+     * `request.url.searchParams.set("external", "react,react-dom")`
+     */
+    postprocess?: (request: ProcessedRequest) => void;
+}
+/**
+ * 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;
+    private resolveWithUrlIssuer;
+    private resolveNodeModule;
+    private parameterize;
+    private isNodeModule;
+}
+export {};

package/dist/browser/BrowserRequirePlugin.d.ts

@@ -0,0 +1,38 @@
+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 option provides a direct mapping from the module specifier to the module content, similar to the mechanism of a virtual module.
+     * If this option is not provided or the mapping result is undefined, it will fallback to resolving from memfs and run `execute`.
+     */
+    modules?: Record<string, unknown> | ((id: string) => unknown);
+}
+/**
+ * This plugin inject browser-compatible `require` function to the `Compiler`.
+ * 1. This plugin makes it possible to use custom loaders in browser by providing a virtual module mechanism.
+ * 2. This plugin resolves the JavaScript in the memfs with Node.js resolution algorithm rather than in the host filesystem.
+ * 3. This plugin 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) | undefined;
+    constructor(options: BrowserRequirePluginOptions);
+    apply(compiler: Compiler): void;
+}
+export {};

package/dist/browser/buffer.d.ts

@@ -0,0 +1 @@
+export { Buffer } from "@napi-rs/wasm-runtime/fs";