@zgeoff/oxlint-config 0.2.0 → 0.2.2

package/README.md

@@ -6,8 +6,9 @@ restriction-rule cherry-picks, comment-style enforcement via `@stylistic`, and a
 function declarations, bare named exports, destructured and inline-typed parameters, ternary and
 await arguments, awaits hidden inside a control-flow condition or a `&&`/`||`/`??` chain, every
 JSDoc block, and any run of more than three line comments. `zgeoff/function-verb` enforces the
-function-naming taxonomy from the shared agent guidelines, and `zgeoff/test-beside-module` keeps
-each test file beside the module it tests.
+function-naming taxonomy from the shared agent guidelines, `zgeoff/test-beside-module` keeps each
+test file beside the module it tests, and `zgeoff/import-zones` fails an import that crosses a
+module boundary the repo declares.
 
 ## Usage
 
@@ -88,6 +89,67 @@ first statement, so put the comment above it:
 A second test file for a module (`<name>.host.test.ts`) needs its own `<name>.host.<ext>`, so the
 rule reports it beside only `<name>.ts`.
 
+## `zgeoff/import-zones`
+
+Off unless a repo configures it. The options name zones (path globs, relative to the repo root) and
+the boundaries between them. A file belongs to every zone its path matches, so zones may overlap.
+Each entry has a `name`, which starts its report, an optional `reason`, which ends it, and optional
+`from` zones and `ignore` globs that limit which importing files it judges.
+
+- `edges` judge an import that resolves to a file: relative, or the package's own name resolved
+  through its `exports` under `conditions` plus `default`. A target in a `to` zone fails unless it
+  is also in an `allow` zone; with `allow` alone, a target in none of the `allow` zones fails, a
+  target in no zone included. `allowTypeOnly` exempts type-only imports (`true`, or globs the target
+  must match), and `allowWithin: "src/*"` exempts an import inside the importer's own `src/<name>/`.
+- `modules` restrict a package or builtin (`node:` prefix optional, subpaths included) to the
+  `allow` zones; `allowTypeOnly: true` exempts type-only imports.
+- `globals` restrict a call to a global, bare or through `globalThis`, `self` or `window`.
+- `unzoned` reports a file in a `from` zone that belongs to none of `zones`.
+- `unresolved` reports a relative or self-referencing import that resolves to no file, and a dynamic
+  `import()` or `require()` whose specifier is computed.
+
+```jsonc
+{
+  "rules": {
+    "zgeoff/import-zones": [
+      "error",
+      {
+        "zones": {
+          "core": ["src/**"],
+          "support": ["src/{config,state}/**"],
+          "process": ["src/process/**"],
+          "tooling": ["scripts/**"],
+        },
+        "edges": [
+          { "name": "core-no-tooling", "from": ["core"], "to": ["tooling"] },
+          {
+            "name": "support",
+            "from": ["support"],
+            "allow": ["support"],
+            "allowTypeOnly": ["**/types.ts"],
+            "reason": "support modules sit below the stages",
+          },
+        ],
+        "modules": [
+          {
+            "name": "child-process",
+            "modules": ["node:child_process"],
+            "from": ["core"],
+            "allow": ["process"],
+            "allowTypeOnly": true,
+          },
+        ],
+        "unresolved": [{ "name": "unresolved", "from": ["core"] }],
+      },
+    ],
+  },
+}
+```
+
+Exempt a known violation with a next-line disable comment that names the ticket that removes it. An
+unzoned report sits on the first statement, so its comment goes above that. Run lint with
+`--report-unused-disable-directives-severity error` so a comment outlives no import.
+
 ## Notes
 
 - The config enables the `typescript`, `unicorn`, `oxc`, `import`, and `promise` plugins and loads

package/find-repo-root.js

@@ -0,0 +1,20 @@
+import { existsSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+
+// the nearest ancestor holding `.git` (a directory, or a worktree's file), or
+// null outside a repository
+export default function findRepoRoot(filename) {
+  let dir = dirname(filename);
+
+  while (!existsSync(join(dir, '.git'))) {
+    const parent = dirname(dir);
+
+    if (parent === dir) {
+      return null;
+    }
+
+    dir = parent;
+  }
+
+  return dir;
+}

package/import-zones-schema.js

@@ -0,0 +1,50 @@
+// the options of zgeoff/import-zones; oxlint rejects a config that breaks it
+const stringList = { type: 'array', items: { type: 'string' } };
+
+function buildEntrySchema(properties, required, anyOf) {
+  return {
+    type: 'array',
+    items: {
+      type: 'object',
+      properties: {
+        name: { type: 'string' },
+        from: stringList,
+        ignore: stringList,
+        reason: { type: 'string' },
+        ...properties,
+      },
+      required: ['name', ...required],
+      additionalProperties: false,
+      ...(anyOf === undefined ? {} : { anyOf }),
+    },
+  };
+}
+
+const importZonesSchema = {
+  type: 'object',
+  properties: {
+    zones: { type: 'object', additionalProperties: stringList },
+    extensions: stringList,
+    conditions: stringList,
+    edges: buildEntrySchema(
+      {
+        to: stringList,
+        allow: stringList,
+        allowTypeOnly: { anyOf: [{ type: 'boolean' }, stringList] },
+        allowWithin: { type: 'string' },
+      },
+      ['from'],
+      [{ required: ['to'] }, { required: ['allow'] }],
+    ),
+    modules: buildEntrySchema(
+      { modules: stringList, allow: stringList, allowTypeOnly: { type: 'boolean' } },
+      ['modules', 'allow'],
+    ),
+    globals: buildEntrySchema({ globals: stringList, allow: stringList }, ['globals', 'allow']),
+    unzoned: buildEntrySchema({ zones: stringList }, ['from', 'zones']),
+    unresolved: buildEntrySchema({}, []),
+  },
+  additionalProperties: false,
+};
+
+export default importZonesSchema;

package/import-zones.js

@@ -0,0 +1,295 @@
+import { relative, sep } from 'node:path';
+import findRepoRoot from './find-repo-root.js';
+import importZonesSchema from './import-zones-schema.js';
+import loadZoneOptions from './load-zone-options.js';
+import resolveImportTarget from './resolve-import-target.js';
+
+// Judges each import against named zones: path globs relative to the repo
+// root, which may overlap. A file belongs to every zone its path matches.
+
+function buildFileState(context) {
+  const options = loadZoneOptions(context.options[0] ?? {});
+  const filename = context.physicalFilename;
+  const root = findRepoRoot(filename) ?? context.cwd;
+  const path = toRootPath(root, filename);
+
+  return { context, options, filename, root, path, zones: collectZones(options.zones, path) };
+}
+
+function toRootPath(root, path) {
+  return relative(root, path).split(sep).join('/');
+}
+
+function collectZones(zones, path) {
+  return zones.filter((zone) => zone.match(path)).map((zone) => zone.name);
+}
+
+function isInAny(fileZones, names) {
+  return names.some((name) => fileZones.includes(name)) === true;
+}
+
+// an entry without `from` applies to every file
+function collectEntries(file, entries) {
+  return entries.filter(
+    (entry) =>
+      (entry.from === undefined || isInAny(file.zones, entry.from)) && !entry.ignore(file.path),
+  );
+}
+
+// `at` is `{ node }` or `{ loc }`
+function emitReport(file, entry, report) {
+  const reason = entry.reason === undefined ? '' : ` — ${entry.reason}`;
+
+  file.context.report({
+    ...report.at,
+    messageId: report.messageId,
+    data: { rule: entry.name, reason, ...report.data },
+  });
+}
+
+function formatZones(names) {
+  return names.length === 0 ? 'no zone' : names.join(', ');
+}
+
+// `imported` is `{ node, source, typeOnly }`, one per import of any form
+function checkImport(file, imported) {
+  const specifier = findStaticSpecifier(imported.source);
+
+  if (specifier === null) {
+    emitUnresolved(file, imported.node, { messageId: 'computed', data: {} });
+
+    return;
+  }
+
+  const target = resolveImportTarget(file.filename, specifier, {
+    root: file.root,
+    extensions: file.options.extensions,
+    conditions: file.options.conditions,
+  });
+
+  if (target.kind === 'module') {
+    checkModule(file, imported, target.specifier);
+  } else if (target.kind === 'missing') {
+    emitUnresolved(file, imported.node, { messageId: 'unresolved', data: { specifier } });
+  } else {
+    checkEdge(file, imported, toRootPath(file.root, target.path));
+  }
+}
+
+// a string literal, or a template literal with nothing interpolated
+function findStaticSpecifier(node) {
+  if (node?.type === 'Literal' && typeof node.value === 'string') {
+    return node.value;
+  }
+
+  if (node?.type === 'TemplateLiteral' && node.expressions.length === 0) {
+    return node.quasis.map((quasi) => quasi.value.cooked ?? '').join('');
+  }
+
+  return null;
+}
+
+function emitUnresolved(file, node, report) {
+  for (const entry of collectEntries(file, file.options.unresolved)) {
+    emitReport(file, entry, { at: { node }, ...report });
+  }
+}
+
+function checkModule(file, imported, specifier) {
+  for (const entry of collectEntries(file, file.options.modules)) {
+    const isAllowed =
+      isInAny(file.zones, entry.allow) || (imported.typeOnly && entry.allowTypeOnly === true);
+
+    if (!isAllowed && isRestrictedModule(entry, specifier)) {
+      emitReport(file, entry, {
+        at: { node: imported.node },
+        messageId: 'module',
+        data: { module: specifier, allow: formatZones(entry.allow) },
+      });
+    }
+  }
+}
+
+function isRestrictedModule(entry, specifier) {
+  const name = toModuleName(specifier);
+
+  return entry.modules.some((module) => {
+    const restricted = toModuleName(module);
+
+    return name === restricted || name.startsWith(`${restricted}/`);
+  });
+}
+
+function toModuleName(specifier) {
+  return specifier.replace(/^node:/u, '');
+}
+
+function checkEdge(file, imported, target) {
+  const targetZones = collectZones(file.options.zones, target);
+
+  for (const entry of collectEntries(file, file.options.edges)) {
+    // `to` picks the targets judged, every target when absent; `allow`
+    // exempts some of them
+    const isForbidden =
+      (entry.to === undefined || isInAny(targetZones, entry.to)) &&
+      (entry.allow === undefined || !isInAny(targetZones, entry.allow));
+    const isTypeExempt =
+      imported.typeOnly &&
+      (entry.allowTypeOnly === true || entry.typeOnlyTargets?.(target) === true);
+
+    if (isForbidden && !isTypeExempt && entry.within?.(file.path, target) !== true) {
+      emitReport(file, entry, {
+        at: { node: imported.node },
+        messageId: 'edge',
+        data: {
+          from: formatZones(entry.from.filter((name) => file.zones.includes(name))),
+          target,
+          to: formatZones(targetZones),
+        },
+      });
+    }
+  }
+}
+
+function checkUnzoned(file, program) {
+  // anchor on the first statement, as test-beside-module does, so a disable
+  // comment at the top of the file covers the report
+  const start = program.body[0]?.loc.start ?? { line: 1, column: 0 };
+
+  for (const entry of collectEntries(file, file.options.unzoned)) {
+    if (!isInAny(file.zones, entry.zones)) {
+      emitReport(file, entry, {
+        at: { loc: { start, end: start } },
+        messageId: 'unzoned',
+        data: { zones: formatZones(entry.zones) },
+      });
+    }
+  }
+}
+
+function checkGlobalCall(file, node) {
+  for (const entry of collectEntries(file, file.options.globals)) {
+    const global = findGlobalCallName(file, node, entry.globals);
+
+    if (global !== null && !isInAny(file.zones, entry.allow)) {
+      emitReport(file, entry, {
+        at: { node },
+        messageId: 'global',
+        data: { global, allow: formatZones(entry.allow) },
+      });
+    }
+  }
+}
+
+const globalObjects = new Set(['globalThis', 'self', 'window']);
+
+// a call of the global itself, so a local binding of the same name passes
+function findGlobalCallName(file, node, names) {
+  const callee = node.callee;
+  let name = null;
+  let binding = null;
+
+  if (callee.type === 'Identifier' && names.includes(callee.name)) {
+    name = callee.name;
+    binding = callee.name;
+  } else if (
+    callee.type === 'MemberExpression' &&
+    !callee.computed &&
+    callee.object.type === 'Identifier' &&
+    globalObjects.has(callee.object.name) &&
+    callee.property.type === 'Identifier' &&
+    names.includes(callee.property.name)
+  ) {
+    name = callee.property.name;
+    binding = callee.object.name;
+  }
+
+  return name === null || isLocalBinding(file, node, binding) ? null : name;
+}
+
+function isLocalBinding(file, node, name) {
+  let scope = file.context.sourceCode.getScope(node);
+
+  while (scope !== null) {
+    if ((scope.set.get(name)?.defs.length ?? 0) > 0) {
+      return true;
+    }
+
+    scope = scope.upper;
+  }
+
+  return false;
+}
+
+function isTypeOnlyImport(node) {
+  return (
+    node.importKind === 'type' ||
+    (node.specifiers.length > 0 && node.specifiers.every((entry) => entry.importKind === 'type'))
+  );
+}
+
+function isTypeOnlyExport(node) {
+  return (
+    node.exportKind === 'type' ||
+    (node.specifiers.length > 0 && node.specifiers.every((entry) => entry.exportKind === 'type'))
+  );
+}
+
+const importZones = {
+  meta: {
+    type: 'problem',
+    messages: {
+      edge: '{{rule}}: {{from}} must not import {{target}} ({{to}}){{reason}}',
+      module: '{{rule}}: {{module}} is allowed only in {{allow}}{{reason}}',
+      global: '{{rule}}: {{global}}() is allowed only in {{allow}}{{reason}}',
+      unzoned: '{{rule}}: this file belongs to none of {{zones}}; add its path to one{{reason}}',
+      unresolved: '{{rule}}: cannot resolve {{specifier}}{{reason}}',
+      computed: '{{rule}}: cannot check a computed import specifier{{reason}}',
+    },
+    schema: [importZonesSchema],
+  },
+  create(context) {
+    const file = buildFileState(context);
+
+    return {
+      Program(node) {
+        checkUnzoned(file, node);
+      },
+      ImportDeclaration(node) {
+        checkImport(file, { node, source: node.source, typeOnly: isTypeOnlyImport(node) });
+      },
+      ExportNamedDeclaration(node) {
+        if (node.source !== null) {
+          checkImport(file, { node, source: node.source, typeOnly: isTypeOnlyExport(node) });
+        }
+      },
+      ExportAllDeclaration(node) {
+        checkImport(file, { node, source: node.source, typeOnly: node.exportKind === 'type' });
+      },
+      ImportExpression(node) {
+        checkImport(file, { node, source: node.source, typeOnly: false });
+      },
+      TSImportType(node) {
+        checkImport(file, { node, source: node.source ?? node.argument?.literal, typeOnly: true });
+      },
+      TSImportEqualsDeclaration(node) {
+        const reference = node.moduleReference;
+
+        if (reference.type === 'TSExternalModuleReference') {
+          const typeOnly = node.importKind === 'type';
+
+          checkImport(file, { node, source: reference.expression, typeOnly });
+        }
+      },
+      CallExpression(node) {
+        checkGlobalCall(file, node);
+
+        if (node.callee.type === 'Identifier' && node.callee.name === 'require') {
+          checkImport(file, { node, source: node.arguments[0], typeOnly: false });
+        }
+      },
+    };
+  },
+};
+
+export default importZones;

package/load-zone-options.js

@@ -0,0 +1,64 @@
+import makeGlobMatcher from './make-glob-matcher.js';
+
+const defaultExtensions = ['.ts', '.tsx', '.mts', '.cts', '.js', '.jsx', '.mjs', '.cjs'];
+
+const loadedOptions = new Map();
+
+// oxlint hands each file its own copy of the options, so the compiled form is
+// keyed by content
+export default function loadZoneOptions(options) {
+  const key = JSON.stringify(options);
+  let loaded = loadedOptions.get(key);
+
+  if (loaded === undefined) {
+    loaded = buildZoneOptions(options);
+
+    loadedOptions.set(key, loaded);
+  }
+
+  return loaded;
+}
+
+function buildZoneOptions(options) {
+  const globsByZone = options.zones ?? {};
+  const zones = Object.keys(globsByZone).map((name) => ({
+    name,
+    match: makeGlobMatcher(globsByZone[name]),
+  }));
+
+  const buildEntries = (entries) => (entries ?? []).map((entry) => buildEntry(entry));
+
+  return {
+    zones,
+    extensions: options.extensions ?? defaultExtensions,
+    conditions: new Set([...(options.conditions ?? []), 'default']),
+    edges: buildEntries(options.edges),
+    modules: buildEntries(options.modules),
+    globals: buildEntries(options.globals),
+    unzoned: buildEntries(options.unzoned),
+    unresolved: buildEntries(options.unresolved),
+  };
+}
+
+function buildEntry(entry) {
+  return {
+    ...entry,
+    ignore: makeGlobMatcher(entry.ignore ?? []),
+    typeOnlyTargets: Array.isArray(entry.allowTypeOnly)
+      ? makeGlobMatcher(entry.allowTypeOnly)
+      : null,
+    within: entry.allowWithin === undefined ? null : makeWithinMatcher(entry.allowWithin),
+  };
+}
+
+// `src/*` keeps an import inside the importer's own `src/<name>/` directory
+function makeWithinMatcher(glob) {
+  const depth = glob.split('/').length;
+  const match = makeGlobMatcher([glob]);
+
+  return (from, to) => {
+    const prefix = from.split('/').slice(0, depth).join('/');
+
+    return match(prefix) && to.split('/').slice(0, depth).join('/') === prefix;
+  };
+}

package/make-glob-matcher.js

@@ -0,0 +1,36 @@
+// supports `**`, `*`, `?` and one level of `{a,b}`; every other character is
+// literal. Paths and globs use `/`.
+export default function makeGlobMatcher(globs) {
+  const patterns = globs.map((glob) => toGlobRegExp(glob));
+
+  return (path) => patterns.some((pattern) => pattern.test(path));
+}
+
+const braceGroup = /(?<group>\{[^{}]*\})/u;
+
+function toGlobRegExp(glob) {
+  const source = glob
+    .split(braceGroup)
+    .map((part) => (braceGroup.test(part) ? toAlternativesSource(part) : toGlobSource(part)))
+    .join('');
+
+  return new RegExp(`^${source}$`, 'u');
+}
+
+function toAlternativesSource(group) {
+  const alternatives = group
+    .slice(1, -1)
+    .split(',')
+    .map((part) => toGlobSource(part));
+
+  return `(?:${alternatives.join('|')})`;
+}
+
+const globTokenSources = { '**/': '(?:.*/)?', '**': '.*', '*': '[^/]*', '?': '[^/]' };
+
+function toGlobSource(text) {
+  return text.replaceAll(
+    /\*\*\/|\*\*|\*|\?|[$()+.[\\\]^{|}]/gu,
+    (token) => globTokenSources[token] ?? `\\${token}`,
+  );
+}

package/oxlintrc.json

@@ -38,10 +38,12 @@
     ],
 
     // own-line comments get a blank line above so they don't crowd the
-    // previous statement; comments opening a block/object/class/etc are exempt
+    // previous statement; comments opening a block/object/class/etc are exempt,
+    // and so are oxlint directives, which oxfmt's import sort packs tight
     "@stylistic/lines-around-comment": [
       "error",
       {
+        "ignorePattern": "^\\s*oxlint-",
         "beforeLineComment": true,
         "beforeBlockComment": true,
         "allowBlockStart": true,
@@ -120,6 +122,27 @@
     // this config targets node/bun tooling — node builtins are the platform
     "import/no-nodejs-modules": "off",
 
+    // a file past 500 non-blank lines holds more than one concept, and a fifth
+    // parameter wants an options object
+    "max-lines": ["error", { "max": 500, "skipBlankLines": true }],
+    "max-params": ["error", { "max": 4 }],
+
+    // counts that fire on code already in its clearest form
+    "max-statements": "off",
+    "max-lines-per-function": "off",
+    "import/max-dependencies": "off",
+
+    // the fix reads worse than the code: tsc checks assignment before use, a
+    // guard `continue` is an early return, awaits in a loop keep order, and
+    // an event or timer needs a bare `new Promise`
+    "init-declarations": "off",
+    "no-continue": "off",
+    "no-await-in-loop": "off",
+    "promise/avoid-new": "off",
+
+    // a library or platform handle has no readonly form
+    "typescript/prefer-readonly-parameter-types": "off",
+
     // preload-style modules (matcher registration, type augmentation) are
     // side-effect imports by design
     "import/no-unassigned-import": [

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zgeoff/oxlint-config",
-  "version": "0.2.0",
+  "version": "0.2.2",
   "description": "Shareable oxlint config: strict categories, house-style rules, and a custom JS plugin",
   "license": "MIT",
   "repository": {
@@ -15,6 +15,12 @@
     "max-consecutive-line-comments.js",
     "no-jsdoc.js",
     "test-beside-module.js",
+    "import-zones.js",
+    "import-zones-schema.js",
+    "find-repo-root.js",
+    "load-zone-options.js",
+    "make-glob-matcher.js",
+    "resolve-import-target.js",
     "index.js"
   ],
   "type": "module",

package/plugin.js

@@ -1,4 +1,5 @@
 import functionVerb from './function-verb.js';
+import importZones from './import-zones.js';
 import maxConsecutiveLineComments from './max-consecutive-line-comments.js';
 import noJSDoc from './no-jsdoc.js';
 import testBesideModule from './test-beside-module.js';
@@ -97,6 +98,7 @@ const plugin = {
     'max-consecutive-line-comments': maxConsecutiveLineComments,
     'function-verb': functionVerb,
     'test-beside-module': testBesideModule,
+    'import-zones': importZones,
   },
 };
 

package/resolve-import-target.js

@@ -0,0 +1,177 @@
+import { existsSync, readFileSync, statSync } from 'node:fs';
+import { dirname, join, resolve } from 'node:path';
+
+// a `.js` specifier in TypeScript source names the `.ts` file beside it
+const sourceExtensions = { '.js': ['.ts', '.tsx'], '.mjs': ['.mts'], '.cjs': ['.cts'] };
+
+// `module` with the specifier for a package or builtin, `file` with the
+// absolute path when the import resolves, `missing` otherwise. The package's
+// own name resolves through its `exports`, and `#` names through its `imports`.
+export default function resolveImportTarget(filename, specifier, settings) {
+  if (isPathSpecifier(specifier)) {
+    return toTarget(findImportedFile(filename, specifier, settings.extensions));
+  }
+
+  const manifest = findPackageManifest(dirname(filename), settings.root);
+
+  return resolveManifestTarget(manifest, specifier, settings.conditions);
+}
+
+function resolveManifestTarget(manifest, specifier, conditions) {
+  const name = manifest?.name;
+
+  if (specifier.startsWith('#')) {
+    const mapped = findMappedTarget(manifest?.imports, specifier, conditions);
+
+    return mapped !== null && !isPathSpecifier(mapped)
+      ? { kind: 'module', specifier: mapped }
+      : toMappedTarget(manifest, mapped);
+  }
+
+  if (typeof name === 'string' && (specifier === name || specifier.startsWith(`${name}/`))) {
+    const subpath = `.${specifier.slice(name.length)}`;
+
+    return toMappedTarget(
+      manifest,
+      findMappedTarget(toSubpathMap(manifest.exports), subpath, conditions),
+    );
+  }
+
+  return { kind: 'module', specifier };
+}
+
+function toTarget(path) {
+  return path === null ? { kind: 'missing' } : { kind: 'file', path };
+}
+
+function toMappedTarget(manifest, mapped) {
+  return mapped === null
+    ? { kind: 'missing' }
+    : { kind: 'file', path: resolve(manifest.dir, mapped) };
+}
+
+function isPathSpecifier(specifier) {
+  return /^[./]/u.test(specifier);
+}
+
+const manifests = new Map();
+
+function findPackageManifest(dir, root) {
+  if (manifests.has(dir)) {
+    return manifests.get(dir);
+  }
+
+  const path = join(dir, 'package.json');
+  const parent = dirname(dir);
+  let manifest = null;
+
+  if (existsSync(path)) {
+    manifest = { dir, ...JSON.parse(readFileSync(path, 'utf8')) };
+  } else if (dir !== root && parent !== dir) {
+    manifest = findPackageManifest(parent, root);
+  }
+
+  manifests.set(dir, manifest);
+
+  return manifest;
+}
+
+// `exports` without `.` keys is the target of the package's own name alone
+function toSubpathMap(exports) {
+  const isSubpathMap =
+    typeof exports === 'object' &&
+    exports !== null &&
+    !Array.isArray(exports) &&
+    Object.keys(exports).some((key) => key.startsWith('.'));
+
+  return isSubpathMap || exports === undefined ? exports : { '.': exports };
+}
+
+// an exact key wins; otherwise the `*` pattern with the longest prefix, then
+// the longest key, as node picks it, its match substituted into the target
+function findMappedTarget(map, key, conditions) {
+  if (typeof map !== 'object' || map === null) {
+    return null;
+  }
+
+  if (Object.hasOwn(map, key)) {
+    return findConditionTarget(map[key], conditions);
+  }
+
+  const [pattern] = Object.keys(map)
+    .filter((candidate) => isPatternMatch(candidate, key))
+    .toSorted((left, right) => {
+      const byPrefix = right.indexOf('*') - left.indexOf('*');
+
+      return byPrefix === 0 ? right.length - left.length : byPrefix;
+    });
+
+  return pattern === undefined ? null : findPatternTarget(map, pattern, { key, conditions });
+}
+
+function findPatternTarget(map, pattern, lookup) {
+  const star = pattern.indexOf('*');
+  const match = lookup.key.slice(star, lookup.key.length - (pattern.length - star - 1));
+  const target = findConditionTarget(map[pattern], lookup.conditions);
+
+  return target === null ? null : target.replaceAll('*', match);
+}
+
+function isPatternMatch(pattern, key) {
+  const star = pattern.indexOf('*');
+
+  if (star === -1 || pattern.includes('*', star + 1)) {
+    return false;
+  }
+
+  const prefix = pattern.slice(0, star);
+  const suffix = pattern.slice(star + 1);
+
+  return key.length >= pattern.length && key.startsWith(prefix) && key.endsWith(suffix);
+}
+
+// node's rule: the first key, in object order, that names an active
+// condition; in an array, the first entry that yields a target
+function findConditionTarget(value, conditions) {
+  if (typeof value === 'string') {
+    return value;
+  }
+
+  if (typeof value !== 'object' || value === null) {
+    return null;
+  }
+
+  const candidates = Array.isArray(value)
+    ? value
+    : Object.keys(value)
+        .filter((condition) => conditions.has(condition))
+        .map((condition) => value[condition]);
+
+  return (
+    candidates
+      .map((candidate) => findConditionTarget(candidate, conditions))
+      .find((target) => target !== null) ?? null
+  );
+}
+
+function findImportedFile(filename, specifier, extensions) {
+  const base = resolve(dirname(filename), specifier);
+  const swapped = Object.keys(sourceExtensions).flatMap((ext) =>
+    base.endsWith(ext)
+      ? sourceExtensions[ext].map((other) => `${base.slice(0, -ext.length)}${other}`)
+      : [],
+  );
+
+  const candidates = [
+    base,
+    ...swapped,
+    ...extensions.map((ext) => `${base}${ext}`),
+    ...extensions.map((ext) => join(base, `index${ext}`)),
+  ];
+
+  return candidates.find((candidate) => isFile(candidate)) ?? null;
+}
+
+function isFile(path) {
+  return statSync(path, { throwIfNoEntry: false })?.isFile() ?? false;
+}

package/test-beside-module.js

@@ -1,35 +1,20 @@
-import { existsSync, readdirSync, statSync } from 'node:fs';
+import { readdirSync, statSync } from 'node:fs';
 import { basename, dirname, join, relative, sep } from 'node:path';
+import findRepoRoot from './find-repo-root.js';
 
 const testFilePattern = /^(?<base>.+)\.test\.tsx?$/u;
 
 // suites that run the whole program have no single module to sit beside
 const exemptRootDirs = new Set(['e2e', 'evals']);
 
+// the repo root, not oxlint's working directory, so a per-package lint
+// script neither exempts a package's own e2e/ nor flags the root one
 function isUnderExemptRoot(cwd, filename) {
   const [first] = relative(findRepoRoot(filename) ?? cwd, filename).split(sep);
 
   return exemptRootDirs.has(first);
 }
 
-// the repo root, not oxlint's working directory, so a per-package lint
-// script neither exempts a package's own e2e/ nor flags the root one
-function findRepoRoot(filename) {
-  let dir = dirname(filename);
-
-  while (!existsSync(join(dir, '.git'))) {
-    const parent = dirname(dir);
-
-    if (parent === dir) {
-      return null;
-    }
-
-    dir = parent;
-  }
-
-  return dir;
-}
-
 // a module is `<name>.<ext>` with a single-segment extension, so a
 // declaration file never stands in for one, and neither does another test
 // (`foo.test.ts` beside `foo.test.test.ts`)