npm - evg_observable - Versions diffs - 3.0.0 → 3.0.1 - Mend

evg_observable 3.0.0 → 3.0.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (4) hide show

package/package.json +1 -1
package/BENCHMARK_BUNDLE_RESULTS.md +0 -149
package/BENCHMARK_OBSERVABLE_FNS_RESULTS.md +0 -197
package/BREAKING_CHANGES.md +0 -70

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "evg_observable",
-  "version": "3.0.0",
+  "version": "3.0.1",
   "description": "Alternative fast and light library version - observable.",
   "main": "src/outLib/index.js",
   "types": "src/outLib/index.d.ts",

package/BENCHMARK_BUNDLE_RESULTS.md DELETED Viewed

@@ -1,149 +0,0 @@
-# Benchmark Results: Bundle vs TypeScript vs RxJS
-Date: 2026-01-10
-## Methodology
-Performance comparison of three variants:
-1. **Bundle** - Minified JavaScript from `repo/evg_observable.js` (7.2 kB)
-2. **TypeScript** - On-the-fly compilation via ts-node
-3. **RxJS** - From node_modules (88 kB UMD bundle)
-**Size comparison:** EVG Observable is **12.2x smaller** than RxJS (7.2 kB vs 88 kB)
-## Test Results
-Results averaged over 3 clean benchmark runs (no background processes):
-### 1. Observable Creation
-| Variant | Ops/sec | Relative Performance |
-|---------|---------|---------------------|
-| Bundle | 122,701,000 | **baseline** |
-| TypeScript | 52,574,000 | 2.3x slower |
-| RxJS | 53,639,000 | 2.3x slower |
-**Winner: Bundle**
-### 2. Emit 100 Values (1 subscriber)
-| Variant | Ops/sec | Relative Performance |
-|---------|---------|---------------------|
-| Bundle | 1,662,000 | **baseline** |
-| TypeScript | 1,079,000 | 1.5x slower |
-| RxJS | 239,000 | 7.0x slower |
-**Winner: Bundle**
-### 3. Filter and Transform (pipe chain)
-| Variant | Ops/sec | Relative Performance |
-|---------|---------|---------------------|
-| Bundle | 340,000 | **baseline** |
-| TypeScript | 324,000 | ~equal (5% difference) |
-| RxJS | 149,000 | 2.3x slower |
-**Winner: Bundle** (marginal advantage)
-### 4. Multiple Subscribers
-#### 10 Subscribers
-| Variant | Ops/sec | Relative Performance |
-|---------|---------|---------------------|
-| Bundle | 9,946,000 | **baseline** |
-| TypeScript | 8,119,000 | 1.2x slower |
-| RxJS | 3,500,000 | 2.8x slower |
-#### 100 Subscribers
-| Variant | Ops/sec | Relative Performance |
-|---------|---------|---------------------|
-| Bundle | 1,236,000 | **baseline** |
-| TypeScript | 991,000 | 1.2x slower |
-| RxJS | 432,000 | 2.9x slower |
-#### 1000 Subscribers
-| Variant | Ops/sec | Relative Performance |
-|---------|---------|---------------------|
-| Bundle | 124,000 | **baseline** |
-| TypeScript | 98,000 | 1.3x slower |
-| RxJS | 41,000 | 3.0x slower |
-**Winner: Bundle** (all cases)
-### 5. Batch Emission - of(100)
-| Variant | Ops/sec | Relative Performance |
-|---------|---------|---------------------|
-| Bundle | 906,000 | **baseline** |
-| TypeScript | 752,000 | 1.2x slower |
-| RxJS | 176,000 | 5.1x slower |
-**Winner: Bundle**
-### 6. Five Chained Filters
-| Variant | Ops/sec | Relative Performance |
-|---------|---------|---------------------|
-| Bundle | 18,900 | **baseline** |
-| TypeScript | 18,200 | ~equal (4% difference) |
-| RxJS | 9,200 | 2.1x slower |
-**Winner: Bundle** (marginal advantage)
-### 7. Large Payload (complex objects)
-| Variant | Ops/sec | Relative Performance |
-|---------|---------|---------------------|
-| Bundle | 879,000 | **baseline** |
-| TypeScript | 755,000 | 1.2x slower |
-| RxJS | 184,000 | 4.8x slower |
-**Winner: Bundle**
-## Summary
-### Bundle vs TypeScript
-The minified bundle shows **consistent advantage** over TypeScript compilation:
-- **Object creation**: 2.3x faster - significant advantage
-- **Data emission**: 1.5x faster - noticeable advantage
-- **Filtering/transformation**: ~equal performance (within 5%)
-- **Multiple subscribers**: 1.2-1.3x faster - stable advantage
-- **Batch emission**: 1.2x faster
-- **Large objects**: 1.2x faster
-**Reasons for bundle's advantage:**
-1. Minification and dead code elimination
-2. Better V8 JIT optimization for compiled code
-3. Reduced module loading overhead
-4. Inlining of small functions
-### EVG Observable vs RxJS
-Both variants (bundle and TypeScript) **significantly outperform RxJS**:
-- **Creation**: ~2.3x faster
-- **Simple emission**: 5-7x faster
-- **Filtering**: 2.3x faster
-- **Multiple subscribers**: 2.8-3.0x faster
-- **Batch emission**: 4.5-5.1x faster
-- **Complex filtering**: ~2.1x faster
-- **Large objects**: 4.7-4.8x faster
-### Recommendations
-1. **For production**: Use minified bundle for maximum performance
-2. **For development**: TypeScript compilation provides nearly equal performance with type safety convenience
-3. **Migration from RxJS**: Expect 2-7x performance improvement depending on usage patterns
-## Technical Details
-- **Node.js**: v22.17.1
-- **Benchmark.js**: Standard settings
-- **Minimum runs**: 71-90 per test
-- **Margin of Error**: ±0.71% - ±5.21%

package/BENCHMARK_OBSERVABLE_FNS_RESULTS.md DELETED Viewed

@@ -1,197 +0,0 @@
-# Benchmark Results: EVG Observable vs observable-fns
-Date: 2026-01-10
-## Methodology
-Performance comparison of two lightweight Observable libraries:
-1. **EVG Observable** - True hot observables with original architecture (7.2 kB minified)
-2. **observable-fns** - Based on zen-observable, provides Subject for hot observables (10.8 kB minified)
-**Size comparison:** EVG Observable is **1.5x smaller** than observable-fns (7.2 kB vs 10.8 kB)
-Benchmarked on Node.js v22.17.1, results averaged over 3 clean runs (no background processes).
-## Test Results
-### 1. Observable Creation
-| Library | Ops/sec | Relative Performance |
-|---------|---------|---------------------|
-| EVG Observable | 54,138,000 | **baseline** |
-| observable-fns | 17,226,000 | 3.1x slower |
-**Winner: EVG Observable** (3.1x faster)
-### 2. Single Emission Performance Matrix
-#### 1 Emission × Multiple Subscribers
-| Subscribers | EVG Observable | observable-fns | Advantage |
-|-------------|----------------|----------------|-----------|
-| 1 | 53,802,000 ops/sec | 36,757,000 | **1.5x faster** |
-| 10 | 14,318,000 ops/sec | 6,283,000 | **2.3x faster** |
-| 100 | 1,700,000 ops/sec | 733,000 | **2.3x faster** |
-| 1,000 | 176,000 ops/sec | 73,000 | **2.4x faster** |
-| 10,000 | 16,100 ops/sec | 6,900 | **2.3x faster** |
-**Winner: EVG Observable** (consistent 1.5-2.4x advantage)
-#### 10 Emissions × Multiple Subscribers
-| Subscribers | EVG Observable | observable-fns | Advantage |
-|-------------|----------------|----------------|-----------|
-| 1 | 9,881,000 ops/sec | 5,568,000 | **1.8x faster** |
-| 10 | 1,651,000 ops/sec | 677,000 | **2.4x faster** |
-| 100 | 176,000 ops/sec | 75,000 | **2.3x faster** |
-| 1,000 | 17,800 ops/sec | 7,400 | **2.4x faster** |
-| 10,000 | 1,600 ops/sec | 700 | **2.3x faster** |
-**Winner: EVG Observable** (consistent 1.8-2.4x advantage)
-#### 100 Emissions × Multiple Subscribers
-| Subscribers | EVG Observable | observable-fns | Advantage |
-|-------------|----------------|----------------|-----------|
-| 1 | 1,022,000 ops/sec | 552,000 | **1.9x faster** |
-| 10 | 169,000 ops/sec | 69,000 | **2.4x faster** |
-| 100 | 17,500 ops/sec | 7,300 | **2.4x faster** |
-| 1,000 | 1,770 ops/sec | 730 | **2.4x faster** |
-| 10,000 | 166 ops/sec | 65 | **2.6x faster** |
-**Winner: EVG Observable** (consistent 1.9-2.6x advantage)
-#### 1000 Emissions × Multiple Subscribers
-| Subscribers | EVG Observable | observable-fns | Advantage |
-|-------------|----------------|----------------|-----------|
-| 1 | 98,400 ops/sec | 54,400 | **1.8x faster** |
-| 10 | 16,900 ops/sec | 7,000 | **2.4x faster** |
-| 100 | 1,750 ops/sec | 730 | **2.4x faster** |
-| 1,000 | 179 ops/sec | 75 | **2.4x faster** |
-| 10,000 | 15.8 ops/sec | 6.1 | **2.6x faster** |
-**Winner: EVG Observable** (consistent 1.8-2.6x advantage)
-### 3. Filter & Transform (pipe chain with 100 emissions)
-| Subscribers | EVG Observable | observable-fns | Advantage |
-|-------------|----------------|----------------|-----------|
-| 1 | 292,000 ops/sec | 127,000 | **2.3x faster** |
-| 10 | 275,000 ops/sec | 18,700 | **14.7x faster** |
-| 100 | 280,000 ops/sec | 1,880 | **149x faster** |
-| 1,000 | 273,000 ops/sec | 143 | **1,909x faster** |
-| 10,000 | 277,000 ops/sec | 13.7 | **20,219x faster** |
-**Winner: EVG Observable** (dramatic advantage at higher subscriber counts)
-**Analysis:** EVG Observable's pipe architecture is extremely efficient with multiple subscribers. observable-fns creates separate pipe chains per subscriber, causing exponential slowdown.
-### 4. Five Chained Filters (100 emissions)
-| Subscribers | EVG Observable | observable-fns | Advantage |
-|-------------|----------------|----------------|-----------|
-| 1 | 119,000 ops/sec | 71,300 | **1.7x faster** |
-| 10 | 116,400 ops/sec | 7,280 | **16.0x faster** |
-| 100 | 113,500 ops/sec | 709 | **160x faster** |
-| 1,000 | 112,400 ops/sec | 57.6 | **1,951x faster** |
-| 10,000 | 114,100 ops/sec | 2.1 | **54,333x faster** |
-**Winner: EVG Observable** (exponential advantage at higher subscriber counts)
-**Analysis:** Complex pipe chains show EVG Observable's architectural superiority. The advantage grows exponentially with subscriber count.
-### 5. Large Payload (complex objects, 100 emissions)
-| Library | Ops/sec | Relative Performance |
-|---------|---------|---------------------|
-| EVG Observable | 749,000 | **baseline** |
-| observable-fns | 549,000 | 1.4x slower |
-**Winner: EVG Observable** (1.4x faster)
-### 6. Subscribe/Unsubscribe Churn (1000 cycles)
-| Library | Ops/sec | Relative Performance |
-|---------|---------|---------------------|
-| EVG Observable | 4,406 | **~equal** |
-| observable-fns | 4,537 | ~equal |
-**Winner: Tie** (within margin of error)
-**Analysis:** Both libraries have similar overhead for subscription management.
-## Summary
-### Key Findings
-1. **Simple Emissions (1 subscriber)**: EVG Observable is **1.5-1.9x faster**
-   - Consistent advantage across all emission counts
-   - Both scale linearly
-2. **Multiple Subscribers (10-10,000)**: EVG Observable is **2.3-2.6x faster**
-   - Advantage increases slightly with subscriber count
-   - EVG's true hot observable architecture shines
-3. **Pipe Operations**: EVG Observable has **dramatic advantage**
-   - 1 subscriber: 1.7-2.3x faster
-   - 10 subscribers: 14.7-16.0x faster
-   - 100 subscribers: 149-160x faster
-   - 1,000 subscribers: 1,900-1,950x faster
-   - 10,000 subscribers: 20,000-54,000x faster
-4. **Observable Creation**: EVG Observable is **3.1x faster**
-   - Lower instantiation overhead
-5. **Large Payloads**: EVG Observable is **1.4x faster**
-   - Efficient data passing
-### Architectural Insights
-**EVG Observable's advantages:**
-- True hot observable architecture (single pipe chain for all subscribers)
-- Efficient subscription management for multi-subscriber scenarios
-- Optimized pipe operations that don't duplicate work
-- Lower memory overhead per subscriber
-**observable-fns characteristics:**
-- Based on zen-observable (cold observables)
-- Each subscriber creates separate pipe chain
-- Good for single-subscriber patterns
-- Struggles with multi-subscriber pipe operations
-### Recommendations
-**Choose EVG Observable when:**
-- You have multiple subscribers (most real-world scenarios)
-- Using pipe operators (filter, map, etc.)
-- Performance is critical
-- Real-time broadcasting (WebSocket, SSE, event emitters)
-- Need hot observable semantics
-**Choose observable-fns when:**
-- You need zen-observable API compatibility
-- Single subscriber patterns
-- Cold observable semantics required
-### Performance Summary Table
-| Operation Type | Typical Advantage | Best Case | Worst Case |
-|----------------|-------------------|-----------|------------|
-| Simple emission | 1.5-2.4x | 2.6x | 1.5x |
-| Pipe (1 sub) | 1.7-2.3x | 2.3x | 1.7x |
-| Pipe (10+ subs) | 15-20,000x | 54,333x | 14.7x |
-| Creation | 3.1x | 3.1x | 3.1x |
-| Large payloads | 1.4x | 1.4x | 1.4x |
-| Sub/Unsub | ~equal | - | - |
-## Technical Details
-- **Node.js**: v22.17.1
-- **Benchmark.js**: Standard settings
-- **Runs**: 3 clean benchmark runs, averaged
-- **Per-test samples**: 70-94 runs per scenario
-- **Margin of Error**: ±1.2% - ±2.9% (typical)
-- **Total scenarios**: 33 benchmark scenarios
-- **Verification**: All pipe operations include result verification to ensure correct behavior

package/BREAKING_CHANGES.md DELETED Viewed

@@ -1,70 +0,0 @@
-# Breaking Changes - Performance Optimizations Branch
-## Version 2.15.0
-### Internal Field Renaming
-**Affected field:** `value` renamed to `_value`
-The internal field storing the current observable value has been renamed from `value` to `_value` to follow TypeScript conventions for protected/private members.
-**Before:**
-```typescript
-export class Observable<T> {
-    constructor(private value: T) {}
-}
-```
-**After:**
-```typescript
-export class Observable<T> {
-    protected _value: T;
-    constructor(value: T) {
-        this._value = value;
-    }
-}
-```
-**Migration:**
-- If you were extending `Observable` and accessing `this.value`, change to `this._value`
-- Use the public `getValue()` method for reading the current value (recommended)
-### Visibility Changes
-The following fields changed from `private` to `protected` to enable better inheritance:
-| Field | Before | After |
-|-------|--------|-------|
-| `enabled` | private | protected |
-| `filters` | private | protected |
-| `_value` (formerly `value`) | private | protected |
-**Impact:** This is not a breaking change for most users, but allows subclasses to access these fields.
-### Recommended Migration Path
-Instead of accessing internal fields directly, use the public API:
-```typescript
-// Instead of:
-// @ts-ignore
-const val = observable._value;
-// Use:
-const val = observable.getValue();
-// Instead of:
-// @ts-ignore
-const count = observable.subs.length;
-// Use:
-const count = observable.size();
-```
-### New Behavior
-1. **`destroy()` now uses `Promise.resolve()`** instead of `setInterval()` for async cleanup when called during emission
-2. **`unsubscribeAll()` is now safe to call during `next()`** - uses deferred cleanup mechanism
-3. **Early exit optimization** - `next()` returns immediately if there are no subscribers
-These behavioral changes improve performance and memory management but should not require code changes.