TypeScript rollup-plugin-babel.default函数代码示例

export default {
  input: 'src/index.ts',
  external: [
    ...Object.keys(pkg.peerDependencies || {}),
    ...Object.keys(pkg.dependencies || {}),
    ...(pkg.bin ? ['path', 'util', 'child_process', 'fs'] : [])
  ],
  output: [
    pkg.main && { file: pkg.main, format: 'cjs' },
    pkg.module && { file: pkg.module, format: 'es' },
    pkg.unpkg && { name: pkg.name, file: pkg.unpkg, format: 'umd' }
  ].filter(Boolean),
  plugins: [
    babel({
      configFile: path.join(__dirname, 'babel.config.js'),
      extensions: ['.ts', '.tsx', '.js']
    }),
    resolve({
      extensions: ['.ts', '.tsx', '.js']
    }),
    commonjs({
      namedExports: {
        '@storybook/addon-actions': [
          'action',
          'ADDON_ID',
          'PANEL_ID',
          'EVENT_ID'
        ],
        '@storybook/addons': ['makeDecorator'],
        react: [
          'createContext',

 private static compileGlobals(cachePath: string, tree: PageTree) {
   const pageCachePath = join(cachePath, tree.context.$PAGE.$name);
   return rollup.rollup({
     entry: tree.scripts.globals.map(x => x.path),
     context: "window",
     plugins: [
       includes({ paths: [ join(pageCachePath, "scripts")] }),
       multientry({ exports: false }),
       nodeResolve({ jsnext: true }),
       commonjs({}),
       babel({
         presets: [
           [
             "es2015",
             {
               "modules": false
             }
           ]
         ],
         "plugins": [
           "external-helpers"
         ],
         exclude: "node_modules/**"
       })
     ]
   }).then(bundle => bundle.generate({format: "iife", exports: "none", sourceMap: true}).code);
 }

  /** Creates a rollup bundle of a specified JavaScript file.*/
  private async createRollupBundle(config: RollupBundleConfig) {
    const bundleOptions = {
      context: 'this',
      external: Object.keys(rollupExternals),
      input: config.entry,
      onwarn: (message: string) => {
        if (/but never used/.test(message)) {
          return false;
        }
        console.warn(message);
      },
      plugins: [
        rollupRemoveLicensesPlugin,
        rollupNodeResolutionPlugin(),
        rollupAlias(this.getResolvedSecondaryEntryPointImportPaths(config.dest))
      ]
    };

    const writeOptions = {
      name: config.moduleName || 'ng.web',
      amd: { id: config.importName },
      globals: rollupGlobals,
      file: config.dest,
      format: config.format,
      banner: buildConfig.licenseBanner,
      sourcemap: false
    };

    bundleOptions.plugins.push(commonjs({
      include: 'node_modules/**'
    }));

    // Only transpile es5 / umd packages
    if (!config.es6) {
      bundleOptions.plugins.push(babel({
        include: 'node_modules/**'
      }));
    }

    // For UMD bundles, we need to adjust the `external` bundle option in order to include
    // all necessary code in the bundle.
    if (config.format === 'umd') {
      // bundleOptions.plugins.push(minify());

      // For all UMD bundles, we want to exclude tslib from the `external` bundle option so that
      // it is inlined into the bundle.
      let external = Object.keys(rollupGlobals);
      external.splice(external.indexOf('tslib'), 1);

      // If each secondary entry-point is re-exported at the root, we want to exclude those
      // secondary entry-points from the rollup globals because we want the UMD for the
      // primary entry-point to include *all* of the sources for those entry-points.
      if (this.buildPackage.exportsSecondaryEntryPointsAtRoot &&
        config.moduleName === `ng.${this.buildPackage.name}`) {

        const importRegex = new RegExp(`@angular-mdc/${this.buildPackage.name}/.+`);
        external = external.filter(e => !importRegex.test(e));
      }

      bundleOptions.external = external;
    }

    return rollup.rollup(bundleOptions).then((bundle: any) => bundle.write(writeOptions));
  }

  pluginNodeResolve(),
  pluginCommonJS(),
  pluginReplace({ 'process.env.NODE_ENV': '"production"' }),
  pluginTypescript({
    tsconfig: false,
    experimentalDecorators: true,
    module: 'es2015'
  }),
  pluginBabel({
    presets: [
      [
        require.resolve('@babel/preset-env'),
        {
          modules: false,
          targets: {
            browsers: ['last 2 versions']
          }
        }
      ]
    ],
    babelrc: false,
    runtimeHelpers: true
  })
]

export function pluginCreateVueApp(filename: string, component: string): any {
  return {
    name: 'Inline',
    resolveId(id) {
      if (id === filename) return filename
    },

  output: [
    {
      file: pkg.main,
      format: "cjs",
    },
    {
      file: pkg.module,
      format: "es",
    },
  ],
  external: [
    "tslib",
    // @ts-ignore
    ...Object.keys(process.binding("natives")),
    ...Object.keys(pkg.dependencies || {}),
    ...Object.keys(pkg.peerDependencies || {}),
  ],
  plugins: [
    rollupTypeScript({
      "target": "es5",
      "module": "es6",
    }),
    rollupBabel({
      plugins: [
        "babel-plugin-pure-calls-annotation",
      ],
      exclude: "node_modules/**",
      extensions: [".js", ".jsx", ".ts", ".tsx"],
    }),
  ],
};

const env = process.env.NODE_ENV;
const plugins = [
  nodeResolve({
    jsnext: true
  }),
  babel({
    babelrc: false,
    exclude: 'node_modules/**',
    plugins: ["external-helpers"],
    presets: [
      ["latest", {
        "es2015": {
          "modules": false
        },
        "es2016": false,
        "es2017": false
      }]
    ],
    env: {
      "commonjs": {
        "plugins": [
          ["transform-es2015-modules-commonjs", { "loose": true }]
        ]
      }
    }
  }),
  replace({
    'process.env.NODE_ENV': JSON.stringify(env)
  }),
  commonjs(),
  uglify({