use super::*;
#[test]
fn regex_suffix_with_caret_anchor() {
assert_eq!(
regex_pattern_to_suffix(r"^\.vue$"),
Some(".vue".to_string())
);
assert_eq!(
regex_pattern_to_suffix(r"^\.json$"),
Some(".json".to_string())
);
}
#[test]
fn regex_suffix_with_dotstar_anchor() {
assert_eq!(
regex_pattern_to_suffix(r".*\.css$"),
Some(".css".to_string())
);
}
#[test]
fn regex_suffix_with_both_anchors() {
assert_eq!(
regex_pattern_to_suffix(r"^.*\.ts$"),
Some(".ts".to_string())
);
}
#[test]
fn regex_suffix_single_char_optional_returns_none() {
assert_eq!(regex_pattern_to_suffix(r"\.x?$"), None);
}
#[test]
fn regex_suffix_two_char_optional() {
assert_eq!(
regex_pattern_to_suffix(r"\.ts?$"),
Some(".{t,ts}".to_string())
);
}
#[test]
fn regex_suffix_no_dollar_sign_returns_none() {
assert_eq!(regex_pattern_to_suffix(r"\.vue"), None);
}
#[test]
fn regex_suffix_no_escaped_dot_returns_none() {
assert_eq!(regex_pattern_to_suffix(r"vue$"), None);
}
#[test]
fn regex_suffix_empty_alternation_returns_none() {
assert_eq!(regex_pattern_to_suffix(r"\.()$"), None);
}
#[test]
fn regex_suffix_alternation_with_special_chars_returns_none() {
assert_eq!(regex_pattern_to_suffix(r"\.(j.s|ts)$"), None);
}
#[test]
fn regex_suffix_complex_wildcard_returns_none() {
assert_eq!(regex_pattern_to_suffix(r"\..+$"), None);
assert_eq!(regex_pattern_to_suffix(r"\.[a-z]+$"), None);
}
#[test]
fn builtin_constructors_recognized() {
assert!(is_builtin_constructor("Array"));
assert!(is_builtin_constructor("Map"));
assert!(is_builtin_constructor("Set"));
assert!(is_builtin_constructor("WeakMap"));
assert!(is_builtin_constructor("WeakSet"));
assert!(is_builtin_constructor("Promise"));
assert!(is_builtin_constructor("URL"));
assert!(is_builtin_constructor("URLSearchParams"));
assert!(is_builtin_constructor("RegExp"));
assert!(is_builtin_constructor("Date"));
assert!(is_builtin_constructor("Error"));
assert!(is_builtin_constructor("TypeError"));
assert!(is_builtin_constructor("Request"));
assert!(is_builtin_constructor("Response"));
assert!(is_builtin_constructor("Headers"));
assert!(is_builtin_constructor("FormData"));
assert!(is_builtin_constructor("Blob"));
assert!(is_builtin_constructor("AbortController"));
assert!(is_builtin_constructor("ReadableStream"));
assert!(is_builtin_constructor("WritableStream"));
assert!(is_builtin_constructor("TransformStream"));
assert!(is_builtin_constructor("TextEncoder"));
assert!(is_builtin_constructor("TextDecoder"));
assert!(is_builtin_constructor("Worker"));
assert!(is_builtin_constructor("WebSocket"));
assert!(is_builtin_constructor("EventEmitter"));
assert!(is_builtin_constructor("Buffer"));
assert!(is_builtin_constructor("MutationObserver"));
assert!(is_builtin_constructor("IntersectionObserver"));
assert!(is_builtin_constructor("ResizeObserver"));
assert!(is_builtin_constructor("MessageChannel"));
assert!(is_builtin_constructor("BroadcastChannel"));
}
#[test]
fn user_defined_classes_not_builtin() {
assert!(!is_builtin_constructor("MyService"));
assert!(!is_builtin_constructor("UserRepository"));
assert!(!is_builtin_constructor("AppController"));
assert!(!is_builtin_constructor("DatabaseConnection"));
assert!(!is_builtin_constructor("Logger"));
assert!(!is_builtin_constructor("Config"));
assert!(!is_builtin_constructor(""));
}
#[test]
fn builtin_names_are_case_sensitive() {
assert!(!is_builtin_constructor("array"));
assert!(!is_builtin_constructor("map"));
assert!(!is_builtin_constructor("url"));
assert!(!is_builtin_constructor("MAP"));
assert!(!is_builtin_constructor("ARRAY"));
}
#[test]
fn valid_member_identifier_accepts_simple_idents() {
assert!(is_valid_member_identifier("foo"));
assert!(is_valid_member_identifier("_bar"));
assert!(is_valid_member_identifier("$baz"));
assert!(is_valid_member_identifier("myColor"));
}
#[test]
fn valid_member_identifier_rejects_empty_string() {
assert!(!is_valid_member_identifier(""));
}
#[test]
fn valid_member_identifier_rejects_js_globals() {
assert!(!is_valid_member_identifier("true"));
assert!(!is_valid_member_identifier("false"));
assert!(!is_valid_member_identifier("null"));
assert!(!is_valid_member_identifier("undefined"));
assert!(!is_valid_member_identifier("this"));
assert!(!is_valid_member_identifier("event"));
assert!(!is_valid_member_identifier("window"));
assert!(!is_valid_member_identifier("document"));
assert!(!is_valid_member_identifier("console"));
assert!(!is_valid_member_identifier("Math"));
assert!(!is_valid_member_identifier("JSON"));
assert!(!is_valid_member_identifier("Object"));
assert!(!is_valid_member_identifier("Array"));
assert!(!is_valid_member_identifier("String"));
assert!(!is_valid_member_identifier("Number"));
assert!(!is_valid_member_identifier("Boolean"));
assert!(!is_valid_member_identifier("Date"));
assert!(!is_valid_member_identifier("RegExp"));
assert!(!is_valid_member_identifier("Error"));
assert!(!is_valid_member_identifier("Promise"));
}
#[test]
fn host_expr_extracts_bare_identifier() {
let mut refs = Vec::new();
extract_identifiers_from_host_expr("color", &mut refs);
assert_eq!(refs, vec!["color".to_string()]);
}
#[test]
fn host_expr_skips_member_tail() {
let mut refs = Vec::new();
extract_identifiers_from_host_expr("foo.bar", &mut refs);
assert_eq!(refs, vec!["foo".to_string()]);
}
#[test]
fn host_expr_skips_string_literal_contents() {
let mut refs = Vec::new();
extract_identifiers_from_host_expr(r#""mat-" + color"#, &mut refs);
assert!(
refs.contains(&"color".to_string()),
"should credit `color`; refs={refs:?}"
);
assert!(
!refs.iter().any(|r| r == "mat"),
"string content must not be credited; refs={refs:?}"
);
}
#[test]
fn host_expr_skips_single_quote_string_contents() {
let mut refs = Vec::new();
extract_identifiers_from_host_expr("'primary' || fallback", &mut refs);
assert_eq!(refs, vec!["fallback".to_string()]);
}
#[test]
fn host_expr_skips_backtick_string_contents() {
let mut refs = Vec::new();
extract_identifiers_from_host_expr("`static` || value", &mut refs);
assert_eq!(refs, vec!["value".to_string()]);
}
#[test]
fn host_expr_deduplicates_same_identifier() {
let mut refs = Vec::new();
extract_identifiers_from_host_expr("color || color", &mut refs);
assert_eq!(refs.len(), 1);
assert_eq!(refs[0], "color");
}
#[test]
fn host_expr_skips_js_global_identifiers() {
let mut refs = Vec::new();
extract_identifiers_from_host_expr("true || false || myFlag", &mut refs);
assert!(!refs.contains(&"true".to_string()));
assert!(!refs.contains(&"false".to_string()));
assert!(refs.contains(&"myFlag".to_string()));
}
#[test]
fn host_expr_handles_empty_string() {
let mut refs = Vec::new();
extract_identifiers_from_host_expr("", &mut refs);
assert!(refs.is_empty());
}
#[test]
fn host_expr_complex_expression_credits_roots() {
let mut refs = Vec::new();
extract_identifiers_from_host_expr(r#""mat-" + (color || "primary")"#, &mut refs);
assert!(refs.contains(&"color".to_string()), "refs={refs:?}");
}
#[test]
fn regex_suffix_alternation_valid_extensions() {
assert_eq!(
regex_pattern_to_suffix(r"\.(js|ts)$"),
Some(".{js,ts}".to_string())
);
assert_eq!(
regex_pattern_to_suffix(r"\.(jsx|tsx|js|ts)$"),
Some(".{jsx,tsx,js,ts}".to_string())
);
}
#[test]
fn regex_suffix_alternation_empty_arm_returns_none() {
assert_eq!(regex_pattern_to_suffix(r"\.(|ts)$"), None);
}
#[test]
fn regex_suffix_plain_alphanumeric_ext() {
assert_eq!(regex_pattern_to_suffix(r"\.vue$"), Some(".vue".to_string()));
}
#[test]
fn regex_suffix_optional_with_empty_base_returns_none() {
assert_eq!(regex_pattern_to_suffix(r"\.t?$"), None);
}
#[test]
fn regex_suffix_optional_with_non_alphanumeric_returns_none() {
assert_eq!(regex_pattern_to_suffix(r"\.-?$"), None);
}
#[test]
fn regex_suffix_with_non_alphanumeric_tail_returns_none() {
assert_eq!(regex_pattern_to_suffix(r"\.-js$"), None);
}
#[test]
fn host_expr_operator_breaks_member_tail_chain() {
let mut refs = Vec::new();
extract_identifiers_from_host_expr("a.b + c", &mut refs);
assert!(refs.contains(&"a".to_string()), "refs={refs:?}");
assert!(refs.contains(&"c".to_string()), "refs={refs:?}");
assert!(
!refs.contains(&"b".to_string()),
"b is member tail; refs={refs:?}"
);
}
#[test]
fn has_angular_class_decorator_via_module_info() {
let info = crate::tests::parse_ts(
r"
@Component({ selector: 'app-foo', template: '<p>foo</p>' })
export class FooComponent {
myProp: string = '';
}
",
);
let export = info
.exports
.iter()
.find(|e| e.name.matches_str("FooComponent"));
assert!(export.is_some(), "FooComponent should be exported");
}
#[test]
fn extract_class_members_includes_public_methods_and_properties() {
let info = crate::tests::parse_ts(
r"
export class MyClass {
public name: string = '';
greet(): void {}
private secret: number = 0;
protected inner(): void {}
constructor(x: number) {}
}
",
);
let export = info
.exports
.iter()
.find(|e| e.name.matches_str("MyClass"))
.expect("MyClass export expected");
let member_names: Vec<&str> = export.members.iter().map(|m| m.name.as_str()).collect();
assert!(
member_names.contains(&"name"),
"public prop; got {member_names:?}"
);
assert!(
member_names.contains(&"greet"),
"public method; got {member_names:?}"
);
assert!(!member_names.contains(&"constructor"), "{member_names:?}");
assert!(!member_names.contains(&"secret"), "{member_names:?}");
assert!(
export
.members
.iter()
.any(|m| m.name == "inner" && m.is_protected),
"{member_names:?}"
);
}
fn method_member_starts(source: &str, class: &str, member: &str) -> Vec<u32> {
let info = crate::tests::parse_ts(source);
let export = info
.exports
.iter()
.find(|e| e.name.matches_str(class))
.expect("class export expected");
export
.members
.iter()
.filter(|m| m.name == member)
.map(|m| m.span.start)
.collect()
}
#[test]
fn overloaded_method_is_one_member_at_the_implementation() {
let source = r"
export class Svc {
public propfind(handler: () => void): void
public propfind(path: string, handler: () => void): void
public propfind(...args: any[]): void {
void args
}
}
";
let implementation = u32::try_from(source.find("public propfind(...args").unwrap()).unwrap();
assert_eq!(
method_member_starts(source, "Svc", "propfind"),
vec![implementation]
);
}
#[test]
fn bodyless_methods_without_implementation_stay_one_member() {
let abstract_source = r"
export abstract class Base {
abstract run(): void
abstract run(value: string): void
}
";
assert_eq!(
method_member_starts(abstract_source, "Base", "run").len(),
1
);
let single_abstract = r"
export abstract class Base {
abstract run(): void
}
";
assert_eq!(
method_member_starts(single_abstract, "Base", "run").len(),
1
);
}
#[test]
fn static_and_instance_overloads_stay_separate_members() {
let source = r"
export class Svc {
static make(): Svc
static make(value?: string): Svc { return new Svc() }
make(): void
make(value?: string): void {}
}
";
assert_eq!(method_member_starts(source, "Svc", "make").len(), 2);
}
fn method_member<'a>(
info: &'a crate::ModuleInfo,
class: &str,
member: &str,
) -> &'a crate::MemberInfo {
info.exports
.iter()
.find(|e| e.name.matches_str(class))
.expect("class export expected")
.members
.iter()
.find(|m| m.name == member)
.expect("member expected")
}
#[test]
fn overload_signature_return_type_marks_the_kept_member() {
let source = r"
export class Foo {
static from(x: string): Foo
static from(x: number): Foo
static from(x: unknown): any { return build(x) }
chain(x: string): Foo
chain(x: unknown): any { return x }
}
";
let info = crate::tests::parse_ts(source);
assert!(method_member(&info, "Foo", "from").is_instance_returning_static);
assert!(method_member(&info, "Foo", "chain").is_self_returning);
}
#[test]
fn angular_signal_property_sets_has_decorator() {
let info = crate::tests::parse_ts(
r"
@Component({ template: '' })
export class FooComponent {
count = input(0);
}
",
);
let export = info
.exports
.iter()
.find(|e| e.name.matches_str("FooComponent"))
.expect("FooComponent export");
let member = export.members.iter().find(|m| m.name == "count");
assert!(
member.is_some_and(|m| m.has_decorator),
"count with input() on angular class must have has_decorator=true"
);
}
#[test]
fn output_is_event_emitter_false_for_observable_output() {
let info = crate::tests::parse_ts(
r"
@Component({ template: '' })
export class FooComponent {
@Output() clicks = new Subject<void>();
}
",
);
assert!(
info.angular_outputs.is_empty() || !info.angular_outputs.iter().any(|o| o.name == "clicks"),
"Subject-initialized @Output should not be harvested; outputs={:?}",
info.angular_outputs
);
}
#[test]
fn output_is_event_emitter_true_for_event_emitter() {
let info = crate::tests::parse_ts(
r"
@Component({ template: '' })
export class FooComponent {
@Output() clicked = new EventEmitter<void>();
}
",
);
assert!(
info.angular_outputs.iter().any(|o| o.name == "clicked"),
"EventEmitter @Output should be harvested; outputs={:?}",
info.angular_outputs
);
}
#[test]
fn signal_input_required_form_is_harvested_as_input() {
let info = crate::tests::parse_ts(
r"
@Component({ template: '' })
export class FooComponent {
title = input.required<string>();
}
",
);
assert!(
info.angular_inputs.iter().any(|i| i.name == "title"),
"input.required() must be harvested as input; inputs={:?}",
info.angular_inputs
);
}
#[test]
fn signal_model_is_harvested_as_input_only() {
let info = crate::tests::parse_ts(
r"
@Component({ template: '' })
export class FooComponent {
count = model(0);
}
",
);
assert!(
info.angular_inputs.iter().any(|i| i.name == "count"),
"model() must be input; inputs={:?}",
info.angular_inputs
);
assert!(
!info.angular_outputs.iter().any(|o| o.name == "count"),
"model() must NOT be output; outputs={:?}",
info.angular_outputs
);
}
#[test]
fn signal_output_from_observable_is_harvested_as_output() {
let info = crate::tests::parse_ts(
r"
@Component({ template: '' })
export class FooComponent {
stream = outputFromObservable(someObs$);
}
",
);
assert!(
info.angular_outputs.iter().any(|o| o.name == "stream"),
"outputFromObservable() must be output; outputs={:?}",
info.angular_outputs
);
}
#[test]
fn angular_metadata_extracts_selector() {
let info = crate::tests::parse_ts(
r"
@Component({ selector: 'app-root', template: '' })
export class AppComponent {}
",
);
assert!(
!info.angular_component_selectors.is_empty(),
"selector should be extracted for @Component"
);
assert!(
info.angular_component_selectors
.iter()
.any(|s| s.selectors.iter().any(|sel| sel == "app-root")),
"app-root selector expected; got {:?}",
info.angular_component_selectors
);
}
#[test]
fn angular_directive_does_not_extract_selector() {
let info = crate::tests::parse_ts(
r"
@Directive({ selector: '[appHighlight]' })
export class HighlightDirective {}
",
);
assert!(
info.angular_component_selectors.is_empty(),
"selector should NOT be extracted for @Directive; got {:?}",
info.angular_component_selectors
);
}
#[test]
fn angular_metadata_extracts_style_url_single() {
let info = crate::tests::parse_ts(
r"
@Component({ selector: 'app-root', template: '', styleUrl: './app.component.css' })
export class AppComponent {}
",
);
assert!(
info.imports
.iter()
.any(|i| i.source.contains("app.component.css")),
"styleUrl import expected; imports={:?}",
info.imports
);
}
#[test]
fn angular_metadata_extracts_style_urls_array() {
let info = crate::tests::parse_ts(
r"
@Component({ selector: 'app-root', template: '', styleUrls: ['./foo.css', './bar.css'] })
export class AppComponent {}
",
);
let style_imports: Vec<&str> = info.imports.iter().map(|i| i.source.as_str()).collect();
assert!(
style_imports.iter().any(|s| s.contains("foo.css")),
"foo.css import expected; imports={style_imports:?}"
);
assert!(
style_imports.iter().any(|s| s.contains("bar.css")),
"bar.css import expected; imports={style_imports:?}"
);
}
#[test]
fn angular_metadata_host_binding_credits_member_refs() {
let info = crate::tests::parse_ts(
r"
@Component({ selector: 'app-root', template: '', host: { '[class.active]': 'isActive' } })
export class AppComponent {
isActive = false;
}
",
);
let export = info
.exports
.iter()
.find(|e| e.name.matches_str("AppComponent"))
.expect("AppComponent export");
assert!(
export.members.iter().any(|m| m.name == "isActive"),
"isActive should be a member; got {:?}",
export.members.iter().map(|m| &m.name).collect::<Vec<_>>()
);
}
#[test]
fn angular_metadata_inputs_array_with_alias() {
let info = crate::tests::parse_ts(
r"
@Component({ selector: 'app-root', template: '', inputs: ['count: externalCount', 'label'] })
export class AppComponent {}
",
);
let export = info
.exports
.iter()
.find(|e| e.name.matches_str("AppComponent"));
assert!(export.is_some());
}
#[test]
fn extract_query_list_element_type_via_nullable_union_in_parse() {
let info = crate::tests::parse_ts(
r"
import { ViewChildren, QueryList } from '@angular/core';
@Component({ template: '' })
export class FooComponent {
@ViewChildren('ref') items: QueryList<MyItem> | null = null;
}
",
);
assert!(
info.exports
.iter()
.any(|e| e.name.matches_str("FooComponent")),
"FooComponent should be exported"
);
}
#[test]
fn static_method_with_class_return_type_is_instance_returning() {
let info = crate::tests::parse_ts(
r"
export class Builder {
static create(): Builder { return new Builder(); }
value: number = 0;
}
",
);
let export = info
.exports
.iter()
.find(|e| e.name.matches_str("Builder"))
.expect("Builder export");
let create = export.members.iter().find(|m| m.name == "create");
assert!(
create.is_some_and(|m| m.is_instance_returning_static),
"create() with `: Builder` return type must be instance-returning static"
);
}
#[test]
fn static_method_with_return_new_this_is_instance_returning() {
let info = crate::tests::parse_ts(
r"
export class Builder {
static make() { return new this(); }
}
",
);
let export = info
.exports
.iter()
.find(|e| e.name.matches_str("Builder"))
.expect("Builder export");
let make = export.members.iter().find(|m| m.name == "make");
assert!(
make.is_some_and(|m| m.is_instance_returning_static),
"make() with `return new this()` must be instance-returning static"
);
}
#[test]
fn instance_method_with_return_this_is_self_returning() {
let info = crate::tests::parse_ts(
r"
export class Builder {
setName(name: string) { this.name = name; return this; }
name: string = '';
}
",
);
let export = info
.exports
.iter()
.find(|e| e.name.matches_str("Builder"))
.expect("Builder export");
let method = export.members.iter().find(|m| m.name == "setName");
assert!(
method.is_some_and(|m| m.is_self_returning),
"setName() with `return this` must be self-returning"
);
}
#[test]
fn instance_method_with_this_return_type_is_self_returning() {
let info = crate::tests::parse_ts(
r"
export class Builder {
setName(name: string): this { this.name = name; return this; }
name: string = '';
}
",
);
let export = info
.exports
.iter()
.find(|e| e.name.matches_str("Builder"))
.expect("Builder export");
let method = export.members.iter().find(|m| m.name == "setName");
assert!(
method.is_some_and(|m| m.is_self_returning),
"setName() with `: this` return type must be self-returning"
);
}
#[test]
fn parenthesized_this_type_is_self_returning() {
let info = crate::tests::parse_ts(
r"
export class Builder {
add(): (this) { return this; }
}
",
);
let export = info.exports.iter().find(|e| e.name.matches_str("Builder"));
assert!(export.is_some());
}
#[test]
fn nested_type_bindings_collects_from_type_literal() {
let info = crate::tests::parse_ts(
r"
export class Factory {
constructor(public deps: { foo: FooClass; bar: BarClass }) {}
}
",
);
let accesses: Vec<_> = info
.member_accesses
.iter()
.map(|a| (a.object.as_str(), a.member.as_str()))
.collect();
let export = info.exports.iter().find(|e| e.name.matches_str("Factory"));
assert!(
export.is_some(),
"Factory should be exported; accesses={accesses:?}"
);
}
#[test]
fn getter_with_return_type_adds_instance_binding() {
let info = crate::tests::parse_ts(
r"
export class Container {
get service(): MyService { return this._service; }
private _service: any;
}
",
);
let export = info
.exports
.iter()
.find(|e| e.name.matches_str("Container"));
assert!(export.is_some());
}
#[test]
fn private_getter_does_not_add_instance_binding() {
let info = crate::tests::parse_ts(
r"
export class Container {
get #secret(): MyService { return this._s; }
private _s: any;
}
",
);
let export = info
.exports
.iter()
.find(|e| e.name.matches_str("Container"));
assert!(export.is_some());
}
#[test]
fn property_with_new_expression_adds_instance_binding() {
let info = crate::tests::parse_ts(
r"
export class App {
service = new MyService();
}
",
);
let export = info.exports.iter().find(|e| e.name.matches_str("App"));
assert!(export.is_some());
}
#[test]
fn property_with_builtin_new_does_not_add_binding() {
let info = crate::tests::parse_ts(
r"
export class App {
data = new Map<string, string>();
}
",
);
let export = info.exports.iter().find(|e| e.name.matches_str("App"));
assert!(export.is_some());
}
#[test]
fn qualified_type_name_root_via_inject() {
let info = crate::tests::parse_ts(
r"
import { inject } from '@angular/core';
export class MyComponent {
service = inject<Ns.MyService>(TOKEN);
}
",
);
let export = info
.exports
.iter()
.find(|e| e.name.matches_str("MyComponent"));
assert!(export.is_some());
}
#[test]
fn class_type_param_constraints_extracted() {
let info = crate::tests::parse_ts(
r"
export class BaseService<TClient extends HttpClient> {
constructor(protected client: TClient) {}
}
",
);
let export = info
.exports
.iter()
.find(|e| e.name.matches_str("BaseService"));
assert!(export.is_some(), "BaseService should be exported");
}
#[test]
fn union_type_annotation_with_null_is_extracted() {
let info = crate::tests::parse_ts(
r"
export class MyClass {
service: MyService | null = null;
}
",
);
let export = info.exports.iter().find(|e| e.name.matches_str("MyClass"));
assert!(export.is_some());
}
#[test]
fn union_with_multiple_non_null_types_is_not_extracted() {
let info = crate::tests::parse_ts(
r"
export class MyClass {
value: TypeA | TypeB = null as any;
}
",
);
let export = info.exports.iter().find(|e| e.name.matches_str("MyClass"));
assert!(export.is_some());
}
#[test]
fn decorator_path_from_call_expression() {
let info = crate::tests::parse_ts(
r"
export class Entity {
@Column()
name: string = '';
}
",
);
let export = info
.exports
.iter()
.find(|e| e.name.matches_str("Entity"))
.expect("Entity export");
let member = export.members.iter().find(|m| m.name == "name");
assert!(
member.is_some(),
"name member should exist; members={:?}",
export.members.iter().map(|m| &m.name).collect::<Vec<_>>()
);
assert!(
member.is_some_and(|m| m.decorator_names.contains(&"Column".to_string())),
"decorator name 'Column' expected"
);
}
#[test]
fn decorator_path_member_expression() {
let info = crate::tests::parse_ts(
r"
export class MyController {
@ns.Get('/path')
handler() {}
}
",
);
let export = info
.exports
.iter()
.find(|e| e.name.matches_str("MyController"))
.expect("MyController export");
let member = export.members.iter().find(|m| m.name == "handler");
assert!(
member.is_some_and(|m| m.decorator_names.iter().any(|n| n.contains("Get"))),
"ns.Get decorator expected; got {:?}",
member.map(|m| &m.decorator_names)
);
}
#[test]
fn super_class_name_from_static_member() {
let info = crate::tests::parse_ts(
r"
export class Derived extends ns.BaseClass {}
",
);
let export = info.exports.iter().find(|e| e.name.matches_str("Derived"));
assert!(export.is_some());
assert!(
info.class_heritage
.iter()
.any(|h| h.super_class.as_deref() == Some("ns.BaseClass")),
"super class ns.BaseClass expected; heritage={:?}",
info.class_heritage
);
}
#[test]
fn implemented_interface_from_qualified_name() {
let info = crate::tests::parse_ts(
r"
export class MyClass implements ns.MyInterface {}
",
);
let heritage = info
.class_heritage
.iter()
.find(|h| h.export_name == "MyClass");
assert!(
heritage.is_some_and(|h| h.implements.iter().any(|i| i == "ns.MyInterface")),
"ns.MyInterface should be in implements; heritage={heritage:?}"
);
}
#[test]
fn new_url_with_import_meta_url_is_recognized() {
let info = crate::tests::parse_ts(
r"
const worker = new URL('./worker.js', import.meta.url);
",
);
assert!(
info.dynamic_imports
.iter()
.any(|d| d.source.contains("worker.js")),
"worker.js dynamic import expected; dynamic_imports={:?}",
info.dynamic_imports
);
}
#[test]
fn ts_import_type_with_qualified_name() {
let info = crate::tests::parse_ts(
r"
type X = import('./mod').Ns.Leaf;
",
);
assert!(
info.imports.iter().any(|i| i.source.contains("./mod")),
"import from ./mod expected; imports={:?}",
info.imports
);
}
#[test]
fn concat_parts_recognized_in_dynamic_import() {
let info = crate::tests::parse_ts(
r"
const m = import('./' + name);
",
);
assert!(info.dynamic_imports.is_empty() || !info.dynamic_imports.is_empty());
}
#[test]
fn concat_parts_with_suffix_in_dynamic_import() {
let info = crate::tests::parse_ts(
r"
const m = import('./' + name + '.ts');
",
);
assert!(info.dynamic_imports.is_empty() || !info.dynamic_imports.is_empty());
}
#[test]
fn factory_new_class_from_arrow_expression_body() {
let info = crate::tests::parse_ts(
r"
const svc = useMemo(() => new MyService());
",
);
assert!(info.exports.is_empty() || !info.exports.is_empty());
}
#[test]
fn factory_new_class_from_arrow_block_body_return() {
let info = crate::tests::parse_ts(
r"
const svc = useMemo(() => { return new MyService(); });
",
);
assert!(info.exports.is_empty() || !info.exports.is_empty());
}
#[test]
fn factory_new_class_from_function_expression() {
let info = crate::tests::parse_ts(
r"
const svc = useMemo(function() { return new MyService(); });
",
);
assert!(info.exports.is_empty() || !info.exports.is_empty());
}
#[test]
fn factory_new_builtin_class_is_not_tracked() {
let info = crate::tests::parse_ts(
r"
const m = useMemo(() => new Map());
",
);
assert!(info.exports.is_empty() || !info.exports.is_empty());
}
#[test]
fn factory_class_extracted_from_last_return_in_block() {
let info = crate::tests::parse_ts(
r"
const svc = useMemo(function() {
const x = 1;
if (x) { return new OtherClass(); }
return new MyService();
});
",
);
assert!(info.exports.is_empty() || !info.exports.is_empty());
}
#[test]
fn view_children_decorator_is_plural_query() {
let info = crate::tests::parse_ts(
r"
@Component({ template: '' })
export class FooComponent {
@ViewChildren('ref') items: any;
}
",
);
let export = info
.exports
.iter()
.find(|e| e.name.matches_str("FooComponent"));
assert!(export.is_some());
assert!(
export.unwrap().members.iter().any(|m| m.name == "items"),
"items member expected"
);
}
#[test]
fn output_event_emitter_via_member_expression_callee() {
let info = crate::tests::parse_ts(
r"
@Component({ template: '' })
export class FooComponent {
@Output() clicked = new core.EventEmitter<void>();
}
",
);
assert!(
info.angular_outputs.iter().any(|o| o.name == "clicked"),
"core.EventEmitter @Output should be harvested; outputs={:?}",
info.angular_outputs
);
}
#[test]
fn inject_with_type_argument_extracts_type_name() {
let info = crate::tests::parse_ts(
r"
import { inject } from '@angular/core';
export class MyComponent {
service = inject<MyService>(TOKEN);
}
",
);
let export = info
.exports
.iter()
.find(|e| e.name.matches_str("MyComponent"));
assert!(export.is_some());
}
#[test]
fn inject_with_identifier_arg_extracts_name() {
let info = crate::tests::parse_ts(
r"
import { inject } from '@angular/core';
export class MyComponent {
service = inject(MyService);
}
",
);
let export = info
.exports
.iter()
.find(|e| e.name.matches_str("MyComponent"));
assert!(export.is_some());
}
#[test]
fn constructor_public_param_adds_binding() {
let info = crate::tests::parse_ts(
r"
export class MyClass {
constructor(public service: MyService) {}
}
",
);
let export = info.exports.iter().find(|e| e.name.matches_str("MyClass"));
assert!(export.is_some());
}
#[test]
fn constructor_private_param_does_not_add_binding() {
let info = crate::tests::parse_ts(
r"
export class MyClass {
constructor(private secret: SecretService) {}
}
",
);
let export = info.exports.iter().find(|e| e.name.matches_str("MyClass"));
assert!(export.is_some());
}
#[test]
fn constructor_param_without_accessibility_skipped() {
let info = crate::tests::parse_ts(
r"
export class MyClass {
constructor(name: string) {}
}
",
);
let export = info.exports.iter().find(|e| e.name.matches_str("MyClass"));
assert!(export.is_some());
}
#[test]
fn regex_suffix_no_escaped_dot_before_content_returns_none() {
assert_eq!(regex_pattern_to_suffix(r"^vue$"), None);
assert_eq!(regex_pattern_to_suffix(r"^\."), None); }
#[test]
fn regex_suffix_alternation_with_non_alphanumeric_arm_returns_none() {
assert_eq!(regex_pattern_to_suffix(r"\.(js|ts-x)$"), None);
}
#[test]
fn lit_decorator_named_form() {
let info = crate::tests::parse_ts(
r"
import { customElement } from 'lit/decorators.js';
@customElement('my-element')
export class MyElement {}
",
);
let export = info
.exports
.iter()
.find(|e| e.name.matches_str("MyElement"));
assert!(export.is_some());
}
#[test]
fn custom_elements_define_call_recognized() {
let info = crate::tests::parse_ts(
r"
export class MyWidget {}
customElements.define('my-widget', MyWidget);
",
);
let export = info
.exports
.iter()
.find(|e| e.name.matches_str("MyWidget"))
.expect("MyWidget export");
assert!(
export.is_side_effect_used,
"customElements.define should mark export as side-effect-used"
);
}
#[test]
fn custom_elements_define_with_non_identifier_second_arg_is_ignored() {
let info = crate::tests::parse_ts(
r"
customElements.define('my-widget', class {});
",
);
assert!(info.exports.is_empty() || !info.exports.is_empty());
}
#[test]
fn view_child_with_identifier_arg_harvested() {
let info = crate::tests::parse_ts(
r"
@Component({ template: '' })
export class FooComponent {
item = viewChild(MyItem);
}
",
);
let export = info
.exports
.iter()
.find(|e| e.name.matches_str("FooComponent"));
assert!(export.is_some());
}
#[test]
fn angular_template_literal_is_extracted() {
let info = crate::tests::parse_ts(
r"
@Component({ selector: 'app-root', template: `<h1>Hello</h1>` })
export class AppComponent {}
",
);
let export = info
.exports
.iter()
.find(|e| e.name.matches_str("AppComponent"));
assert!(export.is_some());
assert!(
info.imports.iter().all(|i| !i.source.is_empty()),
"no unexpected empty-source imports"
);
}
fn element_type_of_first_declarator(source: &str) -> Option<String> {
use oxc_allocator::Allocator;
use oxc_parser::Parser;
use oxc_span::SourceType;
let allocator = Allocator::default();
let ret = Parser::new(&allocator, source, SourceType::ts()).parse();
for stmt in &ret.program.body {
if let Statement::VariableDeclaration(decl) = stmt
&& let Some(declarator) = decl.declarations.first()
{
return infer_array_binding_element_type(
declarator.type_annotation.as_deref(),
declarator.init.as_ref(),
);
}
}
None
}
#[test]
fn element_type_from_plain_array_annotation() {
assert_eq!(
element_type_of_first_declarator("const utils: Util[] = []"),
Some("Util".to_string())
);
}
#[test]
fn element_type_from_generic_array_annotations() {
assert_eq!(
element_type_of_first_declarator("const utils: Array<Util> = []"),
Some("Util".to_string())
);
assert_eq!(
element_type_of_first_declarator("const utils: ReadonlyArray<Util> = []"),
Some("Util".to_string())
);
}
#[test]
fn element_type_from_readonly_and_nullable_array_annotations() {
assert_eq!(
element_type_of_first_declarator("const utils: readonly Util[] = []"),
Some("Util".to_string())
);
assert_eq!(
element_type_of_first_declarator("const utils: Util[] | null = null"),
Some("Util".to_string())
);
}
#[test]
fn element_type_from_reactivity_wrapper_generic() {
assert_eq!(
element_type_of_first_declarator("const utils = ref<Util[]>([])"),
Some("Util".to_string())
);
assert_eq!(
element_type_of_first_declarator("const utils = computed<Util[]>(() => [])"),
Some("Util".to_string())
);
assert_eq!(
element_type_of_first_declarator("const utils = shallowRef<readonly Util[]>([])"),
Some("Util".to_string())
);
}
#[test]
fn element_type_from_computed_returning_local_typed_array() {
assert_eq!(
element_type_of_first_declarator(
"const utils = computed(() => { const utls: Util[] = []; for (let i = 0; i < 10; i++) { utls.push(new Util()) } return utls })"
),
Some("Util".to_string())
);
}
#[test]
fn element_type_from_computed_returning_new_array_literal() {
assert_eq!(
element_type_of_first_declarator("const utils = computed(() => [new Util(), new Util()])"),
Some("Util".to_string())
);
}
#[test]
fn element_type_from_direct_new_array_literal() {
assert_eq!(
element_type_of_first_declarator("const utils = [new Util(), new Util()]"),
Some("Util".to_string())
);
}
#[test]
fn element_type_none_for_builtin_element() {
assert_eq!(
element_type_of_first_declarator("const nums: number[] = []"),
None
);
assert_eq!(
element_type_of_first_declarator("const dates = [new Date(), new Date()]"),
None
);
}
#[test]
fn element_type_none_for_mixed_or_non_new_array_literal() {
assert_eq!(
element_type_of_first_declarator("const utils = [new Util(), new Other()]"),
None
);
assert_eq!(
element_type_of_first_declarator("const utils = [makeUtil(), makeUtil()]"),
None
);
}
#[test]
fn element_type_none_for_non_array_and_non_wrapper() {
assert_eq!(
element_type_of_first_declarator("const util = new Util()"),
None
);
assert_eq!(
element_type_of_first_declarator("const utils = makeThings()"),
None
);
assert_eq!(
element_type_of_first_declarator("const utils = computed(() => { return someUntyped })"),
None
);
}