crates/core/tests/un_template_literal_rule.rs

GitHub
mod common;

use common::{assert_eq_normalized, render, render_rule};
use wakaru_core::facts::{HelperExportFact, HelperKind, ModuleFacts, ModuleFactsMap};
use wakaru_core::rules::{RewriteLevel, UnTemplateLiteral};

fn apply(input: &str) -> String {
    render_rule(input, |_| UnTemplateLiteral::new())
}

fn apply_minimal(input: &str) -> String {
    render_rule(input, |_| {
        UnTemplateLiteral::new_with_level(RewriteLevel::Minimal)
    })
}

#[test]
fn restores_template_literal_from_concat_chain() {
    // Reused from packages/unminify/src/transformations/__tests__/un-template-literal.spec.ts
    let input = r#"
var example1 = "the ".concat("simple ", form);
var example2 = "".concat(1);
var example3 = 1 + "".concat(foo).concat(bar).concat(baz);
var example4 = 1 + "".concat(foo, "bar").concat(baz);
var example5 = "".concat(1, f, "oo", true).concat(b, "ar", 0).concat(baz);
var example6 = "test ".concat(foo, " ").concat(bar);
"#;
    // VarDeclToLetConst converts var to const since these vars are never reassigned.
    let expected = r#"
var example1 = `the simple ${form}`;
var example2 = `${1}`;
var example3 = 1 + `${foo}${bar}${baz}`;
var example4 = 1 + `${foo}bar${baz}`;
var example5 = `${1}${f}oo${true}${b}ar${0}${baz}`;
var example6 = `test ${foo} ${bar}`;
"#;

    let output = apply(input);
    assert_eq_normalized(&output, expected);
}

#[test]
fn keeps_non_consecutive_concat_calls() {
    // Reused from packages/unminify/src/transformations/__tests__/un-template-literal.spec.ts
    let input = r#"
"the".concat(first, " take the ").concat(second, " and ").split(' ').concat(third);
"#;
    let expected = r#"
`the${first} take the ${second} and `.split(' ').concat(third);
"#;

    let output = apply(input);
    assert_eq_normalized(&output, expected);
}

#[test]
fn plus_chain_starting_with_string_literal() {
    let input = r#"
var a = "prefix: " + value;
var b = "hello, " + name + "!";
var c = "@@redux-saga/" + key;
"#;
    let expected = r#"
var a = `prefix: ${value}`;
var b = `hello, ${name}!`;
var c = `@@redux-saga/${key}`;
"#;
    let output = apply(input);
    assert_eq_normalized(&output, expected);
}

#[test]
fn plus_chain_ending_with_string_literal() {
    let input = r#"
var a = value + " suffix";
var b = expr + " has been deprecated";
"#;
    let expected = r#"
var a = `${value} suffix`;
var b = `${expr} has been deprecated`;
"#;
    let output = apply(input);
    assert_eq_normalized(&output, expected);
}

#[test]
fn keeps_plus_empty_string_conversion() {
    let input = r#"
var actual = object + "";
var other = "" + object;
"#;
    let output = apply_minimal(input);
    assert_eq_normalized(&output, input);
}

#[test]
fn standard_rewrites_empty_string_conversion() {
    let input = r#"
var actual = object + "";
var other = "" + object;
"#;
    let expected = r#"
var actual = `${object}`;
var other = `${object}`;
"#;
    let output = apply(input);
    assert_eq_normalized(&output, expected);
}

#[test]
fn plus_chain_groups_non_string_prefix() {
    // `a + b + "c"` must NOT become `${a}${b}c` (breaks arithmetic for numbers).
    // The non-string prefix `a + b` is kept as a single grouped expression.
    let input = r#"
var result = prefix + count + " items";
"#;
    let expected = r#"
var result = `${prefix + count} items`;
"#;
    let output = apply(input);
    assert_eq_normalized(&output, expected);
}

#[test]
fn plus_chain_mixed_string_positions() {
    let input = r#"
var msg = "redux-saga " + level + ": " + text + "\n" + extra;
"#;
    let expected = "var msg = `redux-saga ${level}: ${text}\n${extra}`;\n";
    let output = apply(input);
    assert_eq_normalized(&output, expected);
}

#[test]
fn nested_plus_chain_inside_template_expression() {
    // Inner concatenation inside a logical expression should also be converted.
    // Previously required a double-pass because converting the outer chain
    // returned early without visiting children of the new template literal.
    let input = r#"
var msg = "Given " + (n && 'action "' + String(n) + '"' || "an action") + ', reducer "' + e + '" returned undefined.';
"#;
    let expected = r#"
var msg = `Given ${n && `action "${String(n)}"` || "an action"}, reducer "${e}" returned undefined.`;
"#;
    let output = apply(input);
    assert_eq_normalized(&output, expected);
}

#[test]
fn pure_number_addition_not_transformed() {
    // No string literals → must not be turned into a template.
    let input = r#"
var x = a + b + c;
var y = 1 + 2;
"#;
    let expected = r#"
var x = a + b + c;
var y = 1 + 2;
"#;
    let output = apply(input);
    assert_eq_normalized(&output, expected);
}

#[test]
fn standard_normalizes_escaped_newlines_in_untagged_template() {
    let input = r#"var slideIn = (direction) => `\n0% {transform: translate3d(0, ${-200 * direction}%, 0)}\n100% {transform: translate3d(0, 0, 0)}\n`;"#;
    let expected = r#"var slideIn = (direction)=>`
0% {transform: translate3d(0, ${-200 * direction}%, 0)}
100% {transform: translate3d(0, 0, 0)}
`;
"#;

    let output = apply(input);
    assert_eq!(output, expected);
}

#[test]
fn minimal_preserves_escaped_newlines_in_untagged_template() {
    let input = r#"var slideIn = (direction) => `\n0% {transform: translate3d(0, ${-200 * direction}%, 0)}\n100% {transform: translate3d(0, 0, 0)}\n`;"#;
    let expected = r#"var slideIn = (direction)=>`\n0% {transform: translate3d(0, ${-200 * direction}%, 0)}\n100% {transform: translate3d(0, 0, 0)}\n`;
"#;

    let output = apply_minimal(input);
    assert_eq!(output, expected);
}

#[test]
fn keeps_escaped_newlines_in_tagged_template_raw() {
    let input = r#"var out = tag`\n0% {transform}\n`;"#;
    let expected = r#"var out = tag`\n0% {transform}\n`;
"#;

    let output = apply(input);
    assert_eq!(output, expected);
}

#[test]
fn keeps_literal_backslash_n_in_untagged_template() {
    let input = r#"var out = `\\nnot a line break`;"#;
    let expected = r#"var out = `\\nnot a line break`;
"#;

    let output = apply(input);
    assert_eq!(output, expected);
}

#[test]
fn keeps_escaped_crlf_in_untagged_template() {
    let input = r#"var out = `header\r\n\r\n`;"#;
    let expected = r#"var out = `header\r\n\r\n`;
"#;

    let output = apply(input);
    assert_eq!(output, expected);
}

#[test]
fn restores_babel_modern_tagged_template() {
    let input = r#"
var _templateObject;
function _taggedTemplateLiteral(e, t) { return e; }
var out = tag(_templateObject || (_templateObject = _taggedTemplateLiteral(["hello ", ""], ["hello ", ""])), name);
"#;
    let expected = r#"
var out = tag`hello ${name}`;
"#;
    let output = apply(input);
    assert_eq_normalized(&output, expected);
}

#[test]
fn restores_babel_runtime_imported_tagged_template() {
    // transform-runtime imports the helper from @babel/runtime.
    let input = r#"
import _taggedTemplateLiteral from "@babel/runtime/helpers/taggedTemplateLiteral";
var _templateObject;
var out = tag(_templateObject || (_templateObject = _taggedTemplateLiteral(["hello ", ""], ["hello ", ""])), name);
"#;
    let expected = r#"
var out = tag`hello ${name}`;
"#;
    let output = apply(input);
    assert_eq_normalized(&output, expected);
}

#[test]
fn restores_aliased_babel_runtime_imported_tagged_template() {
    // The local name is not a known helper name — detection must go through
    // LocalHelperContext path classification, not is_template_helper_name.
    let input = r#"
import t from "@babel/runtime/helpers/taggedTemplateLiteral";
var _templateObject;
var out = tag(_templateObject || (_templateObject = t(["hello ", ""], ["hello ", ""])), name);
"#;
    let expected = r#"
var out = tag`hello ${name}`;
"#;
    let output = apply(input);
    assert_eq_normalized(&output, expected);
}

#[test]
fn restores_swc_imported_tagged_template_loose() {
    let input = r#"
import { _ as _tagged_template_literal_loose } from "@swc/helpers/_/_tagged_template_literal_loose";
var _templateObject;
var out = tag(_templateObject || (_templateObject = _tagged_template_literal_loose(["hello ", ""], ["hello ", ""])), name);
"#;
    let expected = r#"
var out = tag`hello ${name}`;
"#;
    let output = apply(input);
    assert_eq_normalized(&output, expected);
}

#[test]
fn restores_typescript_tagged_template() {
    let input = r#"
var __makeTemplateObject = (this && this.__makeTemplateObject) || function (cooked, raw) { return cooked; };
var out = tag(__makeTemplateObject(["hello ", ""], ["hello ", ""]), name);
"#;
    let expected = r#"
var out = tag`hello ${name}`;
"#;
    let output = apply(input);
    assert_eq_normalized(&output, expected);
}

#[test]
fn restores_swc_tagged_template() {
    let input = r#"
function _tagged_template_literal(strings, raw) { return strings; }
var out = tag(_tagged_template_literal(["hello ", ""], ["hello ", ""]), name);
"#;
    let expected = r#"
var out = tag`hello ${name}`;
"#;
    let output = apply(input);
    assert_eq_normalized(&output, expected);
}

#[test]
fn restores_swc_tagged_template_newlines_without_raw_argument() {
    let input = r#"
function _tagged_template_literal(strings, raw) { return strings; }
function _templateObject() {
    var data = _tagged_template_literal([
        "\n  staticOne\n  staticTwo\n  ",
        "\n  ",
        "\n  staticThree\n  ",
        "\n"
    ]);
    _templateObject = function _templateObject() {
        return data;
    };
    return data;
}
var out = tag(_templateObject(), dynamicOne, dynamicTwo, dynamicThree);
"#;
    let expected = r#"var out = tag`
  staticOne
  staticTwo
  ${dynamicOne}
  ${dynamicTwo}
  staticThree
  ${dynamicThree}
`;
"#;

    let output = apply(input);
    assert_eq!(output, expected);
}

#[test]
fn restores_cross_module_default_object_swc_tagged_template() {
    let mut facts = ModuleFactsMap::new();
    facts.insert(
        "helpers.js",
        ModuleFacts {
            default_object_helper_exports: vec![HelperExportFact {
                exported: "_".into(),
                local: Some("template".into()),
                kind: HelperKind::TaggedTemplateLiteral,
            }],
            ..Default::default()
        },
    );

    let input = r#"
import helpers from "./helpers.js";
function _templateObject() {
    const data = helpers._(["hello ", ""]);
    _templateObject = () => data;
    return data;
}
var out = tag(_templateObject(), name);
"#;
    let expected = r#"
import helpers from "./helpers.js";
var out = tag`hello ${name}`;
"#;
    let output = render_rule(input, |_| {
        UnTemplateLiteral::new_with_facts(RewriteLevel::Standard, &facts)
    });
    assert_eq_normalized(&output, expected);
}

#[test]
fn restores_cross_module_direct_tagged_template_keeps_import() {
    let mut facts = ModuleFactsMap::new();
    facts.insert(
        "helpers.js",
        ModuleFacts {
            helper_exports: vec![HelperExportFact {
                exported: "_".into(),
                local: Some("template".into()),
                kind: HelperKind::TaggedTemplateLiteral,
            }],
            ..Default::default()
        },
    );

    let input = r#"
import { _ as template } from "./helpers.js";
var out = tag(template(["hello ", ""], ["hello ", ""]), name);
"#;
    let expected = r#"
import { _ as template } from "./helpers.js";
var out = tag`hello ${name}`;
"#;
    let output = render_rule(input, |_| {
        UnTemplateLiteral::new_with_facts(RewriteLevel::Standard, &facts)
    });
    assert_eq_normalized(&output, expected);
}

#[test]
fn restores_esbuild_cached_tagged_template() {
    let input = r#"
var __template = function(cooked, raw) { return cooked; };
var _a;
var out = tag(_a || (_a = __template(["hello ", ""], ["hello ", ""])), name);
"#;
    let expected = r#"
var out = tag`hello ${name}`;
"#;
    let output = apply(input);
    assert_eq_normalized(&output, expected);
}

#[test]
fn restores_esbuild_terser_inlined_cached_tagged_template() {
    let input = r#"
var _a;
var out = tag(_a || (_a = function(cooked, raw) { return cooked; }(["hello ", ""], ["hello ", ""])), name);
"#;
    let expected = r#"
var out = tag`hello ${name}`;
"#;
    let output = apply(input);
    assert_eq_normalized(&output, expected);
}

#[test]
fn restores_esbuild_terser_inlined_raw_tagged_template() {
    let input = r#"
var _a;
var out = tag(_a || (_a = function(cooked, raw) { return cooked; }(["line\n", "😀"], ["line\\n", "\\u{1f600}"])), value);
"#;
    let expected = r#"
var out = tag`line\n${value}\u{1f600}`;
"#;
    let output = apply(input);
    assert_eq_normalized(&output, expected);
}

#[test]
fn restores_babel_cache_function_tagged_template() {
    let input = r#"
function _templateObject() {
    const data = _taggedTemplateLiteral(["hello ", ""]);
    _templateObject = function () { return data; };
    return data;
}
function _taggedTemplateLiteral(e, t) { return e; }
var out = tag(_templateObject(), name);
"#;
    let expected = r#"
var out = tag`hello ${name}`;
"#;
    let output = apply(input);
    assert_eq_normalized(&output, expected);
}

#[test]
fn restores_member_tagged_template_with_raw_segments() {
    let input = r#"
var _templateObject;
function _taggedTemplateLiteral(e, t) { return e; }
var out = css.div(_templateObject || (_templateObject = _taggedTemplateLiteral(["line\n", ""], ["line\\n", ""])), value);
"#;
    let expected = r#"
var out = css.div`line\n${value}`;
"#;
    let output = apply(input);
    assert_eq_normalized(&output, expected);
}

#[test]
fn restores_esbuild_terser_mangled_member_tagged_template() {
    // Produced by esbuild ES5 output minified with Terser compress+mangle.
    let input = r#"
var e=Object.freeze,r=Object.defineProperty,c=function(c,o){return e(r(c,"raw",{value:e(o||c.slice())}))},o,a=css.div(o||(o=c(["color: ","; margin: ","px;"])),color,space);use(a);
"#;
    let expected = r#"
const a = css.div`color: ${color}; margin: ${space}px;`;
use(a);
"#;
    assert_eq_normalized(&render(input), expected);
}

#[test]
fn restores_mangled_babel_loose_tagged_template() {
    // babel-7.8-loose-terser-compress-mangle: the helper body is
    // `n.raw = r` with a `.slice(0)` copy — no Object.freeze.
    // Full pipeline: SimplifySequence normalizes the comma-return into
    // separate statements before helper detection runs.
    let input = r#"
function n(){const t=r(["hello ",""]);return n=function(){return t},t}
function r(n,r){return r||(r=n.slice(0)),n.raw=r,n}
var t=tag(n(),name);
"#;
    let expected = r#"
const t = tag`hello ${name}`;
"#;
    assert_eq_normalized(&render(input), expected);
}

#[test]
fn restores_mangled_tsc_tagged_template() {
    // tsc-es5-terser-compress-mangle: uses Object.defineProperty(e, "raw", ...)
    // instead of Object.freeze(Object.defineProperties(...)).
    let input = r#"
var e=this&&this.__makeTemplateObject||function(e,t){return Object.defineProperty?Object.defineProperty(e,"raw",{value:t}):e.raw=t,e},t=tag(e(["hello ",""],["hello ",""]),name);
"#;
    let expected = r#"
const t = tag`hello ${name}`;
"#;
    assert_eq_normalized(&render(input), expected);
}

#[test]
fn removes_consumed_template_cache_from_shared_var_decl() {
    let input = r#"
var _templateObject, keep = 1;
function _taggedTemplateLiteral(e, t) { return e; }
var out = tag(_templateObject || (_templateObject = _taggedTemplateLiteral(["hello ", ""], ["hello ", ""])), name);
"#;
    let expected = r#"
var keep = 1;
var out = tag`hello ${name}`;
"#;
    let output = apply(input);
    assert_eq_normalized(&output, expected);
}