import type { KillBehavior, WorkerOptions } from './worker-options'
import { KillBehaviors } from './worker-options'
-const DEFAULT_MAX_INACTIVE_TIME = 1000 * 60
+const DEFAULT_MAX_INACTIVE_TIME = 60000
const DEFAULT_KILL_BEHAVIOR: KillBehavior = KillBehaviors.SOFT
/**
- * Base class containing some shared logic for all poolifier workers.
+ * Base class that implements some shared logic for all poolifier workers.
*
* @template MainWorker Type of main worker.
* @template Data Type of data this worker receives from pool's execution. This can only be serializable data.
): void {
if (value.data !== undefined && value.id !== undefined) {
// Here you will receive messages
- if (this.opts.async) {
+ if (this.opts.async === true) {
this.runInAsyncScope(this.runAsync.bind(this), this, fn, value)
} else {
this.runInAsyncScope(this.run.bind(this), this, fn, value)
this.mainWorker = value.parent
} else if (value.kill !== undefined) {
// Here is time to kill this worker, just clearing the interval
- if (this.aliveInterval) clearInterval(this.aliveInterval)
+ if (this.aliveInterval != null) clearInterval(this.aliveInterval)
this.emitDestroy()
}
}
- private checkWorkerOptions (opts: WorkerOptions) {
+ private checkWorkerOptions (opts: WorkerOptions): void {
this.opts.killBehavior = opts.killBehavior ?? DEFAULT_KILL_BEHAVIOR
this.opts.maxInactiveTime =
opts.maxInactiveTime ?? DEFAULT_MAX_INACTIVE_TIME
- /**
- * Whether the worker is working asynchronously or not.
- */
- this.opts.async = !!opts.async
+ this.opts.async = opts.async ?? false
}
/**
- * Check if the `fn` parameter is passed to the constructor.
+ * Checks if the `fn` parameter is passed to the constructor.
*
* @param fn The function that should be defined.
*/
private checkFunctionInput (fn: (data: Data) => Response): void {
- if (!fn) throw new Error('fn parameter is mandatory')
+ if (fn == null) throw new Error('fn parameter is mandatory')
+ if (typeof fn !== 'function') {
+ throw new TypeError('fn parameter is not a function')
+ }
}
/**
* @returns Reference to the main worker.
*/
protected getMainWorker (): MainWorker {
- if (!this.mainWorker) {
+ if (this.mainWorker == null) {
throw new Error('Main worker was not set')
}
return this.mainWorker
}
/**
- * Send a message to the main worker.
+ * Sends a message to the main worker.
*
* @param message The response message.
*/
protected abstract sendToMainWorker (message: MessageValue<Response>): void
/**
- * Check to see if the worker should be terminated, because its living too long.
+ * Checks if the worker should be terminated, because its living too long.
*/
protected checkAlive (): void {
if (
}
/**
- * Handle an error and convert it to a string so it can be sent back to the main worker.
+ * Handles an error and convert it to a string so it can be sent back to the main worker.
*
* @param e The error raised by the worker.
* @returns Message of the error.
}
/**
- * Run the given function synchronously.
+ * Runs the given function synchronously.
*
* @param fn Function that will be executed.
* @param value Input data for the given function.
}
/**
- * Run the given function asynchronously.
+ * Runs the given function asynchronously.
*
* @param fn Function that will be executed.
* @param value Input data for the given function.