eslint-plugin-complete 1.0.0

package/dist/rules.d.ts

@@ -0,0 +1,49 @@
+export declare const rules: {
+    "complete-sentences-jsdoc": import("@typescript-eslint/utils/ts-eslint").RuleModule<import("./completeSentence.js").CompleteSentenceMessageIds, [], import("./interfaces/MyPluginDocs.js").MyPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+    "complete-sentences-line-comments": import("@typescript-eslint/utils/ts-eslint").RuleModule<import("./completeSentence.js").CompleteSentenceMessageIds, [], import("./interfaces/MyPluginDocs.js").MyPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+    "consistent-enum-values": import("@typescript-eslint/utils/ts-eslint").RuleModule<"inconsistentValue", [], import("./interfaces/MyPluginDocs.js").MyPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+    "consistent-named-tuples": import("@typescript-eslint/utils/ts-eslint").RuleModule<"notNamed", [], import("./interfaces/MyPluginDocs.js").MyPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+    "eqeqeq-fix": import("@typescript-eslint/utils/ts-eslint").RuleModule<"unexpected", [], import("./interfaces/MyPluginDocs.js").MyPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+    "format-jsdoc-comments": import("@typescript-eslint/utils/ts-eslint").RuleModule<"incorrectlyFormatted", import("./rules/format-jsdoc-comments.js").Options, import("./interfaces/MyPluginDocs.js").MyPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+    "format-line-comments": import("@typescript-eslint/utils/ts-eslint").RuleModule<"incorrectlyFormatted", import("./rules/format-line-comments.js").Options, import("./interfaces/MyPluginDocs.js").MyPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+    "jsdoc-code-block-language": import("@typescript-eslint/utils/ts-eslint").RuleModule<"noLanguage", [], import("./interfaces/MyPluginDocs.js").MyPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+    "newline-between-switch-case": import("@typescript-eslint/utils/ts-eslint").RuleModule<"noNewline", [], import("./interfaces/MyPluginDocs.js").MyPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+    "no-confusing-set-methods": import("@typescript-eslint/utils/ts-eslint").RuleModule<"noKeys" | "noEntries", [], import("./interfaces/MyPluginDocs.js").MyPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+    "no-empty-jsdoc": import("@typescript-eslint/utils/ts-eslint").RuleModule<"isEmpty", [], import("./interfaces/MyPluginDocs.js").MyPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+    "no-empty-line-comments": import("@typescript-eslint/utils/ts-eslint").RuleModule<"isEmpty", [], import("./interfaces/MyPluginDocs.js").MyPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+    "no-explicit-array-loops": import("@typescript-eslint/utils/ts-eslint").RuleModule<"noExplicitArray", [], import("./interfaces/MyPluginDocs.js").MyPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+    "no-explicit-map-set-loops": import("@typescript-eslint/utils/ts-eslint").RuleModule<"noExplicitMap" | "noExplicitSet", [], import("./interfaces/MyPluginDocs.js").MyPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+    "no-for-in": import("@typescript-eslint/utils/ts-eslint").RuleModule<"noForIn", [], import("./interfaces/MyPluginDocs.js").MyPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+    "no-let-any": import("@typescript-eslint/utils/ts-eslint").RuleModule<"noType", [], import("./interfaces/MyPluginDocs.js").MyPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+    "no-mutable-return": import("@typescript-eslint/utils/ts-eslint").RuleModule<"mutableArray" | "mutableMap" | "mutableSet", [], import("./interfaces/MyPluginDocs.js").MyPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+    "no-number-enums": import("@typescript-eslint/utils/ts-eslint").RuleModule<"noNumberEnums", [], import("./interfaces/MyPluginDocs.js").MyPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+    "no-object-any": import("@typescript-eslint/utils/ts-eslint").RuleModule<"noType", [], import("./interfaces/MyPluginDocs.js").MyPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+    "no-object-methods-with-map-set": import("@typescript-eslint/utils/ts-eslint").RuleModule<"noObjectEntriesMap" | "noObjectKeysMap" | "noObjectValuesMap" | "noObjectEntriesSet" | "noObjectKeysSet" | "noObjectValuesSet", [], import("./interfaces/MyPluginDocs.js").MyPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+    "no-string-length-0": import("@typescript-eslint/utils/ts-eslint").RuleModule<"noStringLength0", [], import("./interfaces/MyPluginDocs.js").MyPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+    "no-template-curly-in-string-fix": import("@typescript-eslint/utils/ts-eslint").RuleModule<"unexpectedTemplateExpression", [], import("./interfaces/MyPluginDocs.js").MyPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+    "no-undefined-return-type": import("@typescript-eslint/utils/ts-eslint").RuleModule<"undefinedReturnType", [], import("./interfaces/MyPluginDocs.js").MyPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+    "no-unnecessary-assignment": import("@typescript-eslint/utils/ts-eslint").RuleModule<import("./rules/no-unnecessary-assignment.js").MessageIds, [], import("./interfaces/MyPluginDocs.js").MyPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+    "no-unsafe-plusplus": import("@typescript-eslint/utils/ts-eslint").RuleModule<"plusPlus" | "minusMinus", [], import("./interfaces/MyPluginDocs.js").MyPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+    "no-useless-return": import("@typescript-eslint/utils/ts-eslint").RuleModule<"unnecessaryReturn", [], import("./interfaces/MyPluginDocs.js").MyPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+    "no-void-return-type": import("@typescript-eslint/utils/ts-eslint").RuleModule<"voidReturnType", [], import("./interfaces/MyPluginDocs.js").MyPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+    "prefer-const": import("@typescript-eslint/utils/ts-eslint").RuleModule<"useConst", [], import("./interfaces/MyPluginDocs.js").MyPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+    "prefer-plusplus": import("@typescript-eslint/utils/ts-eslint").RuleModule<import("./rules/prefer-plusplus.js").MessageIds, [], import("./interfaces/MyPluginDocs.js").MyPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+    "prefer-postfix-plusplus": import("@typescript-eslint/utils/ts-eslint").RuleModule<"plusPlus" | "minusMinus", [], import("./interfaces/MyPluginDocs.js").MyPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+    "prefer-readonly-parameter-types": import("@typescript-eslint/utils/ts-eslint").RuleModule<"shouldBeReadonly", [{
+        allow?: import("@typescript-eslint/type-utils").TypeOrValueSpecifier[];
+        checkParameterProperties?: boolean;
+        ignoreInferredTypes?: boolean;
+        treatMethodsAsReadonly?: boolean;
+        onlyRecordsArraysMapsSet?: boolean;
+    }], import("./interfaces/MyPluginDocs.js").MyPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+    "require-break": import("@typescript-eslint/utils/ts-eslint").RuleModule<"noBreak", [], import("./interfaces/MyPluginDocs.js").MyPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+    "require-capital-const-assertions": import("@typescript-eslint/utils/ts-eslint").RuleModule<"noConstAssertion", [], import("./interfaces/MyPluginDocs.js").MyPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+    "require-capital-read-only": import("@typescript-eslint/utils/ts-eslint").RuleModule<import("./rules/require-capital-read-only.js").MessageIds, [], import("./interfaces/MyPluginDocs.js").MyPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+    "require-unannotated-const-assertions": import("@typescript-eslint/utils/ts-eslint").RuleModule<"annotatedConstAssertion", [], import("./interfaces/MyPluginDocs.js").MyPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+    "require-variadic-function-argument": import("@typescript-eslint/utils/ts-eslint").RuleModule<"noArgument", [], import("./interfaces/MyPluginDocs.js").MyPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+    "strict-array-methods": import("@typescript-eslint/utils/ts-eslint").RuleModule<"conditionError", [], import("./interfaces/MyPluginDocs.js").MyPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+    "strict-enums": import("@typescript-eslint/utils/ts-eslint").RuleModule<import("./rules/strict-enums.js").MessageIds, [], import("./interfaces/MyPluginDocs.js").MyPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+    "strict-undefined-functions": import("@typescript-eslint/utils/ts-eslint").RuleModule<"mismatchedReturnType", [], import("./interfaces/MyPluginDocs.js").MyPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+    "strict-void-functions": import("@typescript-eslint/utils/ts-eslint").RuleModule<"mismatchedReturnType", [], import("./interfaces/MyPluginDocs.js").MyPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+};
+//# sourceMappingURL=rules.d.ts.map

package/dist/rules.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rules.d.ts","sourceRoot":"","sources":["../src/rules.ts"],"names":[],"mappings":"AA6CA,eAAO,MAAM,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAyCjB,CAAC"}

package/dist/rules.js

@@ -0,0 +1,85 @@
+/// THIS FILE IS AUTOMATICALLY GENERATED BY THE "generate.ts" SCRIPT.
+/// DO NOT EDIT THIS FILE! YOU CAN REGENERATE IT WITH:
+/// npm run generate
+import { completeSentencesJSDoc } from "./rules/complete-sentences-jsdoc.js";
+import { completeSentencesLineComments } from "./rules/complete-sentences-line-comments.js";
+import { consistentEnumValues } from "./rules/consistent-enum-values.js";
+import { consistentNamedTuples } from "./rules/consistent-named-tuples.js";
+import { eqeqeqFix } from "./rules/eqeqeq-fix.js";
+import { formatJSDocComments } from "./rules/format-jsdoc-comments.js";
+import { formatLineComments } from "./rules/format-line-comments.js";
+import { jsdocCodeBlockLanguage } from "./rules/jsdoc-code-block-language.js";
+import { newlineBetweenSwitchCase } from "./rules/newline-between-switch-case.js";
+import { noConfusingSetMethods } from "./rules/no-confusing-set-methods.js";
+import { noEmptyJSDoc } from "./rules/no-empty-jsdoc.js";
+import { noEmptyLineComments } from "./rules/no-empty-line-comments.js";
+import { noExplicitArrayLoops } from "./rules/no-explicit-array-loops.js";
+import { noExplicitMapSetLoops } from "./rules/no-explicit-map-set-loops.js";
+import { noForIn } from "./rules/no-for-in.js";
+import { noLetAny } from "./rules/no-let-any.js";
+import { noMutableReturn } from "./rules/no-mutable-return.js";
+import { noNumberEnums } from "./rules/no-number-enums.js";
+import { noObjectAny } from "./rules/no-object-any.js";
+import { noObjectMethodsWithMapSet } from "./rules/no-object-methods-with-map-set.js";
+import { noStringLength0 } from "./rules/no-string-length-0.js";
+import { noTemplateCurlyInStringFix } from "./rules/no-template-curly-in-string-fix.js";
+import { noUndefinedReturnType } from "./rules/no-undefined-return-type.js";
+import { noUnnecessaryAssignment } from "./rules/no-unnecessary-assignment.js";
+import { noUnsafePlusplus } from "./rules/no-unsafe-plusplus.js";
+import { noUselessReturn } from "./rules/no-useless-return.js";
+import { noVoidReturnType } from "./rules/no-void-return-type.js";
+import { preferConst } from "./rules/prefer-const.js";
+import { preferPlusplus } from "./rules/prefer-plusplus.js";
+import { preferPostfixPlusplus } from "./rules/prefer-postfix-plusplus.js";
+import { preferReadonlyParameterTypes } from "./rules/prefer-readonly-parameter-types.js";
+import { requireBreak } from "./rules/require-break.js";
+import { requireCapitalConstAssertions } from "./rules/require-capital-const-assertions.js";
+import { requireCapitalReadOnly } from "./rules/require-capital-read-only.js";
+import { requireUnannotatedConstAssertions } from "./rules/require-unannotated-const-assertions.js";
+import { requireVariadicFunctionArgument } from "./rules/require-variadic-function-argument.js";
+import { strictArrayMethods } from "./rules/strict-array-methods.js";
+import { strictEnums } from "./rules/strict-enums.js";
+import { strictUndefinedFunctions } from "./rules/strict-undefined-functions.js";
+import { strictVoidFunctions } from "./rules/strict-void-functions.js";
+export const rules = {
+    "complete-sentences-jsdoc": completeSentencesJSDoc,
+    "complete-sentences-line-comments": completeSentencesLineComments,
+    "consistent-enum-values": consistentEnumValues,
+    "consistent-named-tuples": consistentNamedTuples,
+    "eqeqeq-fix": eqeqeqFix,
+    "format-jsdoc-comments": formatJSDocComments,
+    "format-line-comments": formatLineComments,
+    "jsdoc-code-block-language": jsdocCodeBlockLanguage,
+    "newline-between-switch-case": newlineBetweenSwitchCase,
+    "no-confusing-set-methods": noConfusingSetMethods,
+    "no-empty-jsdoc": noEmptyJSDoc,
+    "no-empty-line-comments": noEmptyLineComments,
+    "no-explicit-array-loops": noExplicitArrayLoops,
+    "no-explicit-map-set-loops": noExplicitMapSetLoops,
+    "no-for-in": noForIn,
+    "no-let-any": noLetAny,
+    "no-mutable-return": noMutableReturn,
+    "no-number-enums": noNumberEnums,
+    "no-object-any": noObjectAny,
+    "no-object-methods-with-map-set": noObjectMethodsWithMapSet,
+    "no-string-length-0": noStringLength0,
+    "no-template-curly-in-string-fix": noTemplateCurlyInStringFix,
+    "no-undefined-return-type": noUndefinedReturnType,
+    "no-unnecessary-assignment": noUnnecessaryAssignment,
+    "no-unsafe-plusplus": noUnsafePlusplus,
+    "no-useless-return": noUselessReturn,
+    "no-void-return-type": noVoidReturnType,
+    "prefer-const": preferConst,
+    "prefer-plusplus": preferPlusplus,
+    "prefer-postfix-plusplus": preferPostfixPlusplus,
+    "prefer-readonly-parameter-types": preferReadonlyParameterTypes,
+    "require-break": requireBreak,
+    "require-capital-const-assertions": requireCapitalConstAssertions,
+    "require-capital-read-only": requireCapitalReadOnly,
+    "require-unannotated-const-assertions": requireUnannotatedConstAssertions,
+    "require-variadic-function-argument": requireVariadicFunctionArgument,
+    "strict-array-methods": strictArrayMethods,
+    "strict-enums": strictEnums,
+    "strict-undefined-functions": strictUndefinedFunctions,
+    "strict-void-functions": strictVoidFunctions,
+};

package/dist/template.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=template.d.ts.map

package/dist/template.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"template.d.ts","sourceRoot":"","sources":["../src/template.ts"],"names":[],"mappings":""}

package/dist/template.js

@@ -0,0 +1,29 @@
+export {};
+/*
+import { ESLintUtils } from "@typescript-eslint/utils";
+import { createRule } from "../utils.js";
+
+export const RULE_NAME_CAMEL_CASE = createRule({
+  name: "RULE_NAME",
+  meta: {
+    type: "problem",
+    docs: {
+      description: "RULE_DESCRIPTION",
+      recommended: true,
+      requiresTypeChecking: true,
+    },
+    schema: [],
+    messages: {
+      foo: "Foo must be bar.",
+    },
+  },
+  defaultOptions: [],
+  create(context) {
+    const parserServices = ESLintUtils.getParserServices(context);
+    const checker = parserServices.program.getTypeChecker();
+
+    return {
+    };
+  },
+});
+*/

package/dist/typeUtils.d.ts

@@ -0,0 +1,28 @@
+import ts from "typescript";
+export declare function getTypeName(type: ts.Type): string | undefined;
+/**
+ * @param symbol The symbol to check.
+ * @param flagsToCheck The composition of one or more `ts.SymbolFlags`.
+ */
+export declare function isSymbolFlagSet(symbol: ts.Symbol, flagsToCheck: number | ts.SymbolFlags): boolean;
+/**
+ * Checks if the given type is either an array/tuple type, or a union made up solely of array/tuple
+ * types.
+ *
+ * Based on the `isTypeArrayTypeOrUnionOfArrayTypes` from `typescript-eslint`, but modified to also
+ * match tuples.
+ */
+export declare function isTypeArrayTupleTypeOrUnionOfArrayTupleTypes(type: ts.Type, checker: ts.TypeChecker): boolean;
+export declare function isAny(type: ts.Type): boolean;
+/** Returns all types of a union type or an array containing `type` itself if it's no union type. */
+export declare function unionTypeParts(type: ts.Type): readonly ts.Type[];
+/**
+ * Note that if the type is a union, this function will decompose it into the parts and get the
+ * flags of every union constituent.
+ *
+ * @param type The type to check.
+ * @param flagsToCheck The composition of one or more `ts.TypeFlags`.
+ */
+export declare function isTypeFlagSet(type: ts.Type, flagsToCheck: number | ts.TypeFlags): boolean;
+export declare function isFlagSet(flags: number, flag: number): boolean;
+//# sourceMappingURL=typeUtils.d.ts.map

package/dist/typeUtils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"typeUtils.d.ts","sourceRoot":"","sources":["../src/typeUtils.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,MAAM,YAAY,CAAC;AAW5B,wBAAgB,WAAW,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,GAAG,MAAM,GAAG,SAAS,CAoB7D;AAED;;;GAGG;AACH,wBAAgB,eAAe,CAC7B,MAAM,EAAE,EAAE,CAAC,MAAM,EACjB,YAAY,EAAE,MAAM,GAAG,EAAE,CAAC,WAAW,GACpC,OAAO,CAET;AAED;;;;;;GAMG;AACH,wBAAgB,4CAA4C,CAC1D,IAAI,EAAE,EAAE,CAAC,IAAI,EACb,OAAO,EAAE,EAAE,CAAC,WAAW,GACtB,OAAO,CAQT;AAED,wBAAgB,KAAK,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,GAAG,OAAO,CAE5C;AAED,oGAAoG;AACpG,wBAAgB,cAAc,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,GAAG,SAAS,EAAE,CAAC,IAAI,EAAE,CAEhE;AAOD;;;;;;GAMG;AACH,wBAAgB,aAAa,CAC3B,IAAI,EAAE,EAAE,CAAC,IAAI,EACb,YAAY,EAAE,MAAM,GAAG,EAAE,CAAC,SAAS,GAClC,OAAO,CAGT;AAED,wBAAgB,SAAS,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAE9D"}

package/dist/typeUtils.js

@@ -0,0 +1,76 @@
+// Some of the functions are copy-pasted here from the `typescript-eslint` repository and slightly
+// modified.
+import ts from "typescript";
+/** Gets all of the type flags in a type, iterating through unions automatically. */
+function getTypeFlags(type) {
+    let flags = 0;
+    for (const t of unionTypeParts(type)) {
+        flags |= t.flags;
+    }
+    return flags;
+}
+export function getTypeName(type) {
+    const escapedName = type.getSymbol()?.escapedName;
+    if (escapedName !== undefined && escapedName !== "__type") {
+        return escapedName;
+    }
+    const aliasSymbolName = type.aliasSymbol?.getName();
+    if (aliasSymbolName !== undefined) {
+        return aliasSymbolName;
+    }
+    // The above checks do not work with boolean values.
+    if ("intrinsicName" in type) {
+        const { intrinsicName } = type;
+        if (typeof intrinsicName === "string" && intrinsicName !== "") {
+            return intrinsicName;
+        }
+    }
+    return undefined;
+}
+/**
+ * @param symbol The symbol to check.
+ * @param flagsToCheck The composition of one or more `ts.SymbolFlags`.
+ */
+export function isSymbolFlagSet(symbol, flagsToCheck) {
+    return isFlagSet(symbol.flags, flagsToCheck);
+}
+/**
+ * Checks if the given type is either an array/tuple type, or a union made up solely of array/tuple
+ * types.
+ *
+ * Based on the `isTypeArrayTypeOrUnionOfArrayTypes` from `typescript-eslint`, but modified to also
+ * match tuples.
+ */
+export function isTypeArrayTupleTypeOrUnionOfArrayTupleTypes(type, checker) {
+    for (const t of unionTypeParts(type)) {
+        if (!checker.isArrayType(t) && !checker.isTupleType(t)) {
+            return false;
+        }
+    }
+    return true;
+}
+export function isAny(type) {
+    return isTypeFlagSet(type, ts.TypeFlags.Any);
+}
+/** Returns all types of a union type or an array containing `type` itself if it's no union type. */
+export function unionTypeParts(type) {
+    return isUnion(type) ? type.types : [type];
+}
+function isUnion(type) {
+    // We cannot use the `isTypeFlagSet` function here, since that decomposes unions.
+    return isFlagSet(type.flags, ts.TypeFlags.Union);
+}
+/**
+ * Note that if the type is a union, this function will decompose it into the parts and get the
+ * flags of every union constituent.
+ *
+ * @param type The type to check.
+ * @param flagsToCheck The composition of one or more `ts.TypeFlags`.
+ */
+export function isTypeFlagSet(type, flagsToCheck) {
+    const flags = getTypeFlags(type);
+    return isFlagSet(flags, flagsToCheck);
+}
+export function isFlagSet(flags, flag) {
+    return (flags & flag) !== 0;
+}

package/dist/utils.d.ts

@@ -0,0 +1,13 @@
+import type { TSESTree } from "@typescript-eslint/utils";
+import { ESLintUtils } from "@typescript-eslint/utils";
+import type { MyPluginDocs } from "./interfaces/MyPluginDocs.js";
+export declare function areStringsEqualExcludingTrailingSpaces(string1: string, string2: string): boolean;
+/** @see https://typescript-eslint.io/developers/custom-rules#extra-rule-docs-types */
+export declare const createRule: <Options extends readonly unknown[], MessageIds extends string>({ meta, name, ...rule }: Readonly<ESLintUtils.RuleWithMetaAndName<Options, MessageIds, MyPluginDocs>>) => ESLintUtils.RuleModule<MessageIds, Options, MyPluginDocs, ESLintUtils.RuleListener>;
+/**
+ * From: https://stackoverflow.com/questions/13627308/add-st-nd-rd-and-th-ordinal-suffix-to-a-number
+ */
+export declare function getOrdinalSuffix(i: number): string;
+export declare function getParentFunction(node: TSESTree.Node): TSESTree.ArrowFunctionExpression | TSESTree.FunctionDeclarationWithName | TSESTree.FunctionDeclarationWithOptionalName | TSESTree.FunctionExpression | undefined;
+export declare function hasURL(text: string): boolean;
+//# sourceMappingURL=utils.d.ts.map

package/dist/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../src/utils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AACzD,OAAO,EAAY,WAAW,EAAE,MAAM,0BAA0B,CAAC;AACjE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,8BAA8B,CAAC;AAKjE,wBAAgB,sCAAsC,CACpD,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,MAAM,GACd,OAAO,CAqBT;AAED,sFAAsF;AAEtF,eAAO,MAAM,UAAU,+PAGtB,CAAC;AAEF;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAalD;AAED,wBAAgB,iBAAiB,CAC/B,IAAI,EAAE,QAAQ,CAAC,IAAI,GAEjB,QAAQ,CAAC,uBAAuB,GAChC,QAAQ,CAAC,2BAA2B,GACpC,QAAQ,CAAC,mCAAmC,GAC5C,QAAQ,CAAC,kBAAkB,GAC3B,SAAS,CAYZ;AAED,wBAAgB,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAE5C"}

package/dist/utils.js

@@ -0,0 +1,54 @@
+import { ASTUtils, ESLintUtils } from "@typescript-eslint/utils";
+/** Taken from ESLint: https://github.com/eslint/eslint/blob/main/lib/rules/max-len.js */
+const URL_REGEXP = /[^:/?#]:\/\/[^?#]/u;
+export function areStringsEqualExcludingTrailingSpaces(string1, string2) {
+    const string1Lines = string1.split("\n");
+    const string2Lines = string2.split("\n");
+    if (string1Lines.length !== string2Lines.length) {
+        return false;
+    }
+    // eslint-disable-next-line unicorn/no-for-loop
+    for (let i = 0; i < string1Lines.length; i++) {
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        const line1 = string1Lines[i];
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        const line2 = string2Lines[i];
+        if (line1.trimEnd() !== line2.trimEnd()) {
+            return false;
+        }
+    }
+    return true;
+}
+/** @see https://typescript-eslint.io/developers/custom-rules#extra-rule-docs-types */
+// eslint-disable-next-line new-cap
+export const createRule = ESLintUtils.RuleCreator((ruleName) => `https://github.com/complete-ts/complete/blob/main/packages/eslint-plugin-complete/docs/rules/${ruleName}.md`);
+/**
+ * From: https://stackoverflow.com/questions/13627308/add-st-nd-rd-and-th-ordinal-suffix-to-a-number
+ */
+export function getOrdinalSuffix(i) {
+    const j = i % 10;
+    const k = i % 100;
+    if (j === 1 && k !== 11) {
+        return `${i}st`;
+    }
+    if (j === 2 && k !== 12) {
+        return `${i}nd`;
+    }
+    if (j === 3 && k !== 13) {
+        return `${i}rd`;
+    }
+    return `${i}th`;
+}
+export function getParentFunction(node) {
+    let parent = node;
+    while (parent !== undefined) {
+        parent = parent.parent; // eslint-disable-line @typescript-eslint/prefer-destructuring
+        if (ASTUtils.isFunction(parent)) {
+            return parent;
+        }
+    }
+    return undefined;
+}
+export function hasURL(text) {
+    return URL_REGEXP.test(text);
+}

package/package.json

@@ -0,0 +1,55 @@
+{
+  "name": "eslint-plugin-complete",
+  "version": "1.0.0",
+  "description": "An ESLint plugin that contains useful rules.",
+  "keywords": [
+    "eslint",
+    "plugin",
+    "complete",
+    "lint",
+    "linting",
+    "rules",
+    "enum",
+    "enums",
+    "comment",
+    "comments",
+    "format",
+    "autoformat",
+    "prettier",
+    "sentences"
+  ],
+  "homepage": "https://complete-js.github.io/",
+  "bugs": {
+    "url": "https://github.com/complete-js/complete/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/complete-js/complete.git"
+  },
+  "license": "MIT",
+  "author": "Zamiell",
+  "type": "module",
+  "main": "./dist/index.js",
+  "files": [
+    "dist",
+    "LICENSE",
+    "package.json",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "tsx ./scripts/build.ts",
+    "create-rule": "tsx ./scripts/createRule.ts",
+    "generate": "tsx ./scripts/generate.ts",
+    "lint": "tsx ./scripts/lint.ts",
+    "test": "jest"
+  },
+  "dependencies": {
+    "@typescript-eslint/type-utils": "^8.4.0",
+    "@typescript-eslint/utils": "^8.4.0",
+    "typescript-eslint": "^8.4.0"
+  },
+  "peerDependencies": {
+    "eslint": ">= 9.0.0",
+    "typescript": ">= 5.0.0"
+  }
+}