Add vitepress docs

docs/lib/worker.md

@@ -0,0 +1,117 @@
+# Worker
+
+The Worker class provides a robust queue processing system with batched operations, throttling, and message routing capabilities. It's designed to handle asynchronous operations efficiently while maintaining control over processing rates and resource usage.
+
+## Overview
+
+```typescript
+class Worker<T> {
+  constructor(readonly opts: WorkerOpts<T> = {})
+}
+```
+
+The Worker class accepts messages of type `T` and processes them according to configured options and handlers.
+
+## Configuration
+
+```typescript
+type WorkerOpts<T> = {
+  // Function to determine routing key for messages
+  getKey?: (x: T) => any
+
+  // Function to check if message should be deferred
+  shouldDefer?: (x: T) => boolean
+
+  // Maximum messages to process in one batch
+  chunkSize?: number // default: 50
+
+  // Milliseconds between processing batches
+  delay?: number // default: 50
+}
+```
+
+## Basic Usage
+
+```typescript
+// Create worker for processing messages
+const worker = new Worker<Message>({
+  chunkSize: 10,
+  delay: 100,
+  getKey: msg => msg.type
+})
+
+// Add message handlers
+worker.addHandler('email', async (msg) => {
+  await sendEmail(msg)
+})
+
+worker.addHandler('notification', async (msg) => {
+  await sendNotification(msg)
+})
+
+// Add messages to queue
+worker.push({
+  type: 'email',
+  content: 'Hello'
+})
+```
+
+## Features
+
+### Message Routing
+
+Messages can be routed to specific handlers based on a key:
+
+```typescript
+const worker = new Worker<Task>({
+  getKey: task => task.priority
+})
+
+// Handle high priority tasks
+worker.addHandler('high', async (task) => {
+  await processUrgent(task)
+})
+
+// Handle normal priority tasks
+worker.addHandler('normal', async (task) => {
+  await processNormal(task)
+})
+```
+
+### Global Handlers
+
+Handle all messages regardless of routing key:
+
+```typescript
+worker.addGlobalHandler(async (message) => {
+  console.log('Processing:', message)
+})
+```
+
+### Message Deferral
+
+Defer processing of messages that aren't ready:
+
+```typescript
+const worker = new Worker<Task>({
+  shouldDefer: (task) => !task.isReady(),
+  delay: 1000
+})
+
+worker.push(task) // Will retry until task.isReady()
+```
+
+### Flow Control
+
+Control message processing:
+
+```typescript
+// Pause processing
+worker.pause()
+
+// Resume processing
+worker.resume()
+
+// Clear queue
+worker.clear()
+```