crates/napi/types/node-types.ts (1)

35-47: Consider renaming the type parameter 'Map' to avoid confusion

Using 'Map' as a type parameter name may cause confusion with the built-in Map type in JavaScript and TypeScript. Renaming it to something more descriptive like 'NodeType' or 'Schema' can improve readability and maintainability.

Apply this diff to rename the type parameter:

-export type FieldTypeMeta<
-  Map extends NodeTypeSchema,
-  F extends FieldNames<Map>
-> = Map["fields"] extends Record<
+export type FieldTypeMeta<
+  NodeType extends NodeTypeSchema,
+  F extends FieldNames<NodeType>
+> = NodeType["fields"] extends Record<
     string,
     { types: ReadonlyArray<{ type: string }> }
   >
-  ? Map["fields"][F]
+  ? NodeType["fields"][F]
   : {
       required: false;
       types: [{ type: string }];
     };

crates/napi/scripts/generate-types.ts (1)

59-75: Consider fetching node types in parallel to improve performance

Currently, the generateLangNodeTypes function fetches node types sequentially, which may be time-consuming. Fetching all node types in parallel using Promise.all can significantly improve the script's performance.

Apply this diff to fetch node types in parallel:

 async function generateLangNodeTypes() {
-  for (const [lang, url] of Object.entries(languagesNodeTypesUrls)) {
-    const nodeTypesResponse = await fetch(url);
-    const nodeTypes = (await nodeTypesResponse.json()) as NodeTypeSchema[];
-    const nodeTypeMap = Object.fromEntries(
-      nodeTypes.map((node) => [node.type, node])
-    );
-    await writeFile(
-      path.join(dirname, "..", "types", `${lang}-node-types.ts`),
-      `type ${lang}NodeTypesMap = ${JSON.stringify(nodeTypeMap, null, 2)};
-
-export default ${lang}NodeTypesMap;
-`
-    );
-  }
+  await Promise.all(
+    Object.entries(languagesNodeTypesUrls).map(async ([lang, url]) => {
+      const nodeTypesResponse = await fetch(url);
+      const nodeTypes = (await nodeTypesResponse.json()) as NodeTypeSchema[];
+      const nodeTypeMap = Object.fromEntries(
+        nodeTypes.map((node) => [node.type, node])
+      );
+      await writeFile(
+        path.join(dirname, "..", "types", `${lang}-node-types.ts`),
+        `type ${lang}NodeTypesMap = ${JSON.stringify(nodeTypeMap, null, 2)};
+
+export default ${lang}NodeTypesMap;
+`
+      );
+    })
+  );
 }

crates/napi/src/sg_node.rs (2)

82-86: LGTM! Consider enhancing documentation.

The new is method provides a type-safe way to check node kinds. Consider adding an example usage in the documentation to demonstrate its benefits over direct string comparison.

Add a code example to the documentation:

  /// Check if the node is the same kind as the given `kind` string
+ /// 
+ /// # Example
+ /// ```typescript
+ /// if (node.is("FunctionDeclaration")) {
+ ///   // Handle function declaration
+ /// }
+ /// ```
  #[napi]
  pub fn is(&self, kind: String) -> bool {

---

217-217: LGTM! Consider pre-allocating vector.

The TypeScript return type Array<SgNode<M>> correctly specifies an array of matched nodes.

Consider pre-allocating the result vector to avoid reallocations:

-    let mut ret = vec![];
+    let mut ret = Vec::with_capacity(all_matches.len());

Configuration used: CodeRabbit UI
Review profile: CHILL
Plan: Pro

#!/bin/bash
# Description: Verify that NodeTypesMap has keys and is not empty.

# Search for all declarations of NodeTypesMap and ensure they have keys
rg 'export type NodeTypesMap = Record<string, NodeTypeSchema>;' -A 5

# Check usage of SgNode to ensure M extends NodeTypesMap with keys
rg 'SgNode<\s*[^,]+,\s*[^>]+>'

#!/bin/bash
# Check NodeTypeSchema definition and its fields
rg "type NodeTypeSchema" -A 10

# Check if there are any concrete implementations or usage of NodeTypesMap
rg "NodeTypesMap" -A 3

#!/bin/bash
# Description: Check for dependency conflicts and outdated packages.

# Install dependencies
yarn install

# List outdated packages
yarn outdated

# Audit for vulnerabilities
yarn audit

#!/bin/bash
# Let's examine the package.json files to understand the dependency relationships

# First, let's see the full package.json content
cat crates/napi/package.json

# Then, let's check if there are any other package.json files that might have related dependencies
fd package.json

#!/bin/bash
# Let's check the content of the main npm package.json and benches/package.json
# to see if there are any conflicting dependencies

cat npm/package.json
cat benches/package.json

# Also check if tsx or @types/node are used in the codebase
rg -l "from 'tsx'" .
rg -l "require\(['\"](tsx|@types/node)" .

#!/bin/bash
# Description: Check how the type parameter T is used in TypeScript definitions
rg -A 5 "class SgNode" crates/napi/index.d.ts

#!/bin/bash
# Let's check the full TypeScript interface to understand how T is used
rg -B 2 -A 15 "class SgNode" crates/napi/index.d.ts

# Also check if NodeTypesMap is defined in the same file
rg "type NodeTypesMap" crates/napi/index.d.ts

crates/napi/types/node-types.ts (1)

48-54: Consider adding JSDoc comments for better documentation.

The GetSafeFieldType utility type plays a crucial role in type safety. Consider adding JSDoc comments to explain its purpose and usage.

+/**
+ * Safely extracts the type of a field from the NodeTypesMap
+ * @template Map - The node types map
+ * @template K - The key type in the map
+ * @template F - The field name
+ * @template M - The field metadata
+ */
 type GetSafeFieldType<
   Map extends NodeTypesMap,
   K extends keyof Map,
   F extends FieldNames<Map[K]>,
   M extends FieldTypeMeta<Map[K], F> = FieldTypeMeta<Map[K], F>
 > = M["types"][number]["type"];

crates/napi/scripts/generate-types.ts (1)

78-257: Consider breaking down the updateIndexDts function.

The function is quite long and handles multiple responsibilities. Consider breaking it down into smaller, focused functions:

• Type parameter updates
• Method signature updates
• Import/export generation

+async function updateTypeParameters(root: any) {
+  const sgRootClass = root.find({
+    rule: createMatchClassDeclarationRule("SgRoot"),
+  });
+  return {
+    sgRootClassTypeParametersRemovalEdit: sgRootClass!
+      .field("type_parameters")
+      ?.replace(""),
+    sgRootNameEdit: sgRootClass!
+      .field("name")!
+      .replace("SgRoot<M extends NodeTypesMap = NodeTypesMap>")
+  };
+}

+async function updateMethodSignatures(root: any) {
+  const sgNodeClass = root.find({
+    rule: createMatchClassDeclarationRule("SgNode"),
+  });
+  // ... method signature updates
+}

 async function updateIndexDts() {
   const indexDtsPath = path.join(dirname, "..", "index.d.ts");
   const indexDtsSource = await readFile(indexDtsPath, "utf8");
   const sgRoot = await parseAsync(Lang.TypeScript, indexDtsSource);
   const root = sgRoot.root();
-  // ... rest of the function
+  const { sgRootClassTypeParametersRemovalEdit, sgRootNameEdit } = 
+    await updateTypeParameters(root);
+  const methodSignatureEdits = await updateMethodSignatures(root);
   // ... continue with import/export generation
 }

crates/napi/src/sg_node.rs (1)

78-78: Consider documenting TypeScript return type annotations.

The TypeScript return type annotations improve type safety, but their purpose and relationship to the type system could be better documented.

+/// Returns the string name of the node kind
+/// TypeScript: Returns the specific node type T from the NodeTypesMap
 #[napi(ts_return_type = "T")]
 pub fn kind(&self) -> String {

Also applies to: 166-166, 178-178, 217-217, 296-296, 379-379

crates/napi/index.d.ts (3)

1-25: LGTM! Consider adding JSDoc comments for the node type maps.

The imports and exports are well-organized, providing comprehensive type coverage for various languages. Consider adding JSDoc comments to document the structure and usage of these node type maps for better developer experience.

---

136-139: Excellent type safety improvements!

The generic type parameters and type-narrowing methods significantly enhance type safety and developer experience:

• M extends NodeTypesMap ensures language-specific node types
• T extends keyof M ensures valid node kinds
• is<K>() enables proper type narrowing
• Field methods now provide accurate type information

Consider adding examples in JSDoc comments to demonstrate the usage of these typed methods.

Also applies to: 145-147, 171-173

---

197-203: Consider extracting common documentation to a shared location.

The parseAsync documentation is duplicated across all language namespaces. Consider:

1. Creating a shared documentation comment that can be referenced
2. Using TSDoc's @inheritDoc tag to reduce duplication

Also applies to: 219-225, 241-247, 263-269, 285-291, 307-313

Configuration used: CodeRabbit UI
Review profile: CHILL
Plan: Pro

Configuration used: CodeRabbit UI
Review profile: CHILL
Plan: Pro

} catch (e) {
  console.error(`Error while generating node types for ${lang}:`, e);
+ process.exit(1);
}

#!/bin/bash
# Description: Check for potential test files outside __test__ directory
# that might be missed by the updated paths

# Look for potential test files outside __test__
fd -e ts -e tsx --exclude '__test__' '.*\.spec\.|.*\.test\.' .

# Look for files that might need testing based on the findInFiles usage
rg -l 'findInFiles' . --type ts --type tsx --exclude '*.spec.*' --exclude '*.test.*'

#!/bin/bash
# Let's try with correct ripgrep syntax and split into multiple commands

# Look for potential test files outside __test__
fd -e ts -e tsx --exclude '__test__' '.*\.spec\.|.*\.test\.' .

# Look for files that use findInFiles
rg -l 'findInFiles' --type ts --type tsx . | grep -v '\.spec\.' | grep -v '\.test\.'

# Check the actual test file to understand the test coverage
cat crates/napi/__test__/index.spec.ts