project bootstrap

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;

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

@@ -0,0 +1,76 @@
+const { promises: fsPromises } = require('fs');
+const path = require('path');
+const commonPathPrefix = require('common-path-prefix');
+const findUp = require('find-up');
+
+/** @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';
+
+  // Load users' `package.json` -
+  // We will cache the results in a global variable so it will only be parsed once.
+  let packageJsonType = packageJsonTypeMap.get(this.rootContext);
+  if (!packageJsonType) {
+    try {
+      const commonPath = commonPathPrefix([this.rootContext, this.resourcePath], '/');
+      const stopPath = path.resolve(commonPath, '..');
+
+      const packageJsonPath = await findUp(
+        (dir) => {
+          if (dir === stopPath) return findUp.stop;
+          return 'package.json';
+        },
+        { cwd: path.dirname(this.resourcePath) }
+      );
+
+      const buffer = await fsPromises.readFile(packageJsonPath, { encoding: 'utf-8' });
+      const rawPackageJson = buffer.toString('utf-8');
+      ({ type: packageJsonType } = JSON.parse(rawPackageJson));
+      packageJsonTypeMap.set(this.rootContext, packageJsonType);
+    } catch (e) {
+      // Failed to parse `package.json`, do nothing.
+    }
+  }
+
+  // Check `package.json` for the `type` field -
+  // fallback to use `cjs` for anything ambiguous.
+  return packageJsonType === 'module' ? 'esm' : 'cjs';
+}
+
+module.exports = getModuleSystem;

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;

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,
+};

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;