prebundle 1.2.4 → 1.2.5

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

@@ -0,0 +1,12 @@
+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>, 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;
+export declare function pkgNameToAtTypes(name: string): string;
+/**
+ * Find the direct type file for a given file path.
+ * @param filepath
+ */
+export declare function findDirectTypeFile(filepath: string): string | undefined;

package/dist/index.d.ts

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

package/dist/index.js

@@ -0,0 +1,365 @@
+import * as __WEBPACK_EXTERNAL_MODULE_node_path__ from "node:path";
+import * as __WEBPACK_EXTERNAL_MODULE__compiled_fs_extra_index_js__ from "../compiled/fs-extra/index.js";
+import * as __WEBPACK_EXTERNAL_MODULE_node_module__ from "node:module";
+import * as __WEBPACK_EXTERNAL_MODULE_node_url__ from "node:url";
+import * as __WEBPACK_EXTERNAL_MODULE__vercel_ncc__ from "@vercel/ncc";
+import * as __WEBPACK_EXTERNAL_MODULE__compiled_fast_glob_index_js__ from "../compiled/fast-glob/index.js";
+import * as __WEBPACK_EXTERNAL_MODULE__compiled_rslog_index_js__ from "../compiled/rslog/index.js";
+import * as __WEBPACK_EXTERNAL_MODULE_rollup_plugin_dts__ from "rollup-plugin-dts";
+import * as __WEBPACK_EXTERNAL_MODULE_rollup__ from "rollup";
+import * as __WEBPACK_EXTERNAL_MODULE_terser__ from "terser";
+import * as __WEBPACK_EXTERNAL_MODULE_prettier__ from "prettier";
+const DIST_DIR = 'compiled';
+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'
+};
+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'
+];
+const cwd = process.cwd();
+const helper_require = (0, __WEBPACK_EXTERNAL_MODULE_node_module__.createRequire)(import.meta.url);
+function findDepPath(name) {
+    try {
+        let entry = (0, __WEBPACK_EXTERNAL_MODULE_node_path__.dirname)(helper_require.resolve((0, __WEBPACK_EXTERNAL_MODULE_node_path__.join)(name), {
+            paths: [
+                cwd
+            ]
+        }));
+        while(!(0, __WEBPACK_EXTERNAL_MODULE_node_path__.dirname)(entry).endsWith('node_modules'))entry = (0, __WEBPACK_EXTERNAL_MODULE_node_path__.dirname)(entry);
+        if (name.includes('/')) return (0, __WEBPACK_EXTERNAL_MODULE_node_path__.join)((0, __WEBPACK_EXTERNAL_MODULE_node_path__.dirname)(entry), name);
+        return entry;
+    } catch (err) {
+        return null;
+    }
+}
+const resolveConfig = async ()=>{
+    const configPath = (0, __WEBPACK_EXTERNAL_MODULE_node_path__.join)(cwd, 'prebundle.config.mjs');
+    const config = await import((0, __WEBPACK_EXTERNAL_MODULE_node_url__.pathToFileURL)(configPath).href);
+    return config.default;
+};
+function parseTasks(dependencies, globalPrettier) {
+    const result = [];
+    for (const dep of dependencies){
+        const depName = 'string' == typeof dep ? dep : dep.name;
+        const importPath = (0, __WEBPACK_EXTERNAL_MODULE_node_path__.join)(cwd, DIST_DIR, depName);
+        const distPath = (0, __WEBPACK_EXTERNAL_MODULE_node_path__.join)(cwd, DIST_DIR, depName);
+        const depPath = findDepPath(depName);
+        if (!depPath) throw new Error(`Failed to resolve dependency: ${depName}`);
+        const depEntry = helper_require.resolve(depName, {
+            paths: [
+                cwd
+            ]
+        });
+        const info = {
+            depName,
+            depPath,
+            depEntry,
+            distPath,
+            importPath
+        };
+        if ('string' == typeof dep) result.push({
+            minify: false,
+            target: 'es2019',
+            externals: {},
+            dtsExternals: [],
+            emitFiles: [],
+            packageJsonField: [],
+            prettier: globalPrettier,
+            ...info
+        });
+        else result.push({
+            minify: dep.minify ?? false,
+            target: dep.target ?? 'es2019',
+            ignoreDts: dep.ignoreDts,
+            externals: dep.externals ?? {},
+            dtsExternals: dep.dtsExternals ?? [],
+            emitFiles: dep.emitFiles ?? [],
+            prettier: dep.prettier ?? globalPrettier,
+            afterBundle: dep.afterBundle,
+            beforeBundle: dep.beforeBundle,
+            packageJsonField: dep.packageJsonField ?? [],
+            ...info
+        });
+    }
+    return result;
+}
+function pick(obj, keys) {
+    return keys.reduce((ret, key)=>{
+        if (void 0 !== obj[key]) ret[key] = obj[key];
+        return ret;
+    }, {});
+}
+function pkgNameToAtTypes(name) {
+    const mangled = name.replace(/^@([^\/]+)\/([^\/]+)/, '$1__$2');
+    return `@types/${mangled}`;
+}
+/**
+ * Find the direct type file for a given file path.
+ * @param filepath
+ */ function findDirectTypeFile(filepath) {
+    if (/\.d\.[cm]?ts/.test(filepath)) return filepath;
+    const ext = (0, __WEBPACK_EXTERNAL_MODULE_node_path__.extname)(filepath);
+    const base = filepath.slice(0, -ext.length);
+    const _find = (list)=>{
+        for (const f of list)try {
+            return helper_require.resolve(f, {
+                paths: [
+                    cwd
+                ]
+            });
+        } catch  {}
+    };
+    switch(ext){
+        case '.js':
+        case '.ts':
+            return _find([
+                base + '.d.ts'
+            ]);
+        case '.mjs':
+        case '.mts':
+            return _find([
+                base + '.d.mts',
+                base + '.d.ts'
+            ]);
+        case '.cjs':
+        case '.cts':
+            return _find([
+                base + '.d.cts',
+                base + '.d.ts'
+            ]);
+        default:
+    }
+}
+const { logger } = __WEBPACK_EXTERNAL_MODULE__compiled_rslog_index_js__["default"];
+function emitAssets(assets, distPath) {
+    for (const key of Object.keys(assets)){
+        const asset = assets[key];
+        __WEBPACK_EXTERNAL_MODULE__compiled_fs_extra_index_js__["default"].outputFileSync((0, __WEBPACK_EXTERNAL_MODULE_node_path__.join)(distPath, key), asset.source);
+    }
+}
+async function emitIndex(code, distPath, prettier) {
+    const distIndex = (0, __WEBPACK_EXTERNAL_MODULE_node_path__.join)(distPath, 'index.js');
+    // use terser to strip comments and use prettier to format the code
+    if (prettier) {
+        const minimized = await (0, __WEBPACK_EXTERNAL_MODULE_terser__.minify)(code, {
+            compress: false,
+            mangle: false,
+            ecma: 2019
+        });
+        if (!minimized.code) throw new Error('terser minify failed');
+        const formatted = await (0, __WEBPACK_EXTERNAL_MODULE_prettier__.format)(minimized.code, {
+            filepath: distIndex
+        });
+        await __WEBPACK_EXTERNAL_MODULE__compiled_fs_extra_index_js__["default"].outputFile(distIndex, formatted);
+    } else await __WEBPACK_EXTERNAL_MODULE__compiled_fs_extra_index_js__["default"].outputFile(distIndex, code);
+}
+async function emitDts(task, externals) {
+    const outputDefaultDts = ()=>{
+        __WEBPACK_EXTERNAL_MODULE__compiled_fs_extra_index_js__["default"].outputFileSync((0, __WEBPACK_EXTERNAL_MODULE_node_path__.join)(task.distPath, 'index.d.ts'), 'export = any;\n');
+    };
+    if (task.ignoreDts) {
+        outputDefaultDts();
+        return;
+    }
+    const getTypes = (json)=>{
+        var _json_exports;
+        return json && (json.types || json.typing || json.typings || // for those who use `exports` only
+        getTypes(null === (_json_exports = json.exports) || void 0 === _json_exports ? void 0 : _json_exports['.'])) || null;
+    };
+    const getInput = ()=>{
+        const pkgPath = (0, __WEBPACK_EXTERNAL_MODULE_node_path__.join)(task.depPath, 'package.json');
+        const pkgJson = __WEBPACK_EXTERNAL_MODULE__compiled_fs_extra_index_js__["default"].readJsonSync(pkgPath, 'utf-8');
+        const types = getTypes(pkgJson);
+        if (types) return (0, __WEBPACK_EXTERNAL_MODULE_node_path__.join)(task.depPath, types);
+        const directTypeFile = findDirectTypeFile(task.depEntry);
+        if (directTypeFile) return directTypeFile;
+        const depTypesPath = findDepPath(`${pkgNameToAtTypes(task.depName)}/package.json`);
+        if (!depTypesPath) return null;
+        const depTypesPkg = __WEBPACK_EXTERNAL_MODULE__compiled_fs_extra_index_js__["default"].readJsonSync(depTypesPath, 'utf-8');
+        const depTypes = getTypes(depTypesPkg);
+        return depTypes ? (0, __WEBPACK_EXTERNAL_MODULE_node_path__.join)((0, __WEBPACK_EXTERNAL_MODULE_node_path__.dirname)(depTypesPath), depTypes) : null;
+    };
+    const input = getInput();
+    if (!input) {
+        outputDefaultDts();
+        return;
+    }
+    try {
+        const inputConfig = {
+            input,
+            external: [
+                ...Object.keys(externals),
+                ...task.dtsExternals,
+                ...NODE_BUILTINS
+            ],
+            plugins: [
+                (0, __WEBPACK_EXTERNAL_MODULE_rollup_plugin_dts__.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 (0, __WEBPACK_EXTERNAL_MODULE_rollup__.rollup)(inputConfig);
+        await bundle.write(outputConfig);
+    } catch (error) {
+        logger.error(`rollup-plugin-dts failed: ${task.depName}`);
+        logger.error(error);
+    }
+}
+function emitPackageJson(task, assets) {
+    const packageJsonPath = (0, __WEBPACK_EXTERNAL_MODULE_node_path__.join)(task.depPath, 'package.json');
+    const packageJson = __WEBPACK_EXTERNAL_MODULE__compiled_fs_extra_index_js__["default"].readJsonSync(packageJsonPath, 'utf-8');
+    const outputPath = (0, __WEBPACK_EXTERNAL_MODULE_node_path__.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';
+    pickedPackageJson.type = 'commonjs';
+    if (assets['package.json']) try {
+        Object.assign(pickedPackageJson, pick(JSON.parse(assets['package.json'].source), [
+            'type'
+        ]));
+    } catch  {}
+    __WEBPACK_EXTERNAL_MODULE__compiled_fs_extra_index_js__["default"].writeJSONSync(outputPath, pickedPackageJson);
+}
+function emitLicense(task) {
+    const licensePath = (0, __WEBPACK_EXTERNAL_MODULE_node_path__.join)(task.depPath, 'LICENSE');
+    if (__WEBPACK_EXTERNAL_MODULE__compiled_fs_extra_index_js__["default"].existsSync(licensePath)) __WEBPACK_EXTERNAL_MODULE__compiled_fs_extra_index_js__["default"].copySync(licensePath, (0, __WEBPACK_EXTERNAL_MODULE_node_path__.join)(task.distPath, 'license'));
+}
+function emitExtraFiles(task) {
+    const { emitFiles } = task;
+    for (const item of emitFiles){
+        const path = (0, __WEBPACK_EXTERNAL_MODULE_node_path__.join)(task.distPath, item.path);
+        __WEBPACK_EXTERNAL_MODULE__compiled_fs_extra_index_js__["default"].outputFileSync(path, item.content);
+    }
+}
+function removeSourceMap(task) {
+    const maps = __WEBPACK_EXTERNAL_MODULE__compiled_fast_glob_index_js__["default"].sync((0, __WEBPACK_EXTERNAL_MODULE_node_path__.join)(task.distPath, '**/*.map'));
+    for (const mapPath of maps)__WEBPACK_EXTERNAL_MODULE__compiled_fs_extra_index_js__["default"].removeSync(mapPath);
+}
+function renameDistFolder(task) {
+    const pkgPath = (0, __WEBPACK_EXTERNAL_MODULE_node_path__.join)(task.distPath, 'package.json');
+    const pkgJson = __WEBPACK_EXTERNAL_MODULE__compiled_fs_extra_index_js__["default"].readJsonSync(pkgPath, 'utf-8');
+    for (const key of [
+        'types',
+        'typing',
+        'typings'
+    ]){
+        var _pkgJson_key;
+        if (null === (_pkgJson_key = pkgJson[key]) || void 0 === _pkgJson_key ? void 0 : _pkgJson_key.startsWith('dist/')) {
+            pkgJson[key] = pkgJson[key].replace('dist/', 'types/');
+            const distFolder = (0, __WEBPACK_EXTERNAL_MODULE_node_path__.join)(task.distPath, 'dist');
+            const typesFolder = (0, __WEBPACK_EXTERNAL_MODULE_node_path__.join)(task.distPath, 'types');
+            if (__WEBPACK_EXTERNAL_MODULE__compiled_fs_extra_index_js__["default"].existsSync(distFolder)) __WEBPACK_EXTERNAL_MODULE__compiled_fs_extra_index_js__["default"].renameSync(distFolder, typesFolder);
+        }
+    }
+    __WEBPACK_EXTERNAL_MODULE__compiled_fs_extra_index_js__["default"].writeJSONSync(pkgPath, pkgJson);
+}
+const pkgName = process.argv[2];
+async function prebundle(task) {
+    let commonExternals = arguments.length > 1 && void 0 !== arguments[1] ? arguments[1] : {};
+    if (pkgName && task.depName !== pkgName) return;
+    logger.start(`prebundle: ${task.depName}`);
+    __WEBPACK_EXTERNAL_MODULE__compiled_fs_extra_index_js__["default"].removeSync(task.distPath);
+    if (task.beforeBundle) await task.beforeBundle(task);
+    const mergedExternals = {
+        ...DEFAULT_EXTERNALS,
+        ...commonExternals,
+        ...task.externals
+    };
+    const { code, assets } = await (0, __WEBPACK_EXTERNAL_MODULE__vercel_ncc__["default"])(task.depEntry, {
+        minify: task.minify,
+        target: task.target,
+        externals: mergedExternals,
+        assetBuilds: false
+    });
+    await emitIndex(code, task.distPath, task.prettier);
+    emitAssets(assets, task.distPath);
+    await emitDts(task, mergedExternals);
+    emitLicense(task);
+    emitPackageJson(task, assets);
+    removeSourceMap(task);
+    renameDistFolder(task);
+    emitExtraFiles(task);
+    if (task.afterBundle) await task.afterBundle(task);
+    logger.success(`prebundle: ${task.depName}\n\n`);
+}
+async function run() {
+    const config = await resolveConfig();
+    const parsedTasks = parseTasks(config.dependencies, config.prettier);
+    for (const task of parsedTasks)await prebundle(task, config.externals);
+}
+export { run };

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

@@ -0,0 +1,53 @@
+export type ImportMap = {
+    path: string;
+    content: string;
+};
+export type DependencyConfig = {
+    /** Name of dependency */
+    name: string;
+    /** Whether to minify the code. */
+    minify?: boolean;
+    /** Externals to leave as requires of the build. */
+    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. */
+    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>;
+    /** Whether to prettier the code and strip comments */
+    prettier?: boolean;
+};
+export type ParsedTask = {
+    depPath: string;
+    depEntry: string;
+    distPath: string;
+    importPath: string;
+    ignoreDts?: boolean;
+    prettier?: 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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "prebundle",
-  "version": "1.2.4",
+  "version": "1.2.5",
   "repository": {
     "type": "git",
     "url": "https://github.com/rspack-contrib/prebundle"
@@ -19,7 +19,7 @@
     "build": "rslib build",
     "dev": "rslib build --watch",
     "prebundle": "node ./bin.js",
-    "prepublishOnly": "npm run build",
+    "prepare": "npm run build",
     "bump": "npx bumpp"
   },
   "dependencies": {