@depup/typescript-eslint__utils 8.57.1-depup.0

package/dist/ast-utils/helpers.d.ts

@@ -0,0 +1,18 @@
+import type { AST_NODE_TYPES, AST_TOKEN_TYPES, TSESTree } from '../ts-estree';
+export declare const isNodeOfType: <NodeType extends AST_NODE_TYPES>(nodeType: NodeType) => (node: TSESTree.Node | null | undefined) => node is Extract<TSESTree.Node, {
+    type: NodeType;
+}>;
+export declare const isNodeOfTypes: <NodeTypes extends readonly AST_NODE_TYPES[]>(nodeTypes: NodeTypes) => (node: TSESTree.Node | null | undefined) => node is Extract<TSESTree.Node, {
+    type: NodeTypes[number];
+}>;
+export declare const isNodeOfTypeWithConditions: <NodeType extends AST_NODE_TYPES, ExtractedNode extends Extract<TSESTree.Node, {
+    type: NodeType;
+}>, Conditions extends Partial<ExtractedNode>>(nodeType: NodeType, conditions: Conditions) => ((node: TSESTree.Node | null | undefined) => node is Conditions & ExtractedNode);
+export declare const isTokenOfTypeWithConditions: <TokenType extends AST_TOKEN_TYPES, ExtractedToken extends Extract<TSESTree.Token, {
+    type: TokenType;
+}>, Conditions extends Partial<{
+    type: TokenType;
+} & TSESTree.Token>>(tokenType: TokenType, conditions: Conditions) => ((token: TSESTree.Token | null | undefined) => token is Conditions & ExtractedToken);
+export declare const isNotTokenOfTypeWithConditions: <TokenType extends AST_TOKEN_TYPES, ExtractedToken extends Extract<TSESTree.Token, {
+    type: TokenType;
+}>, Conditions extends Partial<ExtractedToken>>(tokenType: TokenType, conditions: Conditions) => ((token: TSESTree.Token | null | undefined) => token is Exclude<TSESTree.Token, Conditions & ExtractedToken>);

package/dist/ast-utils/helpers.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isNotTokenOfTypeWithConditions = exports.isTokenOfTypeWithConditions = exports.isNodeOfTypeWithConditions = exports.isNodeOfTypes = exports.isNodeOfType = void 0;
+const isNodeOfType = (nodeType) => (node) => node?.type === nodeType;
+exports.isNodeOfType = isNodeOfType;
+const isNodeOfTypes = (nodeTypes) => (node) => !!node && nodeTypes.includes(node.type);
+exports.isNodeOfTypes = isNodeOfTypes;
+const isNodeOfTypeWithConditions = (nodeType, conditions) => {
+    const entries = Object.entries(conditions);
+    return (node) => node?.type === nodeType &&
+        entries.every(([key, value]) => node[key] === value);
+};
+exports.isNodeOfTypeWithConditions = isNodeOfTypeWithConditions;
+const isTokenOfTypeWithConditions = (tokenType, conditions) => {
+    const entries = Object.entries(conditions);
+    return (token) => token?.type === tokenType &&
+        entries.every(([key, value]) => token[key] === value);
+};
+exports.isTokenOfTypeWithConditions = isTokenOfTypeWithConditions;
+const isNotTokenOfTypeWithConditions = (tokenType, conditions) => (token) => !(0, exports.isTokenOfTypeWithConditions)(tokenType, conditions)(token);
+exports.isNotTokenOfTypeWithConditions = isNotTokenOfTypeWithConditions;

package/dist/ast-utils/index.d.ts

@@ -0,0 +1,4 @@
+export * from './eslint-utils';
+export * from './helpers';
+export * from './misc';
+export * from './predicates';

package/dist/ast-utils/index.js

@@ -0,0 +1,20 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./eslint-utils"), exports);
+__exportStar(require("./helpers"), exports);
+__exportStar(require("./misc"), exports);
+__exportStar(require("./predicates"), exports);

package/dist/ast-utils/misc.d.ts

@@ -0,0 +1,6 @@
+import type { TSESTree } from '../ts-estree';
+export declare const LINEBREAK_MATCHER: RegExp;
+/**
+ * Determines whether two adjacent tokens are on the same line
+ */
+export declare function isTokenOnSameLine(left: TSESTree.Node | TSESTree.Token, right: TSESTree.Node | TSESTree.Token): boolean;

package/dist/ast-utils/misc.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LINEBREAK_MATCHER = void 0;
+exports.isTokenOnSameLine = isTokenOnSameLine;
+exports.LINEBREAK_MATCHER = /\r\n|[\r\n\u2028\u2029]/;
+/**
+ * Determines whether two adjacent tokens are on the same line
+ */
+function isTokenOnSameLine(left, right) {
+    return left.loc.end.line === right.loc.start.line;
+}

package/dist/ast-utils/predicates.d.ts

@@ -0,0 +1,68 @@
+import type { TSESTree } from '../ts-estree';
+export declare const isOptionalChainPunctuator: (token: TSESTree.Token | null | undefined) => token is {
+    value: "?.";
+} & TSESTree.PunctuatorToken;
+export declare const isNotOptionalChainPunctuator: (token: TSESTree.Token | null | undefined) => token is TSESTree.BooleanToken | TSESTree.BlockComment | TSESTree.LineComment | TSESTree.IdentifierToken | TSESTree.JSXIdentifierToken | TSESTree.JSXTextToken | TSESTree.KeywordToken | TSESTree.NullToken | TSESTree.NumericToken | TSESTree.PrivateIdentifierToken | TSESTree.PunctuatorToken | TSESTree.RegularExpressionToken | TSESTree.StringToken | TSESTree.TemplateToken;
+export declare const isNonNullAssertionPunctuator: (token: TSESTree.Token | null | undefined) => token is {
+    value: "!";
+} & TSESTree.PunctuatorToken;
+export declare const isNotNonNullAssertionPunctuator: (token: TSESTree.Token | null | undefined) => token is TSESTree.BooleanToken | TSESTree.BlockComment | TSESTree.LineComment | TSESTree.IdentifierToken | TSESTree.JSXIdentifierToken | TSESTree.JSXTextToken | TSESTree.KeywordToken | TSESTree.NullToken | TSESTree.NumericToken | TSESTree.PrivateIdentifierToken | TSESTree.PunctuatorToken | TSESTree.RegularExpressionToken | TSESTree.StringToken | TSESTree.TemplateToken;
+/**
+ * Returns true if and only if the node represents: foo?.() or foo.bar?.()
+ */
+export declare const isOptionalCallExpression: (node: TSESTree.Node | null | undefined) => node is {
+    optional: boolean;
+} & TSESTree.CallExpression;
+/**
+ * Returns true if and only if the node represents logical OR
+ */
+export declare const isLogicalOrOperator: (node: TSESTree.Node | null | undefined) => node is Partial<TSESTree.LogicalExpression> & TSESTree.LogicalExpression;
+/**
+ * Checks if a node is a type assertion:
+ * ```
+ * x as foo
+ * <foo>x
+ * ```
+ */
+export declare const isTypeAssertion: (node: TSESTree.Node | null | undefined) => node is TSESTree.TSAsExpression | TSESTree.TSTypeAssertion;
+export declare const isVariableDeclarator: (node: TSESTree.Node | null | undefined) => node is TSESTree.VariableDeclaratorDefiniteAssignment | TSESTree.VariableDeclaratorMaybeInit | TSESTree.VariableDeclaratorNoInit | TSESTree.UsingInForOfDeclarator | TSESTree.UsingInNormalContextDeclarator;
+export declare const isFunction: (node: TSESTree.Node | null | undefined) => node is TSESTree.ArrowFunctionExpression | TSESTree.FunctionDeclarationWithName | TSESTree.FunctionDeclarationWithOptionalName | TSESTree.FunctionExpression;
+export declare const isFunctionType: (node: TSESTree.Node | null | undefined) => node is TSESTree.TSCallSignatureDeclaration | TSESTree.TSConstructorType | TSESTree.TSConstructSignatureDeclaration | TSESTree.TSDeclareFunctionNoDeclare | TSESTree.TSDeclareFunctionWithDeclare | TSESTree.TSEmptyBodyFunctionExpression | TSESTree.TSFunctionType | TSESTree.TSMethodSignatureComputedName | TSESTree.TSMethodSignatureNonComputedName;
+export declare const isFunctionOrFunctionType: (node: TSESTree.Node | null | undefined) => node is TSESTree.ArrowFunctionExpression | TSESTree.FunctionDeclarationWithName | TSESTree.FunctionDeclarationWithOptionalName | TSESTree.FunctionExpression | TSESTree.TSCallSignatureDeclaration | TSESTree.TSConstructorType | TSESTree.TSConstructSignatureDeclaration | TSESTree.TSDeclareFunctionNoDeclare | TSESTree.TSDeclareFunctionWithDeclare | TSESTree.TSEmptyBodyFunctionExpression | TSESTree.TSFunctionType | TSESTree.TSMethodSignatureComputedName | TSESTree.TSMethodSignatureNonComputedName;
+export declare const isTSFunctionType: (node: TSESTree.Node | null | undefined) => node is TSESTree.TSFunctionType;
+export declare const isTSConstructorType: (node: TSESTree.Node | null | undefined) => node is TSESTree.TSConstructorType;
+export declare const isClassOrTypeElement: (node: TSESTree.Node | null | undefined) => node is TSESTree.FunctionExpression | TSESTree.MethodDefinitionComputedName | TSESTree.MethodDefinitionNonComputedName | TSESTree.PropertyDefinitionComputedName | TSESTree.PropertyDefinitionNonComputedName | TSESTree.TSAbstractMethodDefinitionComputedName | TSESTree.TSAbstractMethodDefinitionNonComputedName | TSESTree.TSAbstractPropertyDefinitionComputedName | TSESTree.TSAbstractPropertyDefinitionNonComputedName | TSESTree.TSCallSignatureDeclaration | TSESTree.TSConstructSignatureDeclaration | TSESTree.TSEmptyBodyFunctionExpression | TSESTree.TSIndexSignature | TSESTree.TSMethodSignatureComputedName | TSESTree.TSMethodSignatureNonComputedName | TSESTree.TSPropertySignatureComputedName | TSESTree.TSPropertySignatureNonComputedName;
+/**
+ * Checks if a node is a constructor method.
+ */
+export declare const isConstructor: (node: TSESTree.Node | null | undefined) => node is Partial<TSESTree.MethodDefinitionComputedName | TSESTree.MethodDefinitionNonComputedName> & (TSESTree.MethodDefinitionComputedName | TSESTree.MethodDefinitionNonComputedName);
+/**
+ * Checks if a node is a setter method.
+ */
+export declare function isSetter(node: TSESTree.Node | undefined): node is {
+    kind: 'set';
+} & (TSESTree.MethodDefinition | TSESTree.Property);
+export declare const isIdentifier: (node: TSESTree.Node | null | undefined) => node is TSESTree.Identifier;
+/**
+ * Checks if a node represents an `await …` expression.
+ */
+export declare const isAwaitExpression: (node: TSESTree.Node | null | undefined) => node is TSESTree.AwaitExpression;
+/**
+ * Checks if a possible token is the `await` keyword.
+ */
+export declare const isAwaitKeyword: (token: TSESTree.Token | null | undefined) => token is {
+    value: "await";
+} & TSESTree.IdentifierToken;
+/**
+ * Checks if a possible token is the `type` keyword.
+ */
+export declare const isTypeKeyword: (token: TSESTree.Token | null | undefined) => token is {
+    value: "type";
+} & TSESTree.IdentifierToken;
+/**
+ * Checks if a possible token is the `import` keyword.
+ */
+export declare const isImportKeyword: (token: TSESTree.Token | null | undefined) => token is {
+    value: "import";
+} & TSESTree.KeywordToken;
+export declare const isLoop: (node: TSESTree.Node | null | undefined) => node is TSESTree.DoWhileStatement | TSESTree.ForInStatement | TSESTree.ForOfStatement | TSESTree.ForStatement | TSESTree.WhileStatement;

package/dist/ast-utils/predicates.js

@@ -0,0 +1,108 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isLoop = exports.isImportKeyword = exports.isTypeKeyword = exports.isAwaitKeyword = exports.isAwaitExpression = exports.isIdentifier = exports.isConstructor = exports.isClassOrTypeElement = exports.isTSConstructorType = exports.isTSFunctionType = exports.isFunctionOrFunctionType = exports.isFunctionType = exports.isFunction = exports.isVariableDeclarator = exports.isTypeAssertion = exports.isLogicalOrOperator = exports.isOptionalCallExpression = exports.isNotNonNullAssertionPunctuator = exports.isNonNullAssertionPunctuator = exports.isNotOptionalChainPunctuator = exports.isOptionalChainPunctuator = void 0;
+exports.isSetter = isSetter;
+const ts_estree_1 = require("../ts-estree");
+const helpers_1 = require("./helpers");
+exports.isOptionalChainPunctuator = (0, helpers_1.isTokenOfTypeWithConditions)(ts_estree_1.AST_TOKEN_TYPES.Punctuator, { value: '?.' });
+exports.isNotOptionalChainPunctuator = (0, helpers_1.isNotTokenOfTypeWithConditions)(ts_estree_1.AST_TOKEN_TYPES.Punctuator, { value: '?.' });
+exports.isNonNullAssertionPunctuator = (0, helpers_1.isTokenOfTypeWithConditions)(ts_estree_1.AST_TOKEN_TYPES.Punctuator, { value: '!' });
+exports.isNotNonNullAssertionPunctuator = (0, helpers_1.isNotTokenOfTypeWithConditions)(ts_estree_1.AST_TOKEN_TYPES.Punctuator, { value: '!' });
+/**
+ * Returns true if and only if the node represents: foo?.() or foo.bar?.()
+ */
+exports.isOptionalCallExpression = (0, helpers_1.isNodeOfTypeWithConditions)(ts_estree_1.AST_NODE_TYPES.CallExpression, 
+// this flag means the call expression itself is option
+// i.e. it is foo.bar?.() and not foo?.bar()
+{ optional: true });
+/**
+ * Returns true if and only if the node represents logical OR
+ */
+exports.isLogicalOrOperator = (0, helpers_1.isNodeOfTypeWithConditions)(ts_estree_1.AST_NODE_TYPES.LogicalExpression, { operator: '||' });
+/**
+ * Checks if a node is a type assertion:
+ * ```
+ * x as foo
+ * <foo>x
+ * ```
+ */
+exports.isTypeAssertion = (0, helpers_1.isNodeOfTypes)([
+    ts_estree_1.AST_NODE_TYPES.TSAsExpression,
+    ts_estree_1.AST_NODE_TYPES.TSTypeAssertion,
+]);
+exports.isVariableDeclarator = (0, helpers_1.isNodeOfType)(ts_estree_1.AST_NODE_TYPES.VariableDeclarator);
+const functionTypes = [
+    ts_estree_1.AST_NODE_TYPES.ArrowFunctionExpression,
+    ts_estree_1.AST_NODE_TYPES.FunctionDeclaration,
+    ts_estree_1.AST_NODE_TYPES.FunctionExpression,
+];
+exports.isFunction = (0, helpers_1.isNodeOfTypes)(functionTypes);
+const functionTypeTypes = [
+    ts_estree_1.AST_NODE_TYPES.TSCallSignatureDeclaration,
+    ts_estree_1.AST_NODE_TYPES.TSConstructorType,
+    ts_estree_1.AST_NODE_TYPES.TSConstructSignatureDeclaration,
+    ts_estree_1.AST_NODE_TYPES.TSDeclareFunction,
+    ts_estree_1.AST_NODE_TYPES.TSEmptyBodyFunctionExpression,
+    ts_estree_1.AST_NODE_TYPES.TSFunctionType,
+    ts_estree_1.AST_NODE_TYPES.TSMethodSignature,
+];
+exports.isFunctionType = (0, helpers_1.isNodeOfTypes)(functionTypeTypes);
+exports.isFunctionOrFunctionType = (0, helpers_1.isNodeOfTypes)([
+    ...functionTypes,
+    ...functionTypeTypes,
+]);
+exports.isTSFunctionType = (0, helpers_1.isNodeOfType)(ts_estree_1.AST_NODE_TYPES.TSFunctionType);
+exports.isTSConstructorType = (0, helpers_1.isNodeOfType)(ts_estree_1.AST_NODE_TYPES.TSConstructorType);
+exports.isClassOrTypeElement = (0, helpers_1.isNodeOfTypes)([
+    // ClassElement
+    ts_estree_1.AST_NODE_TYPES.PropertyDefinition,
+    ts_estree_1.AST_NODE_TYPES.FunctionExpression,
+    ts_estree_1.AST_NODE_TYPES.MethodDefinition,
+    ts_estree_1.AST_NODE_TYPES.TSAbstractPropertyDefinition,
+    ts_estree_1.AST_NODE_TYPES.TSAbstractMethodDefinition,
+    ts_estree_1.AST_NODE_TYPES.TSEmptyBodyFunctionExpression,
+    ts_estree_1.AST_NODE_TYPES.TSIndexSignature,
+    // TypeElement
+    ts_estree_1.AST_NODE_TYPES.TSCallSignatureDeclaration,
+    ts_estree_1.AST_NODE_TYPES.TSConstructSignatureDeclaration,
+    // AST_NODE_TYPES.TSIndexSignature,
+    ts_estree_1.AST_NODE_TYPES.TSMethodSignature,
+    ts_estree_1.AST_NODE_TYPES.TSPropertySignature,
+]);
+/**
+ * Checks if a node is a constructor method.
+ */
+exports.isConstructor = (0, helpers_1.isNodeOfTypeWithConditions)(ts_estree_1.AST_NODE_TYPES.MethodDefinition, { kind: 'constructor' });
+/**
+ * Checks if a node is a setter method.
+ */
+function isSetter(node) {
+    return (!!node &&
+        (node.type === ts_estree_1.AST_NODE_TYPES.MethodDefinition ||
+            node.type === ts_estree_1.AST_NODE_TYPES.Property) &&
+        node.kind === 'set');
+}
+exports.isIdentifier = (0, helpers_1.isNodeOfType)(ts_estree_1.AST_NODE_TYPES.Identifier);
+/**
+ * Checks if a node represents an `await …` expression.
+ */
+exports.isAwaitExpression = (0, helpers_1.isNodeOfType)(ts_estree_1.AST_NODE_TYPES.AwaitExpression);
+/**
+ * Checks if a possible token is the `await` keyword.
+ */
+exports.isAwaitKeyword = (0, helpers_1.isTokenOfTypeWithConditions)(ts_estree_1.AST_TOKEN_TYPES.Identifier, { value: 'await' });
+/**
+ * Checks if a possible token is the `type` keyword.
+ */
+exports.isTypeKeyword = (0, helpers_1.isTokenOfTypeWithConditions)(ts_estree_1.AST_TOKEN_TYPES.Identifier, { value: 'type' });
+/**
+ * Checks if a possible token is the `import` keyword.
+ */
+exports.isImportKeyword = (0, helpers_1.isTokenOfTypeWithConditions)(ts_estree_1.AST_TOKEN_TYPES.Keyword, { value: 'import' });
+exports.isLoop = (0, helpers_1.isNodeOfTypes)([
+    ts_estree_1.AST_NODE_TYPES.DoWhileStatement,
+    ts_estree_1.AST_NODE_TYPES.ForStatement,
+    ts_estree_1.AST_NODE_TYPES.ForInStatement,
+    ts_estree_1.AST_NODE_TYPES.ForOfStatement,
+    ts_estree_1.AST_NODE_TYPES.WhileStatement,
+]);

package/dist/eslint-utils/InferTypesFromRule.d.ts

@@ -0,0 +1,9 @@
+import type { RuleCreateFunction, RuleModule } from '../ts-eslint';
+/**
+ * Uses type inference to fetch the Options type from the given RuleModule
+ */
+export type InferOptionsTypeFromRule<T> = T extends RuleModule<infer _MessageIds, infer Options> ? Options : T extends RuleCreateFunction<infer _MessageIds, infer Options> ? Options : unknown;
+/**
+ * Uses type inference to fetch the MessageIds type from the given RuleModule
+ */
+export type InferMessageIdsTypeFromRule<T> = T extends RuleModule<infer MessageIds, infer _TOptions> ? MessageIds : T extends RuleCreateFunction<infer MessageIds, infer _TOptions> ? MessageIds : unknown;

package/dist/eslint-utils/InferTypesFromRule.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/eslint-utils/RuleCreator.d.ts

@@ -0,0 +1,32 @@
+import type { RuleContext, RuleListener, RuleMetaData, RuleMetaDataDocs, RuleModule } from '../ts-eslint/Rule';
+export type NamedCreateRuleMetaDocs = Omit<RuleMetaDataDocs, 'url'>;
+export type NamedCreateRuleMeta<MessageIds extends string, PluginDocs = unknown, Options extends readonly unknown[] = []> = {
+    docs: PluginDocs & RuleMetaDataDocs;
+} & Omit<RuleMetaData<MessageIds, PluginDocs, Options>, 'docs'>;
+export interface RuleCreateAndOptions<Options extends readonly unknown[], MessageIds extends string> {
+    create: (context: Readonly<RuleContext<MessageIds, Options>>, optionsWithDefault: Readonly<Options>) => RuleListener;
+    /** @deprecated Use meta.defaultOptions instead */
+    defaultOptions?: Readonly<Options>;
+}
+export interface RuleWithMeta<Options extends readonly unknown[], MessageIds extends string, Docs = unknown> extends RuleCreateAndOptions<Options, MessageIds> {
+    meta: RuleMetaData<MessageIds, Docs, Options>;
+    name?: string;
+}
+export interface RuleWithMetaAndName<Options extends readonly unknown[], MessageIds extends string, Docs = unknown> extends RuleCreateAndOptions<Options, MessageIds> {
+    meta: NamedCreateRuleMeta<MessageIds, Docs, Options>;
+    name: string;
+}
+type RuleModuleWithName<MessageIds extends string, Options extends readonly unknown[] = [], Docs = unknown, ExtendedRuleListener extends RuleListener = RuleListener> = RuleModule<MessageIds, Options, Docs, ExtendedRuleListener> & {
+    name: string;
+};
+/**
+ * Creates reusable function to create rules with default options and docs URLs.
+ *
+ * @param urlCreator Creates a documentation URL for a given rule name.
+ * @returns Function to create a rule with the docs URL format.
+ */
+export declare function RuleCreator<PluginDocs = unknown>(urlCreator: (ruleName: string) => string): <Options extends readonly unknown[], MessageIds extends string>({ meta, name, ...rule }: Readonly<RuleWithMetaAndName<Options, MessageIds, PluginDocs>>) => RuleModuleWithName<MessageIds, Options, PluginDocs>;
+export declare namespace RuleCreator {
+    var withoutDocs: <Options extends readonly unknown[], MessageIds extends string>(args: Readonly<RuleWithMeta<Options, MessageIds>>) => RuleModule<MessageIds, Options>;
+}
+export { type RuleListener, type RuleModule } from '../ts-eslint/Rule';

package/dist/eslint-utils/RuleCreator.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RuleCreator = RuleCreator;
+const applyDefault_1 = require("./applyDefault");
+/**
+ * Creates reusable function to create rules with default options and docs URLs.
+ *
+ * @param urlCreator Creates a documentation URL for a given rule name.
+ * @returns Function to create a rule with the docs URL format.
+ */
+function RuleCreator(urlCreator) {
+    // This function will get much easier to call when this is merged https://github.com/Microsoft/TypeScript/pull/26349
+    // TODO - when the above PR lands; add type checking for the context.report `data` property
+    return function createNamedRule({ meta, name, ...rule }) {
+        const ruleWithDocs = createRule({
+            meta: {
+                ...meta,
+                docs: {
+                    ...meta.docs,
+                    url: urlCreator(name),
+                },
+            },
+            name,
+            ...rule,
+        });
+        return ruleWithDocs;
+    };
+}
+function createRule({ create, 
+// Keep accepting deprecated defaultOptions for backward compatibility.
+// eslint-disable-next-line @typescript-eslint/no-deprecated
+defaultOptions, meta, name, }) {
+    const resolvedDefaultOptions = (meta.defaultOptions ??
+        defaultOptions ??
+        []);
+    return {
+        create(context) {
+            const optionsWithDefault = (0, applyDefault_1.applyDefault)(resolvedDefaultOptions, context.options);
+            return create(context, optionsWithDefault);
+        },
+        defaultOptions,
+        meta,
+        name,
+    };
+}
+/**
+ * Creates a well-typed TSESLint custom ESLint rule without a docs URL.
+ *
+ * @returns Well-typed TSESLint custom ESLint rule.
+ * @remarks It is generally better to provide a docs URL function to RuleCreator.
+ */
+RuleCreator.withoutDocs = function withoutDocs(args) {
+    return createRule(args);
+};

package/dist/eslint-utils/applyDefault.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Pure function - doesn't mutate either parameter!
+ * Uses the default options and overrides with the options provided by the user
+ * @param defaultOptions the defaults
+ * @param userOptions the user opts
+ * @returns the options with defaults
+ */
+export declare function applyDefault<User extends readonly unknown[], Default extends User>(defaultOptions: Readonly<Default>, userOptions: Readonly<User> | null): Default;

package/dist/eslint-utils/applyDefault.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.applyDefault = applyDefault;
+const deepMerge_1 = require("./deepMerge");
+/**
+ * Pure function - doesn't mutate either parameter!
+ * Uses the default options and overrides with the options provided by the user
+ * @param defaultOptions the defaults
+ * @param userOptions the user opts
+ * @returns the options with defaults
+ */
+function applyDefault(defaultOptions, userOptions) {
+    // clone defaults
+    const options = structuredClone(defaultOptions);
+    if (userOptions == null) {
+        return options;
+    }
+    // For avoiding the type error
+    //   `This expression is not callable. Type 'unknown' has no call signatures.ts(2349)`
+    options.forEach((opt, i) => {
+        // eslint-disable-next-line @typescript-eslint/internal/eqeq-nullish
+        if (userOptions[i] !== undefined) {
+            const userOpt = userOptions[i];
+            if ((0, deepMerge_1.isObjectNotArray)(userOpt) && (0, deepMerge_1.isObjectNotArray)(opt)) {
+                options[i] = (0, deepMerge_1.deepMerge)(opt, userOpt);
+            }
+            else {
+                options[i] = userOpt;
+            }
+        }
+    });
+    return options;
+}

package/dist/eslint-utils/deepMerge.d.ts

@@ -0,0 +1,14 @@
+export type ObjectLike<T = unknown> = Record<string, T>;
+/**
+ * Check if the variable contains an object strictly rejecting arrays
+ * @returns `true` if obj is an object
+ */
+export declare function isObjectNotArray(obj: unknown): obj is ObjectLike;
+/**
+ * Pure function - doesn't mutate either parameter!
+ * Merges two objects together deeply, overwriting the properties in first with the properties in second
+ * @param first The first object
+ * @param second The second object
+ * @returns a new object
+ */
+export declare function deepMerge(first?: ObjectLike, second?: ObjectLike): Record<string, unknown>;

package/dist/eslint-utils/deepMerge.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isObjectNotArray = isObjectNotArray;
+exports.deepMerge = deepMerge;
+/**
+ * Check if the variable contains an object strictly rejecting arrays
+ * @returns `true` if obj is an object
+ */
+function isObjectNotArray(obj) {
+    return typeof obj === 'object' && obj != null && !Array.isArray(obj);
+}
+/**
+ * Pure function - doesn't mutate either parameter!
+ * Merges two objects together deeply, overwriting the properties in first with the properties in second
+ * @param first The first object
+ * @param second The second object
+ * @returns a new object
+ */
+function deepMerge(first = {}, second = {}) {
+    // get the unique set of keys across both objects
+    const keys = new Set([...Object.keys(first), ...Object.keys(second)]);
+    return Object.fromEntries([...keys].map(key => {
+        const firstHasKey = key in first;
+        const secondHasKey = key in second;
+        const firstValue = first[key];
+        const secondValue = second[key];
+        let value;
+        if (firstHasKey && secondHasKey) {
+            if (isObjectNotArray(firstValue) && isObjectNotArray(secondValue)) {
+                // object type
+                value = deepMerge(firstValue, secondValue);
+            }
+            else {
+                // value type
+                value = secondValue;
+            }
+        }
+        else if (firstHasKey) {
+            value = firstValue;
+        }
+        else {
+            value = secondValue;
+        }
+        return [key, value];
+    }));
+}

package/dist/eslint-utils/getParserServices.d.ts

@@ -0,0 +1,22 @@
+import type * as TSESLint from '../ts-eslint';
+import type { ParserServices, ParserServicesWithTypeInformation } from '../ts-estree';
+/**
+ * Try to retrieve type-aware parser service from context.
+ * This **_will_** throw if it is not available.
+ */
+export declare function getParserServices<MessageIds extends string, Options extends readonly unknown[]>(context: Readonly<TSESLint.RuleContext<MessageIds, Options>>): ParserServicesWithTypeInformation;
+/**
+ * Try to retrieve type-aware parser service from context.
+ * This **_will_** throw if it is not available.
+ */
+export declare function getParserServices<MessageIds extends string, Options extends readonly unknown[]>(context: Readonly<TSESLint.RuleContext<MessageIds, Options>>, allowWithoutFullTypeInformation: false): ParserServicesWithTypeInformation;
+/**
+ * Try to retrieve type-aware parser service from context.
+ * This **_will not_** throw if it is not available.
+ */
+export declare function getParserServices<MessageIds extends string, Options extends readonly unknown[]>(context: Readonly<TSESLint.RuleContext<MessageIds, Options>>, allowWithoutFullTypeInformation: true): ParserServices;
+/**
+ * Try to retrieve type-aware parser service from context.
+ * This may or may not throw if it is not available, depending on if `allowWithoutFullTypeInformation` is `true`
+ */
+export declare function getParserServices<MessageIds extends string, Options extends readonly unknown[]>(context: Readonly<TSESLint.RuleContext<MessageIds, Options>>, allowWithoutFullTypeInformation: boolean): ParserServices;

package/dist/eslint-utils/getParserServices.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getParserServices = getParserServices;
+const parserSeemsToBeTSESLint_1 = require("./parserSeemsToBeTSESLint");
+const ERROR_MESSAGE_REQUIRES_PARSER_SERVICES = "You have used a rule which requires type information, but don't have parserOptions set to generate type information for this file. See https://tseslint.com/typed-linting for enabling linting with type information.";
+const ERROR_MESSAGE_UNKNOWN_PARSER = 'Note: detected a parser other than @typescript-eslint/parser. Make sure the parser is configured to forward "parserOptions.project" to @typescript-eslint/parser.';
+function getParserServices(context, allowWithoutFullTypeInformation = false) {
+    const parser = 
+    // eslint-disable-next-line @typescript-eslint/no-deprecated -- For compatibility with ESLint 8
+    context.parserPath || context.languageOptions.parser?.meta?.name;
+    // This check is unnecessary if the user is using the latest version of our parser.
+    //
+    // However the world isn't perfect:
+    // - Users often use old parser versions.
+    //   Old versions of the parser would not return any parserServices unless parserOptions.project was set.
+    // - Users sometimes use parsers that aren't @typescript-eslint/parser
+    //   Other parsers won't return the parser services we expect (if they return any at all).
+    //
+    // This check allows us to handle bad user setups whilst providing a nice user-facing
+    // error message explaining the problem.
+    if (context.sourceCode.parserServices?.esTreeNodeToTSNodeMap == null ||
+        context.sourceCode.parserServices.tsNodeToESTreeNodeMap == null) {
+        throwError(parser);
+    }
+    // if a rule requires full type information, then hard fail if it doesn't exist
+    // this forces the user to supply parserOptions.project
+    if (context.sourceCode.parserServices.program == null &&
+        !allowWithoutFullTypeInformation) {
+        throwError(parser);
+    }
+    return context.sourceCode.parserServices;
+}
+/* eslint-enable @typescript-eslint/unified-signatures */
+function throwError(parser) {
+    const messages = [
+        ERROR_MESSAGE_REQUIRES_PARSER_SERVICES,
+        `Parser: ${parser || '(unknown)'}`,
+        !(0, parserSeemsToBeTSESLint_1.parserSeemsToBeTSESLint)(parser) && ERROR_MESSAGE_UNKNOWN_PARSER,
+    ].filter(Boolean);
+    throw new Error(messages.join('\n'));
+}

package/dist/eslint-utils/index.d.ts

@@ -0,0 +1,6 @@
+export * from './applyDefault';
+export * from './deepMerge';
+export * from './getParserServices';
+export * from './InferTypesFromRule';
+export * from './nullThrows';
+export * from './RuleCreator';

package/dist/eslint-utils/index.js

@@ -0,0 +1,22 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./applyDefault"), exports);
+__exportStar(require("./deepMerge"), exports);
+__exportStar(require("./getParserServices"), exports);
+__exportStar(require("./InferTypesFromRule"), exports);
+__exportStar(require("./nullThrows"), exports);
+__exportStar(require("./RuleCreator"), exports);

package/dist/eslint-utils/nullThrows.d.ts

@@ -0,0 +1,12 @@
+/**
+ * A set of common reasons for calling nullThrows
+ */
+export declare const NullThrowsReasons: {
+    readonly MissingParent: "Expected node to have a parent.";
+    readonly MissingToken: (token: string, thing: string) => string;
+};
+/**
+ * Assert that a value must not be null or undefined.
+ * This is a nice explicit alternative to the non-null assertion operator.
+ */
+export declare function nullThrows<T>(value: T, message: string): NonNullable<T>;

package/dist/eslint-utils/nullThrows.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NullThrowsReasons = void 0;
+exports.nullThrows = nullThrows;
+/**
+ * A set of common reasons for calling nullThrows
+ */
+exports.NullThrowsReasons = {
+    MissingParent: 'Expected node to have a parent.',
+    MissingToken: (token, thing) => `Expected to find a ${token} for the ${thing}.`,
+};
+/**
+ * Assert that a value must not be null or undefined.
+ * This is a nice explicit alternative to the non-null assertion operator.
+ */
+function nullThrows(value, message) {
+    if (value == null) {
+        throw new Error(`Non-null Assertion Failed: ${message}`);
+    }
+    return value;
+}

package/dist/eslint-utils/parserSeemsToBeTSESLint.d.ts

@@ -0,0 +1 @@
+export declare function parserSeemsToBeTSESLint(parser: string | undefined): boolean;

package/dist/eslint-utils/parserSeemsToBeTSESLint.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parserSeemsToBeTSESLint = parserSeemsToBeTSESLint;
+function parserSeemsToBeTSESLint(parser) {
+    return !!parser && /(?:typescript-eslint|\.\.)[\w/\\]*parser/.test(parser);
+}

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+export * as ASTUtils from './ast-utils';
+export * as ESLintUtils from './eslint-utils';
+export * as JSONSchema from './json-schema';
+export * as TSESLint from './ts-eslint';
+export * from './ts-estree';
+export * as TSUtils from './ts-utils';