fix: restore remaining source and test files from fix/node24

Assisted-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: bennypowers

packages/browser-logs/src/browserScript.ts

@@ -4,17 +4,15 @@ import path from 'path';
 const REGEXP_SOURCE_MAP = /\/\/# sourceMappingURL=.*/;
 
 const serializeScript = fs
-  .readFileSync(path.resolve(__dirname, 'serialize.js'), 'utf-8')
+  .readFileSync(path.resolve(import.meta.dirname, 'serialize.js'), 'utf-8')
   .replace(REGEXP_SOURCE_MAP, '');
 const logUncaughtErrorsScript = fs
-  .readFileSync(path.resolve(__dirname, 'logUncaughtErrors.js'), 'utf-8')
+  .readFileSync(path.resolve(import.meta.dirname, 'logUncaughtErrors.js'), 'utf-8')
   .replace(REGEXP_SOURCE_MAP, '');
 
 /**
- * Create the browser script. This project is compiled as CJS because it also needs to run in node, so
- * we create a small wrapper.
- *
- * It can't be ESM anyway, because it should work on older browsers as well.
+ * Create the browser script as an IIFE wrapper.
+ * It can't be ESM because it should work on older browsers as well.
  */
 export const browserScript =
   '(function () { var module={};var exports={};\n' +

packages/config-loader/src/ConfigLoaderError.js

@@ -1 +0,0 @@
-module.exports = class ConfigLoaderError extends Error {};

packages/config-loader/src/ConfigLoaderError.ts

@@ -0,0 +1 @@
+export default class ConfigLoaderError extends Error {}

packages/config-loader/src/getPackageType.ts

@@ -0,0 +1,29 @@
+import fs from 'fs/promises';
+import path from 'path';
+import { fileExists } from './utils.ts';
+
+/**
+ * Gets the package type for a given directory. Walks up the file system, looking
+ * for a package.json file and returns the package type.
+ */
+async function getPackageType(basedir: string): Promise<string> {
+  let currentPath = basedir;
+  try {
+    while (await fileExists(currentPath)) {
+      const pkgJsonPath = path.join(currentPath, 'package.json');
+
+      if (await fileExists(pkgJsonPath)) {
+        const pkgJsonString = await fs.readFile(pkgJsonPath, { encoding: 'utf-8' });
+        const pkgJson = JSON.parse(pkgJsonString);
+        return pkgJson.type || 'commonjs';
+      }
+
+      currentPath = path.resolve(currentPath, '..');
+    }
+  } catch (e) {
+    // don't log any error
+  }
+  return 'commonjs';
+}
+
+export default getPackageType;

packages/config-loader/src/importConfig.ts

@@ -0,0 +1,35 @@
+import { pathToFileURL } from 'url';
+import ConfigLoaderError from './ConfigLoaderError.ts';
+
+// These strings may be node-version dependent and need updating over time
+// They're just to display a helpful error message
+const CJS_ERRORS = [
+  'ReferenceError: module is not defined',
+  'ReferenceError: require is not defined',
+  'ReferenceError: exports is not defined',
+];
+
+async function importConfig(path: string): Promise<object> {
+  try {
+    const config = await import(pathToFileURL(path).href);
+
+    if (typeof config.default !== 'object') {
+      throw new ConfigLoaderError(
+        `Config at ${path} should have a default export that is an object.`,
+      );
+    }
+
+    return config.default;
+  } catch (e) {
+    if (CJS_ERRORS.some(msg => (e as Error).stack?.includes(msg))) {
+      throw new ConfigLoaderError(
+        'You are using CommonJS syntax such as "require" or "module.exports" in a config loaded as es module. ' +
+          'Use import/export syntax, or load the file as a CommonJS module by ' +
+          'using the .cjs file extension or by removing type="module" from your package.json.',
+      );
+    }
+    throw e;
+  }
+}
+
+export default importConfig;

packages/config-loader/src/importOrRequireConfig.js

@@ -1,33 +0,0 @@
-const getPackageType = require('./getPackageType');
-const path = require('path');
-const requireConfig = require('./requireConfig');
-
-/**
- * @param {string} configPath
- */
-function importConfig(configPath) {
-  // Conditionally requires importConfig function to avoid logging a warning on node v12
-  // when not using an es modules
-  const importConfigFunction = require('./importConfig');
-  return importConfigFunction(configPath);
-}
-
-/**
- * @param {string} configPath
- * @param {string} basedir
- */
-async function importOrRequireConfig(configPath, basedir) {
-  const ext = path.extname(configPath);
-
-  switch (ext) {
-    case '.mjs':
-      return importConfig(configPath);
-    case '.cjs':
-      return requireConfig(configPath);
-    default:
-      const packageType = await getPackageType(basedir);
-      return packageType === 'module' ? importConfig(configPath) : requireConfig(configPath);
-  }
-}
-
-module.exports = importOrRequireConfig;

packages/config-loader/src/importOrRequireConfig.ts

@@ -0,0 +1,20 @@
+import getPackageType from './getPackageType.ts';
+import path from 'path';
+import requireConfig from './requireConfig.ts';
+import importConfigFunction from './importConfig.ts';
+
+async function importOrRequireConfig(configPath: string, basedir: string): Promise<object> {
+  const ext = path.extname(configPath);
+
+  switch (ext) {
+    case '.mjs':
+      return importConfigFunction(configPath);
+    case '.cjs':
+      return requireConfig(configPath);
+    default:
+      const packageType = await getPackageType(basedir);
+      return packageType === 'module' ? importConfigFunction(configPath) : requireConfig(configPath);
+  }
+}
+
+export default importOrRequireConfig;

packages/config-loader/src/index.ts

@@ -0,0 +1,30 @@
+import path from 'path';
+import { fileExists } from './utils.ts';
+import ConfigLoaderError from './ConfigLoaderError.ts';
+import importOrRequireConfig from './importOrRequireConfig.ts';
+
+const EXTENSIONS = ['.mjs', '.cjs', '.js'];
+
+async function readConfig(name: string, customPath?: string, basedir: string = process.cwd()): Promise<any> {
+  const resolvedCustomPath = customPath ? path.resolve(basedir, customPath) : undefined;
+  if (resolvedCustomPath && !(await fileExists(resolvedCustomPath))) {
+    throw new ConfigLoaderError(`Could not find a config file at ${resolvedCustomPath}`);
+  }
+
+  // load the custom config file
+  if (resolvedCustomPath) {
+    return importOrRequireConfig(resolvedCustomPath, basedir);
+  }
+
+  // iterate file extensions in order, load the config if it exists
+  for (const extension of EXTENSIONS) {
+    const configPath = path.join(basedir, name + extension);
+    if (await fileExists(configPath)) {
+      return importOrRequireConfig(configPath, basedir);
+    }
+  }
+
+  return null;
+}
+
+export { readConfig, ConfigLoaderError };

packages/config-loader/src/requireConfig.ts

@@ -0,0 +1,28 @@
+import { createRequire } from 'module';
+import ConfigLoaderError from './ConfigLoaderError.ts';
+
+const require = createRequire(import.meta.url);
+
+// These strings may be node-version dependent and need updating over time
+// They're just to display a helpful error message
+const ESM_ERRORS = [
+  "SyntaxError: Unexpected token 'export'",
+  'SyntaxError: Cannot use import statement outside a module',
+];
+
+function requireConfig(path: string): object {
+  try {
+    return require(path);
+  } catch (e) {
+    if (ESM_ERRORS.some(msg => (e as Error).stack?.includes(msg))) {
+      throw new ConfigLoaderError(
+        'You are using es module syntax in a config loaded as CommonJS module. ' +
+          'Use require/module.exports syntax, or load the file as es module by using the .mjs ' +
+          'file extension or by setting type="module" in your package.json.',
+      );
+    }
+    throw e;
+  }
+}
+
+export default requireConfig;

packages/config-loader/src/utils.js

@@ -1,15 +0,0 @@
-const fs = require('fs').promises;
-
-/**
- * @param {string} path
- */
-async function fileExists(path) {
-  try {
-    await fs.access(path);
-    return true;
-  } catch (e) {
-    return false;
-  }
-}
-
-module.exports = { fileExists };