@jameswyse/oxc-config 0.3.0 → 0.5.0

package/REFERENCE.md

@@ -72,11 +72,11 @@ Native rules: `prefer-const`, `no-param-reassign` and `oxc/no-accumulating-sprea
 
 These rules run only once the project names its owners through the [project boundary options](docs/configuration.md#enforce-project-boundaries).
 
-- `wyse/no-env-access` (`env`): reading `process.env` or `import.meta.env`, or destructuring `env` from either, outside the owners, config files and scripts. It doesn't check that the owner validates what it reads.
-- `wyse/import-boundaries` (`boundaries`): a value import, re-export, literal dynamic import, or `require` call, including a loader made with `createRequire` from `node:module`, that matches a `deny` glob. Type-only imports and `import("…")` types pass unless the boundary sets `types: true`. It doesn't check computed imports.
+- `wyse/no-env-access` (`env`): reading `process.env` or `import.meta.env` outside the owners, config files and scripts. That includes destructuring `env`, `globalThis.process.env`, `global.process.env`, `process["env"]` and `Reflect.get(process, "env")`, including with `"env" as const`, importing `env` from `node:process` or `process`, reading `env` from those modules' default, namespace, literal dynamic import or `require`, including through a loader made with `createRequire` from `node:module` or `module` or a `const` copy of a loader, and re-exporting `env`, the default or the whole module from them with `export { ... } from` or `export * from`. Other `node:process` imports and re-exports, such as `argv`, type-only re-exports, a `require` function the file defines itself, a loader variable that's reassigned, and a `process` property on `window` or `self` pass. It doesn't check that the owner validates what it reads.
+- `wyse/import-boundaries` (`boundaries`): a value import, re-export, literal dynamic import, or `require` call, including a loader made with `createRequire` from `node:module` or `module`, whether stored, copied to another `const` or called directly as `createRequire(import.meta.url)("…")`, that matches a `deny` glob. A loader variable that's reassigned doesn't count. Type-only imports and `import("…")` types pass unless the boundary sets `types: true`. It doesn't check computed imports.
 - `wyse/server-action-guard` (`serverActionGuards`): a `"use server"` action that doesn't start by awaiting a guard, and indirect or default exports from server-action modules. Non-exported helpers and test files pass.
-- `wyse/no-ambient-clock` (`clock`): `Date.now()` and argument-less `new Date()`, including through `globalThis` or `window`. Parameter defaults, uncalled `Date.now`, provider functions that only return the read, and test files pass.
-- `wyse/no-ambient-random` (`random`): `Math.random()`, `crypto.randomUUID()`, and `randomUUID` or `randomInt` from `node:crypto`. The same exceptions apply. `randomBytes` and `getRandomValues` pass because they generate secrets.
+- `wyse/no-ambient-clock` (`clock`): `Date.now()`, `Date()` and argument-less `new Date()`, including through `globalThis` or `window`. It also reports argument-less `new TZDate()` and `new TZDateMini()` and one-argument `TZDate.tz(zone)` from `@date-fns/tz`, `@date-fns/tz/date` or `@date-fns/tz/date/mini`, and the date-fns helpers that read the current time: `constructNow`, the `startOf` and `endOf` helpers for today, tomorrow and yesterday, `isToday`, `isTomorrow`, `isYesterday`, `isPast`, `isFuture`, the `isThis*` helpers, `formatDistanceToNow`, `formatDistanceToNowStrict`, `isMatch`, and `isMatch` and `isMatchWithOptions` from `date-fns/fp`. A helper reports where it's called, where it's passed or stored uncalled, such as `dates.filter(isPast)` or `{ check: isToday }`, and where it's exported by local name, such as `export { isPast }`. A `date-fns/fp` helper reports once at the end of its call chain, so the partial application in `values.filter(isMatch("yyyy"))` reports too. A `const` alias reports where it's used. Helpers count whether they're imported by name, through a namespace, from a `date-fns/<name>` subpath, by literal dynamic import or by `require`. Re-exporting one of these helpers with `export { ... } from`, or a module that contains one, such as `date-fns` or `date-fns/fp`, with `export * from`, also reports, because calls through the re-export no longer resolve to date-fns. Helpers that compare with a given date, such as `isSameDay`, type positions such as `typeof isPast`, type-only imports and exports, and re-exports of `TZDate`, `TZDateMini`, other date-fns helpers or types pass. Parameter defaults, such as `check = isPast`, uncalled `Date.now`, provider functions that only return the read, including through `.call`, `.apply` or `.bind`, write-only uses of a helper's name on a module object, such as `d.isPast = check`, `[d.isPast] = values`, `for (d.isPast of values)`, `delete d.isPast` and `delete d?.isPast`, and test files pass. Parentheses, `as`, `satisfies` and `!` don't change the result, so `(Date.now as typeof Date.now)()` reports and `{ now: () => startOfToday() as Date }` passes.
+- `wyse/no-ambient-random` (`random`): `Math.random()`, `crypto.randomUUID()`, and `randomUUID` or `randomInt` from `node:crypto`. The same exceptions and wrapper handling apply. `randomBytes` and `getRandomValues` pass because they generate secrets.
 
 ## Tests
 

package/dist/rules/electron-no-remote-module.js

@@ -1,5 +1,5 @@
 import { defineRule } from "@oxlint/plugins";
-import { isGlobal, propertyName, variableFor } from "../shared/index.js";
+import { isGlobal, moduleExportName, propertyName, variableFor } from "../shared/index.js";
 function moduleName(node) {
     return node?.type === "Literal" && typeof node.value === "string" ? node.value : null;
 }
@@ -38,9 +38,6 @@ function isElectronModule(sourceCode, node) {
         definitionNode.id.type === "Identifier" &&
         isElectron(requiredModule(sourceCode, definitionNode.init)));
 }
-function specifierName(node) {
-    return node.type === "Identifier" ? node.name : node.value;
-}
 export const electronNoRemoteModule = defineRule({
     meta: {
         type: "problem",
@@ -66,7 +63,7 @@ export const electronNoRemoteModule = defineRule({
                 }
                 for (const specifier of node.specifiers) {
                     if (specifier.type === "ImportSpecifier" &&
-                        specifierName(specifier.imported) === "remote") {
+                        moduleExportName(specifier.imported) === "remote") {
                         context.report({ node: specifier, messageId: "remote" });
                     }
                 }
@@ -76,7 +73,7 @@ export const electronNoRemoteModule = defineRule({
                     return;
                 }
                 for (const specifier of node.specifiers) {
-                    if (specifierName(specifier.local) === "remote") {
+                    if (moduleExportName(specifier.local) === "remote") {
                         context.report({ node: specifier, messageId: "remote" });
                     }
                 }

package/dist/rules/import-boundaries.js

@@ -1,6 +1,6 @@
 import { dirname, resolve as resolvePath } from "node:path";
 import { defineRule } from "@oxlint/plugins";
-import { importedBinding, isGlobal, matchesAny, projectPath, variableFor, } from "../shared/index.js";
+import { isRequire, matchesAny, projectPath } from "../shared/index.js";
 function isStringList(value) {
     return Array.isArray(value) && value.every((item) => typeof item === "string");
 }
@@ -29,17 +29,6 @@ function parseSettings(options) {
     }
     return { root: option.root, boundaries: option.boundaries.map(parseBoundary) };
 }
-const nodeModuleSources = new Set(["module", "node:module"]);
-function isRequire(sourceCode, callee) {
-    if (isGlobal(sourceCode, callee, "require")) {
-        return true;
-    }
-    const definition = variableFor(sourceCode, callee)?.defs[0];
-    const init = definition?.node.type === "VariableDeclarator" ? definition.node.init : null;
-    const factory = init?.type === "CallExpression" ? init.callee : null;
-    const binding = factory === null ? null : importedBinding(sourceCode, factory);
-    return (binding !== null && nodeModuleSources.has(binding.source) && binding.name === "createRequire");
-}
 export const importBoundaries = defineRule({
     meta: {
         type: "problem",

package/dist/rules/no-ambient-clock.js

@@ -1,5 +1,127 @@
 import { defineRule } from "@oxlint/plugins";
-import { propertyName, isGlobalValue, isInjectionSeam } from "../shared/index.js";
+import { importedBinding, isGlobalValue, isInjectedValue, isInjectionSeam, moduleExportName, outermostExpression, staticPropertyName, unwrapExpression, variableFor, } from "../shared/index.js";
+const timeZoneModules = new Set(["@date-fns/tz", "@date-fns/tz/date", "@date-fns/tz/date/mini"]);
+const timeZoneDates = new Set(["TZDate", "TZDateMini"]);
+const clockHelpers = new Set([
+    "date-fns/constructNow",
+    "date-fns/startOfToday",
+    "date-fns/endOfToday",
+    "date-fns/startOfTomorrow",
+    "date-fns/endOfTomorrow",
+    "date-fns/startOfYesterday",
+    "date-fns/endOfYesterday",
+    "date-fns/isToday",
+    "date-fns/isTomorrow",
+    "date-fns/isYesterday",
+    "date-fns/isPast",
+    "date-fns/isFuture",
+    "date-fns/isThisSecond",
+    "date-fns/isThisMinute",
+    "date-fns/isThisHour",
+    "date-fns/isThisWeek",
+    "date-fns/isThisISOWeek",
+    "date-fns/isThisMonth",
+    "date-fns/isThisQuarter",
+    "date-fns/isThisYear",
+    "date-fns/formatDistanceToNow",
+    "date-fns/formatDistanceToNowStrict",
+    "date-fns/isMatch",
+    "date-fns/fp/isMatch",
+    "date-fns/fp/isMatchWithOptions",
+]);
+function helperPath(source, name) {
+    return name === "default" || source.endsWith(`/${name}`) ? source : `${source}/${name}`;
+}
+function isClockHelper(sourceCode, node) {
+    const binding = importedBinding(sourceCode, node);
+    return binding !== null && clockHelpers.has(helperPath(binding.source, binding.name));
+}
+function exposesClockHelper(source) {
+    return [...clockHelpers].some((helper) => helperPath(source, helper.slice(helper.lastIndexOf("/") + 1)) === helper);
+}
+function isTypeImport(definition) {
+    const declaration = definition.parent;
+    const specifier = definition.node;
+    return (declaration?.type === "ImportDeclaration" &&
+        (declaration.importKind === "type" ||
+            (specifier.type === "ImportSpecifier" && specifier.importKind === "type")));
+}
+function isTypePosition(node) {
+    const parent = node.parent;
+    const declaration = parent?.parent;
+    return (parent?.type === "TSTypeQuery" ||
+        parent?.type === "TSQualifiedName" ||
+        (parent?.type === "ExportSpecifier" &&
+            (parent.exportKind === "type" ||
+                (declaration?.type === "ExportNamedDeclaration" && declaration.exportKind === "type"))));
+}
+function isValueReference(sourceCode, node) {
+    const variable = variableFor(sourceCode, node);
+    const definition = variable?.defs[0];
+    return (variable !== null &&
+        definition !== undefined &&
+        !isTypeImport(definition) &&
+        !isTypePosition(node) &&
+        variable.references.some((reference) => reference.identifier === node && reference.isRead()));
+}
+const functionMethods = new Set(["call", "apply", "bind"]);
+function helperUse(node) {
+    const value = outermostExpression(node);
+    const parent = value.parent;
+    if (parent?.type === "CallExpression" && parent.callee === value) {
+        return helperUse(parent);
+    }
+    if (parent?.type === "MemberExpression" &&
+        parent.object === value &&
+        functionMethods.has(staticPropertyName(parent) ?? "")) {
+        const use = helperUse(parent);
+        return use === parent ? node : use;
+    }
+    return node;
+}
+function isWriteTarget(node) {
+    const expression = outermostExpression(node);
+    const target = expression.parent?.type === "ChainExpression"
+        ? outermostExpression(expression.parent)
+        : expression;
+    const parent = target.parent;
+    return ((parent?.type === "AssignmentExpression" &&
+        parent.left === target &&
+        parent.operator === "=") ||
+        ((parent?.type === "ForOfStatement" || parent?.type === "ForInStatement") &&
+            parent.left === target) ||
+        (parent?.type === "UnaryExpression" && parent.operator === "delete") ||
+        (parent?.type === "AssignmentPattern" && parent.left === target) ||
+        (parent?.type === "Property" &&
+            parent.value === target &&
+            parent.parent.type === "ObjectPattern") ||
+        parent?.type === "ArrayPattern" ||
+        parent?.type === "RestElement");
+}
+function isFollowedAlias(node) {
+    const value = outermostExpression(node);
+    const declarator = value.parent;
+    const declaration = declarator?.parent;
+    return (declarator?.type === "VariableDeclarator" &&
+        declarator.init === value &&
+        declarator.id.type === "Identifier" &&
+        declaration?.type === "VariableDeclaration" &&
+        declaration.kind === "const" &&
+        declaration.parent.type !== "ExportNamedDeclaration");
+}
+function isTimeZoneDate(sourceCode, node) {
+    const binding = importedBinding(sourceCode, node);
+    return binding !== null && timeZoneModules.has(binding.source) && timeZoneDates.has(binding.name);
+}
+function isCurrentTimeZoneDate(sourceCode, node) {
+    const callee = unwrapExpression(node.callee);
+    const [zone] = node.arguments;
+    return (callee.type === "MemberExpression" &&
+        staticPropertyName(callee) === "tz" &&
+        isTimeZoneDate(sourceCode, callee.object) &&
+        node.arguments.length === 1 &&
+        zone?.type !== "SpreadElement");
+}
 export const noAmbientClock = defineRule({
     meta: {
         type: "suggestion",
@@ -11,24 +133,59 @@ export const noAmbientClock = defineRule({
     },
     create(context) {
         const sourceCode = context.sourceCode;
-        function check(node, date) {
-            if (isGlobalValue(sourceCode, date, "Date") && !isInjectionSeam(node)) {
+        function report(node) {
+            if (!isInjectionSeam(node)) {
                 context.report({ node, messageId: "clock" });
             }
         }
+        function reportHelper(reference) {
+            const use = helperUse(reference);
+            if ((use !== reference || !isFollowedAlias(reference)) && !isInjectedValue(use)) {
+                context.report({ node: use, messageId: "clock" });
+            }
+        }
         return {
+            Identifier(node) {
+                if (isClockHelper(sourceCode, node) && isValueReference(sourceCode, node)) {
+                    reportHelper(node);
+                }
+            },
             MemberExpression(node) {
-                if (propertyName(node) === "now") {
-                    check(node, node.object);
+                if (staticPropertyName(node) === "now" && isGlobalValue(sourceCode, node.object, "Date")) {
+                    report(node);
+                }
+                if (isClockHelper(sourceCode, node) && !isWriteTarget(node)) {
+                    reportHelper(node);
                 }
             },
             NewExpression(node) {
-                if (node.arguments.length === 0) {
-                    check(node, node.callee);
+                if (node.arguments.length === 0 &&
+                    (isGlobalValue(sourceCode, node.callee, "Date") ||
+                        isTimeZoneDate(sourceCode, node.callee))) {
+                    report(node);
                 }
             },
             CallExpression(node) {
-                check(node, node.callee);
+                if (isGlobalValue(sourceCode, node.callee, "Date") ||
+                    isCurrentTimeZoneDate(sourceCode, node)) {
+                    report(node);
+                }
+            },
+            ExportNamedDeclaration(node) {
+                if (!node.source || node.exportKind === "type") {
+                    return;
+                }
+                for (const specifier of node.specifiers) {
+                    if (specifier.exportKind !== "type" &&
+                        clockHelpers.has(helperPath(node.source.value, moduleExportName(specifier.local)))) {
+                        context.report({ node: specifier, messageId: "clock" });
+                    }
+                }
+            },
+            ExportAllDeclaration(node) {
+                if (node.exportKind !== "type" && exposesClockHelper(node.source.value)) {
+                    context.report({ node, messageId: "clock" });
+                }
             },
         };
     },

package/dist/rules/no-env-access.js

@@ -1,10 +1,34 @@
 import { defineRule } from "@oxlint/plugins";
-import { isGlobal, propertyName } from "../shared/index.js";
+import { importedBinding, isGlobalValue, isNodeGlobalValue, moduleExportName, staticPropertyName, staticString, unwrapExpression, } from "../shared/index.js";
+const processModules = new Set(["node:process", "process"]);
+const environmentExports = new Set(["env", "default"]);
 function isImportMeta(node) {
-    return (node?.type === "MetaProperty" && node.meta.name === "import" && node.property.name === "meta");
+    const value = unwrapExpression(node);
+    return (value.type === "MetaProperty" && value.meta.name === "import" && value.property.name === "meta");
+}
+function isProcessModule(sourceCode, node) {
+    const binding = importedBinding(sourceCode, node);
+    return (binding !== null &&
+        processModules.has(binding.source) &&
+        (binding.name === "*" || binding.name === "default"));
 }
 function isEnvironmentSource(sourceCode, node) {
-    return isGlobal(sourceCode, node, "process") || isImportMeta(node);
+    if (!node) {
+        return false;
+    }
+    return (isNodeGlobalValue(sourceCode, node, "process") ||
+        isImportMeta(node) ||
+        isProcessModule(sourceCode, node));
+}
+function isReflectGet(sourceCode, node) {
+    const callee = unwrapExpression(node.callee);
+    const [target, key] = node.arguments;
+    return (callee.type === "MemberExpression" &&
+        staticPropertyName(callee) === "get" &&
+        isGlobalValue(sourceCode, callee.object, "Reflect") &&
+        target?.type !== "SpreadElement" &&
+        isEnvironmentSource(sourceCode, target) &&
+        staticString(key) === "env");
 }
 export const noEnvAccess = defineRule({
     meta: {
@@ -19,14 +43,47 @@ export const noEnvAccess = defineRule({
         const sourceCode = context.sourceCode;
         return {
             MemberExpression(node) {
-                if (propertyName(node) === "env" && isEnvironmentSource(sourceCode, node.object)) {
+                if (staticPropertyName(node) === "env" && isEnvironmentSource(sourceCode, node.object)) {
                     context.report({ node, messageId: "env" });
                 }
             },
             VariableDeclarator(node) {
                 if (node.id.type === "ObjectPattern" &&
                     isEnvironmentSource(sourceCode, node.init) &&
-                    node.id.properties.some((property) => property.type === "Property" && propertyName(property) === "env")) {
+                    node.id.properties.some((property) => property.type === "Property" && staticPropertyName(property) === "env")) {
+                    context.report({ node, messageId: "env" });
+                }
+            },
+            CallExpression(node) {
+                if (isReflectGet(sourceCode, node)) {
+                    context.report({ node, messageId: "env" });
+                }
+            },
+            ImportDeclaration(node) {
+                if (!processModules.has(node.source.value) || node.importKind === "type") {
+                    return;
+                }
+                for (const specifier of node.specifiers) {
+                    if (specifier.type === "ImportSpecifier" &&
+                        specifier.importKind !== "type" &&
+                        moduleExportName(specifier.imported) === "env") {
+                        context.report({ node: specifier, messageId: "env" });
+                    }
+                }
+            },
+            ExportNamedDeclaration(node) {
+                if (!node.source || !processModules.has(node.source.value) || node.exportKind === "type") {
+                    return;
+                }
+                for (const specifier of node.specifiers) {
+                    if (specifier.exportKind !== "type" &&
+                        environmentExports.has(moduleExportName(specifier.local))) {
+                        context.report({ node: specifier, messageId: "env" });
+                    }
+                }
+            },
+            ExportAllDeclaration(node) {
+                if (processModules.has(node.source.value) && node.exportKind !== "type") {
                     context.report({ node, messageId: "env" });
                 }
             },

package/dist/rules/no-uncontrolled-test-clock.js

@@ -25,7 +25,7 @@ function fakesDate(options) {
     });
 }
 function isNodeMock(sourceCode, node) {
-    const binding = importedBinding(sourceCode, unwrapExpression(node));
+    const binding = importedBinding(sourceCode, node);
     return nameOf(node) === "mock" || (binding?.source === "node:test" && binding.name === "mock");
 }
 function isLocalFunction(sourceCode, node) {

package/dist/shared/index.d.ts

@@ -3,6 +3,10 @@ export type ApiReference = {
     readonly module: string;
     readonly name: string;
 };
+export type ImportedBinding = {
+    readonly source: string;
+    readonly name: string;
+};
 export type TestContext = {
     readonly callback: FunctionNode;
     readonly api: ApiReference;
@@ -17,19 +21,21 @@ export declare function variableFor(sourceCode: SourceCode, node: ESTree.Node):
 export declare function isGlobal(sourceCode: SourceCode, identifier: ESTree.Node | null | undefined, name: string): boolean;
 export declare function propertyName(node: ESTree.Node): string | null;
 export declare function isPlaywright(module: string): boolean;
-export declare function apiReference(sourceCode: SourceCode, node: ESTree.Node, seen?: Set<Variable>): ApiReference | null;
+export declare function unwrapExpression(node: ESTree.Node): ESTree.Node;
+export declare function outermostExpression(node: ESTree.Node): ESTree.Node;
+export declare function staticString(node: ESTree.Node | null | undefined): string | null;
+export declare function staticPropertyName(node: ESTree.Node): string | null;
+export declare function moduleExportName(node: ESTree.ModuleExportName): string;
+export declare function importedBinding(sourceCode: SourceCode, node: ESTree.Node): ImportedBinding | null;
+export declare function isRequire(sourceCode: SourceCode, node: ESTree.Node): boolean;
+export declare function apiReference(sourceCode: SourceCode, node: ESTree.Node): ApiReference | null;
 export declare function testContext(sourceCode: SourceCode, node: ESTree.Node): TestContext | null;
 export declare function projectPath(cwd: string, file: string): string;
 export declare function matchesAny(path: string, patterns?: readonly string[]): boolean;
 export declare function isGlobalValue(sourceCode: SourceCode, node: ESTree.Node | null | undefined, name: string): boolean;
+export declare function isNodeGlobalValue(sourceCode: SourceCode, node: ESTree.Node | null | undefined, name: string): boolean;
+export declare function isInjectedValue(source: ESTree.Node): boolean;
 export declare function isInjectionSeam(source: ESTree.Node): boolean;
 export declare function isShortCircuited(call: ESTree.CallExpression): boolean;
-export declare function staticPropertyName(node: ESTree.Node): string | null;
-export declare function importedBinding(sourceCode: SourceCode, node: ESTree.Node): {
-    readonly source: string;
-    readonly name: string;
-} | null;
 export declare function isEffectModule(sourceCode: SourceCode, node: ESTree.Node, module: string): boolean;
-export declare function unwrapExpression(node: ESTree.Node): ESTree.Node;
-export declare function outermostExpression(node: ESTree.Node): ESTree.Node;
 export {};

package/dist/shared/index.js

@@ -89,92 +89,246 @@ export function propertyName(node) {
 export function isPlaywright(module) {
     return module === "@playwright/test" || module === "playwright/test";
 }
-export function apiReference(sourceCode, node, seen = new Set()) {
-    if (node.type === "Identifier") {
-        const variable = variableFor(sourceCode, node);
+export function unwrapExpression(node) {
+    return node.type === "ParenthesizedExpression" ||
+        node.type === "TSAsExpression" ||
+        node.type === "TSSatisfiesExpression" ||
+        node.type === "TSNonNullExpression" ||
+        node.type === "TSTypeAssertion"
+        ? unwrapExpression(node.expression)
+        : node;
+}
+export function outermostExpression(node) {
+    const parent = node.parent;
+    return parent !== null && unwrapExpression(parent) === unwrapExpression(node)
+        ? outermostExpression(parent)
+        : node;
+}
+export function staticString(node) {
+    const value = node ? unwrapExpression(node) : null;
+    if (value?.type === "TemplateLiteral") {
+        const [quasi] = value.quasis;
+        return value.expressions.length === 0 && quasi ? (quasi.value.cooked ?? null) : null;
+    }
+    return value?.type === "Literal" && typeof value.value === "string" ? value.value : null;
+}
+export function staticPropertyName(node) {
+    return "computed" in node && node.computed ? staticString(memberKey(node)) : propertyName(node);
+}
+export function moduleExportName(node) {
+    return node.type === "Identifier" ? node.name : node.value;
+}
+function dynamicImportSource(node) {
+    const awaited = unwrapExpression(node);
+    const loaded = awaited.type === "AwaitExpression" ? unwrapExpression(awaited.argument) : null;
+    if (loaded?.type !== "ImportExpression") {
+        return null;
+    }
+    return staticString(loaded.source);
+}
+const bindingCache = new WeakMap();
+const referenceCache = new WeakMap();
+function memberBinding(owner, name) {
+    return (owner?.name === "*" || owner?.name === "default") && name !== null
+        ? { source: owner.source, name }
+        : null;
+}
+function bindsName(property, name) {
+    if (property.type !== "Property") {
+        return false;
+    }
+    const target = property.value.type === "AssignmentPattern" ? property.value.left : property.value;
+    return target.type === "Identifier" && target.name === name;
+}
+function constAlias(definition) {
+    const declaration = definition.parent;
+    const declarator = definition.node;
+    return definition.type === "Variable" &&
+        declaration?.type === "VariableDeclaration" &&
+        declaration.kind === "const" &&
+        declarator.type === "VariableDeclarator" &&
+        declarator.init
+        ? { init: declarator.init, pattern: declarator.id, name: definition.name.name }
+        : null;
+}
+function destructuredName(pattern, name) {
+    const property = pattern.type === "ObjectPattern"
+        ? pattern.properties.find((candidate) => bindsName(candidate, name))
+        : undefined;
+    return property ? staticPropertyName(property) : null;
+}
+function aliasTarget(alias, resolve, member) {
+    const initial = resolve(alias.init);
+    if (alias.pattern.type === "Identifier") {
+        return initial;
+    }
+    const name = destructuredName(alias.pattern, alias.name);
+    return initial !== null && name !== null ? member(initial, name) : null;
+}
+function cached(cache, variable, resolve) {
+    if (!cache.has(variable)) {
+        cache.set(variable, null);
+        cache.set(variable, resolve());
+    }
+    return cache.get(variable) ?? null;
+}
+const nodeModuleSources = new Set(["module", "node:module"]);
+const loaderCache = new WeakMap();
+function unchangedInit(variable) {
+    const [definition, ...otherDefinitions] = variable.defs;
+    const declarator = definition?.node;
+    return otherDefinitions.length === 0 &&
+        definition?.type === "Variable" &&
+        declarator?.type === "VariableDeclarator" &&
+        declarator.id === definition.name &&
+        variable.references.every((reference) => reference.init || !reference.isWrite())
+        ? declarator.init
+        : null;
+}
+function isRequireFactory(node, resolve) {
+    const binding = node.type === "CallExpression" ? resolve(node.callee) : null;
+    return (binding !== null && nodeModuleSources.has(binding.source) && binding.name === "createRequire");
+}
+function isLoader(sourceCode, node, resolve) {
+    const callee = unwrapExpression(node);
+    if (isGlobal(sourceCode, callee, "require") || isRequireFactory(callee, resolve)) {
+        return true;
+    }
+    const variable = variableFor(sourceCode, callee);
+    return (variable !== null &&
+        cached(loaderCache, variable, () => {
+            const init = unchangedInit(variable);
+            return init !== null && isLoader(sourceCode, init, resolve);
+        }) === true);
+}
+function loadedSource(sourceCode, node, resolve) {
+    const required = node.type === "CallExpression" &&
+        node.arguments.length === 1 &&
+        isLoader(sourceCode, node.callee, resolve);
+    return required ? staticString(node.arguments[0]) : dynamicImportSource(node);
+}
+function importBinding(definition) {
+    const declaration = definition.parent;
+    const specifier = definition.node;
+    if (definition.type !== "ImportBinding" || declaration?.type !== "ImportDeclaration") {
+        return null;
+    }
+    const source = declaration.source.value;
+    if (specifier.type === "ImportNamespaceSpecifier") {
+        return { source, name: "*" };
+    }
+    if (specifier.type === "ImportDefaultSpecifier") {
+        return { source, name: "default" };
+    }
+    return specifier.type === "ImportSpecifier"
+        ? {
+            source,
+            name: moduleExportName(specifier.imported),
+        }
+        : null;
+}
+export function importedBinding(sourceCode, node) {
+    const value = unwrapExpression(node);
+    const source = loadedSource(sourceCode, value, (callee) => importedBinding(sourceCode, callee));
+    if (source !== null) {
+        return { source, name: "*" };
+    }
+    if (value.type === "MemberExpression") {
+        return memberBinding(importedBinding(sourceCode, value.object), staticPropertyName(value));
+    }
+    const variable = variableFor(sourceCode, value);
+    const definition = variable?.defs[0];
+    if (variable === null || definition === undefined) {
+        return null;
+    }
+    return cached(bindingCache, variable, () => {
+        const alias = constAlias(definition);
+        return alias === null
+            ? importBinding(definition)
+            : aliasTarget(alias, (init) => importedBinding(sourceCode, init), memberBinding);
+    });
+}
+export function isRequire(sourceCode, node) {
+    return isLoader(sourceCode, node, (callee) => importedBinding(sourceCode, callee));
+}
+function bindingReference(binding) {
+    const defaultExport = defaultImports.get(binding.source);
+    if (binding.name === "default") {
+        return defaultExport ? { module: binding.source, name: defaultExport } : null;
+    }
+    return defaultExport !== undefined &&
+        testFunctions.has(defaultExport) &&
+        testModifiers.has(binding.name)
+        ? { module: binding.source, name: defaultExport }
+        : { module: binding.source, name: binding.name };
+}
+function memberReference(object, name) {
+    if (object.name === "*") {
+        return bindingReference({ source: object.module, name });
+    }
+    if (testFunctions.has(object.name) && (testModifiers.has(name) || testFactories.has(name))) {
+        return object;
+    }
+    if (object.module === "@effect/vitest" &&
+        ["test", "it"].includes(object.name) &&
+        effectModifiers.has(name)) {
+        return object;
+    }
+    return object.name === "test" && testFunctions.has(name) ? { module: object.module, name } : null;
+}
+export function apiReference(sourceCode, node) {
+    const value = unwrapExpression(node);
+    const source = loadedSource(sourceCode, value, (callee) => importedBinding(sourceCode, callee));
+    if (source !== null) {
+        return { module: source, name: "*" };
+    }
+    if (value.type === "Identifier") {
+        const variable = variableFor(sourceCode, value);
         if (!variable?.defs.length) {
-            return testFunctions.has(node.name) || node.name === "expect"
-                ? { module: "global", name: node.name }
+            return testFunctions.has(value.name) || value.name === "expect"
+                ? { module: "global", name: value.name }
                 : null;
         }
         const [definition] = variable.defs;
-        if (seen.has(variable) || definition === undefined || variable.defs.length !== 1) {
+        if (definition === undefined || variable.defs.length !== 1) {
             return null;
         }
-        seen.add(variable);
-        const specifier = definition.node;
-        const declaration = definition.parent;
-        if (definition.type === "ImportBinding" && declaration?.type === "ImportDeclaration") {
-            const module = declaration.source.value;
-            if (specifier.type === "ImportDefaultSpecifier" ||
-                (specifier.type === "ImportSpecifier" &&
-                    specifier.imported.type === "Identifier" &&
-                    specifier.imported.name === "default")) {
-                const name = defaultImports.get(module);
-                return name ? { module, name } : null;
+        return cached(referenceCache, variable, () => {
+            const alias = constAlias(definition);
+            if (alias !== null) {
+                return aliasTarget(alias, (init) => apiReference(sourceCode, init), memberReference);
             }
-            if (specifier.type === "ImportNamespaceSpecifier") {
-                return { module, name: "*" };
-            }
-            if (specifier.type === "ImportSpecifier") {
-                return {
-                    module,
-                    name: specifier.imported.type === "Identifier"
-                        ? specifier.imported.name
-                        : specifier.imported.value,
-                };
-            }
-            return null;
-        }
-        if (definition.type === "Variable" &&
-            declaration?.type === "VariableDeclaration" &&
-            declaration.kind === "const" &&
-            specifier.type === "VariableDeclarator" &&
-            specifier.id.type === "Identifier" &&
-            specifier.init) {
-            return apiReference(sourceCode, specifier.init, seen);
-        }
-        return null;
+            const binding = importBinding(definition);
+            return binding && bindingReference(binding);
+        });
+    }
+    if (value.type === "MemberExpression") {
+        const object = apiReference(sourceCode, value.object);
+        const name = staticPropertyName(value);
+        return object && name !== null ? memberReference(object, name) : null;
     }
-    if (node.type === "MemberExpression") {
-        const object = apiReference(sourceCode, node.object, seen);
-        const name = propertyName(node);
-        if (!object || !name) {
+    if (value.type === "CallExpression") {
+        const callee = unwrapExpression(value.callee);
+        if (callee.type !== "MemberExpression") {
             return null;
         }
-        if (object.name === "*") {
-            return { module: object.module, name };
-        }
-        if (testFunctions.has(object.name) && (testModifiers.has(name) || testFactories.has(name))) {
-            return object;
-        }
-        if (object.module === "@effect/vitest" &&
-            ["test", "it"].includes(object.name) &&
-            effectModifiers.has(name)) {
-            return object;
-        }
-        if (object.name === "test" && testFunctions.has(name)) {
-            return { module: object.module, name };
-        }
-        return null;
-    }
-    if (node.type === "CallExpression" && node.callee.type === "MemberExpression") {
-        const name = propertyName(node.callee);
-        const object = apiReference(sourceCode, node.callee.object, seen);
+        const name = staticPropertyName(callee);
+        const object = apiReference(sourceCode, callee.object);
         if (object && name !== null && testFunctions.has(object.name) && testFactories.has(name)) {
             return object;
         }
-        if (object &&
+        return object &&
             ["test", "it"].includes(object.name) &&
             (isPlaywright(object.module) || ["vitest", "@effect/vitest"].includes(object.module)) &&
-            name === "extend") {
-            return object;
-        }
+            name === "extend"
+            ? object
+            : null;
     }
-    if (node.type === "TaggedTemplateExpression" &&
-        node.tag.type === "MemberExpression" &&
-        propertyName(node.tag) === "each") {
-        return apiReference(sourceCode, node.tag.object, seen);
+    if (value.type === "TaggedTemplateExpression") {
+        const tag = unwrapExpression(value.tag);
+        return tag.type === "MemberExpression" && staticPropertyName(tag) === "each"
+            ? apiReference(sourceCode, tag.object)
+            : null;
     }
     return null;
 }
@@ -202,53 +356,56 @@ export function projectPath(cwd, file) {
 export function matchesAny(path, patterns = []) {
     return patterns.some((pattern) => matchesGlob(path, pattern));
 }
-const globalObjects = ["globalThis", "global", "window", "self"];
+const nodeGlobalObjects = ["globalThis", "global"];
+const globalObjects = [...nodeGlobalObjects, "window", "self"];
 function isFunctionNode(node) {
     return (node.type === "ArrowFunctionExpression" ||
         node.type === "FunctionExpression" ||
         node.type === "FunctionDeclaration");
 }
-export function isGlobalValue(sourceCode, node, name) {
-    if (isGlobal(sourceCode, node, name)) {
+function isGlobalThrough(sourceCode, node, name, objects) {
+    const value = node ? unwrapExpression(node) : null;
+    if (isGlobal(sourceCode, value, name)) {
         return true;
     }
-    return (node?.type === "MemberExpression" &&
-        propertyName(node) === name &&
-        globalObjects.some((object) => isGlobal(sourceCode, node.object, object)));
+    return (value?.type === "MemberExpression" &&
+        staticPropertyName(value) === name &&
+        objects.some((object) => isGlobal(sourceCode, unwrapExpression(value.object), object)));
+}
+export function isGlobalValue(sourceCode, node, name) {
+    return isGlobalThrough(sourceCode, node, name, globalObjects);
+}
+export function isNodeGlobalValue(sourceCode, node, name) {
+    return isGlobalThrough(sourceCode, node, name, nodeGlobalObjects);
 }
 function returns(callback, value) {
     const body = callback.body;
-    if (body === value) {
-        return true;
-    }
     if (body?.type !== "BlockStatement") {
-        return false;
+        return body !== null && unwrapExpression(body) === value;
     }
     const [statement] = body.body;
-    return (body.body.length === 1 && statement?.type === "ReturnStatement" && statement.argument === value);
+    return (body.body.length === 1 &&
+        statement?.type === "ReturnStatement" &&
+        statement.argument !== null &&
+        unwrapExpression(statement.argument) === value);
 }
 function isProvider(callback, value) {
-    const holder = callback.parent;
-    if (holder.type === "AssignmentPattern") {
-        return holder.right === callback;
+    const provider = outermostExpression(callback);
+    const holder = provider.parent;
+    if (holder?.type === "AssignmentPattern") {
+        return holder.right === provider;
     }
     if (!returns(callback, value)) {
         return false;
     }
-    return ((holder.type === "Property" && holder.value === callback) ||
-        (holder.type === "LogicalExpression" &&
-            holder.right === callback &&
+    return ((holder?.type === "Property" && holder.value === provider) ||
+        (holder?.type === "LogicalExpression" &&
+            holder.right === provider &&
             ["??", "||"].includes(holder.operator)));
 }
-export function isInjectionSeam(source) {
-    const parent = source.parent;
-    if (source.type !== "NewExpression" && source.type !== "CallExpression") {
-        return parent?.type === "CallExpression" && parent.callee === source
-            ? isInjectionSeam(parent)
-            : true;
-    }
+export function isInjectedValue(source) {
     let child = source;
-    for (let ancestor = parent; ancestor; child = ancestor, ancestor = ancestor.parent) {
+    for (let ancestor = source.parent; ancestor; child = ancestor, ancestor = ancestor.parent) {
         if (ancestor.type === "AssignmentPattern") {
             return ancestor.right === child;
         }
@@ -258,6 +415,14 @@ export function isInjectionSeam(source) {
     }
     return false;
 }
+export function isInjectionSeam(source) {
+    if (source.type !== "NewExpression" && source.type !== "CallExpression") {
+        const callee = outermostExpression(source);
+        const call = callee.parent;
+        return call?.type === "CallExpression" && call.callee === callee ? isInjectionSeam(call) : true;
+    }
+    return isInjectedValue(source);
+}
 export function isShortCircuited(call) {
     let current = call;
     while (current.type === "CallExpression" || current.type === "MemberExpression") {
@@ -271,60 +436,8 @@ export function isShortCircuited(call) {
     }
     return false;
 }
-export function staticPropertyName(node) {
-    if (!("computed" in node && node.computed)) {
-        return propertyName(node);
-    }
-    const key = memberKey(node);
-    return key?.type === "Literal" && typeof key.value === "string" ? key.value : null;
-}
-export function importedBinding(sourceCode, node) {
-    if (node.type === "MemberExpression") {
-        const owner = importedBinding(sourceCode, node.object);
-        const name = staticPropertyName(node);
-        return (owner?.name === "*" || owner?.name === "default") && name !== null
-            ? { source: owner.source, name }
-            : null;
-    }
-    const definition = variableFor(sourceCode, node)?.defs[0];
-    const declaration = definition?.parent;
-    if (definition?.type !== "ImportBinding" || declaration?.type !== "ImportDeclaration") {
-        return null;
-    }
-    const specifier = definition.node;
-    const source = declaration.source.value;
-    if (specifier.type === "ImportNamespaceSpecifier") {
-        return { source, name: "*" };
-    }
-    if (specifier.type === "ImportDefaultSpecifier") {
-        return { source, name: "default" };
-    }
-    return specifier.type === "ImportSpecifier"
-        ? {
-            source,
-            name: specifier.imported.type === "Identifier"
-                ? specifier.imported.name
-                : specifier.imported.value,
-        }
-        : null;
-}
 export function isEffectModule(sourceCode, node, module) {
     const binding = importedBinding(sourceCode, node);
     return ((binding?.source === "effect" && binding.name === module) ||
         (binding?.source === `effect/${module}` && binding.name === "*"));
 }
-export function unwrapExpression(node) {
-    return node.type === "ParenthesizedExpression" ||
-        node.type === "TSAsExpression" ||
-        node.type === "TSSatisfiesExpression" ||
-        node.type === "TSNonNullExpression" ||
-        node.type === "TSTypeAssertion"
-        ? unwrapExpression(node.expression)
-        : node;
-}
-export function outermostExpression(node) {
-    const parent = node.parent;
-    return parent !== null && unwrapExpression(parent) === unwrapExpression(node)
-        ? outermostExpression(parent)
-        : node;
-}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jameswyse/oxc-config",
-  "version": "0.3.0",
+  "version": "0.5.0",
   "description": "Opinionated Oxlint and Oxfmt configs with custom rules for TypeScript and JavaScript projects",
   "keywords": [
     "config",