tsv_ts 0.8.0

TypeScript/JS formatter, type stripper and acorn-compatible parser — part of tsv
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

// Module path pattern detection for TypeScript call expressions
//
// Handles special formatting for module-related calls:
// - `require.resolve(string)` - don't break args, let assignment break
// - `require.resolve.paths(string)` - break before `.paths`
// - `import.meta.resolve(string)` - break before `.resolve`
//
// Note: Plain `require(string)` is NOT special-cased - it wraps at print width like
// any other call. This diverges from Prettier which keeps require() on one line
// regardless of length.

use super::super::{Printer, is_string_literal};
use crate::ast;

/// These calls keep the module path on the same line as the method.
///
/// Patterns:
/// - `require.resolve(string)` → don't break args, let assignment break
pub(super) fn is_module_path_no_break(
    call: &ast::CallExpression<'_>,
    printer: &Printer<'_>,
) -> bool {
    // Must have exactly 1 argument that is a string literal
    if call.arguments.len() != 1 || !is_string_literal(call.arguments[0]) {
        return false;
    }

    // Check for `require.resolve()`
    if let ast::ExpressionKind::MemberExpression(member) = &call.callee.kind
        && !member.computed
        && !member.optional
        && let ast::ExpressionKind::Identifier(resolve_id) = &member.property.kind
        && printer.with_ident_name(resolve_id, |s| s == "resolve")
        && let ast::ExpressionKind::Identifier(require_id) = &member.object.kind
        && printer.with_ident_name(require_id, |s| s == "require")
    {
        return true;
    }

    false
}

/// Module path call patterns where prettier breaks at the chain rather than at args.
/// Returns (base_expr, method_name) if this is a module path call that should break at chain.
///
/// Patterns:
/// - `require.resolve.paths(string)` → break before `.paths`
/// - `import.meta.resolve(string)` → break before `.resolve`
pub(super) fn get_module_path_chain_break<'a>(
    call: &'a ast::CallExpression<'a>,
    printer: &Printer<'_>,
) -> Option<(&'a ast::Expression<'a>, &'a ast::Identifier<'a>)> {
    // Must have exactly 1 argument that is a string literal
    if call.arguments.len() != 1 || !is_string_literal(call.arguments[0]) {
        return None;
    }

    // Callee must be a member expression (not computed, not optional)
    let ast::ExpressionKind::MemberExpression(member) = &call.callee.kind else {
        return None;
    };
    if member.computed || member.optional {
        return None;
    }

    // Property must be an identifier
    let ast::ExpressionKind::Identifier(method_name) = &member.property.kind else {
        return None;
    };

    let (is_paths, is_resolve) =
        printer.with_ident_name(method_name, |m| (m == "paths", m == "resolve"));

    // Check for `require.resolve.paths()`
    if is_paths {
        // Object should be `require.resolve`
        if let ast::ExpressionKind::MemberExpression(obj_member) = &member.object.kind
            && !obj_member.computed
            && !obj_member.optional
            && let ast::ExpressionKind::Identifier(resolve_id) = &obj_member.property.kind
            && printer.with_ident_name(resolve_id, |s| s == "resolve")
            && let ast::ExpressionKind::Identifier(require_id) = &obj_member.object.kind
            && printer.with_ident_name(require_id, |s| s == "require")
        {
            return Some((member.object, method_name));
        }
    }

    // Check for `import.meta.resolve()`
    if is_resolve && let ast::ExpressionKind::MetaProperty(meta) = &member.object.kind {
        let is_import_meta = printer.with_ident_name(&meta.meta, |m| m == "import")
            && printer.with_ident_name(&meta.property, |p| p == "meta");
        if is_import_meta {
            return Some((member.object, method_name));
        }
    }

    None
}