prebundle 1.1.0 → 1.2.1

package/dist/helper.d.ts

@@ -1,6 +1,6 @@
 import type { Config, DependencyConfig, ParsedTask } from './types.js';
 export declare function findDepPath(name: string): string | null;
 export declare const resolveConfig: () => Promise<Config>;
-export declare function parseTasks(dependencies: Array<string | DependencyConfig>): ParsedTask[];
+export declare function parseTasks(dependencies: Array<string | DependencyConfig>, globalPrettier?: boolean): ParsedTask[];
 export declare function pick<T, U extends keyof T>(obj: T, keys: ReadonlyArray<U>): Pick<T, U>;
 export declare function replaceFileContent(filePath: string, replaceFn: (content: string) => string): void;

package/dist/helper.js

@@ -24,7 +24,7 @@ export const resolveConfig = async () => {
     const config = await import(pathToFileURL(configPath).href);
     return config.default;
 };
-export function parseTasks(dependencies) {
+export function parseTasks(dependencies, globalPrettier) {
     const result = [];
     for (const dep of dependencies) {
         const depName = typeof dep === 'string' ? dep : dep.name;
@@ -50,6 +50,7 @@ export function parseTasks(dependencies) {
                 dtsExternals: [],
                 emitFiles: [],
                 packageJsonField: [],
+                prettier: globalPrettier,
                 ...info,
             });
         }
@@ -61,6 +62,7 @@ export function parseTasks(dependencies) {
                 externals: dep.externals ?? {},
                 dtsExternals: dep.dtsExternals ?? [],
                 emitFiles: dep.emitFiles ?? [],
+                prettier: dep.prettier ?? globalPrettier,
                 afterBundle: dep.afterBundle,
                 beforeBundle: dep.beforeBundle,
                 packageJsonField: dep.packageJsonField ?? [],

package/dist/index.js

@@ -2,7 +2,7 @@ import { parseTasks, resolveConfig } from './helper.js';
 import { prebundle } from './prebundle.js';
 export async function run() {
     const config = await resolveConfig();
-    const parsedTasks = parseTasks(config.dependencies);
+    const parsedTasks = parseTasks(config.dependencies, config.prettier);
     for (const task of parsedTasks) {
         await prebundle(task, config.externals);
     }

package/dist/prebundle.js

@@ -7,6 +7,8 @@ import { DEFAULT_EXTERNALS, NODE_BUILTINS } from './constant.js';
 import { findDepPath, pick } from './helper.js';
 import { dts } from 'rollup-plugin-dts';
 import { rollup } from 'rollup';
+import swc from '@swc/core';
+import { format } from 'prettier';
 const { logger } = rslog;
 function emitAssets(assets, distPath) {
     for (const key of Object.keys(assets)) {
@@ -14,13 +16,26 @@ function emitAssets(assets, distPath) {
         fs.outputFileSync(join(distPath, key), asset.source);
     }
 }
-function emitIndex(code, distPath) {
+async function emitIndex(code, distPath, prettier) {
     const distIndex = join(distPath, 'index.js');
-    fs.outputFileSync(distIndex, code);
+    if (prettier) {
+        const minimized = await swc.minify(code, {
+            compress: false,
+            mangle: false,
+            ecma: 2019,
+        });
+        const formatted = await format(minimized.code, {
+            filepath: distIndex,
+        });
+        await fs.outputFile(distIndex, formatted);
+    }
+    else {
+        await fs.outputFile(distIndex, code);
+    }
 }
 async function emitDts(task, externals) {
     const outputDefaultDts = () => {
-        fs.writeFileSync(join(task.distPath, 'index.d.ts'), 'export = any;\n');
+        fs.outputFileSync(join(task.distPath, 'index.d.ts'), 'export = any;\n');
     };
     if (task.ignoreDts) {
         outputDefaultDts();
@@ -172,7 +187,7 @@ export async function prebundle(task, commonExternals = {}) {
         externals: mergedExternals,
         assetBuilds: false,
     });
-    emitIndex(code, task.distPath);
+    await emitIndex(code, task.distPath, task.prettier);
     emitAssets(assets, task.distPath);
     await emitDts(task, mergedExternals);
     emitLicense(task);

package/dist/src/constant.d.ts

@@ -0,0 +1,8 @@
+export declare const DIST_DIR = "compiled";
+export declare const DEFAULT_EXTERNALS: {
+    './package.json': string;
+    '../package.json': string;
+    '../../package.json': string;
+};
+export declare const NODE_BUILTINS: string[];
+export declare const cwd: string;

package/dist/src/constant.js

@@ -0,0 +1,48 @@
+export const DIST_DIR = 'compiled';
+export const DEFAULT_EXTERNALS = {
+    // ncc bundled wrong package.json, using external to avoid this problem
+    './package.json': './package.json',
+    '../package.json': './package.json',
+    '../../package.json': './package.json',
+};
+export const NODE_BUILTINS = [
+    '_stream_duplex',
+    '_stream_passthrough',
+    '_stream_readable',
+    '_stream_transform',
+    '_stream_writable',
+    'assert',
+    'buffer',
+    'child_process',
+    'cluster',
+    'console',
+    'constants',
+    'crypto',
+    'dgram',
+    'dns',
+    'domain',
+    'events',
+    'fs',
+    'http',
+    'https',
+    'module',
+    'net',
+    'os',
+    'path',
+    'process',
+    'punycode',
+    'querystring',
+    'readline',
+    'repl',
+    'stream',
+    'string_decoder',
+    'sys',
+    'timers',
+    'tls',
+    'tty',
+    'url',
+    'util',
+    'vm',
+    'zlib',
+];
+export const cwd = process.cwd();

package/dist/src/helper.d.ts

@@ -0,0 +1,6 @@
+import type { Config, DependencyConfig, ParsedTask } from './types.js';
+export declare function findDepPath(name: string): string | null;
+export declare const resolveConfig: () => Promise<Config>;
+export declare function parseTasks(dependencies: Array<string | DependencyConfig>): ParsedTask[];
+export declare function pick<T, U extends keyof T>(obj: T, keys: ReadonlyArray<U>): Pick<T, U>;
+export declare function replaceFileContent(filePath: string, replaceFn: (content: string) => string): void;

package/dist/src/helper.js

@@ -0,0 +1,87 @@
+import { dirname, join } from 'node:path';
+import fs from '../compiled/fs-extra/index.js';
+import { cwd, DIST_DIR } from './constant.js';
+import { createRequire } from 'node:module';
+import { pathToFileURL } from 'node:url';
+const require = createRequire(import.meta.url);
+export function findDepPath(name) {
+    try {
+        let entry = dirname(require.resolve(join(name), { paths: [cwd] }));
+        while (!dirname(entry).endsWith('node_modules')) {
+            entry = dirname(entry);
+        }
+        if (name.includes('/')) {
+            return join(dirname(entry), name);
+        }
+        return entry;
+    }
+    catch (err) {
+        return null;
+    }
+}
+export const resolveConfig = async () => {
+    const configPath = join(cwd, 'prebundle.config.mjs');
+    const config = await import(pathToFileURL(configPath).href);
+    return config.default;
+};
+export function parseTasks(dependencies) {
+    const result = [];
+    for (const dep of dependencies) {
+        const depName = typeof dep === 'string' ? dep : dep.name;
+        const importPath = join(cwd, DIST_DIR, depName);
+        const distPath = join(cwd, DIST_DIR, depName);
+        const depPath = findDepPath(depName);
+        if (!depPath) {
+            throw new Error(`Failed to resolve dependency: ${depName}`);
+        }
+        const depEntry = require.resolve(depName, { paths: [cwd] });
+        const info = {
+            depName,
+            depPath,
+            depEntry,
+            distPath,
+            importPath,
+        };
+        if (typeof dep === 'string') {
+            result.push({
+                minify: false,
+                target: 'es2019',
+                externals: {},
+                dtsExternals: [],
+                emitFiles: [],
+                packageJsonField: [],
+                ...info,
+            });
+        }
+        else {
+            result.push({
+                minify: dep.minify ?? false,
+                target: dep.target ?? 'es2019',
+                ignoreDts: dep.ignoreDts,
+                externals: dep.externals ?? {},
+                dtsExternals: dep.dtsExternals ?? [],
+                emitFiles: dep.emitFiles ?? [],
+                afterBundle: dep.afterBundle,
+                beforeBundle: dep.beforeBundle,
+                packageJsonField: dep.packageJsonField ?? [],
+                ...info,
+            });
+        }
+    }
+    return result;
+}
+export function pick(obj, keys) {
+    return keys.reduce((ret, key) => {
+        if (obj[key] !== undefined) {
+            ret[key] = obj[key];
+        }
+        return ret;
+    }, {});
+}
+export function replaceFileContent(filePath, replaceFn) {
+    const content = fs.readFileSync(filePath, 'utf-8');
+    const newContent = replaceFn(content);
+    if (newContent !== content) {
+        fs.writeFileSync(filePath, newContent);
+    }
+}

package/dist/src/index.d.ts

@@ -0,0 +1,2 @@
+export declare function run(): Promise<void>;
+export type { Config } from './types.js';

package/dist/src/index.js

@@ -0,0 +1,9 @@
+import { parseTasks, resolveConfig } from './helper.js';
+import { prebundle } from './prebundle.js';
+export async function run() {
+    const config = await resolveConfig();
+    const parsedTasks = parseTasks(config.dependencies);
+    for (const task of parsedTasks) {
+        await prebundle(task, config.externals);
+    }
+}

package/dist/src/prebundle.d.ts

@@ -0,0 +1,2 @@
+import type { ParsedTask } from './types.js';
+export declare function prebundle(task: ParsedTask, commonExternals?: Record<string, string>): Promise<void>;

package/dist/src/prebundle.js

@@ -0,0 +1,197 @@
+import { dirname, join } from 'node:path';
+import ncc from '@vercel/ncc';
+import fastGlob from '../compiled/fast-glob/index.js';
+import fs from '../compiled/fs-extra/index.js';
+import rslog from '../compiled/rslog/index.js';
+import { DEFAULT_EXTERNALS, NODE_BUILTINS } from './constant.js';
+import { findDepPath, pick } from './helper.js';
+import { dts } from 'rollup-plugin-dts';
+import { rollup } from 'rollup';
+import swc from '@swc/core';
+import { format } from 'prettier';
+const { logger } = rslog;
+function emitAssets(assets, distPath) {
+    for (const key of Object.keys(assets)) {
+        const asset = assets[key];
+        fs.outputFileSync(join(distPath, key), asset.source);
+    }
+}
+async function emitIndex(code, distPath) {
+    const distIndex = join(distPath, 'index.js');
+    const minimized = swc.minifySync(code, {
+        compress: false,
+        mangle: false,
+        ecma: 2019,
+    });
+    const formatted = await format(minimized.code, {
+        filepath: distIndex,
+    });
+    fs.outputFileSync(distIndex, formatted);
+}
+async function emitDts(task, externals) {
+    const outputDefaultDts = () => {
+        fs.writeFileSync(join(task.distPath, 'index.d.ts'), 'export = any;\n');
+    };
+    if (task.ignoreDts) {
+        outputDefaultDts();
+        return;
+    }
+    const getTypes = (json) => json.types || json.typing || json.typings || null;
+    const getInput = () => {
+        const pkgPath = join(task.depPath, 'package.json');
+        const pkgJson = fs.readJsonSync(pkgPath, 'utf-8');
+        const types = getTypes(pkgJson);
+        if (types) {
+            return join(task.depPath, types);
+        }
+        const depTypesPath = findDepPath(`@types/${task.depName}/package.json`);
+        if (!depTypesPath) {
+            return null;
+        }
+        const depTypesPkg = fs.readJsonSync(depTypesPath, 'utf-8');
+        const depTypes = getTypes(depTypesPkg);
+        return depTypes ? join(dirname(depTypesPath), depTypes) : null;
+    };
+    const input = getInput();
+    if (!input) {
+        outputDefaultDts();
+        return;
+    }
+    try {
+        const inputConfig = {
+            input,
+            external: [
+                ...Object.keys(externals),
+                ...task.dtsExternals,
+                ...NODE_BUILTINS,
+            ],
+            plugins: [
+                dts({
+                    respectExternal: true,
+                    compilerOptions: {
+                        skipLibCheck: true,
+                        // https://github.com/Swatinem/rollup-plugin-dts/issues/143,
+                        // but it will cause error when bundle ts which import another ts file.
+                        preserveSymlinks: false,
+                        // https://github.com/Swatinem/rollup-plugin-dts/issues/127
+                        composite: false,
+                        // https://github.com/Swatinem/rollup-plugin-dts/issues/113
+                        declarationMap: false,
+                        // Ensure ".d.ts" modules are generated
+                        declaration: true,
+                        // Skip ".js" generation
+                        noEmit: false,
+                        emitDeclarationOnly: true,
+                        // Skip code generation when error occurs
+                        noEmitOnError: true,
+                        // Avoid extra work
+                        checkJs: false,
+                        // Ensure we can parse the latest code
+                        // @ts-expect-error
+                        target: task.target,
+                    },
+                }),
+            ],
+        };
+        const outputConfig = {
+            dir: task.distPath,
+            format: 'esm',
+            exports: 'named',
+            entryFileNames: 'index.d.ts',
+        };
+        const bundle = await rollup(inputConfig);
+        await bundle.write(outputConfig);
+    }
+    catch (error) {
+        logger.error(`rollup-plugin-dts failed: ${task.depName}`);
+        logger.error(error);
+    }
+}
+function emitPackageJson(task) {
+    const packageJsonPath = join(task.depPath, 'package.json');
+    const packageJson = fs.readJsonSync(packageJsonPath, 'utf-8');
+    const outputPath = join(task.distPath, 'package.json');
+    const pickedPackageJson = pick(packageJson, [
+        'name',
+        'author',
+        'version',
+        'funding',
+        'license',
+        ...task.packageJsonField,
+    ]);
+    if (task.depName !== pickedPackageJson.name) {
+        pickedPackageJson.name = task.depName;
+    }
+    pickedPackageJson.types = 'index.d.ts';
+    fs.writeJSONSync(outputPath, pickedPackageJson);
+}
+function emitLicense(task) {
+    const licensePath = join(task.depPath, 'LICENSE');
+    if (fs.existsSync(licensePath)) {
+        fs.copySync(licensePath, join(task.distPath, 'license'));
+    }
+}
+function emitExtraFiles(task) {
+    const { emitFiles } = task;
+    for (const item of emitFiles) {
+        const path = join(task.distPath, item.path);
+        fs.outputFileSync(path, item.content);
+    }
+}
+function removeSourceMap(task) {
+    const maps = fastGlob.sync(join(task.distPath, '**/*.map'));
+    for (const mapPath of maps) {
+        fs.removeSync(mapPath);
+    }
+}
+function renameDistFolder(task) {
+    const pkgPath = join(task.distPath, 'package.json');
+    const pkgJson = fs.readJsonSync(pkgPath, 'utf-8');
+    for (const key of ['types', 'typing', 'typings']) {
+        if (pkgJson[key]?.startsWith('dist/')) {
+            pkgJson[key] = pkgJson[key].replace('dist/', 'types/');
+            const distFolder = join(task.distPath, 'dist');
+            const typesFolder = join(task.distPath, 'types');
+            if (fs.existsSync(distFolder)) {
+                fs.renameSync(distFolder, typesFolder);
+            }
+        }
+    }
+    // compiled packages are always use commonjs
+    pkgJson.type = 'commonjs';
+    fs.writeJSONSync(pkgPath, pkgJson);
+}
+const pkgName = process.argv[2];
+export async function prebundle(task, commonExternals = {}) {
+    if (pkgName && task.depName !== pkgName) {
+        return;
+    }
+    logger.start(`prebundle: ${task.depName}`);
+    fs.removeSync(task.distPath);
+    if (task.beforeBundle) {
+        await task.beforeBundle(task);
+    }
+    const mergedExternals = {
+        ...DEFAULT_EXTERNALS,
+        ...commonExternals,
+        ...task.externals,
+    };
+    const { code, assets } = await ncc(task.depEntry, {
+        minify: task.minify,
+        target: task.target,
+        externals: mergedExternals,
+        assetBuilds: false,
+    });
+    emitIndex(code, task.distPath);
+    emitAssets(assets, task.distPath);
+    await emitDts(task, mergedExternals);
+    emitLicense(task);
+    emitPackageJson(task);
+    removeSourceMap(task);
+    renameDistFolder(task);
+    emitExtraFiles(task);
+    if (task.afterBundle) {
+        await task.afterBundle(task);
+    }
+    logger.success(`prebundle: ${task.depName}\n\n`);
+}

package/dist/src/types.d.ts

@@ -0,0 +1,50 @@
+export type ImportMap = {
+    path: string;
+    content: string;
+};
+export type DependencyConfig = {
+    /** Name of dependency */
+    name: string;
+    /** Whether to minify the code. */
+    minify?: boolean;
+    /** Whether to strip comments when minify is false. */
+    stripComments?: boolean;
+    /** Externals to leave as requires of the build. */
+    externals?: Record<string, string>;
+    /** Externals types */
+    dtsExternals?: Array<string | RegExp>;
+    /** Emit extra entry files to map imports. */
+    emitFiles?: ImportMap[];
+    /** Copy extra fields from original package.json to target package.json. */
+    packageJsonField?: string[];
+    /** Whether to ignore type definitions */
+    ignoreDts?: boolean;
+    /** Target ECMA version */
+    target?: string;
+    beforeBundle?: (task: ParsedTask) => void | Promise<void>;
+    afterBundle?: (task: ParsedTask) => void | Promise<void>;
+};
+export type Config = {
+    /**
+     * Configure externals for all packages,
+     * will be merged with dependencies[i].externals.
+     */
+    externals?: Record<string, string>;
+    dependencies: Array<string | DependencyConfig>;
+};
+export type ParsedTask = {
+    depPath: string;
+    depEntry: string;
+    distPath: string;
+    importPath: string;
+    ignoreDts?: boolean;
+    target: NonNullable<DependencyConfig['target']>;
+    minify: NonNullable<DependencyConfig['minify']>;
+    depName: NonNullable<DependencyConfig['name']>;
+    externals: NonNullable<DependencyConfig['externals']>;
+    dtsExternals: NonNullable<DependencyConfig['dtsExternals']>;
+    emitFiles: NonNullable<DependencyConfig['emitFiles']>;
+    afterBundle?: NonNullable<DependencyConfig['afterBundle']>;
+    beforeBundle?: NonNullable<DependencyConfig['beforeBundle']>;
+    packageJsonField: NonNullable<DependencyConfig['packageJsonField']>;
+};

package/dist/src/types.js

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

package/dist/types.d.ts

@@ -11,6 +11,8 @@ export type DependencyConfig = {
     externals?: Record<string, string>;
     /** Externals types */
     dtsExternals?: Array<string | RegExp>;
+    /** Whether to prettier the code and strip comments */
+    prettier?: boolean;
     /** Emit extra entry files to map imports. */
     emitFiles?: ImportMap[];
     /** Copy extra fields from original package.json to target package.json. */
@@ -29,6 +31,8 @@ export type Config = {
      */
     externals?: Record<string, string>;
     dependencies: Array<string | DependencyConfig>;
+    /** Whether to prettier the code and strip comments */
+    prettier?: boolean;
 };
 export type ParsedTask = {
     depPath: string;
@@ -36,6 +40,7 @@ export type ParsedTask = {
     distPath: string;
     importPath: string;
     ignoreDts?: boolean;
+    prettier?: boolean;
     target: NonNullable<DependencyConfig['target']>;
     minify: NonNullable<DependencyConfig['minify']>;
     depName: NonNullable<DependencyConfig['name']>;

package/package.json

@@ -1,22 +1,24 @@
 {
   "name": "prebundle",
-  "version": "1.1.0",
-  "main": "./dist/index.js",
-  "type": "module",
+  "version": "1.2.1",
   "repository": {
     "type": "git",
     "url": "https://github.com/rspack-contrib/prebundle"
   },
+  "type": "module",
+  "main": "./dist/index.js",
+  "bin": {
+    "prebundle": "./bin.js"
+  },
   "files": [
     "dist",
     "bin.js",
     "compiled"
   ],
-  "bin": {
-    "prebundle": "./bin.js"
-  },
   "dependencies": {
+    "@swc/core": "^1.6.13",
     "@vercel/ncc": "0.38.1",
+    "prettier": "^3.2.5",
     "rollup": "^4.17.1",
     "rollup-plugin-dts": "^6.1.0"
   },
@@ -25,7 +27,6 @@
     "@types/node": "18.x",
     "fast-glob": "^3.3.2",
     "fs-extra": "^11.2.0",
-    "prettier": "^3.2.5",
     "rslog": "^1.2.2",
     "typescript": "^5.4.2"
   },
@@ -33,8 +34,8 @@
     "registry": "https://registry.npmjs.org/"
   },
   "scripts": {
-    "dev": "tsc --watch",
     "build": "tsc",
+    "dev": "tsc --watch",
     "prebundle": "node ./bin.js"
   }
 }