rbtr-lang-javascript 2026.9.0.dev1__tar.gz

rbtr_lang_javascript-2026.9.0.dev1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Alejandro Giacometti
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

rbtr_lang_javascript-2026.9.0.dev1/PKG-INFO

@@ -0,0 +1,74 @@
+Metadata-Version: 2.4
+Name: rbtr-lang-javascript
+Version: 2026.9.0.dev1
+Summary: rbtr — JavaScript / TypeScript / TSX language plugin
+Keywords: code-search,code-index,tree-sitter,static-analysis,semantic-search,developer-tools,javascript,typescript
+Author: Alejandro Giacometti
+Author-email: Alejandro Giacometti <alejandro.giacometti@gmail.com>
+License-Expression: MIT
+License-File: LICENSE
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: JavaScript
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Topic :: Text Processing :: Indexing
+Classifier: Typing :: Typed
+Requires-Dist: rbtr==2026.9.0.dev1
+Requires-Dist: tree-sitter-javascript
+Requires-Dist: tree-sitter-typescript
+Requires-Python: >=3.13
+Project-URL: Homepage, https://github.com/janrito/rbtr
+Project-URL: Repository, https://github.com/janrito/rbtr
+Project-URL: Documentation, https://github.com/janrito/rbtr/tree/main/packages/rbtr-lang-javascript#readme
+Project-URL: Issues, https://github.com/janrito/rbtr/issues
+Project-URL: Changelog, https://github.com/janrito/rbtr/releases
+Description-Content-Type: text/markdown
+
+# rbtr-lang-javascript
+
+JavaScript, TypeScript, and TSX support for [rbtr]. A **default**
+plugin — installed with rbtr itself (`pip install rbtr`).
+
+[rbtr]: https://github.com/janrito/rbtr/tree/main/packages/rbtr#readme
+
+## What it ingests
+
+One plugin, three ids across two grammars: `javascript` (`.js` / `.mjs` /
+`.jsx`), `typescript` (`.ts`), and `tsx` (`.tsx`). A symbol's leading JSDoc is
+folded into its chunk content.
+
+- **Functions** — declarations, generators, and arrow functions bound to a
+  const; class/object methods (class members scoped to their class).
+- **Classes** — classes, and TypeScript interfaces, enums, type aliases, and
+  namespaces (a namespace also scopes its members).
+- **Variables** — module-level `const` / `let` (including destructuring).
+- **Re-exports** — `export * from "./c"` and `export { x } from "./b"` read
+  from another module, so they resolve as imports do. A consumer reaches a
+  symbol through them without ever naming the file that defines it.
+- **Imports** — `import`, `import type`, namespace, default, and side-effect
+  imports → import chunks with resolved module + names, for cross-file edges.
+
+## Chunks produced
+
+```js
+function greet(name) { … }        // function "greet"
+const add = (a, b) => a + b;      // function "add"
+class Button { render() {} }      // class "Button"; method "render" scope "Button"
+export const MAX = 100;           // variable "MAX"
+import { x } from "./x";          // import, metadata {module: "./x", names: "x"}
+```
+
+## Embedded / injected chunks
+
+None of its own — JavaScript/TypeScript are embedded *by* the HTML, Markdown,
+and SFC (Vue/Svelte) plugins, which delegate `<script>` blocks and fenced code
+here.
+
+## Grammar & dependencies
+
+Uses the `tree-sitter-javascript` and `tree-sitter-typescript` grammars. No
+runtime dependency on other language plugins; the test suite dev-depends on
+`rbtr-lang-css` so the sample's `styles.css` extracts and the cross-file edges
+snapshot.

rbtr_lang_javascript-2026.9.0.dev1/README.md

@@ -0,0 +1,46 @@
+# rbtr-lang-javascript
+
+JavaScript, TypeScript, and TSX support for [rbtr]. A **default**
+plugin — installed with rbtr itself (`pip install rbtr`).
+
+[rbtr]: https://github.com/janrito/rbtr/tree/main/packages/rbtr#readme
+
+## What it ingests
+
+One plugin, three ids across two grammars: `javascript` (`.js` / `.mjs` /
+`.jsx`), `typescript` (`.ts`), and `tsx` (`.tsx`). A symbol's leading JSDoc is
+folded into its chunk content.
+
+- **Functions** — declarations, generators, and arrow functions bound to a
+  const; class/object methods (class members scoped to their class).
+- **Classes** — classes, and TypeScript interfaces, enums, type aliases, and
+  namespaces (a namespace also scopes its members).
+- **Variables** — module-level `const` / `let` (including destructuring).
+- **Re-exports** — `export * from "./c"` and `export { x } from "./b"` read
+  from another module, so they resolve as imports do. A consumer reaches a
+  symbol through them without ever naming the file that defines it.
+- **Imports** — `import`, `import type`, namespace, default, and side-effect
+  imports → import chunks with resolved module + names, for cross-file edges.
+
+## Chunks produced
+
+```js
+function greet(name) { … }        // function "greet"
+const add = (a, b) => a + b;      // function "add"
+class Button { render() {} }      // class "Button"; method "render" scope "Button"
+export const MAX = 100;           // variable "MAX"
+import { x } from "./x";          // import, metadata {module: "./x", names: "x"}
+```
+
+## Embedded / injected chunks
+
+None of its own — JavaScript/TypeScript are embedded *by* the HTML, Markdown,
+and SFC (Vue/Svelte) plugins, which delegate `<script>` blocks and fenced code
+here.
+
+## Grammar & dependencies
+
+Uses the `tree-sitter-javascript` and `tree-sitter-typescript` grammars. No
+runtime dependency on other language plugins; the test suite dev-depends on
+`rbtr-lang-css` so the sample's `styles.css` extracts and the cross-file edges
+snapshot.

rbtr_lang_javascript-2026.9.0.dev1/pyproject.toml

@@ -0,0 +1,68 @@
+[build-system]
+requires = ["uv_build>=0.11.26,<1"]
+build-backend = "uv_build"
+
+[tool.uv.build-backend]
+module-name = "rbtr_lang_javascript"
+
+[tool.uv.sources.rbtr]
+workspace = true
+
+[tool.uv.sources.rbtr-lang-css]
+workspace = true
+
+[project]
+name = "rbtr-lang-javascript"
+version = "2026.9.0-dev1"
+description = "rbtr — JavaScript / TypeScript / TSX language plugin"
+readme = "README.md"
+license = "MIT"
+license-files = ["LICENSE"]
+keywords = [
+    "code-search",
+    "code-index",
+    "tree-sitter",
+    "static-analysis",
+    "semantic-search",
+    "developer-tools",
+    "javascript",
+    "typescript",
+]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "Programming Language :: JavaScript",
+    "Programming Language :: Python :: 3 :: Only",
+    "Programming Language :: Python :: 3.13",
+    "Topic :: Software Development :: Libraries",
+    "Topic :: Text Processing :: Indexing",
+    "Typing :: Typed",
+]
+requires-python = ">=3.13"
+dependencies = [
+    "rbtr==2026.9.0-dev1",
+    "tree-sitter-javascript",
+    "tree-sitter-typescript",
+]
+
+[[project.authors]]
+name = "Alejandro Giacometti"
+email = "alejandro.giacometti@gmail.com"
+
+[project.urls]
+Homepage = "https://github.com/janrito/rbtr"
+Repository = "https://github.com/janrito/rbtr"
+Documentation = "https://github.com/janrito/rbtr/tree/main/packages/rbtr-lang-javascript#readme"
+Issues = "https://github.com/janrito/rbtr/issues"
+Changelog = "https://github.com/janrito/rbtr/releases"
+
+[project.entry-points."rbtr.languages"]
+javascript = "rbtr_lang_javascript.plugin:javascript"
+typescript = "rbtr_lang_javascript.plugin:typescript"
+tsx = "rbtr_lang_javascript.plugin:tsx"
+
+[dependency-groups]
+dev = [
+    "rbtr[test]",
+    "rbtr-lang-css",
+]

rbtr_lang_javascript-2026.9.0.dev1/pyproject.toml.orig

@@ -0,0 +1,70 @@
+[build-system]
+requires = ["uv_build>=0.11.26,<1"]
+build-backend = "uv_build"
+
+[tool.uv.build-backend]
+module-name = "rbtr_lang_javascript"
+# No source-exclude: the plugin's tests, samples, and snapshots ship
+# with the wheel (they are the language's golden record), and the .scm
+# queries ship as package data.
+
+[project]
+name = "rbtr-lang-javascript"
+version = "2026.9.0-dev1"
+description = "rbtr — JavaScript / TypeScript / TSX language plugin"
+readme = "README.md"
+license = "MIT"
+license-files = ["LICENSE"]
+authors = [
+  { name = "Alejandro Giacometti", email = "alejandro.giacometti@gmail.com" },
+]
+keywords = [
+  "code-search",
+  "code-index",
+  "tree-sitter",
+  "static-analysis",
+  "semantic-search",
+  "developer-tools",
+  "javascript",
+  "typescript",
+]
+classifiers = [
+  "Development Status :: 4 - Beta",
+  "Intended Audience :: Developers",
+  "Programming Language :: JavaScript",
+  "Programming Language :: Python :: 3 :: Only",
+  "Programming Language :: Python :: 3.13",
+  "Topic :: Software Development :: Libraries",
+  "Topic :: Text Processing :: Indexing",
+  "Typing :: Typed",
+]
+requires-python = ">=3.13"
+dependencies = [
+  "rbtr==2026.9.0-dev1",
+  "tree-sitter-javascript",
+  "tree-sitter-typescript",
+]
+
+[project.urls]
+Homepage = "https://github.com/janrito/rbtr"
+Repository = "https://github.com/janrito/rbtr"
+Documentation = "https://github.com/janrito/rbtr/tree/main/packages/rbtr-lang-javascript#readme"
+Issues = "https://github.com/janrito/rbtr/issues"
+Changelog = "https://github.com/janrito/rbtr/releases"
+
+[project.entry-points."rbtr.languages"]
+# Each value resolves to the language's `LanguageRegistration` (named by its
+# id) — see the rbtr ARCHITECTURE "External plugins" note. One package, three
+# ids across two grammars.
+javascript = "rbtr_lang_javascript.plugin:javascript"
+typescript = "rbtr_lang_javascript.plugin:typescript"
+tsx = "rbtr_lang_javascript.plugin:tsx"
+
+[tool.uv.sources]
+rbtr = { workspace = true }
+# The javascript sample project includes a styles.css, so the sample test
+# needs the css plugin available to extract it and snapshot the cross edges.
+rbtr-lang-css = { workspace = true }
+
+[dependency-groups]
+dev = ["rbtr[test]", "rbtr-lang-css"]

rbtr_lang_javascript-2026.9.0.dev1/src/rbtr_lang_javascript/__init__.py

@@ -0,0 +1 @@
+"""JavaScript and TypeScript language plugin package."""

rbtr_lang_javascript-2026.9.0.dev1/src/rbtr_lang_javascript/javascript.scm

@@ -0,0 +1,4 @@
+; JS uses `identifier` for class names (TS uses `type_identifier`).
+(class_declaration
+  name: (identifier) @_cls_name) @class
+

rbtr_lang_javascript-2026.9.0.dev1/src/rbtr_lang_javascript/plugin.py

@@ -0,0 +1,190 @@
+"""JavaScript and TypeScript language plugins.
+
+Registers three languages (one per tree-sitter grammar) sharing a
+common import extractor and a shared core query (classes, functions,
+generators, variables, imports, and methods — class/object members
+including get/set accessors).  TS additionally captures interfaces,
+enums, type aliases, abstract classes, and interface/abstract method
+signatures.
+
+Extracted chunks::
+
+    function greet() {}             → function "greet", scope ""
+    const add = (a, b) => a + b;    → function "add", scope ""
+    class Service {}                → class "Service", scope ""
+
+    import { foo } from './models'
+        → import, metadata {module: "models", names: "foo", dots: "1"}
+    import React from 'react'
+        → import, metadata {module: "react", names: "React"}
+    import './styles.css'
+        → import, metadata {module: "styles", dots: "1"}
+"""
+
+from __future__ import annotations
+
+from pathlib import PurePosixPath
+from typing import TYPE_CHECKING
+
+from rbtr.domain.models import ImportMeta
+from rbtr.languages.registration import (
+    ImportResolver,
+    LanguageRegistration,
+    QueryExtraction,
+    load_query,
+    parse_path_relative,
+)
+
+if TYPE_CHECKING:
+    from tree_sitter import Node
+
+_SHARED_QUERIES = load_query(__package__, "shared") + load_query(__package__, "variables")
+_JS_QUERY = load_query(__package__, "javascript") + _SHARED_QUERIES
+_TS_QUERY = load_query(__package__, "typescript") + _SHARED_QUERIES
+
+
+# ── Import extractor (shared by JS and TS) ───────────────────────────
+
+
+def extract_import_meta(
+    resolver: ImportResolver, node: Node, captures: dict[str, list[Node]]
+) -> ImportMeta:
+    """Extract import data from a JS/TS `import_statement` node.
+
+    Reads `@_import_module` from captures, then walks the node
+    for import names (which the query can't capture because
+    they're multi-valued).  Applies `parse_path_relative` and
+    extension stripping to the module path.
+
+    Examples:
+
+        `import { foo } from './models'`:
+            module="models", names="foo", dots="1"
+
+        `import React from 'react'`:
+            module="react", names="React"
+
+        `import * as utils from '../utils'`:
+            module="utils", names="utils", dots="2"
+
+        `import './styles.css'`:
+            module="styles", dots="1"
+    """
+    meta = resolver(node, captures)
+    names: list[str] = []
+
+    # Module comes from @_import_module capture (string_fragment).
+    # Still need to parse relative paths and strip extensions.
+    raw_module = meta.module
+
+    # Import clause (no named fields — child iteration needed).
+    for child in node.children:
+        if child.type != "import_clause":
+            continue
+        for ic in child.children:
+            match ic.type:
+                case "identifier":
+                    if ic.text:
+                        names.append(ic.text.decode())
+                case "named_imports":
+                    for spec in ic.children:
+                        if spec.type == "import_specifier":
+                            sid = spec.child_by_field_name("name")
+                            if sid and sid.text:
+                                names.append(sid.text.decode())
+                case "namespace_import":
+                    for ns in ic.children:
+                        if ns.type == "identifier" and ns.text:
+                            names.append(ns.text.decode())
+                            break
+
+    if raw_module:
+        dots, cleaned = parse_path_relative(raw_module)
+        if dots:
+            meta.dots = str(dots)
+        # Strip file extensions so edges.py can match without guessing.
+        cleaned = str(PurePosixPath(cleaned).with_suffix("")) or cleaned
+        meta.module = cleaned
+
+    if names:
+        meta.names = ",".join(names)
+    return meta
+
+
+# ── Plugin ───────────────────────────────────────────────────────────
+
+
+javascript = LanguageRegistration(
+    id="javascript",
+    extensions=frozenset({".js", ".jsx", ".mjs"}),
+    grammar_module="tree_sitter_javascript",
+    extraction=QueryExtraction(
+        query=_JS_QUERY,
+        scope_types=frozenset({"class_declaration", "function_declaration"}),
+        class_scope_types=frozenset({"class_declaration"}),
+        # Both `/** */` JSDoc and `//` comments land in
+        # the grammar as a single `comment` node type.
+    ),
+    index_files=frozenset({"index.js"}),
+    import_targets=frozenset({"javascript", "css"}),
+    source_roots=("", "src"),
+    extraction_serial=6,
+)
+typescript = LanguageRegistration(
+    id="typescript",
+    extensions=frozenset({".ts"}),
+    grammar_module="tree_sitter_typescript",
+    grammar_entry="language_typescript",
+    extraction=QueryExtraction(
+        query=_TS_QUERY,
+        scope_types=frozenset(
+            {
+                "class_declaration",
+                "abstract_class_declaration",
+                "interface_declaration",
+                "function_declaration",
+                "internal_module",
+                "module",
+                "enum_declaration",
+            }
+        ),
+        class_scope_types=frozenset(
+            {"class_declaration", "abstract_class_declaration", "interface_declaration"}
+        ),
+    ),
+    index_files=frozenset({"index.ts", "index.js"}),
+    import_targets=frozenset({"typescript", "tsx", "javascript", "css"}),
+    source_roots=("", "src"),
+    extraction_serial=6,
+)
+tsx = LanguageRegistration(
+    id="tsx",
+    extensions=frozenset({".tsx"}),
+    grammar_module="tree_sitter_typescript",
+    grammar_entry="language_tsx",
+    extraction=QueryExtraction(
+        query=_TS_QUERY,
+        scope_types=frozenset(
+            {
+                "class_declaration",
+                "abstract_class_declaration",
+                "interface_declaration",
+                "function_declaration",
+                "internal_module",
+                "module",
+                "enum_declaration",
+            }
+        ),
+        class_scope_types=frozenset(
+            {"class_declaration", "abstract_class_declaration", "interface_declaration"}
+        ),
+    ),
+    index_files=frozenset({"index.tsx", "index.ts", "index.js"}),
+    import_targets=frozenset({"tsx", "typescript", "javascript", "css"}),
+    source_roots=("", "src"),
+    extraction_serial=3,
+)
+
+javascript.import_extractor(extract_import_meta)
+typescript.import_extractor(extract_import_meta)
+tsx.import_extractor(extract_import_meta)

rbtr_lang_javascript-2026.9.0.dev1/src/rbtr_lang_javascript/shared.scm

@@ -0,0 +1,29 @@
+; Shared patterns — identical across the JS and TS grammars.
+; Comments (JS/TS: single `comment` type for `//` and `/* */`, incl. JSDoc).
+(comment) @comment
+
+; method_definition covers class and object-literal members, generators,
+; and get/set accessors; inside a class it promotes to a method scoped to
+; the class, elsewhere it is a scope-less method.
+(function_declaration
+  name: (identifier) @_fn_name) @function
+
+(generator_function_declaration
+  name: (identifier) @_fn_name) @function
+
+(import_statement
+  source: (string (string_fragment) @_import_module)) @import
+
+(lexical_declaration
+  (variable_declarator
+    name: (identifier) @_fn_name
+    value: (arrow_function))) @function
+
+(method_definition
+  name: (property_identifier) @_method_name) @method
+
+; A re-export reads from another module, so it resolves as an import, and
+; it is how a symbol reaches a consumer that never names its defining
+; file.
+(export_statement
+  source: (string (string_fragment) @_import_module)) @import

rbtr_lang_javascript-2026.9.0.dev1/src/rbtr_lang_javascript/tests/__snapshots__/test_samples/test_edges_match_snapshot[javascript].json

@@ -0,0 +1,4 @@
+[
+  "javascript.js::import \"./styles.css\"; -> styles.css::.greeter [imports]",
+  "javascript.js::import { LOCALE } from \"./config.js\"; -> config.js::LOCALE [imports]"
+]

rbtr_lang_javascript-2026.9.0.dev1/src/rbtr_lang_javascript/tests/__snapshots__/test_samples/test_edges_match_snapshot[tsx].json

@@ -0,0 +1,3 @@
+[
+  "tsx.tsx::import { INITIAL_LABEL } from \"./labels\"; -> labels.ts::INITIAL_LABEL [imports]"
+]

rbtr_lang_javascript-2026.9.0.dev1/src/rbtr_lang_javascript/tests/__snapshots__/test_samples/test_edges_match_snapshot[typescript].json

@@ -0,0 +1,6 @@
+[
+  "typescript.ts::export * from \"./config\"; -> config.ts::LOCALE [imports]",
+  "typescript.ts::export { Locale } from \"./types\"; -> types.ts::Formatter [imports]",
+  "typescript.ts::import type { Formatter } from \"./types\"; -> types.ts::Formatter [imports]",
+  "typescript.ts::import { LOCALE } from \"./config\"; -> config.ts::LOCALE [imports]"
+]