ts-gen 0.1.0

Generate wasm-bindgen Rust bindings from TypeScript .d.ts files
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122

//! Detection and execution of the `declare var` + `interface` merge pattern.

use oxc_ast::ast::*;

use crate::ir::*;
use crate::parse::docs::DocComments;
use crate::parse::members::property_key_name;
use crate::parse::types::{convert_formal_params, convert_ts_type, convert_type_params};
use crate::util::diagnostics::DiagnosticCollector;
use crate::util::naming::to_snake_case;

/// Check if a variable declarator looks like a class constructor pattern.
/// Returns true if the type annotation is a type literal containing `prototype` and/or `new`.
pub fn is_class_constructor_var(declarator: &VariableDeclarator<'_>) -> bool {
    // In oxc 0.118, type_annotation is directly on VariableDeclarator
    if let Some(type_ann) = &declarator.type_annotation {
        if let TSType::TSTypeLiteral(lit) = &type_ann.type_annotation {
            let has_prototype = lit.members.iter().any(|m| {
                if let TSSignature::TSPropertySignature(prop) = m {
                    property_key_name(&prop.key)
                        .map(|n| n == "prototype")
                        .unwrap_or(false)
                } else {
                    false
                }
            });
            let has_new = lit
                .members
                .iter()
                .any(|m| matches!(m, TSSignature::TSConstructSignatureDeclaration(_)));
            return has_prototype || has_new;
        }
    }
    false
}

/// Extract the name from a variable declarator.
/// In oxc 0.118, BindingPattern is an enum directly.
pub fn var_declarator_name(declarator: &VariableDeclarator<'_>) -> Option<String> {
    match &declarator.id {
        BindingPattern::BindingIdentifier(ident) => Some(ident.name.to_string()),
        _ => None,
    }
}

/// Extract constructor, static methods, and static properties from a type literal.
pub fn extract_var_members(
    type_literal: &TSTypeLiteral<'_>,
    docs: &DocComments<'_>,
    diag: &mut DiagnosticCollector,
) -> (Option<ConstructorMember>, Vec<Member>) {
    let mut constructor = None;
    let mut static_members = Vec::new();

    for member in &type_literal.members {
        match member {
            TSSignature::TSConstructSignatureDeclaration(ctor) => {
                let params = convert_formal_params(&ctor.params, diag);
                let doc = docs.for_span(ctor.span.start);
                constructor = Some(ConstructorMember { params, doc });
            }
            TSSignature::TSPropertySignature(prop) => {
                let js_name = match property_key_name(&prop.key) {
                    Some(name) => name,
                    None => continue,
                };
                if js_name == "prototype" {
                    continue;
                }
                let doc = docs.for_span(prop.span.start);
                let type_ref = prop
                    .type_annotation
                    .as_ref()
                    .map(|ann| convert_ts_type(&ann.type_annotation, diag))
                    .unwrap_or(TypeRef::Any);
                static_members.push(Member::StaticGetter(StaticGetterMember {
                    js_name: js_name.clone(),
                    type_ref: type_ref.clone(),
                    doc,
                }));
                if !prop.readonly {
                    static_members.push(Member::StaticSetter(StaticSetterMember {
                        js_name,
                        type_ref,
                        doc: None,
                    }));
                }
            }
            TSSignature::TSMethodSignature(method) => {
                let js_name = match property_key_name(&method.key) {
                    Some(name) => name,
                    None => continue,
                };
                let doc = docs.for_span(method.span.start);
                let name = to_snake_case(&js_name);
                let type_params = convert_type_params(method.type_parameters.as_ref(), diag);
                let params = convert_formal_params(&method.params, diag);
                let return_type = method
                    .return_type
                    .as_ref()
                    .map(|rt| convert_ts_type(&rt.type_annotation, diag))
                    .unwrap_or(TypeRef::Void);
                static_members.push(Member::StaticMethod(StaticMethodMember {
                    name,
                    js_name,
                    type_params,
                    params,
                    return_type,
                    doc,
                }));
            }
            TSSignature::TSCallSignatureDeclaration(_) => {
                diag.warn("Call signatures in declare var type literal are not supported");
            }
            TSSignature::TSIndexSignature(_) => {
                diag.warn("Index signatures in declare var type literal are not supported");
            }
        }
    }

    (constructor, static_members)
}