@rspack/core 0.0.0-20220909025136

package/CHANGELOG.md

@@ -0,0 +1,51 @@
+# @rspack/core
+
+## 0.0.0-20220909025136
+
+### Patch Changes
+
+- 53ee00d1: test alpha publish
+- Updated dependencies [53ee00d1]
+  - @rspack/binding@0.0.0-20220909025136
+  - @rspack/dev-server@0.0.0-20220909025136
+  - @rspack/plugin-postcss@0.0.0-20220909025136
+
+## 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
+
+- 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
+
+- 536f6f70: fix broken lib
+- Updated dependencies [536f6f70]
+  - @rspack/binding@0.0.4
+  - @rspack/dev-server@0.0.3
+  - @rspack/plugin-postcss@0.0.3
+
+## 0.0.2
+
+### Patch Changes
+
+- bd57e818: first release
+- Updated dependencies [bd57e818]
+  - @rspack/binding@0.0.2
+  - rspack-dev-server@0.0.2
+  - rspack-plugin-postcss@0.0.2

package/README.md

@@ -0,0 +1 @@
+# rspack

package/bin.js

@@ -0,0 +1 @@
+require("./dist/bin/index");

package/dist/bin/index.d.ts

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

package/dist/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/dist/build.d.ts

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

package/dist/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/dist/config.d.ts

@@ -0,0 +1,51 @@
+/// <reference types="node" />
+import type { RawOptions } from "@rspack/binding";
+import type { ModuleRule } from ".";
+import Rspack from ".";
+export declare type Asset = {
+    source?: string;
+    buffer?: Buffer;
+};
+export declare type Assets = Record<string, Asset>;
+export declare type Plugin = {
+    name: string;
+    apply(compiler: Rspack): 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"];
+    output?: RawOptions["output"];
+}
+export declare function User2Native(config: RspackOptions): RawOptions & {
+    plugins: Plugin[];
+};

package/dist/config.js

@@ -0,0 +1,26 @@
+"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,
+        output: config.output,
+        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.d.ts

@@ -0,0 +1,73 @@
+/// <reference types="node" />
+export * from "./build";
+import * as binding from "@rspack/binding";
+import type { RawModuleRuleUse, RawModuleRule } from "@rspack/binding";
+import * as tapable from "tapable";
+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"];
+}
+declare type ModuleRuleUse = {
+    builtinLoader: BuiltinLoader;
+    options?: unknown;
+} | {
+    loader: JsLoader;
+    options?: unknown;
+};
+interface JsLoader {
+    (this: LoaderContext, loaderContext: LoaderContext): Promise<LoaderResult | void> | LoaderResult | void;
+    displayName?: string;
+}
+declare type BuiltinLoader = string;
+interface LoaderContextInternal {
+    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 LoaderResult {
+    content: Buffer | string;
+    meta: Buffer | string;
+}
+declare function createRawModuleRuleUses(uses: ModuleRuleUse[]): RawModuleRuleUse[];
+declare type EmitAssetCallback = (options: {
+    filename: string;
+    asset: Config.Asset;
+}) => void;
+declare class RspackCompilation {
+    emitAssetCallback: EmitAssetCallback;
+    hooks: {
+        processAssets: tapable.AsyncSeriesHook<Config.Assets>;
+    };
+    constructor();
+    updateAsset(filename: string, asset: Config.Asset): void;
+    emitAsset(finame: string, asset: Config.Asset): void;
+    procssAssets(err: Error, value: string, emitAsset: any): Promise<string>;
+}
+declare class Rspack {
+    #private;
+    options: RspackOptions;
+    compilation: RspackCompilation;
+    hooks: {
+        done: tapable.AsyncSeriesHook<void>;
+        compilation: tapable.SyncHook<RspackCompilation>;
+    };
+    constructor(options: RspackOptions);
+    build(): Promise<binding.Stats>;
+    rebuild(): Promise<Record<string, string>>;
+}
+export { Rspack, createRawModuleRuleUses };
+export type { ModuleRule };
+export default Rspack;

package/dist/index.js

@@ -0,0 +1,229 @@
+"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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+var _Rspack_instances, _Rspack_plugins, _Rspack_instance, _Rspack_done, _Rspack_procssAssets, _Rspack_newCompilation;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createRawModuleRuleUses = exports.Rspack = void 0;
+__exportStar(require("./build"), exports);
+const binding = __importStar(require("@rspack/binding"));
+const tapable = __importStar(require("tapable"));
+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 RspackCompilation {
+    constructor() {
+        this.hooks = {
+            processAssets: new tapable.AsyncSeriesHook(["assets"])
+        };
+    }
+    updateAsset(filename, asset) {
+        this.emitAsset(filename, asset);
+    }
+    emitAsset(finame, asset) {
+        if (!this.emitAssetCallback) {
+            throw new Error("can't call emitAsset outof processAssets hook for now");
+        }
+        this.emitAssetCallback({
+            filename: finame,
+            asset
+        });
+    }
+    async procssAssets(err, value, emitAsset) {
+        this.emitAssetCallback = emitAsset;
+        if (err) {
+            throw err;
+        }
+        const context = JSON.parse(value);
+        await this.hooks.processAssets.promise(context === null || context === void 0 ? void 0 : context.inner);
+        return createDummyResult(context.id);
+    }
+}
+class Rspack {
+    constructor(options) {
+        var _a;
+        this.options = options;
+        _Rspack_instances.add(this);
+        _Rspack_plugins.set(this, void 0);
+        _Rspack_instance.set(this, void 0);
+        const nativeConfig = Config.User2Native(options);
+        __classPrivateFieldSet(this, _Rspack_instance, binding.newRspack(nativeConfig, {
+            doneCallback: __classPrivateFieldGet(this, _Rspack_instances, "m", _Rspack_done).bind(this),
+            processAssetsCallback: __classPrivateFieldGet(this, _Rspack_instances, "m", _Rspack_procssAssets).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() {
+        const stats = await binding.rebuild(__classPrivateFieldGet(this, _Rspack_instance, "f"));
+        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_procssAssets = async function _Rspack_procssAssets(err, value, emitAsset) {
+    return this.compilation.procssAssets(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/example/basic.ts

@@ -0,0 +1,71 @@
+import path from "path";
+import postcssLoader from "@rspack/plugin-postcss";
+import { Rspack } from "../src";
+
+const rspack = new Rspack({
+	entry: {
+		main: path.resolve(__dirname, "../../../examples/postcss/index.js")
+	},
+	context: path.resolve(__dirname, "../../../examples/postcss"),
+	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: [
+			{
+				test: ".module.css$",
+				uses: [
+					{
+						loader: postcssLoader,
+						options: {
+							modules: true
+						}
+					}
+					// {
+					// 	loader: function testLoader(loaderContext) {
+					// 		// console.log(loaderContext);
+					// 		return {
+					// 			content: loaderContext.source.getBufFer(),
+					// 			meta: Buffer.from("something")
+					// 		};
+					// 	}
+					// }
+				]
+			}
+		]
+	}
+});
+
+async function main() {
+	const stats = await rspack.build();
+	console.log(stats);
+	// assert(stats.assets.length > 0)
+}
+
+main();

package/example/react-example/index.html

@@ -0,0 +1,12 @@
+<!DOCTYPE html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta http-equiv="X-UA-Compatible" content="IE=edge" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>Document</title>
+  </head>
+  <body>
+    <div id="root"></div>
+  </body>
+</html>

package/example/react-example/package.json

@@ -0,0 +1,17 @@
+{
+  "name": "react-example",
+  "version": "1.0.0",
+  "description": "",
+  "main": "index.js",
+  "scripts": {
+    "dev": "rspack dev rspack.config.json"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "dependencies": {
+    "@rspack/core": "workspace:*",
+    "react": "17.0.0",
+    "react-dom": "17.0.0"
+  }
+}

package/example/react-example/rspack.config.json

@@ -0,0 +1,13 @@
+{
+  "mode": "development",
+  "entry": {
+    "main": "./src/index.js"
+  },
+  "dev": {
+    "port": 8081,
+    "static": {
+      "directory": "dist"
+    }
+  },
+  "plugins": ["html"]
+}

package/example/react-example/src/app.jsx

@@ -0,0 +1,44 @@
+import React from 'react';
+import ReactDOM from 'react-dom';
+import './base.css';
+import LogoJPG from './file.jpg';
+import LogoPNG from './file.png';
+import LogoSVG from './file.svg';
+import Json from './data.json';
+// import Dark from './dark.svg';
+// import Light from './light.svg'
+// import LogoUrl from './logo.svg'
+// import Logo from './logo.svg'
+// const Button = React.lazy(() => import('../src/button'))
+
+// console.log('LogoUrl', LogoUrl)
+// console.log('Logo', Logo)
+
+const App = () => {
+  return (
+    <React.Suspense fallback={<div>loading...</div>}>
+      <div>hello world</div>
+      {/* <Button></Button> */}
+
+      <img
+        style={{ width: '40px', height: '40px' }}
+        src={LogoJPG}
+        alt="logo jpg"
+      />
+      <img
+        style={{ width: '40px', height: '40px' }}
+        src={LogoPNG}
+        alt="logo png"
+      />
+      <img
+        style={{ width: '40px', height: '40px' }}
+        src={LogoSVG}
+        alt="logo svg"
+      />
+      {/* <Logo width={'40px'} height={'40px'} />
+      <Light width={'40px'} height={'40px'} />
+      <Dark width={'40px'} height={'40px'} /> */}
+    </React.Suspense>
+  );
+};
+ReactDOM.render(<App />, document.getElementById('root'));

package/example/react-example/src/base.css

@@ -0,0 +1,9 @@
+@import './foo.css';
+
+body {
+  background: gray;
+  background-image: url('./logo.svg');
+}
+.class {
+  box-shadow: 10px 5px 5px red;
+}

package/example/react-example/src/button.jsx

@@ -0,0 +1,3 @@
+import React from 'react'
+const button = () => <div>cute button</div>
+export default button

package/example/react-example/src/dark.svg

@@ -0,0 +1 @@
+<?xml version="1.0" standalone="no"?><!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd"><svg t="1599669065723" class="icon" viewBox="0 0 1024 1024" version="1.1" xmlns="http://www.w3.org/2000/svg" p-id="18411" width="32" height="32" xmlns:xlink="http://www.w3.org/1999/xlink"><defs><style type="text/css"></style></defs><path d="M390 250c0-52.6 10.6-102.6 29.8-148.2C237.4 146 102 310.2 102 506c0 229.6 186.4 416 416 416 195.8 0 360-135.4 404.2-317.8-45.6 19.2-95.8 29.8-148.2 29.8-212 0-384-172-384-384z" p-id="18412"></path></svg>