@esmx/rspack 3.0.0-rc.11 → 3.0.0-rc.111

package/src/rspack/pack.test.ts

@@ -0,0 +1,215 @@
+import type { ManifestJsonExports } from '@esmx/core';
+import { describe, expect, it } from 'vitest';
+import { contentHash, generateExports } from './pack';
+
+describe('generateExports', () => {
+    it('should generate exports with both client and server files', () => {
+        const clientExports: ManifestJsonExports = {
+            'src/entry.client': {
+                file: 'src/entry.client.95f6085b.final.mjs',
+                name: 'src/entry.client',
+                pkg: true,
+                identifier: 'ssr-vue2-remote/src/entry.client'
+            },
+            'src/components/index': {
+                file: 'src/components/index.a73d6772.final.mjs',
+                name: 'src/components/index',
+                pkg: true,
+                identifier: 'ssr-vue2-remote/src/components/index'
+            }
+        };
+
+        const serverExports: ManifestJsonExports = {
+            'src/entry.server': {
+                file: 'src/entry.server.b85ed2ff.final.mjs',
+                name: 'src/entry.server',
+                pkg: true,
+                identifier: 'ssr-vue2-remote/src/entry.server'
+            },
+            'src/components/index': {
+                file: 'src/components/index.12b57db5.final.mjs',
+                name: 'src/components/index',
+                pkg: true,
+                identifier: 'ssr-vue2-remote/src/components/index'
+            }
+        };
+
+        const result = generateExports({
+            client: clientExports,
+            server: serverExports
+        });
+
+        expect(result).toEqual({
+            './src/entry.client':
+                './client/src/entry.client.95f6085b.final.mjs',
+            './src/entry.server':
+                './server/src/entry.server.b85ed2ff.final.mjs',
+            './src/components/index': {
+                default: './server/src/components/index.12b57db5.final.mjs',
+                browser: './client/src/components/index.a73d6772.final.mjs'
+            }
+        });
+    });
+
+    it('should merge with existing exports', () => {
+        const clientExports: ManifestJsonExports = {
+            index: {
+                file: 'index.js',
+                name: 'index',
+                pkg: true,
+                identifier: 'index'
+            }
+        };
+
+        const serverExports: ManifestJsonExports = {
+            index: {
+                file: 'index.js',
+                name: 'index',
+                pkg: true,
+                identifier: 'index'
+            }
+        };
+
+        const existingExports = {
+            './custom': './custom.js'
+        };
+
+        const result = generateExports({
+            client: clientExports,
+            server: serverExports,
+            base: existingExports
+        });
+
+        expect(result).toEqual({
+            './custom': './custom.js',
+            '.': {
+                default: './server/index.js',
+                browser: './client/index.js'
+            }
+        });
+    });
+
+    it('should handle empty exports', () => {
+        const clientExports: ManifestJsonExports = {};
+        const serverExports: ManifestJsonExports = {};
+
+        const result = generateExports({
+            client: clientExports,
+            server: serverExports
+        });
+
+        expect(result).toEqual({});
+    });
+
+    it('should handle only client exports', () => {
+        const clientExports: ManifestJsonExports = {
+            utils: {
+                file: 'utils.js',
+                name: 'utils',
+                pkg: true,
+                identifier: 'utils'
+            }
+        };
+
+        const serverExports: ManifestJsonExports = {};
+
+        const result = generateExports({
+            client: clientExports,
+            server: serverExports
+        });
+
+        expect(result).toEqual({
+            './utils': './client/utils.js'
+        });
+    });
+
+    it('should handle only server exports', () => {
+        const clientExports: ManifestJsonExports = {};
+
+        const serverExports: ManifestJsonExports = {
+            api: {
+                file: 'api.js',
+                name: 'api',
+                pkg: true,
+                identifier: 'api'
+            }
+        };
+
+        const result = generateExports({
+            client: clientExports,
+            server: serverExports
+        });
+
+        expect(result).toEqual({
+            './api': './server/api.js'
+        });
+    });
+
+    it('should handle index export correctly', () => {
+        const clientExports: ManifestJsonExports = {
+            index: {
+                file: 'index.js',
+                name: 'index',
+                pkg: true,
+                identifier: 'index'
+            }
+        };
+
+        const serverExports: ManifestJsonExports = {
+            index: {
+                file: 'index.js',
+                name: 'index',
+                pkg: true,
+                identifier: 'index'
+            }
+        };
+
+        const result = generateExports({
+            client: clientExports,
+            server: serverExports
+        });
+
+        expect(result).toEqual({
+            '.': {
+                default: './server/index.js',
+                browser: './client/index.js'
+            }
+        });
+    });
+});
+
+describe('contentHash', () => {
+    it('should generate SHA256 hash for buffer', () => {
+        const buffer = Buffer.from('test content');
+        const result = contentHash(buffer);
+
+        expect(result).toMatch(/^sha256-[a-f0-9]{64}$/);
+        expect(result).toBe(
+            'sha256-6ae8a75555209fd6c44157c0aed8016e763ff435a19cf186f76863140143ff72'
+        );
+    });
+
+    it('should use custom algorithm when provided', () => {
+        const buffer = Buffer.from('test content');
+        const result = contentHash(buffer, 'md5');
+
+        expect(result).toMatch(/^md5-[a-f0-9]{32}$/);
+        expect(result).toBe('md5-9473fdd0d880a43c21b7778d34872157');
+    });
+
+    it('should handle empty buffer', () => {
+        const buffer = Buffer.from('');
+        const result = contentHash(buffer);
+
+        expect(result).toBe(
+            'sha256-e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855'
+        );
+    });
+
+    it('should handle binary data', () => {
+        const buffer = Buffer.from([0x00, 0x01, 0x02, 0x03, 0xff]);
+        const result = contentHash(buffer);
+
+        expect(result).toMatch(/^sha256-[a-f0-9]{64}$/);
+    });
+});

package/src/rspack/pack.ts

@@ -0,0 +1,101 @@
+import crypto from 'node:crypto';
+import type { Esmx, ManifestJson } from '@esmx/core';
+import Arborist from '@npmcli/arborist';
+import pacote from 'pacote';
+
+export async function pack(esmx: Esmx): Promise<boolean> {
+    const { packConfig } = esmx;
+
+    const pkgJson = await packConfig.packageJson(
+        esmx,
+        await buildPackageJson(esmx)
+    );
+    esmx.writeSync(
+        esmx.resolvePath('dist/package.json'),
+        JSON.stringify(pkgJson, null, 4)
+    );
+
+    if (!packConfig.enable) {
+        return true;
+    }
+
+    await packConfig.onBefore(esmx, pkgJson);
+
+    const data = await pacote.tarball(esmx.resolvePath('dist'), {
+        Arborist
+    });
+    const hash = contentHash(data);
+    packConfig.outputs.forEach((file) => {
+        const tgz = esmx.resolvePath('./', file);
+        const txt = tgz.replace(/\.tgz$/, '.txt');
+        esmx.writeSync(tgz, data);
+        esmx.writeSync(txt, hash);
+    });
+
+    await packConfig.onAfter(esmx, pkgJson, data);
+    return true;
+}
+
+export interface GenerateExportsOptions {
+    client: ManifestJson['exports'];
+    server: ManifestJson['exports'];
+    base?: Record<string, unknown>;
+}
+
+export function generateExports(
+    options: GenerateExportsOptions
+): Record<string, unknown> {
+    const { client, server, base = {} } = options;
+    const exports: Record<string, unknown> = { ...base };
+
+    const set = new Set([...Object.keys(client), ...Object.keys(server)]);
+
+    set.forEach((name) => {
+        const clientExport = client[name];
+        const serverExport = server[name];
+        const exportName = name === 'index' ? '.' : `./${name}`;
+
+        if (clientExport && serverExport) {
+            exports[exportName] = {
+                default: `./server/${serverExport.file}`,
+                browser: `./client/${clientExport.file}`
+            };
+        } else if (clientExport) {
+            exports[exportName] = `./client/${clientExport.file}`;
+        } else if (serverExport) {
+            exports[exportName] = `./server/${serverExport.file}`;
+        }
+    });
+
+    return exports;
+}
+
+async function buildPackageJson(esmx: Esmx): Promise<Record<string, any>> {
+    const [clientJson, serverJson, curJson] = await Promise.all([
+        esmx.readJson<ManifestJson>(
+            esmx.resolvePath('dist/client/manifest.json')
+        ),
+        esmx.readJson<ManifestJson>(
+            esmx.resolvePath('dist/server/manifest.json')
+        ),
+        esmx.readJson(esmx.resolvePath('package.json'))
+    ]);
+
+    const exports = generateExports({
+        client: clientJson.exports,
+        server: serverJson.exports,
+        base: curJson?.exports
+    });
+
+    const buildJson: Record<string, any> = {
+        ...curJson,
+        exports
+    };
+    return buildJson;
+}
+
+export function contentHash(buffer: Buffer, algorithm = 'sha256') {
+    const hash = crypto.createHash(algorithm);
+    hash.update(buffer);
+    return `${algorithm}-${hash.digest('hex')}`;
+}

package/src/{utils → rspack/utils}/rsbuild.ts

@@ -1,5 +1,9 @@
 import { styleText } from 'node:util';
-import { type Compiler, type RspackOptions, rspack } from '@rspack/core';
+import { type RspackOptions, rspack } from '@rspack/core';
+
+function showError(message: string) {
+    console.error(styleText('red', message));
+}
 
 export function createRsBuild(options: RspackOptions[]) {
     const multiCompiler = rspack(options);
@@ -11,19 +15,20 @@ export function createRsBuild(options: RspackOptions[]) {
             return new Promise<boolean>((resolve) => {
                 multiCompiler.run((err, stats) => {
                     if (err) {
+                        showError(err.message);
                         return resolve(false);
                     }
                     if (stats?.hasErrors()) {
                         stats
                             .toJson({ errors: true })
                             ?.errors?.forEach((err) => {
-                                console.log(styleText('red', err.message));
+                                showError(err.message);
                             });
                         return resolve(false);
                     }
                     multiCompiler.close((err) => {
                         if (err) {
-                            console.log(styleText('red', err.message));
+                            showError(err.message);
                             return resolve(false);
                         }
                         process.nextTick(() => {
@@ -36,7 +41,7 @@ export function createRsBuild(options: RspackOptions[]) {
         watch() {
             const watching = multiCompiler.watch({}, (err, stats) => {
                 if (err) {
-                    console.error(err);
+                    console.log(styleText('red', err.message));
                     return;
                 }
                 if (stats?.hasErrors()) {
@@ -46,7 +51,7 @@ export function createRsBuild(options: RspackOptions[]) {
                 }
             });
 
-            // 监听进程信号，确保优雅退出
+            // Listen to process signals to ensure graceful shutdown
             const signals = ['SIGINT', 'SIGTERM', 'SIGHUP'] satisfies string[];
             signals.forEach((signal) => {
                 process.on(signal, () => {
@@ -56,7 +61,7 @@ export function createRsBuild(options: RspackOptions[]) {
                 });
             });
 
-            // 监听未捕获的异常和 Promise 拒绝
+            // Listen to uncaught exceptions and Promise rejections
             process.on('uncaughtException', handleExit);
             process.on('unhandledRejection', handleExit);
 
@@ -69,37 +74,3 @@ export function createRsBuild(options: RspackOptions[]) {
         }
     };
 }
-
-export class RsBuild {
-    private compiler: Compiler;
-    public constructor(options: RspackOptions) {
-        this.compiler = rspack(options);
-    }
-    public async build() {
-        return new Promise<boolean>((resolve) => {
-            this.compiler.run((err, stats) => {
-                if (err) {
-                    return resolve(false);
-                }
-                if (stats?.hasErrors()) {
-                    stats.toJson({ errors: true })?.errors?.forEach((err) => {
-                        console.error(err);
-                    });
-                    return resolve(false);
-                }
-                this.compiler.close((err) => {
-                    if (err) {
-                        console.error(err);
-                        return resolve(false);
-                    }
-                    process.nextTick(() => {
-                        resolve(true);
-                    });
-                });
-            });
-        });
-    }
-    public watch() {
-        const watching = this.compiler.watch({}, () => {});
-    }
-}