@rspack/core 0.0.0-20220909025136

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

@@ -0,0 +1,49 @@
+{
+  "name": "@rspack/core",
+  "version": "0.0.0-20220909025136",
+  "bin": {
+    "rspack": "./bin.js"
+  },
+  "main": "./lib/index.js",
+  "types": "./lib/index.d.ts",
+  "devDependencies": {
+    "@types/node": "^18.6.3",
+    "tsm": "^2.2.2",
+    "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.0-20220909025136",
+    "@types/webpack-sources": "3.2.0"
+  },
+  "dependencies": {
+    "@rspack/binding": "0.0.0-20220909025136",
+    "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.0-20220909025136",
+    "sirv": "2.0.2",
+    "@rspack/plugin-postcss": "^0.0.0-20220909025136",
+    "tapable": "2.2.1",
+    "webpack-sources": "3.2.3"
+  },
+  "optionalDependencies": {
+    "@tmp-sass-embedded/darwin-arm64": "1.54.4",
+    "@tmp-sass-embedded/darwin-x64": "1.54.4",
+    "@tmp-sass-embedded/linux-arm64": "1.54.4",
+    "@tmp-sass-embedded/linux-ia32": "1.54.4",
+    "@tmp-sass-embedded/linux-x64": "1.54.4",
+    "@tmp-sass-embedded/win32-ia32": "1.54.4",
+    "@tmp-sass-embedded/win32-x64": "1.54.4"
+  },
+  "scripts": {
+    "build": "rm -rf lib/ && tsc",
+    "dev": "tsc -w",
+    "example": "node -r ts-node/register ./example/basic.ts",
+    "test": "uvu -r tsm tests"
+  }
+}

package/src/bin/index.ts

@@ -0,0 +1,36 @@
+import { Command } from "commander";
+import { createServer } from "@rspack/dev-server";
+import { Rspack } from "..";
+import fs from "fs";
+import { build } from "../build";
+
+const program = new 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 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 Rspack(config);
+		const { options: { dev: { port = 8080 } = {} } = {} } = rspack;
+		await rspack.build();
+		const server = await createServer(rspack.options);
+		server.listen(port, () => console.log(`Server listening on port: ${port}`));
+	});
+
+program.parse();

package/src/build.ts

@@ -0,0 +1,8 @@
+import { Rspack } from ".";
+export async function build(config: any) {
+	const rspack = new Rspack(config);
+	const stats = await rspack.build();
+	if (stats.errors.length > 0) {
+		throw new Error(stats.errors[0].message);
+	}
+}

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
+	};
+}