@sawport/peers-caller 0.0.0 → 0.0.1

package/README.md

@@ -680,103 +680,228 @@ yarn type-check   # Check TypeScript types without building
 
 This project uses **Vitest** for testing with comprehensive coverage reporting and WebRTC API mocking.
 
-This project uses Vitest for testing with comprehensive coverage reporting.
+### Testing
+
+This project uses **Vitest** for testing with comprehensive coverage reporting and WebRTC API mocking.
+
+#### Test Environment
+
+The test setup includes:
+- **WebRTC API Mocks**: RTCPeerConnection, MediaDevices, getUserMedia
+- **Socket.IO Mocking**: Complete WebSocket simulation
+- **jsdom Environment**: DOM testing capabilities
+- **TypeScript Support**: Full type checking in tests
+- **Coverage Reporting**: Detailed coverage analysis
 
 #### Running Tests
 
 ```bash
-# Run tests once
+# Run all tests once
 yarn test
 
-# Run tests in watch mode (for development)
+# Watch mode for development
 yarn test:watch
 
-# Run tests with coverage report
+# Generate coverage report
 yarn test:coverage
 
-# Open Vitest UI
+# Interactive test UI
 yarn test:ui
 ```
 
-#### Test Structure
-
-- `__tests__/` - Integration and setup tests
-- `src/**/*.test.ts` - Unit tests alongside source code
-- `src/test-utils.ts` - Shared test utilities and mocks
-
 #### Writing Tests
 
-The test environment includes:
-
-- **WebRTC API mocks** - RTCPeerConnection, MediaDevices, etc.
-- **External library mocks** - simple-peer, socket.io-client
-- **jsdom environment** - For DOM testing
-- **TypeScript support** - Full type checking in tests
+```typescript
+import { describe, it, expect, vi } from 'vitest';
+import { PeersCaller } from '../core/PeersCaller';
+import { mockWebRTC } from '../test-utils';
 
-Example test:
+describe('PeersCaller', () => {
+  beforeEach(() => {
+    mockWebRTC(); // Set up WebRTC mocks
+  });
 
-```typescript
-import { describe, it, expect } from 'vitest';
-import { generatePeerId } from '../utils';
+  it('should initialize successfully', async () => {
+    const peersCaller = new PeersCaller({
+      conversationId: 'test-123',
+      userId: 'user-456',
+      token: 'fake-token',
+      socketUrl: 'http://localhost:3000'
+    });
 
-describe('generatePeerId', () => {
-  it('should generate unique peer IDs', () => {
-    const id1 = generatePeerId();
-    const id2 = generatePeerId();
-    
-    expect(id1).not.toBe(id2);
-    expect(id1).toMatch(/^peer_\d+_[a-z0-9]{1,9}$/);
+    await expect(peersCaller.initialize()).resolves.not.toThrow();
+    expect(peersCaller.getCallState().callStatus).toBe('idle');
   });
 });
 ```
 
 #### Coverage Thresholds
 
-The project maintains high test coverage standards:
-
 - **Branches**: 80%
 - **Functions**: 80%
 - **Lines**: 80%
 - **Statements**: 80%
 
-### CI/CD
+### Project Structure
+
+```
+src/
+├── core/                 # Core classes and logic
+│   ├── PeersCaller.ts   # Main orchestrator
+│   ├── CallSocket.ts    # WebSocket signaling
+│   ├── CallParticipant.ts # Participant management
+│   ├── CallRecorder.ts  # Recording functionality
+│   └── ...
+├── store/               # Zustand state management
+│   └── index.ts
+├── hooks/               # React hooks
+│   └── index.ts
+├── types/               # TypeScript definitions
+│   └── index.ts
+├── utils/               # Utility functions
+│   └── index.ts
+├── test-utils.ts        # Test utilities and mocks
+└── index.ts             # Main entry point
+```
+
+### Contributing Guidelines
+
+1. **Fork & Clone**: Fork the repository and clone your fork
+2. **Branch**: Create a feature branch (`git checkout -b feature/amazing-feature`)
+3. **Develop**: Make your changes following the coding standards
+4. **Test**: Write tests for new functionality and ensure all tests pass
+5. **Type Safety**: Maintain TypeScript strict mode compliance
+6. **Documentation**: Update documentation as needed
+7. **Commit**: Use conventional commit messages
+8. **PR**: Open a Pull Request with a clear description
+
+### Code Style Guidelines
+
+- **TypeScript Strict Mode**: All code must pass strict type checking
+- **ESLint + Prettier**: Follow the established code style
+- **Functional Programming**: Prefer pure functions and immutability
+- **Error Handling**: Always handle errors gracefully
+- **Documentation**: Document public APIs and complex logic
+- **Testing**: Write tests for all new functionality
+
+### Build & Distribution
+
+The library is built using **Vite** and generates multiple output formats:
+
+```bash
+dist/
+├── peers-caller.es.js    # ES modules
+├── peers-caller.umd.js   # UMD bundle
+├── index.d.ts            # TypeScript declarations
+└── style.css             # Optional styles
+```
+
+### CI/CD Pipeline
 
 GitHub Actions automatically:
 
-- ✅ Runs tests on Node.js 18.x, 20.x, 22.x
-- ✅ Checks TypeScript compilation
-- ✅ Generates coverage reports
-- ✅ Builds the library
-- ✅ Uploads coverage to Codecov (optional)
+- ✅ **Tests** on Node.js 18.x, 20.x, 22.x
+- ✅ **Type Checking** with TypeScript
+- ✅ **Linting** with ESLint
+- ✅ **Coverage Reports** with Codecov
+- ✅ **Build Validation** for all platforms
+- 🚀 **Automated Publishing** to npm (on release)
+
+## 🤝 Contributing
+
+We welcome contributions! Here's how you can help:
+
+### Areas for Contribution
+
+- 🐛 **Bug Fixes**: Report and fix issues
+- ✨ **Features**: Propose and implement new features
+- 📚 **Documentation**: Improve docs and examples
+- 🧪 **Testing**: Add more test cases and improve coverage
+- 🔧 **Performance**: Optimize performance and bundle size
+- 🎨 **UI/UX**: Improve React hooks and developer experience
+
+### Getting Started
+
+1. Check existing [issues](https://github.com/sawport/peers-caller/issues) and [pull requests](https://github.com/sawport/peers-caller/pulls)
+2. Open an issue to discuss major changes
+3. Follow the development setup instructions
+4. Make your changes and add tests
+5. Submit a pull request
+
+### Commit Convention
+
+We use [Conventional Commits](https://www.conventionalcommits.org/):
+
+```bash
+feat: add screen sharing support
+fix: resolve peer connection race condition
+docs: update API documentation
+test: add integration tests for recording
+refactor: simplify state management logic
+```
+
+## 📋 Roadmap
 
-## API Reference
+### Current Version (v0.x)
 
-### Utilities
+- ✅ Basic peer-to-peer video calls
+- ✅ Mesh architecture (up to 4 participants)
+- ✅ Media controls (audio/video toggle)
+- ✅ Screen sharing
+- ✅ Call recording
+- ✅ React hooks integration
+- ✅ TypeScript support
 
-### Store
+### Planned Features (v1.0)
 
+- 🔄 **Improved Error Handling**: Better error recovery and user feedback
+- 📊 **Call Analytics**: Bandwidth monitoring and quality metrics
+- 🔊 **Audio Processing**: Noise suppression and echo cancellation
+- 📱 **Mobile Optimization**: Better mobile device support
+- 🌍 **Internationalization**: Multi-language support
+- 🔌 **Plugin System**: Extensible architecture for custom features
 
-### Types
+### Future Considerations
 
-## Contributing
+- **SFU Mode**: Support for Selective Forwarding Unit architecture
+- **Chat Integration**: Text messaging during calls
+- **Whiteboard**: Collaborative drawing and annotation
+- **Virtual Backgrounds**: AI-powered background replacement
+- **Call Waiting**: Queue management for busy participants
 
-1. Fork the repository
-2. Create a feature branch (`git checkout -b feature/amazing-feature`)
-3. Make your changes
-4. Add tests for new functionality
-5. Ensure tests pass (`yarn test`)
-6. Commit your changes (`git commit -m 'Add amazing feature'`)
-7. Push to the branch (`git push origin feature/amazing-feature`)
-8. Open a Pull Request
+## 🔒 Security Considerations
 
-### Development Guidelines
+### WebRTC Security
 
-- Write tests for all new functionality
-- Maintain TypeScript strict mode compliance
-- Follow the existing code style
-- Update documentation as needed
-- Ensure CI passes before submitting PR
+- **DTLS Encryption**: All media streams are encrypted end-to-end
+- **SRTP**: Secure Real-time Transport Protocol for media
+- **ICE Candidates**: Secure NAT traversal with STUN/TURN servers
+- **Origin Validation**: Server-side origin checking for WebSocket connections
 
-## License
+### Authentication
 
-MIT License - see LICENSE file for details.
+- **JWT Tokens**: Secure authentication with JSON Web Tokens
+- **Token Expiration**: Implement proper token refresh mechanisms
+- **User Validation**: Server-side user validation and authorization
+
+### Best Practices
+
+- **HTTPS Only**: Always use HTTPS in production
+- **CORS Configuration**: Properly configure Cross-Origin Resource Sharing
+- **Input Validation**: Validate all user inputs and signaling data
+- **Rate Limiting**: Implement rate limiting on signaling server
+- **Audit Logging**: Log security-relevant events
+
+## 📄 License
+
+MIT License - see [LICENSE](./LICENSE) file for details.
+
+---
+
+<div align="center">
+
+**Built with ❤️ by the [Sawport](https://github.com/sawport) team**
+
+[🌟 Star on GitHub](https://github.com/sawport/peers-caller) • [🐛 Report Issues](https://github.com/sawport/peers-caller/issues) • [💬 Discussions](https://github.com/sawport/peers-caller/discussions)
+
+</div>

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sawport/peers-caller",
-  "version": "0.0.0",
+  "version": "0.0.1",
   "description": "WebRTC multi-peer video call library with mesh architecture supporting up to 4 participants",
   "type": "module",
   "main": "./dist/peers-caller.umd.js",