remap polyfills (via $jscomp) without including $jscomp definition in the output

When splitting the app into “bundles”, sharing $jscomp definitions between all bundles could be beneficial, especially if the rollups are created by concatenating “bundles” on-demand.

With the new option --inject_library=es6_runtime we can easily externalize $jscomp definitions that can be used to patch the environment, but the missing part is how to compile modules with the proper mapping for polyfills without having to include $jscomp definitions in those other files?

[brad4d]

AFAICT, the purpose of this issue is to request the ability to do something like this.

1. Run closure-compiler on a.js, b.js, and c.js to create abc_out.js
2. Run closure-compiler on x.js, y.js, and z.js to create xyz_out.js
3. Concatenate abc_out.js and xyz_out.js when shipping them to the browser and / or load them independently in the browser.

Presumably externs files are used to define the interface between code in the 2 output files. This bug exists because you would need to include the $jscomp polyfill code needed to support transpilation only once.

A core part of the closure-compiler design is that it should see all of the relevant code, except possibly some external library code that is not compiled. Separately compiling pieces then putting them together later isn’t something we actively try to support.

If the purpose of doing things this way is to reduce the amount of code that must be shipped to the browser, the --module flag should be used as @ChadKillingsworth suggested above. With this flag the compiler sees all the code as input, but splits the output into separately loadable files. Here’s his nice SO article about it.

https://stackoverflow.com/questions/10395810/how-do-i-split-my-javascript-into-modules-using-googles-closure-compiler/10401030#10401030

[stevendwood]

@brad4d - given the answer from @shicks here https://github.com/google/closure-compiler/issues/1603 it seems like you kind of can do this ? I think first would need to get the polyfills in a separate output file by compiling an empty source with force inject es6 runtime.

Then you build abc_out.js and xyz_out.js using the option setPreventLibraryInjection(true). Or presumably you could write a small file that used all the transpilable features you wanted to support and compile that to get the polyfills. You then combine the polyfill and the two output files.