@apollion-dsi/scripts 0.7.7

package/src/config/webpack.config.js

@@ -0,0 +1,308 @@
+import path from 'path';
+
+import ForkTsCheckerWebpackPlugin from 'fork-ts-checker-webpack-plugin';
+import InlineChunkHtmlPlugin from '../utils/InlineChunkHtmlPlugin';
+import InterpolateHtmlPlugin from '../utils/InterpolateHtmlPlugin';
+import ModuleNotFoundPlugin from '../utils/ModuleNotFoundPlugin';
+import ModuleScopePlugin from '../utils/ModuleScopePlugin';
+import ReactRefreshWebpackPlugin from '@pmmmwh/react-refresh-webpack-plugin';
+import CaseSensitivePathsPlugin from 'case-sensitive-paths-webpack-plugin';
+import GitRevision from 'git-revision-webpack-plugin';
+import HtmlWebpackPlugin from 'html-webpack-plugin';
+import resolve from 'resolve';
+import TerserPlugin from 'terser-webpack-plugin';
+import TsconfigPathsPlugin from 'tsconfig-paths-webpack-plugin';
+import webpack from 'webpack';
+import { WebpackManifestPlugin } from 'webpack-manifest-plugin';
+
+import getClientEnvironment from './env';
+import modules from './modules';
+
+export default (webpackEnv, paths, options = {}) => {
+  const appPackageJson = require(paths.appPackageJson);
+
+  const GitRevisionPlugin = new GitRevision({ branch: true });
+
+  const shouldInlineRuntimeChunk = process.env.INLINE_RUNTIME_CHUNK !== 'false';
+
+  const imageInlineSizeLimit = parseInt(process.env.IMAGE_INLINE_SIZE_LIMIT || '10000');
+
+  const useTypeScript = true;
+
+  const hasJsxRuntime = (() => {
+    if (process.env.DISABLE_NEW_JSX_TRANSFORM === 'true') {
+      return false;
+    }
+    try {
+      require.resolve('react/jsx-runtime');
+      return true;
+    } catch (e) {
+      return false;
+    }
+  })();
+
+  const isEnvDevelopment = webpackEnv === 'development';
+  const isEnvProduction = webpackEnv === 'production';
+  const shouldUseSourceMap = isEnvDevelopment;
+
+  const isEnvProductionProfile = isEnvProduction && process.argv.includes('--profile');
+
+  const env = getClientEnvironment(paths.publicUrlOrPath.slice(0, -1), options);
+
+  const shouldUseReactRefresh = env.raw.FAST_REFRESH;
+
+  return {
+    mode: isEnvProduction ? 'production' : isEnvDevelopment && 'development',
+    bail: isEnvProduction,
+    devtool: isEnvProduction
+      ? shouldUseSourceMap
+        ? 'source-map'
+        : false
+      : isEnvDevelopment && 'cheap-module-source-map',
+    // WDS v5 injects the HMR client automatically — no need to prepend it here
+    entry: paths.appIndexJs,
+    output: {
+      path: isEnvProduction ? paths.appBuild : undefined,
+      pathinfo: isEnvDevelopment,
+      filename: isEnvProduction ? 'static/js/[name].[contenthash:8].js' : isEnvDevelopment && 'static/js/bundle.js',
+      chunkFilename: isEnvProduction
+        ? 'static/js/[name].[contenthash:8].chunk.js'
+        : isEnvDevelopment && 'static/js/[name].chunk.js',
+      publicPath: paths.publicUrlOrPath,
+      devtoolModuleFilenameTemplate: isEnvProduction
+        ? (info) => path.relative(paths.appSrc, info.absoluteResourcePath).replace(/\\/g, '/')
+        : isEnvDevelopment && ((info) => path.resolve(info.absoluteResourcePath).replace(/\\/g, '/')),
+      // Replaces deprecated jsonpFunction
+      chunkLoadingGlobal: `webpackJsonp${appPackageJson.name}`,
+      globalObject: 'this',
+    },
+    optimization: {
+      minimize: isEnvProduction,
+      minimizer: [
+        new TerserPlugin({
+          terserOptions: {
+            parse: { ecma: 8 },
+            compress: {
+              ecma: 5,
+              warnings: false,
+              comparisons: false,
+              inline: 2,
+            },
+            mangle: { safari10: true },
+            keep_classnames: isEnvProductionProfile,
+            keep_fnames: isEnvProductionProfile,
+            output: {
+              ecma: 5,
+              comments: false,
+              ascii_only: true,
+            },
+          },
+        }),
+      ],
+      splitChunks: isEnvProduction
+        ? {
+            chunks: 'all',
+            name: false,
+            cacheGroups: {
+              commons: {
+                test: /[\\/]node_modules[\\/]/,
+                minSize: 50000,
+                name: 'vendors',
+                chunks: 'all',
+              },
+            },
+          }
+        : { chunks: 'all', name: false },
+      runtimeChunk: {
+        name: (entrypoint) => `runtime-${entrypoint.name}`,
+      },
+    },
+    resolve: {
+      modules: ['node_modules', paths.appNodeModules].concat(modules.additionalModulePaths || []),
+      extensions: paths.moduleFileExtensions
+        .map((ext) => `.${ext}`)
+        .filter((ext) => useTypeScript || !ext.includes('ts')),
+      alias: {
+        'react-native': 'react-native-web',
+        ...(isEnvProductionProfile && {
+          'react-dom$': 'react-dom/profiling',
+          'scheduler/tracing': 'scheduler/tracing-profiling',
+        }),
+        ...(modules.webpackAliases || {}),
+      },
+      // Replaces Webpack 4 `node` polyfill shims — disable browser-irrelevant Node built-ins
+      fallback: {
+        dgram: false,
+        fs: false,
+        net: false,
+        tls: false,
+        child_process: false,
+      },
+      plugins: [
+        new ModuleScopePlugin(paths.appSrc, [paths.appPackageJson]),
+        new TsconfigPathsPlugin(),
+      ],
+    },
+    module: {
+      strictExportPresence: true,
+      rules: [
+        {
+          oneOf: [
+            // Webpack 5 asset modules replace url-loader and file-loader
+            {
+              test: /\.avif$/,
+              type: 'asset/inline',
+              mimetype: 'image/avif',
+            },
+            {
+              test: [/\.bmp$/, /\.gif$/, /\.jpe?g$/, /\.png$/],
+              type: 'asset',
+              parser: {
+                dataUrlCondition: { maxSize: imageInlineSizeLimit },
+              },
+              generator: {
+                filename: 'static/media/[name].[hash:8][ext]',
+              },
+            },
+            {
+              test: /\.(js|mjs|jsx|ts|tsx)$/,
+              include: paths.appSrc,
+              loader: require.resolve('babel-loader'),
+              options: {
+                babelrc: false,
+                configFile: false,
+                presets: [
+                  [
+                    require.resolve('@babel/preset-env'),
+                    {
+                      targets: 'defaults',
+                      useBuiltIns: 'usage',
+                      corejs: 3,
+                    },
+                  ],
+                  [
+                    require.resolve('@babel/preset-react'),
+                    {
+                      runtime: hasJsxRuntime ? 'automatic' : 'classic',
+                    },
+                  ],
+                  require.resolve('@babel/preset-typescript'),
+                ],
+                plugins: [
+                  !!options.relayArtifactDirectory && ['relay', { artifactDirectory: options.relayArtifactDirectory }],
+                  [
+                    'babel-plugin-styled-components',
+                    {
+                      displayName: !isEnvProduction,
+                      ssr: false,
+                      transpileTemplateLiterals: isEnvProduction,
+                      pure: true,
+                    },
+                  ],
+                  isEnvDevelopment && shouldUseReactRefresh && require.resolve('react-refresh/babel'),
+                ].filter(Boolean),
+                cacheDirectory: true,
+                cacheCompression: false,
+                compact: isEnvProduction,
+              },
+            },
+            {
+              test: /\.(js|mjs)$/,
+              exclude: /@babel(?:\/|\\{1,2})runtime/,
+              loader: require.resolve('babel-loader'),
+              options: {
+                babelrc: false,
+                configFile: false,
+                compact: false,
+                presets: [[require.resolve('@babel/preset-env'), { targets: 'defaults' }]],
+                cacheDirectory: true,
+                cacheCompression: false,
+                sourceMaps: shouldUseSourceMap,
+                inputSourceMap: shouldUseSourceMap,
+              },
+            },
+            // Catch-all: replaces file-loader
+            {
+              exclude: [/\.(js|mjs|jsx|ts|tsx)$/, /\.html$/, /\.json$/],
+              type: 'asset/resource',
+              generator: {
+                filename: 'static/media/[name].[hash:8][ext]',
+              },
+            },
+          ],
+        },
+      ],
+    },
+    plugins: [
+      new HtmlWebpackPlugin({
+        title: options.head.title,
+        inject: true,
+        template: paths.appHtml,
+        ...(isEnvProduction
+          ? {
+              minify: {
+                removeComments: true,
+                collapseWhitespace: true,
+                removeRedundantAttributes: true,
+                useShortDoctype: true,
+                removeEmptyAttributes: true,
+                removeStyleLinkTypeAttributes: true,
+                keepClosingSlash: true,
+                minifyJS: true,
+                minifyCSS: true,
+                minifyURLs: true,
+              },
+            }
+          : undefined),
+      }),
+      isEnvProduction && shouldInlineRuntimeChunk && new InlineChunkHtmlPlugin(HtmlWebpackPlugin, [/runtime-.+[.]js/]),
+      new InterpolateHtmlPlugin(HtmlWebpackPlugin, env.raw),
+      new ModuleNotFoundPlugin(paths.appPath),
+      GitRevisionPlugin,
+      new webpack.DefinePlugin(
+        Object.assign(env.stringified, {
+          PACKAGE_VERSION: JSON.stringify(appPackageJson.version),
+          SERVICE: JSON.stringify(appPackageJson.name),
+          IS_PROD_MODE: !isEnvProduction,
+          VERSION: JSON.stringify(GitRevisionPlugin.version()),
+          COMMITHASH: JSON.stringify(GitRevisionPlugin.commithash()),
+          BRANCH: JSON.stringify(GitRevisionPlugin.branch()),
+          CONSTANTS: JSON.stringify(options.constants),
+          I18N_CONFIG: JSON.stringify(options.i18nConfig),
+        }),
+      ),
+      isEnvDevelopment && new webpack.HotModuleReplacementPlugin(),
+      isEnvDevelopment && shouldUseReactRefresh && new ReactRefreshWebpackPlugin(),
+      isEnvDevelopment && new CaseSensitivePathsPlugin(),
+      new WebpackManifestPlugin({
+        fileName: 'asset-manifest.json',
+        publicPath: paths.publicUrlOrPath,
+        generate: (seed, files, entrypoints) => {
+          const manifestFiles = files.reduce((manifest, file) => {
+            manifest[file.name] = file.path;
+            return manifest;
+          }, seed);
+          const entrypointFiles = entrypoints.main.filter((fileName) => !fileName.endsWith('.map'));
+          return { files: manifestFiles, entrypoints: entrypointFiles };
+        },
+      }),
+      // Updated Webpack 5 API — was: new webpack.IgnorePlugin(/pattern/, /context/)
+      new webpack.IgnorePlugin({ resourceRegExp: /^\.\/locale$/, contextRegExp: /moment$/ }),
+      useTypeScript &&
+        new ForkTsCheckerWebpackPlugin({
+          async: isEnvDevelopment,
+          typescript: {
+            typescriptPath: resolve.sync('typescript', {
+              basedir: paths.appNodeModules,
+            }),
+            configFile: paths.appTsConfig,
+            diagnosticOptions: {
+              semantic: true,
+              syntactic: true,
+            },
+          },
+        }),
+    ].filter(Boolean),
+    performance: false,
+  };
+};

package/src/config/webpackDevServer.config.ts

@@ -0,0 +1,78 @@
+import fs from 'fs';
+
+import { AppPaths } from './paths';
+
+import {
+  evalSourceMapMiddleware,
+  ignoredFiles,
+  noopServiceWorkerMiddleware,
+  redirectServedPathMiddleware as redirectServedPath,
+} from '../utils/devServerMiddleware';
+
+export default (proxy: any, allowedHost: any, paths: AppPaths) => {
+  const host = process.env.HOST || '0.0.0.0';
+  const sockHost = process.env.WDS_SOCKET_HOST;
+  const sockPath = process.env.WDS_SOCKET_PATH;
+  const sockPort = process.env.WDS_SOCKET_PORT;
+
+  return {
+    // Replaces deprecated disableHostCheck
+    allowedHosts:
+      !proxy || process.env.DANGEROUSLY_DISABLE_HOST_CHECK === 'true'
+        ? ('all' as const)
+        : ([allowedHost].filter(Boolean) as string[]),
+    compress: true,
+    // Replaces clientLogLevel, injectClient, sockHost/sockPath/sockPort, overlay
+    client: {
+      logging: 'none' as const,
+      overlay: false,
+      webSocketURL: {
+        hostname: sockHost,
+        pathname: sockPath,
+        port: sockPort ? Number(sockPort) : undefined,
+      },
+    },
+    // Replaces contentBase + contentBasePublicPath + watchContentBase
+    static: [
+      {
+        directory: paths.appPublic,
+        publicPath: [paths.publicUrlOrPath],
+        watch: {
+          ignored: ignoredFiles(paths.appSrc),
+        },
+      },
+    ],
+    hot: true,
+    // Replaces transportMode
+    webSocketServer: 'ws' as const,
+    // Replaces publicPath at root level
+    devMiddleware: {
+      publicPath: paths.publicUrlOrPath.slice(0, -1),
+    },
+    host,
+    historyApiFallback: {
+      disableDotRule: true as const,
+      index: paths.publicUrlOrPath,
+    },
+    // Replaces public
+    ...(allowedHost && !(!proxy || process.env.DANGEROUSLY_DISABLE_HOST_CHECK === 'true')
+      ? { allowedHosts: [allowedHost] }
+      : {}),
+    proxy,
+    // Replaces before() + after() hooks
+    setupMiddlewares(middlewares: any[], devServer: any) {
+      devServer.app.use(evalSourceMapMiddleware(devServer));
+
+      if (fs.existsSync(paths.proxySetup)) {
+        require(paths.proxySetup)(devServer.app);
+      }
+
+      middlewares.push(
+        { name: 'redirect-served-path', middleware: redirectServedPath(paths.publicUrlOrPath) },
+        { name: 'noop-service-worker', middleware: noopServiceWorkerMiddleware(paths.publicUrlOrPath) },
+      );
+
+      return middlewares;
+    },
+  };
+};

package/src/index.ts

@@ -0,0 +1,3 @@
+export { createAppPaths, AppPaths } from './config/paths';
+export { createDevServer } from './command/dev';
+export { createProductionBuild } from './command/build';

package/src/utils/FileSizeReporter.ts

@@ -0,0 +1,168 @@
+import fs from 'fs';
+import path from 'path';
+import zlib from 'zlib';
+
+import chalk from 'chalk';
+
+function filesize(bytes: number): string {
+  if (!Number.isFinite(bytes)) return '0 B';
+  const sign = bytes < 0 ? '-' : '';
+  const abs = Math.abs(bytes);
+  const units = ['B', 'KB', 'MB', 'GB', 'TB'];
+  let i = 0;
+  let n = abs;
+  while (n >= 1024 && i < units.length - 1) {
+    n /= 1024;
+    i++;
+  }
+  const value = i === 0 ? n.toFixed(0) : n.toFixed(2);
+  return `${sign}${value} ${units[i]}`;
+}
+
+type SizeMap = Record<string, number>;
+
+export type PreviousFileSizes = {
+  root: string;
+  sizes: SizeMap;
+};
+
+function canReadAsset(asset: string): boolean {
+  return (
+    /\.(js|css)$/.test(asset) && !/service-worker\.js/.test(asset) && !/precache-manifest\.[0-9a-f]+\.js/.test(asset)
+  );
+}
+
+function gzipSize(buf: Buffer): number {
+  return zlib.gzipSync(buf, { level: 6 }).length;
+}
+
+function walkSync(dir: string, out: string[] = []): string[] {
+  if (!fs.existsSync(dir)) return out;
+  for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+    const full = path.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      walkSync(full, out);
+    } else if (entry.isFile()) {
+      out.push(full);
+    }
+  }
+  return out;
+}
+
+function removeFileNameHash(buildFolder: string, fileName: string): string {
+  return fileName
+    .replace(buildFolder, '')
+    .replace(/\\/g, '/')
+    .replace(/\/?(.*)(\.[0-9a-f]+)(\.chunk)?(\.js|\.css)/, (_match, p1, _p2, p3, p4) => p1 + (p3 || '') + p4);
+}
+
+function getDifferenceLabel(currentSize: number, previousSize: number): string {
+  const FIFTY_KILOBYTES = 1024 * 50;
+  const difference = currentSize - previousSize;
+  const fileSize = !Number.isNaN(difference) ? filesize(difference) : '';
+  if (difference >= FIFTY_KILOBYTES) {
+    return chalk.red('+' + fileSize);
+  } else if (difference < FIFTY_KILOBYTES && difference > 0) {
+    return chalk.yellow('+' + fileSize);
+  } else if (difference < 0) {
+    return chalk.green(fileSize);
+  }
+  return '';
+}
+
+export function measureFileSizesBeforeBuild(buildFolder: string): Promise<PreviousFileSizes> {
+  return new Promise((resolve) => {
+    try {
+      const files = walkSync(buildFolder).filter(canReadAsset);
+      const sizes: SizeMap = {};
+      files.forEach((file) => {
+        try {
+          const contents = fs.readFileSync(file);
+          const key = removeFileNameHash(buildFolder, file);
+          sizes[key] = gzipSize(contents);
+        } catch {
+          /* ignore */
+        }
+      });
+      resolve({ root: buildFolder, sizes });
+    } catch {
+      resolve({ root: buildFolder, sizes: {} });
+    }
+  });
+}
+
+export function printFileSizesAfterBuild(
+  webpackStats: any,
+  previousSizeMap: PreviousFileSizes,
+  buildFolder: string,
+  maxBundleGzipSize: number,
+  maxChunkGzipSize: number,
+): void {
+  const root = previousSizeMap?.root || buildFolder;
+  const sizes = previousSizeMap?.sizes || {};
+
+  const statsArr = webpackStats && typeof webpackStats.stats !== 'undefined' ? webpackStats.stats : [webpackStats];
+
+  const assets: Array<{ folder: string; name: string; size: number; sizeLabel: string }> = [];
+
+  statsArr.forEach((stats: any) => {
+    if (!stats) return;
+    const statsAssets = stats.toJson({ all: false, assets: true }).assets || [];
+    statsAssets
+      .filter((a: any) => canReadAsset(a.name))
+      .forEach((asset: any) => {
+        const filePath = path.join(root, asset.name);
+        let size = 0;
+        try {
+          const contents = fs.readFileSync(filePath);
+          size = gzipSize(contents);
+        } catch {
+          size = asset.size || 0;
+        }
+        const previousSize = sizes[removeFileNameHash(root, filePath)];
+        const difference = getDifferenceLabel(size, previousSize);
+        assets.push({
+          folder: path.join(path.basename(buildFolder), path.dirname(asset.name)),
+          name: path.basename(asset.name),
+          size,
+          sizeLabel: filesize(size) + (difference ? ' (' + difference + ')' : ''),
+        });
+      });
+  });
+
+  assets.sort((a, b) => b.size - a.size);
+
+  const longestSizeLabelLength = assets.length ? Math.max(...assets.map((a) => stripAnsi(a.sizeLabel).length)) : 0;
+  let suggestBundleSplitting = false;
+
+  assets.forEach((asset) => {
+    let { sizeLabel } = asset;
+    const sizeLength = stripAnsi(sizeLabel).length;
+    if (sizeLength < longestSizeLabelLength) {
+      sizeLabel += ' '.repeat(longestSizeLabelLength - sizeLength);
+    }
+    const isMainBundle = asset.name.indexOf('main.') === 0;
+    const maxRecommendedSize = isMainBundle ? maxBundleGzipSize : maxChunkGzipSize;
+    const isLarge = maxRecommendedSize && asset.size > maxRecommendedSize;
+    if (isLarge && /\.js$/.test(asset.name)) suggestBundleSplitting = true;
+    console.log(
+      '  ' +
+        (isLarge ? chalk.yellow(sizeLabel) : sizeLabel) +
+        '  ' +
+        chalk.dim(asset.folder + path.sep) +
+        chalk.cyan(asset.name),
+    );
+  });
+
+  if (suggestBundleSplitting) {
+    console.log();
+    console.log(chalk.yellow('The bundle size is significantly larger than recommended.'));
+  }
+}
+
+function stripAnsi(s: string): string {
+  // eslint-disable-next-line no-control-regex
+  return s.replace(/\x1B\[[0-9;]*m/g, '');
+}
+
+export default { measureFileSizesBeforeBuild, printFileSizesAfterBuild };

package/src/utils/InlineChunkHtmlPlugin.js

@@ -0,0 +1,67 @@
+'use strict';
+
+class InlineChunkHtmlPlugin {
+  constructor(htmlWebpackPlugin, tests) {
+    this.htmlWebpackPlugin = htmlWebpackPlugin;
+    this.tests = tests || [];
+  }
+
+  getInlinedTag(publicPath, assets, tag) {
+    if (tag.tagName !== 'script' || !(tag.attributes && tag.attributes.src)) {
+      return tag;
+    }
+    const scriptName = publicPath
+      ? tag.attributes.src.replace(publicPath, '')
+      : tag.attributes.src;
+
+    if (!this.tests.some((test) => scriptName.match(test))) {
+      return tag;
+    }
+
+    const asset = assets[scriptName];
+    if (asset == null) {
+      return tag;
+    }
+
+    return {
+      tagName: 'script',
+      innerHTML: asset.source(),
+      closeTag: true,
+    };
+  }
+
+  apply(compiler) {
+    let publicPath = compiler.options.output.publicPath || '';
+    if (publicPath && !publicPath.endsWith('/')) {
+      publicPath += '/';
+    }
+
+    compiler.hooks.compilation.tap('InlineChunkHtmlPlugin', (compilation) => {
+      const tagFunction = (tag) =>
+        this.getInlinedTag(publicPath, compilation.assets, tag);
+
+      const hooks = this.htmlWebpackPlugin.getHooks(compilation);
+      hooks.alterAssetTagGroups.tap('InlineChunkHtmlPlugin', (assets) => {
+        assets.headTags = assets.headTags.map(tagFunction);
+        assets.bodyTags = assets.bodyTags.map(tagFunction);
+      });
+
+      // Remove inlined assets from the output (best-effort)
+      compilation.hooks.processAssets.tap(
+        {
+          name: 'InlineChunkHtmlPlugin',
+          stage: compilation.constructor.PROCESS_ASSETS_STAGE_OPTIMIZE_INLINE || 700,
+        },
+        (assets) => {
+          Object.keys(assets).forEach((assetName) => {
+            if (this.tests.some((test) => assetName.match(test))) {
+              delete compilation.assets[assetName];
+            }
+          });
+        },
+      );
+    });
+  }
+}
+
+module.exports = InlineChunkHtmlPlugin;

package/src/utils/InterpolateHtmlPlugin.js

@@ -0,0 +1,27 @@
+'use strict';
+
+const escapeStringRegexp = (str) => str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+
+class InterpolateHtmlPlugin {
+  constructor(htmlWebpackPlugin, replacements) {
+    this.htmlWebpackPlugin = htmlWebpackPlugin;
+    this.replacements = replacements || {};
+  }
+
+  apply(compiler) {
+    compiler.hooks.compilation.tap('InterpolateHtmlPlugin', (compilation) => {
+      const hooks = this.htmlWebpackPlugin.getHooks(compilation);
+      hooks.afterTemplateExecution.tap('InterpolateHtmlPlugin', (data) => {
+        Object.keys(this.replacements).forEach((key) => {
+          const value = this.replacements[key];
+          data.html = data.html.replace(
+            new RegExp('%' + escapeStringRegexp(key) + '%', 'g'),
+            value == null ? '' : String(value),
+          );
+        });
+      });
+    });
+  }
+}
+
+module.exports = InterpolateHtmlPlugin;

package/src/utils/ModuleNotFoundPlugin.js

@@ -0,0 +1,13 @@
+'use strict';
+
+class ModuleNotFoundPlugin {
+  constructor(_appPath, _yarnLockFile) {
+    // no-op: original plugin provided nicer error messages.
+  }
+
+  apply(_compiler) {
+    // no-op
+  }
+}
+
+module.exports = ModuleNotFoundPlugin;

package/src/utils/ModuleScopePlugin.js

@@ -0,0 +1,13 @@
+'use strict';
+
+class ModuleScopePlugin {
+  constructor(_appSrc, _allowedFiles) {
+    // no-op
+  }
+
+  apply(_resolver) {
+    // no-op
+  }
+}
+
+module.exports = ModuleScopePlugin;