@rspack/core 1.0.0-beta.3 → 1.0.0-beta.5

package/dist/stats/statsFactoryUtils.d.ts

@@ -1,5 +1,6 @@
 /// <reference types="node" />
 import type * as binding from "@rspack/binding";
+import type { JsOriginRecord } from "@rspack/binding";
 import type { Compilation, NormalizedStatsOptions } from "../Compilation";
 import { type Comparator } from "../util/comparators";
 import type { StatsFactory, StatsFactoryContext } from "./StatsFactory";
@@ -23,8 +24,10 @@ export type KnownStatsChunkGroup = {
         prefetch?: StatsChunkGroup[];
     };
     childAssets?: {
-        [index: string]: string[];
+        preload?: string[];
+        prefetch?: string[];
     };
+    isOverSizeLimit?: boolean;
 };
 export type KnownStatsChunk = {
     type: string;
@@ -70,6 +73,8 @@ export type KnownStatsAsset = {
     info: AssetInfo;
     size: number;
     emitted: boolean;
+    cached: boolean;
+    related?: StatsAsset[];
     chunkNames?: (string | number)[];
     chunkIdHints?: (string | number)[];
     chunks?: (string | null | undefined)[];
@@ -163,9 +168,12 @@ export type KnownStatsModuleReason = {
     moduleIdentifier?: string;
     module?: string;
     moduleName?: string;
+    resolvedModuleIdentifier?: string;
+    resolvedModule?: string;
     type?: string;
     userRequest?: string;
     moduleId?: string | null;
+    resolvedModuleId?: string | number | null;
 };
 export type StatsModuleReason = KnownStatsModuleReason & Record<string, any>;
 export type KnownStatsChunkOrigin = {
@@ -243,6 +251,7 @@ export type SimpleExtractors = {
     profile: ExtractorsByOption<binding.JsStatsModuleProfile, StatsProfile>;
     moduleReason: ExtractorsByOption<binding.JsStatsModuleReason, StatsModuleReason>;
     chunk: ExtractorsByOption<binding.JsStatsChunk, KnownStatsChunk>;
+    chunkOrigin: ExtractorsByOption<JsOriginRecord, StatsChunkOrigin>;
     error: ExtractorsByOption<binding.JsStatsError, StatsError>;
     warning: ExtractorsByOption<binding.JsStatsWarning, StatsError>;
     moduleTraceItem: ExtractorsByOption<binding.JsStatsModuleTrace, StatsModuleTraceItem>;
@@ -275,4 +284,8 @@ export declare const mergeToObject: (items: {
     name: string;
 }[]) => Object;
 export declare function resolveStatsMillisecond(s: binding.JsStatsMillisecond): number;
+export declare const errorsSpaceLimit: (errors: StatsError[], max: number) => {
+    errors: StatsError[];
+    filtered: number;
+};
 export {};

package/dist/stats/statsFactoryUtils.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.resolveStatsMillisecond = exports.mergeToObject = exports.moduleGroup = exports.assetGroup = exports.sortByField = exports.countWithChildren = exports.spaceLimited = exports.collapse = exports.getTotalItems = exports.iterateConfig = exports.uniqueOrderedArray = exports.uniqueArray = void 0;
+exports.errorsSpaceLimit = exports.resolveStatsMillisecond = exports.mergeToObject = exports.moduleGroup = exports.assetGroup = exports.sortByField = exports.countWithChildren = exports.spaceLimited = exports.collapse = exports.getTotalItems = exports.iterateConfig = exports.uniqueOrderedArray = exports.uniqueArray = void 0;
 const comparators_1 = require("../util/comparators");
 const uniqueArray = (items, selector) => {
     const set = new Set();
@@ -279,3 +279,64 @@ function resolveStatsMillisecond(s) {
     return s.secs * 1000 + s.subsecMillis;
 }
 exports.resolveStatsMillisecond = resolveStatsMillisecond;
+const errorsSpaceLimit = (errors, max) => {
+    let filtered = 0;
+    // Can not fit into limit
+    // print only messages
+    if (errors.length + 1 >= max) {
+        return {
+            errors: errors.map(error => {
+                if (typeof error === "string" || !error.details)
+                    return error;
+                filtered++;
+                return { ...error, details: "" };
+            }),
+            filtered
+        };
+    }
+    let fullLength = errors.length;
+    let result = errors;
+    let i = 0;
+    for (; i < errors.length; i++) {
+        const error = errors[i];
+        if (typeof error !== "string" && error.details) {
+            const splitted = error.details.split("\n");
+            const len = splitted.length;
+            fullLength += len;
+            if (fullLength > max) {
+                result = i > 0 ? errors.slice(0, i) : [];
+                const overLimit = fullLength - max + 1;
+                const error = errors[i++];
+                result.push({
+                    ...error,
+                    details: error.details.split("\n").slice(0, -overLimit).join("\n"),
+                    filteredDetails: overLimit
+                });
+                filtered = errors.length - i;
+                for (; i < errors.length; i++) {
+                    const error = errors[i];
+                    if (typeof error === "string" || !error.details)
+                        result.push(error);
+                    result.push({ ...error, details: "" });
+                }
+                break;
+            }
+            if (fullLength === max) {
+                result = errors.slice(0, ++i);
+                filtered = errors.length - i;
+                for (; i < errors.length; i++) {
+                    const error = errors[i];
+                    if (typeof error === "string" || !error.details)
+                        result.push(error);
+                    result.push({ ...error, details: "" });
+                }
+                break;
+            }
+        }
+    }
+    return {
+        errors: result,
+        filtered
+    };
+};
+exports.errorsSpaceLimit = errorsSpaceLimit;

package/dist/util/fs.d.ts

@@ -9,6 +9,8 @@
  */
 /// <reference types="node" />
 /// <reference types="node" />
+/// <reference types="node" />
+import type { Abortable } from "node:events";
 import type { WatchOptions } from "../config";
 export interface Watcher {
     close(): void;
@@ -25,7 +27,7 @@ export interface WatcherInfo {
     fileTimeInfoEntries: Map<string, FileSystemInfoEntry | "ignore">;
     contextTimeInfoEntries: Map<string, FileSystemInfoEntry | "ignore">;
 }
-interface IDirent {
+export type IStatsBase<T> = {
     isFile: () => boolean;
     isDirectory: () => boolean;
     isBlockDevice: () => boolean;
@@ -33,9 +35,33 @@ interface IDirent {
     isSymbolicLink: () => boolean;
     isFIFO: () => boolean;
     isSocket: () => boolean;
-    name: string | Buffer;
-}
-interface IStats {
+    dev: T;
+    ino: T;
+    mode: T;
+    nlink: T;
+    uid: T;
+    gid: T;
+    rdev: T;
+    size: T;
+    blksize: T;
+    blocks: T;
+    atimeMs: T;
+    mtimeMs: T;
+    ctimeMs: T;
+    birthtimeMs: T;
+    atime: Date;
+    mtime: Date;
+    ctime: Date;
+    birthtime: Date;
+};
+export type IStats = IStatsBase<number>;
+export type IBigIntStats = IStatsBase<bigint> & {
+    atimeNs: bigint;
+    mtimeNs: bigint;
+    ctimeNs: bigint;
+    birthtimeNs: bigint;
+};
+interface IDirent {
     isFile: () => boolean;
     isDirectory: () => boolean;
     isBlockDevice: () => boolean;
@@ -43,24 +69,7 @@ interface IStats {
     isSymbolicLink: () => boolean;
     isFIFO: () => boolean;
     isSocket: () => boolean;
-    dev: number | bigint;
-    ino: number | bigint;
-    mode: number | bigint;
-    nlink: number | bigint;
-    uid: number | bigint;
-    gid: number | bigint;
-    rdev: number | bigint;
-    size: number | bigint;
-    blksize: number | bigint;
-    blocks: number | bigint;
-    atimeMs: number | bigint;
-    mtimeMs: number | bigint;
-    ctimeMs: number | bigint;
-    birthtimeMs: number | bigint;
-    atime: Date;
-    mtime: Date;
-    ctime: Date;
-    birthtime: Date;
+    name: string | Buffer;
 }
 export interface OutputFileSystem {
     writeFile: (arg0: string, arg1: string | Buffer, arg2: (arg0?: null | NodeJS.ErrnoException) => void) => void;
@@ -75,6 +84,220 @@ export interface OutputFileSystem {
     relative?: (arg0: string, arg1: string) => string;
     dirname?: (arg0: string) => string;
 }
+export type JsonPrimitive = string | number | boolean | null;
+export type JsonArray = JsonValue[];
+export type JsonValue = JsonPrimitive | JsonObject | JsonArray;
+export type JsonObject = {
+    [Key in string]: JsonValue;
+} & {
+    [Key in string]?: JsonValue | undefined;
+};
+export type NoParamCallback = (err: NodeJS.ErrnoException | null) => void;
+export type StringCallback = (err: NodeJS.ErrnoException | null, data?: string) => void;
+export type BufferCallback = (err: NodeJS.ErrnoException | null, data?: Buffer) => void;
+export type StringOrBufferCallback = (err: NodeJS.ErrnoException | null, data?: string | Buffer) => void;
+export type ReaddirStringCallback = (err: NodeJS.ErrnoException | null, files?: string[]) => void;
+export type ReaddirBufferCallback = (err: NodeJS.ErrnoException | null, files?: Buffer[]) => void;
+export type ReaddirStringOrBufferCallback = (err: NodeJS.ErrnoException | null, files?: string[] | Buffer[]) => void;
+export type ReaddirDirentCallback = (err: NodeJS.ErrnoException | null, files?: IDirent[]) => void;
+export type StatsCallback = (err: NodeJS.ErrnoException | null, stats?: IStats) => void;
+export type BigIntStatsCallback = (err: NodeJS.ErrnoException | null, stats?: IBigIntStats) => void;
+export type StatsOrBigIntStatsCallback = (err: NodeJS.ErrnoException | null, stats?: IStats | IBigIntStats) => void;
+export type NumberCallback = (err: NodeJS.ErrnoException | null, data?: number) => void;
+export type ReadJsonCallback = (err: NodeJS.ErrnoException | Error | null, data?: JsonObject) => void;
+export type PathLike = string | Buffer | URL;
+export type PathOrFileDescriptor = PathLike | number;
+export type ObjectEncodingOptions = {
+    encoding?: BufferEncoding | null;
+};
+export type ReadFile = {
+    (path: PathOrFileDescriptor, options: ({
+        encoding: null | undefined;
+        flag?: string;
+    } & Abortable) | null | undefined, callback: BufferCallback): void;
+    (path: PathOrFileDescriptor, options: ({
+        encoding: BufferEncoding;
+        flag?: string;
+    } & Abortable) | BufferEncoding, callback: StringCallback): void;
+    (path: PathOrFileDescriptor, options: (ObjectEncodingOptions & {
+        flag?: string;
+    } & Abortable) | BufferEncoding | null | undefined, callback: StringOrBufferCallback): void;
+    (path: PathOrFileDescriptor, callback: BufferCallback): void;
+};
+export type ReadFileSync = {
+    (path: PathOrFileDescriptor, options: {
+        encoding: null | undefined;
+        flag?: string;
+    } | null): Buffer;
+    (path: PathOrFileDescriptor, options: {
+        encoding: BufferEncoding;
+        flag?: string;
+    } | BufferEncoding): string;
+    (path: PathOrFileDescriptor, options: (ObjectEncodingOptions & {
+        flag?: string;
+    }) | BufferEncoding | null): string | Buffer;
+};
+export type EncodingOption = ObjectEncodingOptions | BufferEncoding | undefined | null;
+export type BufferEncodingOption = "buffer" | {
+    encoding: "buffer";
+};
+export type StatOptions = {
+    bigint?: boolean;
+};
+export type StatSyncOptions = {
+    bigint?: boolean;
+    throwIfNoEntry?: boolean;
+};
+export type Readlink = {
+    (path: PathLike, options: EncodingOption, callback: StringCallback): void;
+    (path: PathLike, options: BufferEncodingOption, callback: BufferCallback): void;
+    (path: PathLike, options: EncodingOption, callback: StringOrBufferCallback): void;
+    (path: PathLike, callback: StringCallback): void;
+};
+export type ReadlinkSync = {
+    (path: PathLike, options: EncodingOption): string;
+    (path: PathLike, options: BufferEncodingOption): Buffer;
+    (path: PathLike, options: EncodingOption): string | Buffer;
+};
+export type Readdir = {
+    (path: PathLike, options: {
+        encoding: BufferEncoding | null;
+        withFileTypes?: false;
+        recursive?: boolean;
+    } | BufferEncoding | null | undefined, callback: ReaddirStringCallback): void;
+    (path: PathLike, options: {
+        encoding: "buffer";
+        withFileTypes?: false;
+        recursive?: boolean;
+    } | "buffer", callback: ReaddirBufferCallback): void;
+    (path: PathLike, callback: ReaddirStringCallback): void;
+    (path: PathLike, options: (ObjectEncodingOptions & {
+        withFileTypes: true;
+        recursive?: boolean;
+    }) | BufferEncoding | null | undefined, callback: ReaddirStringOrBufferCallback): void;
+    (path: PathLike, options: ObjectEncodingOptions & {
+        withFileTypes: true;
+        recursive?: boolean;
+    }, callback: ReaddirDirentCallback): void;
+};
+export type ReaddirSync = {
+    (path: PathLike, options: {
+        encoding: BufferEncoding | null;
+        withFileTypes?: false;
+        recursive?: boolean;
+    } | BufferEncoding | null): string[];
+    (path: PathLike, options: {
+        encoding: "buffer";
+        withFileTypes?: false;
+        recursive?: boolean;
+    } | "buffer"): Buffer[];
+    (path: PathLike, options: (ObjectEncodingOptions & {
+        withFileTypes?: false;
+        recursive?: boolean;
+    }) | BufferEncoding | null): string[] | Buffer[];
+    (path: PathLike, options: ObjectEncodingOptions & {
+        withFileTypes: true;
+        recursive?: boolean;
+    }): IDirent[];
+};
+export type Stat = {
+    (path: PathLike, callback: StatsCallback): void;
+    (path: PathLike, options: (StatOptions & {
+        bigint?: false;
+    }) | undefined, callback: StatsCallback): void;
+    (path: PathLike, options: StatOptions & {
+        bigint: true;
+    }, callback: BigIntStatsCallback): void;
+    (path: PathLike, options: StatOptions | undefined, callback: StatsOrBigIntStatsCallback): void;
+};
+export type StatSync = {
+    (path: PathLike, options?: undefined): IStats;
+    (path: PathLike, options?: StatSyncOptions & {
+        bigint?: false;
+        throwIfNoEntry: false;
+    }): IStats | undefined;
+    (path: PathLike, options: StatSyncOptions & {
+        bigint: true;
+        throwIfNoEntry: false;
+    }): IBigIntStats | undefined;
+    (path: PathLike, options?: StatSyncOptions & {
+        bigint?: false;
+    }): IStats;
+    (path: PathLike, options: StatSyncOptions & {
+        bigint: true;
+    }): IBigIntStats;
+    (path: PathLike, options: StatSyncOptions & {
+        bigint: boolean;
+        throwIfNoEntry?: false;
+    }): IStats | IBigIntStats;
+    (path: PathLike, options?: StatSyncOptions): IStats | IBigIntStats | undefined;
+};
+export type LStat = {
+    (path: PathLike, callback: StatsCallback): void;
+    (path: PathLike, options: (StatOptions & {
+        bigint?: false;
+    }) | undefined, callback: StatsCallback): void;
+    (path: PathLike, options: StatOptions & {
+        bigint: true;
+    }, callback: BigIntStatsCallback): void;
+    (path: PathLike, options: StatOptions | undefined, callback: StatsOrBigIntStatsCallback): void;
+};
+export type LStatSync = {
+    (path: PathLike, options?: undefined): IStats;
+    (path: PathLike, options?: StatSyncOptions & {
+        bigint?: false;
+        throwIfNoEntry: false;
+    }): IStats | undefined;
+    (path: PathLike, options: StatSyncOptions & {
+        bigint: true;
+        throwIfNoEntry: false;
+    }): IBigIntStats | undefined;
+    (path: PathLike, options?: StatSyncOptions & {
+        bigint?: false;
+    }): IStats;
+    (path: PathLike, options: StatSyncOptions & {
+        bigint: true;
+    }): IBigIntStats;
+    (path: PathLike, options: StatSyncOptions & {
+        bigint: boolean;
+        throwIfNoEntry?: false;
+    }): IStats | IBigIntStats;
+    (path: PathLike, options?: StatSyncOptions): IStats | IBigIntStats | undefined;
+};
+export type RealPath = {
+    (path: PathLike, options: EncodingOption, callback: StringCallback): void;
+    (path: PathLike, options: BufferEncodingOption, callback: BufferCallback): void;
+    (path: PathLike, options: EncodingOption, callback: StringOrBufferCallback): void;
+    (path: PathLike, callback: StringCallback): void;
+};
+export type RealPathSync = {
+    (path: PathLike, options?: EncodingOption): string;
+    (path: PathLike, options: BufferEncodingOption): Buffer;
+    (path: PathLike, options?: EncodingOption): string | Buffer;
+};
+export type ReadJson = (path: PathOrFileDescriptor, callback: ReadJsonCallback) => void;
+export type ReadJsonSync = (path: PathOrFileDescriptor) => JsonObject;
+export type Purge = (files?: string | string[] | Set<string>) => void;
+export type InputFileSystem = {
+    readFile: ReadFile;
+    readFileSync?: ReadFileSync;
+    readlink: Readlink;
+    readlinkSync?: ReadlinkSync;
+    readdir: Readdir;
+    readdirSync?: ReaddirSync;
+    stat: Stat;
+    statSync?: StatSync;
+    lstat?: LStat;
+    lstatSync?: LStatSync;
+    realpath?: RealPath;
+    realpathSync?: RealPathSync;
+    readJson?: ReadJson;
+    readJsonSync?: ReadJsonSync;
+    purge?: Purge;
+    join?: (path1: string, path2: string) => string;
+    relative?: (from: string, to: string) => string;
+    dirname?: (path: string) => string;
+};
 export declare function rmrf(fs: OutputFileSystem, p: string, callback: (err?: Error | null) => void): void;
 export declare const mkdirp: (fs: OutputFileSystem, p: string, callback: (error?: Error) => void) => void;
 export interface FileSystemInfoEntry {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rspack/core",
-  "version": "1.0.0-beta.3",
+  "version": "1.0.0-beta.5",
   "webpackVersion": "5.75.0",
   "license": "MIT",
   "description": "The fast Rust-based web bundler with webpack-compatible API",
@@ -58,9 +58,9 @@
   },
   "dependencies": {
     "@module-federation/runtime-tools": "0.2.3",
+    "@rspack/lite-tapable": "1.0.0",
     "caniuse-lite": "^1.0.30001616",
-    "@rspack/binding": "1.0.0-beta.3",
-    "@rspack/lite-tapable": "1.0.0-beta.3"
+    "@rspack/binding": "1.0.0-beta.5"
   },
   "peerDependencies": {
     "@swc/helpers": ">=0.5.1"

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

@@ -1,16 +0,0 @@
-import { BuiltinPluginName } from "@rspack/binding";
-import type { AssetConditions } from "../util/assetCondition";
-export type SwcCssMinimizerRspackPluginOptions = {
-    test?: AssetConditions;
-    exclude?: AssetConditions;
-    include?: AssetConditions;
-};
-export declare const SwcCssMinimizerRspackPlugin: {
-    new (options?: SwcCssMinimizerRspackPluginOptions | undefined): {
-        name: BuiltinPluginName;
-        _args: [options?: SwcCssMinimizerRspackPluginOptions | undefined];
-        affectedHooks: "done" | "make" | "compile" | "emit" | "afterEmit" | "invalid" | "thisCompilation" | "afterDone" | "compilation" | "normalModuleFactory" | "contextModuleFactory" | "initialize" | "shouldEmit" | "infrastructureLog" | "beforeRun" | "run" | "assetEmitted" | "failed" | "shutdown" | "watchRun" | "watchClose" | "environment" | "afterEnvironment" | "afterPlugins" | "afterResolvers" | "beforeCompile" | "afterCompile" | "finishMake" | "entryOption" | undefined;
-        raw(compiler: import("../Compiler").Compiler): import("@rspack/binding").BuiltinPlugin;
-        apply(compiler: import("../Compiler").Compiler): void;
-    };
-};

package/dist/builtin-plugin/SwcCssMinimizerPlugin.js

@@ -1,12 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SwcCssMinimizerRspackPlugin = void 0;
-const binding_1 = require("@rspack/binding");
-const base_1 = require("./base");
-exports.SwcCssMinimizerRspackPlugin = (0, base_1.create)(binding_1.BuiltinPluginName.SwcCssMinimizerRspackPlugin, (options) => {
-    return {
-        test: options?.test,
-        include: options?.include,
-        exclude: options?.exclude
-    };
-});