✨ Features

🚀 Quick Start

npm install zeed
# or
pnpm add zeed
# or
yarn add zeed

📚 Core Features

🪵 Universal Logging

Powerful, filterable logging for browser and terminal with colorful output and stack traces.

import { Logger } from 'zeed'

const log = Logger('demo')

log('Hello World')
log.info('Info')
log.warn('Warning')
log.error('Error')

Terminal output:

Browser output:

localStorage.zeed = '*'

ZEED=* node myapp.js

import { LoggerFileHandler } from 'zeed'

LoggerFileHandler('/var/log/app.log', {
  rotation: {
    size: '10M',
    maxFiles: 5,
    compress: 'gzip'
  }
})

⚙️ Async/Promise Utilities

Powerful utilities for working with async operations:

// Wait for an event
await waitOn(emitter, 'action', 1000)

// Sleep for milliseconds
await sleep(1000)

// Timeout a promise
await timeout(asyncFn, 1000)

// Ensure a value is a Promise
await promisify(returnValue)

🆔 Unique ID Generation

Multiple ID generation strategies for different use cases:

// UUID (Base62, 22 chars) - cryptographically secure
const id = uuid()

// Sortable UID with timestamp
const sortable = suid()
suidDate(sortable) // Extract timestamp

// Named incremental IDs (great for debugging)
uname('user') // => 'user-0'
uname('user') // => 'user-1'

// Classic UUID v4
const classic = uuidv4() // => 'a7755f8d-ef6f-45e9-8db3-d29347a4a2a1'

Available ID types: uuid, uuidB32, suid, quid, uuidv4

🎯 Typed Event Emitter

Type-safe, async event emitter with full TypeScript support:

interface MyEvents {
  inc: (count: number) => number
}

const e = new Emitter<MyEvents>()
e.on('inc', async count => counter + 1)
await e.emit('inc', 1)

// Or use the .call proxy
await e.call.inc(1)

Global emitter for cross-module communication:

declare global {
  interface ZeedGlobalEmitter {
    test: (x: string) => void
  }
}

getGlobalEmitter().call.test('Hello World')

💬 Messaging

Type-safe messaging infrastructure for client-server communication:

const m = useMessageHub({ channel }).send<MyMessages>()
m.echo({ hello: 'world' })

📖 Full messaging documentation

✅ Schema Validation

Powerful schema validation with full TypeScript inference and Standard Schema support:

import { z } from 'zeed'

// Define and validate schemas
const userSchema = z.object({
  name: z.string(),
  email: z.string(),
  age: z.number().optional(),
  role: z.stringLiterals(['admin', 'user', 'guest']),
})

// Full type inference
type User = z.infer<typeof userSchema>

// Parse and validate
const user = schemaParseObject(userSchema, data)

// Use with any standard-schema-compatible library
const schema = z.object({
  name: z.string(),
  count: z.number(),
})

const result = schema['~standard'].validate({ name: 'test', count: 42 })
if (result.issues) {
  console.error('Validation failed:', result.issues)
}
else {
  console.log('Valid data:', result.value)
}

📖 Complete schema documentation

📊 Additional Utilities

interface Row extends SortedItem {
  id: string
  title: string
}
sortedItems(rows)

const { encode, decode } = useBase(62)
decode(encode(data)) === data

deepEqual(obj1, obj2)
deepMerge(obj1, obj2)

const dispose = useDispose()
dispose.add(cleanup)
await dispose()

📦 More Features

Zeed includes many more utilities - explore the full API documentation!

🤝 Related Projects

By the same author:

• zeed-dom - DOM manipulation utilities
• zerva - Modular server framework

Similar utility libraries:

• lib0 - Fundamental utility functions
• antfu/utils - Collection of common utilities
• vueuse - Vue composition utilities
• unjs - Unified JavaScript tools

📄 License

MIT