eslint-cdk-plugin 3.4.3 → 3.4.5

package/dist/index.d.ts

@@ -1,47 +0,0 @@
-import { FlatConfig } from "@typescript-eslint/utils/ts-eslint";
-declare const rules: {
-    "construct-constructor-property": import("@typescript-eslint/utils/ts-eslint").RuleModule<"invalidConstructorProperty" | "invalidConstructorType" | "invalidConstructorIdType", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
-    "no-construct-in-interface": import("@typescript-eslint/utils/ts-eslint").RuleModule<"invalidInterfaceProperty", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
-    "no-construct-in-public-property-of-construct": import("@typescript-eslint/utils/ts-eslint").RuleModule<"invalidPublicPropertyOfConstruct", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
-    "no-construct-stack-suffix": import("@typescript-eslint/utils/ts-eslint").RuleModule<"invalidConstructId", [{
-        disallowedSuffixes?: ("Construct" | "Stack")[];
-    }], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
-    "no-import-private": import("eslint").Rule.RuleModule;
-    "no-mutable-property-of-props-interface": import("@typescript-eslint/utils/ts-eslint").RuleModule<"invalidPropertyOfPropsInterface", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
-    "no-mutable-public-property-of-construct": import("@typescript-eslint/utils/ts-eslint").RuleModule<"invalidPublicPropertyOfConstruct", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
-    "no-parent-name-construct-id-match": import("@typescript-eslint/utils/ts-eslint").RuleModule<"invalidConstructId", {
-        disallowContainingParentName?: boolean;
-    }[], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
-    "no-unused-props": import("@typescript-eslint/utils/ts-eslint").RuleModule<"unusedProp", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
-    "no-variable-construct-id": import("@typescript-eslint/utils/ts-eslint").RuleModule<"invalidConstructId", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
-    "pascal-case-construct-id": import("@typescript-eslint/utils/ts-eslint").RuleModule<"invalidConstructId", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
-    "props-name-convention": import("@typescript-eslint/utils/ts-eslint").RuleModule<"invalidPropsName", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
-    "require-jsdoc": import("@typescript-eslint/utils/ts-eslint").RuleModule<"missingJSDoc", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
-    "require-passing-this": import("@typescript-eslint/utils/ts-eslint").RuleModule<"missingPassingThis", {
-        allowNonThisAndDisallowScope?: boolean;
-    }[], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
-    "require-props-default-doc": import("@typescript-eslint/utils/ts-eslint").RuleModule<"missingDefaultDoc", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
-};
-declare const configs: {
-    recommended: {
-        languageOptions: FlatConfig.LanguageOptions;
-        plugins: FlatConfig.Plugins;
-        rules: FlatConfig.Rules;
-    };
-    strict: {
-        languageOptions: FlatConfig.LanguageOptions;
-        plugins: FlatConfig.Plugins;
-        rules: FlatConfig.Rules;
-    };
-};
-export { configs, rules };
-export interface EslintCdkPlugin {
-    rules: typeof rules;
-    configs: Readonly<{
-        recommended: FlatConfig.Config;
-        strict: FlatConfig.Config;
-    }>;
-}
-declare const eslintCdkPlugin: EslintCdkPlugin;
-export default eslintCdkPlugin;
-//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,UAAU,EAAE,MAAM,oCAAoC,CAAC;AAoBhE,QAAA,MAAM,KAAK;;;;;;;;;;;;;;;;;;;;;;CAiBV,CAAC;AAmEF,QAAA,MAAM,OAAO;;yBAzDM,UAAU,CAAC,eAAe;iBAClC,UAAU,CAAC,OAAO;eACpB,UAAU,CAAC,KAAK;;;yBAFN,UAAU,CAAC,eAAe;iBAClC,UAAU,CAAC,OAAO;eACpB,UAAU,CAAC,KAAK;;CA0DxB,CAAC;AAEF,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,CAAC;AAE1B,MAAM,WAAW,eAAe;IAC9B,KAAK,EAAE,OAAO,KAAK,CAAC;IACpB,OAAO,EAAE,QAAQ,CAAC;QAChB,WAAW,EAAE,UAAU,CAAC,MAAM,CAAC;QAC/B,MAAM,EAAE,UAAU,CAAC,MAAM,CAAC;KAC3B,CAAC,CAAC;CACJ;AAED,QAAA,MAAM,eAAe,EAAE,eAGtB,CAAC;AAEF,eAAe,eAAe,CAAC"}

package/src/constants/tsInternalFlags.ts

@@ -1,18 +0,0 @@
-/**
- * Implementing `SymbolFlags` defined in typescript on your own, in order not to include TypeScript in dependencies
- */
-export const SYMBOL_FLAGS = {
-  CLASS: 32,
-  Interface: 64,
-} as const;
-
-/**
- * Implementing `SyntaxKind` defined in typescript on your own, in order not to include TypeScript in dependencies
- */
-export const SYNTAX_KIND = {
-  CLASS_DECLARATION: 263,
-  CONSTRUCTOR: 176,
-  IMPLEMENTS_KEYWORD: 119,
-  IDENTIFIER: 80,
-  PROPERTY_ACCESS_EXPRESSION: 211,
-} as const;

package/src/rules/no-unused-props.ts

@@ -1,176 +0,0 @@
-import {
-  AST_NODE_TYPES,
-  ESLintUtils,
-  ParserServicesWithTypeInformation,
-  TSESLint,
-  TSESTree,
-} from "@typescript-eslint/utils";
-
-import { createRule } from "../utils/createRule";
-import { getConstructor } from "../utils/getConstructor";
-import {
-  IPropsUsageTracker,
-  propsUsageTrackerFactory,
-} from "../utils/propsUsageTracker";
-import { isConstructType } from "../utils/typecheck/cdk";
-
-type Context = TSESLint.RuleContext<"unusedProp", []>;
-
-/**
- * Enforces that all properties defined in props type are used within the constructor
- * @param context - The rule context provided by ESLint
- * @returns An object containing the AST visitor functions
- */
-export const noUnusedProps = createRule({
-  name: "no-unused-props",
-  meta: {
-    type: "suggestion",
-    docs: {
-      description:
-        "Enforces that all properties defined in props type are used within the constructor",
-    },
-    messages: {
-      unusedProp: "Property '{{propName}}' is defined in props but never used",
-    },
-    schema: [],
-  },
-  defaultOptions: [],
-  create(context) {
-    const parserServices = ESLintUtils.getParserServices(context);
-
-    return {
-      ClassDeclaration(node) {
-        const type = parserServices.getTypeAtLocation(node);
-        if (!isConstructType(type)) return;
-
-        const constructor = getConstructor(node);
-        if (!constructor) return;
-
-        analyzePropsUsage(constructor, context, parserServices);
-      },
-    };
-  },
-});
-
-/**
- * Analyzes props usage in the constructor
- */
-const analyzePropsUsage = (
-  constructor: TSESTree.MethodDefinition,
-  context: Context,
-  parserServices: ParserServicesWithTypeInformation
-): void => {
-  const params = constructor.value.params;
-
-  // NOTE: Check if constructor has props parameter (3rd parameter)
-  if (params.length < 3) return;
-
-  const propsParam = params[2];
-
-  switch (propsParam.type) {
-    case AST_NODE_TYPES.Identifier: {
-      // NOTE: Standard props parameter (e.g. props: MyConstructProps)
-      const propsType = parserServices.getTypeAtLocation(propsParam);
-      const tracker = propsUsageTrackerFactory(propsType);
-      if (!tracker || !constructor.value.body) return;
-
-      analyzeConstructorBody(constructor.value.body, propsParam.name, tracker);
-      reportUnusedProperties(tracker, propsParam, context);
-      return;
-    }
-    case AST_NODE_TYPES.ObjectPattern: {
-      // NOTE: Inline destructuring (e.g. { bucketName, enableVersioning }: MyConstructProps)
-      const typeAnnotation = propsParam.typeAnnotation?.typeAnnotation;
-      if (!typeAnnotation) return;
-
-      const propsType = parserServices.getTypeAtLocation(typeAnnotation);
-      const tracker = propsUsageTrackerFactory(propsType);
-      if (!tracker) return;
-
-      tracker.markAsUsedForObjectPattern(propsParam);
-      reportUnusedProperties(tracker, propsParam, context);
-      return;
-    }
-    default:
-      return;
-  }
-};
-
-/**
- * Analyzes constructor body for props usage patterns
- */
-const analyzeConstructorBody = (
-  body: TSESTree.BlockStatement,
-  propsParamName: string,
-  tracker: IPropsUsageTracker
-): void => {
-  const visited = new Set<TSESTree.Node>();
-
-  const visitNode = (node: TSESTree.Node): void => {
-    if (visited.has(node)) return;
-    visited.add(node);
-
-    switch (node.type) {
-      case AST_NODE_TYPES.MemberExpression:
-        tracker.markAsUsedForMemberExpression(node, propsParamName);
-        break;
-      case AST_NODE_TYPES.VariableDeclarator:
-        tracker.markAsUsedForVariableDeclarator(node, propsParamName);
-        break;
-      case AST_NODE_TYPES.AssignmentExpression:
-        tracker.markAsUsedForAssignmentExpression(node, propsParamName);
-        break;
-    }
-
-    // NOTE: Recursively visit child nodes
-    const children = getChildNodes(node);
-    for (const child of children) {
-      visitNode(child);
-    }
-  };
-
-  visitNode(body);
-};
-
-/**
- * Reports unused properties to ESLint
- */
-const reportUnusedProperties = (
-  tracker: IPropsUsageTracker,
-  propsParam: TSESTree.Parameter,
-  context: Context
-): void => {
-  for (const propName of tracker.getUnusedProperties()) {
-    context.report({
-      node: propsParam,
-      messageId: "unusedProp",
-      data: {
-        propName,
-      },
-    });
-  }
-};
-
-/**
- * Safely gets child nodes from a TSESTree.Node
- */
-const getChildNodes = (node: TSESTree.Node): TSESTree.Node[] => {
-  return Object.entries(node).reduce<TSESTree.Node[]>((acc, [key, value]) => {
-    if (["parent", "range", "loc"].includes(key)) return acc; // Keys to skip to avoid circular references and unnecessary properties
-    if (isESTreeNode(value)) return [...acc, value];
-    if (Array.isArray(value)) return [...acc, ...value.filter(isESTreeNode)];
-    return acc;
-  }, []);
-};
-
-/**
- * Type guard to check if a value is a TSESTree.Node
- */
-const isESTreeNode = (value: unknown): value is TSESTree.Node => {
-  return (
-    value !== null &&
-    typeof value === "object" &&
-    "type" in value &&
-    typeof (value as { type: unknown }).type === "string"
-  );
-};

package/src/utils/getArrayElementType.ts

@@ -1,14 +0,0 @@
-import { Type } from "typescript";
-
-import { isArrayType } from "./typecheck/ts-type";
-
-export const getArrayElementType = (type: Type): Type | undefined => {
-  if (!isArrayType(type)) return undefined;
-
-  // Get type arguments for Array<T>
-  if ("typeArguments" in type && Array.isArray(type.typeArguments)) {
-    return (type.typeArguments as Type[])[0];
-  }
-
-  return undefined;
-};

package/src/utils/getPropertyNames.ts

@@ -1,45 +0,0 @@
-import { AST_NODE_TYPES, TSESTree } from "@typescript-eslint/utils";
-import { Type } from "typescript";
-
-import {
-  isClassDeclaration,
-  isConstructorDeclaration,
-} from "./typecheck/ts-node";
-
-/**
- * Retrieves the property names from an array of properties.
- *
- * @param properties An array of properties to extract names from.
- * @returns An array of property names.
- */
-export const getPropertyNames = (
-  properties: (TSESTree.Property | TSESTree.RestElement)[]
-): string[] => {
-  return properties.reduce<string[]>(
-    (acc, prop) =>
-      prop.type === AST_NODE_TYPES.Property &&
-      prop.key.type === AST_NODE_TYPES.Identifier
-        ? [...acc, prop.key.name]
-        : acc,
-    []
-  );
-};
-
-/**
- * Parses type to get the property names of the class constructor.
- * @returns The property names of the class constructor.
- */
-export const getConstructorPropertyNames = (type: Type): string[] => {
-  const declarations = type.symbol?.declarations;
-  if (!declarations?.length) return [];
-
-  const classDeclaration = declarations[0];
-  if (!isClassDeclaration(classDeclaration)) return [];
-
-  const constructor = classDeclaration.members.find((member) =>
-    isConstructorDeclaration(member)
-  );
-  if (!constructor?.parameters.length) return [];
-
-  return constructor.parameters.map((param) => param.name.getText());
-};

package/src/utils/typecheck/cdk.ts

@@ -1,71 +0,0 @@
-import { Type } from "typescript";
-
-type SuperClassType = "Construct" | "Stack" | "Resource";
-
-/**
- * Check if the type extends Construct or Stack
- * @param type - The type to check
- * @param ignoredClasses - Classes that inherit from Construct Class or Stack Class but do not want to be treated as Construct Class or Stack Class
- * @returns True if the type extends Construct or Stack, otherwise false
- */
-export const isConstructOrStackType = (
-  type: Type,
-  ignoredClasses: readonly string[] = ["App", "Stage", "CfnOutput"] as const
-): boolean => {
-  if (ignoredClasses.includes(type.symbol?.name ?? "")) return false;
-  return isTargetSuperClassType(
-    type,
-    ["Construct", "Stack"],
-    isConstructOrStackType
-  );
-};
-
-/**
- * Check if the type extends Construct
- * @param type - The type to check
- * @param ignoredClasses - Classes that inherit from Construct Class but do not want to be treated as Construct Class
- * @returns True if the type extends Construct, otherwise false
- */
-export const isConstructType = (
-  type: Type,
-  ignoredClasses: readonly string[] = [
-    "App",
-    "Stage",
-    "CfnOutput",
-    "Stack",
-  ] as const
-): boolean => {
-  if (ignoredClasses.includes(type.symbol?.name ?? "")) return false;
-  return isTargetSuperClassType(type, ["Construct"], isConstructType);
-};
-
-export const isResourceType = (
-  type: Type,
-  ignoredClasses: readonly string[] = [] // App, Stage, CfnOutput, Stack are not extended Resource, so no need to ignore them
-): boolean => {
-  if (ignoredClasses.includes(type.symbol?.name ?? "")) return false;
-  return isTargetSuperClassType(type, ["Resource"], isResourceType);
-};
-
-/**
- * Check if the type extends target super class
- * @param type - The type to check
- * @param targetSuperClasses - The target super classes
- * @returns True if the type extends target super class, otherwise false
- */
-const isTargetSuperClassType = (
-  type: Type,
-  targetSuperClasses: SuperClassType[],
-  typeCheckFunction: (type: Type) => boolean
-): boolean => {
-  if (!type.symbol) return false;
-
-  // NOTE: Check if the current type ends in target super class
-  if (targetSuperClasses.some((suffix) => type.symbol.name === suffix)) {
-    return true;
-  }
-
-  // NOTE: Check the base type
-  const baseTypes = type.getBaseTypes() ?? [];
-  return baseTypes.some((baseType) => typeCheckFunction(baseType));
-};

package/src/utils/typecheck/ts-node.ts

@@ -1,42 +0,0 @@
-import {
-  ClassDeclaration,
-  ConstructorDeclaration,
-  HeritageClause,
-  Identifier,
-  Node,
-  PropertyAccessExpression,
-} from "typescript";
-
-import { SYNTAX_KIND } from "../../constants/tsInternalFlags";
-
-// NOTE: In order not to make it dependent on the typescript library, it defines its own unions.
-//       Therefore, the type information structures do not match.
-/* eslint-disable @typescript-eslint/no-unsafe-enum-comparison */
-
-// NOTE: Implementing type check method defined in typescript on your own, in order not to include TypeScript in dependencies
-
-export const isClassDeclaration = (node: Node): node is ClassDeclaration => {
-  return node.kind === SYNTAX_KIND.CLASS_DECLARATION;
-};
-
-export const isIdentifier = (node: Node): node is Identifier => {
-  return node.kind === SYNTAX_KIND.IDENTIFIER;
-};
-
-export const isPropertyAccessExpression = (
-  node: Node
-): node is PropertyAccessExpression => {
-  return node.kind === SYNTAX_KIND.PROPERTY_ACCESS_EXPRESSION;
-};
-
-export const checkHeritageClauseIsImplements = (
-  node: HeritageClause
-): boolean => {
-  return node.token === SYNTAX_KIND.IMPLEMENTS_KEYWORD;
-};
-
-export const isConstructorDeclaration = (
-  node: Node
-): node is ConstructorDeclaration => {
-  return node.kind === SYNTAX_KIND.CONSTRUCTOR;
-};

package/src/utils/typecheck/ts-type.ts

@@ -1,27 +0,0 @@
-import { Symbol, Type } from "typescript";
-
-import { SYMBOL_FLAGS } from "../../constants/tsInternalFlags";
-
-// NOTE: In order not to make it dependent on the typescript library, it defines its own unions.
-//       Therefore, the type information structures do not match.
-/* eslint-disable @typescript-eslint/no-unsafe-enum-comparison */
-
-const getSymbol = (type: Type): Symbol | undefined => {
-  return type.getSymbol?.() ?? type.symbol;
-};
-
-export const isClassType = (type: Type): boolean => {
-  return getSymbol(type)?.flags === SYMBOL_FLAGS.CLASS;
-};
-
-export const isArrayType = (type: Type): boolean => {
-  const symbol = getSymbol(type);
-  if (symbol?.name === "Array") return true;
-
-  if ("target" in type && type.target) {
-    const targetSymbol = getSymbol(type.target as Type);
-    return targetSymbol?.name === "Array";
-  }
-
-  return false;
-};