@memberjunction/react-linter 0.0.1 → 5.38.0

package/dist/schema-validation/semantic-validators/subset-of-entity-fields-validator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"subset-of-entity-fields-validator.js","sourceRoot":"","sources":["../../../src/schema-validation/semantic-validators/subset-of-entity-fields-validator.ts"],"names":[],"mappings":"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"}

package/dist/schema-validation/semantic-validators/validation-context.d.ts

@@ -0,0 +1,335 @@
+/**
+ * Validation Context
+ *
+ * Provides all the information a semantic validator needs to perform validation.
+ * This context is passed to validators by the linter rule and includes:
+ * - AST node and path information for location tracking
+ * - Component spec for type lookups
+ * - Sibling props for dependency resolution
+ * - Entity/query metadata from data requirements
+ * - Helper methods for common validation tasks
+ */
+import * as t from '@babel/types';
+import { NodePath } from '@babel/traverse';
+import { ComponentSpec } from '@memberjunction/interactive-component-types';
+import type { SQLParserDialect } from '@memberjunction/sql-dialect';
+import { TypeInferenceEngine } from '../../type-inference-engine.js';
+import { ExtractedValue } from '../../prop-value-extractor.js';
+/**
+ * Context object passed to semantic validators
+ *
+ * Contains all information needed to validate a prop value against semantic constraints.
+ */
+export interface ValidationContext {
+    /**
+     * The AST node being validated
+     *
+     * This is typically the JSXAttribute node, but validators can traverse
+     * to child nodes for more specific location information.
+     */
+    node: t.Node;
+    /**
+     * Babel traversal path for the node
+     *
+     * Provides access to parent nodes, scope information, and AST manipulation.
+     * Validators should not modify the AST - this is read-only validation.
+     */
+    path: NodePath<any>;
+    /**
+     * Name of the component being validated
+     *
+     * Example: "DataGrid", "EntityDataGrid", "SimpleChart"
+     */
+    componentName: string;
+    /**
+     * Full component specification
+     *
+     * Provides access to:
+     * - Type definitions (for custom type validation)
+     * - Data requirements (entities, queries)
+     * - Other properties (for cross-property validation)
+     * - Dependency specs (for validating nested components)
+     */
+    componentSpec: ComponentSpec;
+    /**
+     * Name of the property being validated
+     *
+     * Example: "fields", "columns", "entityName", "extraFilter"
+     */
+    propertyName: string;
+    /**
+     * Extracted value of the property
+     *
+     * This is the result of PropValueExtractor.extract() and can be:
+     * - Primitive: string, number, boolean, null
+     * - Array: Array of extracted values
+     * - Object: Record<string, ExtractedValue>
+     * - DynamicValue: { _type: 'identifier' | 'expression', name?, description? }
+     *
+     * If the value is a DynamicValue, validators should typically skip validation
+     * and return an empty violations array (the linter will warn the user).
+     */
+    propertyValue: ExtractedValue;
+    /**
+     * Map of sibling props on the same JSX element
+     *
+     * Key is prop name, value is extracted value.
+     * Used for constraints with `dependsOn` to access related prop values.
+     *
+     * Example:
+     * ```typescript
+     * // <EntityDataGrid entityName="Members" fields={['FirstName', 'LastName']} />
+     * siblingProps.get('entityName') // => "Members"
+     * siblingProps.get('fields') // => ['FirstName', 'LastName']
+     * ```
+     */
+    siblingProps: Map<string, ExtractedValue>;
+    /**
+     * Map of entity name to entity metadata
+     *
+     * Populated from componentSpec.dataRequirements.entities
+     * Used by validators that check field names, entity references, etc.
+     *
+     * Example:
+     * ```typescript
+     * const memberEntity = entities.get('Members');
+     * const fields = memberEntity.fields; // Array of EntityFieldInfo
+     * ```
+     */
+    entities: Map<string, EntityMetadata>;
+    /**
+     * Map of query name to query metadata
+     *
+     * Populated from componentSpec.dataRequirements.queries
+     * Used by validators that check query references and parameters.
+     *
+     * Example:
+     * ```typescript
+     * const query = queries.get('Sales by Region');
+     * const params = query.parameters; // Array of QueryParameter
+     * ```
+     */
+    queries: Map<string, QueryMetadata>;
+    /**
+     * Type inference engine for checking expression types
+     *
+     * Used for advanced type checking beyond what PropValueExtractor provides.
+     * Can infer types of variables, function calls, etc.
+     */
+    typeEngine: TypeInferenceEngine;
+    /**
+     * SQL dialect for WHERE clause parsing and validation.
+     *
+     * Used by the SqlWhereClauseValidator to parse SQL with the correct syntax
+     * for the target database platform (SQL Server, PostgreSQL, etc.).
+     * If not provided, the validator falls back to SQL Server dialect.
+     */
+    dialect?: SQLParserDialect;
+    /**
+     * Get field metadata for an entity
+     *
+     * @param entityName - Name of the entity
+     * @returns Array of field info, or empty array if entity not found
+     *
+     * @example
+     * ```typescript
+     * const fields = context.getEntityFields('Members');
+     * const fieldNames = fields.map(f => f.name);
+     * ```
+     */
+    getEntityFields(entityName: string): EntityFieldInfo[];
+    /**
+     * Get the data type of a specific field on an entity
+     *
+     * @param entityName - Name of the entity
+     * @param fieldName - Name of the field
+     * @returns Data type string (e.g., 'string', 'number', 'date'), or null if not found
+     *
+     * @example
+     * ```typescript
+     * const fieldType = context.getEntityFieldType('Members', 'JoinDate');
+     * // => 'date'
+     * ```
+     */
+    getEntityFieldType(entityName: string, fieldName: string): string | null;
+    /**
+     * Find field names similar to the given field name (for suggestions)
+     *
+     * Uses fuzzy matching (Levenshtein distance or similar) to find close matches.
+     * Useful for "Did you mean?" error messages.
+     *
+     * @param fieldName - The field name to find matches for
+     * @param entityName - Name of the entity to search in
+     * @param maxResults - Maximum number of suggestions (default: 3)
+     * @returns Array of similar field names, sorted by similarity
+     *
+     * @example
+     * ```typescript
+     * const suggestions = context.findSimilarFieldNames('FristName', 'Members', 3);
+     * // => ['FirstName', 'FirstNameNormalized', 'FirstNameMasked']
+     * ```
+     */
+    findSimilarFieldNames(fieldName: string, entityName: string, maxResults?: number): string[];
+    /**
+     * Get parameter metadata for a query
+     *
+     * @param queryName - Name of the query
+     * @returns Array of parameter info, or empty array if query not found
+     *
+     * @example
+     * ```typescript
+     * const params = context.getQueryParameters('Sales by Region');
+     * const requiredParams = params.filter(p => p.required);
+     * ```
+     */
+    getQueryParameters(queryName: string): QueryParameter[];
+    /**
+     * Check if a query exists in the component's data requirements
+     *
+     * @param queryName - Name of the query to check
+     * @param categoryPath - Optional category path for disambiguation
+     * @returns True if the query exists
+     *
+     * @example
+     * ```typescript
+     * if (!context.hasQuery('Sales Report', '/Reports/Sales')) {
+     *   // Query not found
+     * }
+     * ```
+     */
+    hasQuery(queryName: string, categoryPath?: string): boolean;
+    /**
+     * Check if an entity exists in the component's data requirements
+     *
+     * @param entityName - Name of the entity to check
+     * @returns True if the entity exists
+     *
+     * @example
+     * ```typescript
+     * if (!context.hasEntity('Members')) {
+     *   // Entity not found
+     * }
+     * ```
+     */
+    hasEntity(entityName: string): boolean;
+}
+/**
+ * Entity metadata extracted from data requirements
+ */
+export interface EntityMetadata {
+    /**
+     * Entity name
+     */
+    name: string;
+    /**
+     * Entity description (if available)
+     */
+    description?: string;
+    /**
+     * Array of field metadata for this entity
+     */
+    fields: EntityFieldInfo[];
+    /**
+     * Primary key field name(s)
+     */
+    primaryKeys?: string[];
+}
+/**
+ * Field metadata for an entity
+ */
+export interface EntityFieldInfo {
+    /**
+     * Field name
+     */
+    name: string;
+    /**
+     * Data type (e.g., 'string', 'number', 'date', 'boolean')
+     */
+    type: string;
+    /**
+     * SQL data type (e.g., 'nvarchar', 'int', 'datetime', 'bit')
+     */
+    sqlType?: string;
+    /**
+     * Whether this field is required (NOT NULL)
+     */
+    required?: boolean;
+    /**
+     * Field description (if available)
+     */
+    description?: string;
+    /**
+     * Whether this is a primary key field
+     */
+    isPrimaryKey?: boolean;
+    /**
+     * If this is a foreign key, the related entity name
+     */
+    relatedEntity?: string;
+    /**
+     * Maximum length for string fields
+     */
+    maxLength?: number;
+}
+/**
+ * Query metadata extracted from data requirements
+ */
+export interface QueryMetadata {
+    /**
+     * Query name
+     */
+    name: string;
+    /**
+     * Query description (if available)
+     */
+    description?: string;
+    /**
+     * Category path for disambiguation
+     */
+    categoryPath?: string;
+    /**
+     * Array of parameter metadata for this query
+     */
+    parameters: QueryParameter[];
+    /**
+     * Expected result fields (if specified)
+     */
+    resultFields?: Array<{
+        name: string;
+        type: string;
+    }>;
+}
+/**
+ * Parameter metadata for a query
+ */
+export interface QueryParameter {
+    /**
+     * Parameter name
+     */
+    name: string;
+    /**
+     * Parameter data type
+     */
+    type: string;
+    /**
+     * SQL data type
+     */
+    sqlType?: string;
+    /**
+     * Whether this parameter is required
+     */
+    required?: boolean;
+    /**
+     * Default value if not provided
+     */
+    defaultValue?: any;
+    /**
+     * Example/test value for documentation
+     */
+    testValue?: any;
+    /**
+     * Parameter description (if available)
+     */
+    description?: string;
+}
+//# sourceMappingURL=validation-context.d.ts.map

package/dist/schema-validation/semantic-validators/validation-context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validation-context.d.ts","sourceRoot":"","sources":["../../../src/schema-validation/semantic-validators/validation-context.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,KAAK,CAAC,MAAM,cAAc,CAAC;AAClC,OAAO,EAAE,QAAQ,EAAE,MAAM,iBAAiB,CAAC;AAC3C,OAAO,EAAE,aAAa,EAAE,MAAM,6CAA6C,CAAC;AAC5E,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,6BAA6B,CAAC;AACpE,OAAO,EAAE,mBAAmB,EAAE,MAAM,6BAA6B,CAAC;AAClE,OAAO,EAAE,cAAc,EAAE,MAAM,4BAA4B,CAAC;AAE5D;;;;GAIG;AACH,MAAM,WAAW,iBAAiB;IAKhC;;;;;OAKG;IACH,IAAI,EAAE,CAAC,CAAC,IAAI,CAAC;IAEb;;;;;OAKG;IACH,IAAI,EAAE,QAAQ,CAAC,GAAG,CAAC,CAAC;IAMpB;;;;OAIG;IACH,aAAa,EAAE,MAAM,CAAC;IAEtB;;;;;;;;OAQG;IACH,aAAa,EAAE,aAAa,CAAC;IAM7B;;;;OAIG;IACH,YAAY,EAAE,MAAM,CAAC;IAErB;;;;;;;;;;;OAWG;IACH,aAAa,EAAE,cAAc,CAAC;IAE9B;;;;;;;;;;;;OAYG;IACH,YAAY,EAAE,GAAG,CAAC,MAAM,EAAE,cAAc,CAAC,CAAC;IAM1C;;;;;;;;;;;OAWG;IACH,QAAQ,EAAE,GAAG,CAAC,MAAM,EAAE,cAAc,CAAC,CAAC;IAEtC;;;;;;;;;;;OAWG;IACH,OAAO,EAAE,GAAG,CAAC,MAAM,EAAE,aAAa,CAAC,CAAC;IAMpC;;;;;OAKG;IACH,UAAU,EAAE,mBAAmB,CAAC;IAEhC;;;;;;OAMG;IACH,OAAO,CAAC,EAAE,gBAAgB,CAAC;IAM3B;;;;;;;;;;;OAWG;IACH,eAAe,CAAC,UAAU,EAAE,MAAM,GAAG,eAAe,EAAE,CAAC;IAEvD;;;;;;;;;;;;OAYG;IACH,kBAAkB,CAAC,UAAU,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAAC;IAEzE;;;;;;;;;;;;;;;;OAgBG;IACH,qBAAqB,CAAC,SAAS,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,UAAU,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;IAE5F;;;;;;;;;;;OAWG;IACH,kBAAkB,CAAC,SAAS,EAAE,MAAM,GAAG,cAAc,EAAE,CAAC;IAExD;;;;;;;;;;;;;OAaG;IACH,QAAQ,CAAC,SAAS,EAAE,MAAM,EAAE,YAAY,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC;IAE5D;;;;;;;;;;;;OAYG;IACH,SAAS,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC;CACxC;AAED;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B;;OAEG;IACH,IAAI,EAAE,MAAM,CAAC;IAEb;;OAEG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC;IAErB;;OAEG;IACH,MAAM,EAAE,eAAe,EAAE,CAAC;IAE1B;;OAEG;IACH,WAAW,CAAC,EAAE,MAAM,EAAE,CAAC;CACxB;AAED;;GAEG;AACH,MAAM,WAAW,eAAe;IAC9B;;OAEG;IACH,IAAI,EAAE,MAAM,CAAC;IAEb;;OAEG;IACH,IAAI,EAAE,MAAM,CAAC;IAEb;;OAEG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC;IAEjB;;OAEG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAC;IAEnB;;OAEG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC;IAErB;;OAEG;IACH,YAAY,CAAC,EAAE,OAAO,CAAC;IAEvB;;OAEG;IACH,aAAa,CAAC,EAAE,MAAM,CAAC;IAEvB;;OAEG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED;;GAEG;AACH,MAAM,WAAW,aAAa;IAC5B;;OAEG;IACH,IAAI,EAAE,MAAM,CAAC;IAEb;;OAEG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC;IAErB;;OAEG;IACH,YAAY,CAAC,EAAE,MAAM,CAAC;IAEtB;;OAEG;IACH,UAAU,EAAE,cAAc,EAAE,CAAC;IAE7B;;OAEG;IACH,YAAY,CAAC,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;CACtD;AAED;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B;;OAEG;IACH,IAAI,EAAE,MAAM,CAAC;IAEb;;OAEG;IACH,IAAI,EAAE,MAAM,CAAC;IAEb;;OAEG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC;IAEjB;;OAEG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAC;IAEnB;;OAEG;IACH,YAAY,CAAC,EAAE,GAAG,CAAC;IAEnB;;OAEG;IACH,SAAS,CAAC,EAAE,GAAG,CAAC;IAEhB;;OAEG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB"}

package/dist/schema-validation/semantic-validators/validation-context.js

@@ -0,0 +1,13 @@
+/**
+ * Validation Context
+ *
+ * Provides all the information a semantic validator needs to perform validation.
+ * This context is passed to validators by the linter rule and includes:
+ * - AST node and path information for location tracking
+ * - Component spec for type lookups
+ * - Sibling props for dependency resolution
+ * - Entity/query metadata from data requirements
+ * - Helper methods for common validation tasks
+ */
+export {};
+//# sourceMappingURL=validation-context.js.map

package/dist/schema-validation/semantic-validators/validation-context.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"validation-context.js","sourceRoot":"","sources":["../../../src/schema-validation/semantic-validators/validation-context.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG"}

package/dist/styles-type-analyzer.d.ts

@@ -0,0 +1,64 @@
+/**
+ * @fileoverview Analyzes the ComponentStyles TypeScript interface to validate style property access
+ * @module @memberjunction/react-test-harness
+ */
+/**
+ * Analyzes the ComponentStyles interface from @memberjunction/interactive-component-types
+ * to provide validation and suggestions for style property access
+ */
+export declare class StylesTypeAnalyzer {
+    private validPaths;
+    private propertyMap;
+    private defaultStyles;
+    constructor();
+    /**
+     * Analyzes the ComponentStyles interface to extract all valid property paths
+     */
+    private analyzeComponentStylesInterface;
+    /**
+     * Finds an interface by name in a source file
+     */
+    private findInterface;
+    /**
+     * Recursively extracts property paths from an interface
+     */
+    private extractPaths;
+    /**
+     * Extracts paths from a type node
+     */
+    private extractPathsFromType;
+    /**
+     * Adds a path to our tracking structures
+     */
+    private addPath;
+    /**
+     * Loads structure from the actual runtime default styles
+     */
+    private loadFallbackStructure;
+    /**
+     * Builds paths from a structure object
+     */
+    private buildPathsFromStructure;
+    /**
+     * Checks if a property path is valid
+     */
+    isValidPath(pathArray: string[]): boolean;
+    /**
+     * Finds all paths containing a specific property name
+     */
+    findPropertyPaths(propertyName: string): string[];
+    /**
+     * Gets suggestions for an invalid path
+     */
+    getSuggestionsForPath(invalidPath: string[]): {
+        correctPaths: string[];
+        availableAtParent: string[];
+        didYouMean: string | null;
+    };
+    /**
+     * Gets the actual default value from the runtime styles object
+     * This ensures we have a single source of truth for default values
+     */
+    getDefaultValueForPath(pathArray: string[]): string;
+}
+//# sourceMappingURL=styles-type-analyzer.d.ts.map

package/dist/styles-type-analyzer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"styles-type-analyzer.d.ts","sourceRoot":"","sources":["../src/styles-type-analyzer.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAaH;;;GAGG;AACH,qBAAa,kBAAkB;IAC7B,OAAO,CAAC,UAAU,CAAc;IAChC,OAAO,CAAC,WAAW,CAAwB;IAC3C,OAAO,CAAC,aAAa,CAAkB;;IAYvC;;OAEG;IACH,OAAO,CAAC,+BAA+B;IA0CvC;;OAEG;IACH,OAAO,CAAC,aAAa;IAerB;;OAEG;IACH,OAAO,CAAC,YAAY;IAqBpB;;OAEG;IACH,OAAO,CAAC,oBAAoB;IAa5B;;OAEG;IACH,OAAO,CAAC,OAAO;IAYf;;OAEG;IACH,OAAO,CAAC,qBAAqB;IAM7B;;OAEG;IACH,OAAO,CAAC,uBAAuB;IAa/B;;OAEG;IACH,WAAW,CAAC,SAAS,EAAE,MAAM,EAAE,GAAG,OAAO;IAMzC;;OAEG;IACH,iBAAiB,CAAC,YAAY,EAAE,MAAM,GAAG,MAAM,EAAE;IAWjD;;OAEG;IACH,qBAAqB,CAAC,WAAW,EAAE,MAAM,EAAE,GAAG;QAC5C,YAAY,EAAE,MAAM,EAAE,CAAC;QACvB,iBAAiB,EAAE,MAAM,EAAE,CAAC;QAC5B,UAAU,EAAE,MAAM,GAAG,IAAI,CAAA;KAC1B;IAgDD;;;OAGG;IACH,sBAAsB,CAAC,SAAS,EAAE,MAAM,EAAE,GAAG,MAAM;CAgCpD"}

package/dist/styles-type-analyzer.js

@@ -0,0 +1,242 @@
+/**
+ * @fileoverview Analyzes the ComponentStyles TypeScript interface to validate style property access
+ * @module @memberjunction/react-test-harness
+ */
+import * as ts from 'typescript';
+import * as path from 'path';
+import * as fs from 'fs';
+import { createRequire } from 'module';
+import { SetupStyles } from '@memberjunction/react-runtime';
+// ESM compatibility: require.resolve is not available in ESM, use createRequire
+// See: https://nodejs.org/api/module.html#modulecreaterequirefilename
+const _require = createRequire(import.meta.url);
+/**
+ * Analyzes the ComponentStyles interface from @memberjunction/interactive-component-types
+ * to provide validation and suggestions for style property access
+ */
+export class StylesTypeAnalyzer {
+    constructor() {
+        this.validPaths = new Set();
+        this.propertyMap = new Map();
+        // Get the default styles from the runtime - single source of truth
+        this.defaultStyles = SetupStyles();
+        this.analyzeComponentStylesInterface();
+    }
+    /**
+     * Analyzes the ComponentStyles interface to extract all valid property paths
+     */
+    analyzeComponentStylesInterface() {
+        try {
+            // Find the type definition file
+            const typePackagePath = _require.resolve('@memberjunction/interactive-component-types');
+            const packageDir = path.dirname(typePackagePath);
+            const typeFile = path.join(packageDir, 'src', 'runtime-types.ts');
+            // Check if file exists, if not try the dist version
+            const actualFile = fs.existsSync(typeFile)
+                ? typeFile
+                : path.join(packageDir, 'runtime-types.d.ts');
+            if (!fs.existsSync(actualFile)) {
+                // Fallback to hardcoded structure if we can't find the file
+                this.loadFallbackStructure();
+                return;
+            }
+            const sourceCode = fs.readFileSync(actualFile, 'utf-8');
+            // Create a TypeScript program to parse the file
+            const sourceFile = ts.createSourceFile(actualFile, sourceCode, ts.ScriptTarget.Latest, true);
+            // Find the ComponentStyles interface
+            const interfaceNode = this.findInterface(sourceFile, 'ComponentStyles');
+            if (interfaceNode) {
+                this.extractPaths(interfaceNode, []);
+            }
+            else {
+                // Fallback if we can't find the interface
+                this.loadFallbackStructure();
+            }
+        }
+        catch (error) {
+            console.warn('Failed to analyze ComponentStyles interface, using fallback structure:', error);
+            this.loadFallbackStructure();
+        }
+    }
+    /**
+     * Finds an interface by name in a source file
+     */
+    findInterface(sourceFile, name) {
+        let result;
+        const visit = (node) => {
+            if (ts.isInterfaceDeclaration(node) && node.name?.text === name) {
+                result = node;
+                return;
+            }
+            ts.forEachChild(node, visit);
+        };
+        visit(sourceFile);
+        return result;
+    }
+    /**
+     * Recursively extracts property paths from an interface
+     */
+    extractPaths(node, currentPath) {
+        if (ts.isInterfaceDeclaration(node) || ts.isTypeLiteralNode(node)) {
+            const members = ts.isInterfaceDeclaration(node) ? node.members : node.members;
+            members.forEach(member => {
+                if (ts.isPropertySignature(member) && member.name && ts.isIdentifier(member.name)) {
+                    const propName = member.name.text;
+                    const newPath = [...currentPath, propName];
+                    // Add this path
+                    this.addPath(newPath);
+                    // If the type is an object/interface, recurse
+                    if (member.type) {
+                        this.extractPathsFromType(member.type, newPath);
+                    }
+                }
+            });
+        }
+    }
+    /**
+     * Extracts paths from a type node
+     */
+    extractPathsFromType(typeNode, currentPath) {
+        if (ts.isTypeLiteralNode(typeNode)) {
+            this.extractPaths(typeNode, currentPath);
+        }
+        else if (ts.isUnionTypeNode(typeNode)) {
+            // For union types, we might have object literals
+            typeNode.types.forEach(type => {
+                if (ts.isTypeLiteralNode(type)) {
+                    this.extractPaths(type, currentPath);
+                }
+            });
+        }
+    }
+    /**
+     * Adds a path to our tracking structures
+     */
+    addPath(pathArray) {
+        const pathStr = pathArray.join('.');
+        this.validPaths.add(pathStr);
+        // Add to property map for quick lookup
+        const lastProp = pathArray[pathArray.length - 1];
+        if (!this.propertyMap.has(lastProp)) {
+            this.propertyMap.set(lastProp, []);
+        }
+        this.propertyMap.get(lastProp).push(pathStr);
+    }
+    /**
+     * Loads structure from the actual runtime default styles
+     */
+    loadFallbackStructure() {
+        // Use the actual default styles as the structure source
+        // We need to cast through unknown because ComponentStyles doesn't have an index signature
+        this.buildPathsFromStructure(this.defaultStyles, []);
+    }
+    /**
+     * Builds paths from a structure object
+     */
+    buildPathsFromStructure(obj, currentPath) {
+        for (const key in obj) {
+            const newPath = [...currentPath, key];
+            this.addPath(newPath);
+            const value = obj[key];
+            // Check if it's an object but not a boolean (which was being compared incorrectly)
+            if (value && typeof value === 'object') {
+                this.buildPathsFromStructure(value, newPath);
+            }
+        }
+    }
+    /**
+     * Checks if a property path is valid
+     */
+    isValidPath(pathArray) {
+        // Remove 'styles' from the beginning if present
+        const cleanPath = pathArray[0] === 'styles' ? pathArray.slice(1) : pathArray;
+        return this.validPaths.has(cleanPath.join('.'));
+    }
+    /**
+     * Finds all paths containing a specific property name
+     */
+    findPropertyPaths(propertyName) {
+        const paths = [];
+        // Look for exact matches
+        if (this.propertyMap.has(propertyName)) {
+            paths.push(...this.propertyMap.get(propertyName));
+        }
+        return paths;
+    }
+    /**
+     * Gets suggestions for an invalid path
+     */
+    getSuggestionsForPath(invalidPath) {
+        // Remove 'styles' prefix if present
+        const cleanPath = invalidPath[0] === 'styles' ? invalidPath.slice(1) : invalidPath;
+        const suggestions = {
+            correctPaths: [],
+            availableAtParent: [],
+            didYouMean: null
+        };
+        // Find where the misplaced property might exist
+        const lastProp = cleanPath[cleanPath.length - 1];
+        suggestions.correctPaths = this.findPropertyPaths(lastProp)
+            .map(p => 'styles.' + p);
+        // Get available properties at the parent level
+        if (cleanPath.length > 1) {
+            const parentPath = cleanPath.slice(0, -1).join('.');
+            this.validPaths.forEach(validPath => {
+                if (validPath.startsWith(parentPath + '.')) {
+                    const nextProp = validPath.substring(parentPath.length + 1).split('.')[0];
+                    if (nextProp && !suggestions.availableAtParent.includes(nextProp)) {
+                        suggestions.availableAtParent.push(nextProp);
+                    }
+                }
+            });
+        }
+        else {
+            // At root level, show root properties
+            this.validPaths.forEach(validPath => {
+                const rootProp = validPath.split('.')[0];
+                if (!suggestions.availableAtParent.includes(rootProp)) {
+                    suggestions.availableAtParent.push(rootProp);
+                }
+            });
+        }
+        // Generate "did you mean" suggestion
+        if (suggestions.correctPaths.length > 0) {
+            suggestions.didYouMean = suggestions.correctPaths[0];
+        }
+        return suggestions;
+    }
+    /**
+     * Gets the actual default value from the runtime styles object
+     * This ensures we have a single source of truth for default values
+     */
+    getDefaultValueForPath(pathArray) {
+        const cleanPath = pathArray[0] === 'styles' ? pathArray.slice(1) : pathArray;
+        // Navigate the actual default styles object to get the real value
+        // Cast through unknown because ComponentStyles doesn't have an index signature
+        let current = this.defaultStyles;
+        for (const prop of cleanPath) {
+            if (current && typeof current === 'object' && prop in current) {
+                current = current[prop];
+            }
+            else {
+                // Path doesn't exist in defaults, return empty string
+                return "undefined";
+            }
+        }
+        // If we found a value, return it properly quoted
+        if (current !== undefined && current !== null) {
+            // For string values, add quotes
+            if (typeof current === 'string') {
+                return `'${current}'`;
+            }
+            // For objects (intermediate paths), return undefined since we can't provide a meaningful default
+            if (typeof current === 'object') {
+                return "{}";
+            }
+            // For other primitive types, convert to string
+            return String(current);
+        }
+        return "undefined";
+    }
+}
+//# sourceMappingURL=styles-type-analyzer.js.map