catalyst-core-internal 0.0.1-beta.0

package/webpack/base.babel.js

@@ -0,0 +1,165 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = exports.basePlugins = void 0;
+var _path = _interopRequireDefault(require("path"));
+var _webpack = _interopRequireDefault(require("webpack"));
+var _miniCssExtractPlugin = _interopRequireDefault(require("mini-css-extract-plugin"));
+var _webpackBundleAnalyzer = require("webpack-bundle-analyzer");
+var _webpackPlugin = _interopRequireDefault(require("@loadable/webpack-plugin"));
+var _scssParams = require("./scssParams");
+var _babelConfig = _interopRequireDefault(require("./babel.config.client"));
+var _babelConfig2 = _interopRequireDefault(require("./babel.config.ssr"));
+var _loadEnvironmentVariables = _interopRequireDefault(require("../scripts/loadEnvironmentVariables"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+const catalystConfig = require(_path.default.resolve(__dirname, "..", "config.json"));
+const {
+  CLIENT_ENV_VARIABLES: clientEnv,
+  ANALYZE_BUNDLE
+} = require(`${process.env.src_path}/config/config.json`);
+const {
+  _moduleAliases
+} = require(`${process.env.src_path}/package.json`);
+(0, _loadEnvironmentVariables.default)();
+const isDev = process.env.NODE_ENV === "development";
+const isSSR = !!process.env.SSR || false;
+const basePlugins = exports.basePlugins = [new _webpackPlugin.default({
+  filename: "loadable-stats.json",
+  writeToDisk: {
+    filename: _path.default.join(__dirname, "..")
+  }
+}),
+// **This loads process.env variable during webpack build process
+new _webpack.default.DefinePlugin({
+  "process.env": ([...clientEnv, ...Object.keys(process.env)] || []).reduce((clientEnvMap, env) => {
+    clientEnvMap[env] = JSON.stringify(process.env[env]);
+    return clientEnvMap;
+  }, {})
+}),
+// ** This is used to analyze bundle size.
+ANALYZE_BUNDLE && new _webpackBundleAnalyzer.BundleAnalyzerPlugin({
+  generateStatsFile: ANALYZE_BUNDLE
+}), new _webpack.default.IgnorePlugin({
+  resourceRegExp: /^\.\/locale$/,
+  contextRegExp: /moment$/
+})];
+const {
+  PUBLIC_STATIC_ASSET_URL,
+  PUBLIC_STATIC_ASSET_PATH
+} = process.env;
+let publicPath = `${PUBLIC_STATIC_ASSET_URL}${PUBLIC_STATIC_ASSET_PATH}`;
+var _default = exports.default = {
+  context: _path.default.resolve(process.env.src_path),
+  mode: isDev ? "development" : "production",
+  entry: {
+    app: [_path.default.resolve(process.env.src_path, "./client/index.js")]
+  },
+  output: {
+    path: _path.default.join(process.env.src_path, `${process.env.BUILD_OUTPUT_PATH}/public`),
+    chunkFilename: process.env.NODE_ENV === "development" ? catalystConfig.chunkFileNameDev : catalystConfig.chunkFileNameProd,
+    publicPath: publicPath,
+    chunkFilename: process.env.NODE_ENV === "development" ? catalystConfig.chunkFileNameDev : catalystConfig.chunkFileNameProd
+  },
+  resolve: {
+    fallback: {
+      url: require.resolve("url")
+    },
+    extensions: [".js", ".jsx", ".scss"],
+    alias: Object.keys(_moduleAliases || {}).reduce((moduleEnvMap, alias) => {
+      moduleEnvMap[alias] = _path.default.join(process.env.src_path, ..._moduleAliases[alias].split("/"));
+      return moduleEnvMap;
+    }, {})
+  },
+  plugins: basePlugins,
+  module: {
+    rules: [{
+      test: /\.jsx$|\.js$/,
+      exclude: _path.default.resolve(process.env.src_path, "./node_modules"),
+      use: {
+        loader: "babel-loader",
+        options: isSSR ? _babelConfig2.default : _babelConfig.default
+      }
+    }, {
+      // This loader processes all the .scss files that should be modularized. This should exclude anything inside node_modules and everything inside src/css/base since they should be globally scoped.
+      test: /\.scss$/,
+      exclude: [_path.default.resolve(process.env.src_path, "./node_modules"), _path.default.resolve(process.env.src_path, "./src/static/css/base")],
+      use: [isDev && "css-hot-loader", !isSSR && _miniCssExtractPlugin.default.loader, {
+        loader: "css-loader",
+        options: {
+          modules: {
+            mode: "local",
+            exportOnlyLocals: !isDev && isSSR,
+            localIdentName: isDev ? catalystConfig.cssModulesIdentifierDev : catalystConfig.cssModulesIdentifierProd
+          }
+        }
+      }, {
+        loader: "postcss-loader"
+      }, {
+        loader: "sass-loader",
+        options: {
+          additionalData: "$font_url: " + (0, _scssParams.fontUrl)() + ";" + "$url_for: " + (0, _scssParams.imageUrl)() + ";"
+        }
+      }, {
+        loader: "sass-resources-loader",
+        options: {
+          resources: [_path.default.resolve(process.env.src_path, "./src/static/css/resources/*.scss")]
+        }
+      }]
+    }, {
+      // In development mode, client request app.css ,which has all the css in node_modules and src/static/css/base, This is served by webpack-dev-server. However in prod this css is injected in the doc sent from the server and needs to be global, so we don't pass the files through css-loader to be modularized.
+      test: /\.scss$/,
+      include: [_path.default.resolve(process.env.src_path, "./node_modules"), _path.default.resolve(process.env.src_path, "./src/static/css/base")],
+      use: [isDev && "css-hot-loader", !isSSR && _miniCssExtractPlugin.default.loader, {
+        loader: "css-loader"
+      }, {
+        loader: "postcss-loader"
+      }, {
+        loader: "sass-loader",
+        options: {
+          additionalData: "$font_url: " + (0, _scssParams.fontUrl)() + ";" + "$url_for: " + (0, _scssParams.imageUrl)() + ";"
+        }
+      }, {
+        loader: "sass-resources-loader",
+        options: {
+          resources: [_path.default.resolve(process.env.src_path, "./src/static/css/resources/*.scss")]
+        }
+      }]
+    }, {
+      test: /\.css$/,
+      use: [!isSSR && _miniCssExtractPlugin.default.loader, "css-loader", "postcss-loader"]
+    }, {
+      test: /\.(png|jpg|gif|jpeg|ico?)$/,
+      use: ["url-loader?limit=10240", "img-loader"]
+    }, {
+      test: /\.svg$/i,
+      issuer: /\.[jt]sx?$/,
+      use: ["@svgr/webpack", "url-loader?limit=10240", "img-loader"]
+    }, {
+      // This loader loads fonts in src/static/fonts using file-loader
+      test: /\.(ttf|eot|woff2|json?)$/,
+      use: [{
+        loader: "url-loader",
+        options: {
+          limit: 10240,
+          outputPath: [_path.default.resolve(process.env.src_path, "./src/static/fonts/")]
+        }
+      }, "file-loader"]
+    }, {
+      // This loader loads html files
+      test: /\.html$/,
+      use: [{
+        loader: "html-loader",
+        options: {
+          minimize: {
+            minifyJS: true,
+            minifyCSS: true,
+            removeComments: false,
+            collapseWhitespace: true
+          }
+        }
+      }]
+    }]
+  }
+};

package/webpack/development.client.babel.js

@@ -0,0 +1,82 @@
+"use strict";
+
+var _path = _interopRequireDefault(require("path"));
+var _webpackDevServer = _interopRequireDefault(require("webpack-dev-server"));
+var _webpack = _interopRequireDefault(require("webpack"));
+var _webpackMerge = _interopRequireDefault(require("webpack-merge"));
+var _baseBabel = _interopRequireDefault(require("./base.babel.js"));
+var _reactRefreshWebpackPlugin = _interopRequireDefault(require("@pmmmwh/react-refresh-webpack-plugin"));
+var _miniCssExtractPlugin = _interopRequireDefault(require("mini-css-extract-plugin"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+/* eslint-disable no-console */
+
+const {
+  WEBPACK_DEV_SERVER_PORT,
+  WEBPACK_DEV_SERVER_HOSTNAME
+} = process.env;
+const catalystConfig = require(_path.default.resolve(__dirname, "..", "config.json"));
+const plugins = require(_path.default.join(process.env.src_path, "webpackConfig.js"));
+const webpackConfig = (0, _webpackMerge.default)(_baseBabel.default, {
+  devtool: "inline-source-map",
+  stats: "minimal",
+  plugins: [new _reactRefreshWebpackPlugin.default({
+    overlay: {
+      entry: false
+    }
+  }), new _miniCssExtractPlugin.default({
+    filename: catalystConfig.cssChunkFileName,
+    ignoreOrder: true
+  }), ...plugins.developmentPlugins].filter(Boolean),
+  optimization: {
+    runtimeChunk: "single",
+    moduleIds: "deterministic",
+    splitChunks: {
+      cacheGroups: {
+        commonVendor: {
+          test: /[\\/]node_modules[\\/](react|react-dom|react-redux|react-router|react-router-dom|redux|redux-thunk|axios|react-loadable-visibility|react-helmet-async|react-fast-compare|react-async-script|babel|@loadable\/component|catalyst)[\\/]/,
+          name: "commonVendor",
+          minSize: 30000
+        },
+        utilityVendor: {
+          maxInitialRequests: Infinity,
+          chunks: "all",
+          // minSize: 0, // Enable to replicate stand alone chunking for all packages
+          reuseExistingChunk: true,
+          // Disable to replicate stand alone chunking for all packages
+          minRemainingSize: 1000,
+          // Disable to replicate stand alone chunking for all packages
+          test: /[\\/]node_modules[\\/]/,
+          name(module) {
+            const moduleFileName = module.identifier().split("/").reduceRight(item => item);
+            return `npm.${moduleFileName}`;
+          }
+        }
+      }
+    }
+  }
+});
+console.info("Firing up catalyst dev server...\n");
+let devServer = new _webpackDevServer.default({
+  port: process.env.WEBPACK_DEV_SERVER_PORT,
+  host: process.env.WEBPACK_DEV_SERVER_HOSTNAME,
+  static: {
+    publicPath: webpackConfig.output.publicPath
+  },
+  hot: true,
+  historyApiFallback: true,
+  headers: {
+    "Access-Control-Allow-Origin": "*"
+  },
+  client: {
+    logging: "error",
+    overlay: {
+      errors: false,
+      warnings: false,
+      runtimeErrors: false
+    },
+    reconnect: true
+  }
+}, (0, _webpack.default)(webpackConfig));
+devServer.startCallback(() => {
+  console.info(`Webpack dev server mounted at http://${WEBPACK_DEV_SERVER_HOSTNAME}:${WEBPACK_DEV_SERVER_PORT}.`);
+});

package/webpack/plugins/mime-types.js

@@ -0,0 +1,82 @@
+"use strict";
+
+module.exports = {
+  m4a: "audio/mp4",
+  f4a: "audio/mp4",
+  f4b: "audio/mp4",
+  oga: "audio/ogg",
+  ogg: "audio/ogg",
+  mid: "audio/&",
+  midi: "audio/&",
+  mp3: "audio/&",
+  wav: "audio/&",
+  js: "application/javascript",
+  jsonp: "application/javascript",
+  json: "application/json",
+  doc: "application/msword",
+  dot: "application/msword",
+  bin: "application/octet-stream",
+  ai: "application/postscript",
+  pptx: "application/vnd.openxmlformats-officedocument.presentationml.presentation",
+  xlsx: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+  docx: "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+  xla: "application/vnd.ms-excel",
+  xls: "application/vnd.ms-excel",
+  xlt: "application/vnd.ms-excel",
+  eot: "application/vnd.ms-fontobject",
+  pot: "application/vnd.ms-powerpoint",
+  ppa: "application/vnd.ms-powerpoint",
+  pps: "application/vnd.ms-powerpoint",
+  ppt: "application/vnd.ms-powerpoint",
+  swf: "application/x-shockwave-flash",
+  atom: "application/xml",
+  rdf: "application/xml",
+  rss: "application/xml",
+  xml: "application/xml",
+  pdf: "application/&",
+  rtf: "application/&",
+  zip: "application/&",
+  otf: "font/opentype",
+  ttf: "font/&",
+  ttc: "font/&",
+  woff: "font/&",
+  jpe: "image/jpeg",
+  jpeg: "image/jpeg",
+  jpg: "image/jpeg",
+  svg: "image/svg+xml",
+  svgz: "image/svg+xml",
+  psd: "image/vnd.adobe.photoshop",
+  ico: "image/vnd.microsoft.icon",
+  bmp: "image/&",
+  ief: "image/&",
+  gif: "image/&",
+  png: "image/&",
+  tif: "image/&",
+  tiff: "image/&",
+  webp: "image/&",
+  appcache: "text/cache-manifest",
+  manifest: "text/cache-manifest",
+  txt: "text/plain",
+  htc: "text/x-component",
+  vcf: "text/x-vcard",
+  css: "text/&",
+  html: "text/&",
+  php: "text/&",
+  vtt: "text/&",
+  markdown: "text/x-&",
+  md: "text/x-&",
+  mp4: "video/mp4",
+  m4v: "video/mp4",
+  f4v: "video/mp4",
+  f4p: "video/mp4",
+  ogv: "video/ogg",
+  mov: "video/quicktime",
+  qt: "video/quicktime",
+  avi: "video/&",
+  mpg: "video/&",
+  vdo: "video/&",
+  viv: "video/&",
+  vivo: "video/&",
+  webm: "video/&",
+  flv: "video/x-&"
+};

package/webpack/plugins/route-manifest-copy.js

@@ -0,0 +1,122 @@
+"use strict";
+
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return typeof key === "symbol" ? key : String(key); }
+function _toPrimitive(input, hint) { if (typeof input !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (typeof res !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
+const NAME = "route-manifest-plugin";
+const fs = require("fs");
+const path = require("path");
+const acornLoose = require("acorn-loose");
+const zlib = require("zlib");
+const generateMappingToOrigin = (pathToRoutesFile, routesVariableName) => {
+  const fileContent = fs.readFileSync(path.resolve(pathToRoutesFile), "utf-8");
+  const ast = acornLoose.parse(fileContent, {
+    ecmaVersion: 2020
+  });
+  const routes = [];
+  const componentMapping = {};
+  const getValue = valueObj => {
+    switch (valueObj.type) {
+      case "Literal":
+        return valueObj.value;
+      case "Identifier":
+        return valueObj.name;
+      default:
+        return "";
+    }
+  };
+  ast.body.forEach(declarationBlock => {
+    declarationBlock?.declarations?.forEach(variableDeclaration => {
+      if (variableDeclaration?.id?.name === routesVariableName) {
+        const objectExpression = variableDeclaration?.init?.elements;
+        objectExpression.forEach(obj => {
+          const route = {};
+          obj?.properties.forEach(property => {
+            if (property) route[property.key.name] = getValue(property.value);
+          });
+          routes.push(route);
+        });
+      }
+      if (variableDeclaration?.init?.type === "CallExpression" && variableDeclaration?.init?.callee?.name === "loadable") {
+        const componentName = variableDeclaration?.id?.name;
+        const importArgument = variableDeclaration?.init?.arguments?.[0]; // import is first argument in loadable;
+        componentMapping[componentName] = importArgument?.body?.source?.value;
+      }
+    });
+  });
+  const mappedRoutes = routes.map(route => _objectSpread(_objectSpread({}, route), {}, {
+    origin: componentMapping[route.component] || ""
+  }));
+  return mappedRoutes;
+};
+const RoutesManifestPlugin = function (options) {
+  this.options = options;
+};
+RoutesManifestPlugin.prototype.run = function (bundle, options) {
+  const {
+    pathToRoutesFile,
+    routesVariableName
+  } = options;
+  const mappedRoutes = generateMappingToOrigin(pathToRoutesFile, routesVariableName);
+  const {
+    publicPath,
+    chunks
+  } = bundle.getStats().toJson();
+  const originToChunksMapping = {};
+  const originToChildrenMapping = {};
+  chunks.forEach(chunk => {
+    chunk.origins.forEach(origin => {
+      originToChunksMapping[origin.request] = [...(originToChunksMapping[origin.request] || []), ...chunk.files.map(file => `${publicPath}${file}`)];
+      chunk.children.forEach(childId => {
+        const chunk = chunks.find(chunk => chunk.id === childId);
+        originToChildrenMapping[origin.request] = [...(originToChildrenMapping[origin.request] || []), ...chunk.files.map(file => `${publicPath}${file}`)];
+      });
+    });
+  });
+  mappedRoutes.forEach(mappedRoute => {
+    mappedRoute.chunks = [...new Set(originToChunksMapping[mappedRoute.origin])];
+    mappedRoute.children = [...new Set(originToChildrenMapping[mappedRoute.origin])];
+  });
+  return mappedRoutes;
+};
+RoutesManifestPlugin.prototype.apply = function (compiler) {
+  if (compiler.hooks !== void 0) {
+    compiler.hooks.emit.tap(NAME, compilation => {
+      const assetsMappingJson = this.run(compilation, this.options);
+      const stringifiedAssetsMappingJson = JSON.stringify(assetsMappingJson);
+      const compressedGzip = zlib.gzipSync(stringifiedAssetsMappingJson);
+      const compressedBrotli = zlib.brotliCompressSync(stringifiedAssetsMappingJson);
+      compilation.assets["route-manifest.json.gz"] = {
+        source: function () {
+          return compressedGzip;
+        },
+        size: function () {
+          return compressedGzip.length;
+        }
+      };
+      compilation.assets["route-manifest.json.br"] = {
+        source: function () {
+          return compressedBrotli;
+        },
+        size: function () {
+          return compressedBrotli.length;
+        }
+      };
+      compilation.assets["route-manifest.json"] = {
+        source: function () {
+          return stringifiedAssetsMappingJson;
+        },
+        size: function () {
+          return stringifiedAssetsMappingJson.length;
+        }
+      };
+    });
+  } else {
+    compiler.plugin("emit", bundle => {
+      this.run(bundle, this.options);
+    });
+  }
+};
+module.exports = RoutesManifestPlugin;

package/webpack/plugins/route-manifest-plugin.js

@@ -0,0 +1,122 @@
+"use strict";
+
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return typeof key === "symbol" ? key : String(key); }
+function _toPrimitive(input, hint) { if (typeof input !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (typeof res !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
+const NAME = "route-manifest-plugin";
+const fs = require("fs");
+const path = require("path");
+const acornLoose = require("acorn-loose");
+const zlib = require("zlib");
+const generateMappingToOrigin = (pathToRoutesFile, routesVariableName) => {
+  const fileContent = fs.readFileSync(path.resolve(pathToRoutesFile), "utf-8");
+  const ast = acornLoose.parse(fileContent, {
+    ecmaVersion: 2020
+  });
+  const routes = [];
+  const componentMapping = {};
+  const getValue = valueObj => {
+    switch (valueObj.type) {
+      case "Literal":
+        return valueObj.value;
+      case "Identifier":
+        return valueObj.name;
+      default:
+        return "";
+    }
+  };
+  ast.body.forEach(declarationBlock => {
+    declarationBlock?.declarations?.forEach(variableDeclaration => {
+      if (variableDeclaration?.id?.name === routesVariableName) {
+        const objectExpression = variableDeclaration?.init?.elements;
+        objectExpression.forEach(obj => {
+          const route = {};
+          obj?.properties.forEach(property => {
+            if (property) route[property.key.name] = getValue(property.value);
+          });
+          routes.push(route);
+        });
+      }
+      if (variableDeclaration?.init?.type === "CallExpression" && variableDeclaration?.init?.callee?.name === "loadable") {
+        const componentName = variableDeclaration?.id?.name;
+        const importArgument = variableDeclaration?.init?.arguments?.[0]; // import is first argument in loadable;
+        componentMapping[componentName] = importArgument?.body?.source?.value;
+      }
+    });
+  });
+  const mappedRoutes = routes.map(route => _objectSpread(_objectSpread({}, route), {}, {
+    origin: componentMapping[route.component] || ""
+  }));
+  return mappedRoutes;
+};
+const RoutesManifestPlugin = function (options) {
+  this.options = options;
+};
+RoutesManifestPlugin.prototype.run = function (bundle, options) {
+  const {
+    pathToRoutesFile,
+    routesVariableName
+  } = options;
+  const mappedRoutes = generateMappingToOrigin(pathToRoutesFile, routesVariableName);
+  const {
+    publicPath,
+    chunks
+  } = bundle.getStats().toJson();
+  const originToChunksMapping = {};
+  const originToChildrenMapping = {};
+  chunks.forEach(chunk => {
+    chunk.origins.forEach(origin => {
+      originToChunksMapping[origin.request] = [...(originToChunksMapping[origin.request] || []), ...chunk.files.map(file => `${publicPath}${file}`)];
+      chunk.children.forEach(childId => {
+        const chunk = chunks.find(chunk => chunk.id === childId);
+        originToChildrenMapping[origin.request] = [...(originToChildrenMapping[origin.request] || []), ...chunk.files.map(file => `${publicPath}${file}`)];
+      });
+    });
+  });
+  mappedRoutes.forEach(mappedRoute => {
+    mappedRoute.chunks = [...new Set(originToChunksMapping[mappedRoute.origin])];
+    mappedRoute.children = [...new Set(originToChildrenMapping[mappedRoute.origin])];
+  });
+  return mappedRoutes;
+};
+RoutesManifestPlugin.prototype.apply = function (compiler) {
+  if (compiler.hooks !== void 0) {
+    compiler.hooks.emit.tap(NAME, compilation => {
+      const assetsMappingJson = this.run(compilation, this.options);
+      const stringifiedAssetsMappingJson = JSON.stringify(assetsMappingJson);
+      const compressedGzip = zlib.gzipSync(stringifiedAssetsMappingJson);
+      const compressedBrotli = zlib.brotliCompressSync(stringifiedAssetsMappingJson);
+      compilation.assets["route-manifest.json.gz"] = {
+        source: function () {
+          return compressedGzip;
+        },
+        size: function () {
+          return compressedGzip.length;
+        }
+      };
+      compilation.assets["route-manifest.json.br"] = {
+        source: function () {
+          return compressedBrotli;
+        },
+        size: function () {
+          return compressedBrotli.length;
+        }
+      };
+      compilation.assets["route-manifest.json"] = {
+        source: function () {
+          return stringifiedAssetsMappingJson;
+        },
+        size: function () {
+          return stringifiedAssetsMappingJson.length;
+        }
+      };
+    });
+  } else {
+    compiler.plugin("emit", bundle => {
+      this.run(bundle, this.options);
+    });
+  }
+};
+module.exports = RoutesManifestPlugin;