@rspack/core 0.0.4 → 0.0.6

package/CHANGELOG.md

@@ -1,5 +1,15 @@
 # @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

package/lib/bin/index.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/bin/index.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const commander_1 = require("commander");
+const dev_server_1 = require("@rspack/dev-server");
+const __1 = require("..");
+const build_1 = require("../build");
+const program = new commander_1.Command();
+program
+    .option("--env", "env")
+    .command("build", {
+    isDefault: true
+})
+    .description("Rspack build cli")
+    .argument("<config-file>", "rspack config  file path")
+    .action(async (configPath) => {
+    const config = require(configPath);
+    const stats = await (0, build_1.build)(config);
+    console.log(stats);
+});
+program
+    .command("dev")
+    .description("Rspack build cli")
+    .argument("<config-file>", "rspack config file path")
+    .action(async (configPath) => {
+    const config = require(configPath);
+    const rspack = new __1.Rspack(config);
+    const { options: { dev: { port = 8080 } = {} } = {} } = rspack;
+    await rspack.build();
+    const server = await (0, dev_server_1.createServer)(rspack.options);
+    server.listen(port, () => console.log(`Server listening on port: ${port}`));
+});
+program.parse();

package/lib/build.d.ts

@@ -0,0 +1 @@
+export declare function build(config: any): Promise<void>;

package/lib/build.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.build = void 0;
+const _1 = require(".");
+async function build(config) {
+    const rspack = new _1.Rspack(config);
+    const stats = await rspack.build();
+    if (stats.errors.length > 0) {
+        throw new Error(stats.errors[0].message);
+    }
+}
+exports.build = build;

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/lib/config/module.d.ts

@@ -0,0 +1,64 @@
+/// <reference types="node" />
+import type { RawModuleRuleUse, RawModuleRule } from "@rspack/binding";
+export interface ModuleRule {
+    test?: RawModuleRule["test"];
+    resource?: RawModuleRule["resource"];
+    resourceQuery?: RawModuleRule["resourceQuery"];
+    uses?: ModuleRuleUse[];
+    type?: RawModuleRule["type"];
+}
+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;
+        };
+    };
+}
+interface LoaderContextInternal {
+    source: number[];
+    resource: String;
+    resourcePath: String;
+    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 JsLoader {
+    (this: LoaderContext, loaderContext: LoaderContext): Promise<LoaderResult | void> | LoaderResult | void;
+    displayName?: string;
+}
+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;

package/lib/index.js

@@ -0,0 +1,154 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var _RspackCompilation_emitAssetCallback, _Rspack_instances, _Rspack_plugins, _Rspack_instance, _Rspack_done, _Rspack_processAssets, _Rspack_newCompilation;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Rspack = void 0;
+__exportStar(require("./build"), exports);
+const binding = __importStar(require("@rspack/binding"));
+const tapable = __importStar(require("tapable"));
+const config_1 = require("./config");
+const webpack_sources_1 = require("webpack-sources");
+const createDummyResult = (id) => {
+    const result = {
+        id,
+        inner: null
+    };
+    return JSON.stringify(result);
+};
+class RspackCompilation {
+    constructor() {
+        _RspackCompilation_emitAssetCallback.set(this, void 0);
+        this.hooks = {
+            processAssets: new tapable.AsyncSeriesHook([
+                "assets"
+            ])
+        };
+    }
+    /**
+     * unsafe to call out of processAssets
+     * @param filename
+     * @param asset
+     */
+    updateAsset(filename, asset) {
+        this.emitAsset(filename, asset);
+    }
+    /**
+     * unsafe to call out of processAssets
+     * @param filename
+     * @param asset
+     */
+    emitAsset(filename, asset) {
+        if (!__classPrivateFieldGet(this, _RspackCompilation_emitAssetCallback, "f")) {
+            throw new Error("can't call emitAsset outof processAssets hook for now");
+        }
+        __classPrivateFieldGet(this, _RspackCompilation_emitAssetCallback, "f").call(this, {
+            filename: filename,
+            asset
+        });
+    }
+    async processAssets(err, value, emitAsset) {
+        var _a;
+        __classPrivateFieldSet(this, _RspackCompilation_emitAssetCallback, emitAsset, "f");
+        if (err) {
+            throw err;
+        }
+        const context = JSON.parse(value);
+        let content = (_a = context.inner) !== null && _a !== void 0 ? _a : {};
+        let assets = {};
+        for (const [key, value] of Object.entries(content)) {
+            // webpack-sources's type definition is wrong, it actually could accept Buffer type
+            let source = value.source;
+            if (Array.isArray(value.source)) {
+                source = Buffer.from(value.source);
+            }
+            assets[key] = new webpack_sources_1.RawSource(source);
+        }
+        await this.hooks.processAssets.promise(assets);
+        return createDummyResult(context.id);
+    }
+}
+_RspackCompilation_emitAssetCallback = new WeakMap();
+class Rspack {
+    constructor(options) {
+        var _a;
+        _Rspack_instances.add(this);
+        _Rspack_plugins.set(this, void 0);
+        _Rspack_instance.set(this, void 0);
+        this.options = (0, config_1.resolveOptions)(options);
+        // @ts-ignored
+        __classPrivateFieldSet(this, _Rspack_instance, binding.newRspack(this.options, {
+            doneCallback: __classPrivateFieldGet(this, _Rspack_instances, "m", _Rspack_done).bind(this),
+            processAssetsCallback: __classPrivateFieldGet(this, _Rspack_instances, "m", _Rspack_processAssets).bind(this)
+        }), "f");
+        this.hooks = {
+            done: new tapable.AsyncSeriesHook(),
+            compilation: new tapable.SyncHook(["compilation"])
+        };
+        __classPrivateFieldSet(this, _Rspack_plugins, (_a = options.plugins) !== null && _a !== void 0 ? _a : [], "f");
+        for (const plugin of __classPrivateFieldGet(this, _Rspack_plugins, "f")) {
+            plugin.apply(this);
+        }
+    }
+    async build() {
+        const compilation = __classPrivateFieldGet(this, _Rspack_instances, "m", _Rspack_newCompilation).call(this);
+        const stats = await binding.build(__classPrivateFieldGet(this, _Rspack_instance, "f"));
+        return stats;
+    }
+    async rebuild(changeFiles) {
+        const stats = await binding.rebuild(__classPrivateFieldGet(this, _Rspack_instance, "f"), changeFiles);
+        return stats;
+    }
+}
+exports.Rspack = Rspack;
+_Rspack_plugins = new WeakMap(), _Rspack_instance = new WeakMap(), _Rspack_instances = new WeakSet(), _Rspack_done = async function _Rspack_done(err, value) {
+    if (err) {
+        throw err;
+    }
+    const context = JSON.parse(value);
+    await this.hooks.done.promise();
+    return createDummyResult(context.id);
+}, _Rspack_processAssets = async function _Rspack_processAssets(err, value, emitAsset) {
+    return this.compilation.processAssets(err, value, emitAsset);
+}, _Rspack_newCompilation = function _Rspack_newCompilation() {
+    const compilation = new RspackCompilation();
+    this.compilation = compilation;
+    this.hooks.compilation.call(compilation);
+    return compilation;
+};
+exports.default = Rspack;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rspack/core",
-  "version": "0.0.4",
+  "version": "0.0.6",
   "bin": {
     "rspack": "./bin.js"
   },
@@ -14,20 +14,20 @@
     "@types/ws": "8.5.3",
     "@types/connect": "3.4.35",
     "uvu": "0.5.6",
-    "@rspack/core": "0.0.4",
+    "@rspack/core": "0.0.6",
     "@types/webpack-sources": "3.2.0"
   },
   "dependencies": {
-    "@rspack/binding": "0.0.5",
+    "@rspack/binding": "0.0.6",
     "commander": "9.4.0",
     "ws": "8.8.1",
     "connect": "3.7.0",
     "chokidar": "3.5.3",
     "open": "8.4.0",
     "clipanion": "3.2.0-rc.11",
-    "@rspack/dev-server": "^0.0.4",
+    "@rspack/dev-server": "^0.0.6",
     "sirv": "2.0.2",
-    "@rspack/plugin-postcss": "^0.0.4",
+    "@rspack/plugin-postcss": "^0.0.6",
     "tapable": "2.2.1",
     "webpack-sources": "3.2.3"
   },
@@ -45,6 +45,5 @@
     "dev": "tsc -w",
     "example": "node -r ts-node/register ./example/basic.ts",
     "test": "uvu -r tsm tests"
-  },
-  "readme": "# rspack\n"
+  }
 }