|
```ts
// ================= worker.ts ====================
// traditional worker — simple enough
// ================================================
import {parentPort, workerData} from 'node:worker_threads'
import {processImage} from './processImage'
const imageFiles = workerData
parentPort.postMessage({
type: 'started',
expected: imageFiles.length,
})
let processed = 0
for (let i = 0; i < imageFiles.length; i++) {
const file = imageFiles[i]
try {
const result = await processImage(file)
parentPort.postMessage({
type: 'progress',
file: file.name,
completed: i + 1,
result,
})
processed++
} catch {
// ...
}
}
parentPort.postMessage({
type: 'finished',
processed,
})
```
|
```ts
// ================ worker.ts ========================
// worker-channel worker — still simple and type-safe!
// ===================================================
import {parentPort, workerData} from 'node:worker_threads'
import {WorkerChannelReporter} from '@sanity/worker-channels'
import {processImage} from './processImage'
import type {ImageChannel} from '...'
const report = WorkerChannelReporter.from(parentPort)
const imageFiles = workerData
report.event.started({expected: imageFiles.length})
let processed = 0
for (let i = 0; i < imageFiles.length; i++) {
const file = imageFiles[i]
try {
const result = await processImage(file)
report.stream.progress.emit({
file: file.name,
completed: i + 1,
result,
})
processed++
} catch {
// ...
}
}
report.stream.progress.end()
report.event.finished({processed})
```
|
|
```ts
// ================= main.ts ===================
// a traditional parent — spaghetti control flow
// =============================================
import {Worker} from 'node:worker_threads'
const worker = new Worker(/* ... */)
let expected = 0
await new Promise((resolve, reject) => {
worker.on('message', (msg) => {
switch (msg.type) {
case 'started':
expected = msg.expected
console.log(`Processing ${expected} images...`)
break
case 'progress':
const {file, completed} = msg
console.log(`${file}: ${completed}/${expected}`)
break
case 'finished':
const {processed} = msg
console.log(`Processed ${processed}/${expected}`)
resolve()
break
default:
console.warn('Unknown message type:', msg.type)
}
})
// don't forget to propagate errors
worker.on('error', reject)
})
```
|
```ts
// ==================== main.ts =======================
// a worker-channel parent — control flow matches child
// ====================================================
import {Worker} from 'node:worker_threads'
import {WorkerChannelReceiver} from '@sanity/worker-channels'
import type {ImageChannel} from '...'
const worker = new Worker(/* ... */)
const receiver = WorkerChannelReceiver.from(worker)
// BONUS: the receiver automatically propagates errors
const {expected} = await receiver.event.started()
console.log(`Processing ${expected} images...`)
for await (const progress of receiver.stream.progress()) {
const {file, completed} = progress
console.log(`${file}: ${completed}/${expected}`)
}
const {processed} = await receiver.event.finished()
console.log(`Processed ${processed}/${expected}`)
receiver.unsubscribe() // clean up after the worker
```
|