@rspack/core 0.0.2 → 0.0.6

package/CHANGELOG.md

@@ -1,5 +1,35 @@
 # @rspack/core
 
+## 0.0.6
+
+### Patch Changes
+
+- e6d0926a: unify version
+- Updated dependencies [e6d0926a]
+  - @rspack/binding@0.0.6
+  - @rspack/dev-server@0.0.6
+  - @rspack/plugin-postcss@0.0.6
+
+## 0.0.4
+
+### Patch Changes
+
+- d466288: add process_assets hook
+- Updated dependencies [d466288]
+  - @rspack/binding@0.0.5
+  - @rspack/dev-server@0.0.4
+  - @rspack/plugin-postcss@0.0.4
+
+## 0.0.3
+
+### Patch Changes
+
+- 536f6f70: fix broken lib
+- Updated dependencies [536f6f70]
+  - @rspack/binding@0.0.4
+  - @rspack/dev-server@0.0.3
+  - @rspack/plugin-postcss@0.0.3
+
 ## 0.0.2
 
 ### Patch Changes

package/example/basic.ts

@@ -1,5 +1,5 @@
 import path from "path";
-import postcssLoader from "rspack-plugin-postcss";
+import postcssLoader from "@rspack/plugin-postcss";
 import { Rspack } from "../src";
 
 const rspack = new Rspack({
@@ -7,7 +7,35 @@ const rspack = new Rspack({
 		main: path.resolve(__dirname, "../../../examples/postcss/index.js")
 	},
 	context: path.resolve(__dirname, "../../../examples/postcss"),
-	plugins: ["html"],
+	plugins: [
+		{
+			name: "test",
+			apply(compiler) {
+				compiler.hooks.done.tap("done1", () => {
+					console.log("done1");
+				});
+				compiler.hooks.done.tap("done2", () => {
+					console.log("done2");
+				});
+				compiler.hooks.compilation.tap("compilation", compilation => {
+					compilation.hooks.processAssets.tapPromise(
+						"processAssets1",
+						async assets => {
+							for (const value of Object.values(assets)) {
+								console.log("value:", value.buffer(), value.source());
+							}
+							compilation.emitAsset("test.js", {
+								source: "hello world"
+							});
+							compilation.updateAsset("main.js", {
+								source: "hello main"
+							});
+						}
+					);
+				});
+			}
+		}
+	],
 	module: {
 		rules: [
 			{

package/{dist → lib}/bin/index.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const commander_1 = require("commander");
-const rspack_dev_server_1 = require("rspack-dev-server");
+const dev_server_1 = require("@rspack/dev-server");
 const __1 = require("..");
 const build_1 = require("../build");
 const program = new commander_1.Command();
@@ -26,7 +26,7 @@ program
     const rspack = new __1.Rspack(config);
     const { options: { dev: { port = 8080 } = {} } = {} } = rspack;
     await rspack.build();
-    const server = await (0, rspack_dev_server_1.createServer)(rspack.options);
+    const server = await (0, dev_server_1.createServer)(rspack.options);
     server.listen(port, () => console.log(`Server listening on port: ${port}`));
 });
 program.parse();

package/lib/config/builtins.d.ts

@@ -0,0 +1,3 @@
+import type { RawBuiltins } from "@rspack/binding";
+export declare type Builtins = RawBuiltins;
+export declare type ResolvedBuiltins = RawBuiltins | any[];

package/lib/config/builtins.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/config/context.d.ts

@@ -0,0 +1,2 @@
+export declare type Context = string;
+export declare type ResolvedContext = string;

package/lib/config/context.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/config/define.d.ts

@@ -0,0 +1,2 @@
+export declare type Define = Record<string, string>;
+export declare type ResolvedDefine = Record<string, string>;

package/lib/config/define.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/config/dev.d.ts

@@ -0,0 +1,17 @@
+export interface Dev {
+    port?: number;
+    static?: {
+        directory?: string;
+    };
+}
+export interface ResolvedDev {
+    port: number;
+    static: {
+        directory: string;
+    };
+}
+interface ResolveDevConfigContext {
+    context: string;
+}
+export declare function resolveDevOptions(devConfig: Dev, context: ResolveDevConfigContext): ResolvedDev;
+export {};

package/lib/config/dev.js

@@ -0,0 +1,17 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveDevOptions = void 0;
+const node_path_1 = __importDefault(require("node:path"));
+function resolveDevOptions(devConfig = {}, context) {
+    var _a, _b, _c;
+    return {
+        port: (_a = devConfig.port) !== null && _a !== void 0 ? _a : 8080,
+        static: {
+            directory: (_c = (_b = devConfig.static) === null || _b === void 0 ? void 0 : _b.directory) !== null && _c !== void 0 ? _c : node_path_1.default.resolve(context.context, "dist")
+        }
+    };
+}
+exports.resolveDevOptions = resolveDevOptions;

package/lib/config/entry.d.ts

@@ -0,0 +1,2 @@
+export declare type Entry = Record<string, string>;
+export declare type ResolvedEntry = Record<string, string>;

package/lib/config/entry.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/config/external.d.ts

@@ -0,0 +1,2 @@
+export declare type External = Record<string, string>;
+export declare type ResolvedExternal = Record<string, string>;

package/lib/config/external.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/config/index.d.ts

@@ -0,0 +1,45 @@
+import type { Context, ResolvedContext } from "./context";
+import type { Define, ResolvedDefine } from "./define";
+import type { Dev, ResolvedDev } from "./dev";
+import type { Entry, ResolvedEntry } from "./entry";
+import type { External, ResolvedExternal } from "./external";
+import type { Mode, ResolvedMode } from "./mode";
+import type { Module, ResolvedModule } from "./module";
+import type { Plugin } from "./plugin";
+import type { ResolvedTarget, Target } from "./target";
+import type { Output, ResolvedOutput } from "./output";
+import { Builtins, ResolvedBuiltins } from "./builtins";
+import { Resolve, ResolvedResolve } from "./resolve";
+export declare type Asset = {
+    source: string;
+};
+export declare type Assets = Record<string, Asset>;
+export interface RspackOptions {
+    entry?: Entry;
+    context?: Context;
+    plugins?: Plugin[];
+    dev?: Dev;
+    module?: Module;
+    define?: Define;
+    target?: Target;
+    mode?: Mode;
+    external?: External;
+    output?: Output;
+    builtins: Builtins;
+    resolve: Resolve;
+}
+export interface ResolvedRspackOptions {
+    entry: ResolvedEntry;
+    context: ResolvedContext;
+    plugins: Plugin[];
+    dev: ResolvedDev;
+    module: ResolvedModule;
+    define: ResolvedDefine;
+    target: ResolvedTarget;
+    mode: ResolvedMode;
+    external: ResolvedExternal;
+    output: ResolvedOutput;
+    builtins: ResolvedBuiltins;
+    resolve: ResolvedResolve;
+}
+export declare function resolveOptions(config: RspackOptions): ResolvedRspackOptions;

package/lib/config/index.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveOptions = void 0;
+const target_1 = require("./target");
+const output_1 = require("./output");
+const dev_1 = require("./dev");
+const module_1 = require("./module");
+function resolveOptions(config) {
+    var _a, _b, _c, _d, _e, _f, _g, _h;
+    const context = (_a = config.context) !== null && _a !== void 0 ? _a : process.cwd();
+    const mode = (_b = config.mode) !== null && _b !== void 0 ? _b : "development";
+    const dev = (0, dev_1.resolveDevOptions)(config.dev, { context });
+    const entry = (_c = config.entry) !== null && _c !== void 0 ? _c : {};
+    const output = (0, output_1.resolveOutputOptions)(config.output);
+    const define = (_d = config.define) !== null && _d !== void 0 ? _d : {};
+    const target = (0, target_1.resolveTargetOptions)(config.target);
+    const external = (_e = config.external) !== null && _e !== void 0 ? _e : {};
+    const plugins = (_f = config.plugins) !== null && _f !== void 0 ? _f : [];
+    const builtins = (_g = config.builtins) !== null && _g !== void 0 ? _g : [];
+    const resolve = (_h = config.resolve) !== null && _h !== void 0 ? _h : {};
+    const module = (0, module_1.resolveModuleOptions)(config.module);
+    return {
+        context,
+        mode,
+        dev,
+        entry,
+        output,
+        define,
+        target,
+        external,
+        plugins,
+        builtins,
+        module,
+        resolve
+    };
+}
+exports.resolveOptions = resolveOptions;

package/lib/config/mode.d.ts

@@ -0,0 +1,2 @@
+export declare type Mode = string;
+export declare type ResolvedMode = string;

package/lib/config/mode.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/{dist/index.d.ts → lib/config/module.d.ts}

@@ -1,27 +1,35 @@
 /// <reference types="node" />
-export * from "./build";
-import * as binding from "@rspack/binding";
 import type { RawModuleRuleUse, RawModuleRule } from "@rspack/binding";
-import type { RspackOptions } from "./config";
-interface ModuleRule {
+export interface ModuleRule {
     test?: RawModuleRule["test"];
     resource?: RawModuleRule["resource"];
     resourceQuery?: RawModuleRule["resourceQuery"];
     uses?: ModuleRuleUse[];
     type?: RawModuleRule["type"];
 }
-declare type ModuleRuleUse = {
-    builtinLoader: BuiltinLoader;
-    options?: unknown;
-} | {
-    loader: JsLoader;
-    options?: unknown;
-};
-interface JsLoader {
-    (this: LoaderContext, loaderContext: LoaderContext): Promise<LoaderResult | void> | LoaderResult | void;
-    displayName?: string;
+export interface Module {
+    rules?: ModuleRule[];
+    parser?: {
+        dataUrlCondition?: {
+            maxSize?: number;
+        };
+    };
+}
+interface ResolvedModuleRule {
+    test?: RawModuleRule["test"];
+    resource?: RawModuleRule["resource"];
+    resourceQuery?: RawModuleRule["resourceQuery"];
+    uses?: RawModuleRuleUse[];
+    type?: RawModuleRule["type"];
+}
+export interface ResolvedModule {
+    rules: ResolvedModuleRule[];
+    parser?: {
+        dataUrlCondition: {
+            maxSize: number;
+        };
+    };
 }
-declare type BuiltinLoader = string;
 interface LoaderContextInternal {
     source: number[];
     resource: String;
@@ -29,24 +37,28 @@ interface LoaderContextInternal {
     resourceQuery: String | null;
     resourceFragment: String | null;
 }
+interface LoaderResult {
+    content: Buffer | string;
+    meta: Buffer | string;
+}
 interface LoaderContext extends Pick<LoaderContextInternal, "resource" | "resourcePath" | "resourceQuery" | "resourceFragment"> {
     source: {
         getCode(): string;
         getBuffer(): Buffer;
     };
 }
-interface LoaderResult {
-    content: Buffer | string;
-    meta: Buffer | string;
+interface JsLoader {
+    (this: LoaderContext, loaderContext: LoaderContext): Promise<LoaderResult | void> | LoaderResult | void;
+    displayName?: string;
 }
-declare function createRawModuleRuleUses(uses: ModuleRuleUse[]): RawModuleRuleUse[];
-declare class Rspack {
-    #private;
-    options: RspackOptions;
-    constructor(options: RspackOptions);
-    build(): Promise<binding.Stats>;
-    rebuild(): Promise<Record<string, string>>;
-}
-export { Rspack, createRawModuleRuleUses };
-export type { ModuleRule };
-export default Rspack;
+declare type BuiltinLoader = string;
+declare type ModuleRuleUse = {
+    builtinLoader: BuiltinLoader;
+    options?: unknown;
+} | {
+    loader: JsLoader;
+    options?: unknown;
+};
+export declare function createRawModuleRuleUses(uses: ModuleRuleUse[]): RawModuleRuleUse[];
+export declare function resolveModuleOptions(module?: Module): ResolvedModule;
+export {};

package/lib/config/module.js

@@ -0,0 +1,121 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveModuleOptions = exports.createRawModuleRuleUses = void 0;
+const node_assert_1 = __importDefault(require("node:assert"));
+const toBuffer = (bufLike) => {
+    if (Buffer.isBuffer(bufLike)) {
+        return bufLike;
+    }
+    else if (typeof bufLike === "string") {
+        return Buffer.from(bufLike);
+    }
+    throw new Error("Buffer or string expected");
+};
+function composeJsUse(uses) {
+    if (!uses.length) {
+        return null;
+    }
+    async function loader(err, data) {
+        if (err) {
+            throw err;
+        }
+        const loaderThreadsafeContext = JSON.parse(data.toString("utf-8"));
+        const { p: payload, id } = loaderThreadsafeContext;
+        const loaderContextInternal = {
+            source: payload.source,
+            resourcePath: payload.resourcePath,
+            resourceQuery: payload.resourceQuery,
+            resource: payload.resource,
+            resourceFragment: payload.resourceFragment
+        };
+        let sourceBuffer = Buffer.from(loaderContextInternal.source);
+        let meta = Buffer.from("");
+        // Loader is executed from right to left
+        for (const use of uses) {
+            (0, node_assert_1.default)("loader" in use);
+            const loaderContext = {
+                ...loaderContextInternal,
+                source: {
+                    getCode() {
+                        return sourceBuffer.toString("utf-8");
+                    },
+                    getBuffer() {
+                        return sourceBuffer;
+                    }
+                },
+                getOptions() {
+                    return use.options;
+                }
+            };
+            let loaderResult;
+            if ((loaderResult = await Promise.resolve().then(() => use.loader.apply(loaderContext, [loaderContext])))) {
+                const content = loaderResult.content;
+                meta = meta.length > 0 ? meta : toBuffer(loaderResult.meta);
+                sourceBuffer = toBuffer(content);
+            }
+        }
+        const loaderResultPayload = {
+            content: [...sourceBuffer],
+            meta: [...meta]
+        };
+        const loaderThreadsafeResult = {
+            id: id,
+            p: loaderResultPayload
+        };
+        return Buffer.from(JSON.stringify(loaderThreadsafeResult), "utf-8");
+    }
+    loader.displayName = `NodeLoaderAdapter(${uses
+        .map(item => {
+        (0, node_assert_1.default)("loader" in item);
+        return item.loader.displayName || item.loader.name || "unknown-loader";
+    })
+        .join(" -> ")})`;
+    return {
+        loader
+    };
+}
+function createRawModuleRuleUses(uses) {
+    return createRawModuleRuleUsesImpl([...uses].reverse());
+}
+exports.createRawModuleRuleUses = createRawModuleRuleUses;
+function createRawModuleRuleUsesImpl(uses) {
+    if (!uses.length) {
+        return [];
+    }
+    const index = uses.findIndex(use => "builtinLoader" in use);
+    if (index < 0) {
+        return [composeJsUse(uses)];
+    }
+    const before = uses.slice(0, index);
+    const after = uses.slice(index + 1);
+    return [
+        composeJsUse(before),
+        createNativeUse(uses[index]),
+        ...createRawModuleRuleUsesImpl(after)
+    ].filter((item) => Boolean(item));
+}
+function createNativeUse(use) {
+    var _a;
+    (0, node_assert_1.default)("builtinLoader" in use);
+    if (use.builtinLoader === "sass-loader") {
+        ((_a = use.options) !== null && _a !== void 0 ? _a : (use.options = {})).__exePath = require.resolve(`@tmp-sass-embedded/${process.platform}-${process.arch}/dart-sass-embedded/dart-sass-embedded${process.platform === "win32" ? ".bat" : ""}`);
+    }
+    return {
+        builtinLoader: use.builtinLoader,
+        options: JSON.stringify(use.options)
+    };
+}
+function resolveModuleOptions(module = {}) {
+    var _a;
+    const rules = ((_a = module.rules) !== null && _a !== void 0 ? _a : []).map(rule => ({
+        ...rule,
+        uses: createRawModuleRuleUses(rule.uses || [])
+    }));
+    return {
+        rules
+    };
+}
+exports.resolveModuleOptions = resolveModuleOptions;

package/lib/config/output.d.ts

@@ -0,0 +1,17 @@
+export interface Output {
+    path?: string;
+    publicPath?: string;
+    assetModuleFilename?: string;
+    filename?: string;
+    chunkFilename?: string;
+    uniqueName?: string;
+}
+export interface ResolvedOutput {
+    path?: string;
+    publicPath?: string;
+    assetModuleFilename?: string;
+    filename?: string;
+    chunkFilename?: string;
+    uniqueName?: string;
+}
+export declare function resolveOutputOptions(output?: Output): ResolvedOutput;

package/lib/config/output.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveOutputOptions = void 0;
+function resolveOutputOptions(output = {}) {
+    return {
+        path: output.path,
+        publicPath: output.publicPath,
+        chunkFilename: output.chunkFilename,
+        filename: output.publicPath,
+        assetModuleFilename: output.assetModuleFilename,
+        uniqueName: output.uniqueName
+    };
+}
+exports.resolveOutputOptions = resolveOutputOptions;

package/lib/config/plugin.d.ts

@@ -0,0 +1,5 @@
+import Rspack from "..";
+export interface Plugin {
+    name: string;
+    apply(compiler: Rspack): void;
+}

package/lib/config/plugin.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/config/resolve.d.ts

@@ -0,0 +1,6 @@
+export declare type Resolve = {
+    preferRelative?: boolean;
+};
+export declare type ResolvedResolve = {
+    preferRelative?: boolean;
+};

package/lib/config/resolve.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/config/target.d.ts

@@ -0,0 +1,5 @@
+declare type TargetItem = "web" | "webworker" | "browserslist" | "es3" | "es5" | "es2015" | "es2016" | "es2017" | "es2018" | "es2019" | "es2020" | "es2021" | "es2022";
+export declare type Target = TargetItem | TargetItem[] | false;
+export declare type ResolvedTarget = TargetItem[];
+export declare function resolveTargetOptions(target?: Target): ResolvedTarget;
+export {};

package/lib/config/target.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveTargetOptions = void 0;
+function resolveTargetOptions(target = "web") {
+    if (!target) {
+        return [];
+    }
+    if (!Array.isArray(target)) {
+        return [target];
+    }
+    return target;
+}
+exports.resolveTargetOptions = resolveTargetOptions;

package/lib/index.d.ts

@@ -0,0 +1,39 @@
+export * from "./build";
+import * as binding from "@rspack/binding";
+import * as tapable from "tapable";
+import { RspackOptions, ResolvedRspackOptions, Asset } from "./config";
+import { Source } from "webpack-sources";
+declare class RspackCompilation {
+    #private;
+    hooks: {
+        processAssets: tapable.AsyncSeriesHook<Record<string, Source>>;
+    };
+    constructor();
+    /**
+     * unsafe to call out of processAssets
+     * @param filename
+     * @param asset
+     */
+    updateAsset(filename: string, asset: Asset): void;
+    /**
+     * unsafe to call out of processAssets
+     * @param filename
+     * @param asset
+     */
+    emitAsset(filename: string, asset: Asset): void;
+    processAssets(err: Error, value: string, emitAsset: any): Promise<string>;
+}
+declare class Rspack {
+    #private;
+    compilation: RspackCompilation;
+    hooks: {
+        done: tapable.AsyncSeriesHook<void>;
+        compilation: tapable.SyncHook<RspackCompilation>;
+    };
+    options: ResolvedRspackOptions;
+    constructor(options: RspackOptions);
+    build(): Promise<binding.Stats>;
+    rebuild(changeFiles: string[]): Promise<Record<string, string>>;
+}
+export { Rspack };
+export default Rspack;