// 入口main。js
import { b } from './test/a'
console.log(b + 1)
console.log(1111)

// './test/a'
export const b = 'xx'
export const bbbbbbb = 'xx'

const b = 'xx';
console.log(b + 1);
console.log(1111);

/******/ (function(modules) { // webpackBootstrap
/******/   // The module cache
/******/   var installedModules = {};
/******/
/******/   // The require function
/******/   function __webpack_require__(moduleId) {
/******/
/******/    // Check if module is in cache
/******/    if(installedModules[moduleId]) {
/******/     return installedModules[moduleId].exports;
/******/    }
/******/    // Create a new module (and put it into the cache)
/******/    var module = installedModules[moduleId] = {
/******/     i: moduleId,
/******/     l: false,
/******/     exports: {}
/******/    };
/******/
/******/    // Execute the module function
/******/    modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
/******/
/******/    // Flag the module as loaded
/******/    module.l = true;
/******/
/******/    // Return the exports of the module
/******/    return module.exports;
/******/   }
/******/
/******/
/******/   // expose the modules object (__webpack_modules__)
/******/   __webpack_require__.m = modules;
/******/
/******/   // expose the module cache
/******/   __webpack_require__.c = installedModules;
/******/
/******/   // define getter function for harmony exports
/******/   __webpack_require__.d = function(exports, name, getter) {
/******/    if(!__webpack_require__.o(exports, name)) {
/******/     Object.defineProperty(exports, name, { enumerable: true, get: getter });
/******/    }
/******/   };
/******/
/******/   // define __esModule on exports
/******/   __webpack_require__.r = function(exports) {
/******/    if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
/******/     Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
/******/    }
/******/    Object.defineProperty(exports, '__esModule', { value: true });
/******/   };
/******/
/******/   // create a fake namespace object
/******/   // mode & 1: value is a module id, require it
/******/   // mode & 2: merge all properties of value into the ns
/******/   // mode & 4: return value when already ns object
/******/   // mode & 8|1: behave like require
/******/   __webpack_require__.t = function(value, mode) {
/******/    if(mode & 1) value = __webpack_require__(value);
/******/    if(mode & 8) return value;
/******/    if((mode & 4) && typeof value === 'object' && value && value.__esModule) return value;
/******/    var ns = Object.create(null);
/******/    __webpack_require__.r(ns);
/******/    Object.defineProperty(ns, 'default', { enumerable: true, value: value });
/******/    if(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key));
/******/    return ns;
/******/   };
/******/
/******/   // getDefaultExport function for compatibility with non-harmony modules
/******/   __webpack_require__.n = function(module) {
/******/    var getter = module && module.__esModule ?
/******/     function getDefault() { return module['default']; } :
/******/     function getModuleExports() { return module; };
/******/    __webpack_require__.d(getter, 'a', getter);
/******/    return getter;
/******/   };
/******/
/******/   // Object.prototype.hasOwnProperty.call
/******/   __webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };
/******/
/******/   // __webpack_public_path__
/******/   __webpack_require__.p = "./";
/******/
/******/
/******/   // Load entry module and return exports
/******/   return __webpack_require__(__webpack_require__.s = 0);
/******/ })
/************************************************************************/
/******/ ([
/* 0 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {

"use strict";
// ESM COMPAT FLAG
__webpack_require__.r(__webpack_exports__);

// CONCATENATED MODULE: ./src/test/a.js
const b = 'xx';
const bbbbbbb = 'xx';

// CONCATENATED MODULE: ./src/main.js
console.log(b + 1);
console.log(1111); 

/***/ })
/******/ ]);

npm i -D rollup-plugin-typescript2

import { RollupOptions } from 'rollup';

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

const options: RollupOptions[] = [
  {
    input: 'src/index.ts',
    output: [
      {
        file: 'dist/index.js',
        format: 'cjs',
      },
      {
        file: 'dist/index.esm.js',
        format: 'esm',
      },
    ],
  },
];

export default options;

rollup --config rollup.config.ts --configPlugin typescript2

// rollup.config.js

// can be an array (for multiple inputs)
export default {
  // core input options
  external,
  input, // conditionally required
  plugins,

  // advanced input options
  cache,
  onwarn,
  preserveEntrySignatures,
  strictDeprecations,

  // danger zone
  acorn,
  acornInjectPlugins,
  context,
  moduleContext,
  preserveSymlinks,
  shimMissingExports,
  treeshake,

  // experimental
  experimentalCacheExpiry,
  perf,

  // required (can be an array, for multiple outputs)
  output: {
    // core output options
    dir,
    file,
    format, // required
    globals,
    name,
    plugins,

    // advanced output options
    assetFileNames,
    banner,
    chunkFileNames,
    compact,
    entryFileNames,
    extend,
    footer,
    hoistTransitiveImports,
    inlineDynamicImports,
    interop,
    intro,
    manualChunks,
    minifyInternalExports,
    outro,
    paths,
    preserveModules,
    preserveModulesRoot,
    sourcemap,
    sourcemapExcludeSources,
    sourcemapFile,
    sourcemapPathTransform,
    validate,

    // danger zone
    amd,
    esModule,
    exports,
    externalLiveBindings,
    freeze,
    indent,
    namespaceToStringTag,
    noConflict,
    preferConst,
    sanitizeFileName,
    strict,
    systemNullSetters
  },

  watch: {
    buildDelay,
    chokidar,
    clearScreen,
    skipWrite,
    exclude,
    include
  }
};

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

// rollup.config.js (building more than one bundle)

export default [
  {
    input: 'main-a.js',
    output: {
      file: 'dist/bundle-a.js',
      format: 'cjs'
    }
  },
  {
    input: 'main-b.js',
    output: [
      {
        file: 'dist/bundle-b1.js',
        format: 'cjs'
      },
      {
        file: 'dist/bundle-b2.js',
        format: 'es'
      }
    ]
  }
];

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

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

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

// 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');

// 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');

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

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

import jq from 'jquery'; 

// rollup.config.js
export default {
  ...,
  external: ['jquery'],
  output: {
    format: 'iife',
    name: 'MyBundle',
    globals: {
      jquery: '$' // jquery 是 moduleId，$ 是 全局变量名variableName
    }
  }
};

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

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

import { Link } from "react-router-dom";

// rollup.config.js
globals: {
    'react-router-dom': 'ReactRouterDOM'
}

// 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://d3js.org/d3.v4.min'
    }
  }
};

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

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

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

// rollup.config.js
import path from 'path';

export default {
  ...,
  external: [
    'some-externally-required-library',
    path.resolve( './src/some-local-file-that-should-not-be-bundled.js' )
  ]
};

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

{
  	input: 'src/index.ts',
    output: [
      {
        file: pkg.module,
        format: 'umd',
        name: "xxx",
        globals:{
          react: "React",
          "react-dom": "ReactDOM",
          jquery: "$",
        }
      },
    ],
  	external:['react', 'react-dom', 'jquery']
}

import pkg from './package.json';

export default {
    external: Object.keys(pkg.peerDependencies || {})
}

// 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')).terser()],
  output: {
    file: 'bundle.js',
    format: 'cjs'
  }
}))();

// rollup.config.js
export default {
  ...,
  onwarn (warning, warn) {
    // skip certain warnings
    if (warning.code === 'UNUSED_EXTERNAL_IMPORT') return;

    // throw on others
    if (warning.code === 'NON_EXISTENT_EXPORT') throw new Error(warning.message);

    // Use default for everything else
    warn(warning);
  }
};

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

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

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

-c, --config <filename>     Use this config file (if argument is used but value
                              is unspecified, defaults to rollup.config.js)
--configPlugin              Allows specifying Rollup plugins to transpile or otherwise control the parsing                               of your configuration file.           
-d, --dir <dirname>         Directory for chunks (if absent, prints to stdout)
-e, --external <ids>        Comma-separate list of module IDs to exclude
-f, --format <format>       Type of output (amd, cjs, es, iife, umd, system)
-g, --globals <pairs>       Comma-separate list of `moduleID:Global` pairs
-h, --help                  Show this help message
-i, --input <filename>      Input (alternative to <entry file>)
-m, --sourcemap             Generate sourcemap (`-m inline` for inline map)
-n, --name <name>           Name for UMD export
-o, --file <output>         Single output file (if absent, prints to stdout)
-p, --plugin <plugin>       Use the plugin specified (may be repeated)
-v, --version               Show version number
-w, --watch                 Watch files in bundle and rebuild on changes
--amd.id <id>               ID for AMD module (default is anonymous)
--amd.autoId                Generate the AMD ID based off the chunk name
--amd.basePath <prefix>     Path to prepend to auto generated AMD ID
--amd.define <name>         Function to use in place of `define`
--assetFileNames <pattern>  Name pattern for emitted assets
--banner <text>             Code to insert at top of bundle (outside wrapper)
--chunkFileNames <pattern>  Name pattern for emitted secondary chunks
--compact                   Minify wrapper code
--context <variable>        Specify top-level `this` value
--entryFileNames <pattern>  Name pattern for emitted entry chunks
--environment <values>      Settings passed to config file (see example)
--no-esModule               Do not add __esModule property
--exports <mode>            Specify export mode (auto, default, named, none)
--extend                    Extend global variable defined by --name
--no-externalLiveBindings   Do not generate code to support live bindings
--failAfterWarnings         Exit with an error if the build produced warnings
--footer <text>             Code to insert at end of bundle (outside wrapper)
--no-freeze                 Do not freeze namespace objects
--no-hoistTransitiveImports Do not hoist transitive imports into entry chunks
--no-indent                 Don't indent result
--no-interop                Do not include interop block
--inlineDynamicImports      Create single bundle when using dynamic imports
--intro <text>              Code to insert at top of bundle (inside wrapper)
--minifyInternalExports     Force or disable minification of internal exports
--namespaceToStringTag      Create proper `.toString` methods for namespaces
--noConflict                Generate a noConflict method for UMD globals
--outro <text>              Code to insert at end of bundle (inside wrapper)
--preferConst               Use `const` instead of `var` for exports
--no-preserveEntrySignatures Avoid facade chunks for entry points
--preserveModules           Preserve module structure
--preserveModulesRoot       Put preserved modules under this path at root level
--preserveSymlinks          Do not follow symlinks when resolving files
--no-sanitizeFileName       Do not replace invalid characters in file names
--shimMissingExports        Create shim variables for missing exports
--silent                    Don't print warnings
--sourcemapExcludeSources   Do not include source code in source maps
--sourcemapFile <file>      Specify bundle position for source maps
--stdin=ext                 Specify file extension used for stdin input
--no-stdin                  Do not read "-" from stdin
--no-strict                 Don't emit `"use strict";` in the generated modules
--strictDeprecations        Throw errors for deprecated features
--systemNullSetters         Replace empty SystemJS setters with `null`
--no-treeshake              Disable tree-shaking optimisations
--no-treeshake.annotations  Ignore pure call annotations
--no-treeshake.moduleSideEffects Assume modules have no side-effects
--no-treeshake.propertyReadSideEffects Ignore property access side-effects
--no-treeshake.tryCatchDeoptimization Do not turn off try-catch-tree-shaking
--no-treeshake.unknownGlobalSideEffects Assume unknown globals do not throw
--waitForBundleInput        Wait for bundle input files
--watch.buildDelay <number> Throttle watch rebuilds
--no-watch.clearScreen      Do not clear the screen when rebuilding
--watch.skipWrite           Do not write files to disk when watching
--watch.exclude <files>     Exclude files from being watched
--watch.include <files>     Limit watching to specified files
--validate                  Validate output

rollup --config rollup.config.dev.js
rollup --config rollup.config.prod.js

npm i -D rollup rollup-plugin-typescript2 @rollup/plugin-babel @rollup/plugin-node-resolve @rollup/plugin-commonjs rollup-plugin-terser rollup-plugin-clear rollup-plugin-progress rollup-plugin-visualizer rollup-plugin-copy cross-env

import { RollupOptions } from 'rollup';
import typescript from 'rollup-plugin-typescript2';
import babel from '@rollup/plugin-babel';
import resolve from '@rollup/plugin-node-resolve';
import commonjs from '@rollup/plugin-commonjs';
import { terser } from 'rollup-plugin-terser';
import clear from 'rollup-plugin-clear';
import progress from 'rollup-plugin-progress';
import { visualizer } from 'rollup-plugin-visualizer';
import copy from 'rollup-plugin-copy';
import json from '@rollup/plugin-json';
import { DEFAULT_EXTENSIONS } from '@babel/core';
import pkg from './package.json';

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

const options: RollupOptions[] = [
  {
    input: 'src/index.ts',
    output: [
      {
        file: pkg.main,
        format: 'cjs',
        exports: 'auto',
        plugins: [
          // put it the last one
          isProd &&
            visualizer({
              filename: './out/report-cjs.html',
              open: true,
              gzipSize: true,
            }),
        ],
      },
      {
        file: pkg.module,
        format: 'es',
        plugins: [
          // put it the last one
          isProd &&
            visualizer({
              filename: './out/report-esm.html',
              open: true,
              gzipSize: true,
            }),
        ],
      },
    ],
    plugins: [
      clear({
        // required, point out which directories should be clear.
        targets: ['dist', 'out'], // 清空 out，否则visualizer会打开之前已存在的html
        // optional, whether clear the directores when rollup recompile on --watch mode.
        watch: true, // default: false
      }),
      progress({
        clearLine: true, // default: true
      }),
      copy({
        targets: [],
      }),
      json(),
      resolve({
        // default:true，需要显式设置来避免warning
        // true: 同名模块优先选择内置模块，例如（fs、path）
        // false: 同名模块优先选择安装的模块
        preferBuiltins: true,
      }),
      commonjs(),
      typescript(),
      babel({
        include: 'src/**/*',
        exclude: '**/node_modules/**',
        babelHelpers: 'runtime', // 构建库时使用
        extensions: [...DEFAULT_EXTENSIONS, '.ts', '.tsx'],
      }),
      isProd &&
        terser({
          compress: {
            // https://github.com/terser/terser
            // 默认会去掉debugger
            // drop_console: true, // 去掉console
            // pure_funcs:['console.log'] // 如果只想去除console.log，而不想去除console.info
          },
        }),
    ],
    // 注意 outpput.globals 也要添加对应的值
    external: [
      // @ts-ignore
      ...Object.keys(pkg.dependencies || {}),
      // @ts-ignore
      ...Object.keys(pkg.peerDependencies || {}),
      /@babel\/runtime/,
    ], //  babelHelpers:'runtime' 使用
  },
];

export default options;

npm install -D rollup cross-env

npm install -D  typescript tslib @types/node ts-node rollup-plugin-typescript2 nodemon

{
  "compilerOptions": {
    "module": "esnext",
    "target": "es5",
    "allowSyntheticDefaultImports": true /* 用来指定允许从没有默认导出的模块中默认导入 */,
    "jsx": "react",
    "lib": ["dom", "dom.iterable", "esnext"] /* 编译过程中需要引入的库文件的列表 */,
    "strict": true,
    "moduleResolution": "node",
    "experimentalDecorators": true /* 用于指定是否启用实验性的装饰器特性 */,
    "downlevelIteration": true /* 当target为'ES5' or 'ES3'时，为'for-of', spread, and destructuring'中的迭代器提供完全支持 */,
    "allowJs": true,
    "esModuleInterop": true /* 通过为导入内容创建命名空间，实现CommonJS和ES模块之间的互操作性，esModuleInterop选项的作用是支持使用import d from 'cjs'的方式引入commonjs包 */,
    "resolveJsonModule": true,
    "forceConsistentCasingInFileNames": true /*     禁止对同一个文件的不一致的引用。 */,
    "noEmit": true /* 不生成编译文件 */,
    "noFallthroughCasesInSwitch": true /* 用于检查switch中是否有case没有使用break跳出switch，默认为false */,
    "noImplicitAny": false /* noImplicitAny的值为false时，如果我们没有为一些值设置明确的类型，编译器会默认认为这个值为any，如果noImplicitAny的值为true的话。则没有明确的类型会报错。默认值为false */,
    "baseUrl": ".",
    "paths": {
      "@/*": ["./src/*"]
    },
    // 生成.d.ts文件
    "declaration": true,
    "declarationDir": "./types"
  },
  "include": ["src"],
  "exclude": ["**/node_modules/**", "build", "dist", "out"]
}

import { RollupOptions } from 'rollup'
import typescript from 'rollup-plugin-typescript2'

const options: RollupOptions = {
  input: 'src/index.ts',
  output: [
    {
      file: 'dist/index.js',
      format: 'cjs',
    },
    {
      file: 'dist/index.esm.js',
      format: 'esm',
    },
  ],
  plugins: [
    typescript({
      // 默认为false，输出声明文件的路径为output.file或output.dir的路径
      // useTsconfigDeclarationDir: true, // 使用tsconfig.json的declarationDir，同时declaration要为true。
    })
  ],
}

export default options

{
  "main": "dist/index.js",
  "module": "dist/index.esm.js",
  "typings": "dist/index.d.ts",
  "scripts": {
    "start": "cross-env NODE_ENV=development rollup --config rollup.config.ts --configPlugin typescript"
  }
}

npm i -D @rollup/plugin-node-resolve @rollup/plugin-commonjs

npm i -D @babel/core @babel/preset-env @babel/preset-typescript @babel/preset-react @babel/plugin-transform-runtime @babel/plugin-proposal-decorators @babel/plugin-proposal-class-properties @rollup/plugin-babel
npm i @babel/runtime-corejs3 

import resolve from '@rollup/plugin-node-resolve'
import commonjs from '@rollup/plugin-commonjs'
import babel from 'rollup-plugin-babel'
import { DEFAULT_EXTENSIONS } from '@babel/core'; // .js,.jsx,.es6,.es,.mjs

export default {
  input: 'src/main.js',
  output: {
    file: 'bundle.js',
    format: 'cjs'
  },
  external: [/@babel\/runtime/], //  babelHelpers:'runtime' 使用
  plugins: [
    resolve(),
    commonjs(),
    babel({
      include: 'src/**/*',
      exclude: '**/node_modules/**', 
      babelHelpers:'runtime', // 构建库时使用
      extensions: [...DEFAULT_EXTENSIONS, 'ts'],
    })
  ]
};

module.exports = {
  // @babel/env === @babel/preset-env  @babel/react === @babel/preset-react ...
  // 当在presets中使用@babel/env，babel会自动加上preset-
  presets: [
    [
      "@babel/preset-env",
      {
        // esm转换成其他模块语法，cjs、amd、umd等
        // Tree Shaking需要设置为false
        modules: false,
        targets: { browsers: ["> 1%", "last 2 versions", "not ie <= 8"] },
      }
    ],
    "@babel/preset-react",
    "@babel/preset-typescript",
  ],
  plugins: [
    ["@babel/plugin-transform-runtime", {
      corejs: {
        version: 3, // 需安装 @babel/runtime-corejs3
        proposals: true
      }
    }],
    ["@babel/plugin-proposal-decorators", { legacy: true }], // 需要放在@babel/plugin-proposal-class-propertie之前
    ["@babel/plugin-proposal-class-properties", { loose: true }], // 用于解析class语法(react必选)
    // @babel/plugin-proposal-private-methods 和 @babel/plugin-proposal-private-property-in-object内置于preset-env,且他们的loose值必须与@babel/plugin-proposal-class-properties的一致
    ['@babel/plugin-proposal-private-methods', { 'loose': true }],
    ['@babel/plugin-proposal-private-property-in-object', { loose: true }],
  ]
}

npm i -D 

// rollup.config.js
import babel from 'rollup-plugin-babel'


export default {
  input: 'src/main.js',
  output: {
    file: 'bundle.js',
    format: 'cjs'
  },
  external: [/@babel\/runtime/], //  babelHelpers:'runtime' 使用
  plugins: [
    babel({
      include: 'src/**/*',
      exclude: '**/node_modules/**', 
      babelHelpers:'runtime', // 构建库时使用
      extensions: [...DEFAULT_EXTENSIONS, 'ts','tsx'],
    })
  ]
};

module.exports = {
    presets: [
    '@babel/preset-typescript',
    ],
}

npm i -D rollup-plugin-terser

import {terser} from 'rollup-plugin-terser';

const isProd = process.env.NODE_ENV === 'production'

export default {
  input: 'src/main.js',
  output: {
    file: 'bundle.js',
    format: 'cjs'
  },
  plugins: [
    isProd &&
        terser({
          compress: {
            // https://github.com/terser/terser
            // 默认会去掉debugger
            // drop_console: true, // 去掉console
            pure_funcs:['console.log'] // 如果只想去除console.log，而不想去除console.info
          },
        }),
  ]
};

npm i -D rollup-plugin-dev

import dev from 'rollup-plugin-dev'

const isProd = process.env.NODE_ENV === 'production'

export default {
  input: 'src/main.js',
  output: {
    file: 'bundle.js',
    format: 'cjs'
  },
  plugins: [
   !isProd && dev({
           dirs: ['dist'],
      port: 8888,
   })
  ]
};

npm i -D rollup-plugin-livereload

import dev from 'rollup-plugin-dev'
import livereload from 'rollup-plugin-livereload'

const isProd = process.env.NODE_ENV === 'production'

export default {
    plugins:[
    !isProd && dev('dist'),
    !isProd && livereload('dist')

    // --- OR ---

    livereload({
      watch: 'dist',
      verbose: false, // Disable console output

      // other livereload options
      port: 12345,
      delay: 300,
      https: {
          key: fs.readFileSync('keys/agent2-key.pem'),
          cert: fs.readFileSync('keys/agent2-cert.pem')
      }
    })
  ]
}

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

const srcPath = path.resolve(__dirname,'src');

const options = [
  {
    input: 'src/index.ts',
    output: [
      {
        file: 'dist/index.js',
        format: 'cjs',
      }
    ],
    plugins: [
         alias({
             entries:{
                 '@': srcPath,
             }
         })
    ],
  },
];

export default options;

npm i -D rollup-plugin-clear rollup-plugin-progress rollup-plugin-visualizer

import { RollupOptions } from 'rollup';
import typescript from 'rollup-plugin-typescript2';
import babel from '@rollup/plugin-babel';
import resolve from '@rollup/plugin-node-resolve';
import commonjs from '@rollup/plugin-commonjs';
import { terser } from 'rollup-plugin-terser';
import clear from 'rollup-plugin-clear';
import progress from 'rollup-plugin-progress';
import { visualizer } from 'rollup-plugin-visualizer';

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

const options: RollupOptions[] = [
  {
    input: 'src/index.ts',
    output: [
      {
        file: 'dist/index.js',
        format: 'cjs',
      }
    ],
    plugins: [
      clear({
        // required, point out which directories should be clear.
        targets: ['some directory'],
        // optional, whether clear the directores when rollup recompile on --watch mode.
        watch: true, // default: false
      }),
      progress({
        clearLine: false // default: true
      }),
      // put it the last one
      isProd &&
        visualizer({
          filename: './out/report.html',
          open: true,
          gzipSize: true,
        }),
    ],
    external: [/@babel\/runtime/], //  babelHelpers:'runtime' 使用
  },
];

export default options;

import postcss from 'rollup-plugin-postcss'
export default {
  input: ...,
  output: ...,
  plugins:[
    postcss()
  ]
}

import postcss from 'rollup-plugin-postcss'
import autoprefixer from 'autoprefixer'
export default {
  input: ...,
  output: ...,
  plugins:[
    postcss({
      plugins: [  
        autoprefixer()  
      ]
    })
  ]
}

"browserslist": [
  "defaults",
  "not ie < 8",
  "last 2 versions",
  "> 1%",
  "iOS 7",
  "last 3 iOS versions"
]

plugins:[
  postcss({
    plugins: [
      autoprefixer(),
      cssnano()
    ]
  })
]

postcss({
  plugins: [
    autoprefixer(),
    cssnano()
  ],
  extract: 'css/index.css'  
})

@import "~bootstrap/dist/css/bootstrap";