cssupgrade 0.0.0-stage → 2026.0.0

package/tests/fixtures/silent-worker.js

@@ -0,0 +1,5 @@
+import { parentPort } from "worker_threads"
+
+/** Worker thread that ignores every request. Used to test worker shutdown. */
+
+parentPort.on("message", () => {})

package/tests/general.test.js

@@ -0,0 +1,42 @@
+import assert from "node:assert/strict"
+import { describe, test } from "node:test"
+import { transform } from "../src/index.js"
+
+describe("transform", () => {
+  test("leave flat CSS without repeated selectors unchanged", () => {
+    const result = transform(".a {\n  color: red;\n}\n\n.b {\n  color: blue;\n}\n")
+
+    assert.equal(result.modified, false)
+    assert.equal(result.code, ".a {\n  color: red;\n}\n\n.b {\n  color: blue;\n}\n")
+  })
+
+  test("nest rules with the newly available baseline", () => {
+    const result = transform(
+      ".a { color: red } .a .b { color: blue }",
+      "newly-available",
+    )
+
+    assert.equal(result.modified, true)
+    assert.equal(result.code, ".a {\n  color: red;\n  .b {\n    color: blue;\n  }\n}")
+  })
+
+  test("produce a stable result on a second pass", () => {
+    const first = transform(".a { color: red } .a .b { color: blue }")
+    const second = transform(first.code)
+
+    assert.equal(second.modified, false)
+    assert.equal(second.code, first.code)
+  })
+
+  test("leave existing nesting unchanged", () => {
+    const result = transform(".a { color: red; .b { color: blue } }")
+
+    assert.equal(result.modified, false)
+  })
+
+  test("leave keyframes unchanged", () => {
+    const result = transform("@keyframes fade { from { opacity: 0 } }")
+
+    assert.equal(result.modified, false)
+  })
+})

package/tests/parser.test.js

@@ -0,0 +1,43 @@
+import assert from "node:assert/strict"
+import { describe, test } from "node:test"
+import { parseCss } from "../src/parser.js"
+
+describe("parseCss", () => {
+  test("record comments", () => {
+    const { comments } = parseCss(".a { /* one */ color: red; /* two */ }")
+
+    assert.deepEqual(
+      comments.map(({ start, end }) =>
+        ".a { /* one */ color: red; /* two */ }".slice(start, end),
+      ),
+      ["/* one */", "/* two */"],
+    )
+  })
+
+  test("parse flat rules", () => {
+    const { ast } = parseCss(".a { color: red } .a .b { color: blue }")
+
+    assert.deepEqual(
+      Array.from(ast.children, (child) => child.type),
+      ["Rule", "Rule"],
+    )
+  })
+
+  test("parse nested rules as raw declarations", () => {
+    const { ast } = parseCss(".a { .b { color: red } }")
+
+    assert.equal(ast.children.first.block.children.first.type, "Raw")
+  })
+
+  test("parse a custom property with a block value as a declaration", () => {
+    const { ast } = parseCss(".a { --theme: { color: red; }; }")
+
+    assert.equal(ast.children.first.block.children.first.type, "Declaration")
+  })
+
+  test("parse a stray semicolon as raw", () => {
+    const { ast } = parseCss(".a { ; }")
+
+    assert.equal(ast.children.first.block.children.first.type, "Raw")
+  })
+})

package/tests/pool.test.js

@@ -0,0 +1,242 @@
+import assert from "node:assert/strict"
+import fs from "node:fs"
+import os from "node:os"
+import path from "node:path"
+import { afterEach, beforeEach, describe, test } from "node:test"
+import { TransformWorker, WorkerPool } from "../src/pool.js"
+
+const WORKER_PATH = path.join(process.cwd(), "src", "worker.js")
+const SILENT_WORKER_PATH = path.join(
+  process.cwd(),
+  "tests",
+  "fixtures",
+  "silent-worker.js",
+)
+const DEEP_AT_RULE_CSS = `${"@media all {".repeat(10_000)}.a { } .a .b { color: red }${"}".repeat(10_000)}`
+
+/**
+ * Collect the workers a pool used while processing files.
+ *
+ * @returns {{fileProcessor: Function, usedWorkers: Set<TransformWorker>}} Stub processor
+ */
+function createRecordingProcessor() {
+  const usedWorkers = new Set()
+
+  return {
+    usedWorkers,
+    async fileProcessor(filePath, options, worker) {
+      usedWorkers.add(worker)
+
+      return { modified: false, error: false }
+    },
+  }
+}
+
+describe("TransformWorker", () => {
+  let tempDir
+
+  beforeEach(() => {
+    tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "cssupgrade-pool-"))
+  })
+
+  afterEach(() => {
+    if (tempDir && fs.existsSync(tempDir)) {
+      fs.rmSync(tempDir, { recursive: true, force: true })
+    }
+  })
+
+  test("transform a file in a worker thread", async () => {
+    const filePath = path.join(tempDir, "legacy.css")
+    fs.writeFileSync(filePath, ".a { color: red } .a .b { color: blue }")
+    const worker = new TransformWorker(WORKER_PATH)
+
+    const message = await worker.transform({
+      filePath,
+      baseline: "widely-available",
+      includeOriginal: true,
+    })
+    await worker.terminate()
+
+    assert.equal(message.success, true, "reports success")
+    assert.equal(message.result.modified, true, "reports the change")
+    assert.equal(
+      message.result.code,
+      ".a {\n  color: red;\n  .b {\n    color: blue;\n  }\n}",
+      "transforms the code",
+    )
+    assert.match(message.result.original, /\.a \.b/, "returns the original source")
+  })
+
+  test("omit the original source when it is not requested", async () => {
+    const filePath = path.join(tempDir, "legacy.css")
+    fs.writeFileSync(filePath, ".a { color: red } .a .b { color: blue }")
+    const worker = new TransformWorker(WORKER_PATH)
+
+    const message = await worker.transform({
+      filePath,
+      baseline: "widely-available",
+      includeOriginal: false,
+    })
+    await worker.terminate()
+
+    assert.equal(message.result.modified, true, "reports the change")
+    assert.equal(
+      message.result.code,
+      ".a {\n  color: red;\n  .b {\n    color: blue;\n  }\n}",
+      "transforms the code",
+    )
+    assert.equal(message.result.original, undefined, "omits the original source")
+  })
+
+  test("report files the worker cannot read", async () => {
+    const worker = new TransformWorker(WORKER_PATH)
+
+    const message = await worker.transform({
+      filePath: path.join(tempDir, "missing.css"),
+      baseline: "widely-available",
+      includeOriginal: true,
+    })
+    await worker.terminate()
+
+    assert.equal(message.success, false, "reports a failure")
+    assert.ok(message.error instanceof Error, "restores an error object")
+    assert.match(message.error.message, /ENOENT/, "reports the read failure")
+  })
+
+  test("report the transform error of a file", async () => {
+    const filePath = path.join(tempDir, "broken.css")
+    fs.writeFileSync(filePath, DEEP_AT_RULE_CSS)
+    const worker = new TransformWorker(WORKER_PATH)
+
+    const message = await worker.transform({
+      filePath,
+      baseline: "widely-available",
+      includeOriginal: false,
+    })
+    await worker.terminate()
+
+    assert.equal(message.success, false, "reports a failure")
+    assert.equal(message.error.name, "RangeError", "keeps the error name")
+    assert.match(
+      message.error.message,
+      /Maximum call stack size exceeded/,
+      "keeps the transform error message",
+    )
+    assert.match(message.error.stack, /\n\s*at /, "keeps the stack trace")
+  })
+
+  test("reject pending requests when the worker stops", async () => {
+    const worker = new TransformWorker(SILENT_WORKER_PATH)
+    const pending = worker.transform({
+      filePath: "unused.css",
+      baseline: "widely-available",
+      includeOriginal: false,
+    })
+
+    await worker.terminate()
+
+    await assert.rejects(
+      pending,
+      { name: "Error", message: /^Worker stopped with exit code \d+$/ },
+      "rejects the request",
+    )
+  })
+
+  test("reject a second request while one is in flight", async () => {
+    const worker = new TransformWorker(SILENT_WORKER_PATH)
+    const inFlight = worker.transform({
+      filePath: "unused.css",
+      baseline: "widely-available",
+      includeOriginal: false,
+    })
+
+    await assert.rejects(
+      worker.transform({
+        filePath: "unused.css",
+        baseline: "widely-available",
+        includeOriginal: false,
+      }),
+      { message: "Worker already transformed a file" },
+      "rejects the second request",
+    )
+
+    await worker.terminate()
+    await assert.rejects(inFlight, "rejects the request still in flight")
+  })
+
+  test("reject requests sent to a stopped worker", async () => {
+    const worker = new TransformWorker(SILENT_WORKER_PATH)
+    await worker.terminate()
+
+    await assert.rejects(
+      worker.transform({
+        filePath: "unused.css",
+        baseline: "widely-available",
+        includeOriginal: false,
+      }),
+      { name: "Error", message: /^Worker stopped with exit code \d+$/ },
+      "rejects the request",
+    )
+  })
+
+  test("reject requests when the worker module fails to load", async () => {
+    const worker = new TransformWorker(path.join(tempDir, "missing-worker.js"))
+
+    await assert.rejects(
+      worker.transform({
+        filePath: "unused.css",
+        baseline: "widely-available",
+        includeOriginal: false,
+      }),
+      { code: "MODULE_NOT_FOUND" },
+      "rejects the request",
+    )
+  })
+})
+
+describe("WorkerPool", () => {
+  test("process files with a limited number of workers", async () => {
+    const files = ["a.css", "b.css", "c.css", "d.css"]
+    const { fileProcessor, usedWorkers } = createRecordingProcessor()
+    const pool = new WorkerPool(fileProcessor, SILENT_WORKER_PATH, 2)
+
+    const results = await pool.processFiles(files, {})
+
+    assert.equal(results.length, files.length, "returns one result per file")
+    assert.deepEqual(
+      results.map((result) => result.modified),
+      [false, false, false, false],
+      "keeps the input order",
+    )
+    assert.equal(usedWorkers.size, 2, "reuses workers across files")
+  })
+
+  test("replace a worker that stopped", async () => {
+    const files = ["a.css", "b.css"]
+    const usedWorkers = new Set()
+
+    async function stopAfterFile(filePath, options, worker) {
+      usedWorkers.add(worker)
+      await worker.terminate()
+
+      return { modified: false, error: false }
+    }
+
+    const pool = new WorkerPool(stopAfterFile, SILENT_WORKER_PATH, 1)
+
+    const results = await pool.processFiles(files, {})
+
+    assert.equal(results.length, files.length, "processes every file")
+    assert.equal(usedWorkers.size, 2, "spawns a replacement worker")
+  })
+
+  test("process no files without spawning a worker", async () => {
+    const { fileProcessor, usedWorkers } = createRecordingProcessor()
+    const pool = new WorkerPool(fileProcessor, SILENT_WORKER_PATH, 2)
+
+    const results = await pool.processFiles([], {})
+
+    assert.deepEqual(results, [], "returns no results")
+    assert.equal(usedWorkers.size, 0, "spawns no worker")
+  })
+})

package/tests/prefilters.test.js

@@ -0,0 +1,24 @@
+import assert from "node:assert/strict"
+import { describe, test } from "node:test"
+import * as newlyAvailable from "../src/newlyAvailable.js"
+import { matchesPrefilter, prefilters } from "../src/prefilters.js"
+import * as widelyAvailable from "../src/widelyAvailable.js"
+
+describe("prefilters", () => {
+  test("accept CSS that can contain nesting", () => {
+    assert.equal(matchesPrefilter("cssNesting", ".a { .b { color: red } }"), true)
+  })
+
+  test("reject CSS with a single block", () => {
+    assert.equal(matchesPrefilter("cssNesting", ".a { color: red }"), false)
+  })
+
+  test("declare a pre-filter for every transformer", () => {
+    const names = [...Object.keys(widelyAvailable), ...Object.keys(newlyAvailable)]
+
+    assert.deepEqual(
+      names.filter((name) => !prefilters.has(name)),
+      [],
+    )
+  })
+})