npm - @atlaspack/reporter-bundle-analyzer - Versions diffs - 2.12.1-canary.3354 - Mend

@atlaspack/reporter-bundle-analyzer 2.12.1-canary.3354

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (8) hide show

package/LICENSE +201 -0
package/client/index.js +112 -0
package/client/vendor/foamtree/LICENSE.txt +208 -0
package/client/vendor/foamtree/carrotsearch.foamtree.js +258 -0
package/index.js +3 -0
package/lib/BundleAnalyzerReporter.js +167 -0
package/package.json +27 -0
package/src/BundleAnalyzerReporter.js +192 -0

package/lib/BundleAnalyzerReporter.js ADDED Viewed

@@ -0,0 +1,167 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+function _assert() {
+  const data = _interopRequireDefault(require("assert"));
+  _assert = function () {
+    return data;
+  };
+  return data;
+}
+function _plugin() {
+  const data = require("@atlaspack/plugin");
+  _plugin = function () {
+    return data;
+  };
+  return data;
+}
+function _utils() {
+  const data = require("@atlaspack/utils");
+  _utils = function () {
+    return data;
+  };
+  return data;
+}
+function _path() {
+  const data = _interopRequireDefault(require("path"));
+  _path = function () {
+    return data;
+  };
+  return data;
+}
+function _nullthrows() {
+  const data = _interopRequireDefault(require("nullthrows"));
+  _nullthrows = function () {
+    return data;
+  };
+  return data;
+}
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+var _default = exports.default = new (_plugin().Reporter)({
+  async report({
+    event,
+    options
+  }) {
+    if (event.type !== 'buildSuccess') {
+      return;
+    }
+    let bundlesByTarget = new (_utils().DefaultMap)(() => []);
+    for (let bundle of event.bundleGraph.getBundles()) {
+      bundlesByTarget.get(bundle.target.name).push(bundle);
+    }
+    let reportsDir = _path().default.join(options.projectRoot, 'atlaspack-bundle-reports');
+    await options.outputFS.mkdirp(reportsDir);
+    await Promise.all([...bundlesByTarget.entries()].map(async ([targetName, bundles]) => {
+      return options.outputFS.writeFile(_path().default.join(reportsDir, `${targetName}.html`), `
+          <html>
+            <head>
+              <meta charset="utf-8">
+              <title>📦Atlaspack Bundle Analyzer | ${targetName}</title>
+              <style>
+                body {
+                  margin: 0;
+                }
+                .tooltip {
+                  background-color: rgba(255, 255, 255, 0.7);
+                  left: 0;
+                  padding: 20px;
+                  pointer-events: none;
+                  position: absolute;
+                  top: 0;
+                  transform: translate3d(0, 0, 0);
+                }
+                .tooltip-content {
+                  font-family: monospace;
+                }
+                .tooltip-content dl div {
+                  display: flex;
+                }
+                .tooltip-title {
+                  font-size: 18px;
+                }
+              </style>
+              <script>
+                ${await options.inputFS.readFile(_path().default.resolve(__dirname, '../client/vendor/foamtree/carrotsearch.foamtree.js'), 'utf8')}
+              </script>
+              <script id="bundle-data" type="application/json">
+                ${JSON.stringify(await getBundleData(bundles, options))}
+              </script>
+            </head>
+            <body>
+              <script>
+                ${await options.inputFS.readFile(_path().default.resolve(__dirname, '../client/index.js'), 'utf8')}
+              </script>
+            </body>
+          </html>
+        `);
+    }));
+  }
+});
+async function getBundleData(bundles, options) {
+  let groups = await Promise.all(bundles.map(bundle => getBundleNode(bundle, options)));
+  return {
+    groups
+  };
+}
+let createMap = () => new (_utils().DefaultMap)(() => createMap());
+async function getBundleNode(bundle, options) {
+  let buildMetrics = await (0, _utils().generateBuildMetrics)([bundle], options.outputFS, options.projectRoot);
+  let bundleData = buildMetrics.bundles[0];
+  let dirMap = createMap();
+  for (let asset of bundleData.assets) {
+    let relativePath = _path().default.relative(options.projectRoot, asset.filePath);
+    let parts = relativePath.split(_path().default.sep);
+    let dirs = parts.slice(0, parts.length - 1);
+    let basename = _path().default.basename(asset.filePath);
+    let map = dirMap;
+    for (let dir of dirs) {
+      (0, _assert().default)(map instanceof _utils().DefaultMap);
+      map = map.get(dir);
+    }
+    (0, _assert().default)(map instanceof _utils().DefaultMap);
+    map.set(basename, {
+      basename,
+      size: asset.size
+    });
+  }
+  return {
+    label: _path().default.relative(options.projectRoot, bundle.filePath),
+    weight: bundle.stats.size,
+    groups: generateGroups(dirMap)
+  };
+}
+function generateGroups(dirMap) {
+  let groups = [];
+  for (let [directoryName, contents] of dirMap) {
+    if (contents instanceof _utils().DefaultMap) {
+      let childrenGroups = generateGroups(contents);
+      if (childrenGroups.length === 1) {
+        let firstChild = childrenGroups[0];
+        groups.push({
+          ...firstChild,
+          label: _path().default.join(directoryName, firstChild.label)
+        });
+      } else {
+        groups.push({
+          label: directoryName,
+          weight: childrenGroups.reduce((acc, g) => acc + (0, _nullthrows().default)(g.weight), 0),
+          groups: childrenGroups
+        });
+      }
+    } else {
+      // file
+      groups.push({
+        label: contents.basename === '' ? 'Code from unknown source files' : contents.basename,
+        weight: contents.size
+      });
+    }
+  }
+  return groups;
+}

package/package.json ADDED Viewed

@@ -0,0 +1,27 @@
+{
+  "name": "@atlaspack/reporter-bundle-analyzer",
+  "version": "2.12.1-canary.3354+7bb54d46a",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/atlassian-labs/atlaspack.git"
+  },
+  "main": "lib/BundleAnalyzerReporter.js",
+  "source": "src/BundleAnalyzerReporter.js",
+  "engines": {
+    "node": ">= 16.0.0",
+    "atlaspack": "2.12.1-canary.3354+7bb54d46a"
+  },
+  "dependencies": {
+    "@atlaspack/plugin": "2.12.1-canary.3354+7bb54d46a",
+    "@atlaspack/utils": "2.12.1-canary.3354+7bb54d46a",
+    "nullthrows": "^1.1.1"
+  },
+  "devDependencies": {
+    "@atlaspack/types": "2.12.1-canary.3354+7bb54d46a"
+  },
+  "gitHead": "7bb54d46a00c5ba9cdbc2ee426dcbe82c8d79a3e"
+}

package/src/BundleAnalyzerReporter.js ADDED Viewed

@@ -0,0 +1,192 @@
+// @flow strict-local
+import type {FilePath, PackagedBundle, PluginOptions} from '@atlaspack/types';
+import invariant from 'assert';
+import {Reporter} from '@atlaspack/plugin';
+import {DefaultMap, generateBuildMetrics} from '@atlaspack/utils';
+import path from 'path';
+import nullthrows from 'nullthrows';
+export default (new Reporter({
+  async report({event, options}) {
+    if (event.type !== 'buildSuccess') {
+      return;
+    }
+    let bundlesByTarget: DefaultMap<
+      string /* target name */,
+      Array<PackagedBundle>,
+    > = new DefaultMap(() => []);
+    for (let bundle of event.bundleGraph.getBundles()) {
+      bundlesByTarget.get(bundle.target.name).push(bundle);
+    }
+    let reportsDir = path.join(options.projectRoot, 'atlaspack-bundle-reports');
+    await options.outputFS.mkdirp(reportsDir);
+    await Promise.all(
+      [...bundlesByTarget.entries()].map(async ([targetName, bundles]) => {
+        return options.outputFS.writeFile(
+          path.join(reportsDir, `${targetName}.html`),
+          `
+          <html>
+            <head>
+              <meta charset="utf-8">
+              <title>📦Atlaspack Bundle Analyzer | ${targetName}</title>
+              <style>
+                body {
+                  margin: 0;
+                }
+                .tooltip {
+                  background-color: rgba(255, 255, 255, 0.7);
+                  left: 0;
+                  padding: 20px;
+                  pointer-events: none;
+                  position: absolute;
+                  top: 0;
+                  transform: translate3d(0, 0, 0);
+                }
+                .tooltip-content {
+                  font-family: monospace;
+                }
+                .tooltip-content dl div {
+                  display: flex;
+                }
+                .tooltip-title {
+                  font-size: 18px;
+                }
+              </style>
+              <script>
+                ${await options.inputFS.readFile(
+                  path.resolve(
+                    __dirname,
+                    '../client/vendor/foamtree/carrotsearch.foamtree.js',
+                  ),
+                  'utf8',
+                )}
+              </script>
+              <script id="bundle-data" type="application/json">
+                ${JSON.stringify(await getBundleData(bundles, options))}
+              </script>
+            </head>
+            <body>
+              <script>
+                ${await options.inputFS.readFile(
+                  path.resolve(__dirname, '../client/index.js'),
+                  'utf8',
+                )}
+              </script>
+            </body>
+          </html>
+        `,
+        );
+      }),
+    );
+  },
+}): Reporter);
+type BundleData = {|
+  groups: Array<Group>,
+|};
+async function getBundleData(
+  bundles: Array<PackagedBundle>,
+  options: PluginOptions,
+): Promise<BundleData> {
+  let groups = await Promise.all(
+    bundles.map(bundle => getBundleNode(bundle, options)),
+  );
+  return {
+    groups,
+  };
+}
+type File = {|
+  basename: string,
+  size: number,
+|};
+type DirMapValue = File | DirMap;
+type DirMap = DefaultMap<FilePath, DirMapValue>;
+let createMap: () => DirMap = () => new DefaultMap(() => createMap());
+async function getBundleNode(bundle: PackagedBundle, options: PluginOptions) {
+  let buildMetrics = await generateBuildMetrics(
+    [bundle],
+    options.outputFS,
+    options.projectRoot,
+  );
+  let bundleData = buildMetrics.bundles[0];
+  let dirMap = createMap();
+  for (let asset of bundleData.assets) {
+    let relativePath = path.relative(options.projectRoot, asset.filePath);
+    let parts = relativePath.split(path.sep);
+    let dirs = parts.slice(0, parts.length - 1);
+    let basename = path.basename(asset.filePath);
+    let map = dirMap;
+    for (let dir of dirs) {
+      invariant(map instanceof DefaultMap);
+      map = map.get(dir);
+    }
+    invariant(map instanceof DefaultMap);
+    map.set(basename, {
+      basename,
+      size: asset.size,
+    });
+  }
+  return {
+    label: path.relative(options.projectRoot, bundle.filePath),
+    weight: bundle.stats.size,
+    groups: generateGroups(dirMap),
+  };
+}
+type Group = {|
+  label: string,
+  weight: number,
+  groups?: Array<Group>,
+|};
+function generateGroups(dirMap: DirMap): Array<Group> {
+  let groups = [];
+  for (let [directoryName, contents] of dirMap) {
+    if (contents instanceof DefaultMap) {
+      let childrenGroups = generateGroups(contents);
+      if (childrenGroups.length === 1) {
+        let firstChild = childrenGroups[0];
+        groups.push({
+          ...firstChild,
+          label: path.join(directoryName, firstChild.label),
+        });
+      } else {
+        groups.push({
+          label: directoryName,
+          weight: childrenGroups.reduce(
+            (acc, g) => acc + nullthrows(g.weight),
+            0,
+          ),
+          groups: childrenGroups,
+        });
+      }
+    } else {
+      // file
+      groups.push({
+        label:
+          contents.basename === ''
+            ? 'Code from unknown source files'
+            : contents.basename,
+        weight: contents.size,
+      });
+    }
+  }
+  return groups;
+}