Configuration Options

Core functionality

external

Type	`(string \| RegExp)[]\| RegExp\| string\| (id: string, parentId: string, isResolved: boolean) => boolean`
CLI	`-e`/`--external <external-id,another-external-id,...>`

Either a function that takes an id and returns true (external) or false (not external), or an Array of module IDs, or regular expressions to match module IDs, that should remain external to the bundle. Can also be just a single ID or regular expression. The matched IDs should be either

the name of an external dependency, exactly the way it is written in the import statement. I.e. to mark import "dependency.js" as external, use "dependency.js" while to mark import "dependency" as external, use "dependency".
a resolved ID (like an absolute path to a file).

// rollup.config.js
import { fileURLToPath } from 'node:url';

export default {
	//...,
	external: [
		'some-externally-required-library',
		fileURLToPath(
			new URL(
				'src/some-local-file-that-should-not-be-bundled.js',
				import.meta.url
			)
		),
		/node_modules/
	]
};

Note that if you want to filter out package imports, e.g. import {rollup} from 'rollup', via a /node_modules/ regular expression, you need something like @rollup/plugin-node-resolve to resolve the imports to node_modules first.

When given as a command line argument, it should be a comma-separated list of IDs

bash

rollup -i src/main.js ... -e foo,bar,baz

When providing a function, it is called with three parameters (id, parent, isResolved) that can give you more fine-grained control

id is the id of the module in question
parent is the id of the module doing the import
isResolved signals whether the id has been resolved by e.g. plugins

When creating an iife or umd bundle, you will need to provide global variable names to replace your external imports via the output.globals option.

If a relative import, i.e. starting with ./ or ../, is marked as "external", rollup will internally resolve the id to an absolute file system location so that different imports of the external module can be merged. When the resulting bundle is written, the import will again be converted to a relative import. Example

// input
// src/main.js (entry point)
import x from '../external.js';
import './nested/nested.js';
console.log(x);

// src/nested/nested.js
// the import would point to the same file if it existed
import x from '../../external.js';
console.log(x);

// output
// the different imports are merged
import x from '../external.js';

console.log(x);

console.log(x);

The conversion back to a relative import is done as if output.file or output.dir were in the same location as the entry point or the common base directory of all entry points if there is more than one.

input

Type	`string \| string []\| { [entryName: string]: string }`
CLI	`-i`/`--input <filename>`

The bundle's entry point(s) (e.g. your main.js or app.js or index.js). If you provide an array of entry points or an object mapping names to entry points, they will be bundled to separate output chunks. Unless the output.file option is used, generated chunk names will follow the output.entryFileNames option. When using the object form, the [name] portion of the file name will be the name of the object property while for the array form, it will be the file name of the entry point.

Note that it is possible when using the object form to put entry points into different sub-folders by adding a / to the name. The following will generate at least two entry chunks with the names entry-a.js and entry-b/index.js, i.e. the file index.js is placed in the folder entry-b

// rollup.config.js
export default {
  ...,
  input: {
    a: 'src/main-a.js',
    'b/index': 'src/main-b.js'
  },
  output: {
    ...,
    entryFileNames: 'entry-[name].js'
  }
};

If you want to convert a set of files to another format while maintaining the file structure and export signatures, the recommended way—instead of using output.preserveModules that may tree-shake exports as well as emit virtual files created by plugins—is to turn every file into an entry point. You can do so dynamically e.g. via the glob package

import { globSync } from 'glob';
import path from 'node:path';
import { fileURLToPath } from 'node:url';

export default {
	input: Object.fromEntries(
		globSync('src/**/*.js').map(file => [
			// This remove `src/` as well as the file extension from each
			// file, so e.g. src/nested/foo.js becomes nested/foo
			path.relative(
				'src',
				file.slice(0, file.length - path.extname(file).length)
			),
			// This expands the relative paths to absolute paths, so e.g.
			// src/nested/foo becomes /project/src/nested/foo.js
			fileURLToPath(new URL(file, import.meta.url))
		])
	),
	output: {
		format: 'es',
		dir: 'dist'
	}
};

The option can be omitted if some plugin emits at least one chunk (using this.emitFile) by the end of the buildStart hook.

When using the command line interface, multiple inputs can be provided by using the option multiple times. When provided as the first options, it is equivalent to not prefix them with --input

shell

rollup --format es --input src/entry1.js --input src/entry2.js
# is equivalent to
rollup src/entry1.js src/entry2.js --format es

Chunks can be named by adding an = to the provided value

shell

rollup main=src/entry1.js other=src/entry2.js --format es

File names containing spaces can be specified by using quotes

shell

rollup "main entry"="src/entry 1.js" "src/other entry.js" --format es

output.dir

Type	`string`
CLI	`-d`/`--dir <dirname>`

The directory in which all generated chunks are placed. This option is required if more than one chunk is generated. Otherwise, the file option can be used instead.

output.file

Type	`string`
CLI	`-o`/`--file <filename>`

The file to write to. Will also be used to generate sourcemaps, if applicable. Can only be used if not more than one chunk is generated.

output.format

Type	`string`
CLI	`-f`/`--format <formatspecifier>`
Default	`"es"`

Specifies the format of the generated bundle. One of the following

amd – Asynchronous Module Definition, used with module loaders like RequireJS
cjs – CommonJS, suitable for Node and other bundlers (alias: commonjs)
es – Keep the bundle as an ES module file, suitable for other bundlers and inclusion as a <script type=module> tag in modern browsers (alias: esm, module)
iife – A self-executing function, suitable for inclusion as a <script> tag. (If you want to create a bundle for your application, you probably want to use this.). "iife" stands for "immediately-invoked Function Expression"
umd – Universal Module Definition, works as amd, cjs and iife all in one
system – Native format of the SystemJS loader (alias: systemjs)

output.globals

Type	`{ [id: string]: string }\| ((id: string) => string)`
CLI	`-g`/`--globals <external-id:variableName,another-external-id:anotherVariableName,...>`

Specifies id: variableName pairs necessary for external imports in umd/iife bundles. For example, in a case like this…

import $ from 'jquery';

…we want to tell Rollup that jquery is external and the jquery module ID equates to the global $ variable

// rollup.config.js
export default {
  ...,
  external: ['jquery'],
  output: {
    format: 'iife',
    name: 'MyBundle',
    globals: {
      jquery: '$'
    }
  }
};

/*
var MyBundle = (function ($) {
  // code goes here
}($));
*/

Alternatively, supply a function that will turn an external module ID into a global variable name.

When given as a command line argument, it should be a comma-separated list of id:variableName pairs

shell

rollup -i src/main.js ... -g jquery:$,underscore:_

To tell Rollup that a local file should be replaced by a global variable, use an absolute id

// rollup.config.js
import { fileURLToPath } from 'node:url';
const externalId = fileURLToPath(
	new URL(
		'src/some-local-file-that-should-not-be-bundled.js',
		import.meta.url
	)
);

export default {
	//...,
	external: [externalId],
	output: {
		format: 'iife',
		name: 'MyBundle',
		globals: {
			[externalId]: 'globalVariable'
		}
	}
};

output.name

Type	`string`
CLI	`-n`/`--name <variableName>`

iife/umd バンドルで値をエクスポートする場合に必要です。この場合、バンドルを表すグローバル変数名になります。同じページ上の他のスクリプトはこの変数名を使用して、バンドルのエクスポートにアクセスできます。

// rollup.config.js
export default {
  ...,
  output: {
    file: 'bundle.js',
    format: 'iife',
    name: 'MyBundle'
  }
};

// var MyBundle = (function () {...

名前空間がサポートされています。つまり、名前にはドットを含めることができます。生成されるバンドルには、名前空間の設定に必要なものが含まれます。

shell

rollup -n "a.b.c"

/* ->
this.a = this.a || {};
this.a.b = this.a.b || {};
this.a.b.c = ...
*/

output.plugins

Type	`MaybeArray<MaybePromise<OutputPlugin \| void>>`

この出力にのみプラグインを追加します。出力固有のプラグインの使用方法の詳細については出力プラグインの使用を、独自のプラグインの作成方法についてはプラグインを参照してください。パッケージからインポートされたプラグインの場合は、インポートされたプラグイン関数を呼び出すことを忘れないでください（つまり、commonjs()、単なるcommonjsではありません）。偽のプラグインは無視されます。これは、プラグインの有効化または無効化を簡単に実行するために使用できます。ネストされたプラグインはフラット化されます。非同期プラグインは待機され、解決されます。

すべてのプラグインがここで使用できるわけではありません。output.plugins は、bundle.generate()またはbundle.write()の実行中、つまりRollupの主要な分析が完了した後に実行されるフックのみを使用するプラグインに限定されています。プラグインの作者である場合は、出力生成フックを参照して、どのフックを使用できるかを確認してください。

次の例では、出力の1つに縮小処理を追加します。

// rollup.config.js
import terser from '@rollup/plugin-terser';

export default {
	input: 'main.js',
	output: [
		{
			file: 'bundle.js',
			format: 'es'
		},
		{
			file: 'bundle.min.js',
			format: 'es',
			plugins: [terser()]
		}
	]
};

plugins

Type	`MaybeArray<MaybePromise<Plugin \| void>>`

プラグインの使用方法の詳細についてはプラグインの使用を、独自のプラグインの作成方法についてはプラグインを参照してください（試してみてください。思っているほど難しくなく、Rollupでできることを大幅に拡張します）。パッケージからインポートされたプラグインの場合は、インポートされたプラグイン関数を呼び出すことを忘れないでください（つまり、commonjs()、単なるcommonjsではありません）。偽のプラグインは無視されます。これは、プラグインの有効化または無効化を簡単に実行するために使用できます。ネストされたプラグインはフラット化されます。非同期プラグインは待機され、解決されます。

// rollup.config.js
import resolve from '@rollup/plugin-node-resolve';
import commonjs from '@rollup/plugin-commonjs';

const isProduction = process.env.NODE_ENV === 'production';

export default (async () => ({
	input: 'main.js',
	plugins: [
		resolve(),
		commonjs(),
		isProduction && (await import('@rollup/plugin-terser')).default()
	],
	output: {
		file: 'bundle.js',
		format: 'cjs'
	}
}))();

（この例では、非同期IIFEと動的インポートを使用して、不要なモジュールの読み込みを回避する方法も示しています。これは驚くほど遅い場合があります。）

高度な機能

cache

Type	`RollupCache \| boolean`
Default	`true`

以前のバンドルのcacheプロパティです。ウォッチモードで後続のビルドを高速化するために使用します。Rollupは変更されたモジュールのみを再解析します。このオプションを明示的にfalseに設定すると、バンドルにcacheプロパティが生成されなくなり、プラグインのキャッシングも無効になります。

const rollup = require('rollup');
let cache;

async function buildWithCache() {
	const bundle = await rollup.rollup({
		cache // is ignored if falsy
		// ... other input options
	});
	cache = bundle.cache; // store the cache object of the previous build
	return bundle;
}

buildWithCache()
	.then(bundle => {
		// ... do something with the bundle
	})
	.then(() => buildWithCache()) // will use the cache of the previous build
	.then(bundle => {
		// ... do something with the bundle
	});

logLevel

Type	`LogLevel \| "silent"`
CLI	`--logLevel <level>`
Default	`"info"`

処理するログを決定します。onLogで利用可能なログレベルを参照してください。デフォルトのlogLevelである"info"は、infoと警告ログが処理され、デバッグログは無視されることを意味します。つまり、プラグインのonLogフック、onLogオプション、またはコンソールに出力されません。

CLIを使用する場合、エラーはログシステム経由で処理されないため、コンソールに引き続き出力されます。エラーログの抑制方法については、--silentフラグを参照してください。

makeAbsoluteExternalsRelative

Type	`boolean\| "ifRelativeSource"`
CLI	`--makeAbsoluteExternalsRelative`/`--no-makeAbsoluteExternalsRelative`
Default	`"ifRelativeSource"`

出力で絶対外部パスを相対パスに変換するかどうかを決定します。これは、ソースで絶対パスであるパスだけでなく、プラグインまたはRollupコアによって絶対パスに解決されるパスにも適用されます。

trueの場合、import "/Users/Rollup/project/relative.js"のような外部インポートは相対パスに変換されます。絶対パスを相対パスに変換する場合、Rollupはfileまたはdirオプションを考慮しません。これは、JavaScript APIを使用するビルドなどでは存在しない可能性があるためです。代わりに、生成されたバンドルのルートは、バンドルに含まれるすべてのモジュールの共通の共有親ディレクトリにあると想定します。すべてのモジュールの共通の親ディレクトリが"/Users/Rollup/project"であると仮定すると、上記のインポートは出力でimport "./relative.js"に変換される可能性があります。出力チャンクが、たとえばchunkFileNames: "chunks/[name].js"を選択することでサブディレクトリにネストされている場合、インポートは"../relative.js"になります。

前述のように、これは、externalオプションによって外部としてマークされる前に絶対パスに解決されるimport "./relative.js"のような元の相対インポートにも適用されます。

一般的な問題の1つは、このメカニズムがimport "/absolute.js'"のようなインポートにも適用され、出力で予期しない相対パスが生成されることです。

この場合、"ifRelativeSource"は、元のインポートが相対インポートかどうかをチェックし、その場合のみ出力で相対インポートに変換します。falseを選択すると、すべてのパスは出力で絶対パスとして保持されます。

externalオプションを使用して相対パスが直接「外部」としてマークされている場合、出力では同じ相対パスになります。プラグインまたはRollupコアによって最初に解決され、その後外部としてマークされた場合は、上記のロジックが適用されます。

maxParallelFileOps

Type	`number`
CLI	`--maxParallelFileOps <number>`
Default	20

モジュールの読み取りまたはチャンクの書き込み時に、rollupが並行して開くファイル数を制限します。制限がない場合、または値が高すぎる場合、「EMFILE：too many open files」でビルドが失敗する可能性があります。これは、オペレーティングシステムが許可するオープンファイルハンドルの数によって異なります。

onLog

Type	`(level: LogLevel, log: RollupLog, defaultHandler: LogOrStringHandler) => void;`

typescript

type LogLevel = 'warn' | 'info' | 'debug';

type LogOrStringHandler = (
	level: LogLevel | 'error',
	log: string | RollupLog
) => void;

// All possible properties, actual properties depend on log
interface RollupLog {
	binding?: string;
	cause?: Error;
	code?: string;
	exporter?: string;
	frame?: string; // always printed by the CLI
	hook?: string;
	id?: string; // always printed by the CLI
	ids?: string[];
	loc?: {
		column: number;
		file?: string;
		line: number;
	}; // always printed by the CLI if id is present
	message: string; // the actual message, always printed by the CLI
	meta?: any; // add custom plugin properties to logs
	names?: string[];
	plugin?: string; // added by Rollup for plugin logs, only printed for warnings
	pluginCode?: string; // added by Rollup for plugin logs that contain a code
	pos?: number;
	reexporter?: string;
	stack?: string; // url for additional information, always printed by the CLI
	url?: string;
}

ログメッセージをインターセプトする関数です。提供されない場合、ログはコンソールに出力されます。Rollup CLIは特定の"warn"ログを集約し、ノイズを減らすためにビルド後に統合された警告を出力します。--silent CLIオプションを使用する場合にも、このハンドラーがトリガーされます。

この関数は、ログレベル、ログオブジェクト、デフォルトハンドラーの3つの引数を受け取ります。ログオブジェクトには、少なくともcodeプロパティとmessageプロパティがあり、さまざまな種類のログの処理方法を制御できます。ログの種類に応じて、他のプロパティが追加されます。組み込みエラーとログの完全なリストとそのコードとプロパティについては、utils/logs.tsを参照してください。

デフォルトハンドラーが呼び出されない場合、ログはコンソールに出力されません。さらに、異なるレベルでデフォルトハンドラーを呼び出すことで、ログレベルを変更できます。追加のレベル"error"を使用すると、ログは、ログのすべてのプロパティが添付されたスローされたエラーになります。

// rollup.config.js
export default {
	//...
	onLog(level, log, handler) {
		if (log.code === 'CIRCULAR_DEPENDENCY') {
			return; // Ignore circular dependency warnings
		}
		if (level === 'warn') {
			handler('error', log); // turn other warnings into errors
		} else {
			handler(level, log); // otherwise, just print the log
		}
	}
};

ログがlogLevelオプションによってフィルタリングされている場合、このハンドラーは呼び出されません。つまり、デフォルトでは、"debug"ログは無視されます。

一部のログには、locプロパティとframeプロパティもあり、ログのソースを見つけることができます。

// rollup.config.js
export default {
	//...
	onLog(level, { loc, frame, message }) {
		if (loc) {
			console.warn(`${loc.file} (${loc.line}:${loc.column}) ${message}`);
			if (frame) console.warn(frame);
		} else {
			console.warn(message);
		}
	}
};

onwarn

Type	`(warning: RollupLog, defaultHandler: (warning: string \| RollupLog) => void) => void;`

警告メッセージをインターセプトする関数です。onLogと非常によく似ていますが、警告のみを受け取ります。デフォルトハンドラーが呼び出されると、ログは警告として処理されます。onLogとonwarnハンドラーの両方が提供されている場合、onLogがlevelをwarnでデフォルトハンドラーを呼び出した場合にのみ、onwarnハンドラーが呼び出されます。

詳細についてはonLogを参照してください。

output.assetFileNames

Type	`string\| ((assetInfo: AssetInfo) => string)`
CLI	`--assetFileNames <pattern>`
Default	`"assets/[name]-[hash][extname]"`

ビルド出力に含めるためにカスタムで出力されるアセットの命名に使用するパターン、またはそのようなパターンを返すためにアセットごとに呼び出される関数です。パターンは次のプレースホルダーをサポートしています。

[extname]：先頭にドットを含むアセットのファイル拡張子（例：.css）。
[ext]：先頭にドットを含まないファイル拡張子（例：css）。
[hash]：アセットのコンテンツに基づくハッシュ。たとえば[hash:10]のように、特定のハッシュ長を設定することもできます。デフォルトでは、base-64ハッシュを作成します。文字セットを減らす必要がある場合は、output.hashCharactersを参照してください。
[name]：拡張子を省いたアセットのファイル名。

フォワードスラッシュ/を使用して、ファイルをサブディレクトリに配置できます。関数の使用時、assetInfoは、fileNameを除いてgenerateBundleのものの縮小版です。output.chunkFileNames、output.entryFileNamesも参照してください。

Type	`string \| ((chunk: ChunkInfo) => string\| Promise<string>)`
CLI	`--banner`/`--footer <text>`

バンドルにプリペンド/アペンドする文字列です。非同期で生成するために、stringに解決されるPromiseを返す関数を提供することもできます（注：bannerとfooterオプションはソースマップを壊しません）。

関数を提供する場合、chunkには、generateBundleフックと同じChunkInfo型を使用するチャンクに関する追加情報が含まれ、次の違いがあります。

チャンクはまだレンダリングされていないため、codeとmapは設定されていません。
ハッシュを含む参照されたすべてのチャンクファイル名には、代わりにハッシュプレースホルダーが含まれます。これには、fileName、imports、importedBindings、dynamicImports、implicitlyLoadedBeforeが含まれます。このオプションから返されたコードでそのようなプレースホルダーファイル名またはその一部を使用する場合、RollupはgenerateBundleの前にプレースホルダーを実際のハッシュに置き換え、ハッシュが参照されたすべてのファイルハッシュを含む最終的に生成されたチャンクの実際のコンテンツを反映するようにします。

chunkは変更可能であり、このフックで適用された変更は、他のプラグインと生成されたバンドルに伝播します。つまり、このフックでインポートまたはエクスポートを追加または削除する場合は、imports、importedBindings、および/またはexportsを更新する必要があります。

// rollup.config.js
export default {
  ...,
  output: {
    ...,
    banner: '/* my-library version ' + version + ' */',
    footer: '/* follow me on Twitter! @rich_harris */'
  }
};

output.intro/output.outroも参照してください。

output.chunkFileNames

Type	`string \| ((chunkInfo: ChunkInfo) => string)`
CLI	`--chunkFileNames <pattern>`
Default	`"[name]-[hash].js"`

コード分割時に作成される共有チャンクに使用するパターン、またはチャンクごとに呼び出されてそのようなパターンを返す関数です。パターンは以下のプレースホルダーをサポートします。

[format]: 出力オプションで定義されたレンダリング形式、例：esまたはcjs。
[hash]: renderChunk内の変換と参照されるファイルハッシュを含む、最終的に生成されたチャンクの内容に基づいたハッシュです。[hash:10]のように、特定のハッシュ長を設定することもできます。デフォルトでは、base-64ハッシュが作成されます。文字セットを削減する必要がある場合は、output.hashCharactersを参照してください。
[name]: チャンクの名前です。output.manualChunksオプションを介して、またはthis.emitFileを介してプラグインによってチャンクが作成された場合に明示的に設定できます。それ以外の場合は、チャンクの内容から導出されます。

スラッシュ/を使用して、ファイルをサブディレクトリに配置できます。関数の使用時、chunkInfoはgenerateBundleのものより簡素化されたバージョンであり、ファイル名に依存するプロパティや、レンダリング済みモジュールに関する情報は含まれません（レンダリングはファイル名が生成された後に行われるため）。ただし、含まれるmoduleIdsのリストにはアクセスできます。output.assetFileNames、output.entryFileNamesも参照してください。

output.compact

Type	`boolean`
CLI	`--compact`/`--no-compact`
Default	`false`

これにより、rollupによって生成されたラッパーコードが縮小されます。これはユーザーが記述したコードには影響しません。このオプションは、事前に縮小されたコードをバンドルする場合に役立ちます。

output.dynamicImportInCjs

Type	`boolean`
CLI	`--dynamicImportInCjs`/`--no-dynamicImportInCjs`
Default	`true`

CommonJS出力はもともと依存関係のインポートにrequire(…)のみをサポートしていましたが、最近のNodeバージョンではimport(…)もサポートされるようになりました。これは、CommonJSファイルからESモジュールをインポートする唯一の方法です。このオプションがデフォルトのtrueの場合、Rollupは外部の動的インポートをCommonJS出力のimport(…)式として保持します。require(…)構文を使用して動的インポートを書き直すには、これをfalseに設定します。

// input
import('external').then(console.log);

// cjs output with dynamicImportInCjs: true or not set
import('external').then(console.log);

// cjs output with dynamicImportInCjs: false
function _interopNamespaceDefault(e) {
	var n = Object.create(null);
	if (e) {
		Object.keys(e).forEach(function (k) {
			if (k !== 'default') {
				var d = Object.getOwnPropertyDescriptor(e, k);
				Object.defineProperty(
					n,
					k,
					d.get
						? d
						: {
								enumerable: true,
								get: function () {
									return e[k];
								}
							}
				);
			}
		});
	}
	n.default = e;
	return Object.freeze(n);
}

Promise.resolve()
	.then(function () {
		return /*#__PURE__*/ _interopNamespaceDefault(require('external'));
	})
	.then(console.log);

output.entryFileNames

Type	`string \| ((chunkInfo: ChunkInfo) => string)`
CLI	`--entryFileNames <pattern>`
Default	`"[name].js"`

エントリポイントから作成されたチャンクに使用するパターン、またはエントリチャンクごとに呼び出されてそのようなパターンを返す関数です。パターンは以下のプレースホルダーをサポートします。

[format]: 出力オプションで定義されたレンダリング形式、例：esまたはcjs。
[hash]: renderChunk内の変換と参照されるファイルハッシュを含む、最終的に生成されたエントリチャンクの内容に基づいたハッシュです。[hash:10]のように、特定のハッシュ長を設定することもできます。デフォルトでは、base-64ハッシュが作成されます。文字セットを削減する必要がある場合は、output.hashCharactersを参照してください。
[name]: 入力オブジェクト形式を使用して異なる名前が定義されていない限り、エントリポイントのファイル名（拡張子なし）。

output.preserveModulesオプションを設定する場合、このパターンはすべてのファイルにも使用されます。この場合、[name]には出力ルートからの相対パスと、.js、.jsx、.mjs、.cjs、.ts、.tsx、.mts、.cts以外の元のファイル拡張子が含まれる場合があります。

output.extend

Type	`boolean`
CLI	`--extend`/`--no-extend`
Default	`false`

umdまたはiife形式でnameオプションによって定義されたグローバル変数を拡張するかどうか。trueの場合、グローバル変数は(global.name = global.name || {})として定義されます。falseの場合、nameによって定義されたグローバルは(global.name = {})のように上書きされます。

output.externalImportAttributes

Type	`boolean`
CLI	`--externalImportAttributes`/`--no-externalImportAttributes`
Default	`true`

出力形式がesの場合、出力の外部インポートにインポート属性を追加するかどうか。デフォルトでは、属性は入力ファイルから取得されますが、プラグインは後で属性を追加または削除できます。例：import "foo" assert {type: "json"}は、オプションがfalseに設定されていない限り、出力に同じインポートが表示されます。モジュールのすべてのインポートで属性が一致する必要があることに注意してください。そうでない場合、警告が出力されます。

output.generatedCode

Type	`"es5" \| "es2015"\| { arrowFunctions?: boolean, constBindings?: boolean, objectShorthand?: boolean, preset?: "es5"\| "es2015", reservedNamesAsProps?: boolean, symbols?: boolean }`
CLI	`--generatedCode <preset>`
Default	`"es5"`

Rollupが生成されたコードで安全に使用できる言語機能。これはユーザーコードをトランスパイルするのではなく、ラッパーやヘルパーで使用されるコードのみを変更します。いくつかのプリセットから選択できます。

"es5": アロー関数などのES2015以降の機能は使用しませんが、プロパティとして使用される予約名は引用符で囲みません。
"es2015": ES2015までのJavaScript機能を使用します。

output.generatedCode.arrowFunctions

Type	`boolean`
CLI	`--generatedCode.arrowFunctions`/`--no-generatedCode.arrowFunctions`
Default	`false`

自動生成されたコードスニペットにアロー関数を使用するかどうか。モジュールラッパーなど、特定の場所では、Rollupは丸括弧で囲まれた通常の関数の使用を続けます。一部のJavaScriptエンジンでは、これにより著しくパフォーマンスが向上します。

output.generatedCode.constBindings

Type	`boolean`
CLI	`--generatedCode.constBindings`/`--no-generatedCode.constBindings`
Default	`false`

これにより、特定の場所とヘルパー関数でvarの代わりにconstが使用されます。これにより、ブロックスコープのため、Rollupはより効率的なヘルパーを生成できます。

// input
export * from 'external';

// cjs output with constBindings: false
var external = require('external');

Object.keys(external).forEach(function (k) {
	if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k))
		Object.defineProperty(exports, k, {
			enumerable: true,
			get: function () {
				return external[k];
			}
		});
});

// cjs output with constBindings: true
const external = require('external');

for (const k in external) {
	if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k))
		Object.defineProperty(exports, k, {
			enumerable: true,
			get: () => external[k]
		});
}

output.generatedCode.objectShorthand

Type	`boolean`
CLI	`--generatedCode.objectShorthand`/`--no-generatedCode.objectShorthand`
Default	`false`

プロパティ名が値と一致する場合、オブジェクトで簡略表記を使用できます。

javascript

// input
const foo = 1;
export { foo, foo as bar };

// system output with objectShorthand: false
System.register('bundle', [], function (exports) {
	'use strict';
	return {
		execute: function () {
			const foo = 1;
			exports({ foo: foo, bar: foo });
		}
	};
});

// system output with objectShorthand: true
System.register('bundle', [], function (exports) {
	'use strict';
	return {
		execute: function () {
			const foo = 1;
			exports({ foo, bar: foo });
		}
	};
});

output.generatedCode.preset

Type	`"es5" \| "es2015"`
CLI	`--generatedCode <value>`

上記にリストされているプリセットのいずれかを選択し、いくつかのオプションをオーバーライドできます。

export default {
	// ...
	output: {
		generatedCode: {
			preset: 'es2015',
			arrowFunctions: false
		}
		// ...
	}
};

output.generatedCode.reservedNamesAsProps

Type	`boolean`
CLI	`--generatedCode.reservedNamesAsProps`/`--no-generatedCode.reservedNamesAsProps`
Default	`true`

"default"などの予約語を引用符を使用せずにプロパティ名として使用できるかどうかを決定します。これにより、生成されたコードの構文がES3準拠になります。ただし、完全なES3準拠にするには、Object.keysやArray.prototype.forEachなどのビルトイン関数をポリフィルする必要がある場合もあります。

javascript

// input
const foo = null;
export { foo as void };

// cjs output with reservedNamesAsProps: false
const foo = null;

exports['void'] = foo;

// cjs output with reservedNamesAsProps: true
const foo = null;

exports.void = foo;

output.generatedCode.symbols

Type	`boolean`
CLI	`--generatedCode.symbols`/`--no-generatedCode.symbols`
Default	`false`

自動生成されたコードスニペットでSymbolの使用を許可するかどうか。現在、これは名前空間がSymbol.toStringTagプロパティをModuleの正しい値に設定するかどうかのみを制御します。つまり、名前空間の場合、String(namespace)は[object Module]を出力します。これは、特定のライブラリやフレームワークの機能検出に使用されます。

javascript

// input
export const foo = 42;

// cjs output with symbols: false
const foo = 42;

exports.foo = foo;

// cjs output with symbols: true
Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });

const foo = 42;

exports.foo = foo;

output.hashCharacters

Type	`"base64" \| "base32" \| "hex"`
CLI	`--hashCharacters <name>`
Default	`"base64"`

これにより、Rollupがファイルハッシュで使用できる文字セットが決まります。

デフォルトの"base64"は、潜在的な文字ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_を持つURLセーフなbase-64ハッシュを使用します。
"base36"は、小文字と数字abcdefghijklmnopqrstuvwxyz0123456789のみを使用します。
"hex"は、文字abcdef0123456789を使用して16進ハッシュを作成します。

output.hoistTransitiveImports

Type	`boolean`
CLI	`--hoistTransitiveImports`/`--no-hoistTransitiveImports`
Default	`true`

デフォルトでは、複数のチャンクを作成する場合、エントリチャンクの推移的インポートは、エントリチャンクへの空のインポートとして追加されます。詳細と背景については、"コード分割時にエントリチャンクに追加のインポートが表示されるのはなぜですか？"を参照してください。このオプションをfalseに設定すると、この動作は無効になります。このオプションは、output.preserveModulesオプションを使用する場合には無視されます。この場合、インポートは決してホイスティングされません。

output.inlineDynamicImports

Type	`boolean`
CLI	`--inlineDynamicImports`/`--no-inlineDynamicImports`
Default	`false`

これにより、新しいチャンクを作成する代わりに動的インポートをインライン化して、単一のバンドルを作成します。単一の入力が提供されている場合のみ可能です。これにより実行順序が変更されることに注意してください。動的にインポートされるモジュールのみが、動的インポートがインライン化されている場合、すぐに実行されます。

output.interop

Type	`"compat" \| "auto" \| "esModule" \| "default" \| "defaultOnly" \| ((id: string) => "compat" \| "auto" \| "esModule" \| "default" \| "defaultOnly")`
CLI	`--interop <value>`
Default	`"default"`

RollupがCommonJSなど、これらの概念をネイティブにサポートしていない形式の外部依存関係からのデフォルト、名前空間、動的インポートをどのように処理するかを制御します。デフォルトモードの"default"はNodeJSの動作を模倣しており、TypeScriptの`esModuleInterop`とは異なることに注意してください。TypeScriptの動作を取得するには、値を` "auto"`に明示的に設定します。例ではCommonJS形式を使用しますが、interopの選択はAMD、IIFE、UMDターゲットにも同様に適用されます。

さまざまな値を理解するために、`cjs`ターゲットに対して次のコードをバンドルしていると仮定します。

import ext_default, * as external from 'external1';
console.log(ext_default, external.bar, external);
import('external2').then(console.log);

Rollupでは、`import * as ext_namespace from 'external'; console.log(ext_namespace.bar);`は`import {bar} from 'external'; console.log(bar);`と完全に同等であり、同じコードが生成されることに注意してください。ただし、上記の例では、名前空間オブジェクト自体もグローバル関数に渡されるため、適切に形成されたオブジェクトとして必要です。

`"default"`は、NodeJSでESモジュールコンテキストからCommonJSをインポートする場合と同様に、必要な値をインポートされたモジュールのデフォルトエクスポートとして扱う必要があると想定しています。名前付きインポートもサポートされており、デフォルトインポートのプロパティとして扱われます。名前空間オブジェクトを作成するために、Rollupはこれらのヘルパーを挿入します。

var external = require('external1');

function _interopNamespaceDefault(e) {
	var n = Object.create(null);
	if (e) {
		Object.keys(e).forEach(function (k) {
			if (k !== 'default') {
				var d = Object.getOwnPropertyDescriptor(e, k);
				Object.defineProperty(
					n,
					k,
					d.get
						? d
						: {
								enumerable: true,
								get: function () {
									return e[k];
								}
							}
				);
			}
		});
	}
	n.default = e;
	return Object.freeze(n);
}

var external__namespace =
	/*#__PURE__*/ _interopNamespaceDefault(external);
console.log(external, external__namespace.bar, external__namespace);
Promise.resolve()
	.then(function () {
		return /*#__PURE__*/ _interopNamespaceDefault(require('external2'));
	})
	.then(console.log);

`"esModule"`は、必要なモジュールが、必要な値がモジュール名前空間に対応し、デフォルトエクスポートがエクスポートされたオブジェクトの`.default`プロパティであるトランスパイルされたESモジュールであると想定しています。これは、ヘルパー関数を挿入しない唯一のinteropタイプです。
js
```
var external = require('external1');
console.log(external.default, external.bar, external);
Promise.resolve()
	.then(function () {
		return require('external2');
	})
	.then(console.log);
```
`esModule`が使用されると、Rollupは追加のinteropヘルパーを追加せず、デフォルトエクスポートのライブバインディングもサポートします。

`"auto"`は、必要な値に`__esModule`プロパティが含まれているかどうかをランタイムで検出するコードを含むヘルパーを挿入することで、`"esModule"`と`"default"`の両方を組み合わせます。このプロパティの追加は、必要な値がトランスパイルされたESモジュールの名前空間であることを示すために、TypeScript `esModuleInterop`、Babel、その他のツールによって実装されたハックです。

var external = require('external1');

function _interopNamespace(e) {
	if (e && e.__esModule) return e;
	var n = Object.create(null);
	if (e) {
		Object.keys(e).forEach(function (k) {
			if (k !== 'default') {
				var d = Object.getOwnPropertyDescriptor(e, k);
				Object.defineProperty(
					n,
					k,
					d.get
						? d
						: {
								enumerable: true,
								get: function () {
									return e[k];
								}
							}
				);
			}
		});
	}
	n.default = e;
	return Object.freeze(n);
}

var external__namespace = /*#__PURE__*/ _interopNamespace(external);
console.log(
	external__namespace.default,
	external__namespace.bar,
	external__namespace
);
Promise.resolve()
	.then(function () {
		return /*#__PURE__*/ _interopNamespace(require('external2'));
	})
	.then(console.log);

Rollupが作成された名前空間オブジェクトを再利用してデフォルトエクスポートを取得する方法に注意してください。名前空間オブジェクトが不要な場合、Rollupはより単純なヘルパーを使用します。

// input
import ext_default from 'external';
console.log(ext_default);

// output
var ext_default = require('external');

function _interopDefault(e) {
	return e && e.__esModule ? e : { default: e };
}

var ext_default__default = /*#__PURE__*/ _interopDefault(ext_default);
console.log(ext_default__default.default);

`compat`は`"auto"`と同等ですが、`__esModule`プロパティではなく`default`プロパティの存在をチェックする、わずかに異なるデフォルトエクスポートのヘルパーを使用している点が異なります。CommonJSモジュールがデフォルトエクスポートとしてはいけない` "default"`プロパティをエクスポートするというまれな状況を除いて、これは特異なハックに依存するのではなく、ダックタイピングを使用するため、多くの場合、interopを「そのまま動作させる」のに役立ちます。

var external = require('external1');

function _interopNamespaceCompat(e) {
	if (e && typeof e === 'object' && 'default' in e) return e;
	var n = Object.create(null);
	if (e) {
		Object.keys(e).forEach(function (k) {
			if (k !== 'default') {
				var d = Object.getOwnPropertyDescriptor(e, k);
				Object.defineProperty(
					n,
					k,
					d.get
						? d
						: {
								enumerable: true,
								get: function () {
									return e[k];
								}
							}
				);
			}
		});
	}
	n.default = e;
	return Object.freeze(n);
}

var external__namespace = /*#__PURE__*/ _interopNamespaceCompat(external);

console.log(
	external__namespace.default,
	external__namespace.bar,
	external__namespace
);
Promise.resolve()
	.then(function () {
		return /*#__PURE__*/ _interopNamespaceCompat(require('external2'));
	})
	.then(console.log);

`"auto"`と同様に、名前空間が不要な場合、Rollupはより単純なヘルパーを使用します。

// input
import ext_default from 'external';
console.log(ext_default);

// output
var ext_default = require('external');

function _interopDefaultCompat(e) {
	return e && typeof e === 'object' && 'default' in e
		? e
		: { default: e };
}

var ext_default__default =
	/*#__PURE__*/ _interopDefaultCompat(ext_default);

console.log(ext_default__default.default);

`"defaultOnly"`は`"default"`に似ていますが、以下の点が異なります。
- 名前付きインポートは禁止されています。そのようなインポートが見つかった場合、Rollupは`es`および`system`形式でもエラーをスローします。このようにして、コードの`es`バージョンがNodeで組み込み以外のCommonJSモジュールを正しくインポートできることが保証されます。
- 名前空間の再エクスポート`export * from 'external';`は禁止されていませんが、無視され、名前付きエクスポートがない場合は効果がないため、Rollupは警告を表示します。
- 名前空間オブジェクトが生成されると、Rollupははるかに単純なヘルパーを使用します。
これが、Rollupがサンプルコードから作成するものです。前に述べたように、これは名前付きインポートと同等であるため、`external.bar`をコードから削除しました。そうでなければ、Rollupはエラーをスローします。
js
```
var ext_default = require('external1');

function _interopNamespaceDefaultOnly(e) {
	return Object.freeze({ __proto__: null, default: e });
}

var ext_default__namespace =
	/*#__PURE__*/ _interopNamespaceDefaultOnly(ext_default);
console.log(ext_default, ext_default__namespace);
Promise.resolve()
	.then(function () {
		return /*#__PURE__*/ _interopNamespaceDefaultOnly(
			require('external2')
		);
	})
	.then(console.log);
```
関数が提供されると、Rollupは各外部IDをこの関数に一度渡して、依存関係ごとのinteropタイプを制御します。
例として、すべての依存関係がCommonJSの場合、次の設定により、名前付きインポートはNode組み込みからのみ許可されます。
js
```
// rollup.config.js
import builtins from 'builtins';
const nodeBuiltins = new Set(builtins());

export default {
	// ...
	output: {
		// ...
		interop(id) {
			if (nodeBuiltins.has(id)) {
				return 'default';
			}
			return 'defaultOnly';
		}
	}
};
```

生成されたinteropコードに影響を与える追加のオプションがいくつかあります。

`output.externalLiveBindings`を`false`に設定すると、簡素化された名前空間ヘルパーと、抽出されたデフォルトインポートの簡素化されたコードが生成されます。
`output.freeze`を`false`に設定すると、生成されたinterop名前空間オブジェクトの凍結が防止されます。

output.intro/output.outro

Type	`string \| ((chunk: ChunkInfo) => string\| Promise<string>)`
CLI	`--intro`/`--outro <text>`

`output.banner/output.footer`に似ていますが、コードはフォーマット固有のラッパーの*内部*に入ります。

export default {
	//...,
	output: {
		//...,
		intro: 'const ENVIRONMENT = "production";'
	}
};

output.manualChunks

Type	`{ [chunkAlias: string]: string[] } \| ((id: string, {getModuleInfo, getModuleIds}) => string \| void)`

カスタム共有コモンチャンクの作成を許可します。オブジェクト形式を使用する場合、各プロパティは、リストされたモジュールとそのすべての依存関係（モジュールグラフの一部であり、別のマニュアルチャンクにない場合）を含むチャンクを表します。

リストされたモジュール自体がモジュールグラフの一部である必要がないことに注意してください。これは、`@rollup/plugin-node-resolve`を使用していて、パッケージからディープインポートを使用する場合に役立ちます。たとえば

javascript

({
	manualChunks: {
		lodash: ['lodash']
	}
});

`lodash`モジュールのすべてを、`import get from 'lodash/get'`形式のインポートのみを使用している場合でも、マニュアルチャンクに入れます。

関数形式を使用する場合、解決されたモジュールIDごとに、関数が呼び出されます。文字列が返されると、モジュールとそのすべての依存関係は、指定された名前のマニュアルチャンクに追加されます。たとえば、これにより、`node_modules`内のすべての依存関係を含む`vendor`チャンクが作成されます。

javascript

function manualChunks(id) {
	if (id.includes('node_modules')) {
		return 'vendor';
	}
}

マニュアルチャンクは、対応するモジュールが実際に使用される前に副作用がトリガーされると、アプリケーションの動作を変更する可能性があることに注意してください。

関数形式を使用する場合、`manualChunks`には、`getModuleInfo`と`getModuleIds`関数を収めたオブジェクトが2番目のパラメーターとして渡されます。これらは、プラグインコンテキストの`this.getModuleInfo`と`this.getModuleIds`と同じように機能します。

これは、モジュールグラフ内の位置に応じて、モジュールをどのマニュアルチャンクに配置するかを動的に決定するために使用できます。たとえば、各コンポーネントが翻訳された文字列のセットを動的にインポートするコンポーネントのセットがあるシナリオを考えてみましょう。

// Inside the "foo" component

function getTranslatedStrings(currentLanguage) {
	switch (currentLanguage) {
		case 'en':
			return import('./foo.strings.en.js');
		case 'de':
			return import('./foo.strings.de.js');
		// ...
	}
}

このような多くのコンポーネントが一緒に使用されると、非常に小さいチャンクの動的インポートが多数発生します。同じチャンクによってインポートされた同じ言語のすべての言語ファイルが常に一緒に使用されることがわかっている場合でも、Rollupにはこの情報がありません。

次のコードは、単一のエントリポイントによってのみ使用される同じ言語のすべてのファイルをマージします。

function manualChunks(id, { getModuleInfo }) {
	const match = /.*\.strings\.(\w+)\.js/.exec(id);
	if (match) {
		const language = match[1]; // e.g. "en"
		const dependentEntryPoints = [];

		// we use a Set here so we handle each module at most once. This
		// prevents infinite loops in case of circular dependencies
		const idsToHandle = new Set(getModuleInfo(id).dynamicImporters);

		for (const moduleId of idsToHandle) {
			const { isEntry, dynamicImporters, importers } =
				getModuleInfo(moduleId);
			if (isEntry || dynamicImporters.length > 0)
				dependentEntryPoints.push(moduleId);

			// The Set iterator is intelligent enough to iterate over
			// elements that are added during iteration
			for (const importerId of importers) idsToHandle.add(importerId);
		}

		// If there is a unique entry, we put it into a chunk based on the
		// entry name
		if (dependentEntryPoints.length === 1) {
			return `${
				dependentEntryPoints[0].split('/').slice(-1)[0].split('.')[0]
			}.strings.${language}`;
		}
		// For multiple entries, we put it into a "shared" chunk
		if (dependentEntryPoints.length > 1) {
			return `shared.strings.${language}`;
		}
	}
}

output.minifyInternalExports

Type	`boolean`
CLI	`--minifyInternalExports`/`--no-minifyInternalExports`
Default	`es`および`system`形式の場合、または`output.compact`が`true`の場合`true`、それ以外の場合は`false`

デフォルトでは、`es`および`system`形式の場合、または`output.compact`が`true`の場合、Rollupは内部変数を1文字の変数としてエクスポートして、より良い縮小を可能にします。

例
入力

// main.js
import './lib.js';

// lib.js
import('./dynamic.js');
export const importantValue = 42;

// dynamic.js
import { importantValue } from './lib.js';
console.log(importantValue);

`output.minifyInternalExports: true`での出力

// main.js
import './main-5532def0.js';

// main-5532def0.js
import('./dynamic-402de2f0.js');
const importantValue = 42;

export { importantValue as i };

// dynamic-402de2f0.js
import { i as importantValue } from './main-5532def0.js';

console.log(importantValue);

`output.minifyInternalExports: false`での出力

// main.js
import './main-5532def0.js';

// main-5532def0.js
import('./dynamic-402de2f0.js');
const importantValue = 42;

export { importantValue };

// dynamic-402de2f0.js
import { importantValue } from './main-5532def0.js';

console.log(importantValue);

このオプションを`true`に設定すると出力が大きくなるように見えますが、実際にはミニファイアを使用する場合、小さくなります。この場合、`export { importantValue as i }`は、たとえば`export{a as i}`または`export{i}`になる可能性がありますが、そうでなければ`export{ a as importantValue }`が生成されます。これは、ミニファイアは通常、エクスポートシグネチャを変更しないためです。

output.paths

Type	`{ [id: string]: string } \| ((id: string) => string)`

外部モジュールIDをパスにマッピングします。外部IDとは、解決できないID、または`external`オプションによって明示的に提供されたIDです。`output.paths`によって提供されるパスは、モジュールIDの代わりに生成されたバンドルで使用され、たとえば、CDNから依存関係をロードできます。

// app.js
import { selectAll } from 'd3';
selectAll('p').style('color', 'purple');
// ...

// rollup.config.js
export default {
	input: 'app.js',
	external: ['d3'],
	output: {
		file: 'bundle.js',
		format: 'amd',
		paths: {
			d3: 'https://d3.dokyumento.jp/d3.v4.min'
		}
	}
};

// bundle.js
define(['https://d3.dokyumento.jp/d3.v4.min'], function (d3) {
	d3.selectAll('p').style('color', 'purple');
	// ...
});

output.preserveModules

Type	`boolean`
CLI	`--preserveModules`/`--no-preserveModules`
Default	`false`

できるだけ少ないチャンクを作成する代わりに、このモードは、元のモジュール名をファイル名として使用するすべてのモジュールに個別のチャンクを作成します。`output.dir`オプションが必要です。ツリーシェイキングは引き続き適用され、提供されたエントリポイントで使用されていないファイル、または実行時に副作用がなく、エントリポイントではないファイルの未使用のエクスポートが抑制されます。一方、プラグイン（`@rollup/plugin-commonjs`など）が特定の結果を得るために追加の「仮想」ファイルを生成する場合、これらのファイルは`_virtual/fileName.js`パターンを使用して実際のファイルとして生成されます。

したがって、ファイルから期待どおりにインポートする場合に、ファイル構造全体を別の形式に変換するために、このオプションを盲目的に使用することはお勧めできません。期待されるエクスポートが欠落している可能性があります。その場合は、`input`オプションオブジェクトに追加することで、すべてのファイルを明示的にエントリポイントとして指定する必要があります。方法については、その例を参照してください。

`cjs`または`amd`形式に変換する場合、各ファイルはデフォルトで`output.exports`が`auto`に設定されたエントリポイントとして扱われます。つまり、たとえば`cjs`の場合、デフォルトエクスポートのみを含むファイルは

// input main.js
export default 42;

// output main.js
('use strict');

var main = 42;

module.exports = main;

値を`module.exports`に直接代入します。誰かがこのファイルをインポートすると、

const main = require('./main.js');
console.log(main); // 42

を介してデフォルトエクスポートにアクセスできます。通常のエントリポイントと同様に、デフォルトエクスポートと名前付きエクスポートを混在させるファイルは警告を生成します。`output.exports: "named"`を使用してすべてのファイルで名前付きエクスポートモードを強制することで、警告を回避できます。その場合、デフォルトエクスポートには、エクスポートの`.default`プロパティを介してアクセスする必要があります。

// input main.js
export default 42;

// output main.js
('use strict');

Object.defineProperty(exports, '__esModule', { value: true });

var main = 42;

exports.default = main;

// consuming file
const main = require('./main.js');
console.log(main.default); // 42

output.preserveModulesRoot

Type	`string`
CLI	`--preserveModulesRoot <directory-name>`

`output.preserveModules`が`true`の場合に`output.dir`パスから削除される入力モジュールへのディレクトリパス。

たとえば、次の構成を指定すると

javascript

export default {
	input: ['src/module.js', `src/another/module.js`],
	output: [
		{
			format: 'es',
			dir: 'dist',
			preserveModules: true,
			preserveModulesRoot: 'src'
		}
	]
};

`preserveModulesRoot`設定により、入力モジュールは`dist/module.js`と`dist/another/module.js`のパスに出力されます。

このオプションは、出力ディレクトリ構造の変更を引き起こす可能性のある`@rollup/plugin-node-resolve`などのプラグインを使用する場合に特に役立ちます。これは、サードパーティモジュールが`external`としてマークされていない場合、または互いに依存し、`external`としてマークされていない複数のパッケージのモノレポで開発する場合に発生する可能性があります。

output.sourcemap

Type	`boolean \| 'inline' \| 'hidden'`
CLI	`-m`/`--sourcemap`/`--no-sourcemap`
Default	`false`

`true`の場合、個別のソースマップファイルが作成されます。`"inline"`の場合、ソースマップはデータURIとして結果の`output`ファイルに追加されます。`"hidden"`は`true`と同様に機能しますが、バンドルされたファイルの対応するソースマップコメントは抑制されます。

output.sourcemapBaseUrl

Type	`string`
CLI	`--sourcemapBaseUrl <url>`

デフォルトでは、Rollupによって生成されるソースマップファイルは、記述されているファイルを参照するために相対URLを使用します。絶対ベースURL（例：https://example.com）を指定することで、ソースマップは代わりに絶対URLを使用します。

output.sourcemapExcludeSources

Type	`boolean`
CLI	`--sourcemapExcludeSources`/`--no-sourcemapExcludeSources`
Default	`false`

trueの場合、ソースの実際のコードはソースマップに追加されず、ソースマップのサイズが大幅に小さくなります。

output.sourcemapFile

Type	`string`
CLI	`--sourcemapFile <file-name-with-path>`

生成されたバンドルの場所。これが絶対パスである場合、ソースマップ内のすべてのsourcesパスは、このパスを基準とした相対パスになります。map.fileプロパティはsourcemapFileのベース名であり、ソースマップの場所はバンドルに隣接していると想定されます。

outputが指定されている場合は、sourcemapFileは必須ではありません。その場合、バンドルの出力ファイル名に ".map" を追加することで出力ファイル名が推測されます。

output.sourcemapFileNames

Type	`string \| ((chunkInfo: ChunkInfo) => string)`
CLI	`--sourcemapFileNames <pattern>`

ソースマップに使用するパターン、またはソースマップごとに呼び出されてそのようなパターンを返す関数。パターンは以下のプレースホルダーをサポートします。

[format]: 出力オプションで定義されたレンダリング形式、例：esまたはcjs。
[hash]: 最終的に生成されたソースマップの内容に基づいたハッシュ。[hash:10]のように、特定のハッシュ長を設定することもできます。デフォルトでは、base-64ハッシュが作成されます。文字セットを削減する必要がある場合は、output.hashCharactersを参照してください。
[chunkhash]: 対応する生成されたチャンク（存在する場合）で使用されるものと同じハッシュ。
[name]: 入力オブジェクト形式を使用して異なる名前が定義されていない限り、エントリポイントのファイル名（拡張子なし）。

output.sourcemapIgnoreList

Type	`boolean \| (relativeSourcePath: string, sourcemapPath: string) => boolean`

ソースマップ内のソースファイルを無視リストに登録するかどうかを決定する述語。これは、x_google_ignoreListソースマップ拡張機能を設定するために使用されます。relativeSourcePathは、生成された.mapファイルから対応するソースファイルへの相対パスであり、sourcemapPathは生成されたソースマップファイルの完全に解決されたパスです。

import path from 'node:path';
export default {
	input: 'src/main',
	output: [
		{
			file: 'bundle.js',
			sourcemapIgnoreList: (relativeSourcePath, sourcemapPath) => {
				// will ignore-list all files with node_modules in their paths
				return relativeSourcePath.includes('node_modules');
			},
			format: 'es',
			sourcemap: true
		}
	]
};

このオプションを明示的に指定しない場合、デフォルトではパスにnode_modulesが含まれるすべてのファイルを無視リストに登録します。無視リストの登録を完全にオフにするには、ここでfalseを指定できます。

output.sourcemapPathTransform

Type	`(relativeSourcePath: string, sourcemapPath: string) => string`

ソースマップ内の各パスに適用する変換。relativeSourcePathは、生成された.mapファイルから対応するソースファイルへの相対パスであり、sourcemapPathは生成されたソースマップファイルの完全に解決されたパスです。

import path from 'node:path';
export default {
	input: 'src/main',
	output: [
		{
			file: 'bundle.js',
			sourcemapPathTransform: (relativeSourcePath, sourcemapPath) => {
				// will replace relative paths with absolute paths
				return path.resolve(
					path.dirname(sourcemapPath),
					relativeSourcePath
				);
			},
			format: 'es',
			sourcemap: true
		}
	]
};

output.validate

Type	`boolean`
CLI	`--validate`/`--no-validate`
Default	`false`

生成されたコードが有効なJavaScriptであるかどうかを検出するために、生成された各チャンクを再解析します。これは、renderChunkフックを使用してコードを変換するプラグインによって生成された出力をデバッグするのに役立ちます。

コードが無効な場合、警告が表示されます。生成された出力を検査できるように、エラーはスローされません。この警告をエラーに昇格させるには、onwarnハンドラーで監視できます。

preserveEntrySignatures

Type	`"strict" \| "allow-extension" \| "exports-only"\| false`
CLI	`--preserveEntrySignatures <strict \| allow-extension>`/`--no-preserveEntrySignatures`
Default	`"exports-only"`

Rollupがエントリチャンクが基礎となるエントリモジュールと同じエクスポートを持つことを保証しようとするかどうかを制御します。

"strict"に設定されている場合、Rollupは対応するエントリモジュールにあるものとまったく同じエクスポートをエントリチャンクに作成します。追加の内部エクスポートをチャンクに追加する必要があるためこれが不可能な場合、Rollupは代わりに、他のチャンクから必要なバインディングを再エクスポートするだけの「ファサード」エントリチャンクを作成しますが、それ以外のコードは含まれません。これはライブラリには推奨される設定です。
"allow-extension"は、エントリチャンクにエントリモジュールのすべてのエクスポートを作成しますが、必要に応じて追加のエクスポートを追加することもでき、「ファサード」エントリチャンクを回避します。この設定は、厳密なシグネチャが不要なライブラリに適しています。
"exports-only"は、エントリモジュールにエクスポートがある場合は"strict"のように動作し、それ以外の場合は"allow-extension"のように動作します。
falseは、エントリモジュールのエクスポートを対応するチャンクに追加せず、それらのエクスポートがバンドルの他の場所で使用されない限り、対応するコードも含まれません。ただし、内部エクスポートはエントリチャンクに追加される場合があります。これは、エントリチャンクがスクリプトタグに配置されるWebアプリには推奨される設定です。チャンク数とバンドルサイズの両方を削減できる可能性があります。

例
入力

// main.js
import { shared } from './lib.js';
export const value = `value: ${shared}`;
import('./dynamic.js');

// lib.js
export const shared = 'shared';

// dynamic.js
import { shared } from './lib.js';
console.log(shared);

preserveEntrySignatures: "strict" の出力

// main.js
export { v as value } from './main-50a71bb6.js';

// main-50a71bb6.js
const shared = 'shared';

const value = `value: ${shared}`;
import('./dynamic-cd23645f.js');

export { shared as s, value as v };

// dynamic-cd23645f.js
import { s as shared } from './main-50a71bb6.js';

console.log(shared);

preserveEntrySignatures: "allow-extension" の出力

// main.js
const shared = 'shared';

const value = `value: ${shared}`;
import('./dynamic-298476ec.js');

export { shared as s, value };

// dynamic-298476ec.js
import { s as shared } from './main.js';

console.log(shared);

preserveEntrySignatures: false の出力

// main.js
import('./dynamic-39821cef.js');

// dynamic-39821cef.js
const shared = 'shared';

console.log(shared);

現時点では、個々のエントリチャンクに対してこの設定をオーバーライドする唯一の方法は、プラグインAPIを使用して、inputオプションを使用する代わりに、this.emitFileを介してそれらのチャンクを出力することです。

strictDeprecations

Type	`boolean`
CLI	`--strictDeprecations`/`--no-strictDeprecations`
Default	`false`

このフラグが有効になっている場合、Rollupは非推奨の機能が使用されたときに警告を表示する代わりに、エラーをスローします。さらに、次のメジャーバージョンで非推奨の警告を受け取るようにマークされている機能も、使用されるとエラーをスローします。

このフラグは、たとえばプラグイン作成者ができるだけ早く次のメジャーリリースに向けてプラグインを調整できるようにするために使用することを目的としています。

危険ゾーン

何をやっているのか分かっている場合を除き、これらのオプションを使用する必要はないでしょう！

context

Type	`string`
CLI	`--context <contextVariable>`
Default	`undefined`

デフォルトでは、モジュールのコンテキスト（つまり、最上位レベルでのthisの値）はundefinedです。まれに、これを'window'などの他のものに変更する必要がある場合があります。

moduleContext

Type	`((id: string) => string) \| { [id: string]: string }`

contextと同じですが、モジュールごとです。id: contextペアのオブジェクト、またはid => context関数のいずれかになります。

output.amd

Type	`{ id?: string, autoId?: boolean, basePath?: string, define?: string }`

注：idは単一ファイルビルドでのみ使用でき、autoId/basePathと組み合わせることはできません。

output.amd.id

Type	`string`
CLI	`--amd.id <amdId>`

AMD/UMDバンドルに使用するID。

// rollup.config.js
export default {
  ...,
  format: 'amd',
  amd: {
    id: 'my-bundle'
  }
};

// -> define('my-bundle', ['dependency'], ...

output.amd.autoId

Type	`boolean`
CLI	`--amd.autoId`

IDをチャンクID（'.js'拡張子を削除したもの）に設定します。

// rollup.config.js
export default {
  ...,
  format: 'amd',
  amd: {
    autoId: true
  }
};

// -> define('main', ['dependency'], ...
// -> define('dynamic-chunk', ['dependency'], ...

output.amd.basePath

Type	`string`
CLI	`--amd.basePath`

自動生成されたIDの前に追加されるパス。ビルドが別のAMDプロジェクト内に配置され、ルートにない場合に役立ちます。

output.amd.autoIdでのみ有効です。

// rollup.config.js
export default {
  ...,
  format: 'amd',
  amd: {
    autoId: true,
    basePath: 'some/where'
  }
};

// -> define('some/where/main', ['dependency'], ...
// -> define('some/where/dynamic-chunk', ['dependency'], ...

output.amd.define

Type	`string`
CLI	`--amd.define <defineFunctionName>`

defineの代わりに使用する関数名。

// rollup.config.js
export default {
  ...,
  format: 'amd',
  amd: {
    define: 'def'
  }
};

// -> def(['dependency'],...

output.amd.forceJsExtensionForImports

Type	`boolean`
CLI	`--amd.forceJsExtensionForImports`
Default	`false`

生成されたチャンクとローカルAMDモジュールのインポートに.js拡張子を追加します。

// rollup.config.js
export default {
  ...,
  format: 'amd',
  amd: {
    forceJsExtensionForImports: true
  }
};

// -> define(['./chunk-or-local-file.js', 'dependency', 'third/dependency'],...

output.esModule

Type	`boolean \| "if-default-prop"`
CLI	`--esModule`/`--no-esModule`
Default	`"if-default-prop"`

非ES形式のエクスポートを生成する際に__esModule: trueプロパティを追加するかどうか。このプロパティは、エクスポートされた値がESモジュールの名前空間であり、このモジュールのデフォルトエクスポートがエクスポートされたオブジェクトの.defaultプロパティに対応することを示します。

trueは、名前付きエクスポートモードを使用する場合に常にプロパティを追加します。これは他のツールが行うものと似ています。
"if-default-prop"は、名前付きエクスポートモードを使用していて、デフォルトエクスポートもある場合にのみプロパティを追加します。微妙な違いは、デフォルトエクスポートがない場合、ライブラリのCommonJSバージョンのコンシューマーは、エラーまたはundefinedの代わりに、すべての名前付きエクスポートをデフォルトエクスポートとして取得することです。__esModuleプロパティは、JavaScriptランタイムによって追従される標準ではなく、多くの相互運用性の問題を引き起こすため、本当に必要な場合にのみ使用を制限することを選択しました。そのため、デフォルト値としてこれを選択しました。
一方、falseは、デフォルトエクスポートが.defaultプロパティになる場合でも、プロパティを追加しません。

output.interopも参照してください。

output.exports

Type	`"auto" \| "default"\| "named"\| "none"`
CLI	`--exports <exportMode>`
Default	`'auto'`

使用するエクスポートモード。デフォルトはautoで、inputモジュールがエクスポートするものに基づいて意図を推測します。

default - export default ...を使用して1つのものだけをエクスポートする場合。CommonJS出力を生成する場合、これはESM出力と互換性があることを意図している場合に問題を引き起こす可能性があることに注意してください（下記参照）。
named - 名前付きエクスポートを使用する場合。
none - 何もエクスポートしない場合（例：ライブラリではなくアプリをビルドする場合）。

これは出力変換のみであるため、すべてのエントリチャンクのエクスポートがデフォルトエクスポートのみである場合にのみdefaultを選択できます。同様に、エクスポートがない場合にのみnoneを選択できます。それ以外の場合は、Rollupはエラーをスローします。

defaultとnamedの違いは、他の人がどのようにあなたのバンドルを利用できるかに影響します。defaultを使用する場合、CommonJSユーザーは例えば以下のように実行できます。

// your-lib package entry
export default 'Hello world';

// a CommonJS consumer
/* require( "your-lib" ) returns "Hello World" */
const hello = require('your-lib');

namedを使用する場合、ユーザーは代わりに以下のように実行します。

// your-lib package entry
export const hello = 'Hello world';

// a CommonJS consumer
/* require( "your-lib" ) returns {hello: "Hello World"} */
const hello = require('your-lib').hello;
/* or using destructuring */
const { hello } = require('your-lib');

問題は、namedエクスポートを使用していて、同時にdefaultエクスポートも持っている場合、ユーザーはdefaultエクスポートを使用するために次のようなことをする必要があるということです。

// your-lib package entry
export default 'foo';
export const bar = 'bar';

// a CommonJS consumer
/* require( "your-lib" ) returns {default: "foo", bar: "bar"} */
const foo = require('your-lib').default;
const bar = require('your-lib').bar;
/* or using destructuring */
const { default: foo, bar } = require('your-lib');

注記: Babel、TypeScript、Webpack、@rollup/plugin-commonjsなど、ESモジュールでCommonJSのrequire(...)呼び出しを解決できるツールがあります。これらのツールに対してESM出力と相互運用可能なCommonJS出力を生成する場合は、常にnamedエクスポートモードを使用する必要があります。その理由は、これらのツールのほとんどは、デフォルトでrequire時にESモジュールの名前空間を返し、デフォルトエクスポートは.defaultプロパティであるためです。

言い換えれば、これらのツールでは、const lib = require("your-lib")がimport lib from "your-lib"と同じになるようなパッケージインターフェースを作成することはできません。しかし、namedエクスポートモードでは、const {lib} = require("your-lib")はimport {lib} from "your-lib"と等価になります。

output.externalLiveBindings

Type	`boolean`
CLI	`--externalLiveBindings`/`--no-externalLiveBindings`
Default	`true`

falseに設定すると、Rollupは外部インポートのライブバインディングをサポートするコードを生成せず、代わりにエクスポートが時間とともに変化しないと仮定します。これにより、Rollupはより最適化されたコードを生成できます。ただし、外部依存関係を含む循環依存関係がある場合、問題が発生する可能性があることに注意してください。

これにより、Rollupがコードにゲッターを生成するほとんどのケースが回避され、多くの場合、IE8互換のコードを作成するために使用できます。

例

// input
export { x } from 'external';

// CJS output with externalLiveBindings: true
var external = require('external');

Object.defineProperty(exports, 'x', {
	enumerable: true,
	get: function () {
		return external.x;
	}
});

// CJS output with externalLiveBindings: false
var external = require('external');

exports.x = external.x;

output.freeze

Type	`boolean`
CLI	`--freeze`/`--no-freeze`
Default	`true`

動的にアクセスされる名前空間インポートオブジェクト（つまり、import * as namespaceImportObject from...）をObject.freeze()するかどうか。

output.indent

Type	`boolean \| string`
CLI	`--indent`/`--no-indent`
Default	`true`

コードのインデントが必要な形式（amd、iife、umd、system）で使用されるインデント文字列。false（インデントなし）、またはtrue（デフォルト - 自動インデント）にすることもできます。

// rollup.config.js
export default {
  ...,
  output: {
    ...,
    indent: false
  }
};

output.noConflict

Type	`boolean`
CLI	`--noConflict`/`--no-noConflict`
Default	`false`

これにより、UMDバンドルに追加のnoConflictエクスポートが生成されます。IIFEシナリオで呼び出されると、このメソッドはバンドルエクスポートを返し、対応するグローバル変数を以前の値に復元します。

output.reexportProtoFromExternal

Type	`boolean`
CLI	`--reexportProtoFromExternal`/`--no-reexportProtoFromExternal`
Default	`true`

このオプションは、output.formatが['amd', 'cjs', 'iife', 'umd']のいずれかに設定され、output.externalLiveBindingsがfalseに設定されている場合にのみ有効です。

最大の互換性のために、Rollupはデフォルトで外部モジュールから__proto__を再エクスポートします。ただし、一般的なユースケースでは、この値をfalseに設定することを強くお勧めします。これにより、出力サイズが効果的に削減されるためです。

// the input file
export * from 'rollup';

// the output file if the output.format is cjs
'use strict';

// reexportProtoFromExternal is true
var rollup = require('rollup');

Object.prototype.hasOwnProperty.call(rollup, '__proto__') &&
	!Object.prototype.hasOwnProperty.call(exports, '__proto__') &&
	Object.defineProperty(exports, '__proto__', {
		enumerable: true,
		value: rollup['__proto__']
	});

Object.keys(rollup).forEach(function (k) {
	if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k))
		exports[k] = rollup[k];
});

// reexportProtoFromExternal is false
var rollup = require('rollup');

Object.keys(rollup).forEach(function (k) {
	if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k))
		exports[k] = rollup[k];
});

output.sanitizeFileName

Type	`boolean \| (string) => string`
CLI	`--sanitizeFileName`/`no-sanitizeFileName`
Default	`true`

すべてのチャンク名サニタイゼーション（\0、?、*文字の削除）を無効にするには、falseに設定します。

あるいは、関数を設定して、カスタムチャンク名サニタイゼーションを許可します。

output.strict

Type	`boolean`
CLI	`--strict`/`--no-strict`
Default	`true`

生成された非ESバンドルの先頭に「use strict」pragmaを含めるかどうか。厳密に言えば、ESモジュールは常に厳格モードであるため、正当な理由がない限り、これを無効にしないでください。

output.systemNullSetters

Type	`boolean`
CLI	`--systemNullSetters`/`--no-systemNullSetters`
Default	`true`

systemモジュール形式を出力する場合、デフォルトでは、空のセッター関数は出力の簡素化のためにnullに置き換えられます。これは、v6.3.3より前のSystemJSと互換性がありません。古いSystemJSバージョンがサポートする空の関数を代わりに出力するには、このオプションを無効にします。

preserveSymlinks

Type	`boolean`
CLI	`--preserveSymlinks`
Default	`false`

falseに設定すると、ファイルの解決時にシンボリックリンクがたどられます。trueに設定すると、たどられる代わりに、シンボリックリンクはリンクがある場所にあるファイルとして扱われます。次の状況を考えてみましょう。

// /main.js
import { x } from './linked.js';
console.log(x);

// /linked.js
// this is a symbolic link to /nested/file.js

// /nested/file.js
export { x } from './dep.js';

// /dep.js
export const x = 'next to linked';

// /nested/dep.js
export const x = 'next to original';

preserveSymlinksがfalseの場合、/main.jsから作成されたバンドルは、シンボリックリンクされたファイルの場所を使用して依存関係を解決するため、「元の隣」とログ出力します。しかし、preserveSymlinksがtrueの場合、「リンクされた隣」とログ出力します。これは、シンボリックリンクが解決されないためです。

shimMissingExports

Type	`boolean`
CLI	`--shimMissingExports`/`--no-shimMissingExports`
Default	`false`

このオプションが指定されている場合、バインディングがこれらのバインディングを定義しないファイルからインポートされても、バンドルは失敗しません。代わりに、これらのバインディングに対して、値がundefinedの新しい変数が作成されます。

treeshake

Type	`boolean \| TreeshakingPreset \| TreeshakingOptions`
CLI	`--treeshake`/`--no-treeshake`
Default	`true`

typescript

type TreeshakingPreset = 'smallest' | 'safest' | 'recommended';

interface TreeshakingOptions {
	annotations?: boolean;
	correctVarValueBeforeDeclaration?: boolean;
	moduleSideEffects?: ModuleSideEffectsOption;
	preset?: TreeshakingPreset;
	propertyReadSideEffects?: boolean | 'always';
	tryCatchDeoptimization?: boolean;
	unknownGlobalSideEffects?: boolean;
}

type ModuleSideEffectsOption =
	| boolean
	| 'no-external'
	| string[]
	| HasModuleSideEffects;
type HasModuleSideEffects = (id: string, external: boolean) => boolean;

ツリーシェイキングを適用するかどうか、およびツリーシェイキングのプロセスを微調整するかどうか。このオプションをfalseに設定すると、バンドルは大きくなりますが、ビルドのパフォーマンスが向上する可能性があります。新しいオプションが追加された場合に自動的に更新される3つのプリセットのいずれかを選択することもできます。

"smallest"は、出力サイズを可能な限り最小限に抑えるためにオプション値を選択します。これは、現在、特定のパターンに依存していない限り、ほとんどのコードベースで機能するはずです。
- 副作用のあるゲッターは、戻り値が使用されている場合にのみ保持されます（treeshake.propertyReadSideEffects: false）。
- インポートされたモジュールのコードは、少なくとも1つのエクスポートされた値が使用されている場合にのみ保持されます（treeshake.moduleSideEffects: false）。
- 壊れたビルトインを検出することに依存するポリフィルをバンドルしないでください（treeshake.tryCatchDeoptimization: false）。
- いくつかのセマンティックな問題が飲み込まれる可能性があります（treeshake.unknownGlobalSideEffects: false、treeshake.correctVarValueBeforeDeclaration: false）。
"recommended"は、ほとんどの使用パターンでうまく機能するはずです。ただし、いくつかのセマンティックな問題が飲み込まれる可能性があります（treeshake.unknownGlobalSideEffects: false、treeshake.correctVarValueBeforeDeclaration: false）。
"safest"は、基本的なツリーシェイキング機能を提供しながら、可能な限り仕様に準拠しようとします。
trueは、オプションを指定しないことと同じであり、常にデフォルト値を選択します（下記参照）。

ツリーシェイキングアルゴリズムによって発生したバグを発見した場合は、問題を報告してください！このオプションをオブジェクトに設定すると、ツリーシェイキングが有効になり、次の追加オプションが許可されます。

treeshake.annotations

Type	`boolean`
CLI	`--treeshake.annotations`/`--no-treeshake.annotations`
Default	`true`

falseの場合、コメント内のアノテーションからのヒントを無視します。

`@PURE`

@__PURE__または#__PURE__を含むコメントは、特定の関数呼び出しまたはコンストラクター呼び出しを副作用がないものとしてマークします。つまり、戻り値がツリーシェイクされていないコードで使用されていない限り、Rollupはツリーシェイク（つまり、呼び出しを削除）します。これらのアノテーションは、効果を発揮するために、呼び出しの直前に置く必要があります。このオプションがfalseに設定されていない限り、次のコードは完全にツリーシェイクされます。その場合、コードは変更されません。

javascript

/*@__PURE__*/ console.log('side-effect');

class Impure {
	constructor() {
		console.log('side-effect');
	}
}

/*@__PURE__ There may be additional text in the comment */ new Impure();

このようなアノテーションは、関数呼び出しまたはコンストラクター呼び出しの直前にあり、呼び出し元から空白またはコメントによってのみ区切られている場合、有効とみなされます。唯一の例外は、呼び出しまたは呼び出しを囲む括弧です。

無効なアノテーションは削除され、Rollupは警告を出力します。有効なアノテーションは、関数呼び出しまたはコンストラクター呼び出しも削除されない限り、コードに残ります。

`@__NO_SIDE_EFFECTS__`

@__NO_SIDE_EFFECTS__または#__NO_SIDE_EFFECTS__を含むコメントは、関数宣言自体を副作用がないものとしてマークします。関数が副作用がないとマークされている場合、その関数へのすべての呼び出しは副作用がないとみなされます。このオプションがfalseに設定されていない限り、次のコードは完全にツリーシェイクされます。その場合、コードは変更されません。

javascript

/*@__NO_SIDE_EFFECTS__*/
function impure() {
	console.log('side-effect');
}

/*@__NO_SIDE_EFFECTS__*/
const impureArrowFn = () => {
	console.log('side-effect');
};

impure(); // <-- call will be considered as side effect free
impureArrowFn(); // <-- call will be considered as side effect free

このようなアノテーションは、関数宣言または最初の宣言された変数が関数である定数変数宣言の直前にあり、宣言から空白またはコメントによってのみ区切られている場合、有効とみなされます。

無効なアノテーションは削除され、Rollupは警告を出力します。有効なアノテーションは、宣言も削除されない限り、コードに残ります。

treeshake.correctVarValueBeforeDeclaration

Type	`boolean`
CLI	`--treeshake.correctVarValueBeforeDeclaration`/`--no-treeshake.correctVarValueBeforeDeclaration`
Default	`false`

いくつかのエッジケースでは、変数が宣言の代入の前にアクセスされ、再代入されない場合、Rollupはプログラム全体で変数が定数であると誤って仮定することがあります（以下の例を参照）。ただし、これらの変数は宣言の前にアクセスでき、undefinedと評価されるため、varで宣言された変数の場合、これは当てはまりません。trueを選択すると、Rollupがvarで宣言された変数の値について何も仮定しないようになります。ただし、これにより、ツリーシェイキングの結果に目に見える悪影響を与える可能性があることに注意してください。

// everything will be tree-shaken unless treeshake.correctVarValueBeforeDeclaration === true
let logBeforeDeclaration = false;

function logIfEnabled() {
	if (logBeforeDeclaration) {
		log();
	}

	var value = true;

	function log() {
		if (!value) {
			console.log('should be retained, value is undefined');
		}
	}
}

logIfEnabled(); // could be removed
logBeforeDeclaration = true;
logIfEnabled(); // needs to be retained as it displays a log

treeshake.manualPureFunctions

Type	`string[]`
CLI	`--treeshake.manualPureFunctions <names>`

常に「純粋」とみなされる関数名のリストを手動で定義できます。つまり、グローバル状態の変更など、呼び出されたときに副作用がありません。チェックは名前だけで実行されます。

これにより、デッドコードの削除に役立つだけでなく、特にoutput.experimentalMinChunkSizeを使用する場合、JavaScriptチャンクの生成が改善される可能性があります。

その名前に一致する関数以外にも、純粋関数上のプロパティと純粋関数から返される関数はすべて純粋関数とみなされ、プロパティへのアクセスは副作用の有無についてチェックされません。

// rollup.config.js
export default {
	treeshake: {
		preset: 'smallest',
		manualPureFunctions: ['styled', 'local']
	}
	// ...
};

// code
import styled from 'styled-components';
const local = console.log;

local(); // removed
styled.div`
	color: blue;
`; // removed
styled?.div(); // removed
styled()(); // removed
styled().div(); // removed

treeshake.moduleSideEffects

Type	`boolean\| "no-external"\| string[]\| (id: string, external: boolean) => boolean`
CLI	`--treeshake.moduleSideEffects`/`--no-treeshake.moduleSideEffects`/`--treeshake.moduleSideEffects no-external`
Default	`true`

falseの場合、何もインポートされていないモジュールと外部依存関係は、グローバル変数の変更やログ出力などの他の副作用を持たないと仮定し、チェックしません。外部依存関係については、空のインポートを抑制します。

javascript

// input file
import { unused } from 'external-a';
import 'external-b';
console.log(42);

javascript

// output with treeshake.moduleSideEffects === true
import 'external-a';
import 'external-b';
console.log(42);

javascript

// output with treeshake.moduleSideEffects === false
console.log(42);

外部モジュール以外の場合、falseでは、そのモジュールからの少なくとも1つのインポートが含まれていない限り、モジュールからステートメントは何も含まれません。

javascript

// input file a.js
import { unused } from './b.js';
console.log(42);

// input file b.js
console.log('side-effect');
const ignored = 'will still be removed';

javascript

// output with treeshake.moduleSideEffects === true
console.log('side-effect');

console.log(42);

javascript

// output with treeshake.moduleSideEffects === false
console.log(42);

副作用のあるモジュールのリスト、または各モジュールごとにそれを決定する関数を指定することもできます。値"no-external"は、可能な場合にのみ外部インポートを削除し、関数(id, external) => !externalと同等です。

このフラグがfalseに設定されているモジュールが別のモジュールから変数を再エクスポートし、その変数が使用されている場合、再エクスポートするモジュールが副作用についてスキャンされるかどうかは、変数の再エクスポート方法によって異なります。

javascript

// input file a.js
import { foo } from './b.js';
console.log(foo);

// input file b.js
// direct reexports will ignore side effects
export { foo } from './c.js';
console.log('this side-effect is ignored');

// input file c.js
// indirect reexports will include side effects
import { foo } from './d.js';
foo.mutated = true;
console.log('this side-effect and the mutation are retained');
export { foo };

// input file d.js
export const foo = 42;

javascript

// output with treeshake.moduleSideEffects === false
const foo = 42;

foo.mutated = true;
console.log('this side-effect and the mutation are retained');

console.log(foo);

名前にもかかわらず、このオプションは副作用のないモジュールに副作用を「追加」するものではないことに注意してください。例えば、依存関係の追跡のために空のモジュールをバンドルに「含める」ことが重要な場合、プラグインインターフェースを使用して、resolveId、load、またはtransformフックを介して、ツリーシェイキングから除外するモジュールを指定できます。

treeshake.preset

Type	`"smallest" \| "safest"\| "recommended"`
CLI	`--treeshake <value>`

上記にリストされているプリセットのいずれかを選択し、いくつかのオプションをオーバーライドできます。

export default {
	treeshake: {
		preset: 'smallest',
		propertyReadSideEffects: true
	}
	// ...
};

treeshake.propertyReadSideEffects

Type	`boolean\| 'always'`
CLI	`--treeshake.propertyReadSideEffects`/`--no-treeshake.propertyReadSideEffects`
Default	`true`

trueの場合、Rollupが副作用があると判断できる未使用のプロパティ読み取りを保持します。これには、nullまたはundefinedのプロパティへのアクセス、またはプロパティアクセスによる明示的なゲッターのトリガーが含まれます。これは、デストラクチャリング代入や、関数パラメーターとして渡されたオブジェクトのゲッターには適用されないことに注意してください。

falseの場合、オブジェクトのプロパティの読み取りには副作用がないと仮定します。コードによっては、このオプションを無効にするとバンドルサイズを大幅に削減できますが、ゲッターまたは不正なプロパティアクセスからのエラーに依存している場合は、機能が壊れる可能性があります。

'always'の場合、デストラクチャリングを含むすべてのメンバープロパティアクセスに副作用があると仮定します。この設定は、副作用のあるゲッターに依存するコードにお勧めです。通常、バンドルサイズは大きくなりますが、treeshakeを完全に無効にするよりも小さくなります。

javascript

// Will be removed if treeshake.propertyReadSideEffects === false
const foo = {
	get bar() {
		console.log('effect');
		return 'bar';
	}
};
const result = foo.bar;
const illegalAccess = foo.quux.tooDeep;

treeshake.tryCatchDeoptimization

Type	`boolean`
CLI	`--treeshake.tryCatchDeoptimization`/`--no-treeshake.tryCatchDeoptimization`
Default	`true`

デフォルトでは、Rollupはツリーシェイキング時にランタイムの多くの組み込みグローバルが最新の仕様に従って動作し、予期しないエラーをスローしないと仮定します。例えば、これらのエラーがスローされることに依存する機能検出ワークフローをサポートするために、Rollupはデフォルトでtryステートメント内のツリーシェイキングを無効にします。関数の引数がtryステートメント内で呼び出された場合、その引数も最適化されません。この機能が不要で、tryステートメント内でツリーシェイキングを行いたい場合は、treeshake.tryCatchDeoptimizationをfalseに設定します。

function otherFn() {
	// even though this function is called from a try-statement, the next line
	// will be removed as side-effect-free
	Object.create(null);
}

function test(callback) {
	try {
		// calls to otherwise side-effect-free global functions are
		// retained inside try-statements for tryCatchDeoptimization: true
		Object.create(null);

		// calls to other function are retained as well but the body of
		// this function may again be subject to tree-shaking
		otherFn();

		// if a parameter is called, then all arguments passed to that
		// function parameter will be deoptimized
		callback();
	} catch {}
}

test(() => {
	// will be ratained
	Object.create(null);
});

// call will be retained but again, otherFn is not deoptimized
test(otherFn);

treeshake.unknownGlobalSideEffects

Type	`boolean`
CLI	`--treeshake.unknownGlobalSideEffects`/`--no-treeshake.unknownGlobalSideEffects`
Default	`true`

存在しないグローバル変数へのアクセスはエラーをスローするため、Rollupはデフォルトで、組み込み以外のグローバル変数へのアクセスをすべて保持します。このチェックを回避するには、このオプションをfalseに設定します。これは、ほとんどのコードベースでは安全です。

// input
const jQuery = $;
const requestTimeout = setTimeout;
const element = angular.element;

// output with unknownGlobalSideEffects == true
const jQuery = $;
const element = angular.element;

// output with unknownGlobalSideEffects == false
const element = angular.element;

例では、最後の行は常に保持されます。なぜなら、elementプロパティへのアクセスは、angularがnullの場合にもエラーをスローする可能性があるためです。このチェックを回避するには、treeshake.propertyReadSideEffectsもfalseに設定します。

実験的なオプション

これらのオプションは、まだ完全に最終決定されていない新機能を反映しています。そのため、マイナーバージョン間で可用性、動作、使用方法が変更される可能性があります。

experimentalCacheExpiry

Type	`number`
CLI	`--experimentalCacheExpiry <numberOfRuns>`
Default	`10`

プラグインによって使用されなくなったキャッシュされたアセットを削除する実行回数を決定します。

experimentalLogSideEffects

Type	`boolean`
CLI	`--experimentalLogSideEffects`/`--no-experimentalLogSideEffects`
Default	`false`

trueに設定すると、各ファイルで見つかった最初の副作用をコンソールにログ出力します。これは、どのファイルに副作用があり、実際の副作用が何かを把握するのに非常に役立ちます。副作用を削除すると、ツリーシェイキングとチャンク生成を改善でき、output.experimentalMinChunkSizeの動作には不可欠です。

ただし、このオプションは最上位レベルのステートメントのみをログ出力します。場合によっては、例えばすぐに実行される関数式の場合、実際の副作用がネストされた式の中に隠れている可能性があります。

output.experimentalMinChunkSize

Type	`number`
CLI	`--experimentalMinChunkSize <size>`
Default	`1`

コード分割設定の最小チャンクサイズターゲットをバイト単位で設定します。この値がデフォルトの1に設定されている場合、Rollupは、インポートと再エクスポート以外のコードを含まないチャンクを他のチャンクにマージしようとします。マージは、エントリがロードされたときに実行される副作用が変更されない場合にのみ実行されます。1の値の場合、コードのロード量をエントリごとに増やさないマージのみが許可されます。

より大きな値は、制限以下のチャンクを他のチャンクにマージしようとします。その場合、エントリが不要なコードをロードする可能性があることが許容されます。ただし、アルゴリズムは常に不要なコードの量を最小限に抑えるようにマージしようとします。

残念ながら、チャンクの動作方法のため、チャンクサイズは、ミニファイアなどのチャンクレンダリングプラグインが実行される前に測定されます。つまり、これを考慮に入れるために十分な高い制限を使用する必要があります。サイズを計算する際には、最上位レベルのステートメントのツリーシェイキングも考慮されます。

perf

Type	`boolean`
CLI	`--perf`/`--no-perf`
Default	`false`

パフォーマンスタイミングを収集するかどうか。コマンドラインまたは設定ファイルから使用する場合、現在のバンドル処理に関する詳細な測定値が表示されます。JavaScript APIから使用する場合、返されるバンドルオブジェクトには、蓄積されたすべての測定値を取得するためにいつでも呼び出すことができる追加のgetTimings()関数が含まれます。

getTimings()は次の形式のオブジェクトを返します。

{
  "# BUILD": [ 698.020877, 33979632, 45328080 ],
  "## parse modules": [ 537.509342, 16295024, 27660296 ],
  "load modules": [ 33.253778999999994, 2277104, 38204152 ],
  ...
}

各キーについて、最初の数値は経過時間を表し、2番目の数値はメモリ消費量の変更を表し、3番目の数値はこのステップ後の合計メモリ消費量を表します。これらのステップの順序は、Object.keysで使用される順序です。最上位レベルのキーは#で始まり、ネストされたステップのタイミングを含みます。つまり、上記の例では、# BUILDステップの698msには、## parse modulesステップの538msが含まれています。

watch

Type	`WatcherOptions \| false`
Default	`{}`

typescript

interface WatcherOptions {
	buildDelay?: number;
	chokidar?: ChokidarOptions;
	clearScreen?: boolean;
	exclude?: string | RegExp | (string | RegExp)[];
	include?: string | RegExp | (string | RegExp)[];
	skipWrite?: boolean;
}

ウォッチモードのオプションを指定するか、この設定がウォッチされないようにします。falseを指定するのは、設定の配列を使用する場合にのみ本当に役立ちます。その場合、この設定はウォッチモードではビルドまたは再ビルドされませんが、Rollupを定期的に実行するとビルドされます。

// rollup.config.js
export default [
	{
		input: 'main.js',
		output: { file: 'bundle.cjs.js', format: 'cjs' }
	},
	{
		input: 'main.js',
		watch: false,
		output: { file: 'bundle.es.js', format: 'es' }
	}
];

これらのオプションは、--watchフラグを使用してRollupを実行するか、rollup.watchを使用する場合にのみ有効になります。

watch.buildDelay

Type	`number`
CLI	`--watch.buildDelay <number>`
Default	`0`

ミリ秒単位で、Rollupが再ビルドをトリガーするまでさらに変更を待つ時間を設定します。デフォルトでは、Rollupは待ちません。ただし、chokidarインスタンスに設定されている小さなデバウンスタイムアウトがあります。これを0より大きい値に設定すると、設定されたミリ秒数の間変更がなかった場合にのみ、Rollupは再ビルドをトリガーします。複数の設定が監視されている場合、Rollupは設定された最大のビルド遅延を使用します。

watch.chokidar

Type	`ChokidarOptions`

バンドルされたchokidarインスタンスに渡される、オプションのウォッチオプションオブジェクトです。chokidarのドキュメントを参照して、使用可能なオプションを確認してください。

watch.clearScreen

Type	`boolean`
CLI	`--watch.clearScreen`/`--no-watch.clearScreen`
Default	`true`

再ビルドがトリガーされたときに画面をクリアするかどうか。

watch.exclude

Type	`string \| RegExp\| (string\| RegExp)[]`
CLI	`--watch.exclude <files>`

ファイルの監視を停止します。

// rollup.config.js
export default {
  ...,
  watch: {
    exclude: 'node_modules/**'
  }
};

watch.include

Type	`string \| RegExp\| (string\| RegExp)[]`
CLI	`--watch.include <files>`

ファイル監視を特定のファイルに制限します。これはモジュールグラフのみをフィルタリングし、追加の監視ファイルを追加することはできないことに注意してください。

// rollup.config.js
export default {
  ...,
  watch: {
    include: 'src/**'
  }
};

watch.skipWrite

Type	`boolean`
CLI	`--watch.skipWrite`/`--no-watch.skipWrite`
Default	`false`

再ビルドがトリガーされたときにbundle.write()ステップをスキップするかどうか。

非推奨のオプション

☢️ これらのオプションは非推奨となり、今後のRollupバージョンで削除される可能性があります。

output.externalImportAssertions

output.externalImportAttributesオプションを使用してください。

Type	`boolean`
CLI	`--externalImportAssertions`/`--no-externalImportAssertions`
Default	`true`

出力形式がesの場合、出力の外部インポートにインポートアサーションを追加するかどうか。デフォルトでは、アサーションは入力ファイルから取得されますが、プラグインは後でアサーションを追加または削除できます。例えば、import "foo" assert {type: "json"}は、オプションがfalseに設定されていない限り、出力に同じインポートが表示されます。モジュールのすべてのインポートは一貫したアサーションを持つ必要があることに注意してください。そうでない場合は警告が表示されます。

Configuration Options

Core functionality ​

external ​

input ​

output.dir ​

output.file ​

output.format ​

output.globals ​

output.name ​

output.plugins ​

plugins ​

高度な機能 ​

cache ​

logLevel ​

makeAbsoluteExternalsRelative ​

maxParallelFileOps ​

onLog ​

onwarn ​

output.assetFileNames ​

output.banner/output.footer ​

output.chunkFileNames ​

output.compact ​

output.dynamicImportInCjs ​

output.entryFileNames ​

output.extend ​

output.externalImportAttributes ​

output.generatedCode ​

output.generatedCode.arrowFunctions ​

output.generatedCode.constBindings ​

output.generatedCode.objectShorthand ​

output.generatedCode.preset ​

output.generatedCode.reservedNamesAsProps ​

output.generatedCode.symbols ​

output.hashCharacters ​

output.hoistTransitiveImports ​

output.inlineDynamicImports ​

output.interop ​

output.intro/output.outro ​

output.manualChunks ​

output.minifyInternalExports ​

output.paths ​

output.preserveModules ​

output.preserveModulesRoot ​

output.sourcemap ​

output.sourcemapBaseUrl ​

output.sourcemapExcludeSources ​

output.sourcemapFile ​

output.sourcemapFileNames ​

output.sourcemapIgnoreList ​

output.sourcemapPathTransform ​

output.validate ​

preserveEntrySignatures ​

strictDeprecations ​

危険ゾーン ​

context ​

moduleContext ​

output.amd ​

output.amd.id ​

output.amd.autoId ​

output.amd.basePath ​

output.amd.define ​

output.amd.forceJsExtensionForImports ​

output.esModule ​

output.exports ​

output.externalLiveBindings ​

output.freeze ​

output.indent ​

output.noConflict ​

output.reexportProtoFromExternal ​

output.sanitizeFileName ​

output.strict ​

output.systemNullSetters ​

preserveSymlinks ​

shimMissingExports ​

treeshake ​

treeshake.annotations ​

@__PURE__ ​

@__NO_SIDE_EFFECTS__ ​

treeshake.correctVarValueBeforeDeclaration ​

treeshake.manualPureFunctions ​

Core functionality

external

input

output.dir

output.file

output.format

output.globals

output.name

output.plugins

plugins

高度な機能

cache

logLevel

makeAbsoluteExternalsRelative

maxParallelFileOps

onLog

onwarn

output.assetFileNames

output.banner/output.footer

output.chunkFileNames

output.compact

output.dynamicImportInCjs

output.entryFileNames

output.extend

output.externalImportAttributes

output.generatedCode

output.generatedCode.arrowFunctions

output.generatedCode.constBindings

output.generatedCode.objectShorthand

output.generatedCode.preset

output.generatedCode.reservedNamesAsProps

output.generatedCode.symbols

output.hashCharacters

output.hoistTransitiveImports

output.inlineDynamicImports

output.interop

output.intro/output.outro

output.manualChunks

output.minifyInternalExports

output.paths

output.preserveModules

output.preserveModulesRoot

output.sourcemap

output.sourcemapBaseUrl

output.sourcemapExcludeSources

output.sourcemapFile

output.sourcemapFileNames

output.sourcemapIgnoreList

output.sourcemapPathTransform

output.validate

preserveEntrySignatures

strictDeprecations

危険ゾーン

context

moduleContext

output.amd

output.amd.id

output.amd.autoId

output.amd.basePath

output.amd.define

output.amd.forceJsExtensionForImports

output.esModule

output.exports

output.externalLiveBindings

output.freeze

output.indent

output.noConflict

output.reexportProtoFromExternal

output.sanitizeFileName

output.strict

output.systemNullSetters

preserveSymlinks

shimMissingExports

treeshake

treeshake.annotations

`@PURE`

`@__NO_SIDE_EFFECTS__`

treeshake.correctVarValueBeforeDeclaration

treeshake.manualPureFunctions

treeshake.moduleSideEffects