npm install --global rollup

cli
├─ run              //定義了runRollup函數(shù)，以及加載配置文件等業(yè)務(wù)代碼
├─ cli.ts           //命令行解析入口
├─ help.md          //rollup幫助文檔
├─ logging.ts       //handleError方法定義

import process from 'node:process';
import help from 'help.md';
import { version } from 'package.json';
import argParser from 'yargs-parser';
import { commandAliases } from '../src/utils/options/mergeOptions';
import run from './run/index';
/**
commandAliases: {
	c: 'config',
	d: 'dir',
	e: 'external',
	f: 'format',
	g: 'globals',
	h: 'help',
	i: 'input',
	m: 'sourcemap',
	n: 'name',
	o: 'file',
	p: 'plugin',
	v: 'version',
	w: 'watch'
};
 */
// process 是一個全局變量，即 global 對象的屬性。
// 它用于描述當(dāng)前Node.js 進程狀態(tài)的對象，提供了一個與操作系統(tǒng)的簡單接口。
// process.argv 屬性返回一個數(shù)組，由命令行執(zhí)行腳本時的各個參數(shù)組成。
// 它的第一個成員總是node，第二個成員是腳本文件名，其余成員是腳本文件的參數(shù)。
// process.argv:  [
//   'C:\\Program Files\\nodejs\\node.exe',
//   'C:\\Program Files\\nodejs\\node_modules\\rollup\\dist\\bin\\rollup'
// ]
/**
 * 1. process.argv.slice(2) 則是從 argv數(shù)組下標為2的元素開始直到末尾提取元素，舉例來說就是提取諸如 rollup -h 中除了 rollup 之外的參數(shù)
 * 2. yargs-parser這個包的作用是把命令行參數(shù)轉(zhuǎn)換為json對象，方便訪問。
 * 例如："rollup -h" 會被argParser解析成 { _: [], h: true, help: true }
 * "rollup --help" 會被argParser解析成 { _: [], help: true, h: true }
 * 'camel-case-expansion' 表示連字符參數(shù)是否應(yīng)該擴展為駝峰大小寫別名？默認是true.
 * 例如： node example.js --foo-bar 會被解析成 { _: [], 'foo-bar': true, fooBar: true }
 *
 */
const command = argParser(process.argv.slice(2), {
  alias: commandAliases, //alias參數(shù)表示鍵的別名對象
  configuration: { 'camel-case-expansion': false } //為 argParser 解析器提供配置選項, 'camel-case-expansion': false 表示連字符參數(shù)不會被擴展為駝峰大小寫別名
});
//process.stdin.isTTY 用于檢測我們的程序是否直接連到終端
if (command.help || (process.argv.length <= 2 && process.stdin.isTTY)) {
  console.log(`\n${help.replace('__VERSION__', version)}\n`);
} else if (command.version) {
  console.log(`rollup v${version}`);
} else {
  try {
    // eslint-disable-next-line unicorn/prefer-module
    //瀏覽器是支持source maps的，但node環(huán)境原生不支持source maps。所以我們可以通過'source-map-support'包來實現(xiàn)這個功能。這樣當(dāng)程序執(zhí)行出錯的時候方便通過控制臺定位到源碼位置。
    require('source-map-support').install();
  } catch {
    // do nothing
  }
  run(command);
}

import { env } from 'node:process';
import type { MergedRollupOptions } from '../../src/rollup/types';
import { errorDuplicateImportOptions, errorFailAfterWarnings } from '../../src/utils/error';
import { isWatchEnabled } from '../../src/utils/options/mergeOptions';
import { getAliasName } from '../../src/utils/relativeId';
import { loadFsEvents } from '../../src/watch/fsevents-importer';
import { handleError } from '../logging';
import type { BatchWarnings } from './batchWarnings';
import build from './build';
import { getConfigPath } from './getConfigPath';
import { loadConfigFile } from './loadConfigFile';
import loadConfigFromCommand from './loadConfigFromCommand';
export default async function runRollup(command: Record<string, any>): Promise<void> {
  let inputSource; //獲取input的值
  if (command._.length > 0) {
    //獲取非選項值
    //例如終端輸入"rollup -i input.js f es"  =>  command:  { _: [ 'f', 'es' ], i: 'input.js', input: 'input.js' }
    if (command.input) {
      handleError(errorDuplicateImportOptions());
    }
    inputSource = command._;
  } else if (typeof command.input === 'string') {
    inputSource = [command.input];
  } else {
    inputSource = command.input;
  }
  if (inputSource && inputSource.length > 0) {
    if (inputSource.some((input: string) => input.includes('='))) {
      //"rollup -i input.js f=es" => { _: [ 'f=es' ], i: 'input.js', input: 'input.js' }
      command.input = {};
      //處理多入口文件的情況
      for (const input of inputSource) {
        const equalsIndex = input.indexOf('=');
        const value = input.slice(Math.max(0, equalsIndex + 1)); //獲取等號右邊的字符=> “es”
        const key = input.slice(0, Math.max(0, equalsIndex)) || getAliasName(input); //獲取等號左邊的字符=> “f”
        command.input[key] = value;
      }
    } else {
      //處理單入口文件的情況
      command.input = inputSource;
    }
  }
  if (command.environment) {
    //獲取environment參數(shù)用于設(shè)置process.env.[XX]
    const environment = Array.isArray(command.environment)
      ? command.environment
      : [command.environment];
    for (const argument of environment) {
      for (const pair of argument.split(',')) {
        const [key, ...value] = pair.split(':');
        env[key] = value.length === 0 ? String(true) : value.join(':');
      }
    }
  }
  if (isWatchEnabled(command.watch)) {
    //觀察模式
    await loadFsEvents();
    const { watch } = await import('./watch-cli');
    watch(command);
  } else {
    //非觀察模式
    try {
      const { options, warnings } = await getConfigs(command);
      try {
        //因為配置文件可以返回一個數(shù)組，所以需要挨個執(zhí)行
        for (const inputOptions of options) {
          //內(nèi)部執(zhí)行 rollup(inputOptions) 進行打包
          await build(inputOptions, warnings, command.silent);
        }
        if (command.failAfterWarnings && warnings.warningOccurred) {
          warnings.flush();
          handleError(errorFailAfterWarnings());
        }
      } catch (error: any) {
        warnings.flush();
        handleError(error);
      }
    } catch (error: any) {
      handleError(error);
    }
  }
}
async function getConfigs(
  command: any
): Promise<{ options: MergedRollupOptions[]; warnings: BatchWarnings }> {
  if (command.config) {
    //獲取配置文件
    const configFile = await getConfigPath(command.config);
    //讀取配置文件獲取配置項
    const { options, warnings } = await loadConfigFile(configFile, command);
    return { options, warnings };
  }
  return await loadConfigFromCommand(command);
}

//rollup.config.ts
export default async function (
  command: Record<string, unknown>
): Promise<RollupOptions | RollupOptions[]> {
  const { collectLicenses, writeLicense } = getLicenseHandler(
    fileURLToPath(new URL('.', import.meta.url))
  );
  const commonJSBuild: RollupOptions = {
    // 'fsevents' is a dependency of 'chokidar' that cannot be bundled as it contains binary code
    external: ['fsevents'],
    input: {
      'loadConfigFile.js': 'cli/run/loadConfigFile.ts',
      'rollup.js': 'src/node-entry.ts'
    },
    onwarn,
    output: {
      banner: getBanner,
      chunkFileNames: 'shared/[name].js',
      dir: 'dist',
      entryFileNames: '[name]',
      exports: 'named',
      externalLiveBindings: false,
      format: 'cjs',
      freeze: false,
      generatedCode: 'es2015',
      interop: 'default',
      manualChunks: { rollup: ['src/node-entry.ts'] },
      sourcemap: true
    },
    plugins: [
      ...nodePlugins,
      addCliEntry(), //添加cli入口文件
      esmDynamicImport(),
      !command.configTest && collectLicenses(),
      !command.configTest && copyTypes('rollup.d.ts')
    ],
    strictDeprecations: true,
    treeshake
  };
  /**
	 * 
	當(dāng)我們執(zhí)行npm run build 的時候就相當(dāng)于執(zhí)行了 rollup --config rollup.config.ts --configPlugin typescript
	此時 command 就是如下對象：
	{ 
		_: [],
		config: 'rollup.config.ts',
		c: 'rollup.config.ts',     
		configPlugin: 'typescript' 
	}
	*/
  if (command.configTest) {
    return commonJSBuild;
  }
  const esmBuild: RollupOptions = {
    ...commonJSBuild,
    input: { 'rollup.js': 'src/node-entry.ts' },
    output: {
      ...commonJSBuild.output,
      dir: 'dist/es',
      format: 'es',
      minifyInternalExports: false,
      sourcemap: false
    },
    plugins: [...nodePlugins, emitModulePackageFile(), collectLicenses(), writeLicense()]
  };
  const { collectLicenses: collectLicensesBrowser, writeLicense: writeLicenseBrowser } =
    getLicenseHandler(fileURLToPath(new URL('browser', import.meta.url)));
  const browserBuilds: RollupOptions = {
    input: 'src/browser-entry.ts',
    onwarn,
    output: [
      {
        banner: getBanner,
        file: 'browser/dist/rollup.browser.js',
        format: 'umd',
        name: 'rollup',
        plugins: [copyTypes('rollup.browser.d.ts')],
        sourcemap: true
      },
      {
        banner: getBanner,
        file: 'browser/dist/es/rollup.browser.js',
        format: 'es',
        plugins: [emitModulePackageFile()]
      }
    ],
    plugins: [
      replaceBrowserModules(),
      alias(moduleAliases),
      nodeResolve({ browser: true }),
      json(),
      commonjs(),
      typescript(),
      terser({ module: true, output: { comments: 'some' } }),
      collectLicensesBrowser(),
      writeLicenseBrowser(),
      cleanBeforeWrite('browser/dist')
    ],
    strictDeprecations: true,
    treeshake
  };
  return [commonJSBuild, esmBuild, browserBuilds];
}

import { chmod } from 'node:fs/promises';
import { resolve } from 'node:path';
import MagicString from 'magic-string';
import type { Plugin } from 'rollup';
const CLI_CHUNK = 'bin/rollup';
export default function addCliEntry(): Plugin {
  return {
    buildStart() {
      this.emitFile({
        fileName: CLI_CHUNK,
        id: 'cli/cli.ts',
        preserveSignature: false,
        type: 'chunk'
      });
    },
    name: 'add-cli-entry',
    renderChunk(code, chunkInfo) {
      if (chunkInfo.fileName === CLI_CHUNK) {
        const magicString = new MagicString(code);
        //聲明在 shell 中使用 node來運行
        magicString.prepend('#!/usr/bin/env node\n\n');
        return { code: magicString.toString(), map: magicString.generateMap({ hires: true }) };
      }
      return null;
    },
    writeBundle({ dir }) {
      return chmod(resolve(dir!, CLI_CHUNK), '755'); //修改文件可讀寫權(quán)限，保證執(zhí)行的權(quán)限
      /*
			在Node.js中，可以調(diào)用fs模塊，有一個方法chmod，可以用來修改文件或目錄的讀寫權(quán)限。方法chmod有三個參數(shù)，文件路徑、讀寫權(quán)限和回調(diào)函數(shù)，其中讀寫權(quán)限是用代號表示的，
			（1）0600：所有者可讀寫，其他的用戶不行
			（2）0644：所有者可讀寫，其他的用戶只讀
			（3）0740：所有者可讀寫，所有者所在的組只讀
			（4）0755：所有者可讀寫，其他用戶可讀可執(zhí)行
			*/
    }
  };
}

#!/usr/bin/env node
/*
  @license
	Rollup.js v3.2.3
	Sat, 28 Jan 2023 07:43:49 GMT - commit 5fa73d941c16a6bcbebaa3ae5bb6aaca8b97d0b7
	https://github.com/rollup/rollup
	Released under the MIT License.
*/
'use strict';
Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: 'Module' } });
const process$1 = require('node:process');
const rollup = require('../shared/rollup.js');
const require$$2 = require('util');
const require$$0 = require('path');
const require$$0$1 = require('fs');
const node_fs = require('node:fs');
const node_path = require('node:path');
const loadConfigFile_js = require('../shared/loadConfigFile.js');
require('node:perf_hooks');
require('node:crypto');
require('node:events');
require('tty');
require('node:url');
# ...
const command = argParser(process$1.argv.slice(2), {
    alias: rollup.commandAliases,
    configuration: { 'camel-case-expansion': false } //為 argParser 解析器提供配置選項, 'camel-case-expansion': false 表示連字符參數(shù)不會被擴展為駝峰大小寫別名
});
//process.stdin.isTTY 用于檢測我們的程序是否直接連到終端
if (command.help || (process$1.argv.length <= 2 && process$1.stdin.isTTY)) {
    console.log(`\n${help.replace('__VERSION__', rollup.version)}\n`);
}
else if (command.version) {
    console.log(`rollup v${rollup.version}`);
}
else {
  try {
      // eslint-disable-next-line unicorn/prefer-module
      //瀏覽器是支持source maps的，但node環(huán)境原生不支持source maps。所以我們可以通過'source-map-support'包來實現(xiàn)這個功能。這樣當(dāng)程序執(zhí)行出錯的時候方便通過控制臺定位到源碼位置。
      require('source-map-support').install();
  }
  catch {
      // do nothing
  }
  runRollup(command);
}
exports.getConfigPath = getConfigPath;
exports.loadConfigFromCommand = loadConfigFromCommand;
exports.prettyMilliseconds = prettyMilliseconds;
exports.printTimings = printTimings;
//# sourceMappingURL=rollup.map