@rspack/core 1.3.15 → 1.4.0-beta.0

package/compiled/@swc/types/index.d.ts

@@ -635,6 +635,14 @@ interface JscConfig {
     };
     minify?: JsMinifyOptions;
     preserveAllComments?: boolean;
+    output?: {
+        /**
+         * This can be used to keep the output ascii-only.
+         * If this option is set, `minify.format.asciiOnly` will be ignored.
+         * @default 'utf8'
+         */
+        charset?: 'utf8' | 'ascii';
+    };
 }
 type JscTarget = "es3" | "es5" | "es2015" | "es2016" | "es2017" | "es2018" | "es2019" | "es2020" | "es2021" | "es2022" | "es2023" | "es2024" | "esnext";
 type ParserConfig = TsParserConfig | EsParserConfig;
@@ -774,6 +782,10 @@ interface TransformConfig {
      * https://www.typescriptlang.org/tsconfig#verbatimModuleSyntax
      */
     verbatimModuleSyntax?: boolean;
+    /**
+     * Native class properties support
+     */
+    nativeClassProperties?: boolean;
 }
 interface ReactConfig {
     /**
@@ -1059,6 +1071,10 @@ interface BaseModuleConfig {
     ignoreDynamic?: boolean;
     allowTopLevelThis?: boolean;
     preserveImportMeta?: boolean;
+    /**
+     * If set to true, This will resolve top .mjs
+     */
+    resolveFully?: boolean;
 }
 interface Es6Config extends BaseModuleConfig {
     type: "es6";
@@ -2098,9 +2114,9 @@ interface Invalid extends Node, HasSpan {
 }
 type WasmAnalysisOptions = {
     parser?: ParserConfig;
-    module?: true | false | 'unknown';
+    module?: true | false | "unknown";
     filename?: string;
-    errorFormat?: 'json' | 'normal';
+    errorFormat?: "json" | "normal";
     cacheRoot?: string;
     plugins: WasmPlugin[];
 };

package/compiled/@swc/types/package.json

@@ -1 +1 @@
-{"name":"@swc/types","author":"강동윤 <kdy1997.dev@gmail.com>","version":"0.1.21","license":"Apache-2.0","types":"index.d.ts","type":"commonjs"}
+{"name":"@swc/types","author":"강동윤 <kdy1997.dev@gmail.com>","version":"0.1.22","license":"Apache-2.0","types":"index.d.ts","type":"commonjs"}

package/compiled/tinypool/README.md

@@ -2,7 +2,7 @@
 
 > Piscina: A fast, efficient Node.js Worker Thread Pool implementation
 
-Tinypool is a fork of piscina. What we try to achieve in this library, is to eliminate some dependencies and features that our target users don't need (currently, our main user will be Vitest). Tinypool's install size (38KB) can then be smaller than Piscina's install size (6MB). If you need features like [utilization](https://github.com/piscinajs/piscina#property-utilization-readonly) or [NAPI](https://github.com/piscinajs/piscina#thread-priority-on-linux-systems), [Piscina](https://github.com/piscinajs/piscina) is a better choice for you. We think that Piscina is an amazing library, and we may try to upstream some of the dependencies optimization in this fork.
+Tinypool is a fork of piscina. What we try to achieve in this library, is to eliminate some dependencies and features that our target users don't need (currently, our main user will be Vitest). Tinypool's install size (38KB) can then be smaller than Piscina's install size (6MB). If you need features like [utilization](https://github.com/piscinajs/piscina#property-utilization-readonly) or OS-specific thread priority setting, [Piscina](https://github.com/piscinajs/piscina) is a better choice for you. We think that Piscina is an amazing library, and we may try to upstream some of the dependencies optimization in this fork.
 
 - ✅ Smaller install size, 38KB
 - ✅ Minimal
@@ -10,203 +10,11 @@ Tinypool is a fork of piscina. What we try to achieve in this library, is to eli
 - ✅ Physical cores instead of Logical cores with [physical-cpu-count](https://www.npmjs.com/package/physical-cpu-count)
 - ✅ Supports `worker_threads` and `child_process`
 - ❌ No utilization
-- ❌ No NAPI
+- ❌ No OS-specific thread priority setting
 
 - Written in TypeScript, and ESM support only. For Node.js 18.x and higher.
 
 _In case you need more tiny libraries like tinypool or tinyspy, please consider submitting an [RFC](https://github.com/tinylibs/rfcs)_
 
-## Example
-
-### Using `node:worker_threads`
-
-#### Basic usage
-
-```js
-// main.mjs
-import Tinypool from 'tinypool'
-
-const pool = new Tinypool({
-  filename: new URL('./worker.mjs', import.meta.url).href,
-})
-const result = await pool.run({ a: 4, b: 6 })
-console.log(result) // Prints 10
-
-// Make sure to destroy pool once it's not needed anymore
-// This terminates all pool's idle workers
-await pool.destroy()
-```
-
-```js
-// worker.mjs
-export default ({ a, b }) => {
-  return a + b
-}
-```
-
-#### Main thread <-> worker thread communication
-
-<details>
-  <summary>See code</summary>
-
-```js
-// main.mjs
-import Tinypool from 'tinypool'
-import { MessageChannel } from 'node:worker_threads'
-
-const pool = new Tinypool({
-  filename: new URL('./worker.mjs', import.meta.url).href,
-})
-const { port1, port2 } = new MessageChannel()
-const promise = pool.run({ port: port1 }, { transferList: [port1] })
-
-port2.on('message', (message) => console.log('Main thread received:', message))
-setTimeout(() => port2.postMessage('Hello from main thread!'), 1000)
-
-await promise
-
-port1.close()
-port2.close()
-```
-
-```js
-// worker.mjs
-export default ({ port }) => {
-  return new Promise((resolve) => {
-    port.on('message', (message) => {
-      console.log('Worker received:', message)
-
-      port.postMessage('Hello from worker thread!')
-      resolve()
-    })
-  })
-}
-```
-
-</details>
-
-### Using `node:child_process`
-
-#### Basic usage
-
-<details>
-  <summary>See code</summary>
-
-```js
-// main.mjs
-import Tinypool from 'tinypool'
-
-const pool = new Tinypool({
-  runtime: 'child_process',
-  filename: new URL('./worker.mjs', import.meta.url).href,
-})
-const result = await pool.run({ a: 4, b: 6 })
-console.log(result) // Prints 10
-```
-
-```js
-// worker.mjs
-export default ({ a, b }) => {
-  return a + b
-}
-```
-
-</details>
-
-#### Main process <-> worker process communication
-
-<details>
-  <summary>See code</summary>
-
-```js
-// main.mjs
-import Tinypool from 'tinypool'
-
-const pool = new Tinypool({
-  runtime: 'child_process',
-  filename: new URL('./worker.mjs', import.meta.url).href,
-})
-
-const messages = []
-const listeners = []
-const channel = {
-  onMessage: (listener) => listeners.push(listener),
-  postMessage: (message) => messages.push(message),
-}
-
-const promise = pool.run({}, { channel })
-
-// Send message to worker
-setTimeout(
-  () => listeners.forEach((listener) => listener('Hello from main process')),
-  1000
-)
-
-// Wait for task to finish
-await promise
-
-console.log(messages)
-// [{ received: 'Hello from main process', response: 'Hello from worker' }]
-```
-
-```js
-// worker.mjs
-export default async function run() {
-  return new Promise((resolve) => {
-    process.on('message', (message) => {
-      // Ignore Tinypool's internal messages
-      if (message?.__tinypool_worker_message__) return
-
-      process.send({ received: message, response: 'Hello from worker' })
-      resolve()
-    })
-  })
-}
-```
-
-</details>
-
-## API
-
-We have a similar API to Piscina, so for more information, you can read Piscina's detailed [documentation](https://github.com/piscinajs/piscina#piscina---the-nodejs-worker-pool) and apply the same techniques here.
-
-### Tinypool specific APIs
-
-#### Pool constructor options
-
-- `isolateWorkers`: Disabled by default. Always starts with a fresh worker when running tasks to isolate the environment.
-- `terminateTimeout`: Disabled by default. If terminating a worker takes `terminateTimeout` amount of milliseconds to execute, an error is raised.
-- `maxMemoryLimitBeforeRecycle`: Disabled by default. When defined, the worker's heap memory usage is compared against this value after task has been finished. If the current memory usage exceeds this limit, worker is terminated and a new one is started to take its place. This option is useful when your tasks leak memory and you don't want to enable `isolateWorkers` option.
-- `runtime`: Used to pick worker runtime. Default value is `worker_threads`.
-  - `worker_threads`: Runs workers in [`node:worker_threads`](https://nodejs.org/api/worker_threads.html). For `main thread <-> worker thread` communication you can use [`MessagePort`](https://nodejs.org/api/worker_threads.html#class-messageport) in the `pool.run()` method's [`transferList` option](https://nodejs.org/api/worker_threads.html#portpostmessagevalue-transferlist). See [example](#main-thread---worker-thread-communication).
-  - `child_process`: Runs workers in [`node:child_process`](https://nodejs.org/api/child_process.html). For `main thread <-> worker process` communication you can use `TinypoolChannel` in the `pool.run()` method's `channel` option. For filtering out the Tinypool's internal messages see `TinypoolWorkerMessage`. See [example](#main-process---worker-process-communication).
-
-#### Pool methods
-
-- `cancelPendingTasks()`: Gracefully cancels all pending tasks without stopping or interfering with on-going tasks. This method is useful when your tasks may have side effects and should not be terminated forcefully during task execution. If your tasks don't have any side effects you may want to use [`{ signal }`](https://github.com/piscinajs/piscina#cancelable-tasks) option for forcefully terminating all tasks, including the on-going ones, instead.
-- `recycleWorkers(options)`: Waits for all current tasks to finish and re-creates all workers. Can be used to force isolation imperatively even when `isolateWorkers` is disabled. Accepts `{ runtime }` option as argument.
-
-#### Exports
-
-- `workerId`: Each worker now has an id ( <= `maxThreads`) that can be imported from `tinypool` in the worker itself (or `process.__tinypool_state__.workerId`).
-
-## Authors
-
-| <a href="https://github.com/Aslemammad"> <img width='150' src="https://avatars.githubusercontent.com/u/37929992?v=4" /><br> Mohammad Bagher </a> |
-| ------------------------------------------------------------------------------------------------------------------------------------------------ |
-
-## Sponsors
-
-Your sponsorship can make a huge difference in continuing our work in open source!
-
-<p align="center">
-  <a href="https://cdn.jsdelivr.net/gh/aslemammad/static/sponsors.svg">
-    <img src='https://cdn.jsdelivr.net/gh/aslemammad/static/sponsors.svg'/>
-  </a>
-</p>
-
-## Credits
-
-[The Vitest team](https://vitest.dev/) for giving me the chance of creating and maintaing this project for vitest.
-
-[Piscina](https://github.com/piscinajs/piscina), because Tinypool is not more than a friendly fork of piscina.
+## Docs
+Read **[full docs](https://github.com/tinylibs/tinypool#readme)** on GitHub.

package/compiled/tinypool/dist/common-Qw-RoVFD.js

@@ -0,0 +1,28 @@
+//#region src/common.ts
+const kMovable = Symbol("Tinypool.kMovable");
+const kTransferable = Symbol.for("Tinypool.transferable");
+const kValue = Symbol.for("Tinypool.valueOf");
+const kQueueOptions = Symbol.for("Tinypool.queueOptions");
+function isTransferable(value) {
+	return value != null && typeof value === "object" && kTransferable in value && kValue in value;
+}
+function isMovable(value) {
+	return isTransferable(value) && value[kMovable] === true;
+}
+function markMovable(value) {
+	Object.defineProperty(value, kMovable, {
+		enumerable: false,
+		configurable: true,
+		writable: true,
+		value: true
+	});
+}
+function isTaskQueue(value) {
+	return typeof value === "object" && value !== null && "size" in value && typeof value.shift === "function" && typeof value.remove === "function" && typeof value.push === "function";
+}
+const kRequestCountField = 0;
+const kResponseCountField = 1;
+const kFieldCount = 2;
+
+//#endregion
+export { isMovable, isTaskQueue, isTransferable, kFieldCount, kQueueOptions, kRequestCountField, kResponseCountField, kTransferable, kValue, markMovable };

package/compiled/tinypool/dist/entry/process.d.ts

@@ -1,2 +1 @@
-
-export {  }
+export { };

package/compiled/tinypool/dist/entry/process.js

@@ -1,92 +1,72 @@
-import {
-  stderr,
-  stdout
-} from "../chunk-ACQHDOFQ.js";
-import {
-  getHandler,
-  throwInNextTick
-} from "../chunk-E2J7JLFN.js";
-import "../chunk-6LX4VMOV.js";
+import { stderr, stdout } from "../utils-De75vAgL.js";
+import { getHandler, throwInNextTick } from "../utils-B--2TaWv.js";
 
-// src/entry/process.ts
+//#region src/entry/process.ts
 process.__tinypool_state__ = {
-  isChildProcess: true,
-  isTinypoolWorker: true,
-  workerData: null,
-  workerId: Number(process.env.TINYPOOL_WORKER_ID)
+	isChildProcess: true,
+	isTinypoolWorker: true,
+	workerData: null,
+	workerId: Number(process.env.TINYPOOL_WORKER_ID)
 };
-var memoryUsage = process.memoryUsage.bind(process);
-var send = process.send.bind(process);
+const memoryUsage = process.memoryUsage.bind(process);
+const send = process.send.bind(process);
 process.on("message", (message) => {
-  if (!message || !message.__tinypool_worker_message__)
-    return;
-  if (message.source === "pool") {
-    const { filename, name } = message;
-    (async function() {
-      if (filename !== null) {
-        await getHandler(filename, name);
-      }
-      send(
-        {
-          ready: true,
-          source: "pool",
-          __tinypool_worker_message__: true
-        },
-        () => {
-        }
-      );
-    })().catch(throwInNextTick);
-    return;
-  }
-  if (message.source === "port") {
-    onMessage(message).catch(throwInNextTick);
-    return;
-  }
-  throw new Error(`Unexpected TinypoolWorkerMessage ${JSON.stringify(message)}`);
+	if (!message || !message.__tinypool_worker_message__) return;
+	if (message.source === "pool") {
+		const { filename, name } = message;
+		(async function() {
+			if (filename !== null) await getHandler(filename, name);
+			send({
+				ready: true,
+				source: "pool",
+				__tinypool_worker_message__: true
+			}, () => {});
+		})().catch(throwInNextTick);
+		return;
+	}
+	if (message.source === "port") {
+		onMessage(message).catch(throwInNextTick);
+		return;
+	}
+	throw new Error(`Unexpected TinypoolWorkerMessage ${JSON.stringify(message)}`);
 });
 async function onMessage(message) {
-  const { taskId, task, filename, name } = message;
-  let response;
-  try {
-    const handler = await getHandler(filename, name);
-    if (handler === null) {
-      throw new Error(`No handler function exported from ${filename}`);
-    }
-    const result = await handler(task);
-    response = {
-      source: "port",
-      __tinypool_worker_message__: true,
-      taskId,
-      result,
-      error: null,
-      usedMemory: memoryUsage().heapUsed
-    };
-    if (stdout()?.writableLength > 0) {
-      await new Promise((resolve) => process.stdout.write("", resolve));
-    }
-    if (stderr()?.writableLength > 0) {
-      await new Promise((resolve) => process.stderr.write("", resolve));
-    }
-  } catch (error) {
-    response = {
-      source: "port",
-      __tinypool_worker_message__: true,
-      taskId,
-      result: null,
-      error: serializeError(error),
-      usedMemory: memoryUsage().heapUsed
-    };
-  }
-  send(response);
+	const { taskId, task, filename, name } = message;
+	let response;
+	try {
+		const handler = await getHandler(filename, name);
+		if (handler === null) throw new Error(`No handler function "${name}" exported from "${filename}"`);
+		const result = await handler(task);
+		response = {
+			source: "port",
+			__tinypool_worker_message__: true,
+			taskId,
+			result,
+			error: null,
+			usedMemory: memoryUsage().heapUsed
+		};
+		if (stdout()?.writableLength > 0) await new Promise((resolve) => process.stdout.write("", resolve));
+		if (stderr()?.writableLength > 0) await new Promise((resolve) => process.stderr.write("", resolve));
+	} catch (error) {
+		response = {
+			source: "port",
+			__tinypool_worker_message__: true,
+			taskId,
+			result: null,
+			error: serializeError(error),
+			usedMemory: memoryUsage().heapUsed
+		};
+	}
+	send(response);
 }
 function serializeError(error) {
-  if (error instanceof Error) {
-    return {
-      ...error,
-      name: error.name,
-      stack: error.stack,
-      message: error.message
-    };
-  }
-  return String(error);
+	if (error instanceof Error) return {
+		...error,
+		name: error.name,
+		stack: error.stack,
+		message: error.message
+	};
+	return String(error);
 }
+
+//#endregion

package/compiled/tinypool/dist/entry/utils.d.ts

@@ -1,5 +1,7 @@
+//#region src/entry/utils.d.ts
 type Handler = Function;
 declare function getHandler(filename: string, name: string): Promise<Handler | null>;
 declare function throwInNextTick(error: Error): void;
 
-export { getHandler, throwInNextTick };
+//#endregion
+export { getHandler, throwInNextTick };

package/compiled/tinypool/dist/entry/utils.js

@@ -1,9 +1,3 @@
-import {
-  getHandler,
-  throwInNextTick
-} from "../chunk-E2J7JLFN.js";
-import "../chunk-6LX4VMOV.js";
-export {
-  getHandler,
-  throwInNextTick
-};
+import { getHandler, throwInNextTick } from "../utils-B--2TaWv.js";
+
+export { getHandler, throwInNextTick };

package/compiled/tinypool/dist/entry/worker.d.ts

@@ -1,2 +1 @@
-
-export {  }
+export { };

package/compiled/tinypool/dist/entry/worker.js

@@ -1,103 +1,75 @@
-import {
-  isMovable,
-  kRequestCountField,
-  kResponseCountField,
-  kTransferable,
-  kValue
-} from "../chunk-UBWFVGJX.js";
-import {
-  stderr,
-  stdout
-} from "../chunk-ACQHDOFQ.js";
-import {
-  getHandler,
-  throwInNextTick
-} from "../chunk-E2J7JLFN.js";
-import "../chunk-6LX4VMOV.js";
+import { isMovable, kRequestCountField, kResponseCountField, kTransferable, kValue } from "../common-Qw-RoVFD.js";
+import { stderr, stdout } from "../utils-De75vAgL.js";
+import { getHandler, throwInNextTick } from "../utils-B--2TaWv.js";
+import { parentPort, receiveMessageOnPort, workerData } from "node:worker_threads";
 
-// src/entry/worker.ts
-import {
-  parentPort,
-  receiveMessageOnPort,
-  workerData as tinypoolData
-} from "worker_threads";
-var [tinypoolPrivateData, workerData] = tinypoolData;
+//#region src/entry/worker.ts
+const [tinypoolPrivateData, workerData$1] = workerData;
 process.__tinypool_state__ = {
-  isWorkerThread: true,
-  isTinypoolWorker: true,
-  workerData,
-  workerId: tinypoolPrivateData.workerId
+	isWorkerThread: true,
+	isTinypoolWorker: true,
+	workerData: workerData$1,
+	workerId: tinypoolPrivateData.workerId
 };
-var memoryUsage = process.memoryUsage.bind(process);
-var useAtomics = process.env.PISCINA_DISABLE_ATOMICS !== "1";
+const memoryUsage = process.memoryUsage.bind(process);
+let useAtomics = process.env.PISCINA_DISABLE_ATOMICS !== "1";
 parentPort.on("message", (message) => {
-  useAtomics = process.env.PISCINA_DISABLE_ATOMICS === "1" ? false : message.useAtomics;
-  const { port, sharedBuffer, filename, name } = message;
-  (async function() {
-    if (filename !== null) {
-      await getHandler(filename, name);
-    }
-    const readyMessage = { ready: true };
-    parentPort.postMessage(readyMessage);
-    port.on("message", onMessage.bind(null, port, sharedBuffer));
-    atomicsWaitLoop(port, sharedBuffer);
-  })().catch(throwInNextTick);
+	useAtomics = process.env.PISCINA_DISABLE_ATOMICS === "1" ? false : message.useAtomics;
+	const { port, sharedBuffer, filename, name } = message;
+	(async function() {
+		if (filename !== null) await getHandler(filename, name);
+		const readyMessage = { ready: true };
+		parentPort.postMessage(readyMessage);
+		port.on("message", onMessage.bind(null, port, sharedBuffer));
+		atomicsWaitLoop(port, sharedBuffer);
+	})().catch(throwInNextTick);
 });
-var currentTasks = 0;
-var lastSeenRequestCount = 0;
+let currentTasks = 0;
+let lastSeenRequestCount = 0;
 function atomicsWaitLoop(port, sharedBuffer) {
-  if (!useAtomics)
-    return;
-  while (currentTasks === 0) {
-    Atomics.wait(sharedBuffer, kRequestCountField, lastSeenRequestCount);
-    lastSeenRequestCount = Atomics.load(sharedBuffer, kRequestCountField);
-    let entry;
-    while ((entry = receiveMessageOnPort(port)) !== void 0) {
-      onMessage(port, sharedBuffer, entry.message);
-    }
-  }
+	if (!useAtomics) return;
+	while (currentTasks === 0) {
+		Atomics.wait(sharedBuffer, kRequestCountField, lastSeenRequestCount);
+		lastSeenRequestCount = Atomics.load(sharedBuffer, kRequestCountField);
+		let entry;
+		while ((entry = receiveMessageOnPort(port)) !== void 0) onMessage(port, sharedBuffer, entry.message);
+	}
 }
 function onMessage(port, sharedBuffer, message) {
-  currentTasks++;
-  const { taskId, task, filename, name } = message;
-  (async function() {
-    let response;
-    let transferList = [];
-    try {
-      const handler = await getHandler(filename, name);
-      if (handler === null) {
-        throw new Error(`No handler function exported from ${filename}`);
-      }
-      let result = await handler(task);
-      if (isMovable(result)) {
-        transferList = transferList.concat(result[kTransferable]);
-        result = result[kValue];
-      }
-      response = {
-        taskId,
-        result,
-        error: null,
-        usedMemory: memoryUsage().heapUsed
-      };
-      if (stdout()?.writableLength > 0) {
-        await new Promise((resolve) => process.stdout.write("", resolve));
-      }
-      if (stderr()?.writableLength > 0) {
-        await new Promise((resolve) => process.stderr.write("", resolve));
-      }
-    } catch (error) {
-      response = {
-        taskId,
-        result: null,
-        // It may be worth taking a look at the error cloning algorithm we
-        // use in Node.js core here, it's quite a bit more flexible
-        error,
-        usedMemory: memoryUsage().heapUsed
-      };
-    }
-    currentTasks--;
-    port.postMessage(response, transferList);
-    Atomics.add(sharedBuffer, kResponseCountField, 1);
-    atomicsWaitLoop(port, sharedBuffer);
-  })().catch(throwInNextTick);
+	currentTasks++;
+	const { taskId, task, filename, name } = message;
+	(async function() {
+		let response;
+		let transferList = [];
+		try {
+			const handler = await getHandler(filename, name);
+			if (handler === null) throw new Error(`No handler function "${name}" exported from "${filename}"`);
+			let result = await handler(task);
+			if (isMovable(result)) {
+				transferList = transferList.concat(result[kTransferable]);
+				result = result[kValue];
+			}
+			response = {
+				taskId,
+				result,
+				error: null,
+				usedMemory: memoryUsage().heapUsed
+			};
+			if (stdout()?.writableLength > 0) await new Promise((resolve) => process.stdout.write("", resolve));
+			if (stderr()?.writableLength > 0) await new Promise((resolve) => process.stderr.write("", resolve));
+		} catch (error) {
+			response = {
+				taskId,
+				result: null,
+				error,
+				usedMemory: memoryUsage().heapUsed
+			};
+		}
+		currentTasks--;
+		port.postMessage(response, transferList);
+		Atomics.add(sharedBuffer, kResponseCountField, 1);
+		atomicsWaitLoop(port, sharedBuffer);
+	})().catch(throwInNextTick);
 }
+
+//#endregion