esupgrade 2025.3.0 → 2025.3.1

package/tests/index.test.js

@@ -1,274 +1,291 @@
 import { describe, test } from "node:test"
-import assert from "node:assert"
+import assert from "node:assert/strict"
 import { transform } from "../src/index.js"
 
-describe("index", () => {
-  describe("transform function", () => {
-    test("should return TransformResult with correct structure", () => {
-      const input = `var x = 1;`
-      const result = transform(input)
-
-      assert.ok(result.hasOwnProperty("code"))
-      assert.ok(result.hasOwnProperty("modified"))
-      assert.ok(result.hasOwnProperty("changes"))
-      assert.strictEqual(typeof result.code, "string")
-      assert.strictEqual(typeof result.modified, "boolean")
-      assert.ok(Array.isArray(result.changes))
-    })
-
-    test("should handle empty string", () => {
-      const input = ``
-      const result = transform(input)
-
-      assert.strictEqual(result.modified, false)
-      assert.strictEqual(result.changes.length, 0)
-      assert.strictEqual(result.code, "")
-    })
-
-    test("should handle whitespace-only string", () => {
-      const input = `   \n\n   `
-      const result = transform(input)
+describe("transform", () => {
+  test("return TransformResult with correct structure", () => {
+    const result = transform(`var x = 1;`)
+    assert(result.hasOwnProperty("code"), "result has code property")
+    assert(result.hasOwnProperty("modified"), "result has modified property")
+    assert(result.hasOwnProperty("changes"), "result has changes property")
+    assert(typeof result.code === "string", "code is string")
+    assert(typeof result.modified === "boolean", "modified is boolean")
+    assert(Array.isArray(result.changes), "changes is array")
+  })
 
-      assert.strictEqual(result.modified, false)
-      assert.strictEqual(result.changes.length, 0)
-    })
+  test("handle empty string", () => {
+    const result = transform(``)
+    assert(!result.modified, "modified is false for empty string")
+    assert(result.changes.length === 0, "changes length is 0")
+    assert(result.code === "", "code is empty")
+  })
 
-    test("should handle comments only", () => {
-      const input = `// This is a comment\n/* Another comment */`
-      const result = transform(input)
+  test("handle whitespace-only string", () => {
+    const result = transform(`   \n\n   `)
+    assert(!result.modified, "modified is false for whitespace")
+    assert(result.changes.length === 0, "changes length is 0")
+  })
 
-      assert.strictEqual(result.modified, false)
-      assert.strictEqual(result.changes.length, 0)
-    })
+  test("handle comments only", () => {
+    const result = transform(`// This is a comment\n/* Another comment */`)
+    assert(!result.modified, "modified is false for comments")
+    assert(result.changes.length === 0, "changes length is 0")
+  })
 
-    test("should apply multiple transformations and track all changes", () => {
-      const input = `
+  test("apply multiple transformations and track all changes", () => {
+    const result = transform(`
         var x = 1;
         var y = 'Hello ' + name;
         var obj = Object.assign({}, data);
-      `
-      const result = transform(input)
-
-      assert.strictEqual(result.modified, true)
-      assert.ok(result.changes.length > 0)
-
-      // Should have changes from varToConst (which does track line numbers)
-      const changeTypes = result.changes.map((c) => c.type)
-      assert.ok(changeTypes.includes("varToConst"))
-
-      // Verify the transformations happened even if not all are tracked
-      assert.match(result.code, /const/)
-      assert.match(result.code, /`Hello/)
-      assert.match(result.code, /\.\.\.data/)
-    })
+      `)
+    assert(result.modified, "modified is true")
+    assert(result.changes.length > 0, "changes length greater than 0")
+    const changeTypes = result.changes.map((c) => c.type)
+    assert(changeTypes.includes("varToConst"), "changes include varToConst")
+    assert.match(result.code, /const/, "code contains const")
+    assert.match(result.code, /`Hello/, "code contains template literal")
+    assert.match(result.code, /\.\.\.data/, "code contains spread")
+  })
 
-    test("should aggregate changes from multiple transformers", () => {
-      const input = `
+  test("aggregate changes from multiple transformers", () => {
+    const result = transform(
+      `
         var a = 1;
         var b = 'Hello ' + world;
         Array.from(items).forEach(item => console.log(item));
-      `
-      const result = transform(input, "widely-available")
-
-      assert.strictEqual(result.modified, true)
-
-      // Should track line numbers for all changes
-      assert.ok(result.changes.every((c) => c.hasOwnProperty("line")))
-      assert.ok(result.changes.every((c) => c.hasOwnProperty("type")))
-    })
-
-    test("should use widely-available transformers by default", () => {
-      const input = `var x = 1;`
-      const result = transform(input)
+      `,
+      "widely-available",
+    )
+    assert(result.modified, "modified is true")
+    assert(
+      result.changes.every((c) => c.hasOwnProperty("line")),
+      "all changes have line property",
+    )
+    assert(
+      result.changes.every((c) => c.hasOwnProperty("type")),
+      "all changes have type property",
+    )
+  })
 
-      assert.strictEqual(result.modified, true)
-      assert.strictEqual(result.changes[0].type, "varToConst")
-    })
+  test("use widely-available transformers by default", () => {
+    const result = transform(`var x = 1;`)
+    assert(result.modified, "modified is true")
+    assert(result.changes[0].type === "varToConst", "first change type is varToConst")
+  })
 
-    test("should include newly-available transformers when specified", () => {
-      const input = `
+  test("include newly-available transformers when specified", () => {
+    const result = transform(
+      `
         var x = 1;
         const p = new Promise((resolve) => resolve(getData()));
-      `
-      const result = transform(input, "newly-available")
-
-      assert.strictEqual(result.modified, true)
-
-      const changeTypes = result.changes.map((c) => c.type)
-      assert.ok(changeTypes.includes("varToConst"))
-      assert.ok(changeTypes.includes("promiseTry"))
-    })
+      `,
+      "newly-available",
+    )
+    assert(result.modified, "modified is true")
+    const changeTypes = result.changes.map((c) => c.type)
+    assert(changeTypes.includes("varToConst"), "changes include varToConst")
+    assert(changeTypes.includes("promiseTry"), "changes include promiseTry")
+  })
 
-    test("should handle complex nested structures", () => {
-      const input = `
+  test("handle complex nested structures", () => {
+    const result = transform(`
         function test() {
           var result = Object.assign({}, {
             message: 'Hello ' + name
           });
           return result;
         }
-      `
-      const result = transform(input)
-
-      assert.strictEqual(result.modified, true)
-      assert.match(result.code, /const result/)
-      assert.match(result.code, /\.\.\./)
-      assert.match(result.code, /`Hello/)
-    })
+      `)
+    assert(result.modified, "modified is true")
+    assert.match(result.code, /const result/, "code contains const result")
+    assert.match(result.code, /\.\.\./, "code contains spread")
+    assert.match(result.code, /`Hello/, "code contains template literal")
+  })
 
-    test("should handle JSX syntax", () => {
-      const input = `
+  test("handle JSX syntax", () => {
+    const result = transform(`
         var Component = () => {
           var title = 'Hello ' + name;
           return <div>{title}</div>;
         };
-      `
-      const result = transform(input)
-
-      assert.strictEqual(result.modified, true)
-      assert.match(result.code, /const/)
-      assert.match(result.code, /<div>/)
-    })
+      `)
+    assert(result.modified, "modified is true")
+    assert.match(result.code, /const/, "code contains const")
+    assert.match(result.code, /<div>/, "code contains JSX")
+  })
 
-    test("should handle TypeScript syntax", () => {
-      const input = `
+  test("handle TypeScript syntax", () => {
+    const result = transform(`
         var x: number = 1;
         const greeting: string = 'Hello ' + name;
-      `
-      const result = transform(input)
+      `)
+    assert(result.modified, "modified is true")
+    assert.match(result.code, /const x: number/, "code contains const x: number")
+    assert.match(result.code, /`Hello/, "code contains template literal")
+  })
 
-      assert.strictEqual(result.modified, true)
-      assert.match(result.code, /const x: number/)
-      assert.match(result.code, /`Hello/)
-    })
+  test("preserve code formatting structure", () => {
+    const result = transform(`var x = 1;
+var y = 2;`)
+    assert.match(result.code, /const x = 1/, "code contains const x = 1")
+    assert.match(result.code, /const y = 2/, "code contains const y = 2")
+  })
 
-    test("should preserve code formatting structure", () => {
-      const input = `var x = 1;
-var y = 2;`
-      const result = transform(input)
+  test("handle very large code", () => {
+    const lines = []
+    for (let i = 0; i < 100; i++) {
+      lines.push(`var x${i} = ${i};`)
+    }
+    const result = transform(lines.join("\n"))
+    assert(result.modified, "modified is true")
+    assert(result.changes.length === 100, "changes length is 100")
+    assert.match(result.code, /const x0 = 0/, "code contains const x0 = 0")
+    assert.match(result.code, /const x99 = 99/, "code contains const x99 = 99")
+  })
 
-      // Should maintain separation between statements
-      assert.match(result.code, /const x = 1/)
-      assert.match(result.code, /const y = 2/)
-    })
+  test("handle code with special characters", () => {
+    const result = transform(`var msg = 'Hello \\n' + 'World\\t!';`)
+    assert(result.modified, "modified is true")
+    assert.match(result.code, /const msg/, "code contains const msg")
+    assert.match(result.code, /`Hello/, "code contains template literal")
+  })
 
-    test("should handle very large code", () => {
-      // Generate a large input with many var declarations
-      const lines = []
-      for (let i = 0; i < 100; i++) {
-        lines.push(`var x${i} = ${i};`)
-      }
-      const input = lines.join("\n")
+  test("handle code with unicode characters", () => {
+    const result = transform(`var msg = 'Hello ' + '世界' + '!';`)
+    assert(result.modified, "modified is true")
+    assert.match(result.code, /const msg/, "code contains const msg")
+  })
 
-      const result = transform(input)
+  test("handle all transformers returning no changes", () => {
+    const result = transform(`const x = 1; const y = 2;`)
+    assert(!result.modified, "modified is false")
+    assert(result.changes.length === 0, "changes length is 0")
+  })
 
-      assert.strictEqual(result.modified, true)
-      assert.strictEqual(result.changes.length, 100)
-      assert.match(result.code, /const x0 = 0/)
-      assert.match(result.code, /const x99 = 99/)
-    })
+  test("handle baseline parameter case sensitivity", () => {
+    const result1 = transform(`var x = 1;`, "widely-available")
+    assert(result1.modified, "modified is true for widely-available")
+    const result2 = transform(`var x = 1;`, "newly-available")
+    assert(result2.modified, "modified is true for newly-available")
+  })
 
-    test("should handle code with special characters", () => {
-      const input = `var msg = 'Hello \\n' + 'World\\t!';`
-      const result = transform(input)
+  test("merge transformers correctly for newly-available", () => {
+    const result = transform(
+      `
+        var x = 1;
+        var obj = Object.assign({}, data);
+        const p = new Promise((resolve) => resolve(getData()));
+      `,
+      "newly-available",
+    )
+    assert(result.modified, "modified is true")
+    const changeTypes = result.changes.map((c) => c.type)
+    assert(changeTypes.includes("varToConst"), "changes include varToConst")
+    assert(changeTypes.includes("promiseTry"), "changes include promiseTry")
+    assert.match(result.code, /const/, "code contains const")
+    assert.match(result.code, /\.\.\.data/, "code contains spread")
+    assert.match(result.code, /Promise\.try/, "code contains Promise.try")
+  })
 
-      assert.strictEqual(result.modified, true)
-      assert.match(result.code, /const msg/)
-      // Template literals preserve the escape sequences
-      assert.match(result.code, /`Hello/)
-    })
+  test("handle code without location info gracefully", () => {
+    const result = transform(`var x = 1;`)
+    assert(result.modified, "modified is true")
+  })
 
-    test("should handle code with unicode characters", () => {
-      const input = `var msg = 'Hello ' + '世界' + '!';`
-      const result = transform(input)
+  test("generate valid JavaScript output", () => {
+    const result = transform(`
+        var x = 1;
+        var greeting = 'Hello ' + name;
+        Array.from(items).forEach(item => console.log(item));
+      `)
+    assert.doesNotThrow(() => {
+      new Function(result.code)
+    }, "code is valid JavaScript")
+  })
 
-      assert.strictEqual(result.modified, true)
-      assert.match(result.code, /const msg/)
-    })
+  test("handle single-line code", () => {
+    const result = transform(`var x = 1; var y = 2; var z = 3;`)
+    assert(result.modified, "modified is true")
+    assert.match(result.code, /const x = 1/, "code contains const x = 1")
+    assert.match(result.code, /const y = 2/, "code contains const y = 2")
+    assert.match(result.code, /const z = 3/, "code contains const z = 3")
+  })
 
-    test("should handle all transformers returning no changes", () => {
-      const input = `const x = 1; const y = 2;`
-      const result = transform(input)
+  test("handle code with existing template literals", () => {
+    const result = transform(`
+        var msg = \`Hello \${name}\`;
+        var other = 'Test ' + value;
+      `)
+    assert(result.modified, "modified is true")
+    assert.match(result.code, /const msg/, "code contains const msg")
+    assert.match(result.code, /const other/, "code contains const other")
+  })
+})
 
-      assert.strictEqual(result.modified, false)
-      assert.strictEqual(result.changes.length, 0)
+describe("transformers", () => {
+  describe("varToConst", () => {
+    test("transform var to const", () => {
+      assert(transform(`var x = 1;`).modified)
+      assert.match(transform(`var x = 1;`).code, /const/)
     })
 
-    test("should handle baseline parameter case sensitivity", () => {
-      const input = `var x = 1;`
-
-      // Should accept exact strings
-      const result1 = transform(input, "widely-available")
-      assert.strictEqual(result1.modified, true)
-
-      const result2 = transform(input, "newly-available")
-      assert.strictEqual(result2.modified, true)
+    test("transform multiple vars to consts", () => {
+      const result = transform(`var x = 1; var y = 2;`)
+      assert(result.modified)
+      assert.match(result.code, /const x = 1/)
+      assert.match(result.code, /const y = 2/)
     })
+  })
 
-    test("should merge transformers correctly for newly-available", () => {
-      const input = `
-        var x = 1;
-        var obj = Object.assign({}, data);
-        const p = new Promise((resolve) => resolve(getData()));
-      `
-      const result = transform(input, "newly-available")
-
-      assert.strictEqual(result.modified, true)
-
-      // Should have changes from transformers that track line numbers
-      const changeTypes = result.changes.map((c) => c.type)
-      assert.ok(changeTypes.includes("varToConst")) // from widely-available
-      assert.ok(changeTypes.includes("promiseTry")) // from newly-available
-
-      // Verify all transformations happened
-      assert.match(result.code, /const/)
-      assert.match(result.code, /\.\.\.data/)
-      assert.match(result.code, /Promise\.try/)
+  describe("stringConcatToTemplate", () => {
+    test("transform string concat to template literal", () => {
+      const result = transform(`var msg = 'Hello ' + name;`)
+      assert(result.modified)
+      assert.match(result.code, /const msg/)
+      assert.match(result.code, /`Hello/)
     })
 
-    test("should handle code without location info gracefully", () => {
-      // Even if some transformations don't have location info, should still work
-      const input = `var x = 1;`
-      const result = transform(input)
-
-      assert.strictEqual(result.modified, true)
-      // Should handle missing loc info gracefully
+    test("transform complex concat to template", () => {
+      const result = transform(`var greeting = 'Hello ' + name + '!';`)
+      assert(result.modified)
+      assert.match(result.code, /const greeting/)
+      assert.match(result.code, /`Hello/)
     })
+  })
 
-    test("should generate valid JavaScript output", () => {
-      const input = `
-        var x = 1;
-        var greeting = 'Hello ' + name;
-        Array.from(items).forEach(item => console.log(item));
-      `
-      const result = transform(input)
-
-      // Try to parse the output to ensure it's valid JS
-      assert.doesNotThrow(() => {
-        new Function(result.code)
-      })
+  describe("objectAssignToSpread", () => {
+    test("transform Object.assign to spread", () => {
+      const result = transform(`var obj = Object.assign({}, data);`)
+      assert(result.modified)
+      assert.match(result.code, /const obj/)
+      assert.match(result.code, /\.\.\.data/)
     })
 
-    test("should handle single-line code", () => {
-      const input = `var x = 1; var y = 2; var z = 3;`
-      const result = transform(input)
-
-      assert.strictEqual(result.modified, true)
-      assert.match(result.code, /const x = 1/)
-      assert.match(result.code, /const y = 2/)
-      assert.match(result.code, /const z = 3/)
+    test("transform nested Object.assign", () => {
+      const result = transform(`var result = Object.assign({}, { message: 'test' });`)
+      assert(result.modified)
+      assert.match(result.code, /const result/)
+      assert.match(result.code, /\.\.\./)
     })
+  })
 
-    test("should handle code with existing template literals", () => {
-      const input = `
-        var msg = \`Hello \${name}\`;
-        var other = 'Test ' + value;
-      `
-      const result = transform(input)
+  describe("promiseTry", () => {
+    test("transform Promise constructor to Promise.try", () => {
+      const result = transform(
+        `const p = new Promise((resolve) => resolve(getData()));`,
+        "newly-available",
+      )
+      assert(result.modified)
+      assert.match(result.code, /Promise\.try/)
+    })
 
-      assert.strictEqual(result.modified, true)
-      assert.match(result.code, /const msg/)
-      assert.match(result.code, /const other/)
+    test("transform Promise with resolve", () => {
+      const result = transform(
+        `const p = new Promise((resolve) => resolve(data));`,
+        "newly-available",
+      )
+      assert(result.modified)
+      assert.match(result.code, /Promise\.try/)
     })
   })
 })