Pull Types For File

[jsfour]

We need to create a subclass of DependencyGraphParser here
https://github.com/octaviuslabs/walter/blob/main/src/dependency-graph-parser.ts#L49 where the build function pulls in the types (not the full code blocks) for the target file.

[jsfour]

@imwalterbot thoughts on how to go about this?

[imwalterbot]

@imwalterbot thoughts on how to go about this?

Queued for processing...

[imwalterbot]

@imwalterbot thoughts on how to go about this?

Processing this now

[imwalterbot]

Based on the provided context, you can create a subclass of DependencyGraphParser that overrides the build function to only pull in the types for the target file. Here's an example of how to create the subclass:

class TypeOnlyDependencyGraphParser extends DependencyGraphParser {
  constructor(gitHubFileUrl: string) {
    super(gitHubFileUrl);
  }

  public async build(): Promise<DepGraph<ts.SourceFile>> {
    Log.info(
      `Building type-only dependency graph for ${this.targetFile.url} excluding target`
    );
    const deps = await this.getDependencies(this.targetFile);

    for (const dep of deps.deps) {
      await this.processFileForTypes(dep);
    }
    return this.graph;
  }

  private async processFileForTypes(url: ParsedGitHubURL): Promise<void> {
    Log.info(`Processing file for types ${url.url}`);
    if (this.graph.hasNode(url.url)) {
      Log.info(`Node exists ${url.url}`);
      return;
    }

    const src = await this.getDependencies(url);
    const typeOnlySourceFile = this.extractTypeDeclarations(src.sourceFile);
    this.graph.addNode(url.url, typeOnlySourceFile);

    for (const dep of src.deps) {
      await this.processFileForTypes(dep);
      Log.info(`Adding edge ${src.url.url} -> ${dep.url}`);
      this.graph.addDependency(src.url.url, dep.url);
    }
  }

  private extractTypeDeclarations(sourceFile: ts.SourceFile): ts.SourceFile {
    // Pseudocode for extracting only type declarations from the source file
    // 1. Iterate through the nodes of the source file
    // 2. If the node is a type declaration, add it to a new source file
    // 3. Return the new source file containing only type declarations

    // Implement the actual logic for extracting type declarations here
  }
}

This subclass, TypeOnlyDependencyGraphParser, overrides the build function to use a new private function processFileForTypes which processes the file and adds only the type declarations to the dependency graph. The extractTypeDeclarations function is a placeholder for the logic to extract type declarations from the source file. You'll need to implement this logic based on your requirements.

[jsfour]

Could we use the typescript compiler in extractTypeDeclarations ?

[imwalterbot]

Could we use the typescript compiler in extractTypeDeclarations ?

Queued for processing...

[imwalterbot]

Could we use the typescript compiler in extractTypeDeclarations ?

Processing this now

[imwalterbot]

Yes, you can use the TypeScript compiler in the extractTypeDeclarations function to extract type declarations from the source file. Here's an example of how to do this:

private extractTypeDeclarations(sourceFile: ts.SourceFile): ts.SourceFile {
  const typeDeclarations: ts.Node[] = [];

  const visitNode = (node: ts.Node): void => {
    if (ts.isTypeAliasDeclaration(node) || ts.isInterfaceDeclaration(node) || ts.isEnumDeclaration(node)) {
      typeDeclarations.push(node);
    } else {
      ts.forEachChild(node, visitNode);
    }
  };

  ts.forEachChild(sourceFile, visitNode);

  // Create a new source file with only type declarations
  const typeDeclarationSourceFile = ts.updateSourceFileNode(sourceFile, typeDeclarations);

  return typeDeclarationSourceFile;
}

In this example, we define a visitNode function that checks if the current node is a type alias, interface, or enum declaration. If it is, we add it to the typeDeclarations array. We then use ts.forEachChild to recursively visit all nodes in the source file. Finally, we create a new source file with only the type declarations using ts.updateSourceFileNode.

You can then use this extractTypeDeclarations function in the TypeOnlyDependencyGraphParser subclass as described in the previous answer.

[jsfour]

What if we only waned the types that the gitHubFileUrl fiile depends on? I think you would need to modify getDependencies.

[imwalterbot]

What if we only waned the types that the gitHubFileUrl fiile depends on? I think you would need to modify getDependencies.

Queued for processing...

[imwalterbot]

What if we only waned the types that the gitHubFileUrl fiile depends on? I think you would need to modify getDependencies.

Processing this now

[imwalterbot]

If you want to modify the getDependencies function to only include the types that the gitHubFileUrl file depends on, you can do the following:

1. Traverse the sourceFile AST to find the import declarations.
2. For each import declaration, check if it imports a type.
3. If it imports a type, add it to the deps array.

Here's an example of how to modify the getDependencies function:

private async getDependencies(targetFile: ParsedGitHubURL): Promise<{
  sourceFile: ts.SourceFile;
  deps: ParsedGitHubURL[];
  url: ParsedGitHubURL;
}> {
  Log.info(`Getting dependencies for ${targetFile.url}`);
  const fileContent = await utils.getFileFromUrl(targetFile.url);

  const sourceFile = ts.createSourceFile(
    fileContent.parsedUrl.filePath,
    fileContent.body,
    ts.ScriptTarget.ES2015,
    true
  );

  const deps: ParsedGitHubURL[] = [];
  const branch = this.branch;

  sourceFile.forEachChild((node) => {
    if (ts.isImportDeclaration(node)) {
      const importPath = (node.moduleSpecifier as ts.StringLiteral).text;
      if (!importPath.startsWith(".") && !importPath.startsWith("/")) {
        Log.info(`Skipping import ${importPath}`);
        return;
      }

      // Check if the import declaration imports a type
      const importClause = node.importClause;
      if (importClause && importClause.namedBindings) {
        const namedBindings = importClause.namedBindings;
        if (ts.isNamedImports(namedBindings)) {
          for (const element of namedBindings.elements) {
            if (element.name && ts.isIdentifier(element.name)) {
              // If the imported element has a type keyword, add it to deps
              if (element.typeKeyword) {
                const imported = calculateAbsolutePath(
                  targetFile.filePath,
                  importPath + ".ts"
                );

                Log.info(`Adding import ${imported}`);
                deps.push(branch.urlForPath(imported));
              }
            }
          }
        }
      }
    }
  });

  return {
    sourceFile,
    deps,
    url: targetFile,
  };
}

This modification will ensure that the deps array only contains the types that the gitHubFileUrl file depends on. Note that this assumes the imports are using named imports. If there are other import styles, you might need to handle them accordingly.

[jsfour]

Ok summarize what we are looking to do.

[imwalterbot]

Ok summarize what we are looking to do.

Queued for processing...