@rspack/core 0.0.7 → 0.0.9

package/src/config/dev.ts

@@ -1,32 +0,0 @@
-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

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

package/src/config/external.ts

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

package/src/config/index.ts

@@ -1,80 +0,0 @@
-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

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

package/src/config/module.ts

@@ -1,240 +0,0 @@
-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

@@ -1,29 +0,0 @@
-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

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

package/src/config/resolve.ts

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

package/src/config/target.ts

@@ -1,28 +0,0 @@
-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;
-}

package/src/index.ts

@@ -1,140 +0,0 @@
-export * from "./build";
-import * as binding from "@rspack/binding";
-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;
-}
-interface RspackThreadsafeResult<T> {
-	readonly id: number;
-	readonly inner: T;
-}
-const createDummyResult = (id: number): string => {
-	const result: RspackThreadsafeResult<null> = {
-		id,
-		inner: null
-	};
-	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 {
-	#plugins: RspackOptions["plugins"];
-	#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) {
-		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(changeFiles: string[]) {
-		const stats = await binding.rebuild(this.#instance, changeFiles);
-		return stats;
-	}
-}
-export { Rspack };
-export default Rspack;

package/tests/config.test.ts

@@ -1,40 +0,0 @@
-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

@@ -1,14 +0,0 @@
-{
-  "compilerOptions": {
-    "module": "CommonJS",
-    "target": "ES2018",
-    "moduleResolution": "node",
-    "esModuleInterop": true,
-    "outDir": "lib",
-    "declaration": true
-  },
-  "include": ["src"],
-  "ts-node": {
-    "transpileOnly": true
-  }
-}