Parallel-Memo-DOM

Parallel-Memo-DOM is a lightweight browser library for offloading CPU-intensive or async computations to Web Workers, enabling parallel execution and keeping the main thread responsive. It also provides optional caching and a thread pool for efficient worker management.

Features

• Execute any function in a Web Worker, including async operations like fetch.
• ThreadPool for managing multiple workers and queuing tasks.
• Optional LRU caching of function results to avoid redundant work.
• Support for transferable objects (ArrayBuffer, MessagePort) for efficient data transfer.
• Dynamic thread pool sizing based on hardware concurrency.
• Fully typed with TypeScript generics.
• Robust error handling: worker failures are caught and replaced automatically.

Installation

npm install parallel-memo-dom

Usage

Using Thread for single function execution

import { Thread } from 'parallel-memo-dom';

const fetchAndFilter = async (url: string) => {
  const res = await fetch(url);
  const data = await res.json();
  return data.filter((item: any) => item.completed); // heavy filtering in worker
};

Thread.exec(fetchAndFilter, 'https://jsonplaceholder.typicode.com/todos')
  .then((result) => console.log('Filtered data:', result))
  .catch((err) => console.error('Thread error:', err));

Note: The network request, JSON parsing, and filtering happen inside the worker thread.

Using ThreadPool for multiple concurrent tasks

import { ThreadPool } from 'parallel-memo-dom';

const pool = new ThreadPool({ size: 4 });

const heavyComputation = (a: number, b: number) => {
  let sum = 0;
  for (let i = 0; i < 1e7; i++) sum += Math.sqrt(a * b);
  return sum;
};

Promise.all([pool.exec(heavyComputation, 10, 20), pool.exec(heavyComputation, 5, 15)]).then(
  (results) => console.log('Results:', results),
);

Configuring caching

import { Thread } from 'parallel-memo-dom';

// Enable or disable caching globally
Thread.configure({ enableCaching: true });

Using transferable objects

import { Thread } from 'parallel-memo-dom';

const processBuffer = (buf: ArrayBuffer) => {
  const copy = new ArrayBuffer(buf.byteLength);
  new Uint8Array(copy).set(new Uint8Array(buf));
  return copy; // only the processed buffer is sent back
};

const buffer = new ArrayBuffer(1_000_000);

Thread.exec(processBuffer, buffer).then((result) =>
  console.log('Processed buffer size:', result.byteLength),
);

API

Thread

• static configure(options: { enableCaching?: boolean }): void
  Configures caching behavior for function executions.

• static exec<T extends any[], R>(fn: (...args: T) => R | Promise<R>, ...args: T): Promise<R>
  Executes a function in a worker thread and returns a promise with the result. Supports async functions and transferable objects.

ThreadPool

• constructor(options: { size?: number; enableCaching?: boolean })
  Creates a pool of workers. Defaults to navigator.hardwareConcurrency if size is not specified.

• exec<T extends any[], R>(fn: (...args: T) => R | Promise<R>, ...args: T): Promise<R>
  Executes a task in the pool, queues it if all workers are busy, and resolves with the result.

Notes

• All code inside Thread or ThreadPool runs in worker threads, meaning the main thread remains responsive.
• Supports async functions, so heavy computations or I/O operations like fetch can safely run in the worker.
• Only cloneable data is returned to the main thread (objects, arrays, primitives). Functions, DOM nodes, and certain classes cannot be transferred.

Contributing

Contributions, bug reports, and feature requests are welcome! Please open an issue or submit a pull request.

License

MIT License — see the LICENSE file for details.