@less-unsound/eslint-plugin 0.0.1

package/dist/esm/rules/no-tuple.d.ts

@@ -0,0 +1,3 @@
+export declare const noTupleRule: import("@typescript-eslint/utils/ts-eslint").RuleModule<"forbiddenTuple", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
+    name: string;
+};

package/dist/esm/rules/no-tuple.js

@@ -0,0 +1,24 @@
+import { createRule } from "../utils/create-rule.js";
+const messageIds = Object.freeze({
+    forbiddenTuple: "Tuple types are not allowed."
+});
+export const noTupleRule = createRule({
+    name: "no-tuple",
+    meta: {
+        type: "problem",
+        docs: {
+            description: "Disallow tuple types."
+        },
+        schema: [],
+        messages: messageIds
+    },
+    defaultOptions: [],
+    create: (context) => ({
+        TSTupleType: (node) => {
+            context.report({
+                node,
+                messageId: "forbiddenTuple"
+            });
+        }
+    })
+});

package/dist/esm/rules/no-type-guard.d.ts

@@ -0,0 +1,3 @@
+export declare const noTypeGuardRule: import("@typescript-eslint/utils/ts-eslint").RuleModule<"forbiddenTypeGuard", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
+    name: string;
+};

package/dist/esm/rules/no-type-guard.js

@@ -0,0 +1,24 @@
+import { createRule } from "../utils/create-rule.js";
+const messageIds = Object.freeze({
+    forbiddenTypeGuard: "Type guards are not allowed."
+});
+export const noTypeGuardRule = createRule({
+    name: "no-type-guard",
+    meta: {
+        type: "problem",
+        docs: {
+            description: "Disallow TypeScript type guards."
+        },
+        schema: [],
+        messages: messageIds
+    },
+    defaultOptions: [],
+    create: (context) => ({
+        TSTypePredicate: (node) => {
+            context.report({
+                node,
+                messageId: "forbiddenTypeGuard"
+            });
+        }
+    })
+});

package/dist/esm/rules/no-typeof-operator.d.ts

@@ -0,0 +1,3 @@
+export declare const noTypeofOperatorRule: import("@typescript-eslint/utils/ts-eslint").RuleModule<"forbiddenTypeofOperator", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
+    name: string;
+};

package/dist/esm/rules/no-typeof-operator.js

@@ -0,0 +1,24 @@
+import { createRule } from "../utils/create-rule.js";
+const messageIds = Object.freeze({
+    forbiddenTypeofOperator: "The runtime `typeof` operator is not allowed."
+});
+export const noTypeofOperatorRule = createRule({
+    name: "no-typeof-operator",
+    meta: {
+        type: "problem",
+        docs: {
+            description: "Disallow the runtime `typeof` operator."
+        },
+        schema: [],
+        messages: messageIds
+    },
+    defaultOptions: [],
+    create: (context) => ({
+        "UnaryExpression[operator='typeof']": (node) => {
+            context.report({
+                node,
+                messageId: "forbiddenTypeofOperator"
+            });
+        }
+    })
+});

package/dist/esm/rules/no-typeof-type.d.ts

@@ -0,0 +1,3 @@
+export declare const noTypeofTypeRule: import("@typescript-eslint/utils/ts-eslint").RuleModule<"forbiddenTypeofType", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
+    name: string;
+};

package/dist/esm/rules/no-typeof-type.js

@@ -0,0 +1,24 @@
+import { createRule } from "../utils/create-rule.js";
+const messageIds = Object.freeze({
+    forbiddenTypeofType: "`typeof` in type context is not allowed."
+});
+export const noTypeofTypeRule = createRule({
+    name: "no-typeof-type",
+    meta: {
+        type: "problem",
+        docs: {
+            description: "Disallow `typeof` in type context."
+        },
+        schema: [],
+        messages: messageIds
+    },
+    defaultOptions: [],
+    create: (context) => ({
+        TSTypeQuery: (node) => {
+            context.report({
+                node,
+                messageId: "forbiddenTypeofType"
+            });
+        }
+    })
+});

package/dist/esm/rules/no-undefined-type.d.ts

@@ -0,0 +1,3 @@
+export declare const noUndefinedTypeRule: import("@typescript-eslint/utils/ts-eslint").RuleModule<"forbiddenUndefinedType", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
+    name: string;
+};

package/dist/esm/rules/no-undefined-type.js

@@ -0,0 +1,24 @@
+import { createRule } from "../utils/create-rule.js";
+const messageIds = Object.freeze({
+    forbiddenUndefinedType: "The `undefined` type is not allowed. Use explicit options or tagged unions instead of `T | undefined`."
+});
+export const noUndefinedTypeRule = createRule({
+    name: "no-undefined-type",
+    meta: {
+        type: "problem",
+        docs: {
+            description: "Disallow the `undefined` type keyword in type positions."
+        },
+        schema: [],
+        messages: messageIds
+    },
+    defaultOptions: [],
+    create: (context) => ({
+        TSUndefinedKeyword: (node) => {
+            context.report({
+                node,
+                messageId: "forbiddenUndefinedType"
+            });
+        }
+    })
+});

package/dist/esm/rules/no-unknown.d.ts

@@ -0,0 +1,3 @@
+export declare const noUnknownRule: import("@typescript-eslint/utils/ts-eslint").RuleModule<"forbiddenUnknown", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
+    name: string;
+};

package/dist/esm/rules/no-unknown.js

@@ -0,0 +1,24 @@
+import { createRule } from "../utils/create-rule.js";
+const messageIds = Object.freeze({
+    forbiddenUnknown: "`unknown` is not allowed."
+});
+export const noUnknownRule = createRule({
+    name: "no-unknown",
+    meta: {
+        type: "problem",
+        docs: {
+            description: "Disallow the `unknown` type."
+        },
+        schema: [],
+        messages: messageIds
+    },
+    defaultOptions: [],
+    create: (context) => ({
+        TSUnknownKeyword: (node) => {
+            context.report({
+                node,
+                messageId: "forbiddenUnknown"
+            });
+        }
+    })
+});

package/dist/esm/rules/no-untagged-object-union.d.ts

@@ -0,0 +1,3 @@
+export declare const noUntaggedObjectUnionRule: import("@typescript-eslint/utils/ts-eslint").RuleModule<"forbiddenUntaggedObjectUnion", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
+    name: string;
+};

package/dist/esm/rules/no-untagged-object-union.js

@@ -0,0 +1,147 @@
+import { AST_NODE_TYPES } from "@typescript-eslint/utils";
+import { createRule } from "../utils/create-rule.js";
+const messageIds = Object.freeze({
+    forbiddenUntaggedObjectUnion: "Untagged object unions are not allowed."
+});
+const getPropertyName = (node) => {
+    if (node.type === AST_NODE_TYPES.Identifier) {
+        return `identifier:${node.name}`;
+    }
+    if (node.type !== AST_NODE_TYPES.Literal) {
+        return undefined;
+    }
+    const { value } = node;
+    if (typeof value === "string") {
+        return `string:${value}`;
+    }
+    if (typeof value === "number") {
+        return `number:${value}`;
+    }
+    if (typeof value === "boolean") {
+        return `boolean:${value}`;
+    }
+    if (typeof value === "bigint") {
+        return `bigint:${value.toString()}`;
+    }
+    if (value === null) {
+        return "null";
+    }
+    return undefined;
+};
+const getLiteralValue = (node) => {
+    if (node.literal.type !== AST_NODE_TYPES.Literal) {
+        return undefined;
+    }
+    const { value } = node.literal;
+    if (typeof value === "string") {
+        return `string:${value}`;
+    }
+    if (typeof value === "number") {
+        return `number:${value}`;
+    }
+    if (typeof value === "boolean") {
+        return `boolean:${value}`;
+    }
+    if (typeof value === "bigint") {
+        return `bigint:${value.toString()}`;
+    }
+    if (value === null) {
+        return "null";
+    }
+    return undefined;
+};
+const getTaggedPropertyValue = (node, propertyName) => {
+    for (const member of node.members) {
+        if (member.type !== AST_NODE_TYPES.TSPropertySignature) {
+            continue;
+        }
+        if (member.optional) {
+            continue;
+        }
+        const name = getPropertyName(member.key);
+        if (name !== propertyName) {
+            continue;
+        }
+        if (member.typeAnnotation === undefined) {
+            return undefined;
+        }
+        if (member.typeAnnotation.typeAnnotation.type !== AST_NODE_TYPES.TSLiteralType) {
+            return undefined;
+        }
+        return getLiteralValue(member.typeAnnotation.typeAnnotation);
+    }
+    return undefined;
+};
+const isTaggedObjectUnion = (node) => {
+    if (node.types.length < 2) {
+        return false;
+    }
+    const first = node.types[0];
+    if (first.type !== AST_NODE_TYPES.TSTypeLiteral) {
+        return false;
+    }
+    const candidateNames = new Set();
+    for (const member of first.members) {
+        if (member.type !== AST_NODE_TYPES.TSPropertySignature) {
+            continue;
+        }
+        if (member.optional) {
+            continue;
+        }
+        if (member.typeAnnotation === undefined) {
+            continue;
+        }
+        if (member.typeAnnotation.typeAnnotation.type !== AST_NODE_TYPES.TSLiteralType) {
+            continue;
+        }
+        const name = getPropertyName(member.key);
+        if (name !== undefined) {
+            candidateNames.add(name);
+        }
+    }
+    for (const propertyName of candidateNames) {
+        const values = new Set();
+        let isValid = true;
+        for (const branch of node.types) {
+            if (branch.type !== AST_NODE_TYPES.TSTypeLiteral) {
+                isValid = false;
+                break;
+            }
+            const value = getTaggedPropertyValue(branch, propertyName);
+            if (value === undefined) {
+                isValid = false;
+                break;
+            }
+            values.add(value);
+        }
+        if (isValid && values.size === node.types.length) {
+            return true;
+        }
+    }
+    return false;
+};
+export const noUntaggedObjectUnionRule = createRule({
+    name: "no-untagged-object-union",
+    meta: {
+        type: "problem",
+        docs: {
+            description: "Disallow unions of inline object types unless they share a literal tag field."
+        },
+        schema: [],
+        messages: messageIds
+    },
+    defaultOptions: [],
+    create: (context) => ({
+        TSUnionType: (node) => {
+            if (isTaggedObjectUnion(node)) {
+                return;
+            }
+            if (node.types.every((branch) => branch.type === AST_NODE_TYPES.TSTypeLiteral)) {
+                context.report({
+                    node,
+                    messageId: "forbiddenUntaggedObjectUnion"
+                });
+            }
+        }
+    })
+});

package/dist/esm/rules/no-utility-type.d.ts

@@ -0,0 +1,3 @@
+export declare const noUtilityTypeRule: import("@typescript-eslint/utils/ts-eslint").RuleModule<"forbiddenUtilityType", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
+    name: string;
+};

package/dist/esm/rules/no-utility-type.js

@@ -0,0 +1,54 @@
+import { AST_NODE_TYPES } from "@typescript-eslint/utils";
+import { createRule } from "../utils/create-rule.js";
+const utilityNames = new Set([
+    "Awaited",
+    "Capitalize",
+    "ConstructorParameters",
+    "Exclude",
+    "Extract",
+    "InstanceType",
+    "Lowercase",
+    "NonNullable",
+    "Omit",
+    "OmitThisParameter",
+    "Partial",
+    "Parameters",
+    "Pick",
+    "Readonly",
+    "Record",
+    "Required",
+    "ReturnType",
+    "ThisParameterType",
+    "ThisType",
+    "Uncapitalize",
+    "Uppercase"
+]);
+const messageIds = Object.freeze({
+    forbiddenUtilityType: "Built-in TypeScript utility types are not allowed."
+});
+export const noUtilityTypeRule = createRule({
+    name: "no-utility-type",
+    meta: {
+        type: "problem",
+        docs: {
+            description: "Disallow built-in TypeScript utility types."
+        },
+        schema: [],
+        messages: messageIds
+    },
+    defaultOptions: [],
+    create: (context) => ({
+        TSTypeReference: (node) => {
+            if (node.typeName.type !== AST_NODE_TYPES.Identifier) {
+                return;
+            }
+            if (!utilityNames.has(node.typeName.name)) {
+                return;
+            }
+            context.report({
+                node,
+                messageId: "forbiddenUtilityType"
+            });
+        }
+    })
+});

package/dist/esm/rules/no-var.d.ts

@@ -0,0 +1,3 @@
+export declare const noVarRule: import("@typescript-eslint/utils/ts-eslint").RuleModule<"forbiddenVar", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
+    name: string;
+};

package/dist/esm/rules/no-var.js

@@ -0,0 +1,24 @@
+import { createRule } from "../utils/create-rule.js";
+const messageIds = Object.freeze({
+    forbiddenVar: "`var` is not allowed."
+});
+export const noVarRule = createRule({
+    name: "no-var",
+    meta: {
+        type: "problem",
+        docs: {
+            description: "Disallow `var` declarations unless mutability is required for performance."
+        },
+        schema: [],
+        messages: messageIds
+    },
+    defaultOptions: [],
+    create: (context) => ({
+        "VariableDeclaration[kind='var']": (node) => {
+            context.report({
+                node,
+                messageId: "forbiddenVar"
+            });
+        }
+    })
+});

package/dist/esm/rules/no-void-operator.d.ts

@@ -0,0 +1,3 @@
+export declare const noVoidOperatorRule: import("@typescript-eslint/utils/ts-eslint").RuleModule<"forbiddenVoidOperator", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
+    name: string;
+};

package/dist/esm/rules/no-void-operator.js

@@ -0,0 +1,24 @@
+import { createRule } from "../utils/create-rule.js";
+const messageIds = Object.freeze({
+    forbiddenVoidOperator: "The `void` operator is not allowed."
+});
+export const noVoidOperatorRule = createRule({
+    name: "no-void-operator",
+    meta: {
+        type: "problem",
+        docs: {
+            description: "Disallow the runtime `void` operator."
+        },
+        schema: [],
+        messages: messageIds
+    },
+    defaultOptions: [],
+    create: (context) => ({
+        "UnaryExpression[operator='void']": (node) => {
+            context.report({
+                node,
+                messageId: "forbiddenVoidOperator"
+            });
+        }
+    })
+});

package/dist/esm/rules/no-while.d.ts

@@ -0,0 +1,3 @@
+export declare const noWhileRule: import("@typescript-eslint/utils/ts-eslint").RuleModule<"forbiddenWhile", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
+    name: string;
+};

package/dist/esm/rules/no-while.js

@@ -0,0 +1,30 @@
+import { createRule } from "../utils/create-rule.js";
+const messageIds = Object.freeze({
+    forbiddenWhile: "`while` and `do ... while` loops are not allowed."
+});
+export const noWhileRule = createRule({
+    name: "no-while",
+    meta: {
+        type: "problem",
+        docs: {
+            description: "Disallow `while` loops and `do ... while` loops."
+        },
+        schema: [],
+        messages: messageIds
+    },
+    defaultOptions: [],
+    create: (context) => ({
+        DoWhileStatement: (node) => {
+            context.report({
+                node,
+                messageId: "forbiddenWhile"
+            });
+        },
+        WhileStatement: (node) => {
+            context.report({
+                node,
+                messageId: "forbiddenWhile"
+            });
+        }
+    })
+});

package/dist/esm/rules/require-boolean-prefix.d.ts

@@ -0,0 +1,4 @@
+import { type TSESLint } from "@typescript-eslint/utils";
+export declare const requireBooleanPrefixRule: TSESLint.RuleModule<"missingBooleanPrefix", [], unknown, TSESLint.RuleListener> & {
+    name: string;
+};

package/dist/esm/rules/require-boolean-prefix.js

@@ -0,0 +1,176 @@
+import { AST_NODE_TYPES } from "@typescript-eslint/utils";
+import { createRule } from "../utils/create-rule.js";
+const allowedPrefixes = Object.freeze([
+    "is",
+    "are",
+    "was",
+    "were",
+    "has",
+    "have",
+    "can",
+    "may",
+    "should",
+    "must",
+    "will",
+    "would",
+    "did",
+    "does",
+    "do",
+    "needs",
+    "need",
+    "requires",
+    "supports",
+    "allows",
+    "contains",
+    "includes",
+    "matches",
+    "exists"
+]);
+const comparisonOperators = new Set([
+    "!=",
+    "!==",
+    "<",
+    "<=",
+    "==",
+    "===",
+    ">",
+    ">=",
+    "in",
+    "instanceof"
+]);
+const messageIds = Object.freeze({
+    missingBooleanPrefix: "Boolean variable and field names must start with an allowed boolean prefix. `{{name}}` should start with one of: {{prefixes}}."
+});
+const isUppercaseLetter = (value) => value.toUpperCase() === value && value.toLowerCase() !== value;
+const hasAllowedPrefix = (name) => allowedPrefixes.some((prefix) => {
+    if (!name.startsWith(prefix)) {
+        return false;
+    }
+    if (name.length === prefix.length) {
+        return true;
+    }
+    const next = name[prefix.length];
+    return next !== undefined && isUppercaseLetter(next);
+});
+const getName = (node) => {
+    if (node.type === AST_NODE_TYPES.Identifier) {
+        return node.name;
+    }
+    if (node.type === AST_NODE_TYPES.PrivateIdentifier) {
+        return node.name;
+    }
+    if (node.type === AST_NODE_TYPES.Literal &&
+        typeof node.value === "string") {
+        return node.value;
+    }
+    return undefined;
+};
+const isBooleanLiteralType = (node) => node.type === AST_NODE_TYPES.TSLiteralType &&
+    node.literal.type === AST_NODE_TYPES.Literal &&
+    typeof node.literal.value === "boolean";
+const isBooleanType = (node) => {
+    if (node.type === AST_NODE_TYPES.TSBooleanKeyword) {
+        return true;
+    }
+    if (isBooleanLiteralType(node)) {
+        return true;
+    }
+    if (node.type === AST_NODE_TYPES.TSUnionType) {
+        return node.types.length > 0 && node.types.every(isBooleanType);
+    }
+    return false;
+};
+const isBooleanAnnotation = (annotation) => annotation !== undefined && isBooleanType(annotation.typeAnnotation);
+const isBooleanExpression = (node) => {
+    if (node.type === AST_NODE_TYPES.Literal &&
+        typeof node.value === "boolean") {
+        return true;
+    }
+    if (node.type === AST_NODE_TYPES.UnaryExpression) {
+        return node.operator === "!";
+    }
+    if (node.type === AST_NODE_TYPES.BinaryExpression) {
+        return comparisonOperators.has(node.operator);
+    }
+    return false;
+};
+const reportIfNeeded = (context, node, name) => {
+    if (hasAllowedPrefix(name)) {
+        return;
+    }
+    context.report({
+        node,
+        messageId: "missingBooleanPrefix",
+        data: {
+            name,
+            prefixes: allowedPrefixes.join(", ")
+        }
+    });
+};
+export const requireBooleanPrefixRule = createRule({
+    name: "require-boolean-prefix",
+    meta: {
+        type: "problem",
+        docs: {
+            description: "Require boolean variables and fields to start with an allowed boolean prefix."
+        },
+        schema: [],
+        messages: messageIds
+    },
+    defaultOptions: [],
+    create: (context) => ({
+        VariableDeclarator: (node) => {
+            if (node.id.type !== AST_NODE_TYPES.Identifier) {
+                return;
+            }
+            const isBoolean = isBooleanAnnotation(node.id.typeAnnotation) ||
+                (node.init !== null &&
+                    node.init !== undefined &&
+                    isBooleanExpression(node.init));
+            if (!isBoolean) {
+                return;
+            }
+            reportIfNeeded(context, node.id, node.id.name);
+        },
+        Property: (node) => {
+            if (node.computed || node.kind !== "init" || node.method) {
+                return;
+            }
+            const name = getName(node.key);
+            if (name === undefined) {
+                return;
+            }
+            if (!isBooleanExpression(node.value)) {
+                return;
+            }
+            reportIfNeeded(context, node.key, name);
+        },
+        PropertyDefinition: (node) => {
+            if (node.computed) {
+                return;
+            }
+            const name = getName(node.key);
+            if (name === undefined) {
+                return;
+            }
+            const isBoolean = isBooleanAnnotation(node.typeAnnotation) ||
+                (node.value !== null &&
+                    node.value !== undefined &&
+                    isBooleanExpression(node.value));
+            if (!isBoolean) {
+                return;
+            }
+            reportIfNeeded(context, node.key, name);
+        },
+        TSPropertySignature: (node) => {
+            if (node.computed || !isBooleanAnnotation(node.typeAnnotation)) {
+                return;
+            }
+            const name = getName(node.key);
+            if (name === undefined) {
+                return;
+            }
+            reportIfNeeded(context, node.key, name);
+        }
+    })
+});

package/dist/esm/rules/require-disjoint-union.d.ts

@@ -0,0 +1,5 @@
+export declare const requireDisjointUnionRule: import("@typescript-eslint/utils/ts-eslint").RuleModule<"forbiddenDisjointUnion", [{
+    tagName: string;
+}], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
+    name: string;
+};