rollup_bundle.bzl

# Copyright 2017 The Bazel Authors. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#    http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

"""Rollup bundling

The versions of Rollup and Uglify are controlled by the Bazel toolchain.
You do not need to install them into your project.
"""

load("//internal/common:collect_es6_sources.bzl", "collect_es6_sources")
load("//internal/common:module_mappings.bzl", "get_module_mappings")
load("//internal/common:node_module_info.bzl", "NodeModuleInfo", "collect_node_modules_aspect")

_ROLLUP_MODULE_MAPPINGS_ATTR = "rollup_module_mappings"

def _rollup_module_mappings_aspect_impl(target, ctx):
    mappings = get_module_mappings(target.label, ctx.rule.attr)
    return struct(rollup_module_mappings = mappings)

rollup_module_mappings_aspect = aspect(
    _rollup_module_mappings_aspect_impl,
    attr_aspects = ["deps"],
)

def _trim_package_node_modules(package_name):
    # trim a package name down to its path prior to a node_modules
    # segment. 'foo/node_modules/bar' would become 'foo' and
    # 'node_modules/bar' would become ''
    segments = []
    for n in package_name.split("/"):
        if n == "node_modules":
            break
        segments += [n]
    return "/".join(segments)

def write_rollup_config(ctx, plugins = [], root_dir = None, filename = "_%s.rollup.conf.js", output_format = "iife", additional_entry_points = []):
    """Generate a rollup config file.

    This is also used by the ng_rollup_bundle and ng_package rules in @angular/bazel.

    Args:
      ctx: Bazel rule execution context
      plugins: extra plugins (defaults to [])
               See the ng_rollup_bundle in @angular/bazel for example of usage.
      root_dir: root directory for module resolution (defaults to None)
      filename: output filename pattern (defaults to `_%s.rollup.conf.js`)
      output_format: passed to rollup output.format option, e.g. "umd"
      additional_entry_points: additional entry points for code splitting

    Returns:
      The rollup config file. See https://rollupjs.org/guide/en#configuration-files
    """
    config = ctx.actions.declare_file(filename % ctx.label.name)

    # build_file_path includes the BUILD.bazel file, transform here to only include the dirname
    build_file_dirname = "/".join(ctx.build_file_path.split("/")[:-1])

    entry_points = [ctx.attr.entry_point] + additional_entry_points

    mappings = dict()
    all_deps = ctx.attr.deps + ctx.attr.srcs
    for dep in all_deps:
        if hasattr(dep, _ROLLUP_MODULE_MAPPINGS_ATTR):
            for k, v in getattr(dep, _ROLLUP_MODULE_MAPPINGS_ATTR).items():
                if k in mappings and mappings[k] != v:
                    fail(("duplicate module mapping at %s: %s maps to both %s and %s" %
                          (dep.label, k, mappings[k], v)), "deps")
                mappings[k] = v

    if not root_dir:
        root_dir = "/".join([ctx.bin_dir.path, build_file_dirname, ctx.label.name + ".es6"])

    node_modules_root = None
    default_node_modules = False
    if ctx.files.node_modules:
        # ctx.files.node_modules is not an empty list
        node_modules_root = "/".join([f for f in [
            ctx.attr.node_modules.label.workspace_root,
            _trim_package_node_modules(ctx.attr.node_modules.label.package),
            "node_modules",
        ] if f])
    for d in ctx.attr.deps:
        if NodeModuleInfo in d:
            possible_root = "/".join(["external", d[NodeModuleInfo].workspace, "node_modules"])
            if not node_modules_root:
                node_modules_root = possible_root
            elif node_modules_root != possible_root:
                fail("All npm dependencies need to come from a single workspace. Found '%s' and '%s'." % (node_modules_root, possible_root))
    if not node_modules_root:
        # there are no fine grained deps and the node_modules attribute is an empty filegroup
        # but we still need a node_modules_root even if its empty
        workspace = ctx.attr.node_modules.label.workspace_root.split("/")[1] if ctx.attr.node_modules.label.workspace_root else ctx.workspace_name
        if workspace == "build_bazel_rules_nodejs" and ctx.attr.node_modules.label.package == "" and ctx.attr.node_modules.label.name == "node_modules_none":
            default_node_modules = True
        node_modules_root = "/".join([f for f in [
            ctx.attr.node_modules.label.workspace_root,
            ctx.attr.node_modules.label.package,
            "node_modules",
        ] if f])

    ctx.actions.expand_template(
        output = config,
        template = ctx.file._rollup_config_tmpl,
        substitutions = {
            "TMPL_workspace_name": ctx.workspace_name,
            "TMPL_rootDir": root_dir,
            "TMPL_global_name": ctx.attr.global_name if ctx.attr.global_name else ctx.label.name,
            "TMPL_module_mappings": str(mappings),
            "TMPL_additional_plugins": ",\n".join(plugins),
            "TMPL_banner_file": "\"%s\"" % ctx.file.license_banner.path if ctx.file.license_banner else "undefined",
            "TMPL_stamp_data": "\"%s\"" % ctx.version_file.path if ctx.version_file else "undefined",
            "TMPL_inputs": ",".join(["\"%s\"" % e for e in entry_points]),
            "TMPL_output_format": output_format,
            "TMPL_node_modules_root": node_modules_root,
            "TMPL_default_node_modules": "true" if default_node_modules else "false",
            "TMPL_target": str(ctx.label),
        },
    )

    return config

def run_rollup(ctx, sources, config, output):
    """Creates an Action that can run rollup on set of sources.

    This is also used by ng_package and ng_rollup_bundle rules in @angular/bazel.

    Args:
      ctx: Bazel rule execution context
      sources: JS sources to rollup
      config: rollup config file
      output: output file

    Returns:
      the sourcemap output file
    """
    map_output = ctx.actions.declare_file(output.basename + ".map", sibling = output)

    _run_rollup(ctx, sources, config, output, map_output)

    return map_output

def _filter_js_inputs(all_inputs):
    return [
        f
        for f in all_inputs
        if f.path.endswith(".js") or f.path.endswith(".json")
    ]

def _run_rollup(ctx, sources, config, output, map_output = None):
    args = ctx.actions.args()
    args.add_all(["--config", config.path])
    if map_output:
        args.add_all(["--output.file", output.path])
        args.add_all(["--output.sourcemap", "--output.sourcemapFile", map_output.path])
    else:
        args.add_all(["--output.dir", output.path])
        args.add_all(["--output.sourcemap"])

    # We will produce errors as needed. Anything else is spammy: a well-behaved
    # bazel rule prints nothing on success.
    #
    # TODO(https://github.com/rollup/rollup/issues/2582): Uncomment the following
    # line once rollup stops reporting build errors with onwarn.
    # args.add("--silent")

    if ctx.attr.globals:
        args.add("--external")
        args.add_joined(ctx.attr.globals.keys(), join_with = ",")
        args.add("--globals")
        args.add_joined(["%s:%s" % g for g in ctx.attr.globals.items()], join_with = ",")

    direct_inputs = [config]
    direct_inputs += _filter_js_inputs(ctx.files.node_modules)

    # Also include files from npm fine grained deps as inputs.
    # These deps are identified by the NodeModuleInfo provider.
    for d in ctx.attr.deps:
        if NodeModuleInfo in d:
            direct_inputs += _filter_js_inputs(d.files.to_list())

    if ctx.file.license_banner:
        direct_inputs += [ctx.file.license_banner]
    if ctx.version_file:
        direct_inputs += [ctx.version_file]

    outputs = [output]
    if map_output:
        outputs += [map_output]

    ctx.actions.run(
        executable = ctx.executable._rollup,
        inputs = depset(direct_inputs, transitive = [sources]),
        outputs = outputs,
        arguments = [args],
    )

def _run_tsc(ctx, input, output):
    args = ctx.actions.args()
    args.add_all(["--target", "es5"])
    args.add("--allowJS")
    args.add(input.path)
    args.add_all(["--outFile", output.path])

    ctx.actions.run(
        executable = ctx.executable._tsc,
        inputs = [input],
        outputs = [output],
        arguments = [args],
    )

def _run_tsc_on_directory(ctx, input_dir, output_dir):
    config = ctx.actions.declare_file("_%s.code-split.tsconfig.json" % ctx.label.name)

    args = ctx.actions.args()
    args.add_all(["--project", config.path])
    args.add_all(["--input", input_dir.path])
    args.add_all(["--output", output_dir.path])

    ctx.actions.run(
        executable = ctx.executable._tsc_directory,
        inputs = [input_dir],
        outputs = [output_dir, config],
        arguments = [args],
    )

def run_uglify(ctx, input, output, debug = False, comments = True, config_name = None, in_source_map = None):
    """Runs uglify on an input file.

    This is also used by https://github.com/angular/angular.

    Args:
      ctx: Bazel rule execution context
      input: input file
      output: output file
      debug: if True then output is beautified (defaults to False)
      comments: if True then copyright comments are preserved in output file (defaults to True)
      config_name: allows callers to control the name of the generated uglify configuration,
          which will be `_[config_name].uglify.json` in the package where the target is declared
      in_source_map: sourcemap file for the input file, passed to the "--source-map content="
          option of rollup.

    Returns:
      The sourcemap file
    """

    map_output = ctx.actions.declare_file(output.basename + ".map", sibling = output)

    _run_uglify(ctx, input, output, map_output, debug, comments, config_name, in_source_map)

    return map_output

def _run_uglify(ctx, input, output, map_output, debug = False, comments = True, config_name = None, in_source_map = None):
    inputs = [input]
    outputs = [output]

    args = ctx.actions.args()

    if map_output:
        # Running uglify on an individual file
        if not config_name:
            config_name = ctx.label.name
            if debug:
                config_name += ".debug"
        config = ctx.actions.declare_file("_%s.uglify.json" % config_name)
        args.add_all(["--config-file", config.path])
        outputs += [map_output, config]

    args.add(input.path)
    args.add_all(["--output", output.path])

    # Source mapping options are comma-packed into one argv
    # see https://github.com/mishoo/UglifyJS2#command-line-usage
    source_map_opts = ["includeSources", "base=" + ctx.bin_dir.path]
    if in_source_map:
        source_map_opts.append("content=" + in_source_map.path)
        inputs.append(in_source_map)

    # This option doesn't work in the config file, only on the CLI
    args.add_all(["--source-map", ",".join(source_map_opts)])

    if comments:
        args.add("--comments")
    if debug:
        args.add("--debug")
        args.add("--beautify")

    ctx.actions.run(
        executable = ctx.executable._uglify_wrapped,
        inputs = inputs,
        outputs = outputs,
        arguments = [args],
    )

def run_sourcemapexplorer(ctx, js, map, output):
    """Runs source-map-explorer to produce an HTML visualization of the sourcemap.

    Args:
      ctx: bazel rule execution context
      js: Javascript bundle
      map: sourcemap from the bundle back to original sources
      output: file where the HTML report is written
    """

    # We must run in a shell in order to redirect stdout.
    # TODO(alexeagle): file a feature request on ctx.actions.run so that stdout
    # could be natively redirected to produce the output file
    ctx.actions.run_shell(
        inputs = [js, map],
        tools = [ctx.executable._source_map_explorer],
        outputs = [output],
        command = "$1 --html $2 $3 > $4",
        arguments = [
            ctx.executable._source_map_explorer.path,
            js.path,
            map.path,
            output.path,
        ],
    )

def _generate_code_split_entry(ctx, bundles_folder, output):
    """Generates a SystemJS boilerplate/entry point file.

    See doc for additional_entry_points for more information
    on purpose and usage of this generated file.

    The SystemJS packages map outputted to the file is generated
    from the entry_point and additional_entry_point attributes and
    is targetted as a specific bundle variant specified by `folder`.

    For example, a rollup_bundle in may be configured like so:

    ```
    rollup_bundle(
        name = "bundle",
        additional_entry_points = [
            "src/hello-world/hello-world.module.ngfactory",
            "src/todos/todos.module.ngfactory",
        ],
        entry_point = "src/main.prod",
        deps = ["//src"],
    )
    ```

    In this case, the main_entry_point_dirname will evaluate to
    `src/` and this will be stripped from the entry points for
    the map. If folder is `bundle.cs`, the generated SystemJS
    boilerplate/entry point file will look like:

    ```
    (function(global) {
    System.config({
      packages: {
        '': {map: {
          "./main.prod": "bundle.cs/main.prod",
          "./hello-world/hello-world.module.ngfactory": "bundle.cs/hello-world.module.ngfactory",
          "./todos/todos.module.ngfactory": "bundle.cs/todos.module.ngfactory"},
          defaultExtension: 'js'},
      }
    });
    System.import('main.prod').catch(function(err) {
      console.error(err);
    });
    })(this);
    ```

    Args:
      ctx: bazel rule execution context
      bundles_folder: the folder name with the bundled chunks to map to
      output: the file to generate
    """
    main_entry_point_basename = ctx.attr.entry_point.split("/")[-1]
    main_entry_point_dirname = "/".join(ctx.attr.entry_point.split("/")[:-1]) + "/"
    entry_points = {}
    for e in [ctx.attr.entry_point] + ctx.attr.additional_entry_points:
        entry_point = e[len(main_entry_point_dirname):]
        entry_points["./" + entry_point] = bundles_folder + "/" + entry_point.split("/")[-1]

    ctx.actions.expand_template(
        output = output,
        template = ctx.file._system_config_tmpl,
        substitutions = {
            "TMPL_entry_points": str(entry_points),
            "TMPL_main_entry_point": main_entry_point_basename,
        },
    )

def _rollup_bundle(ctx):
    if ctx.attr.additional_entry_points:
        # Generate code split bundles if additional entry points have been specified.
        # See doc for additional_entry_points for more information.
        # Note: ".cs" is needed on the output folders since ctx.label.name + ".es6" is already
        # a folder that contains the re-rooted es6 sources
        rollup_config = write_rollup_config(ctx, output_format = "cjs", additional_entry_points = ctx.attr.additional_entry_points)
        code_split_es6_output_dir = ctx.actions.declare_directory(ctx.label.name + ".cs.es6")
        _run_rollup(ctx, collect_es6_sources(ctx), rollup_config, code_split_es6_output_dir)
        code_split_es5_output_dir = ctx.actions.declare_directory(ctx.label.name + ".cs")
        _run_tsc_on_directory(ctx, code_split_es6_output_dir, code_split_es5_output_dir)
        code_split_es5_min_output_dir = ctx.actions.declare_directory(ctx.label.name + ".cs.min")
        _run_uglify(ctx, code_split_es5_output_dir, code_split_es5_min_output_dir, None)
        code_split_es5_min_debug_output_dir = ctx.actions.declare_directory(ctx.label.name + ".cs.min_debug")
        _run_uglify(ctx, code_split_es5_output_dir, code_split_es5_min_debug_output_dir, None, debug = True)

        # Generate the SystemJS boilerplate/entry point files
        _generate_code_split_entry(ctx, ctx.label.name + ".cs.es6", ctx.outputs.build_es6)
        _generate_code_split_entry(ctx, ctx.label.name + ".cs", ctx.outputs.build_es5)
        _generate_code_split_entry(ctx, ctx.label.name + ".cs.min", ctx.outputs.build_es5_min)
        _generate_code_split_entry(ctx, ctx.label.name + ".cs.min_debug", ctx.outputs.build_es5_min_debug)

        # There is no UMD/CJS bundle when code-splitting but we still need to satisfy the output
        _generate_code_split_entry(ctx, ctx.label.name + ".cs", ctx.outputs.build_umd)
        _generate_code_split_entry(ctx, ctx.label.name + ".cs", ctx.outputs.build_cjs)

        # There is no source map explorer output when code-splitting but we still need to satisfy the output
        ctx.actions.expand_template(
            output = ctx.outputs.explore_html,
            template = ctx.file._no_explore_html,
            substitutions = {},
        )
        files = [
            ctx.outputs.build_es6,
            ctx.outputs.build_es5,
            ctx.outputs.build_es5_min,
            ctx.outputs.build_es5_min_debug,
            code_split_es6_output_dir,
            code_split_es5_output_dir,
            code_split_es5_min_output_dir,
            code_split_es5_min_debug_output_dir,
        ]

    else:
        # Generate the bundles
        rollup_config = write_rollup_config(ctx)
        run_rollup(ctx, collect_es6_sources(ctx), rollup_config, ctx.outputs.build_es6)
        _run_tsc(ctx, ctx.outputs.build_es6, ctx.outputs.build_es5)
        source_map = run_uglify(ctx, ctx.outputs.build_es5, ctx.outputs.build_es5_min)
        run_uglify(ctx, ctx.outputs.build_es5, ctx.outputs.build_es5_min_debug, debug = True)
        cjs_rollup_config = write_rollup_config(ctx, filename = "_%s_cjs.rollup.conf.js", output_format = "cjs")
        run_rollup(ctx, collect_es6_sources(ctx), cjs_rollup_config, ctx.outputs.build_cjs)
        umd_rollup_config = write_rollup_config(ctx, filename = "_%s_umd.rollup.conf.js", output_format = "umd")
        run_rollup(ctx, collect_es6_sources(ctx), umd_rollup_config, ctx.outputs.build_umd)
        run_sourcemapexplorer(ctx, ctx.outputs.build_es5_min, source_map, ctx.outputs.explore_html)
        files = [ctx.outputs.build_es5_min, source_map]

    return DefaultInfo(files = depset(files), runfiles = ctx.runfiles(files))

# Expose our list of aspects so derivative rules can override the deps attribute and
# add their own additional aspects.
# If users are in a different repo and load the aspect themselves, they will create
# different Provider symbols (e.g. NodeModuleInfo) and we won't find them.
# So users must use these symbols that are load'ed in rules_nodejs.
ROLLUP_DEPS_ASPECTS = [rollup_module_mappings_aspect, collect_node_modules_aspect]

ROLLUP_ATTRS = {
    "entry_point": attr.string(
        doc = """The starting point of the application, passed as the `--input` flag to rollup.
        This should be a path relative to the workspace root.
        """,
        mandatory = True,
    ),
    "additional_entry_points": attr.string_list(
        doc = """Additional entry points of the application for code splitting, passed as the input to rollup.
        These should be a path relative to the workspace root.

        When additional_entry_points are specified, rollup_bundle
        will split the bundle in multiple entry points and chunks.
        There will be a main entry point chunk as well as entry point
        chunks for each additional_entry_point. The file names
        of these entry points will correspond to the file names
        specified in entry_point and additional_entry_points.
        There will also be one or more common chunks that are shared
        between entry points named chunk-<HASH>.js. The number
        of common chunks is variable depending on the code being
        bundled.

        Entry points and chunks will be outputted to folders:
        - <label-name>.cs.es6 // es6
        - <label-name>.cs // es5
        - <label-name>.cs.min // es5 minified
        - <label-name>.cs.min_debug // es5 minified debug

        The following files will be outputted that contain the
        SystemJS boilerplate to map the entry points to their file
        names and load the main entry point:
        flavors:
        - <label-name>.es6.js // es6
        - <label-name>.js // es5
        - <label-name>.min.js // es5 minified
        - <label-name>.min_debug.js // es5 minified debug

        NOTE: additional_entry_points MUST be in the same folder or deeper than
        the main entry_point for the SystemJS boilerplate/entry point to
        be valid. For example, if the main entry_point is
        `src/main` then all additional_entry_points must be under
        `src/**` such as `src/bar` or `src/foo/bar`. Alternate
        additional_entry_points configurations are valid but the
        SystemJS boilerplate/entry point files will not be usable and
        it is up to the user in these cases to handle the SystemJS
        boilerplate manually.

        It is sufficient to load one of these SystemJS boilerplate/entry point
        files as a script in your HTML to load your application""",
    ),
    "srcs": attr.label_list(
        doc = """JavaScript source files from the workspace.
        These can use ES2015 syntax and ES Modules (import/export)""",
        allow_files = [".js"],
    ),
    "deps": attr.label_list(
        doc = """Other rules that produce JavaScript outputs, such as `ts_library`.""",
        aspects = ROLLUP_DEPS_ASPECTS,
    ),
    "node_modules": attr.label(
        doc = """Dependencies from npm that provide some modules that must be
        resolved by rollup.

        This attribute is DEPRECATED. As of version 0.13.0 the recommended approach
        to npm dependencies is to use fine grained npm dependencies which are setup
        with the `yarn_install` or `npm_install` rules. For example, in a rollup_bundle
        target that used the `node_modules` attribute,

        ```
        rollup_bundle(
          name = "bundle",
          ...
          node_modules = "//:node_modules",
        )
        ```

        which specifies all files within the `//:node_modules` filegroup
        to be inputs to the `bundle`. Using fine grained npm dependencies,
        `bundle` is defined with only the npm dependencies that are
        needed:

        ```
        rollup_bundle(
          name = "bundle",
          ...
          deps = [
              "@npm//foo",
              "@npm//bar",
              ...
          ],
        )
        ```

        In this case, only the `foo` and `bar` npm packages and their
        transitive deps are includes as inputs to the `bundle` target
        which reduces the time required to setup the runfiles for this
        target (see https://github.com/bazelbuild/bazel/issues/5153).

        The @npm external repository and the fine grained npm package
        targets are setup using the `yarn_install` or `npm_install` rule
        in your WORKSPACE file:

        yarn_install(
          name = "npm",
          package_json = "//:package.json",
          yarn_lock = "//:yarn.lock",
        )
        """,
        default = Label("//:node_modules_none"),
    ),
    "license_banner": attr.label(
        doc = """A .txt file passed to the `banner` config option of rollup.
        The contents of the file will be copied to the top of the resulting bundles.
        Note that you can replace a version placeholder in the license file, by using
        the special version `0.0.0-PLACEHOLDER`. See the section on stamping in the README.""",
        allow_single_file = [".txt"],
    ),
    "globals": attr.string_dict(
        doc = """A dict of symbols that reference external scripts.
        The keys are variable names that appear in the program,
        and the values are the symbol to reference at runtime in a global context (UMD bundles).
        For example, a program referencing @angular/core should use ng.core
        as the global reference, so Angular users should include the mapping
        `"@angular/core":"ng.core"` in the globals.""",
        default = {},
    ),
    "global_name": attr.string(
        doc = """A name given to this package when referenced as a global variable.
        This name appears in the bundle module incantation at the beginning of the file,
        and governs the global symbol added to the global context (e.g. `window`) as a side-
        effect of loading the UMD/IIFE JS bundle.

        Rollup doc: "The variable name, representing your iife/umd bundle, by which other scripts on the same page can access it."

        This is passed to the `output.name` setting in Rollup.""",
    ),
    "_rollup": attr.label(
        executable = True,
        cfg = "host",
        default = Label("@build_bazel_rules_nodejs//internal/rollup:rollup"),
    ),
    "_tsc": attr.label(
        executable = True,
        cfg = "host",
        default = Label("@build_bazel_rules_nodejs//internal/rollup:tsc"),
    ),
    "_tsc_directory": attr.label(
        executable = True,
        cfg = "host",
        default = Label("@build_bazel_rules_nodejs//internal/rollup:tsc-directory"),
    ),
    "_uglify_wrapped": attr.label(
        executable = True,
        cfg = "host",
        default = Label("@build_bazel_rules_nodejs//internal/rollup:uglify-wrapped"),
    ),
    "_source_map_explorer": attr.label(
        executable = True,
        cfg = "host",
        default = Label("@build_bazel_rules_nodejs//internal/rollup:source-map-explorer"),
    ),
    "_no_explore_html": attr.label(
        default = Label("@build_bazel_rules_nodejs//internal/rollup:no_explore.html"),
        allow_single_file = True,
    ),
    "_rollup_config_tmpl": attr.label(
        default = Label("@build_bazel_rules_nodejs//internal/rollup:rollup.config.js"),
        allow_single_file = True,
    ),
    "_system_config_tmpl": attr.label(
        default = Label("@build_bazel_rules_nodejs//internal/rollup:system.config.js"),
        allow_single_file = True,
    ),
}

ROLLUP_OUTPUTS = {
    "build_es6": "%{name}.es6.js",
    "build_es5": "%{name}.js",
    "build_es5_min": "%{name}.min.js",
    "build_es5_min_debug": "%{name}.min_debug.js",
    "build_umd": "%{name}.umd.js",
    "build_cjs": "%{name}.cjs.js",
    "explore_html": "%{name}.explore.html",
}

rollup_bundle = rule(
    implementation = _rollup_bundle,
    attrs = ROLLUP_ATTRS,
    outputs = ROLLUP_OUTPUTS,
)
"""
Produces several bundled JavaScript files using Rollup and Uglify.

Load it with
`load("@build_bazel_rules_nodejs//:defs.bzl", "rollup_bundle")`

It performs this work in several separate processes:
1. Call rollup on the original sources
2. Downlevel the resulting code to es5 syntax for older browsers
3. Minify the bundle with Uglify, possibly with pretty output for human debugging.

The default output of a `rollup_bundle` rule is the non-debug-minified es5 bundle.

However you can request one of the other outputs with a dot-suffix on the target's name.
For example, if your `rollup_bundle` is named `my_rollup_bundle`, you can use one of these labels:

To request the ES2015 syntax (e.g. `class` keyword) without downleveling or minification, use the `:my_rollup_bundle.es6.js` label.
To request the ES5 downleveled bundle without minification, use the `:my_rollup_bundle.js` label
To request the debug-minified es5 bundle, use the `:my_rollup_bundle.min_debug.js` label.
To request a UMD-bundle, use the `:my_rollup_bundle.umd.js` label.
To request a CommonJS bundle, use the `:my_rollup_bundle.cjs.js` label.

You can also request an analysis from source-map-explorer by buildng the `:my_rollup_bundle.explore.html` label.
However this is currently broken for `rollup_bundle` ES5 mode because we use tsc for downleveling and
it doesn't compose the resulting sourcemaps with an input sourcemap.
See https://github.com/bazelbuild/rules_nodejs/issues/175

For debugging, note that the `rollup.config.js` and `uglify.config.json` files can be found in the bazel-bin folder next to the resulting bundle.

An example usage can be found in https://github.com/bazelbuild/rules_nodejs/tree/master/internal/e2e/rollup
"""