@blumintinc/eslint-plugin-blumint 1.12.6 → 1.14.0

package/lib/utils/tsTypeClassifier.d.ts

@@ -0,0 +1,30 @@
+import { TSESTree, ParserServices } from '@typescript-eslint/utils';
+import * as ts from 'typescript';
+/**
+ * Re-exporting the typescript namespace type to avoid TS4078.
+ */
+export type TypeScriptModule = typeof ts;
+export type ClassifierOptions = {
+    ignoreSymbol?: boolean;
+};
+export type ClassificationResult = {
+    status: 'primitive' | 'non-primitive' | 'unknown';
+    kind: string;
+};
+/**
+ * Describes the kind of a primitive type for error messages.
+ */
+export declare function describeTypeKind(t: ts.Type, tsModule: TypeScriptModule, options: ClassifierOptions): string;
+/**
+ * Classifies a TypeScript type as primitive, non-primitive, or unknown.
+ */
+export declare function classifyType(t: ts.Type, tsModule: TypeScriptModule, options: ClassifierOptions): 'primitive' | 'non-primitive' | 'unknown';
+/**
+ * Classifies the type of an expression using TypeScript's type checker.
+ */
+export declare function classifyExpressionType(expr: TSESTree.Expression, { checker, tsModule, parserServices, options, }: {
+    checker: ts.TypeChecker;
+    tsModule: TypeScriptModule;
+    parserServices: ParserServices;
+    options: ClassifierOptions;
+}): ClassificationResult;

package/lib/utils/tsTypeClassifier.js

@@ -0,0 +1,149 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.classifyExpressionType = exports.classifyType = exports.describeTypeKind = void 0;
+/**
+ * Describes the kind of a primitive type for error messages.
+ */
+function describeTypeKind(t, tsModule, options) {
+    if (t.isUnion()) {
+        const kinds = new Set(t.types
+            .map((part) => describeTypeKind(part, tsModule, options))
+            .filter((k) => k !== 'primitive value'));
+        if (kinds.size === 0) {
+            return 'primitive value';
+        }
+        if (kinds.size === 1) {
+            return kinds.values().next().value ?? 'primitive value';
+        }
+        // Multiple distinct primitive kinds
+        const sortedKinds = Array.from(kinds).sort();
+        return `${sortedKinds.join(' or ')}`;
+    }
+    const flags = t.flags;
+    if (flags & tsModule.TypeFlags.String)
+        return 'string value';
+    if (flags & tsModule.TypeFlags.StringLiteral)
+        return 'string value';
+    if (flags & tsModule.TypeFlags.TemplateLiteral)
+        return 'string value';
+    if (flags & tsModule.TypeFlags.Number)
+        return 'number value';
+    if (flags & tsModule.TypeFlags.NumberLiteral)
+        return 'number value';
+    if (flags & tsModule.TypeFlags.Enum)
+        return 'number value';
+    if (flags & tsModule.TypeFlags.EnumLiteral)
+        return 'number value';
+    if (flags & tsModule.TypeFlags.Boolean)
+        return 'boolean value';
+    if (flags & tsModule.TypeFlags.BooleanLiteral)
+        return 'boolean value';
+    if (flags & tsModule.TypeFlags.BigInt)
+        return 'bigint value';
+    if (flags & tsModule.TypeFlags.BigIntLiteral)
+        return 'bigint value';
+    if (flags & tsModule.TypeFlags.Null)
+        return 'null value';
+    if (flags & tsModule.TypeFlags.Undefined)
+        return 'undefined value';
+    if (flags &
+        (tsModule.TypeFlags.ESSymbol | tsModule.TypeFlags.UniqueESSymbol)) {
+        return 'symbol value';
+    }
+    return 'primitive value';
+}
+exports.describeTypeKind = describeTypeKind;
+/**
+ * Classifies a TypeScript type as primitive, non-primitive, or unknown.
+ */
+function classifyType(t, tsModule, options) {
+    if (t.isUnion()) {
+        let sawUnknown = false;
+        for (const part of t.types) {
+            const result = classifyType(part, tsModule, options);
+            if (result === 'non-primitive') {
+                return 'non-primitive';
+            }
+            if (result === 'unknown') {
+                sawUnknown = true;
+            }
+        }
+        return sawUnknown ? 'unknown' : 'primitive';
+    }
+    if (t.isIntersection())
+        return 'non-primitive';
+    const flags = t.getFlags();
+    if (flags &
+        (tsModule.TypeFlags.Any |
+            tsModule.TypeFlags.Unknown |
+            tsModule.TypeFlags.Never |
+            tsModule.TypeFlags.TypeParameter)) {
+        return 'unknown';
+    }
+    if (flags &
+        (tsModule.TypeFlags.Object |
+            tsModule.TypeFlags.NonPrimitive |
+            tsModule.TypeFlags.Index |
+            tsModule.TypeFlags.IndexedAccess |
+            tsModule.TypeFlags.Conditional |
+            tsModule.TypeFlags.Substitution)) {
+        return 'non-primitive';
+    }
+    if (flags & tsModule.TypeFlags.Void) {
+        return 'unknown';
+    }
+    if (flags &
+        (tsModule.TypeFlags.ESSymbol | tsModule.TypeFlags.UniqueESSymbol)) {
+        return options.ignoreSymbol ? 'non-primitive' : 'primitive';
+    }
+    if (flags &
+        (tsModule.TypeFlags.String |
+            tsModule.TypeFlags.StringLiteral |
+            tsModule.TypeFlags.TemplateLiteral |
+            tsModule.TypeFlags.Number |
+            tsModule.TypeFlags.NumberLiteral |
+            tsModule.TypeFlags.Enum |
+            tsModule.TypeFlags.EnumLiteral |
+            tsModule.TypeFlags.Boolean |
+            tsModule.TypeFlags.BooleanLiteral |
+            tsModule.TypeFlags.BigInt |
+            tsModule.TypeFlags.BigIntLiteral |
+            tsModule.TypeFlags.Null |
+            tsModule.TypeFlags.Undefined)) {
+        return 'primitive';
+    }
+    return 'unknown';
+}
+exports.classifyType = classifyType;
+/**
+ * Classifies the type of an expression using TypeScript's type checker.
+ */
+function classifyExpressionType(expr, { checker, tsModule, parserServices, options, }) {
+    try {
+        const tsNode = parserServices.esTreeNodeToTSNodeMap.get(expr);
+        if (!tsNode) {
+            /* istanbul ignore next -- rare when parser services mismatch */
+            return { status: 'unknown', kind: 'unknown value' };
+        }
+        const type = checker.getTypeAtLocation(tsNode);
+        const classification = classifyType(type, tsModule, options);
+        if (classification === 'primitive') {
+            return {
+                status: 'primitive',
+                kind: describeTypeKind(type, tsModule, options),
+            };
+        }
+        return {
+            status: classification,
+            kind: classification === 'non-primitive'
+                ? 'non-primitive value'
+                : 'unknown value',
+        };
+    }
+    catch {
+        /* istanbul ignore next -- defensive fallback when type evaluation fails */
+        return { status: 'unknown', kind: 'unknown value' };
+    }
+}
+exports.classifyExpressionType = classifyExpressionType;
+//# sourceMappingURL=tsTypeClassifier.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@blumintinc/eslint-plugin-blumint",
-  "version": "1.12.6",
+  "version": "1.14.0",
   "description": "Custom eslint rules for use within BluMint",
   "author": {
     "name": "Brodie McGuire",
@@ -13,12 +13,12 @@
   },
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/BluMintInc/custom-eslint-rules.git"
+    "url": "git+https://github.com/BluMintInc/eslint-custom-rules.git"
   },
   "bugs": {
-    "url": "https://github.com/BluMintInc/custom-eslint-rules/issues"
+    "url": "https://github.com/BluMintInc/eslint-custom-rules/issues"
   },
-  "homepage": "https://github.com/BluMintInc/custom-eslint-rules#readme",
+  "homepage": "https://github.com/BluMintInc/eslint-custom-rules#readme",
   "keywords": [
     "eslint",
     "eslintplugin",
@@ -29,10 +29,17 @@
     "lint": "npm-run-all \"lint:*\"",
     "lint:eslint-docs": "npm-run-all \"update:eslint-docs -- --check\"",
     "lint:js": "eslint ./src",
-    "lint:shell": "shellcheck .devcontainer/git-flow-completion.bash",
     "lint:fix": "tsc && eslint \"./src/**/*\" --quiet --fix",
     "test": "jest --passWithNoTests --reporters=default --reporters=jest-junit",
     "test:ci": "jest --ci --passWithNoTests --reporters=default --reporters=jest-junit",
+    "address-review": "tsx ./.github/scripts/address-review.ts",
+    "address-merge-conflicts": "tsx ./.github/scripts/address-merge-conflicts.ts",
+    "check-merge-conflicts": "bash ./scripts/check-merge-conflicts.sh",
+    "merge-review": "tsx ./.github/scripts/merge-review.ts",
+    "fetch-unresolved-comments": "./scripts/pr-check-comments.sh",
+    "fetch-unresolved-bot-comments": "./scripts/pr-check-bot-comments.sh",
+    "resolve-comments": "./scripts/pr-resolve-comments.sh",
+    "apply-comment-decisions": "./scripts/pr-apply-comment-decisions.sh",
     "docs": "./scripts/make-docs.sh && npm run update:eslint-docs",
     "update:eslint-docs": "eslint-doc-generator --init-rule-docs",
     "build": "tsc",
@@ -54,12 +61,12 @@
   "devDependencies": {
     "@commitlint/cli": "19.6.1",
     "@commitlint/config-conventional": "19.6.0",
-    "@semantic-release/changelog": "6.0.1",
-    "@semantic-release/commit-analyzer": "9.0.2",
-    "@semantic-release/exec": "6.0.3",
+    "@semantic-release/changelog": "6.0.3",
+    "@semantic-release/commit-analyzer": "13.0.1",
+    "@semantic-release/exec": "7.1.0",
     "@semantic-release/git": "10.0.1",
-    "@semantic-release/npm": "9.0.1",
-    "@semantic-release/release-notes-generator": "10.0.3",
+    "@semantic-release/npm": "13.1.2",
+    "@semantic-release/release-notes-generator": "14.1.0",
     "@types/eslint": "8.37.0",
     "@types/jest": "29.5.14",
     "@types/node": "18.7.13",
@@ -72,9 +79,9 @@
     "cz-conventional-changelog": "3.3.0",
     "del-cli": "4.0.1",
     "dotenv-cli": "5.0.0",
-    "eslint": "8.57.0",
+    "eslint": "8.57.1",
     "eslint-config-prettier": "8.5.0",
-    "eslint-doc-generator": "1.7.1",
+    "eslint-doc-generator": "2.2.0",
     "eslint-import-resolver-typescript": "3.5.5",
     "eslint-plugin-eslint-plugin": "5.0.0",
     "eslint-plugin-import": "2.26.0",
@@ -87,15 +94,17 @@
     "jest": "29.7.0",
     "jest-junit": "14.0.0",
     "jsonc-eslint-parser": "2.3.0",
+    "markdown-eslint-parser": "1.2.1",
     "npm-run-all": "4.1.5",
     "prettier": "2.7.1",
     "remark-cli": "10.0.1",
     "remark-lint": "9.1.1",
     "remark-preset-lint-recommended": "6.1.2",
-    "semantic-release": "19.0.3",
+    "semantic-release": "25.0.2",
     "ts-jest": "29.2.6",
     "ts-node": "10.9.1",
-    "typescript": "4.9.5"
+    "tsx": "4.19.4",
+    "typescript": "5.0.3"
   },
   "peerDependencies": {
     "eslint": ">=7"

package/lib/rules/enforce-assertSafe-object-key.d.ts

@@ -1,2 +0,0 @@
-import { TSESLint } from '@typescript-eslint/utils';
-export declare const enforceAssertSafeObjectKey: TSESLint.RuleModule<"useAssertSafe", [], TSESLint.RuleListener>;