@less-unsound/eslint-plugin 0.0.1

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

@@ -0,0 +1,24 @@
+import { createRule } from "../utils/create-rule.js";
+const messageIds = Object.freeze({
+    forbiddenImportType: "`import()` types are not allowed. Put type imports in the file header instead."
+});
+export const noImportTypeRule = createRule({
+    name: "no-import-type",
+    meta: {
+        type: "problem",
+        docs: {
+            description: "Disallow `import()` types."
+        },
+        schema: [],
+        messages: messageIds
+    },
+    defaultOptions: [],
+    create: (context) => ({
+        TSImportType: (node) => {
+            context.report({
+                node,
+                messageId: "forbiddenImportType"
+            });
+        }
+    })
+});

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

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

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

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

package/dist/esm/rules/no-indexed-access-type.d.ts

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

package/dist/esm/rules/no-indexed-access-type.js

@@ -0,0 +1,24 @@
+import { createRule } from "../utils/create-rule.js";
+const messageIds = Object.freeze({
+    forbiddenIndexedAccessType: "Indexed access types are not allowed."
+});
+export const noIndexedAccessTypeRule = createRule({
+    name: "no-indexed-access-type",
+    meta: {
+        type: "problem",
+        docs: {
+            description: "Disallow indexed access types such as Foo[\"bar\"]."
+        },
+        schema: [],
+        messages: messageIds
+    },
+    defaultOptions: [],
+    create: (context) => ({
+        TSIndexedAccessType: (node) => {
+            context.report({
+                node,
+                messageId: "forbiddenIndexedAccessType"
+            });
+        }
+    })
+});

package/dist/esm/rules/no-indexed-object-type.d.ts

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

package/dist/esm/rules/no-indexed-object-type.js

@@ -0,0 +1,50 @@
+import { AST_NODE_TYPES } from "@typescript-eslint/utils";
+import { createRule } from "../utils/create-rule.js";
+import { containsTypeReference } from "../utils/type-reference.js";
+const messageIds = Object.freeze({
+    forbiddenIndexedObjectType: "Indexed object types are not allowed."
+});
+const getContainingTypeName = (node) => {
+    let current = node.parent;
+    while (current !== undefined) {
+        if (current.type === AST_NODE_TYPES.TSTypeAliasDeclaration ||
+            current.type === AST_NODE_TYPES.TSInterfaceDeclaration) {
+            return current.id.name;
+        }
+        current = current.parent;
+    }
+    return undefined;
+};
+const isAllowedRecursiveIndexSignature = (node) => {
+    if (node.typeAnnotation === undefined) {
+        return false;
+    }
+    const typeName = getContainingTypeName(node);
+    if (typeName === undefined) {
+        return false;
+    }
+    return containsTypeReference(node.typeAnnotation.typeAnnotation, typeName);
+};
+export const noIndexedObjectTypeRule = createRule({
+    name: "no-indexed-object-type",
+    meta: {
+        type: "problem",
+        docs: {
+            description: "Disallow indexed object types such as `{ [key: string]: T }`, except for explicit self-recursive cases."
+        },
+        schema: [],
+        messages: messageIds
+    },
+    defaultOptions: [],
+    create: (context) => ({
+        TSIndexSignature: (node) => {
+            if (isAllowedRecursiveIndexSignature(node)) {
+                return;
+            }
+            context.report({
+                node,
+                messageId: "forbiddenIndexedObjectType"
+            });
+        }
+    })
+});

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

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

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

@@ -0,0 +1,62 @@
+import { createRule } from "../utils/create-rule.js";
+import { containsTypeReference } from "../utils/type-reference.js";
+const messageIds = Object.freeze({
+    forbiddenInheritance: "Inheritance is not allowed."
+});
+const isAllowedRecursiveInterface = (node) => {
+    if (node.extends.length !== 1) {
+        return false;
+    }
+    if (node.body.body.length !== 0) {
+        return false;
+    }
+    const heritage = node.extends[0];
+    if (heritage.typeArguments === undefined) {
+        return false;
+    }
+    return heritage.typeArguments.params.some((parameter) => containsTypeReference(parameter, node.id.name));
+};
+export const noInheritanceRule = createRule({
+    name: "no-inheritance",
+    meta: {
+        type: "problem",
+        docs: {
+            description: "Disallow `extends` on classes and interfaces, except for the documented recursive-interface workaround."
+        },
+        schema: [],
+        messages: messageIds
+    },
+    defaultOptions: [],
+    create: (context) => ({
+        ClassDeclaration: (node) => {
+            if (node.superClass === null) {
+                return;
+            }
+            context.report({
+                node,
+                messageId: "forbiddenInheritance"
+            });
+        },
+        ClassExpression: (node) => {
+            if (node.superClass === null) {
+                return;
+            }
+            context.report({
+                node,
+                messageId: "forbiddenInheritance"
+            });
+        },
+        TSInterfaceDeclaration: (node) => {
+            if (node.extends.length === 0) {
+                return;
+            }
+            if (isAllowedRecursiveInterface(node)) {
+                return;
+            }
+            context.report({
+                node,
+                messageId: "forbiddenInheritance"
+            });
+        }
+    })
+});

package/dist/esm/rules/no-inline-tagged-object.d.ts

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

package/dist/esm/rules/no-inline-tagged-object.js

@@ -0,0 +1,92 @@
+import { AST_NODE_TYPES } from "@typescript-eslint/utils";
+import { createRule } from "../utils/create-rule.js";
+const defaultTagName = "$";
+const messageIds = Object.freeze({
+    useConstructor: "Do not create tagged objects by supplying `{{tagName}}` directly. Use `{{constructorName}}()` instead.",
+    useConstructorGeneric: "Do not create tagged objects by supplying `{{tagName}}` directly. Use a constructor instead."
+});
+const getPropertyName = (node) => {
+    if (node.type === AST_NODE_TYPES.Identifier) {
+        return node.name;
+    }
+    if (node.type !== AST_NODE_TYPES.Literal) {
+        return undefined;
+    }
+    return typeof node.value === "string" ? node.value : undefined;
+};
+const buildConstructorName = (tagValue) => {
+    const parts = tagValue.match(/[A-Za-z0-9]+/g);
+    if (parts === null || parts.length === 0) {
+        return undefined;
+    }
+    const name = parts
+        .map((part) => part[0] === undefined
+        ? ""
+        : part[0].toUpperCase() + part.slice(1))
+        .join("");
+    return /^[A-Z][A-Za-z0-9]*$/u.test(name) ? name : undefined;
+};
+const getTaggedProperty = (node, tagName) => node.properties.find((property) => property.type === AST_NODE_TYPES.Property &&
+    property.kind === "init" &&
+    property.computed === false &&
+    getPropertyName(property.key) === tagName);
+export const noInlineTaggedObjectRule = createRule({
+    name: "no-inline-tagged-object",
+    meta: {
+        type: "problem",
+        docs: {
+            description: "Ban creating tagged objects by supplying the configured tag field directly."
+        },
+        schema: [
+            {
+                type: "object",
+                properties: {
+                    tagName: {
+                        type: "string"
+                    }
+                },
+                additionalProperties: false
+            }
+        ],
+        messages: messageIds
+    },
+    defaultOptions: [{ tagName: defaultTagName }],
+    create: (context, [{ tagName }]) => ({
+        ObjectExpression: (node) => {
+            const property = getTaggedProperty(node, tagName);
+            if (property === undefined) {
+                return;
+            }
+            if (property.value.type !== AST_NODE_TYPES.Literal ||
+                typeof property.value.value !== "string") {
+                context.report({
+                    node: property,
+                    messageId: "useConstructorGeneric",
+                    data: {
+                        tagName
+                    }
+                });
+                return;
+            }
+            const constructorName = buildConstructorName(property.value.value);
+            if (constructorName === undefined) {
+                context.report({
+                    node: property,
+                    messageId: "useConstructorGeneric",
+                    data: {
+                        tagName
+                    }
+                });
+                return;
+            }
+            context.report({
+                node: property,
+                messageId: "useConstructor",
+                data: {
+                    constructorName,
+                    tagName
+                }
+            });
+        }
+    })
+});

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

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

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

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

package/dist/esm/rules/no-json-static-method.d.ts

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

package/dist/esm/rules/no-json-static-method.js

@@ -0,0 +1,155 @@
+import { AST_NODE_TYPES } from "@typescript-eslint/utils";
+import { createRule } from "../utils/create-rule.js";
+const messageIds = Object.freeze({
+    forbiddenJsonStaticMethod: "`JSON.parse` and `JSON.stringify` are not allowed."
+});
+const isBindingIdentifier = (node) => {
+    const parent = node.parent;
+    if (parent === null) {
+        return false;
+    }
+    if (parent.type === AST_NODE_TYPES.VariableDeclarator) {
+        return parent.id === node;
+    }
+    if (parent.type === AST_NODE_TYPES.FunctionDeclaration ||
+        parent.type === AST_NODE_TYPES.FunctionExpression) {
+        return parent.id === node;
+    }
+    if (parent.type === AST_NODE_TYPES.ClassDeclaration ||
+        parent.type === AST_NODE_TYPES.ClassExpression ||
+        parent.type === AST_NODE_TYPES.TSTypeAliasDeclaration ||
+        parent.type === AST_NODE_TYPES.TSInterfaceDeclaration ||
+        parent.type === AST_NODE_TYPES.TSEnumDeclaration) {
+        return parent.id === node;
+    }
+    if (parent.type === AST_NODE_TYPES.TSEnumMember) {
+        return parent.id === node;
+    }
+    if (parent.type === AST_NODE_TYPES.ImportSpecifier ||
+        parent.type === AST_NODE_TYPES.ImportDefaultSpecifier ||
+        parent.type === AST_NODE_TYPES.ImportNamespaceSpecifier) {
+        return parent.local === node;
+    }
+    if (parent.type === AST_NODE_TYPES.ExportSpecifier) {
+        return parent.local === node || parent.exported === node;
+    }
+    if (parent.type === AST_NODE_TYPES.CatchClause) {
+        return parent.param === node;
+    }
+    if (parent.type === AST_NODE_TYPES.TSParameterProperty) {
+        return parent.parameter === node;
+    }
+    if (parent.type === AST_NODE_TYPES.MemberExpression) {
+        return parent.property === node && parent.computed === false;
+    }
+    if (parent.type === AST_NODE_TYPES.Property) {
+        if (parent.parent?.type === AST_NODE_TYPES.ObjectPattern) {
+            return parent.key === node && parent.computed === false;
+        }
+        if (parent.parent?.type === AST_NODE_TYPES.ObjectExpression) {
+            return parent.key === node && parent.computed === false && parent.shorthand === false;
+        }
+        return false;
+    }
+    if (parent.type === AST_NODE_TYPES.MethodDefinition) {
+        return parent.key === node && parent.computed === false;
+    }
+    if (parent.type === AST_NODE_TYPES.PropertyDefinition) {
+        return parent.key === node && parent.computed === false;
+    }
+    if (parent.type === AST_NODE_TYPES.TSPropertySignature ||
+        parent.type === AST_NODE_TYPES.TSMethodSignature) {
+        return parent.key === node;
+    }
+    if (parent.type === AST_NODE_TYPES.LabeledStatement) {
+        return parent.label === node;
+    }
+    if (parent.type === AST_NODE_TYPES.TSQualifiedName) {
+        return parent.left === node;
+    }
+    if (parent.type === AST_NODE_TYPES.TSImportEqualsDeclaration) {
+        return parent.id === node;
+    }
+    return false;
+};
+const hasDeclaredBinding = (scope, name) => {
+    const variable = scope.variables.find((value) => value.name === name);
+    if (variable !== undefined && (variable.defs.length > 0 || variable.identifiers.length > 0)) {
+        return true;
+    }
+    if (scope.upper === null) {
+        return false;
+    }
+    return hasDeclaredBinding(scope.upper, name);
+};
+const isGlobalReference = (context, node) => {
+    if (isBindingIdentifier(node)) {
+        return false;
+    }
+    const scope = context.sourceCode.getScope(node);
+    return hasDeclaredBinding(scope, node.name) === false;
+};
+const getPropertyName = (node) => {
+    if (node.type === AST_NODE_TYPES.Identifier) {
+        return node.name;
+    }
+    if (node.type === AST_NODE_TYPES.Literal && typeof node.value === "string") {
+        return node.value;
+    }
+    return undefined;
+};
+const isStaticJsonNamespace = (context, node) => {
+    if (node.type === AST_NODE_TYPES.ChainExpression) {
+        return isStaticJsonNamespace(context, node.expression);
+    }
+    if (node.type === AST_NODE_TYPES.Identifier) {
+        if (node.name !== "JSON") {
+            return false;
+        }
+        return isGlobalReference(context, node);
+    }
+    if (node.type !== AST_NODE_TYPES.MemberExpression) {
+        return false;
+    }
+    const propertyName = getPropertyName(node.property);
+    if (propertyName !== "JSON") {
+        return false;
+    }
+    if (node.object.type !== AST_NODE_TYPES.Identifier) {
+        return false;
+    }
+    if (!isGlobalReference(context, node.object)) {
+        return false;
+    }
+    return node.object.name === "globalThis" || node.object.name === "window";
+};
+const isForbiddenMethod = (node) => {
+    const propertyName = getPropertyName(node.property);
+    return propertyName === "parse" || propertyName === "stringify";
+};
+export const noJsonStaticMethodRule = createRule({
+    name: "no-json-static-method",
+    meta: {
+        type: "problem",
+        docs: {
+            description: "Disallow `JSON.parse` and `JSON.stringify`, including access through `globalThis.JSON` and `window.JSON`."
+        },
+        schema: [],
+        messages: messageIds
+    },
+    defaultOptions: [],
+    create: (context) => ({
+        MemberExpression: (node) => {
+            if (!isForbiddenMethod(node)) {
+                return;
+            }
+            if (!isStaticJsonNamespace(context, node.object)) {
+                return;
+            }
+            context.report({
+                node,
+                messageId: "forbiddenJsonStaticMethod"
+            });
+        }
+    })
+});

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

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

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

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

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

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

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

@@ -0,0 +1,42 @@
+import { createRule } from "../utils/create-rule.js";
+const messageIds = Object.freeze({
+    forbiddenLet: "`let` is not allowed."
+});
+const isForLoopDeclaration = (parent) => {
+    if (parent === undefined) {
+        return false;
+    }
+    if (parent.type === "ForStatement") {
+        return parent.init !== null && parent.init.type === "VariableDeclaration";
+    }
+    if (parent.type === "ForInStatement" || parent.type === "ForOfStatement") {
+        return parent.left.type === "VariableDeclaration";
+    }
+    return false;
+};
+export const noLetRule = createRule({
+    name: "no-let",
+    meta: {
+        type: "problem",
+        docs: {
+            description: "Disallow `let` declarations unless mutability is required for performance."
+        },
+        schema: [],
+        messages: messageIds
+    },
+    defaultOptions: [],
+    create: (context) => ({
+        VariableDeclaration: (node) => {
+            if (node.kind !== "let") {
+                return;
+            }
+            if (isForLoopDeclaration(node.parent)) {
+                return;
+            }
+            context.report({
+                node,
+                messageId: "forbiddenLet"
+            });
+        }
+    })
+});

package/dist/esm/rules/no-mapped-object-type.d.ts

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

package/dist/esm/rules/no-mapped-object-type.js

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

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

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

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

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

package/dist/esm/rules/no-non-null-assertion.d.ts

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

package/dist/esm/rules/no-non-null-assertion.js

@@ -0,0 +1,24 @@
+import { createRule } from "../utils/create-rule.js";
+const messageIds = Object.freeze({
+    forbiddenNonNullAssertion: "Non-null assertions are not allowed."
+});
+export const noNonNullAssertionRule = createRule({
+    name: "no-non-null-assertion",
+    meta: {
+        type: "problem",
+        docs: {
+            description: "Disallow non-null assertions."
+        },
+        schema: [],
+        messages: messageIds
+    },
+    defaultOptions: [],
+    create: (context) => ({
+        TSNonNullExpression: (node) => {
+            context.report({
+                node,
+                messageId: "forbiddenNonNullAssertion"
+            });
+        }
+    })
+});

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

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