cssupgrade 0.0.0-stage → 2026.0.0

package/src/pool.js

@@ -0,0 +1,165 @@
+import os from "os"
+import { Worker } from "worker_threads"
+
+/**
+ * @typedef {(filePath: string, options: Object, worker: TransformWorker) => Promise<{modified: boolean, error: boolean}>} FileProcessorFunction
+ */
+
+/**
+ * Restore an error posted by a transform worker.
+ *
+ * @param {{name: string, message: string, stack: string | undefined}} errorData - Plain error data.
+ * @returns {Error} Error carrying the worker name, message, and stack.
+ */
+function reviveError({ name, message, stack }) {
+  return Object.assign(new Error(message), { name, stack })
+}
+
+/**
+ * Loading the transformation pipeline takes tens of milliseconds, so one worker
+ * transforms many files instead of being spawned for a single file.
+ */
+export class TransformWorker {
+  #worker
+  #pending = null
+  #stopError = null
+
+  /**
+   * @param {string | URL} workerPath - Path of the worker thread module
+   */
+  constructor(workerPath) {
+    this.#worker = new Worker(workerPath)
+    this.#worker.on("message", (message) => this.#settle(message))
+    this.#worker.on("error", (error) => this.#stop(error))
+    this.#worker.on("exit", (code) =>
+      this.#stop(new Error(`Worker stopped with exit code ${code}`)),
+    )
+  }
+
+  get stopped() {
+    return this.#stopError !== null
+  }
+
+  /**
+   * A stopped thread drops posted messages without a response, so requests fail
+   * immediately instead of waiting for a reply that never comes. One request runs
+   * at a time, so a second request fails loudly instead of losing the first.
+   *
+   * @param {{filePath: string, baseline: string, includeOriginal: boolean}} request - File to transform
+   * @returns {Promise<Object>} Worker response message
+   */
+  transform(request) {
+    if (this.#stopError) {
+      return Promise.reject(this.#stopError)
+    }
+
+    if (this.#pending) {
+      return Promise.reject(new Error("Worker already transformed a file"))
+    }
+
+    return new Promise((resolve, reject) => {
+      this.#pending = { resolve, reject }
+      this.#worker.postMessage(request)
+    })
+  }
+
+  /**
+   * @returns {Promise<number>} Exit code of the stopped thread
+   */
+  terminate() {
+    return this.#worker.terminate()
+  }
+
+  /**
+   * @param {Object} message - Worker response message
+   */
+  #settle(message) {
+    this.#pending?.resolve(
+      message.success ? message : { ...message, error: reviveError(message.error) },
+    )
+    this.#pending = null
+  }
+
+  /**
+   * @param {Error} error - Reason the worker stopped
+   */
+  #stop(error) {
+    this.#stopError ??= error
+    this.#pending?.reject(error)
+    this.#pending = null
+  }
+}
+
+/**
+ * Each worker loads the transformation pipeline once and then processes files
+ * until the queue is empty. A worker that stopped is replaced before it takes on
+ * the next file, so one stopped thread cannot fail the remaining files.
+ */
+export class WorkerPool {
+  #fileProcessor
+  #workerPath
+  #maxWorkers
+
+  /**
+   * @param {FileProcessorFunction} fileProcessor - Processor that handles one file
+   * @param {string | URL} workerPath - Path of the worker thread module
+   * @param {number} [maxWorkers] - Upper bound of concurrent workers
+   */
+  constructor(fileProcessor, workerPath, maxWorkers = os.availableParallelism()) {
+    this.#fileProcessor = fileProcessor
+    this.#workerPath = workerPath
+    this.#maxWorkers = maxWorkers
+  }
+
+  /**
+   * The results keep the input order of the given files.
+   *
+   * @param {string[]} files - Files to process
+   * @param {Object} options - Processing options
+   * @returns {Promise<Array<{modified: boolean, error: boolean}>>} Result per file
+   */
+  async processFiles(files, options) {
+    const results = new Array(files.length)
+    let fileIndex = 0
+
+    const processQueue = async () => {
+      let worker = new TransformWorker(this.#workerPath)
+
+      try {
+        while (fileIndex < files.length) {
+          const currentIndex = fileIndex++
+          results[currentIndex] = await this.#fileProcessor(
+            files[currentIndex],
+            options,
+            worker,
+          )
+          worker = await this.#replaceStoppedWorker(worker)
+        }
+      } finally {
+        await worker.terminate()
+      }
+    }
+
+    const workerCount = Math.min(this.#maxWorkers, files.length)
+    const queues = Array.from({ length: workerCount }, processQueue)
+    await Promise.all(queues)
+
+    return results
+  }
+
+  /**
+   * Provide a running worker for the next file.
+   *
+   * @param {TransformWorker} worker - Worker that handled the previous file
+   * @returns {Promise<TransformWorker>} The worker itself, or a replacement
+   */
+  async #replaceStoppedWorker(worker) {
+    if (!worker.stopped) {
+      return worker
+    }
+
+    await worker.terminate()
+
+    return new TransformWorker(this.#workerPath)
+  }
+}

package/src/prefilters.js

@@ -0,0 +1,29 @@
+/**
+ * Source text conditions that decide whether a transformer can match.
+ *
+ * Every transformer parses the whole source, which dominates the runtime of
+ * this package. A transformer can only match when its pattern occurs in the
+ * source text, so testing the text first skips the parse for transformations
+ * that cannot apply.
+ */
+
+/**
+ * Conditions a transformer needs in the source text. A transformer runs when all
+ * of its conditions match. Each condition must be necessary: when the source
+ * text fails a condition, the transformer cannot change the tree.
+ *
+ * @type {Map<string, RegExp[]>}
+ */
+export const prefilters = new Map([
+  // Nesting needs two rules, so the source holds at least two blocks.
+  ["cssNesting", [/\{[\s\S]*\{/]],
+])
+
+/**
+ * @param {string} name - Transformer name
+ * @param {string} code - Source text of the current transformation pass
+ * @returns {boolean} True when the transformer needs to run
+ */
+export function matchesPrefilter(name, code) {
+  return prefilters.get(name).every((condition) => condition.test(code))
+}