Mail

frontend/node_modules/@pmmmwh/react-refresh-webpack-plugin/loader/utils/getIdentitySourceMap.js

@@ -0,0 +1,30 @@
+const { SourceMapGenerator } = require('source-map');
+
+/**
+ * Generates an identity source map from a source file.
+ * @param {string} source The content of the source file.
+ * @param {string} resourcePath The name of the source file.
+ * @returns {import('source-map').RawSourceMap} The identity source map.
+ */
+function getIdentitySourceMap(source, resourcePath) {
+  const sourceMap = new SourceMapGenerator();
+  sourceMap.setSourceContent(resourcePath, source);
+
+  source.split('\n').forEach((line, index) => {
+    sourceMap.addMapping({
+      source: resourcePath,
+      original: {
+        line: index + 1,
+        column: 0,
+      },
+      generated: {
+        line: index + 1,
+        column: 0,
+      },
+    });
+  });
+
+  return sourceMap.toJSON();
+}
+
+module.exports = getIdentitySourceMap;

frontend/node_modules/@pmmmwh/react-refresh-webpack-plugin/loader/utils/getModuleSystem.js

@@ -0,0 +1,128 @@
+const { promises: fsPromises } = require('fs');
+const path = require('path');
+
+/** @type {Map<string, string | undefined>} */
+let packageJsonTypeMap = new Map();
+
+/**
+ * Infers the current active module system from loader context and options.
+ * @this {import('webpack').loader.LoaderContext}
+ * @param {import('webpack').ModuleFilenameHelpers} ModuleFilenameHelpers Webpack's module filename helpers.
+ * @param {import('../types').NormalizedLoaderOptions} options The normalized loader options.
+ * @return {Promise<'esm' | 'cjs'>} The inferred module system.
+ */
+async function getModuleSystem(ModuleFilenameHelpers, options) {
+  // Check loader options -
+  // if `esModule` is set we don't have to do extra guess work.
+  switch (typeof options.esModule) {
+    case 'boolean': {
+      return options.esModule ? 'esm' : 'cjs';
+    }
+    case 'object': {
+      if (
+        options.esModule.include &&
+        ModuleFilenameHelpers.matchPart(this.resourcePath, options.esModule.include)
+      ) {
+        return 'esm';
+      }
+      if (
+        options.esModule.exclude &&
+        ModuleFilenameHelpers.matchPart(this.resourcePath, options.esModule.exclude)
+      ) {
+        return 'cjs';
+      }
+
+      break;
+    }
+    default: // Do nothing
+  }
+
+  // Check current resource's extension
+  if (/\.mjs$/.test(this.resourcePath)) return 'esm';
+  if (/\.cjs$/.test(this.resourcePath)) return 'cjs';
+
+  if (typeof this.addMissingDependency !== 'function') {
+    // This is Webpack 4 which does not support `import.meta`.
+    // We assume `.js` files are CommonJS because the output cannot be ESM anyway.
+    return 'cjs';
+  }
+
+  // We will assume CommonJS if we cannot determine otherwise
+  let packageJsonType = '';
+
+  // We begin our search for relevant `package.json` files,
+  // at the directory of the resource being loaded.
+  // These paths should already be resolved,
+  // but we resolve them again to ensure we are dealing with an aboslute path.
+  const resourceContext = path.dirname(this.resourcePath);
+  let searchPath = resourceContext;
+  let previousSearchPath = '';
+  // We start our search just above the root context of the webpack compilation
+  const stopPath = path.dirname(this.rootContext);
+
+  // If the module context is a resolved symlink outside the `rootContext` path,
+  // then we will never find the `stopPath` - so we also halt when we hit the root.
+  // Note that there is a potential that the wrong `package.json` is found in some pathalogical cases,
+  // such as a folder that is conceptually a package + does not have an ancestor `package.json`,
+  // but there exists a `package.json` higher up.
+  // This might happen if you have a folder of utility JS files that you symlink but did not organize as a package.
+  // We consider this an unsupported edge case for now.
+  while (searchPath !== stopPath && searchPath !== previousSearchPath) {
+    // If we have already determined the `package.json` type for this path we can stop searching.
+    // We do however still need to cache the found value,
+    // from the `resourcePath` folder up to the matching `searchPath`,
+    // to avoid retracing these steps when processing sibling resources.
+    if (packageJsonTypeMap.has(searchPath)) {
+      packageJsonType = packageJsonTypeMap.get(searchPath);
+
+      let currentPath = resourceContext;
+      while (currentPath !== searchPath) {
+        // We set the found type at least level from `resourcePath` folder up to the matching `searchPath`
+        packageJsonTypeMap.set(currentPath, packageJsonType);
+        currentPath = path.dirname(currentPath);
+      }
+      break;
+    }
+
+    let packageJsonPath = path.join(searchPath, 'package.json');
+    try {
+      const packageSource = await fsPromises.readFile(packageJsonPath, 'utf-8');
+      try {
+        const packageObject = JSON.parse(packageSource);
+
+        // Any package.json is sufficient as long as it can be parsed.
+        // If it does not explicitly have a `type: "module"` it will be assumed to be CommonJS.
+        packageJsonType = typeof packageObject.type === 'string' ? packageObject.type : '';
+        packageJsonTypeMap.set(searchPath, packageJsonType);
+
+        // We set the type in the cache for all paths from the `resourcePath` folder,
+        // up to the matching `searchPath` to avoid retracing these steps when processing sibling resources.
+        let currentPath = resourceContext;
+        while (currentPath !== searchPath) {
+          packageJsonTypeMap.set(currentPath, packageJsonType);
+          currentPath = path.dirname(currentPath);
+        }
+      } catch (e) {
+        // `package.json` exists but could not be parsed.
+        // We track it as a dependency so we can reload if this file changes.
+      }
+
+      this.addDependency(packageJsonPath);
+      break;
+    } catch (e) {
+      // `package.json` does not exist.
+      // We track it as a missing dependency so we can reload if this file is added.
+      this.addMissingDependency(packageJsonPath);
+    }
+
+    // Try again at the next level up
+    previousSearchPath = searchPath;
+    searchPath = path.dirname(searchPath);
+  }
+
+  // Check `package.json` for the `type` field -
+  // fallback to use `cjs` for anything ambiguous.
+  return packageJsonType === 'module' ? 'esm' : 'cjs';
+}
+
+module.exports = getModuleSystem;

frontend/node_modules/@pmmmwh/react-refresh-webpack-plugin/loader/utils/getRefreshModuleRuntime.js

@@ -0,0 +1,63 @@
+/**
+ * @typedef ModuleRuntimeOptions {Object}
+ * @property {boolean} const Use ES6 `const` and `let` in generated runtime code.
+ * @property {'cjs' | 'esm'} moduleSystem The module system to be used.
+ */
+
+/**
+ * Generates code appended to each JS-like module for react-refresh capabilities.
+ *
+ * `__react_refresh_utils__` will be replaced with actual utils during source parsing by `webpack.ProvidePlugin`.
+ *
+ * [Reference for Runtime Injection](https://github.com/webpack/webpack/blob/b07d3b67d2252f08e4bb65d354a11c9b69f8b434/lib/HotModuleReplacementPlugin.js#L419)
+ * [Reference for HMR Error Recovery](https://github.com/webpack/webpack/issues/418#issuecomment-490296365)
+ *
+ * @param {import('webpack').Template} Webpack's templating helpers.
+ * @param {ModuleRuntimeOptions} options The refresh module runtime options.
+ * @returns {string} The refresh module runtime template.
+ */
+function getRefreshModuleRuntime(Template, options) {
+  const constDeclaration = options.const ? 'const' : 'var';
+  const letDeclaration = options.const ? 'let' : 'var';
+  const webpackHot = options.moduleSystem === 'esm' ? 'import.meta.webpackHot' : 'module.hot';
+  return Template.asString([
+    `${constDeclaration} $ReactRefreshModuleId$ = __webpack_require__.$Refresh$.moduleId;`,
+    `${constDeclaration} $ReactRefreshCurrentExports$ = __react_refresh_utils__.getModuleExports(`,
+    Template.indent('$ReactRefreshModuleId$'),
+    ');',
+    '',
+    'function $ReactRefreshModuleRuntime$(exports) {',
+    Template.indent([
+      `if (${webpackHot}) {`,
+      Template.indent([
+        `${letDeclaration} errorOverlay;`,
+        "if (typeof __react_refresh_error_overlay__ !== 'undefined') {",
+        Template.indent('errorOverlay = __react_refresh_error_overlay__;'),
+        '}',
+        `${letDeclaration} testMode;`,
+        "if (typeof __react_refresh_test__ !== 'undefined') {",
+        Template.indent('testMode = __react_refresh_test__;'),
+        '}',
+        'return __react_refresh_utils__.executeRuntime(',
+        Template.indent([
+          'exports,',
+          '$ReactRefreshModuleId$,',
+          `${webpackHot},`,
+          'errorOverlay,',
+          'testMode',
+        ]),
+        ');',
+      ]),
+      '}',
+    ]),
+    '}',
+    '',
+    "if (typeof Promise !== 'undefined' && $ReactRefreshCurrentExports$ instanceof Promise) {",
+    Template.indent('$ReactRefreshCurrentExports$.then($ReactRefreshModuleRuntime$);'),
+    '} else {',
+    Template.indent('$ReactRefreshModuleRuntime$($ReactRefreshCurrentExports$);'),
+    '}',
+  ]);
+}
+
+module.exports = getRefreshModuleRuntime;

frontend/node_modules/@pmmmwh/react-refresh-webpack-plugin/loader/utils/index.js

@@ -0,0 +1,11 @@
+const getIdentitySourceMap = require('./getIdentitySourceMap');
+const getModuleSystem = require('./getModuleSystem');
+const getRefreshModuleRuntime = require('./getRefreshModuleRuntime');
+const normalizeOptions = require('./normalizeOptions');
+
+module.exports = {
+  getIdentitySourceMap,
+  getModuleSystem,
+  getRefreshModuleRuntime,
+  normalizeOptions,
+};

frontend/node_modules/@pmmmwh/react-refresh-webpack-plugin/loader/utils/normalizeOptions.js

@@ -0,0 +1,25 @@
+const { d, n } = require('../../options');
+
+/**
+ * Normalizes the options for the loader.
+ * @param {import('../types').ReactRefreshLoaderOptions} options Non-normalized loader options.
+ * @returns {import('../types').NormalizedLoaderOptions} Normalized loader options.
+ */
+const normalizeOptions = (options) => {
+  d(options, 'const', false);
+
+  n(options, 'esModule', (esModule) => {
+    if (typeof esModule === 'boolean' || typeof esModule === 'undefined') {
+      return esModule;
+    }
+
+    d(esModule, 'include');
+    d(esModule, 'exclude');
+
+    return esModule;
+  });
+
+  return options;
+};
+
+module.exports = normalizeOptions;