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

 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);
 }

function getConfig({ isUMD }) {
  return {
    input: `src/${libraryName}.ts`,
    output: [
      isUMD
        ? {
            file: getFileName(pkg.main.replace('.js', '.umd.js')),
            name: camelCase(libraryName),
            format: 'umd',
          }
        : { file: getFileName(pkg.main), format: 'cjs' },
    ],
    sourcemap: true,
    watch: {
      include: 'src/**',
    },
    external: isUMD ? [] : id => id === 'react' || /codemirror/.test(id),
    plugins: [
      // Compile TypeScript files
      typescript({ useTsconfigDeclarationDir: true }),
      // Allow bundling cjs modules (unlike webpack, rollup doesn't understand cjs)
      isUMD && commonjs(),
      // Allow node_modules resolution, so you can use 'external' to control
      // which external modules to include in the bundle
      // https://github.com/rollup/rollup-plugin-node-resolve#usage
      isUMD && resolve(),

      // Resolve source maps to the original source
      sourceMaps(),

      minify && uglify(),
    ],
  };
}

export function createRollupBundle(config: BundleConfig): Promise<any> {
  const bundleOptions: any = {
    context: 'this',
    external: Object.keys(ROLLUP_GLOBALS),
    entry: config.entry,
  };

  const writeOptions = {
    // Keep the moduleId empty because we don't want to force developers to a specific moduleId.
    moduleId: '',
    moduleName: config.moduleName || 'ng.material',
    banner: LICENSE_BANNER,
    format: config.format,
    dest: config.dest,
    globals: ROLLUP_GLOBALS,
    sourceMap: true
  };

  // When creating a UMD, we want to exclude tslib from the `external` bundle option so that it
  // is inlined into the bundle.
  if (config.format === 'umd') {
    bundleOptions.plugins = [rollupNodeResolutionPlugin()];

    const external = Object.keys(ROLLUP_GLOBALS);
    external.splice(external.indexOf('tslib'), 1);
    bundleOptions.external = external;
  }

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

  /** Creates a rollup bundle of a specified JavaScript file.*/
  private async createRollupBundle(config: RollupBundleConfig) {
    const bundleOptions = {
      context: 'this',
      external: Object.keys(rollupGlobals),
      input: config.entry,
      onwarn: (message: string) => {
        // TODO(jelbourn): figure out *why* rollup warns about certain symbols not being found
        // when those symbols don't appear to be in the input file in the first place.
        if (/but never used/.test(message)) {
          return false;
        }

        console.warn(message);
      },
      plugins: [
        rollupRemoveLicensesPlugin,
      ]
    };

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

    // 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(rollupNodeResolutionPlugin());

      // 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 exlclude those
      // secondary entry-points from the rollup globals because we want the UMD for this package
      // 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/${this.buildPackage.name}/.+`);
        external = external.filter(e => !importRegex.test(e));

        // Use the rollup-alias plugin to map imports of the form `@angular/material/button`
        // to the actual file location so that rollup can resolve the imports (otherwise they
        // will be treated as external dependencies and not included in the bundle).
        bundleOptions.plugins.push(
            rollupAlias(this.getResolvedSecondaryEntryPointImportPaths(config.dest)));
      }

      bundleOptions.external = external;
    }

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

const buildCjsPackage = ({ env }) => {
  return {
    input: `compiled/index.js`,
    output: [
      {
        file: `dist/index.${env}.js`,
        name: libraryName,
        format: 'cjs',
        sourcemap: true,
        exports: 'named',
        globals: {
          react: 'React',
          'prop-types': 'PropTypes',
        },
      },
    ],
    external: ['react', 'react-dom'],
    plugins: [
      commonjs({
        include: /node_modules/,
        namedExports: {
          '../../node_modules/lodash/lodash.js': [
            'flatten',
            'find',
            'upperFirst',
            'debounce',
            'isNil',
            'isNumber',
            'flattenDeep',
            'map',
            'chunk',
            'sortBy',
            'uniqueId',
            'zip',
            'omit',
          ],
          '../../node_modules/react-color/lib/components/common': ['Saturation', 'Hue', 'Alpha'],
        },
      }),
      resolve(),
      sourceMaps(),
      env === 'production' && terser(),
    ],
  };
};

gulp.task('task:worker:test:bundle', done => rollup
  .rollup({
    entry: 'tmp/esm/src/worker/builds/test.js',
    plugins: [
      new SwRewriter(),
      nodeResolve({jsnext: true, main: true}),
      commonjs({
        include: 'node_modules/**',
        namedExports: {
          'node_modules/jshashes/hashes.js': ['SHA1']
        }
      })
    ]
  })
  .then(bundle => bundle.write({
    format: 'iife',
    dest: 'tmp/es5/bundles/worker-test.js',
  })));

gulp.task('task:app:bundle', done => rollup
  .rollup({
    entry: 'tmp/esm/src/index.js',
    plugins: [
      nodeResolve({jsnext: true, main: true}),
      commonjs({
        include: 'node_modules/**',
      }),
    ],
    external: [
      '@angular/core',
    ]
  })
  .then(bundle => bundle.write({
    format: 'umd',
    moduleName: 'ng.appShell',
    dest: 'tmp/es5/bundles/app-shell.umd.js',
    globals: {
      '@angular/core': 'ng.core',
    },
  })));

gulp.task('task:compile:rollup', done => {
  rollup
    .rollup({
      entry: 'tmp/ngc/app/main.js',
      plugins: [
        new RxRewriter(),
        rollupResolveNode({
          jsnext: true,
          main: true,
          extensions: ['.js'],
          preferBuiltins: false
        })
      ]
    })
    .then(bundle => bundle.write({
      format: 'cjs',
      dest: 'tmp/rollup/app.js'
    }))
    .catch(err => {
      console.error(err);
    })
    .then(() => done());
})

const pluginBabel = require('rollup-plugin-babel')
const pluginNodeResolve = require('rollup-plugin-node-resolve')
const pluginCommonJS = require('rollup-plugin-commonjs')
const pluginImage = require('rollup-plugin-url')
const pluginMarkdown = require('rollup-plugin-md')
const pluginTypescript = require('rollup-plugin-typescript')
const pluginReplace = require('rollup-plugin-replace')
const path = require('path')

export const plugins = [
  pluginImage(),
  pluginMarkdown(),
  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']
          }
        }
      ]