output contains asyncGenerator(), but I never use it.

[musicode]

my rollup version is 0.36.3, my config is as below:

import babel from 'rollup-plugin-babel'
import resolve from 'rollup-plugin-node-resolve'
import commonjs from 'rollup-plugin-commonjs'
import uglify from 'rollup-plugin-uglify';

var minify = process.env.NODE_ENV === 'release'

export default {
  entry: 'src/index.js',
  format: 'umd',
  moduleName: 'index',
  plugins: [
    babel({
      presets: [ 'es2015-rollup' ],
      babelrc: false,
      comments: false,
      runtimeHelpers: true
    }),
    resolve({
      jsnext: true,
      main: true,
      browser: true,
    }),
    commonjs(),
    (minify && uglify()),
  ],
  dest: minify ? 'dist/index.min.js' : 'dist/index.js'
}

[musicode]

There are 3 features never used.

var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) {
  return typeof obj;
} : function (obj) {
  return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
};

var asyncGenerator = function () {
  function AwaitValue(value) {
    this.value = value;
  }

  function AsyncGenerator(gen) {
    var front, back;

    function send(key, arg) {
      return new Promise(function (resolve, reject) {
        var request = {
          key: key,
          arg: arg,
          resolve: resolve,
          reject: reject,
          next: null
        };

        if (back) {
          back = back.next = request;
        } else {
          front = back = request;
          resume(key, arg);
        }
      });
    }

    function resume(key, arg) {
      try {
        var result = gen[key](arg);
        var value = result.value;

        if (value instanceof AwaitValue) {
          Promise.resolve(value.value).then(function (arg) {
            resume("next", arg);
          }, function (arg) {
            resume("throw", arg);
          });
        } else {
          settle(result.done ? "return" : "normal", result.value);
        }
      } catch (err) {
        settle("throw", err);
      }
    }

    function settle(type, value) {
      switch (type) {
        case "return":
          front.resolve({
            value: value,
            done: true
          });
          break;

        case "throw":
          front.reject(value);
          break;

        default:
          front.resolve({
            value: value,
            done: false
          });
          break;
      }

      front = front.next;

      if (front) {
        resume(front.key, front.arg);
      } else {
        back = null;
      }
    }

    this._invoke = send;

    if (typeof gen.return !== "function") {
      this.return = undefined;
    }
  }

  if (typeof Symbol === "function" && Symbol.asyncIterator) {
    AsyncGenerator.prototype[Symbol.asyncIterator] = function () {
      return this;
    };
  }

  AsyncGenerator.prototype.next = function (arg) {
    return this._invoke("next", arg);
  };

  AsyncGenerator.prototype.throw = function (arg) {
    return this._invoke("throw", arg);
  };

  AsyncGenerator.prototype.return = function (arg) {
    return this._invoke("return", arg);
  };

  return {
    wrap: function (fn) {
      return function () {
        return new AsyncGenerator(fn.apply(this, arguments));
      };
    },
    await: function (value) {
      return new AwaitValue(value);
    }
  };
}();

var get$1 = function get$1(object, property, receiver) {
  if (object === null) object = Function.prototype;
  var desc = Object.getOwnPropertyDescriptor(object, property);

  if (desc === undefined) {
    var parent = Object.getPrototypeOf(object);

    if (parent === null) {
      return undefined;
    } else {
      return get$1(parent, property, receiver);
    }
  } else if ("value" in desc) {
    return desc.value;
  } else {
    var getter = desc.get;

    if (getter === undefined) {
      return undefined;
    }

    return getter.call(receiver);
  }
};

[musicode]

var set$1 = function set$1(object, property, value, receiver) {
  var desc = Object.getOwnPropertyDescriptor(object, property);

  if (desc === undefined) {
    var parent = Object.getPrototypeOf(object);

    if (parent !== null) {
      set$1(parent, property, value, receiver);
    }
  } else if ("value" in desc && desc.writable) {
    desc.value = value;
  } else {
    var setter = desc.set;

    if (setter !== undefined) {
      setter.call(receiver, value);
    }
  }

  return value;
};

[panzerdp]

I have exactly the same problem.
The build adds the presented unused code.

[kennetpostigo]

Set externalHelpers to true in the configuration to remove this.

[hollowdoor]

@kennetpostigo If I use the externalHelpers option I get this error ReferenceError: babelHelpers is not defined if I run a test build in the browser.

Edit: If I do the opposite (externalHelpers=false) then it works.

[kennetpostigo]

@hollowdoor did you turn this on in the rollup.config.js? It's meant to go in there. Also are you using es2015-rollup?

[hollowdoor]

Oh no wait I was wrong. If I change it to false it inserts the asyncGenerator again. What's weird about this is that it works for a test build, but not for a sub-module. rollup keeps throwing The keyword 'await' is reserved .

@kennetpostigo I don't have a rollup.config.js file. I use rollup as a module. And I turned it on/off in there. If I turn externalHelpers to true I get ReferenceError: babelHelpers is not defined. If I turn externalHelpers to false I get the asyncGenerator in the build, and also a The keyword 'await' is reserved error when I try to build in a consuming script.

So the story goes I have a little module I've published that contains the offending asyncGenerator that works when I run isolated tests. It doesn't work if I try to include that module into an iife build for inclusion in an App.

[kennetpostigo]

@hollowdoor gotcha. Flipping it to true was the only quick fix I found for this. I haven't tried using it as a module but can't imagine it being much different. Are you using es2015-rollup? It should include the helpers

[hollowdoor]

Yes I'm using es2015 rollup. The helpers aren't being included for whatever reason.

Also I don't need them for the module. The only babel-helper code put in there is for typeof.

[hollowdoor]

Ok. It kind of sucks, but what I had to do was let the asyncGenerator remain. In my app build I used the allowReserved option on the rollup's acorn option like this acorn: {allowReserved: true}. So no {externalHelpers:true} in my module's config.

Now my build config for the app looks like this:

export default {
  entry: 'src.js',
  format: 'iife',
  acorn: {allowReserved: true},
  plugins: [
      babel(),
      nodeResolve({ jsnext: true, main: true }),
      commonjs()
  ],
  dest: 'main.js',
  moduleName: 'none'
};

Rather strange bug I must say.

Related rollup/rollup#564 but not the same. I hope things keep working because now my setup could be clobbered by reserved words. Also there are now duplicates of asyncGenerator. :(

I am also not using asyncGenerator, nor the other extraneous stuff listed in one of the earlier posts by @musicode.

[Rich-Harris]

Am unable to reproduce this with the current version (2.7.1) – does anyone have a sample repo illustrating the problem? Thanks

[hollowdoor]

I don't know if this will help.

I have a repo with a library https://github.com/hollowdoor/dom_compose

That library is bundled as es2015, and commonjs modules.

I have a consuming app that has this configuration:

import babel from 'rollup-plugin-babel';
import commonjs from 'rollup-plugin-commonjs';
import nodeResolve from 'rollup-plugin-node-resolve';

export default {
  entry: 'src.js',
  format: 'iife',
  acorn: {allowReserved: true},
  plugins: [
      babel(),
      nodeResolve({ jsnext: true, main: true }),
      commonjs()
  ],
  dest: 'main.js',
  moduleName: 'none'
};

The bablrc for the app looks like this:

{
  "presets": ["es2015-rollup"]
}

The output file main.js contains all kinds of extra/duplicate babel helper definitions.

For the app if I set externalHelpers to true it puts the dependencies in the arguments of the iife. If I set externalHelpers to false I get all kinds of helpers I don't use.

For the dom-compose module if externalHelpers is false when I build the app script I get an async is a reserved word error.

Finally if I don't set externalHelpers (default false) in both the module, and app I can set acorn to allow reserved true. But then I get duplicate babel helper definitions.

I've considered just not using es2015 (except the modules) in my module, but I think that would defeat the purpose of compiling a module that's meant to be consumed by browsers. The other thing I'm considering is switching to buble for the module, and continue to use babel for the app. That wouldn't get rid of the unused babel helpers in the app though.

It could be that I just don't know what I'm doing. :)

Or there's some deep bug, or conflict way down in some other module. Whatever it is it's a mystery to me.

I'm using rollup 0.37.0, and rollup-plugin-babel ^2.6.1.

[Rich-Harris]

@hollowdoor thanks. Are you getting the same results with the latest versions of rollup-plugin-babel and babel-preset-es2015-rollup? It seems to be behaving for me.

The other thing I'm considering is switching to buble for the module, and continue to use babel for the app

I'd recommend that, and not just because I'm biased – the modules will get smaller as a result, and you won't have the weird typeof polyfill appearing multiple times in your app. You would need to use the dangerousForOf and dangerousTaggedTemplateString transforms (as far as I can tell from reading the source code, this is a case where it's legit to use those transforms).

[hollowdoor]

It might be a day, or so before I check the latest babel-preset-es2015-rollup. I've got version 1.2 for babel-preset-es2015-rollup for some reason. Which is weird because I just installed it recently.

I do think I'll switch to buble anyway. For modules it would be better fit. I will need the dangerous transforms for testing, or maybe not. I can test with a browser that supports template literals. As far as compiling the module itself I don't think it needs to know that it's a template tag. But I will need the dangerousForOf.

Before I do switch I'll try testing the newer babel-presets to see if it's working. I'll try to remember to report back here.