Method emit_import_binding_refs

codegraph-kernel/src/tsjs/extractors.rs:971–1014

(&mut self, node: Node<'t>, from_row: u32)

    }

    fn emit_import_binding_refs(&mut self, node: Node<'t>, from_row: u32) {
        let clause = (0..node.named_child_count())
            .filter_map(|i| node.named_child(i))
            .find(|c| c.kind() == "import_clause");
        let Some(clause) = clause else { return }; // side-effect import

        let imports_kind = edge_kind_index("imports").unwrap();
        let push = |w: &mut Self, name_node: Option<Node>| {
            let Some(n) = name_node else { return };
            let name = w.text(n).to_string();
            if name.is_empty() {
                return;
            }
            w.push_ref(from_row, &name, imports_kind, n);
        };

        for i in 0..clause.named_child_count() {
            let Some(child) = clause.named_child(i) else { continue };
            match child.kind() {
                "identifier" => push(self, Some(child)),
                "named_imports" => {
                    for j in 0..child.named_child_count() {
                        let Some(spec) = child.named_child(j) else { continue };
                        if spec.kind() != "import_specifier" {
                            continue;
                        }
                        let n = spec
                            .child_by_field_name("alias")
                            .or_else(|| spec.child_by_field_name("name"))
                            .or_else(|| spec.named_child(0));
                        push(self, n);
                    }
                }
                "namespace_import" => {
                    let n = (0..child.named_child_count())
                        .filter_map(|k| child.named_child(k))
                        .find(|c| c.kind() == "identifier")
                        .or_else(|| child.named_child(0));
                    push(self, n);
                }
                _ => {}
            }
        }
    }

    pub(super) fn emit_re_export_refs(&mut self, node: Node<'t>) {
        let from_row = self.top_row();