@rspack/core 0.0.3 → 0.0.4

package/CHANGELOG.md

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

package/example/basic.ts

@@ -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/package.json

@@ -1,21 +1,35 @@
 {
   "name": "@rspack/core",
-  "main": "./dist/index.js",
-  "version": "0.0.3",
+  "version": "0.0.4",
   "bin": {
     "rspack": "./bin.js"
   },
-  "types": "./dist/index.d.ts",
+  "main": "./lib/index.js",
+  "types": "./lib/index.d.ts",
   "devDependencies": {
     "@types/node": "^18.6.3",
     "tsm": "^2.2.2",
-    "typescript": "4.7.3"
+    "ts-node": "10.9.1",
+    "typescript": "4.7.3",
+    "@types/ws": "8.5.3",
+    "@types/connect": "3.4.35",
+    "uvu": "0.5.6",
+    "@rspack/core": "0.0.4",
+    "@types/webpack-sources": "3.2.0"
   },
   "dependencies": {
-    "@rspack/binding": "0.0.4",
-    "commander": "^9.4.0",
-    "@rspack/dev-server": "^0.0.3",
-    "@rspack/plugin-postcss": "^0.0.3"
+    "@rspack/binding": "0.0.5",
+    "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",
+    "sirv": "2.0.2",
+    "@rspack/plugin-postcss": "^0.0.4",
+    "tapable": "2.2.1",
+    "webpack-sources": "3.2.3"
   },
   "optionalDependencies": {
     "@tmp-sass-embedded/darwin-arm64": "1.54.4",
@@ -27,8 +41,10 @@
     "@tmp-sass-embedded/win32-x64": "1.54.4"
   },
   "scripts": {
-    "build": "rm -rf dist/ && tsc -p tsconfig.json",
-    "dev": "tsc -p tsconfig.json -w",
-    "example": "node -r tsm ./example/basic.ts"
-  }
+    "build": "rm -rf lib/ && tsc",
+    "dev": "tsc -w",
+    "example": "node -r ts-node/register ./example/basic.ts",
+    "test": "uvu -r tsm tests"
+  },
+  "readme": "# rspack\n"
 }

package/src/config/builtins.ts

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

package/src/config/context.ts

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

package/src/config/define.ts

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

package/src/config/dev.ts

@@ -0,0 +1,32 @@
+import path from "node:path";
+
+export interface Dev {
+	port?: number;
+	static?: {
+		directory?: string;
+	};
+}
+
+export interface ResolvedDev {
+	port: number;
+	static: {
+		directory: string;
+	};
+}
+
+interface ResolveDevConfigContext {
+	context: string;
+}
+
+export function resolveDevOptions(
+	devConfig: Dev = {},
+	context: ResolveDevConfigContext
+): ResolvedDev {
+	return {
+		port: devConfig.port ?? 8080,
+		static: {
+			directory:
+				devConfig.static?.directory ?? path.resolve(context.context, "dist")
+		}
+	};
+}

package/src/config/entry.ts

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

package/src/config/external.ts

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

package/src/config/index.ts

@@ -0,0 +1,80 @@
+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 { resolveTargetOptions } from "./target";
+import { resolveOutputOptions } from "./output";
+import { resolveDevOptions } from "./dev";
+import { resolveModuleOptions } from "./module";
+import { Builtins, ResolvedBuiltins } from "./builtins";
+import { Resolve, ResolvedResolve } from "./resolve";
+
+export type Asset = {
+	source: string;
+};
+export 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 function resolveOptions(config: RspackOptions): ResolvedRspackOptions {
+	const context = config.context ?? process.cwd();
+	const mode = config.mode ?? "development";
+	const dev = resolveDevOptions(config.dev, { context });
+	const entry = config.entry ?? {};
+	const output = resolveOutputOptions(config.output);
+	const define = config.define ?? {};
+	const target = resolveTargetOptions(config.target);
+	const external = config.external ?? {};
+	const plugins = config.plugins ?? [];
+	const builtins = config.builtins ?? [];
+	const resolve = config.resolve ?? {};
+	const module = resolveModuleOptions(config.module);
+	return {
+		context,
+		mode,
+		dev,
+		entry,
+		output,
+		define,
+		target,
+		external,
+		plugins,
+		builtins,
+		module,
+		resolve
+	};
+}

package/src/config/mode.ts

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

package/src/config/module.ts

@@ -0,0 +1,240 @@
+import type { RawModuleRuleUse, RawModuleRule } from "@rspack/binding";
+import assert from "node:assert";
+
+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 {
+	// 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 LoaderResult {
+	content: Buffer | string;
+	meta: Buffer | string;
+}
+
+interface LoaderThreadsafeResult {
+	id: number;
+	p: LoaderResultInternal | null | undefined;
+}
+
+interface LoaderResultInternal {
+	content: number[];
+	meta: number[];
+}
+
+interface LoaderContext
+	extends Pick<
+		LoaderContextInternal,
+		"resource" | "resourcePath" | "resourceQuery" | "resourceFragment"
+	> {
+	source: {
+		getCode(): string;
+		getBuffer(): Buffer;
+	};
+}
+
+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");
+};
+
+interface LoaderThreadsafeContext {
+	id: number;
+	p: LoaderContextInternal;
+}
+
+function composeJsUse(uses: ModuleRuleUse[]): RawModuleRuleUse | null {
+	if (!uses.length) {
+		return null;
+	}
+
+	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
+	};
+}
+
+interface JsLoader {
+	(this: LoaderContext, loaderContext: LoaderContext):
+		| Promise<LoaderResult | void>
+		| LoaderResult
+		| void;
+	displayName?: string;
+}
+
+type BuiltinLoader = string;
+
+type ModuleRuleUse =
+	| {
+			builtinLoader: BuiltinLoader;
+			options?: unknown;
+	  }
+	| {
+			loader: JsLoader;
+			options?: unknown;
+	  };
+
+export function createRawModuleRuleUses(
+	uses: ModuleRuleUse[]
+): RawModuleRuleUse[] {
+	return createRawModuleRuleUsesImpl([...uses].reverse());
+}
+
+function createRawModuleRuleUsesImpl(
+	uses: ModuleRuleUse[]
+): RawModuleRuleUse[] {
+	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): item is RawModuleRuleUse => Boolean(item));
+}
+
+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)
+	};
+}
+
+export function resolveModuleOptions(module: Module = {}): ResolvedModule {
+	const rules = (module.rules ?? []).map(rule => ({
+		...rule,
+		uses: createRawModuleRuleUses(rule.uses || [])
+	}));
+	return {
+		rules
+	};
+}

package/src/config/output.ts

@@ -0,0 +1,29 @@
+export interface Output {
+	path?: string;
+	publicPath?: string;
+	assetModuleFilename?: string;
+	filename?: string;
+	chunkFilename?: string;
+	uniqueName?: string;
+}
+
+// TODO: fix it
+export interface ResolvedOutput {
+	path?: string;
+	publicPath?: string;
+	assetModuleFilename?: string;
+	filename?: string;
+	chunkFilename?: string;
+	uniqueName?: string;
+}
+
+export function resolveOutputOptions(output: Output = {}): ResolvedOutput {
+	return {
+		path: output.path,
+		publicPath: output.publicPath,
+		chunkFilename: output.chunkFilename,
+		filename: output.publicPath,
+		assetModuleFilename: output.assetModuleFilename,
+		uniqueName: output.uniqueName
+	};
+}

package/src/config/plugin.ts

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

package/src/config/resolve.ts

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

package/src/config/target.ts

@@ -0,0 +1,28 @@
+type TargetItem =
+	| "web"
+	| "webworker"
+	| "browserslist"
+	| "es3"
+	| "es5"
+	| "es2015"
+	| "es2016"
+	| "es2017"
+	| "es2018"
+	| "es2019"
+	| "es2020"
+	| "es2021"
+	| "es2022";
+
+export type Target = TargetItem | TargetItem[] | false;
+export type ResolvedTarget = TargetItem[];
+
+export function resolveTargetOptions(target: Target = "web"): ResolvedTarget {
+	if (!target) {
+		return [];
+	}
+	if (!Array.isArray(target)) {
+		return [target];
+	}
+
+	return target;
+}