@jameswyse/oxc-config 0.1.0 → 0.3.0

package/dist/vendor/anti-slop/shared/dictionary-types.js

@@ -1,4 +1,4 @@
-import { createTypeAliasEnvironment, hasVisibleTypeBinding, visibleTypeAlias, } from "./type-alias-resolution.js";
+import { aliasSubstitutions, createTypeAliasEnvironment, hasVisibleTypeBinding, visibleTypeAlias, } from "./type-alias-resolution.js";
 const BUILT_INS = new Set([
     "Record",
     "Readonly",
@@ -35,6 +35,9 @@ function typeReferenceName(type) {
 function isBuiltIn(name, use, environment) {
     return BUILT_INS.has(name) && !hasVisibleTypeBinding(name, use, environment.typeAliases);
 }
+function mappedKey(type) {
+    return type.nameType ?? type.constraint;
+}
 function unwrapTransparentType(type) {
     let current = type;
     while (current.type === "TSParenthesizedType" ||
@@ -43,12 +46,6 @@ function unwrapTransparentType(type) {
     }
     return current;
 }
-function isUnappliedReferenceTo(type, name) {
-    const unwrapped = unwrapTransparentType(type);
-    return (unwrapped.type === "TSTypeReference" &&
-        typeReferenceName(unwrapped) === name &&
-        (unwrapped.typeArguments === null || unwrapped.typeArguments.params.length === 0));
-}
 function isNeverType(type) {
     return unwrapTransparentType(type).type === "TSNeverKeyword";
 }
@@ -70,36 +67,6 @@ function isEffectivelyEmptyInterface(declarations) {
         type.extends.length === 0 &&
         (type.body.body.length === 0 || type.body.body.every(isEffectivelyEmptyMember)));
 }
-function resolvedSubstitutionArgument(type, base, resolving = new Set()) {
-    const unwrapped = unwrapTransparentType(type);
-    if (unwrapped.type !== "TSTypeReference") {
-        return type;
-    }
-    const name = typeReferenceName(unwrapped);
-    if (name === null || resolving.has(name)) {
-        return type;
-    }
-    const substitution = base.get(name);
-    if (substitution === void 0) {
-        return type;
-    }
-    const nextResolving = new Set(resolving);
-    nextResolving.add(name);
-    return resolvedSubstitutionArgument(substitution, base, nextResolving);
-}
-function aliasSubstitution(alias, type, base) {
-    const parameters = alias.typeParameters?.params ?? [];
-    const arguments_ = type.typeArguments?.params ?? [];
-    const next = new Map(base);
-    for (const [index, parameter] of parameters.entries()) {
-        const argument = arguments_[index] ?? parameter.default;
-        if (argument === null) {
-            return null;
-        }
-        next.set(parameter.name.name, resolvedSubstitutionArgument(argument, next));
-    }
-    return next;
-}
 function unsafeDirectValue(type, environment, substitutions, resolvingAliases) {
     const unwrapped = unwrapTransparentType(type);
     if (unwrapped.type === "TSUnknownKeyword") {
@@ -144,9 +111,7 @@ function unsafeDirectValue(type, environment, substitutions, resolvingAliases) {
     }
     const substitution = substitutions.get(name);
     if (substitution !== void 0) {
-        return isUnappliedReferenceTo(substitution, name)
-            ? null
-            : unsafeDirectValue(substitution, environment, substitutions, resolvingAliases);
+        return unsafeDirectValue(substitution.type, environment, substitution.substitutions, resolvingAliases);
     }
     const interfaceDeclarations = environment.interfaces.get(name);
     if (interfaceDeclarations !== void 0) {
@@ -156,7 +121,7 @@ function unsafeDirectValue(type, environment, substitutions, resolvingAliases) {
     if (alias === null || resolvingAliases.has(name)) {
         return null;
     }
-    const nextSubstitutions = aliasSubstitution(alias, unwrapped, substitutions);
+    const nextSubstitutions = aliasSubstitutions(alias, unwrapped, substitutions);
     if (nextSubstitutions === null) {
         return null;
     }
@@ -164,6 +129,50 @@ function unsafeDirectValue(type, environment, substitutions, resolvingAliases) {
     nextResolving.add(name);
     return unsafeDirectValue(alias.typeAnnotation, environment, nextSubstitutions, nextResolving);
 }
+function isBroadMappedKey(type, environment, substitutions, visitedAliases = new Set()) {
+    const unwrapped = unwrapTransparentType(type);
+    if (unwrapped.type === "TSStringKeyword" ||
+        unwrapped.type === "TSNumberKeyword" ||
+        unwrapped.type === "TSSymbolKeyword") {
+        return true;
+    }
+    if (unwrapped.type === "TSUnionType") {
+        return unwrapped.types.some((member) => isBroadMappedKey(member, environment, substitutions, visitedAliases));
+    }
+    if (unwrapped.type !== "TSTypeReference") {
+        return false;
+    }
+    const name = typeReferenceName(unwrapped);
+    if (name === null) {
+        return false;
+    }
+    const substitution = substitutions.get(name);
+    if (substitution !== void 0) {
+        return isBroadMappedKey(substitution.type, environment, substitution.substitutions, visitedAliases);
+    }
+    if (name === "PropertyKey" && isBuiltIn(name, unwrapped, environment)) {
+        return true;
+    }
+    const alias = visibleTypeAlias(name, unwrapped, environment.typeAliases);
+    if (alias === null ||
+        (alias.typeParameters?.params.length ?? 0) > 0 ||
+        visitedAliases.has(name)) {
+        return false;
+    }
+    const nextVisited = new Set(visitedAliases);
+    nextVisited.add(name);
+    return isBroadMappedKey(alias.typeAnnotation, environment, substitutions, nextVisited);
+}
+function keptDictionarySource(type, environment, substitutions) {
+    const [source, keys] = type.typeArguments?.params ?? [];
+    if (source === void 0) {
+        return null;
+    }
+    return typeReferenceName(type) === "Omit" ||
+        (keys !== void 0 && isBroadMappedKey(keys, environment, substitutions))
+        ? source
+        : null;
+}
 function dictionaryValueTypes(type, environment, substitutions, resolvingAliases) {
     const unwrapped = unwrapTransparentType(type);
     if (unwrapped.type === "TSTypeLiteral") {
@@ -185,9 +194,7 @@ function dictionaryValueTypes(type, environment, substitutions, resolvingAliases
     }
     const substitution = substitutions.get(name);
     if (substitution !== void 0) {
-        return isUnappliedReferenceTo(substitution, name)
-            ? []
-            : dictionaryValueTypes(substitution, environment, substitutions, resolvingAliases);
+        return dictionaryValueTypes(substitution.type, environment, substitution.substitutions, resolvingAliases);
     }
     if (TRANSPARENT_WRAPPERS.has(name) && isBuiltIn(name, unwrapped, environment)) {
         const wrapped = unwrapped.typeArguments?.params[0];
@@ -200,8 +207,8 @@ function dictionaryValueTypes(type, environment, substitutions, resolvingAliases
         return value === null ? [] : [{ type: value, substitutions }];
     }
     if ((name === "Pick" || name === "Omit") && isBuiltIn(name, unwrapped, environment)) {
-        const source = unwrapped.typeArguments?.params[0];
-        return source === void 0
+        const source = keptDictionarySource(unwrapped, environment, substitutions);
+        return source === null
             ? []
             : dictionaryValueTypes(source, environment, substitutions, resolvingAliases);
     }
@@ -209,7 +216,7 @@ function dictionaryValueTypes(type, environment, substitutions, resolvingAliases
     if (alias === null || resolvingAliases.has(name)) {
         return [];
     }
-    const nextSubstitutions = aliasSubstitution(alias, unwrapped, substitutions);
+    const nextSubstitutions = aliasSubstitutions(alias, unwrapped, substitutions);
     if (nextSubstitutions === null) {
         return [];
     }
@@ -230,40 +237,6 @@ function classifyUnsafeDictionary(type, environment) {
     }
     return null;
 }
-function isBroadMappedKey(type, environment, substitutions, visitedAliases = new Set()) {
-    const unwrapped = unwrapTransparentType(type);
-    if (unwrapped.type === "TSStringKeyword" ||
-        unwrapped.type === "TSNumberKeyword" ||
-        unwrapped.type === "TSSymbolKeyword") {
-        return true;
-    }
-    if (unwrapped.type === "TSUnionType") {
-        return unwrapped.types.some((member) => isBroadMappedKey(member, environment, substitutions, visitedAliases));
-    }
-    if (unwrapped.type !== "TSTypeReference") {
-        return false;
-    }
-    const name = typeReferenceName(unwrapped);
-    if (name === null) {
-        return false;
-    }
-    const substitution = substitutions.get(name);
-    if (substitution !== void 0 && !isUnappliedReferenceTo(substitution, name)) {
-        return isBroadMappedKey(substitution, environment, substitutions, visitedAliases);
-    }
-    if (name === "PropertyKey" && isBuiltIn(name, unwrapped, environment)) {
-        return true;
-    }
-    const alias = visibleTypeAlias(name, unwrapped, environment.typeAliases);
-    if (alias === null ||
-        (alias.typeParameters?.params.length ?? 0) > 0 ||
-        visitedAliases.has(name)) {
-        return false;
-    }
-    const nextVisited = new Set(visitedAliases);
-    nextVisited.add(name);
-    return isBroadMappedKey(alias.typeAnnotation, environment, substitutions, nextVisited);
-}
 function hasBroadRecordKey(type, environment, substitutions) {
     const key = type.typeArguments?.params[0];
     return key === void 0 || isBroadMappedKey(key, environment, substitutions);
@@ -282,7 +255,7 @@ function classifyAliasBroadTarget(type, environment, substitutions, resolvingAli
             : null;
     }
     if (unwrapped.type === "TSMappedType") {
-        return isBroadMappedKey(unwrapped.constraint, environment, substitutions)
+        return isBroadMappedKey(mappedKey(unwrapped), environment, substitutions)
             ? { kind: "open dictionary" }
             : null;
     }
@@ -295,9 +268,7 @@ function classifyAliasBroadTarget(type, environment, substitutions, resolvingAli
     }
     const substitution = substitutions.get(name);
     if (substitution !== void 0) {
-        return isUnappliedReferenceTo(substitution, name)
-            ? null
-            : classifyAliasBroadTarget(substitution, environment, substitutions, resolvingAliases);
+        return classifyAliasBroadTarget(substitution.type, environment, substitution.substitutions, resolvingAliases);
     }
     if (TRANSPARENT_WRAPPERS.has(name) && isBuiltIn(name, unwrapped, environment)) {
         const wrapped = unwrapped.typeArguments?.params[0];
@@ -310,11 +281,18 @@ function classifyAliasBroadTarget(type, environment, substitutions, resolvingAli
             ? { kind: "open dictionary" }
             : null;
     }
+    if ((name === "Pick" || name === "Omit") && isBuiltIn(name, unwrapped, environment)) {
+        const source = keptDictionarySource(unwrapped, environment, substitutions);
+        const target = source === null
+            ? null
+            : classifyAliasBroadTarget(source, environment, substitutions, resolvingAliases);
+        return target?.kind === "open dictionary" ? target : null;
+    }
     const alias = visibleTypeAlias(name, unwrapped, environment.typeAliases);
     if (alias === null || resolvingAliases.has(name)) {
         return null;
     }
-    const nextSubstitutions = aliasSubstitution(alias, unwrapped, substitutions);
+    const nextSubstitutions = aliasSubstitutions(alias, unwrapped, substitutions);
     if (nextSubstitutions === null) {
         return null;
     }
@@ -338,7 +316,9 @@ function classifyWideningTarget(type, environment) {
                 : null;
     }
     if (unwrapped.type === "TSMappedType") {
-        return { kind: "open dictionary" };
+        return isBroadMappedKey(mappedKey(unwrapped), environment, new Map())
+            ? { kind: "open dictionary" }
+            : null;
     }
     if (unwrapped.type !== "TSTypeReference") {
         return null;
@@ -356,18 +336,21 @@ function classifyWideningTarget(type, environment) {
             ? { kind: "open dictionary" }
             : null;
     }
+    if ((name === "Pick" || name === "Omit") && isBuiltIn(name, unwrapped, environment)) {
+        return classifyAliasBroadTarget(unwrapped, environment, new Map(), new Set());
+    }
     const alias = visibleTypeAlias(name, unwrapped, environment.typeAliases);
     if (alias === null) {
         return null;
     }
     if ((alias.typeParameters?.params.length ?? 0) > 0) {
-        const substitutions2 = aliasSubstitution(alias, unwrapped, new Map());
+        const substitutions2 = aliasSubstitutions(alias, unwrapped, new Map());
         const resolved2 = substitutions2 === null
             ? null
             : classifyAliasBroadTarget(alias.typeAnnotation, environment, substitutions2, new Set([name]));
         return resolved2?.kind === "open dictionary" ? { kind: "generic container" } : null;
     }
-    const substitutions = aliasSubstitution(alias, unwrapped, new Map());
+    const substitutions = aliasSubstitutions(alias, unwrapped, new Map());
     if (substitutions === null) {
         return null;
     }

package/dist/vendor/anti-slop/shared/type-alias-resolution.d.ts

@@ -7,6 +7,11 @@ type DeclaredTypeBinding = {
 type TypeBinding = DeclaredTypeBinding & {
     readonly scope: ESTree.Node;
 };
+type Substitution = {
+    readonly type: ESTree.TSType;
+    readonly substitutions: Substitutions;
+};
+type Substitutions = ReadonlyMap<string, Substitution>;
 type TypeAliasEnvironment = {
     readonly aliases: readonly ESTree.TSTypeAliasDeclaration[];
     readonly bindingsByName: ReadonlyMap<string, readonly TypeBinding[]>;
@@ -16,6 +21,7 @@ type ResolvedTypeMatcher = (type: ESTree.TSType, matches: (child: ESTree.TSType)
 declare function createTypeAliasEnvironment(program: ESTree.Program, visitorKeys: VisitorKeys): TypeAliasEnvironment;
 declare function visibleTypeAlias(name: string, use: ESTree.Node, environment: TypeAliasEnvironment): ESTree.TSTypeAliasDeclaration | null;
 declare function hasVisibleTypeBinding(name: string, use: ESTree.Node, environment: TypeAliasEnvironment): boolean;
+declare function aliasSubstitutions(alias: ESTree.TSTypeAliasDeclaration, reference: ESTree.TSTypeReference, base: Substitutions): Substitutions | null;
 declare function resolvedTypeMatches(type: ESTree.TSType, environment: TypeAliasEnvironment, matcher: ResolvedTypeMatcher): boolean;
-export type { ResolvedTypeMatcher, TypeAliasEnvironment };
-export { createTypeAliasEnvironment, hasVisibleTypeBinding, resolvedTypeMatches, visibleTypeAlias };
+export type { ResolvedTypeMatcher, Substitution, Substitutions, TypeAliasEnvironment };
+export { aliasSubstitutions, createTypeAliasEnvironment, hasVisibleTypeBinding, resolvedTypeMatches, visibleTypeAlias, };

package/dist/vendor/anti-slop/shared/type-alias-resolution.js

@@ -105,7 +105,7 @@ function typeReferenceName(type) {
 function aliasSubstitutions(alias, reference, base) {
     const parameters = alias.typeParameters?.params ?? [];
     const arguments_ = reference.typeArguments?.params ?? [];
-    const next = new Map(base);
+    const next = new Map();
     for (const [index, parameter] of parameters.entries()) {
         const explicitArgument = arguments_[index];
         const argument = explicitArgument ?? parameter.default;
@@ -144,4 +144,4 @@ function resolvedTypeMatches(type, environment, matcher) {
     };
     return evaluate(type, new Map(), new Set());
 }
-export { createTypeAliasEnvironment, hasVisibleTypeBinding, resolvedTypeMatches, visibleTypeAlias };
+export { aliasSubstitutions, createTypeAliasEnvironment, hasVisibleTypeBinding, resolvedTypeMatches, visibleTypeAlias, };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jameswyse/oxc-config",
-  "version": "0.1.0",
+  "version": "0.3.0",
   "description": "Opinionated Oxlint and Oxfmt configs with custom rules for TypeScript and JavaScript projects",
   "keywords": [
     "config",
@@ -39,15 +39,15 @@
   },
   "dependencies": {
     "@e18e/eslint-plugin": "0.8.1",
-    "@oxlint/plugins": "1.86.0",
+    "@oxlint/plugins": "1.88.0",
     "eslint-plugin-react-you-might-not-need-an-effect": "1.0.2"
   },
   "devDependencies": {
     "@changesets/cli": "3.0.3",
     "@types/node": "^22.20.5",
-    "oxfmt": "0.71.0",
-    "oxlint": "1.86.0",
-    "oxlint-tsgolint": "7.0.2003",
+    "oxfmt": "0.73.0",
+    "oxlint": "1.88.0",
+    "oxlint-tsgolint": "7.0.2004",
     "typescript": "7.0.2"
   },
   "peerDependencies": {
@@ -66,11 +66,11 @@
   "devEngines": {
     "packageManager": {
       "name": "pnpm",
-      "version": "12.6.0"
+      "version": "12.13.0"
     },
     "runtime": {
       "name": "node",
-      "version": "24.18.0",
+      "version": "24.22.0",
       "onFail": "download"
     }
   },