@ast-grep/napi 0.32.1 → 0.32.3

package/lang/Yaml.d.ts

@@ -0,0 +1,481 @@
+// Auto-generated from tree-sitter Yaml v0.7.0
+type YamlTypes = {
+  "alias": {
+    "type": "alias",
+    "named": true,
+    "fields": {},
+    "children": {
+      "multiple": false,
+      "required": true,
+      "types": [
+        {
+          "type": "alias_name",
+          "named": true
+        }
+      ]
+    }
+  },
+  "anchor": {
+    "type": "anchor",
+    "named": true,
+    "fields": {},
+    "children": {
+      "multiple": false,
+      "required": true,
+      "types": [
+        {
+          "type": "anchor_name",
+          "named": true
+        }
+      ]
+    }
+  },
+  "block_mapping": {
+    "type": "block_mapping",
+    "named": true,
+    "fields": {},
+    "children": {
+      "multiple": true,
+      "required": true,
+      "types": [
+        {
+          "type": "block_mapping_pair",
+          "named": true
+        }
+      ]
+    }
+  },
+  "block_mapping_pair": {
+    "type": "block_mapping_pair",
+    "named": true,
+    "fields": {
+      "key": {
+        "multiple": false,
+        "required": false,
+        "types": [
+          {
+            "type": "block_node",
+            "named": true
+          },
+          {
+            "type": "flow_node",
+            "named": true
+          }
+        ]
+      },
+      "value": {
+        "multiple": false,
+        "required": false,
+        "types": [
+          {
+            "type": "block_node",
+            "named": true
+          },
+          {
+            "type": "flow_node",
+            "named": true
+          }
+        ]
+      }
+    }
+  },
+  "block_node": {
+    "type": "block_node",
+    "named": true,
+    "fields": {},
+    "children": {
+      "multiple": true,
+      "required": true,
+      "types": [
+        {
+          "type": "anchor",
+          "named": true
+        },
+        {
+          "type": "block_mapping",
+          "named": true
+        },
+        {
+          "type": "block_scalar",
+          "named": true
+        },
+        {
+          "type": "block_sequence",
+          "named": true
+        },
+        {
+          "type": "tag",
+          "named": true
+        }
+      ]
+    }
+  },
+  "block_scalar": {
+    "type": "block_scalar",
+    "named": true,
+    "fields": {}
+  },
+  "block_sequence": {
+    "type": "block_sequence",
+    "named": true,
+    "fields": {},
+    "children": {
+      "multiple": true,
+      "required": true,
+      "types": [
+        {
+          "type": "block_sequence_item",
+          "named": true
+        }
+      ]
+    }
+  },
+  "block_sequence_item": {
+    "type": "block_sequence_item",
+    "named": true,
+    "fields": {},
+    "children": {
+      "multiple": false,
+      "required": false,
+      "types": [
+        {
+          "type": "block_node",
+          "named": true
+        },
+        {
+          "type": "flow_node",
+          "named": true
+        }
+      ]
+    }
+  },
+  "document": {
+    "type": "document",
+    "named": true,
+    "fields": {},
+    "children": {
+      "multiple": true,
+      "required": false,
+      "types": [
+        {
+          "type": "block_node",
+          "named": true
+        },
+        {
+          "type": "flow_node",
+          "named": true
+        },
+        {
+          "type": "reserved_directive",
+          "named": true
+        },
+        {
+          "type": "tag_directive",
+          "named": true
+        },
+        {
+          "type": "yaml_directive",
+          "named": true
+        }
+      ]
+    }
+  },
+  "double_quote_scalar": {
+    "type": "double_quote_scalar",
+    "named": true,
+    "fields": {},
+    "children": {
+      "multiple": true,
+      "required": false,
+      "types": [
+        {
+          "type": "escape_sequence",
+          "named": true
+        }
+      ]
+    }
+  },
+  "flow_mapping": {
+    "type": "flow_mapping",
+    "named": true,
+    "fields": {},
+    "children": {
+      "multiple": true,
+      "required": false,
+      "types": [
+        {
+          "type": "flow_node",
+          "named": true
+        },
+        {
+          "type": "flow_pair",
+          "named": true
+        }
+      ]
+    }
+  },
+  "flow_node": {
+    "type": "flow_node",
+    "named": true,
+    "fields": {},
+    "children": {
+      "multiple": true,
+      "required": true,
+      "types": [
+        {
+          "type": "alias",
+          "named": true
+        },
+        {
+          "type": "anchor",
+          "named": true
+        },
+        {
+          "type": "double_quote_scalar",
+          "named": true
+        },
+        {
+          "type": "flow_mapping",
+          "named": true
+        },
+        {
+          "type": "flow_sequence",
+          "named": true
+        },
+        {
+          "type": "plain_scalar",
+          "named": true
+        },
+        {
+          "type": "single_quote_scalar",
+          "named": true
+        },
+        {
+          "type": "tag",
+          "named": true
+        }
+      ]
+    }
+  },
+  "flow_pair": {
+    "type": "flow_pair",
+    "named": true,
+    "fields": {
+      "key": {
+        "multiple": false,
+        "required": false,
+        "types": [
+          {
+            "type": "flow_node",
+            "named": true
+          }
+        ]
+      },
+      "value": {
+        "multiple": false,
+        "required": false,
+        "types": [
+          {
+            "type": "flow_node",
+            "named": true
+          }
+        ]
+      }
+    }
+  },
+  "flow_sequence": {
+    "type": "flow_sequence",
+    "named": true,
+    "fields": {},
+    "children": {
+      "multiple": true,
+      "required": false,
+      "types": [
+        {
+          "type": "flow_node",
+          "named": true
+        },
+        {
+          "type": "flow_pair",
+          "named": true
+        }
+      ]
+    }
+  },
+  "plain_scalar": {
+    "type": "plain_scalar",
+    "named": true,
+    "fields": {},
+    "children": {
+      "multiple": false,
+      "required": true,
+      "types": [
+        {
+          "type": "boolean_scalar",
+          "named": true
+        },
+        {
+          "type": "float_scalar",
+          "named": true
+        },
+        {
+          "type": "integer_scalar",
+          "named": true
+        },
+        {
+          "type": "null_scalar",
+          "named": true
+        },
+        {
+          "type": "string_scalar",
+          "named": true
+        }
+      ]
+    }
+  },
+  "reserved_directive": {
+    "type": "reserved_directive",
+    "named": true,
+    "fields": {},
+    "children": {
+      "multiple": true,
+      "required": true,
+      "types": [
+        {
+          "type": "directive_name",
+          "named": true
+        },
+        {
+          "type": "directive_parameter",
+          "named": true
+        }
+      ]
+    }
+  },
+  "single_quote_scalar": {
+    "type": "single_quote_scalar",
+    "named": true,
+    "fields": {},
+    "children": {
+      "multiple": true,
+      "required": false,
+      "types": [
+        {
+          "type": "escape_sequence",
+          "named": true
+        }
+      ]
+    }
+  },
+  "stream": {
+    "type": "stream",
+    "named": true,
+    "root": true,
+    "fields": {},
+    "children": {
+      "multiple": true,
+      "required": false,
+      "types": [
+        {
+          "type": "document",
+          "named": true
+        }
+      ]
+    }
+  },
+  "tag_directive": {
+    "type": "tag_directive",
+    "named": true,
+    "fields": {},
+    "children": {
+      "multiple": true,
+      "required": true,
+      "types": [
+        {
+          "type": "tag_handle",
+          "named": true
+        },
+        {
+          "type": "tag_prefix",
+          "named": true
+        }
+      ]
+    }
+  },
+  "yaml_directive": {
+    "type": "yaml_directive",
+    "named": true,
+    "fields": {},
+    "children": {
+      "multiple": false,
+      "required": true,
+      "types": [
+        {
+          "type": "yaml_version",
+          "named": true
+        }
+      ]
+    }
+  },
+  "alias_name": {
+    "type": "alias_name",
+    "named": true
+  },
+  "anchor_name": {
+    "type": "anchor_name",
+    "named": true
+  },
+  "boolean_scalar": {
+    "type": "boolean_scalar",
+    "named": true
+  },
+  "comment": {
+    "type": "comment",
+    "named": true
+  },
+  "directive_name": {
+    "type": "directive_name",
+    "named": true
+  },
+  "directive_parameter": {
+    "type": "directive_parameter",
+    "named": true
+  },
+  "escape_sequence": {
+    "type": "escape_sequence",
+    "named": true
+  },
+  "float_scalar": {
+    "type": "float_scalar",
+    "named": true
+  },
+  "integer_scalar": {
+    "type": "integer_scalar",
+    "named": true
+  },
+  "null_scalar": {
+    "type": "null_scalar",
+    "named": true
+  },
+  "string_scalar": {
+    "type": "string_scalar",
+    "named": true
+  },
+  "tag": {
+    "type": "tag",
+    "named": true
+  },
+  "tag_handle": {
+    "type": "tag_handle",
+    "named": true
+  },
+  "tag_prefix": {
+    "type": "tag_prefix",
+    "named": true
+  },
+  "yaml_version": {
+    "type": "yaml_version",
+    "named": true
+  }
+};
+export default YamlTypes;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ast-grep/napi",
-  "version": "0.32.1",
+  "version": "0.32.3",
   "description": "Search and Rewrite code at large scale using precise AST pattern",
   "homepage": "https://ast-grep.github.io",
   "main": "index.js",
@@ -57,7 +57,7 @@
     "@napi-rs/cli": "2.18.4",
     "@types/node": "^22.10.2",
     "ava": "6.2.0",
-    "chalk": "5.3.0",
+    "chalk": "5.4.1",
     "smol-toml": "^1.3.1",
     "ts-node": "10.9.2",
     "typescript": "5.7.2"
@@ -76,14 +76,14 @@
     }
   },
   "optionalDependencies": {
-    "@ast-grep/napi-win32-x64-msvc": "0.32.1",
-    "@ast-grep/napi-darwin-x64": "0.32.1",
-    "@ast-grep/napi-linux-x64-gnu": "0.32.1",
-    "@ast-grep/napi-win32-ia32-msvc": "0.32.1",
-    "@ast-grep/napi-darwin-arm64": "0.32.1",
-    "@ast-grep/napi-win32-arm64-msvc": "0.32.1",
-    "@ast-grep/napi-linux-arm64-gnu": "0.32.1",
-    "@ast-grep/napi-linux-arm64-musl": "0.32.1",
-    "@ast-grep/napi-linux-x64-musl": "0.32.1"
+    "@ast-grep/napi-win32-x64-msvc": "0.32.3",
+    "@ast-grep/napi-darwin-x64": "0.32.3",
+    "@ast-grep/napi-linux-x64-gnu": "0.32.3",
+    "@ast-grep/napi-win32-ia32-msvc": "0.32.3",
+    "@ast-grep/napi-darwin-arm64": "0.32.3",
+    "@ast-grep/napi-win32-arm64-msvc": "0.32.3",
+    "@ast-grep/napi-linux-arm64-gnu": "0.32.3",
+    "@ast-grep/napi-linux-arm64-musl": "0.32.3",
+    "@ast-grep/napi-linux-x64-musl": "0.32.3"
   }
 }

package/types/sgnode.d.ts

@@ -6,6 +6,9 @@ import type {
   Kinds,
   NodeFieldInfo,
   RootKind,
+  NamedKinds,
+  ChildKinds,
+  NamedChildKinds,
 } from './staticTypes'
 import type { NapiConfig } from './config'
 
@@ -36,32 +39,33 @@ export declare class SgNode<
   M extends TypesMap = TypesMap,
   out T extends Kinds<M> = Kinds<M>,
 > {
+  /** Returns the node's id */
+  id(): number
   range(): Range
   isLeaf(): boolean
   isNamed(): boolean
   isNamedLeaf(): boolean
-  /** Returns the string name of the node kind */
-  kind(): T
-  readonly kindToRefine: T
-  /** Check if the node is the same kind as the given `kind` string */
-  is<K extends Kinds<M>>(kind: K): this is SgNode<M, K>
   text(): string
   matches(m: string): boolean
   inside(m: string): boolean
   has(m: string): boolean
   precedes(m: string): boolean
   follows(m: string): boolean
-  getMatch<K extends Kinds<M>>(m: string): RefineNode<M, K> | null
+  /** Returns the string name of the node kind */
+  kind(): T
+  readonly kindToRefine: T
+  /** Check if the node is the same kind as the given `kind` string */
+  is<K extends T>(kind: K): this is SgNode<M, K>
+  // we need this override to allow string literal union
+  is(kind: string): boolean
+
+  getMatch: NodeMethod<M, [mv: string]>
   getMultipleMatches(m: string): Array<SgNode<M>>
   getTransformed(m: string): string | null
   /** Returns the node's SgRoot */
   getRoot(): SgRoot<M>
   children(): Array<SgNode<M>>
-  /** Returns the node's id */
-  id(): number
-  find<K extends Kinds<M>>(
-    matcher: string | number | NapiConfig<M>,
-  ): RefineNode<M, K> | null
+  find: NodeMethod<M, [matcher: string | number | NapiConfig<M>]>
   findAll<K extends Kinds<M>>(
     matcher: string | number | NapiConfig<M>,
   ): Array<RefineNode<M, K>>
@@ -71,12 +75,13 @@ export declare class SgNode<
   fieldChildren<F extends FieldNames<M[T]>>(
     name: F,
   ): Exclude<FieldNode<M, T, F>, null>[]
-  parent<K extends Kinds<M>>(): RefineNode<M, K> | null
-  child<K extends Kinds<M>>(nth: number): RefineNode<M, K> | null
+  parent: NodeMethod<M>
+  child(nth: number): SgNode<M, ChildKinds<M, T>> | null
+  child<K extends NamedChildKinds<M, T>>(nth: number): RefineNode<M, K> | null
   ancestors(): Array<SgNode<M>>
-  next<K extends Kinds<M>>(): RefineNode<M, K> | null
+  next: NodeMethod<M>
   nextAll(): Array<SgNode<M>>
-  prev<K extends Kinds<M>>(): RefineNode<M, K> | null
+  prev: NodeMethod<M>
   prevAll(): Array<SgNode<M>>
   replace(text: string): Edit
   commitEdits(edits: Array<Edit>): string
@@ -92,6 +97,11 @@ export declare class SgRoot<M extends TypesMap = TypesMap> {
   filename(): string
 }
 
+interface NodeMethod<M extends TypesMap, Args extends unknown[] = []> {
+  (...args: Args): SgNode<M> | null
+  <K extends NamedKinds<M>>(...args: Args): RefineNode<M, K> | null
+}
+
 /**
  * if K contains string, return general SgNode. Otherwise,
  * if K is a literal union, return a union of SgNode of each kind.

package/types/staticTypes.d.ts

@@ -48,12 +48,23 @@ export type ExtractField<
   : NodeFieldInfo
 
 // in case of empty types array, return string as fallback
-type NoNever<T, Fallback = string> = [T] extends [never] ? Fallback : T
+type NoNever<T, Fallback> = [T] extends [never] ? Fallback : T
 
 export type TypesInField<M extends TypesMap, I extends NodeFieldInfo> = NoNever<
-  ResolveType<M, I['types'][number]['type']>
+  ResolveType<M, I['types'][number]['type']>,
+  Kinds<M>
 >
 
+export type NamedChildKinds<
+  M extends TypesMap,
+  T extends Kinds<M>,
+> = M[T] extends { children: infer C extends NodeFieldInfo }
+  ? TypesInField<M, C>
+  : NamedKinds<M>
+export type ChildKinds<M extends TypesMap, T extends Kinds<M>> =
+  | NamedChildKinds<M, T>
+  | LowPriorityKey
+
 /**
  * resolve subtypes alias. see tree-sitter's reference
  * e.g. like `expression` => `binary_expression` | `unary_expression` | ...