@memberjunction/react-linter 0.0.1 → 5.38.0

package/dist/runtime-rules/styles-validation.js

@@ -0,0 +1,153 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { traverse } from '../lint-utils.js';
+import { RegisterClass } from '@memberjunction/global';
+import * as t from '@babel/types';
+import { BaseLintRule } from '../lint-rule.js';
+import { StylesTypeAnalyzer } from '../styles-type-analyzer.js';
+/**
+ * Rule: styles-validation
+ *
+ * Consolidated rule that combines:
+ * 1. styles-invalid-path — Validates that styles property access paths are valid
+ *    according to the StylesTypeAnalyzer. Provides suggestions for misspelled
+ *    or misplaced properties.
+ * 2. styles-unsafe-access — Validates safe access patterns on styles objects.
+ *    Currently skips styles access because ComponentStyles interface guarantees
+ *    structure (all required properties exist), but included for future activation.
+ *
+ * Severity: critical (invalid path), varies (unsafe access)
+ * Applies to: all components
+ */
+// Lazy singleton for the styles analyzer
+let _stylesAnalyzer = null;
+function getStylesAnalyzer() {
+    if (!_stylesAnalyzer) {
+        _stylesAnalyzer = new StylesTypeAnalyzer();
+    }
+    return _stylesAnalyzer;
+}
+// Standard props that are always defined with guaranteed structure
+// The ComponentStyles interface guarantees all required properties exist
+// So we don't need to check for optional chaining on the styles object itself
+const standardProps = new Set(['utilities', 'styles', 'components', 'callbacks', 'savedUserSettings', 'onSaveUserSettings']);
+let StylesValidationRule = class StylesValidationRule extends BaseLintRule {
+    get Name() { return 'styles-validation'; }
+    get AppliesTo() { return 'all'; }
+    Test(ast, componentName, componentSpec) {
+        const violations = [];
+        const analyzer = getStylesAnalyzer();
+        traverse(ast, {
+            MemberExpression(path) {
+                // Build the complete property chain first
+                const propertyChain = [];
+                let current = path.node;
+                let hasOptionalChaining = path.node.optional || false;
+                // Walk up from the deepest member expression to build the full chain
+                while (t.isMemberExpression(current)) {
+                    if (current.optional) {
+                        hasOptionalChaining = true;
+                    }
+                    if (t.isIdentifier(current.property)) {
+                        propertyChain.unshift(current.property.name);
+                    }
+                    if (t.isIdentifier(current.object)) {
+                        propertyChain.unshift(current.object.name);
+                        break;
+                    }
+                    current = current.object;
+                }
+                // Only process if this is a styles access
+                if (propertyChain[0] !== 'styles') {
+                    return;
+                }
+                // --- styles-invalid-path logic ---
+                checkInvalidPath(path, propertyChain, analyzer, violations);
+                // --- styles-unsafe-access logic ---
+                // Skip styles access entirely - ComponentStyles interface guarantees structure.
+                // styles is a standard prop with a fixed interface, all required properties exist.
+                // This prevents false positives for patterns like: styles.borders.radius
+                // The ComponentStyles interface (runtime-types.ts) defines all required properties
+                // including colors, spacing, typography, borders, etc. as non-optional.
+                //
+                // When this rule becomes active in the future, hasOptionalChaining and
+                // standardProps are available to implement unsafe-access checks here.
+            },
+        });
+        return violations;
+    }
+};
+StylesValidationRule = __decorate([
+    RegisterClass(BaseLintRule, 'styles-validation')
+], StylesValidationRule);
+export { StylesValidationRule };
+/**
+ * Checks whether a styles property access path is valid according to the
+ * StylesTypeAnalyzer. Produces a violation with suggestions when invalid.
+ */
+function checkInvalidPath(path, propertyChain, analyzer, violations) {
+    if (analyzer.isValidPath(propertyChain)) {
+        return;
+    }
+    const suggestions = analyzer.getSuggestionsForPath(propertyChain);
+    const accessPath = propertyChain.join('.');
+    let message = buildInvalidPathMessage(accessPath, propertyChain, suggestions);
+    // Get a contextual default value
+    const defaultValue = analyzer.getDefaultValueForPath(propertyChain);
+    message += `\n\nSuggested fix with safe access:\n  ${accessPath.replace(/\./g, '?.')} || ${defaultValue}`;
+    violations.push({
+        rule: 'styles-validation',
+        severity: 'critical',
+        line: path.node.loc?.start.line || 0,
+        column: path.node.loc?.start.column || 0,
+        message,
+        code: accessPath,
+        suggestion: {
+            text: 'Fix invalid styles property paths. Use the correct ComponentStyles interface structure.',
+            example: `// ❌ WRONG - Invalid property paths:
+styles.fontSize.small           // fontSize is not at root level
+styles.colors.background        // colors.background exists
+styles.spacing.small            // should be styles.spacing.sm
+
+// ✅ CORRECT - Valid property paths:
+styles.typography.fontSize.sm   // fontSize is under typography
+styles.colors.background        // correct path
+styles.spacing.sm               // correct size name
+
+// With safe access and fallbacks:
+styles?.typography?.fontSize?.sm || '14px'
+styles?.colors?.background || '#FFFFFF'
+styles?.spacing?.sm || '8px'`,
+        },
+    });
+}
+/**
+ * Builds a human-readable message for an invalid styles path, including
+ * did-you-mean suggestions, correct paths, and available properties.
+ */
+function buildInvalidPathMessage(accessPath, propertyChain, suggestions) {
+    let message = `Invalid styles property path: "${accessPath}"`;
+    if (suggestions.didYouMean) {
+        message += `\n\nDid you mean: ${suggestions.didYouMean}?`;
+    }
+    if (suggestions.correctPaths.length > 0) {
+        message += `\n\nThe property "${propertyChain[propertyChain.length - 1]}" exists at:`;
+        suggestions.correctPaths.forEach((p) => {
+            message += `\n  - ${p}`;
+        });
+    }
+    if (suggestions.availableAtParent.length > 0) {
+        const parentPath = propertyChain.slice(0, -1).join('.');
+        message += `\n\nAvailable properties at ${parentPath}:`;
+        message += `\n  ${suggestions.availableAtParent.slice(0, 5).join(', ')}`;
+        if (suggestions.availableAtParent.length > 5) {
+            message += ` (and ${suggestions.availableAtParent.length - 5} more)`;
+        }
+    }
+    return message;
+}
+//# sourceMappingURL=styles-validation.js.map

package/dist/runtime-rules/styles-validation.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"styles-validation.js","sourceRoot":"","sources":["../../src/runtime-rules/styles-validation.ts"],"names":[],"mappings":"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"}

package/dist/runtime-rules/type-inference-errors.d.ts

@@ -0,0 +1,23 @@
+import * as t from '@babel/types';
+import { BaseLintRule } from '../lint-rule.js';
+import { Violation } from '../component-linter.js';
+import { ComponentSpec } from '@memberjunction/interactive-component-types';
+/**
+ * Rule: type-inference-errors
+ *
+ * Surfaces errors found by TypeInferenceEngine (e.g., date parameter validation).
+ *
+ * DEPRECATED: This rule is being replaced by TypeCompatibilityRule in Phase 1 refactor.
+ * Will be removed after Phase 1 validation is complete.
+ *
+ * Severity: high/medium (depends on error type)
+ * Applies to: all components
+ *
+ * Closure dependencies: TypeInferenceEngine (instantiated locally, no closure)
+ */
+export declare class TypeInferenceErrorsRule extends BaseLintRule {
+    get Name(): string;
+    get AppliesTo(): 'all' | 'child' | 'root';
+    Test(ast: t.File, _componentName: string, componentSpec?: ComponentSpec): Violation[];
+}
+//# sourceMappingURL=type-inference-errors.d.ts.map

package/dist/runtime-rules/type-inference-errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"type-inference-errors.d.ts","sourceRoot":"","sources":["../../src/runtime-rules/type-inference-errors.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,cAAc,CAAC;AAElC,OAAO,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AAC5C,OAAO,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAC;AAEhD,OAAO,EAAE,aAAa,EAAE,MAAM,6CAA6C,CAAC;AAE5E;;;;;;;;;;;;GAYG;AACH,qBACa,uBAAwB,SAAQ,YAAY;IACvD,IAAI,IAAI,WAAsC;IAC9C,IAAI,SAAS,IAAI,KAAK,GAAG,OAAO,GAAG,MAAM,CAAkB;IAE3D,IAAI,CAAC,GAAG,EAAE,CAAC,CAAC,IAAI,EAAE,cAAc,EAAE,MAAM,EAAE,aAAa,CAAC,EAAE,aAAa,GAAG,SAAS,EAAE;CA2BtF"}

package/dist/runtime-rules/type-inference-errors.js

@@ -0,0 +1,53 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { RegisterClass } from '@memberjunction/global';
+import { BaseLintRule } from '../lint-rule.js';
+import { TypeInferenceEngine } from '../type-inference-engine.js';
+/**
+ * Rule: type-inference-errors
+ *
+ * Surfaces errors found by TypeInferenceEngine (e.g., date parameter validation).
+ *
+ * DEPRECATED: This rule is being replaced by TypeCompatibilityRule in Phase 1 refactor.
+ * Will be removed after Phase 1 validation is complete.
+ *
+ * Severity: high/medium (depends on error type)
+ * Applies to: all components
+ *
+ * Closure dependencies: TypeInferenceEngine (instantiated locally, no closure)
+ */
+let TypeInferenceErrorsRule = class TypeInferenceErrorsRule extends BaseLintRule {
+    get Name() { return 'type-inference-errors'; }
+    get AppliesTo() { return 'all'; }
+    Test(ast, _componentName, componentSpec) {
+        const violations = [];
+        // Create type inference engine
+        const typeEngine = new TypeInferenceEngine(componentSpec);
+        // Run analysis synchronously (validateQueryParameters is called during traversal)
+        // The async part of analyze() is not needed for date validation
+        typeEngine.analyze(ast);
+        // Get errors collected during analysis
+        const errors = typeEngine.getErrors();
+        // Convert type inference errors to violations
+        for (const error of errors) {
+            violations.push({
+                rule: 'type-inference-errors',
+                severity: error.type === 'error' ? 'high' : 'medium',
+                line: error.line,
+                column: error.column,
+                message: error.message,
+                code: error.code || '',
+            });
+        }
+        return violations;
+    }
+};
+TypeInferenceErrorsRule = __decorate([
+    RegisterClass(BaseLintRule, 'type-inference-errors')
+], TypeInferenceErrorsRule);
+export { TypeInferenceErrorsRule };
+//# sourceMappingURL=type-inference-errors.js.map

package/dist/runtime-rules/type-inference-errors.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"type-inference-errors.js","sourceRoot":"","sources":["../../src/runtime-rules/type-inference-errors.ts"],"names":[],"mappings":";;;;;;AACA,OAAO,EAAE,aAAa,EAAE,MAAM,wBAAwB,CAAC;AACvD,OAAO,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AAE5C,OAAO,EAAE,mBAAmB,EAAE,MAAM,0BAA0B,CAAC;AAG/D;;;;;;;;;;;;GAYG;AAEI,IAAM,uBAAuB,GAA7B,MAAM,uBAAwB,SAAQ,YAAY;IACvD,IAAI,IAAI,KAAK,OAAO,uBAAuB,CAAC,CAAC,CAAC;IAC9C,IAAI,SAAS,KAA+B,OAAO,KAAK,CAAC,CAAC,CAAC;IAE3D,IAAI,CAAC,GAAW,EAAE,cAAsB,EAAE,aAA6B;QACrE,MAAM,UAAU,GAAgB,EAAE,CAAC;QAEnC,+BAA+B;QAC/B,MAAM,UAAU,GAAG,IAAI,mBAAmB,CAAC,aAAa,CAAC,CAAC;QAE1D,kFAAkF;QAClF,gEAAgE;QAChE,UAAU,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC;QAExB,uCAAuC;QACvC,MAAM,MAAM,GAAG,UAAU,CAAC,SAAS,EAAE,CAAC;QAEtC,8CAA8C;QAC9C,KAAK,MAAM,KAAK,IAAI,MAAM,EAAE,CAAC;YAC3B,UAAU,CAAC,IAAI,CAAC;gBACd,IAAI,EAAE,uBAAuB;gBAC7B,QAAQ,EAAE,KAAK,CAAC,IAAI,KAAK,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,QAAQ;gBACpD,IAAI,EAAE,KAAK,CAAC,IAAI;gBAChB,MAAM,EAAE,KAAK,CAAC,MAAM;gBACpB,OAAO,EAAE,KAAK,CAAC,OAAO;gBACtB,IAAI,EAAE,KAAK,CAAC,IAAI,IAAI,EAAE;aACvB,CAAC,CAAC;QACL,CAAC;QAED,OAAO,UAAU,CAAC;IAClB,CAAC;CACJ,CAAA;AA/BY,uBAAuB;IADnC,aAAa,CAAC,YAAY,EAAE,uBAAuB,CAAC;GACxC,uBAAuB,CA+BnC"}

package/dist/runtime-rules/type-mismatch-operation.d.ts

@@ -0,0 +1,23 @@
+import * as t from '@babel/types';
+import { BaseLintRule } from '../lint-rule.js';
+import { Violation } from '../component-linter.js';
+import { ComponentSpec } from '@memberjunction/interactive-component-types';
+/**
+ * Rule: type-mismatch-operation
+ *
+ * Validates that operations are type-safe (e.g., no arithmetic on strings, array methods on non-arrays).
+ *
+ * DEPRECATED: This rule is being replaced by TypeCompatibilityRule in Phase 1 refactor.
+ * Will be removed after Phase 1 validation is complete.
+ *
+ * Severity: high
+ * Applies to: all components
+ *
+ * Closure dependencies: TypeInferenceEngine, ControlFlowAnalyzer (instantiated locally, no closure)
+ */
+export declare class TypeMismatchOperationRule extends BaseLintRule {
+    get Name(): string;
+    get AppliesTo(): 'all' | 'child' | 'root';
+    Test(ast: t.File, _componentName: string, componentSpec?: ComponentSpec): Violation[];
+}
+//# sourceMappingURL=type-mismatch-operation.d.ts.map

package/dist/runtime-rules/type-mismatch-operation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"type-mismatch-operation.d.ts","sourceRoot":"","sources":["../../src/runtime-rules/type-mismatch-operation.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,CAAC,MAAM,cAAc,CAAC;AAClC,OAAO,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AAC5C,OAAO,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAC;AAGhD,OAAO,EAAE,aAAa,EAAE,MAAM,6CAA6C,CAAC;AAE5E;;;;;;;;;;;;GAYG;AACH,qBACa,yBAA0B,SAAQ,YAAY;IACzD,IAAI,IAAI,WAAwC;IAChD,IAAI,SAAS,IAAI,KAAK,GAAG,OAAO,GAAG,MAAM,CAAkB;IAE3D,IAAI,CAAC,GAAG,EAAE,CAAC,CAAC,IAAI,EAAE,cAAc,EAAE,MAAM,EAAE,aAAa,CAAC,EAAE,aAAa,GAAG,SAAS,EAAE;CAkItF"}

package/dist/runtime-rules/type-mismatch-operation.js

@@ -0,0 +1,145 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { traverse } from '../lint-utils.js';
+import { RegisterClass } from '@memberjunction/global';
+import * as t from '@babel/types';
+import { BaseLintRule } from '../lint-rule.js';
+import { TypeInferenceEngine } from '../type-inference-engine.js';
+import { ControlFlowAnalyzer } from '../control-flow-analyzer.js';
+/**
+ * Rule: type-mismatch-operation
+ *
+ * Validates that operations are type-safe (e.g., no arithmetic on strings, array methods on non-arrays).
+ *
+ * DEPRECATED: This rule is being replaced by TypeCompatibilityRule in Phase 1 refactor.
+ * Will be removed after Phase 1 validation is complete.
+ *
+ * Severity: high
+ * Applies to: all components
+ *
+ * Closure dependencies: TypeInferenceEngine, ControlFlowAnalyzer (instantiated locally, no closure)
+ */
+let TypeMismatchOperationRule = class TypeMismatchOperationRule extends BaseLintRule {
+    get Name() { return 'type-mismatch-operation'; }
+    get AppliesTo() { return 'all'; }
+    Test(ast, _componentName, componentSpec) {
+        const violations = [];
+        // Create type inference engine
+        const typeEngine = new TypeInferenceEngine(componentSpec);
+        // Create control flow analyzer
+        const cfa = new ControlFlowAnalyzer(ast, componentSpec);
+        // Run analysis synchronously (the async part is not needed for basic inference)
+        typeEngine.analyze(ast);
+        traverse(ast, {
+            // Check binary operations for type mismatches
+            BinaryExpression(path) {
+                const node = path.node;
+                const operator = node.operator;
+                // Skip comparison operators - they work with any types
+                if (['==', '!=', '===', '!==', '<', '<=', '>', '>=', 'in', 'instanceof'].includes(operator)) {
+                    return;
+                }
+                // Check arithmetic operators (should be numbers)
+                if (['-', '*', '/', '%', '**', '|', '&', '^', '<<', '>>', '>>>'].includes(operator)) {
+                    // Skip if left is PrivateName
+                    if (t.isPrivateName(node.left))
+                        return;
+                    const leftType = typeEngine.inferExpressionType(node.left, path);
+                    const rightType = typeEngine.inferExpressionType(node.right, path);
+                    // Special case: Date - Date is valid (subtraction only)
+                    if (operator === '-' && leftType.type === 'Date' && rightType.type === 'Date') {
+                        // Date - Date produces a number (milliseconds), this is valid
+                        return;
+                    }
+                    // Check if both sides are guarded by typeof checks using Control Flow Analyzer
+                    const leftGuarded = cfa.isNarrowedToType(node.left, path, 'number');
+                    const rightGuarded = cfa.isNarrowedToType(node.right, path, 'number');
+                    // Only flag if we know the type is wrong (not unknown) AND not guarded by typeof
+                    if (!leftGuarded && leftType.type !== 'unknown' && leftType.type !== 'number' && leftType.type !== 'Date') {
+                        violations.push({
+                            rule: 'type-mismatch-operation',
+                            severity: 'high',
+                            line: node.loc?.start.line || 0,
+                            column: node.loc?.start.column || 0,
+                            message: `Arithmetic operator "${operator}" used with ${leftType.type} on left side. Expected number.`,
+                            code: `Convert to number: Number(value) ${operator} ...`,
+                        });
+                    }
+                    if (!rightGuarded && rightType.type !== 'unknown' && rightType.type !== 'number' && rightType.type !== 'Date') {
+                        violations.push({
+                            rule: 'type-mismatch-operation',
+                            severity: 'high',
+                            line: node.loc?.start.line || 0,
+                            column: node.loc?.start.column || 0,
+                            message: `Arithmetic operator "${operator}" used with ${rightType.type} on right side. Expected number.`,
+                            code: `Convert to number: ... ${operator} Number(value)`,
+                        });
+                    }
+                }
+            },
+            // Check array method calls on non-arrays
+            CallExpression(path) {
+                const node = path.node;
+                if (t.isMemberExpression(node.callee) && t.isIdentifier(node.callee.property)) {
+                    const methodName = node.callee.property.name;
+                    // Array-specific methods. Excludes `slice` and `concat` because
+                    // both exist on String.prototype with identical signatures/semantics
+                    // — flagging them on inferred-string types produces false positives
+                    // (e.g. `someString.slice(1)`). The remaining names are genuinely
+                    // array-only.
+                    const arrayOnlyMethods = [
+                        'push', 'pop', 'shift', 'unshift', 'splice',
+                        'map', 'filter', 'reduce', 'reduceRight', 'forEach',
+                        'find', 'findIndex', 'some', 'every', 'flat', 'flatMap',
+                        'sort', 'reverse', 'join', 'fill', 'copyWithin',
+                    ];
+                    if (arrayOnlyMethods.includes(methodName)) {
+                        const objectType = typeEngine.inferExpressionType(node.callee.object, path);
+                        // Only flag if we know it's definitely not an array
+                        if (objectType.type !== 'unknown' && objectType.type !== 'array') {
+                            violations.push({
+                                rule: 'type-mismatch-operation',
+                                severity: 'high',
+                                line: node.loc?.start.line || 0,
+                                column: node.loc?.start.column || 0,
+                                message: `Array method "${methodName}()" called on ${objectType.type}. This will fail at runtime.`,
+                                code: `Ensure value is an array before calling .${methodName}()`,
+                            });
+                        }
+                    }
+                    // String-specific methods
+                    const stringOnlyMethods = [
+                        'charAt', 'charCodeAt', 'codePointAt', 'substring', 'substr',
+                        'toUpperCase', 'toLowerCase', 'trim', 'trimStart', 'trimEnd',
+                        'padStart', 'padEnd', 'repeat', 'split', 'match', 'replace',
+                        'replaceAll', 'search', 'localeCompare', 'normalize',
+                    ];
+                    if (stringOnlyMethods.includes(methodName)) {
+                        const objectType = typeEngine.inferExpressionType(node.callee.object, path);
+                        // Only flag if we know it's definitely not a string
+                        if (objectType.type !== 'unknown' && objectType.type !== 'string') {
+                            violations.push({
+                                rule: 'type-mismatch-operation',
+                                severity: 'high',
+                                line: node.loc?.start.line || 0,
+                                column: node.loc?.start.column || 0,
+                                message: `String method "${methodName}()" called on ${objectType.type}. This may fail at runtime.`,
+                                code: `Ensure value is a string or convert: String(value).${methodName}()`,
+                            });
+                        }
+                    }
+                }
+            },
+        });
+        return violations;
+    }
+};
+TypeMismatchOperationRule = __decorate([
+    RegisterClass(BaseLintRule, 'type-mismatch-operation')
+], TypeMismatchOperationRule);
+export { TypeMismatchOperationRule };
+//# sourceMappingURL=type-mismatch-operation.js.map

package/dist/runtime-rules/type-mismatch-operation.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"type-mismatch-operation.js","sourceRoot":"","sources":["../../src/runtime-rules/type-mismatch-operation.ts"],"names":[],"mappings":"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"}

package/dist/runtime-rules/undefined-component-usage.d.ts

@@ -0,0 +1,20 @@
+import * as t from '@babel/types';
+import { BaseLintRule } from '../lint-rule.js';
+import { Violation } from '../component-linter.js';
+import { ComponentSpec } from '@memberjunction/interactive-component-types';
+/**
+ * Rule: undefined-component-usage
+ *
+ * Detects components that are destructured from the components prop but never used
+ * in JSX. These may be missing from the component spec's dependencies array or
+ * are simply unused.
+ *
+ * Severity: low (informational warning)
+ * Applies to: all components
+ */
+export declare class UndefinedComponentUsageRule extends BaseLintRule {
+    get Name(): string;
+    get AppliesTo(): 'all' | 'child' | 'root';
+    Test(ast: t.File, componentName: string, componentSpec?: ComponentSpec): Violation[];
+}
+//# sourceMappingURL=undefined-component-usage.d.ts.map

package/dist/runtime-rules/undefined-component-usage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"undefined-component-usage.d.ts","sourceRoot":"","sources":["../../src/runtime-rules/undefined-component-usage.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,CAAC,MAAM,cAAc,CAAC;AAClC,OAAO,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AAC5C,OAAO,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAC;AAChD,OAAO,EAAE,aAAa,EAAE,MAAM,6CAA6C,CAAC;AAE5E;;;;;;;;;GASG;AACH,qBACa,2BAA4B,SAAQ,YAAY;IAC3D,IAAI,IAAI,WAA0C;IAClD,IAAI,SAAS,IAAI,KAAK,GAAG,OAAO,GAAG,MAAM,CAAkB;IAE3D,IAAI,CAAC,GAAG,EAAE,CAAC,CAAC,IAAI,EAAE,aAAa,EAAE,MAAM,EAAE,aAAa,CAAC,EAAE,aAAa,GAAG,SAAS,EAAE;CAuHrF"}

package/dist/runtime-rules/undefined-component-usage.js

@@ -0,0 +1,138 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { traverse } from '../lint-utils.js';
+import { RegisterClass } from '@memberjunction/global';
+import * as t from '@babel/types';
+import { BaseLintRule } from '../lint-rule.js';
+/**
+ * Rule: undefined-component-usage
+ *
+ * Detects components that are destructured from the components prop but never used
+ * in JSX. These may be missing from the component spec's dependencies array or
+ * are simply unused.
+ *
+ * Severity: low (informational warning)
+ * Applies to: all components
+ */
+let UndefinedComponentUsageRule = class UndefinedComponentUsageRule extends BaseLintRule {
+    get Name() { return 'undefined-component-usage'; }
+    get AppliesTo() { return 'all'; }
+    Test(ast, componentName, componentSpec) {
+        const violations = [];
+        const componentsFromProps = new Set();
+        const componentsUsedInJSX = new Set();
+        let hasComponentsProp = false;
+        traverse(ast, {
+            // First, find what's destructured from the components prop
+            VariableDeclarator(path) {
+                if (t.isObjectPattern(path.node.id) && t.isIdentifier(path.node.init)) {
+                    // Check if destructuring from 'components'
+                    if (path.node.init.name === 'components') {
+                        hasComponentsProp = true;
+                        for (const prop of path.node.id.properties) {
+                            if (t.isObjectProperty(prop) && t.isIdentifier(prop.key)) {
+                                componentsFromProps.add(prop.key.name);
+                            }
+                        }
+                    }
+                }
+            },
+            // Also check object destructuring in function parameters
+            FunctionDeclaration(path) {
+                if (path.node.id && path.node.id.name === componentName && path.node.params[0]) {
+                    const param = path.node.params[0];
+                    if (t.isObjectPattern(param)) {
+                        for (const prop of param.properties) {
+                            if (t.isObjectProperty(prop) && t.isIdentifier(prop.key) && prop.key.name === 'components') {
+                                hasComponentsProp = true;
+                                // Look for nested destructuring like { components: { A, B } }
+                                if (t.isObjectPattern(prop.value)) {
+                                    for (const innerProp of prop.value.properties) {
+                                        if (t.isObjectProperty(innerProp) && t.isIdentifier(innerProp.key)) {
+                                            componentsFromProps.add(innerProp.key.name);
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            },
+            // Track JSX element usage
+            JSXElement(path) {
+                const openingElement = path.node.openingElement;
+                // Check for direct usage (e.g., <ComponentName>)
+                if (t.isJSXIdentifier(openingElement.name) && /^[A-Z]/.test(openingElement.name.name)) {
+                    const componentName = openingElement.name.name;
+                    // Only track if it's from our destructured components
+                    if (componentsFromProps.has(componentName)) {
+                        componentsUsedInJSX.add(componentName);
+                    }
+                }
+                // Also check for components.X pattern (e.g., <components.ComponentName>)
+                if (t.isJSXMemberExpression(openingElement.name)) {
+                    if (t.isJSXIdentifier(openingElement.name.object) &&
+                        openingElement.name.object.name === 'components' &&
+                        t.isJSXIdentifier(openingElement.name.property)) {
+                        const componentName = openingElement.name.property.name;
+                        // Track usage of components accessed via dot notation
+                        if (componentsFromProps.has(componentName)) {
+                            componentsUsedInJSX.add(componentName);
+                        }
+                    }
+                }
+            },
+        });
+        // Only check if we found a components prop
+        if (hasComponentsProp && componentsFromProps.size > 0) {
+            // Find components that are destructured but never used
+            const unusedComponents = Array.from(componentsFromProps).filter((comp) => !componentsUsedInJSX.has(comp));
+            if (unusedComponents.length > 0) {
+                violations.push({
+                    rule: 'undefined-component-usage',
+                    severity: 'low',
+                    line: 1,
+                    column: 0,
+                    message: `Component destructures ${unusedComponents.join(', ')} from components prop but never uses them. These may be missing from the component spec's dependencies array.`,
+                    suggestion: {
+                        text: 'Ensure all components destructured from the components prop are defined in the component spec dependencies',
+                        example: `// Component spec should include all referenced components:
+{
+  "name": "MyComponent",
+  "code": "...",
+  "dependencies": [
+    {
+      "name": "ModelTreeView",
+      "code": "function ModelTreeView({ ... }) { ... }"
+    },
+    {
+      "name": "PromptTable",
+      "code": "function PromptTable({ ... }) { ... }"
+    },
+    {
+      "name": "FilterPanel",
+      "code": "function FilterPanel({ ... }) { ... }"
+    }
+    // Add ALL components referenced in the root component
+  ]
+}
+
+// Then in your component:
+const { ModelTreeView, PromptTable, FilterPanel } = components;
+// All these will be available`,
+                    },
+                });
+            }
+        }
+        return violations;
+    }
+};
+UndefinedComponentUsageRule = __decorate([
+    RegisterClass(BaseLintRule, 'undefined-component-usage')
+], UndefinedComponentUsageRule);
+export { UndefinedComponentUsageRule };
+//# sourceMappingURL=undefined-component-usage.js.map

package/dist/runtime-rules/undefined-component-usage.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"undefined-component-usage.js","sourceRoot":"","sources":["../../src/runtime-rules/undefined-component-usage.ts"],"names":[],"mappings":"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"}

package/dist/runtime-rules/undefined-jsx-component.d.ts

@@ -0,0 +1,25 @@
+import * as t from '@babel/types';
+import { BaseLintRule } from '../lint-rule.js';
+import { Violation } from '../component-linter.js';
+import { ComponentSpec } from '@memberjunction/interactive-component-types';
+/**
+ * Rule: undefined-jsx-component
+ *
+ * DISABLED: Too many false positives - needs better dependency/library checking.
+ * Re-enable after improving to check dependencies before assuming library components.
+ *
+ * Detects JSX elements that reference undefined components, providing guidance
+ * on how to properly access library components, dependency components, etc.
+ *
+ * Severity: critical/high/medium
+ * Applies to: all components
+ *
+ * NOTE: This rule is currently commented out in the monolith. Extracted as-is for
+ * future re-enablement.
+ */
+export declare class UndefinedJsxComponentRule extends BaseLintRule {
+    get Name(): string;
+    get AppliesTo(): 'all' | 'child' | 'root';
+    Test(ast: t.File, componentName: string, componentSpec?: ComponentSpec): Violation[];
+}
+//# sourceMappingURL=undefined-jsx-component.d.ts.map

package/dist/runtime-rules/undefined-jsx-component.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"undefined-jsx-component.d.ts","sourceRoot":"","sources":["../../src/runtime-rules/undefined-jsx-component.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,CAAC,MAAM,cAAc,CAAC;AAClC,OAAO,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AAC5C,OAAO,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAC;AAChD,OAAO,EAAE,aAAa,EAAE,MAAM,6CAA6C,CAAC;AA2B5E;;;;;;;;;;;;;;GAcG;AACH,qBACa,yBAA0B,SAAQ,YAAY;IACzD,IAAI,IAAI,WAAwC;IAChD,IAAI,SAAS,IAAI,KAAK,GAAG,OAAO,GAAG,MAAM,CAAkB;IAE3D,IAAI,CAAC,GAAG,EAAE,CAAC,CAAC,IAAI,EAAE,aAAa,EAAE,MAAM,EAAE,aAAa,CAAC,EAAE,aAAa,GAAG,SAAS,EAAE;CAgOrF"}