@grafema/core 0.1.0-alpha.1

package/src/plugins/analysis/ast/visitors/ImportExportVisitor.ts

@@ -0,0 +1,259 @@
+/**
+ * ImportExportVisitor - handles import and export declarations
+ *
+ * Handles:
+ * - ImportDeclaration: import { foo } from './module'
+ * - ExportDefaultDeclaration: export default foo
+ * - ExportNamedDeclaration: export { foo, bar }
+ * - ExportAllDeclaration: export * from './module'
+ */
+
+import type {
+  ImportDeclaration,
+  ExportDefaultDeclaration,
+  ExportNamedDeclaration,
+  ExportAllDeclaration,
+  ImportSpecifier,
+  ImportDefaultSpecifier,
+  ImportNamespaceSpecifier,
+  ExportSpecifier,
+  VariableDeclaration,
+  FunctionDeclaration,
+  ClassDeclaration,
+  Identifier,
+  Node
+} from '@babel/types';
+import type { NodePath } from '@babel/traverse';
+import { ASTVisitor, type VisitorModule, type VisitorCollections, type VisitorHandlers } from './ASTVisitor.js';
+import type { VariableInfo } from './VariableVisitor.js';
+
+/**
+ * Callback type for extracting variable names from patterns
+ */
+export type ExtractVariableNamesCallback = (pattern: Node) => VariableInfo[];
+
+/**
+ * Import specifier info
+ */
+interface ImportSpecifierInfo {
+  imported: string;
+  local: string;
+}
+
+/**
+ * Import info
+ */
+interface ImportInfo {
+  source: string;
+  specifiers: ImportSpecifierInfo[];
+  line: number;
+}
+
+/**
+ * Export specifier info
+ */
+interface ExportSpecifierInfo {
+  exported: string;
+  local: string;
+}
+
+/**
+ * Export info
+ */
+interface ExportInfo {
+  type: 'default' | 'named' | 'all';
+  line: number;
+  declaration?: Node;
+  specifiers?: ExportSpecifierInfo[];
+  source?: string;
+  name?: string;
+}
+
+export class ImportExportVisitor extends ASTVisitor {
+  private extractVariableNamesFromPattern: ExtractVariableNamesCallback;
+
+  /**
+   * @param module - Current module being analyzed
+   * @param collections - Must contain 'imports' and 'exports' arrays
+   * @param extractVariableNamesFromPattern - Helper from JSASTAnalyzer
+   */
+  constructor(
+    module: VisitorModule,
+    collections: VisitorCollections,
+    extractVariableNamesFromPattern: ExtractVariableNamesCallback
+  ) {
+    super(module, collections);
+    this.extractVariableNamesFromPattern = extractVariableNamesFromPattern;
+  }
+
+  getImportHandlers(): VisitorHandlers {
+    const { imports } = this.collections;
+
+    return {
+      ImportDeclaration: (path: NodePath) => {
+        const node = path.node as ImportDeclaration;
+        const source = node.source.value;
+
+        // Collect imported names
+        const specifiers: ImportSpecifierInfo[] = [];
+        node.specifiers.forEach((spec) => {
+          if (spec.type === 'ImportSpecifier') {
+            // import { foo, bar } from './module'
+            const importSpec = spec as ImportSpecifier;
+            const importedName = importSpec.imported.type === 'Identifier'
+              ? importSpec.imported.name
+              : importSpec.imported.value;
+            specifiers.push({
+              imported: importedName,
+              local: importSpec.local.name
+            });
+          } else if (spec.type === 'ImportDefaultSpecifier') {
+            // import foo from './module'
+            const defaultSpec = spec as ImportDefaultSpecifier;
+            specifiers.push({
+              imported: 'default',
+              local: defaultSpec.local.name
+            });
+          } else if (spec.type === 'ImportNamespaceSpecifier') {
+            // import * as foo from './module'
+            const namespaceSpec = spec as ImportNamespaceSpecifier;
+            specifiers.push({
+              imported: '*',
+              local: namespaceSpec.local.name
+            });
+          }
+        });
+
+        (imports as ImportInfo[]).push({
+          source,
+          specifiers,
+          line: node.loc!.start.line
+        });
+      }
+    };
+  }
+
+  getExportHandlers(): VisitorHandlers {
+    const { exports } = this.collections;
+    const extractVariableNamesFromPattern = this.extractVariableNamesFromPattern;
+
+    return {
+      ExportDefaultDeclaration: (path: NodePath) => {
+        const node = path.node as ExportDefaultDeclaration;
+
+        (exports as ExportInfo[]).push({
+          type: 'default',
+          line: node.loc!.start.line,
+          declaration: node.declaration
+        });
+      },
+
+      ExportNamedDeclaration: (path: NodePath) => {
+        const node = path.node as ExportNamedDeclaration;
+
+        // export { foo, bar } from './module'
+        if (node.source) {
+          const specifiers: ExportSpecifierInfo[] = node.specifiers.map((spec) => {
+            const exportSpec = spec as ExportSpecifier;
+            const exportedName = exportSpec.exported.type === 'Identifier'
+              ? exportSpec.exported.name
+              : exportSpec.exported.value;
+            const localName = exportSpec.local.type === 'Identifier'
+              ? exportSpec.local.name
+              : exportedName;
+            return {
+              exported: exportedName,
+              local: localName
+            };
+          });
+
+          (exports as ExportInfo[]).push({
+            type: 'named',
+            line: node.loc!.start.line,
+            specifiers,
+            source: node.source.value
+          });
+        }
+        // export { foo, bar }
+        else if (node.specifiers.length > 0) {
+          const specifiers: ExportSpecifierInfo[] = node.specifiers.map((spec) => {
+            const exportSpec = spec as ExportSpecifier;
+            const exportedName = exportSpec.exported.type === 'Identifier'
+              ? exportSpec.exported.name
+              : exportSpec.exported.value;
+            return {
+              exported: exportedName,
+              local: exportSpec.local.name
+            };
+          });
+
+          (exports as ExportInfo[]).push({
+            type: 'named',
+            line: node.loc!.start.line,
+            specifiers
+          });
+        }
+        // export const foo = 42 or export function bar() {}
+        else if (node.declaration) {
+          const declaration = node.declaration;
+
+          // export function foo() {}
+          if (declaration.type === 'FunctionDeclaration') {
+            const funcDecl = declaration as FunctionDeclaration;
+            if (funcDecl.id) {
+              (exports as ExportInfo[]).push({
+                type: 'named',
+                line: node.loc!.start.line,
+                name: funcDecl.id.name
+              });
+            }
+          }
+          // export const foo = 42, bar = 43
+          else if (declaration.type === 'VariableDeclaration') {
+            const varDecl = declaration as VariableDeclaration;
+            varDecl.declarations.forEach((declarator) => {
+              // Handle destructuring: export const { a, b } = obj
+              const variables = extractVariableNamesFromPattern(declarator.id);
+              variables.forEach((varInfo: VariableInfo) => {
+                (exports as ExportInfo[]).push({
+                  type: 'named',
+                  line: node.loc!.start.line,
+                  name: varInfo.name
+                });
+              });
+            });
+          }
+          // export class Foo {}
+          else if (declaration.type === 'ClassDeclaration') {
+            const classDecl = declaration as ClassDeclaration;
+            if (classDecl.id) {
+              (exports as ExportInfo[]).push({
+                type: 'named',
+                line: node.loc!.start.line,
+                name: classDecl.id.name
+              });
+            }
+          }
+        }
+      },
+
+      ExportAllDeclaration: (path: NodePath) => {
+        const node = path.node as ExportAllDeclaration;
+
+        // export * from './module'
+        (exports as ExportInfo[]).push({
+          type: 'all',
+          line: node.loc!.start.line,
+          source: node.source.value
+        });
+      }
+    };
+  }
+
+  getHandlers(): VisitorHandlers {
+    return {
+      ...this.getImportHandlers(),
+      ...this.getExportHandlers()
+    };
+  }
+}

package/src/plugins/analysis/ast/visitors/TypeScriptVisitor.ts

@@ -0,0 +1,235 @@
+/**
+ * TypeScriptVisitor - handles TypeScript-specific AST nodes
+ *
+ * Handles:
+ * - TSInterfaceDeclaration
+ * - TSTypeAliasDeclaration
+ * - TSEnumDeclaration
+ */
+
+import type {
+  TSInterfaceDeclaration,
+  TSTypeAliasDeclaration,
+  TSEnumDeclaration,
+  TSPropertySignature,
+  TSMethodSignature,
+  Identifier,
+  Expression,
+  TSExpressionWithTypeArguments
+} from '@babel/types';
+import type { NodePath } from '@babel/traverse';
+import { ASTVisitor, type VisitorModule, type VisitorCollections, type VisitorHandlers } from './ASTVisitor.js';
+import type {
+  InterfaceDeclarationInfo,
+  InterfacePropertyInfo,
+  TypeAliasInfo,
+  EnumDeclarationInfo,
+  EnumMemberInfo
+} from '../types.js';
+
+/**
+ * Extracts a string representation of a TypeScript type node
+ */
+function typeNodeToString(node: unknown): string {
+  if (!node || typeof node !== 'object') return 'unknown';
+
+  const typeNode = node as { type: string; [key: string]: unknown };
+
+  switch (typeNode.type) {
+    case 'TSStringKeyword':
+      return 'string';
+    case 'TSNumberKeyword':
+      return 'number';
+    case 'TSBooleanKeyword':
+      return 'boolean';
+    case 'TSAnyKeyword':
+      return 'any';
+    case 'TSUnknownKeyword':
+      return 'unknown';
+    case 'TSVoidKeyword':
+      return 'void';
+    case 'TSNullKeyword':
+      return 'null';
+    case 'TSUndefinedKeyword':
+      return 'undefined';
+    case 'TSNeverKeyword':
+      return 'never';
+    case 'TSObjectKeyword':
+      return 'object';
+    case 'TSSymbolKeyword':
+      return 'symbol';
+    case 'TSBigIntKeyword':
+      return 'bigint';
+    case 'TSTypeReference':
+      const typeName = typeNode.typeName as { type: string; name?: string };
+      if (typeName?.type === 'Identifier') {
+        return typeName.name || 'unknown';
+      }
+      return 'unknown';
+    case 'TSArrayType':
+      return `${typeNodeToString(typeNode.elementType)}[]`;
+    case 'TSUnionType':
+      const unionTypes = typeNode.types as unknown[];
+      return unionTypes.map(t => typeNodeToString(t)).join(' | ');
+    case 'TSIntersectionType':
+      const intersectionTypes = typeNode.types as unknown[];
+      return intersectionTypes.map(t => typeNodeToString(t)).join(' & ');
+    case 'TSLiteralType':
+      const literal = typeNode.literal as { value?: unknown; type: string };
+      if (literal?.type === 'StringLiteral') {
+        return `'${literal.value}'`;
+      } else if (literal?.type === 'NumericLiteral') {
+        return String(literal.value);
+      } else if (literal?.type === 'BooleanLiteral') {
+        return String(literal.value);
+      }
+      return 'unknown';
+    case 'TSFunctionType':
+      return 'function';
+    case 'TSTupleType':
+      const tupleTypes = typeNode.elementTypes as unknown[];
+      return `[${tupleTypes.map(t => typeNodeToString(t)).join(', ')}]`;
+    case 'TSTypeLiteral':
+      return 'object';
+    default:
+      return 'unknown';
+  }
+}
+
+export class TypeScriptVisitor extends ASTVisitor {
+  constructor(module: VisitorModule, collections: VisitorCollections) {
+    super(module, collections);
+  }
+
+  getHandlers(): VisitorHandlers {
+    const { module } = this;
+    const {
+      interfaces,
+      typeAliases,
+      enums
+    } = this.collections;
+
+    return {
+      TSInterfaceDeclaration: (path: NodePath) => {
+        const node = path.node as TSInterfaceDeclaration;
+        if (!node.id) return;
+
+        const interfaceName = node.id.name;
+        const interfaceId = `INTERFACE#${interfaceName}#${module.file}#${node.loc!.start.line}`;
+
+        // Extract extends
+        const extendsNames: string[] = [];
+        if (node.extends && node.extends.length > 0) {
+          for (const ext of node.extends) {
+            if (ext.expression.type === 'Identifier') {
+              extendsNames.push((ext.expression as Identifier).name);
+            }
+          }
+        }
+
+        // Extract properties
+        const properties: InterfacePropertyInfo[] = [];
+        if (node.body && node.body.body) {
+          for (const member of node.body.body) {
+            if (member.type === 'TSPropertySignature') {
+              const prop = member as TSPropertySignature;
+              if (prop.key.type === 'Identifier') {
+                properties.push({
+                  name: (prop.key as Identifier).name,
+                  type: prop.typeAnnotation ? typeNodeToString(prop.typeAnnotation.typeAnnotation) : undefined,
+                  optional: prop.optional || false,
+                  readonly: prop.readonly || false
+                });
+              }
+            } else if (member.type === 'TSMethodSignature') {
+              const method = member as TSMethodSignature;
+              if (method.key.type === 'Identifier') {
+                properties.push({
+                  name: (method.key as Identifier).name,
+                  type: 'function',
+                  optional: method.optional || false,
+                  readonly: false
+                });
+              }
+            }
+          }
+        }
+
+        (interfaces as InterfaceDeclarationInfo[]).push({
+          id: interfaceId,
+          type: 'INTERFACE',
+          name: interfaceName,
+          file: module.file,
+          line: node.loc!.start.line,
+          column: node.loc!.start.column,
+          extends: extendsNames.length > 0 ? extendsNames : undefined,
+          properties
+        });
+      },
+
+      TSTypeAliasDeclaration: (path: NodePath) => {
+        const node = path.node as TSTypeAliasDeclaration;
+        if (!node.id) return;
+
+        const typeName = node.id.name;
+        const typeId = `TYPE#${typeName}#${module.file}#${node.loc!.start.line}`;
+
+        // Extract the type being aliased
+        const aliasOf = typeNodeToString(node.typeAnnotation);
+
+        (typeAliases as TypeAliasInfo[]).push({
+          id: typeId,
+          type: 'TYPE',
+          name: typeName,
+          file: module.file,
+          line: node.loc!.start.line,
+          column: node.loc!.start.column,
+          aliasOf
+        });
+      },
+
+      TSEnumDeclaration: (path: NodePath) => {
+        const node = path.node as TSEnumDeclaration;
+        if (!node.id) return;
+
+        const enumName = node.id.name;
+        const enumId = `ENUM#${enumName}#${module.file}#${node.loc!.start.line}`;
+
+        // Extract members
+        const members: EnumMemberInfo[] = [];
+        if (node.members) {
+          for (const member of node.members) {
+            if (member.id.type === 'Identifier') {
+              const memberInfo: EnumMemberInfo = {
+                name: (member.id as Identifier).name
+              };
+
+              // Extract value if present
+              if (member.initializer) {
+                const init = member.initializer as Expression;
+                if (init.type === 'StringLiteral') {
+                  memberInfo.value = (init as { value: string }).value;
+                } else if (init.type === 'NumericLiteral') {
+                  memberInfo.value = (init as { value: number }).value;
+                }
+              }
+
+              members.push(memberInfo);
+            }
+          }
+        }
+
+        (enums as EnumDeclarationInfo[]).push({
+          id: enumId,
+          type: 'ENUM',
+          name: enumName,
+          file: module.file,
+          line: node.loc!.start.line,
+          column: node.loc!.start.column,
+          isConst: node.const || false,
+          members
+        });
+      }
+    };
+  }
+}