@jameswyse/oxc-config 0.1.0

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

@@ -0,0 +1,21 @@
+import type { ESTree, SourceCode } from "@oxlint/plugins";
+type VisitorKeys = SourceCode["visitorKeys"];
+type DeclaredTypeBinding = {
+    readonly alias: ESTree.TSTypeAliasDeclaration | null;
+    readonly name: string;
+};
+type TypeBinding = DeclaredTypeBinding & {
+    readonly scope: ESTree.Node;
+};
+type TypeAliasEnvironment = {
+    readonly aliases: readonly ESTree.TSTypeAliasDeclaration[];
+    readonly bindingsByName: ReadonlyMap<string, readonly TypeBinding[]>;
+    readonly visitorKeys: VisitorKeys;
+};
+type ResolvedTypeMatcher = (type: ESTree.TSType, matches: (child: ESTree.TSType) => boolean) => boolean;
+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 resolvedTypeMatches(type: ESTree.TSType, environment: TypeAliasEnvironment, matcher: ResolvedTypeMatcher): boolean;
+export type { ResolvedTypeMatcher, TypeAliasEnvironment };
+export { createTypeAliasEnvironment, hasVisibleTypeBinding, resolvedTypeMatches, visibleTypeAlias };

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

@@ -0,0 +1,147 @@
+import { childNodes } from "../../../shared/index.js";
+import { lexicalTypeParameterNames } from "./lexical-type-parameters.js";
+const environmentsByProgram = new WeakMap();
+function enclosingTypeScope(node) {
+    let current = node.parent;
+    while (current !== null) {
+        if (current.type === "Program" ||
+            current.type === "BlockStatement" ||
+            current.type === "TSModuleBlock" ||
+            current.type === "StaticBlock" ||
+            current.type === "SwitchStatement") {
+            return current;
+        }
+        current = current.parent;
+    }
+    return node;
+}
+function declaredTypeBinding(node) {
+    if (node.type === "TSTypeAliasDeclaration") {
+        return { alias: node, name: node.id.name };
+    }
+    if (node.type === "TSInterfaceDeclaration" ||
+        node.type === "TSEnumDeclaration" ||
+        node.type === "ClassDeclaration" ||
+        node.type === "ClassExpression") {
+        return node.id === null ? null : { alias: null, name: node.id.name };
+    }
+    if (node.type === "ImportSpecifier" ||
+        node.type === "ImportDefaultSpecifier" ||
+        node.type === "ImportNamespaceSpecifier") {
+        return { alias: null, name: node.local.name };
+    }
+    return null;
+}
+function collectTypeBindings(node, visitorKeys, bindingsByName, aliases) {
+    const declared = declaredTypeBinding(node);
+    if (declared !== null) {
+        const bindings = bindingsByName.get(declared.name) ?? [];
+        bindings.push({ ...declared, scope: enclosingTypeScope(node) });
+        bindingsByName.set(declared.name, bindings);
+        if (declared.alias !== null) {
+            aliases.push(declared.alias);
+        }
+    }
+    for (const child of childNodes(node, visitorKeys)) {
+        collectTypeBindings(child, visitorKeys, bindingsByName, aliases);
+    }
+}
+function createTypeAliasEnvironment(program, visitorKeys) {
+    const cached = environmentsByProgram.get(program);
+    if (cached !== void 0) {
+        return cached;
+    }
+    const bindingsByName = new Map();
+    const aliases = [];
+    collectTypeBindings(program, visitorKeys, bindingsByName, aliases);
+    const environment = { aliases, bindingsByName, visitorKeys };
+    environmentsByProgram.set(program, environment);
+    return environment;
+}
+function ancestorDistance(ancestor, node) {
+    let current = node;
+    let distance = 0;
+    while (current !== null) {
+        if (current === ancestor) {
+            return distance;
+        }
+        current = current.parent;
+        distance += 1;
+    }
+    return null;
+}
+function nearestTypeBindings(name, use, environment) {
+    const candidates = environment.bindingsByName.get(name) ?? [];
+    let nearestDistance = Number.POSITIVE_INFINITY;
+    let nearest = [];
+    for (const candidate of candidates) {
+        const distance = ancestorDistance(candidate.scope, use);
+        if (distance === null || distance > nearestDistance) {
+            continue;
+        }
+        if (distance === nearestDistance) {
+            nearest.push(candidate);
+            continue;
+        }
+        nearestDistance = distance;
+        nearest = [candidate];
+    }
+    return nearest;
+}
+function visibleTypeAlias(name, use, environment) {
+    if (lexicalTypeParameterNames(use, environment.visitorKeys).has(name)) {
+        return null;
+    }
+    const bindings = nearestTypeBindings(name, use, environment);
+    return bindings.length === 1 ? (bindings[0]?.alias ?? null) : null;
+}
+function hasVisibleTypeBinding(name, use, environment) {
+    return (lexicalTypeParameterNames(use, environment.visitorKeys).has(name) ||
+        nearestTypeBindings(name, use, environment).length > 0);
+}
+function typeReferenceName(type) {
+    return type.typeName.type === "Identifier" ? type.typeName.name : null;
+}
+function aliasSubstitutions(alias, reference, base) {
+    const parameters = alias.typeParameters?.params ?? [];
+    const arguments_ = reference.typeArguments?.params ?? [];
+    const next = new Map(base);
+    for (const [index, parameter] of parameters.entries()) {
+        const explicitArgument = arguments_[index];
+        const argument = explicitArgument ?? parameter.default;
+        if (argument === null) {
+            return null;
+        }
+        const argumentSubstitutions = explicitArgument === void 0 ? next : base;
+        next.set(parameter.name.name, {
+            type: argument,
+            substitutions: new Map(argumentSubstitutions),
+        });
+    }
+    return next;
+}
+function resolvedTypeMatches(type, environment, matcher) {
+    const evaluate = (current, substitutions, resolvingAliases) => {
+        if (current.type === "TSTypeReference") {
+            const name = typeReferenceName(current);
+            if (name !== null) {
+                const substitution = substitutions.get(name);
+                if (substitution !== void 0 && !current.typeArguments?.params.length) {
+                    return evaluate(substitution.type, substitution.substitutions, resolvingAliases);
+                }
+                const alias = visibleTypeAlias(name, current, environment);
+                if (alias !== null && !resolvingAliases.has(alias)) {
+                    const nextSubstitutions = aliasSubstitutions(alias, current, substitutions);
+                    if (nextSubstitutions !== null) {
+                        const nextResolving = new Set(resolvingAliases);
+                        nextResolving.add(alias);
+                        return evaluate(alias.typeAnnotation, nextSubstitutions, nextResolving);
+                    }
+                }
+            }
+        }
+        return matcher(current, (child) => evaluate(child, substitutions, resolvingAliases));
+    };
+    return evaluate(type, new Map(), new Set());
+}
+export { createTypeAliasEnvironment, hasVisibleTypeBinding, resolvedTypeMatches, visibleTypeAlias };

package/dist/vendor/eslint-stylistic/padding-line-ast.d.ts

@@ -0,0 +1,14 @@
+import type { Comment, ESTree, SourceCode, Span, Token } from "@oxlint/plugins";
+type TokenOrComment = Token | Comment;
+declare const LINEBREAKS: Set<string>;
+declare const isClosingBraceToken: (token: TokenOrComment) => boolean;
+declare const isSemicolonToken: (token: TokenOrComment) => boolean;
+declare const isNotSemicolonToken: (token: TokenOrComment) => boolean;
+declare const isTokenOnSameLine: (left: Pick<Span, "loc">, right: Pick<Span, "loc">) => boolean;
+declare const isFunction: (node: ESTree.Node) => boolean;
+declare const isSingleLine: (node: ESTree.Node) => boolean;
+declare const skipChainExpression: (node: ESTree.Node) => ESTree.Node;
+declare const isTopLevelExpressionStatement: (node: ESTree.Node) => node is ESTree.ExpressionStatement;
+declare function isParenthesized(node: ESTree.Node, sourceCode: SourceCode): boolean;
+export type { TokenOrComment };
+export { LINEBREAKS, isClosingBraceToken, isFunction, isNotSemicolonToken, isParenthesized, isSemicolonToken, isSingleLine, isTokenOnSameLine, isTopLevelExpressionStatement, skipChainExpression, };

package/dist/vendor/eslint-stylistic/padding-line-ast.js

@@ -0,0 +1,19 @@
+const LINEBREAKS = new Set(["\r\n", "\r", "\n", "\u2028", "\u2029"]);
+const isClosingBraceToken = (token) => token.type === "Punctuator" && token.value === "}";
+const isSemicolonToken = (token) => token.type === "Punctuator" && token.value === ";";
+const isNotSemicolonToken = (token) => !isSemicolonToken(token);
+const isTokenOnSameLine = (left, right) => left.loc.end.line === right.loc.start.line;
+const isFunction = (node) => node.type === "FunctionDeclaration" ||
+    node.type === "FunctionExpression" ||
+    node.type === "ArrowFunctionExpression";
+const isSingleLine = (node) => node.loc.start.line === node.loc.end.line;
+const skipChainExpression = (node) => node.type === "ChainExpression" ? node.expression : node;
+const isTopLevelExpressionStatement = (node) => node.type === "ExpressionStatement" &&
+    (node.parent.type === "Program" ||
+        (node.parent.type === "BlockStatement" && isFunction(node.parent.parent)));
+function isParenthesized(node, sourceCode) {
+    const before = sourceCode.getTokenBefore(node);
+    const after = sourceCode.getTokenAfter(node);
+    return before?.value === "(" && after?.value === ")";
+}
+export { LINEBREAKS, isClosingBraceToken, isFunction, isNotSemicolonToken, isParenthesized, isSemicolonToken, isSingleLine, isTokenOnSameLine, isTopLevelExpressionStatement, skipChainExpression, };

package/dist/vendor/eslint-stylistic/padding-line-between-statements.d.ts

@@ -0,0 +1,91 @@
+import type { CreateRule, ESTree, SourceCode } from "@oxlint/plugins";
+type NodeTestObject = {
+    readonly test: (node: ESTree.Node, sourceCode: SourceCode) => boolean;
+};
+type PaddingType = "any" | "never" | "always";
+type SelectorOption = {
+    readonly selector: string;
+    readonly lineMode?: "any" | "singleline" | "multiline";
+};
+type StatementMatcher = StatementType | SelectorOption;
+type StatementOption = StatementMatcher | readonly StatementMatcher[];
+type PaddingLineOption = {
+    readonly blankLine: PaddingType;
+    readonly prev: StatementOption;
+    readonly next: StatementOption;
+};
+declare function isIIFEStatement(node: ESTree.Node): boolean;
+declare function isCJSRequire(node: ESTree.Node): boolean;
+declare function isBlockLikeStatement(node: ESTree.Node, sourceCode: SourceCode): boolean;
+declare function isDirectivePrologue(node: ESTree.Node, sourceCode: SourceCode): boolean;
+declare function isCJSExport(node: ESTree.Node): boolean;
+declare function isExpression(node: ESTree.Node, sourceCode: SourceCode): boolean;
+declare function hasCJSExportText(node: ESTree.Node, sourceCode: SourceCode): boolean;
+declare function hasCJSImportText(node: ESTree.Node, sourceCode: SourceCode): boolean;
+declare const MaybeMultilineStatementType: {
+    "block-like": {
+        test: typeof isBlockLikeStatement;
+    };
+    expression: {
+        test: typeof isExpression;
+    };
+    return: NodeTestObject;
+    export: NodeTestObject;
+    var: NodeTestObject;
+    let: NodeTestObject;
+    const: NodeTestObject;
+    using: {
+        test: (node: ESTree.Node) => boolean;
+    };
+    type: NodeTestObject;
+};
+declare const BaseStatementTypes: {
+    "*": {
+        test: () => true;
+    };
+    exports: {
+        test: typeof isCJSExport;
+    };
+    require: {
+        test: typeof isCJSRequire;
+    };
+    directive: {
+        test: typeof isDirectivePrologue;
+    };
+    iife: {
+        test: typeof isIIFEStatement;
+    };
+    block: NodeTestObject;
+    empty: NodeTestObject;
+    function: NodeTestObject;
+    "ts-method": NodeTestObject;
+    break: NodeTestObject;
+    case: NodeTestObject;
+    class: NodeTestObject;
+    continue: NodeTestObject;
+    debugger: NodeTestObject;
+    default: NodeTestObject;
+    do: NodeTestObject;
+    for: NodeTestObject;
+    if: NodeTestObject;
+    import: NodeTestObject;
+    switch: NodeTestObject;
+    throw: NodeTestObject;
+    try: NodeTestObject;
+    while: NodeTestObject;
+    with: NodeTestObject;
+    "cjs-export": {
+        test: typeof hasCJSExportText;
+    };
+    "cjs-import": {
+        test: typeof hasCJSImportText;
+    };
+    enum: NodeTestObject;
+    interface: NodeTestObject;
+    "function-overload": NodeTestObject;
+};
+type MaybeMultilineStatementKey = keyof typeof MaybeMultilineStatementType;
+type StatementType = keyof typeof BaseStatementTypes | MaybeMultilineStatementKey | `singleline-${MaybeMultilineStatementKey}` | `multiline-${MaybeMultilineStatementKey}`;
+declare function createPaddingLineRule(options: readonly PaddingLineOption[]): CreateRule;
+export type { PaddingLineOption, SelectorOption, StatementOption };
+export { createPaddingLineRule as default };