@henderea/static-site-builder 1.9.5 → 1.9.10

package/config/webpack.config.prod.js

@@ -1,26 +1,26 @@
-const path = require('path');
-const fs = require('fs');
-const webpack = require('webpack');
-const HtmlWebpackPlugin = require('html-webpack-plugin');
-const CaseSensitivePathsPlugin = require('case-sensitive-paths-webpack-plugin');
-const MiniCssExtractPlugin = require('mini-css-extract-plugin');
-const { WebpackManifestPlugin } = require('webpack-manifest-plugin');
-const CopyPlugin = require('copy-webpack-plugin');
-const { GenerateSW } = require('workbox-webpack-plugin');
-const TsconfigPathsPlugin = require('tsconfig-paths-webpack-plugin');
-const MomentLocalesPlugin = require('moment-locales-webpack-plugin');
-const getClientEnvironment = require('./env');
-const paths = require('./paths');
-const _ = require('lodash');
-const crypto = require('crypto');
-const globby = require('globby');
+import path from 'path';
+import fs from 'fs';
+import webpack from 'webpack';
+import HtmlWebpackPlugin from 'html-webpack-plugin';
+import CaseSensitivePathsPlugin from 'case-sensitive-paths-webpack-plugin';
+import MiniCssExtractPlugin from 'mini-css-extract-plugin';
+import { WebpackManifestPlugin } from 'webpack-manifest-plugin';
+import CopyPlugin from 'copy-webpack-plugin';
+import { GenerateSW } from 'workbox-webpack-plugin';
+import TsconfigPathsPlugin from 'tsconfig-paths-webpack-plugin';
+import MomentLocalesPlugin from 'moment-locales-webpack-plugin';
+import getClientEnvironment from './env';
+import * as paths from './paths';
+import _ from 'lodash';
+import crypto from 'crypto';
+import { globbySync } from 'globby';
 
 // Webpack uses `publicPath` to determine where the app is being served from.
 // It requires a trailing slash, or the file assets will get an incorrect path.
 let publicPath = paths.servedPath;
 // Some apps do not use client-side routing with pushState.
 // For these, "homepage" can be set to "." to enable relative asset paths.
-const shouldUseRelativeAssetPaths = publicPath === './';
+// const shouldUseRelativeAssetPaths = publicPath === './';
 // `publicUrl` is just like `publicPath`, but we will provide it to our app
 // as %PUBLIC_URL% in `index.html` and `process.env.PUBLIC_URL` in JavaScript.
 // Omit trailing slash as %PUBLIC_URL%/xyz looks better than %PUBLIC_URL%xyz.
@@ -30,339 +30,339 @@ let env = getClientEnvironment(publicUrl);
 
 const cssFilename = '[name].css';
 
-const getRevision = file => crypto.createHash('md5').update(fs.readFileSync(file)).digest('hex')
+const getRevision = (file) => crypto.createHash('md5').update(fs.readFileSync(file)).digest('hex');
 
 let additionalManifestEntries = undefined;
 
 if(fs.existsSync(paths.publicDir)) {
-    additionalManifestEntries = globby.sync(['**/*', '!asset-manifest.json', '!service-worker.js'], { cwd: paths.publicDir }).map(f => ({ url: `${publicUrl}/${f}`, revision: getRevision(path.join(paths.publicDir, f)) }));
+  additionalManifestEntries = globbySync(['**/*', '!asset-manifest.json', '!service-worker.js'], { cwd: paths.publicDir }).map((f) => ({ url: `${publicUrl}/${f}`, revision: getRevision(path.join(paths.publicDir, f)) }));
 }
 
 let ssbConfig = {};
 
 if(fs.existsSync(paths.ssbConfig)) {
-    let ssbConfigObj = require(paths.ssbConfig);
-    if(ssbConfigObj) {
-        if(_.isFunction(ssbConfigObj)) {
-            ssbConfig = ssbConfigObj(env.raw, 'production', { publicUrl, ...paths });
-        } else if(_.isPlainObject(ssbConfigObj)) {
-            if(_.has(ssbConfigObj, 'prod')) {
-                ssbConfig = _.get(ssbConfigObj, 'prod');
-            } else if(_.has(ssbConfigObj, 'production')) {
-                ssbConfig = _.get(ssbConfigObj, 'production');
-            } else {
-                ssbConfig = ssbConfigObj;
-            }
-        }
+  let ssbConfigObj = require(paths.ssbConfig);
+  if(ssbConfigObj) {
+    if(_.isFunction(ssbConfigObj)) {
+      ssbConfig = ssbConfigObj(env.raw, 'production', { publicUrl, ...paths });
+    } else if(_.isPlainObject(ssbConfigObj)) {
+      if(_.has(ssbConfigObj, 'prod')) {
+        ssbConfig = _.get(ssbConfigObj, 'prod');
+      } else if(_.has(ssbConfigObj, 'production')) {
+        ssbConfig = _.get(ssbConfigObj, 'production');
+      } else {
+        ssbConfig = ssbConfigObj;
+      }
     }
+  }
 }
 
 ssbConfig = ssbConfig || {};
 
 if(ssbConfig.env && _.isPlainObject(ssbConfig.env)) {
-    const raw = _.extend({}, env.raw, ssbConfig.env);
-    const stringified = {
-        'process.env': Object.keys(raw).reduce((env, key) => {
-            env[key] = JSON.stringify(raw[key]);
-            return env;
-        }, {}),
-    };
-    env = { raw, stringified };
+  const raw = _.extend({}, env.raw, ssbConfig.env);
+  const stringified = {
+    'process.env': Object.keys(raw).reduce((env, key) => {
+      env[key] = JSON.stringify(raw[key]);
+      return env;
+    }, {}),
+  };
+  env = { raw, stringified };
 }
 
 if(ssbConfig.additionalManifestEntries && _.isArray(ssbConfig.additionalManifestEntries)) {
-    additionalManifestEntries.push(...ssbConfig.additionalManifestEntries);
+  additionalManifestEntries.push(...ssbConfig.additionalManifestEntries);
 }
 
 let runtimeCaching = require('./cache-config');
 
 if(ssbConfig.runtimeCaching && _.isArray(ssbConfig.runtimeCaching)) {
-    runtimeCaching = ssbConfig.runtimeCaching;
+  runtimeCaching = ssbConfig.runtimeCaching;
 }
 
 runtimeCaching.unshift({
-    urlPattern: publicPath,
-    handler: 'NetworkFirst',
-    options: {
-        cacheName: 'start-url',
-        expiration: {
-            maxEntries: 1,
-            maxAgeSeconds: 24 * 60 * 60 // 24 hours
-        }
+  urlPattern: publicPath,
+  handler: 'NetworkFirst',
+  options: {
+    cacheName: 'start-url',
+    expiration: {
+      maxEntries: 1,
+      maxAgeSeconds: 24 * 60 * 60 // 24 hours
     }
+  }
 });
 
 let htmlWebpackPluginOptions = {
-    filename: 'index.html',
-    template: paths.appTemplate,
-    inject: 'head',
-    minify: { collapseWhitespace: true }
+  filename: 'index.html',
+  template: paths.appTemplate,
+  inject: 'head',
+  minify: { collapseWhitespace: true }
 };
 
 if(ssbConfig.htmlWebpackPluginOptions && _.isPlainObject(ssbConfig.htmlWebpackPluginOptions)) {
-    htmlWebpackPluginOptions = _.extend({}, htmlWebpackPluginOptions, ssbConfig.htmlWebpackPluginOptions);
+  htmlWebpackPluginOptions = _.extend({}, htmlWebpackPluginOptions, ssbConfig.htmlWebpackPluginOptions);
 }
 
 const plugins = [
-    new webpack.DefinePlugin(env.stringified),
-    new HtmlWebpackPlugin(htmlWebpackPluginOptions),
-    new CaseSensitivePathsPlugin(),
-    new MiniCssExtractPlugin({
-        filename: cssFilename
-    }),
-    new WebpackManifestPlugin({
-        fileName: 'asset-manifest.json',
-        publicPath,
-        filter(file) {
-            if(/^[/]?[.]{2}[/]?/.test(file.path)) { return false; }
-            if(/\.ts$/.test(file.path)) { return false; }
-            if(/(^|[/])\./.test(file.name)) { return false; }
-            return true;
-        }
-    }),
-    new GenerateSW({
-        // Don't precache sourcemaps (they're large) and build asset manifest:
-        exclude: [/\.map$/, /asset-manifest\.json$/, /^[/]?[.]{2}/, /.ts$/],
-        // `navigateFallback` and `navigateFallbackWhitelist` are disabled by default; see
-        // https://github.com/facebook/create-react-app/blob/master/packages/react-scripts/template/README.md#service-worker-considerations
-        navigateFallback: publicUrl + '/index.html',
-        navigateFallbackDenylist: [/^\/_/],
-        additionalManifestEntries,
-        cleanupOutdatedCaches: true,
-        clientsClaim: true,
-        skipWaiting: true,
-        runtimeCaching,
-    }),
+  new webpack.DefinePlugin(env.stringified),
+  new HtmlWebpackPlugin(htmlWebpackPluginOptions),
+  new CaseSensitivePathsPlugin(),
+  new MiniCssExtractPlugin({
+    filename: cssFilename
+  }),
+  new WebpackManifestPlugin({
+    fileName: 'asset-manifest.json',
+    publicPath,
+    filter(file) {
+      if(/^[/]?[.]{2}[/]?/.test(file.path)) { return false; }
+      if(/\.ts$/.test(file.path)) { return false; }
+      if(/(^|[/])\./.test(file.name)) { return false; }
+      return true;
+    }
+  }),
+  new GenerateSW({
+    // Don't precache sourcemaps (they're large) and build asset manifest:
+    exclude: [/\.map$/, /asset-manifest\.json$/, /^[/]?[.]{2}/, /.ts$/],
+    // `navigateFallback` and `navigateFallbackWhitelist` are disabled by default; see
+    // https://github.com/facebook/create-react-app/blob/master/packages/react-scripts/template/README.md#service-worker-considerations
+    navigateFallback: publicUrl + '/index.html',
+    navigateFallbackDenylist: [/^\/_/],
+    additionalManifestEntries,
+    cleanupOutdatedCaches: true,
+    clientsClaim: true,
+    skipWaiting: true,
+    runtimeCaching,
+  }),
 ];
 
 if(ssbConfig.plugins && _.isArray(ssbConfig.plugins)) {
-    plugins.push(...ssbConfig.plugins);
+  plugins.push(...ssbConfig.plugins);
 }
 
 const copyPatterns = [];
 
 if(fs.existsSync(paths.publicDir)) {
-    copyPatterns.push({
-        from: paths.publicDir,
-        to: paths.appDist
-    });
+  copyPatterns.push({
+    from: paths.publicDir,
+    to: paths.appDist
+  });
 }
 
 if(ssbConfig.copyPatterns && _.isArray(ssbConfig.copyPatterns)) {
-    copyPatterns.push(...ssbConfig.copyPatterns);
+  copyPatterns.push(...ssbConfig.copyPatterns);
 }
 
 if(copyPatterns.length > 0) {
-    plugins.push(new CopyPlugin({
-        patterns: copyPatterns
-    }));
+  plugins.push(new CopyPlugin({
+    patterns: copyPatterns
+  }));
 }
 
 let tsConfigPath = paths.tsConfig;
 
 if(ssbConfig.tsConfigPath && fs.existsSync(paths.resolveApp(ssbConfig.tsConfigPath))) {
-    tsConfigPath = paths.resolveApp(ssbConfig.tsConfigPath);
+  tsConfigPath = paths.resolveApp(ssbConfig.tsConfigPath);
 }
 
 const resolvePlugins = [];
 
 if(fs.existsSync(tsConfigPath)) {
-    resolvePlugins.push(new TsconfigPathsPlugin({ configFile: tsConfigPath }));
+  resolvePlugins.push(new TsconfigPathsPlugin({ configFile: tsConfigPath }));
 }
 
 let appIndex = paths.appIndex;
 
 if(ssbConfig.appIndex && fs.existsSync(paths.resolveApp(appIndex))) {
-    appIndex = paths.resolveApp(appIndex);
+  appIndex = paths.resolveApp(appIndex);
 }
 
 const packageJson = require(paths.appPackageJson);
 const config = _.extend({}, packageJson.staticSiteBuilderConfig || {}, ssbConfig);
 const rawMomentLocales = config && config.momentLocales;
 if(rawMomentLocales === '') {
-    plugins.push(new MomentLocalesPlugin());
+  plugins.push(new MomentLocalesPlugin());
 } else if(rawMomentLocales) {
-    plugins.push(new MomentLocalesPlugin({ localesToKeep: rawMomentLocales.split(/\s*,\s*/g) }));
+  plugins.push(new MomentLocalesPlugin({ localesToKeep: rawMomentLocales.split(/\s*,\s*/g) }));
 }
 
 const performance = {};
 
 if(config && (config.sizeHints === false || config.sizeHints == 'warning' || config.sizeHints == 'error')) {
-    performance.hints = config.sizeHints;
+  performance.hints = config.sizeHints;
 }
 
-const getSizeValue = val => {
-    if(_.isNil(val) || val === false) { return null; }
-    if(_.isNumber(val) && !_.isNaN(val)) { return Math.round(val); }
-    if(_.isString(val)) {
-        let m = val.match(/^(\d+(?:\.\d+)?|\.\d+)([bkmg])?$/i);
-        if(m) {
-            let num = parseFloat(m[1]);
-            if(!_.isNaN(num)) {
-                let unit = m[2];
-                if(!unit || unit === '') { unit = 'b'; }
-                unit = unit.toLowerCase();
-                let unitIndex = 'bkmg'.indexOf(unit);
-                if(unitIndex >= 0 || unitIndex <= 3) {
-                    return Math.round(num * Math.pow(1024, unitIndex));
-                }
-            }
+const getSizeValue = (val) => {
+  if(_.isNil(val) || val === false) { return null; }
+  if(_.isNumber(val) && !_.isNaN(val)) { return Math.round(val); }
+  if(_.isString(val)) {
+    let m = val.match(/^(\d+(?:\.\d+)?|\.\d+)([bkmg])?$/i);
+    if(m) {
+      let num = parseFloat(m[1]);
+      if(!_.isNaN(num)) {
+        let unit = m[2];
+        if(!unit || unit === '') { unit = 'b'; }
+        unit = unit.toLowerCase();
+        let unitIndex = 'bkmg'.indexOf(unit);
+        if(unitIndex >= 0 || unitIndex <= 3) {
+          return Math.round(num * Math.pow(1024, unitIndex));
         }
+      }
     }
-    return null;
-}
+  }
+  return null;
+};
 
 let maxEntrypointSize = getSizeValue(config && config.maxEntrypointSize);
 
 if(config && maxEntrypointSize) {
-    performance.maxEntrypointSize = maxEntrypointSize;
+  performance.maxEntrypointSize = maxEntrypointSize;
 }
 
 let maxAssetSize = getSizeValue(config && config.maxAssetSize);
 
 if(config && maxAssetSize) {
-    performance.maxAssetSize = maxAssetSize;
+  performance.maxAssetSize = maxAssetSize;
 }
 
 const extraLoaders = [];
 
 if(ssbConfig.extraLoaders && _.isArray(ssbConfig.extraLoaders)) {
-    extraLoaders.push(...ssbConfig.extraLoaders);
+  extraLoaders.push(...ssbConfig.extraLoaders);
 }
 
 module.exports = _.defaultsDeep({}, ssbConfig.webpack || {}, {
-    mode: 'production',
-    entry: {
-        index: appIndex
-    },
-    devtool: 'source-map',
-    output: {
-        pathinfo: true,
-        path: paths.appDist,
-        publicPath: publicPath
-    },
-    resolve: {
-        modules: ['node_modules'].concat(
-            // It is guaranteed to exist because we tweak it in `env.js`
-            process.env.NODE_PATH.split(path.delimiter).filter(Boolean)
-        ),
-        extensions: ['.js', '.ts', '.json'],
-        plugins: resolvePlugins,
-        roots: [paths.appPath, paths.publicDir],
-    },
-    module: {
-        strictExportPresence: true,
-        rules: [
-            {
-                test: /\.[tj]s$/,
-                parser: { requireEnsure: false }
-            },
-            {
-                oneOf: [
-                    ...extraLoaders,
-                    {
-                        test: /\.ts$/,
-                        exclude: [/[/\\\\]node_modules[/\\\\]/],
-                        use: [
-                            {
-                                loader: require.resolve('ts-loader'),
-                                options: {
-                                    configFile: tsConfigPath
-                                },
-                            },
-                        ]
-                    },
-                    {
-                        test: /\.js$/,
-                        exclude: [/[/\\\\]node_modules[/\\\\]/],
-                        use: [
-                            require.resolve('thread-loader'),
-                            {
-                                loader: require.resolve('babel-loader'),
-                                options: {
-                                    babelrc: false,
-                                    compact: true,
-                                    highlightCode: true,
-                                },
-                            },
-                        ]
-                    },
-                    {
-                        test: /\.js$/,
-                        use: [
-                            require.resolve('thread-loader'),
-                            {
-                                loader: require.resolve('babel-loader'),
-                                options: {
-                                    babelrc: false,
-                                    compact: false,
-                                    // This is a feature of `babel-loader` for webpack (not Babel itself).
-                                    // It enables caching results in ./node_modules/.cache/babel-loader/
-                                    // directory for faster rebuilds.
-                                    cacheDirectory: true,
-                                    highlightCode: true,
-                                },
-                            },
-                        ]
-                    },
-                    {
-                        test: /\.css$/,
-                        use: [
-                            MiniCssExtractPlugin.loader,
-                            {
-                                loader: 'css-loader',
-                                options: {
-                                    sourceMap: true,
-                                }
-                            }
-                        ]
-                    },
-                    {
-                        test: /\.scss$/,
-                        use: [
-                            MiniCssExtractPlugin.loader,
-                            {
-                                loader: 'css-loader',
-                                options: {
-                                    importLoaders: 1,
-                                    sourceMap: true,
-                                }
-                            },
-                            {
-                                loader: 'postcss-loader',
-                                options: {
-                                    postcssOptions: {
-                                        plugins: ['postcss-preset-env']
-                                    },
-                                    sourceMap: true
-                                }
-                            },
-                            {
-                                loader: 'sass-loader',
-                                options: {
-                                    sassOptions: {
-                                        outputStyle: 'compressed'
-                                    },
-                                    sourceMap: true
-                                }
-                            }
-                        ]
-                    },
-                    {
-                        loader: require.resolve('file-loader'),
-                        // Exclude `js` files to keep "css" loader working as it injects
-                        // its runtime that would otherwise processed through "file" loader.
-                        // Also exclude `html` and `json` extensions so they get processed
-                        // by webpack's internal loaders.
-                        exclude: [/\.js$/, /\.ts$/, /\.html$/, /\.ejs$/, /\.hbs$/, /\.json$/],
-                        options: {
-                            name: '[name].[ext]'
-                        }
-                    }
-                ]
+  mode: 'production',
+  entry: {
+    index: appIndex
+  },
+  devtool: 'source-map',
+  output: {
+    pathinfo: true,
+    path: paths.appDist,
+    publicPath: publicPath
+  },
+  resolve: {
+    modules: ['node_modules'].concat(
+      // It is guaranteed to exist because we tweak it in `env.js`
+      process.env.NODE_PATH.split(path.delimiter).filter(Boolean)
+    ),
+    extensions: ['.js', '.ts', '.json'],
+    plugins: resolvePlugins,
+    roots: [paths.appPath, paths.publicDir],
+  },
+  module: {
+    strictExportPresence: true,
+    rules: [
+      {
+        test: /\.[tj]s$/,
+        parser: { requireEnsure: false }
+      },
+      {
+        oneOf: [
+          ...extraLoaders,
+          {
+            test: /\.ts$/,
+            exclude: [/[/\\\\]node_modules[/\\\\]/],
+            use: [
+              {
+                loader: require.resolve('ts-loader'),
+                options: {
+                  configFile: tsConfigPath
+                },
+              },
+            ]
+          },
+          {
+            test: /\.js$/,
+            exclude: [/[/\\\\]node_modules[/\\\\]/],
+            use: [
+              require.resolve('thread-loader'),
+              {
+                loader: require.resolve('babel-loader'),
+                options: {
+                  babelrc: false,
+                  compact: true,
+                  highlightCode: true,
+                },
+              },
+            ]
+          },
+          {
+            test: /\.js$/,
+            use: [
+              require.resolve('thread-loader'),
+              {
+                loader: require.resolve('babel-loader'),
+                options: {
+                  babelrc: false,
+                  compact: false,
+                  // This is a feature of `babel-loader` for webpack (not Babel itself).
+                  // It enables caching results in ./node_modules/.cache/babel-loader/
+                  // directory for faster rebuilds.
+                  cacheDirectory: true,
+                  highlightCode: true,
+                },
+              },
+            ]
+          },
+          {
+            test: /\.css$/,
+            use: [
+              MiniCssExtractPlugin.loader,
+              {
+                loader: 'css-loader',
+                options: {
+                  sourceMap: true,
+                }
+              }
+            ]
+          },
+          {
+            test: /\.scss$/,
+            use: [
+              MiniCssExtractPlugin.loader,
+              {
+                loader: 'css-loader',
+                options: {
+                  importLoaders: 1,
+                  sourceMap: true,
+                }
+              },
+              {
+                loader: 'postcss-loader',
+                options: {
+                  postcssOptions: {
+                    plugins: ['postcss-preset-env']
+                  },
+                  sourceMap: true
+                }
+              },
+              {
+                loader: 'sass-loader',
+                options: {
+                  sassOptions: {
+                    outputStyle: 'compressed'
+                  },
+                  sourceMap: true
+                }
+              }
+            ]
+          },
+          {
+            loader: require.resolve('file-loader'),
+            // Exclude `js` files to keep "css" loader working as it injects
+            // its runtime that would otherwise processed through "file" loader.
+            // Also exclude `html` and `json` extensions so they get processed
+            // by webpack's internal loaders.
+            exclude: [/\.js$/, /\.ts$/, /\.html$/, /\.ejs$/, /\.hbs$/, /\.json$/],
+            options: {
+              name: '[name].[ext]'
             }
+          }
         ]
-    },
-    plugins,
-    performance
-});
+      }
+    ]
+  },
+  plugins,
+  performance
+});