@blumintinc/eslint-plugin-blumint 1.13.0 → 1.15.0

package/lib/utils/getMethodName.d.ts

@@ -0,0 +1,27 @@
+import { TSESTree } from '@typescript-eslint/utils';
+/**
+ * Extracts a stable, human-readable name from method/property/member nodes.
+ * Use the options to align prefixing and computed-key handling with rule semantics.
+ */
+export type GetMethodNameOptions = {
+    /**
+     * Prefix applied to private identifiers:
+     * - undefined (default): empty prefix
+     * - null: return the raw name without any prefix
+     * - string (e.g., '#'): prepend the given prefix
+     */
+    privateIdentifierPrefix?: string | null;
+    /**
+     * When true (default), computed keys fall back to source text; when false, returns empty string.
+     */
+    computedFallbackToText?: boolean;
+};
+export declare const getMethodName: (method: TSESTree.MethodDefinition | TSESTree.TSAbstractMethodDefinition | TSESTree.PropertyDefinition, sourceCode: Readonly<{
+    getText: (node: TSESTree.Node) => string;
+}>, options?: GetMethodNameOptions) => string;
+export declare const getPropertyName: (key: TSESTree.PropertyName | TSESTree.PrivateIdentifier, sourceCode: Readonly<{
+    getText: (node: TSESTree.Node) => string;
+}>, options?: GetMethodNameOptions) => string;
+export declare const getMemberExpressionName: (member: TSESTree.MemberExpression, sourceCode: Readonly<{
+    getText: (node: TSESTree.Node) => string;
+}>, options?: GetMethodNameOptions) => string;

package/lib/utils/getMethodName.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getMemberExpressionName = exports.getPropertyName = exports.getMethodName = void 0;
+const utils_1 = require("@typescript-eslint/utils");
+const getKeyName = (key, sourceCode, { privateIdentifierPrefix = '', computedFallbackToText = true, }) => {
+    if (key.type === utils_1.AST_NODE_TYPES.Identifier) {
+        return key.name;
+    }
+    if (key.type === utils_1.AST_NODE_TYPES.PrivateIdentifier) {
+        if (privateIdentifierPrefix === null) {
+            return key.name;
+        }
+        return `${privateIdentifierPrefix}${key.name}`;
+    }
+    if (key.type === utils_1.AST_NODE_TYPES.Literal) {
+        if (key.value === null || key.value === undefined) {
+            return '';
+        }
+        return String(key.value);
+    }
+    return computedFallbackToText ? sourceCode.getText(key) : '';
+};
+const getMethodName = (method, sourceCode, options = {}) => {
+    return getKeyName(method.key, sourceCode, options);
+};
+exports.getMethodName = getMethodName;
+const getPropertyName = (key, sourceCode, options = {}) => {
+    return getKeyName(key, sourceCode, options);
+};
+exports.getPropertyName = getPropertyName;
+const getMemberExpressionName = (member, sourceCode, options = {}) => {
+    return getKeyName(member.property, sourceCode, options);
+};
+exports.getMemberExpressionName = getMemberExpressionName;
+//# sourceMappingURL=getMethodName.js.map

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.13.0",
+  "version": "1.15.0",
   "description": "Custom eslint rules for use within BluMint",
   "author": {
     "name": "Brodie McGuire",
@@ -33,6 +33,8 @@
     "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",