@rspack/core 0.0.2 → 0.0.6

package/src/index.ts

@@ -1,208 +1,16 @@
 export * from "./build";
-
 import * as binding from "@rspack/binding";
-import type {
-	ExternalObject,
-	RspackInternal,
-	RawModuleRuleUse,
-	RawModuleRule
-} from "@rspack/binding";
-
-import assert from "node:assert";
-import * as Config from "./config";
-import type { RspackOptions } from "./config";
-
-interface ModuleRule {
-	test?: RawModuleRule["test"];
-	resource?: RawModuleRule["resource"];
-	resourceQuery?: RawModuleRule["resourceQuery"];
-	uses?: ModuleRuleUse[];
-	type?: RawModuleRule["type"];
-}
-
-type ModuleRuleUse =
-	| {
-			builtinLoader: BuiltinLoader;
-			options?: unknown;
-	  }
-	| {
-			loader: JsLoader;
-			options?: unknown;
-	  };
-
-interface JsLoader {
-	(this: LoaderContext, loaderContext: LoaderContext):
-		| Promise<LoaderResult | void>
-		| LoaderResult
-		| void;
-	displayName?: string;
-}
-
-type BuiltinLoader = string;
-
-interface LoaderThreadsafeContext {
-	id: number;
-	p: LoaderContextInternal;
-}
-
-interface LoaderContextInternal {
-	// TODO: It's not a good way to do this, we should split the `source` into a separate type and avoid using `serde_json`, but it's a temporary solution.
-	source: number[];
-	resource: String;
-	resourcePath: String;
-	resourceQuery: String | null;
-	resourceFragment: String | null;
-}
-
-interface LoaderContext
-	extends Pick<
-		LoaderContextInternal,
-		"resource" | "resourcePath" | "resourceQuery" | "resourceFragment"
-	> {
-	source: {
-		getCode(): string;
-		getBuffer(): Buffer;
-	};
-}
-
-interface LoaderResultInternal {
-	content: number[];
-	meta: number[];
-}
-
-interface LoaderResult {
-	content: Buffer | string;
-	meta: Buffer | string;
-}
-
-interface LoaderThreadsafeResult {
-	id: number;
-	p: LoaderResultInternal | null | undefined;
-}
-
-const toBuffer = (bufLike: string | Buffer): Buffer => {
-	if (Buffer.isBuffer(bufLike)) {
-		return bufLike;
-	} else if (typeof bufLike === "string") {
-		return Buffer.from(bufLike);
-	}
-
-	throw new Error("Buffer or string expected");
-};
-
-function createRawModuleRuleUses(uses: ModuleRuleUse[]): RawModuleRuleUse[] {
-	return createRawModuleRuleUsesImpl([...uses].reverse());
-}
-
-function createRawModuleRuleUsesImpl(
-	uses: ModuleRuleUse[]
-): RawModuleRuleUse[] {
-	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)
-	];
-}
-
-function createNativeUse(use: ModuleRuleUse): RawModuleRuleUse {
-	assert("builtinLoader" in use);
-
-	if (use.builtinLoader === "sass-loader") {
-		(use.options ??= {} as any).__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 composeJsUse(uses: ModuleRuleUse[]): RawModuleRuleUse {
-	async function loader(err: any, data: Buffer): Promise<Buffer> {
-		if (err) {
-			throw err;
-		}
-
-		const loaderThreadsafeContext: LoaderThreadsafeContext = JSON.parse(
-			data.toString("utf-8")
-		);
-
-		const { p: payload, id } = loaderThreadsafeContext;
-
-		const loaderContextInternal: 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) {
-			assert("loader" in use);
-			const loaderContext = {
-				...loaderContextInternal,
-				source: {
-					getCode(): string {
-						return sourceBuffer.toString("utf-8");
-					},
-					getBuffer(): Buffer {
-						return sourceBuffer;
-					}
-				},
-				getOptions() {
-					return use.options;
-				}
-			};
-
-			let loaderResult: 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: LoaderResultInternal = {
-			content: [...sourceBuffer],
-			meta: [...meta]
-		};
-
-		const loaderThreadsafeResult: LoaderThreadsafeResult = {
-			id: id,
-			p: loaderResultPayload
-		};
-		return Buffer.from(JSON.stringify(loaderThreadsafeResult), "utf-8");
-	}
-	loader.displayName = `NodeLoaderAdapter(${uses
-		.map(item => {
-			assert("loader" in item);
-			return item.loader.displayName || item.loader.name || "unknown-loader";
-		})
-		.join(" -> ")})`;
-	return {
-		loader
-	};
-}
+import type { ExternalObject, RspackInternal } from "@rspack/binding";
+import * as tapable from "tapable";
+import {
+	RspackOptions,
+	ResolvedRspackOptions,
+	Assets,
+	Asset,
+	resolveOptions
+} from "./config";
+
+import { RawSource, Source } from "webpack-sources";
 interface RspackThreadsafeContext<T> {
 	readonly id: number;
 	readonly inner: T;
@@ -218,35 +26,115 @@ const createDummyResult = (id: number): string => {
 	};
 	return JSON.stringify(result);
 };
+type EmitAssetCallback = (options: { filename: string; asset: Asset }) => void;
+class RspackCompilation {
+	#emitAssetCallback: EmitAssetCallback;
+	hooks: {
+		processAssets: tapable.AsyncSeriesHook<Record<string, Source>>;
+	};
+	constructor() {
+		this.hooks = {
+			processAssets: new tapable.AsyncSeriesHook<Record<string, Source>>([
+				"assets"
+			])
+		};
+	}
+	/**
+	 * unsafe to call out of processAssets
+	 * @param filename
+	 * @param asset
+	 */
+	updateAsset(filename: string, asset: Asset) {
+		this.emitAsset(filename, asset);
+	}
+	/**
+	 * unsafe to call out of processAssets
+	 * @param filename
+	 * @param asset
+	 */
+	emitAsset(filename: string, asset: Asset) {
+		if (!this.#emitAssetCallback) {
+			throw new Error("can't call emitAsset outof processAssets hook for now");
+		}
+		this.#emitAssetCallback({
+			filename: filename,
+			asset
+		});
+	}
+	async processAssets(err: Error, value: string, emitAsset: any) {
+		this.#emitAssetCallback = emitAsset;
+		if (err) {
+			throw err;
+		}
+		const context: RspackThreadsafeContext<
+			Record<string, { source: string | Buffer }>
+		> = JSON.parse(value);
+		let content: Record<string, { source: string | Buffer }> =
+			context.inner ?? {};
+		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 RawSource(source as string);
+		}
+		await this.hooks.processAssets.promise(assets);
+		return createDummyResult(context.id);
+	}
+}
 class Rspack {
-	#instance: ExternalObject<RspackInternal>;
 	#plugins: RspackOptions["plugins"];
-	constructor(public options: RspackOptions) {
-		const nativeConfig = Config.User2Native(options);
-		this.#plugins = options.plugins ?? [];
-
-		this.#instance = binding.newRspack(nativeConfig, {
-			doneCallback: this.#done.bind(this)
+	#instance: ExternalObject<RspackInternal>;
+	compilation: RspackCompilation;
+	hooks: {
+		done: tapable.AsyncSeriesHook<void>;
+		compilation: tapable.SyncHook<RspackCompilation>;
+	};
+	options: ResolvedRspackOptions;
+	constructor(options: RspackOptions) {
+		this.options = resolveOptions(options);
+		// @ts-ignored
+		this.#instance = binding.newRspack(this.options, {
+			doneCallback: this.#done.bind(this),
+			processAssetsCallback: this.#processAssets.bind(this)
 		});
+		this.hooks = {
+			done: new tapable.AsyncSeriesHook<void>(),
+			compilation: new tapable.SyncHook<RspackCompilation>(["compilation"])
+		};
+		this.#plugins = options.plugins ?? [];
+		for (const plugin of this.#plugins) {
+			plugin.apply(this);
+		}
 	}
 	async #done(err: Error, value: string) {
-		const context: RspackThreadsafeContext<void> = JSON.parse(value);
-		for (const plugin of this.#plugins) {
-			await plugin.done?.();
+		if (err) {
+			throw err;
 		}
+		const context: RspackThreadsafeContext<void> = JSON.parse(value);
+		await this.hooks.done.promise();
 		return createDummyResult(context.id);
 	}
+	async #processAssets(err: Error, value: string, emitAsset: any) {
+		return this.compilation.processAssets(err, value, emitAsset);
+	}
+	#newCompilation() {
+		const compilation = new RspackCompilation();
+		this.compilation = compilation;
+		this.hooks.compilation.call(compilation);
+		return compilation;
+	}
 	async build() {
+		const compilation = this.#newCompilation();
 		const stats = await binding.build(this.#instance);
 		return stats;
 	}
-
-	async rebuild() {
-		const stats = await binding.rebuild(this.#instance);
+	async rebuild(changeFiles: string[]) {
+		const stats = await binding.rebuild(this.#instance, changeFiles);
 		return stats;
 	}
 }
-
-export { Rspack, createRawModuleRuleUses };
-export type { ModuleRule };
+export { Rspack };
 export default Rspack;

package/tests/config.test.ts

@@ -0,0 +1,40 @@
+import { test } from "uvu";
+import * as assert from "uvu/assert";
+import { Rspack } from "@rspack/core";
+import path from "path";
+
+test("default config snapshot", () => {
+	const resolvedOptions = new Rspack({}).options;
+
+	assert.equal(resolvedOptions.context, process.cwd());
+	assert.equal(
+		resolvedOptions.dev.static.directory,
+		path.resolve(process.cwd(), "./dist")
+	);
+
+	// TypeScript will throw `The operand of a 'delete' operator must be optional`.
+	// But we remove these configurations with absolute paths.
+	// @ts-expect-error
+	delete resolvedOptions.context;
+	// @ts-expect-error
+	delete resolvedOptions.dev.static.directory;
+
+	assert.snapshot(
+		JSON.stringify(resolvedOptions),
+		JSON.stringify({
+			mode: "development",
+			dev: { port: 8080, static: {} },
+			entry: {},
+			output: {},
+			define: {},
+			target: ["web"],
+			external: {},
+			plugins: [],
+			builtins: [],
+			module: { rules: [] },
+			resolve: {}
+		})
+	);
+});
+
+test.run();

package/tsconfig.json

@@ -4,10 +4,11 @@
     "target": "ES2018",
     "moduleResolution": "node",
     "esModuleInterop": true,
-    "outDir": "dist",
+    "outDir": "lib",
     "declaration": true
   },
-  "include": [
-    "src"
-  ]
-}
+  "include": ["src"],
+  "ts-node": {
+    "transpileOnly": true
+  }
+}

package/dist/config.d.ts

@@ -1,43 +0,0 @@
-import type { RawOptions } from "@rspack/binding";
-import type { ModuleRule } from ".";
-export declare type Plugin = {
-    name: string;
-    done?: () => void | Promise<void>;
-};
-export interface RspackOptions {
-    /**
-     * Entry points of compilation.
-     */
-    entry?: RawOptions["entry"];
-    /**
-     * An **absolute** path pointed the
-     */
-    context?: RawOptions["context"];
-    /**
-     * An array of plugins
-     */
-    plugins?: Plugin[];
-    /**
-     * dev server
-     */
-    dev?: {
-        port?: Number;
-        static?: {
-            directory?: string;
-        };
-    };
-    /**
-     * Module configuration.
-     */
-    module?: {
-        rules?: ModuleRule[];
-        parser?: RawOptions["module"]["parser"];
-    };
-    define?: RawOptions["define"];
-    target?: RawOptions["target"];
-    mode?: RawOptions["mode"];
-    external?: RawOptions["external"];
-}
-export declare function User2Native(config: RspackOptions): RawOptions & {
-    plugins: Plugin[];
-};

package/dist/config.js

@@ -1,25 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.User2Native = void 0;
-const _1 = require(".");
-function User2Native(config) {
-    var _a, _b, _c, _d;
-    return {
-        entry: (_a = config.entry) !== null && _a !== void 0 ? _a : {},
-        context: config.context,
-        define: config.define,
-        target: config.target,
-        external: config.external,
-        plugins: (_b = config.plugins) !== null && _b !== void 0 ? _b : [],
-        module: {
-            // TODO: support mutliple rules to support `Module Type`
-            rules: ((_d = (_c = config === null || config === void 0 ? void 0 : config.module) === null || _c === void 0 ? void 0 : _c.rules) !== null && _d !== void 0 ? _d : []).map(rule => {
-                return {
-                    ...rule,
-                    uses: (0, _1.createRawModuleRuleUses)(rule.uses || [])
-                };
-            })
-        }
-    };
-}
-exports.User2Native = User2Native;

package/dist/index.js

@@ -1,184 +0,0 @@
-"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 __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 __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 __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-var _Rspack_instances, _Rspack_instance, _Rspack_plugins, _Rspack_done;
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createRawModuleRuleUses = exports.Rspack = void 0;
-__exportStar(require("./build"), exports);
-const binding = __importStar(require("@rspack/binding"));
-const node_assert_1 = __importDefault(require("node:assert"));
-const Config = __importStar(require("./config"));
-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 createRawModuleRuleUses(uses) {
-    return createRawModuleRuleUsesImpl([...uses].reverse());
-}
-exports.createRawModuleRuleUses = createRawModuleRuleUses;
-function createRawModuleRuleUsesImpl(uses) {
-    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)
-    ];
-}
-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 composeJsUse(uses) {
-    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
-    };
-}
-const createDummyResult = (id) => {
-    const result = {
-        id,
-        inner: null
-    };
-    return JSON.stringify(result);
-};
-class Rspack {
-    constructor(options) {
-        var _a;
-        this.options = options;
-        _Rspack_instances.add(this);
-        _Rspack_instance.set(this, void 0);
-        _Rspack_plugins.set(this, void 0);
-        const nativeConfig = Config.User2Native(options);
-        __classPrivateFieldSet(this, _Rspack_plugins, (_a = options.plugins) !== null && _a !== void 0 ? _a : [], "f");
-        __classPrivateFieldSet(this, _Rspack_instance, binding.newRspack(nativeConfig, {
-            doneCallback: __classPrivateFieldGet(this, _Rspack_instances, "m", _Rspack_done).bind(this)
-        }), "f");
-    }
-    async build() {
-        const stats = await binding.build(__classPrivateFieldGet(this, _Rspack_instance, "f"));
-        return stats;
-    }
-    async rebuild() {
-        const stats = await binding.rebuild(__classPrivateFieldGet(this, _Rspack_instance, "f"));
-        return stats;
-    }
-}
-exports.Rspack = Rspack;
-_Rspack_instance = new WeakMap(), _Rspack_plugins = new WeakMap(), _Rspack_instances = new WeakSet(), _Rspack_done = async function _Rspack_done(err, value) {
-    var _a;
-    const context = JSON.parse(value);
-    for (const plugin of __classPrivateFieldGet(this, _Rspack_plugins, "f")) {
-        await ((_a = plugin.done) === null || _a === void 0 ? void 0 : _a.call(plugin));
-    }
-    return createDummyResult(context.id);
-};
-exports.default = Rspack;