evg_observable 3.0.0 → 3.1.0

package/README.md

@@ -1,4 +1,6 @@
 [![Socket Badge](https://socket.dev/api/badge/npm/package/evg_observable)](https://socket.dev/npm/package/evg_observable)
+<a href="https://www.npmjs.com/package/evg_observable"><img alt="npm version" src="https://img.shields.io/npm/v/evg_observable.svg?style=flat-square"></a>
+<a href="https://bundlephobia.com/result?p=evg_observable"><img alt="Bundle size" src="https://badgen.net/bundlephobia/min/evg_observable"></a>
 <h1 align=center style="color: saddlebrown">
 EVG Observable
 </h1>
@@ -20,6 +22,13 @@ EVG Observable - is a light library for simple use.
         - [pipe().once()](#pipeonce)
         - [pipe().unsubscribeBy()](#pipeunsubscribebycondition)
         - [pipe().and()](#pipeandcondition)
+        - [pipe().throttle()](#pipethrottlems)
+        - [pipe().debounce()](#pipedebouncems)
+        - [pipe().distinctUntilChanged()](#pipedistinctuntilchangedcomparator)
+        - [pipe().tap()](#pipetapfn)
+        - [pipe().take()](#pipetaken)
+        - [pipe().skip()](#pipeskipn)
+        - [pipe().scan()](#pipescankfn-seed)
         - [pipe().toJson()](#pipetojson)
         - [pipe().fromJson()](#pipefromjsonk)
         - [pipe().in()](#pipeink-v)
@@ -41,14 +50,26 @@ EVG Observable - is a light library for simple use.
 
 | Metric | EVG Observable | RxJS |
 |--------|----------------|------|
-| **Bundle size** | **7.2 kB** | 88 kB |
-| **Size advantage** | **12.2x smaller** | - |
-| **Operations** | ~40 | 100+ |
-| **Performance** | **2-7x faster** | baseline |
+| **Bundle size** | **9.4 kB** | 63.6 kB |
+| **Size advantage** | **6.8x smaller** | - |
+| **Operations** | ~43 | 100+ |
+| **Performance** | **2-6x faster** | baseline |
 
 ### Performance Comparison (Bundle vs Bundle)
 
-Benchmarked with minified bundles on Node.js v22.17.1 (v3.0.0 API, averaged over 3 clean runs):
+Benchmarked with minified bundles on Node.js v20.18.3 (v3.1.0 API):
+
+| Test | EVG Observable | RxJS | Advantage |
+|------|----------------|------|-----------|
+| Emit 100 values | 2,955K ops/sec | 508K ops/sec | **5.8x faster** |
+| Filter + transform | 615K ops/sec | 237K ops/sec | **2.6x faster** |
+| 10 subscribers | 21,881K ops/sec | 7,556K ops/sec | **2.9x faster** |
+| 100 subscribers | 2,284K ops/sec | 907K ops/sec | **2.5x faster** |
+| 1000 subscribers | 181K ops/sec | 81K ops/sec | **2.2x faster** |
+| Large payload | 1,455K ops/sec | 370K ops/sec | **3.9x faster** |
+
+<details>
+<summary>Previous results (v3.0.0 API, Node.js v22.17.1, averaged over 3 clean runs)</summary>
 
 | Test | EVG Observable | RxJS | Advantage |
 |------|----------------|------|-----------|
@@ -60,20 +81,6 @@ Benchmarked with minified bundles on Node.js v22.17.1 (v3.0.0 API, averaged over
 | Batch emission - of(100) | 906K ops/sec | 176K ops/sec | **5.1x faster** |
 | 5 chained filters | 19K ops/sec | 9K ops/sec | **2.1x faster** |
 | Large payload | 879K ops/sec | 184K ops/sec | **4.8x faster** |
-
-<details>
-<summary>Previous results (v2.x API, measured in different conditions)</summary>
-
-| Test | EVG Observable | RxJS | Advantage |
-|------|----------------|------|-----------|
-| Emit 100 values | 1,548K ops/sec | 240K ops/sec | **6.4x faster** |
-| Filter + transform | 353K ops/sec | 164K ops/sec | **2.1x faster** |
-| 10 subscribers | 9,078K ops/sec | 2,900K ops/sec | **3.1x faster** |
-| 100 subscribers | 1,245K ops/sec | 336K ops/sec | **3.7x faster** |
-| 1000 subscribers | 122K ops/sec | 33K ops/sec | **3.7x faster** |
-| Large payload | 865K ops/sec | 199K ops/sec | **4.3x faster** |
-
-**Note**: v3.0.0 performance is equal or better than v2.x (emit: +7%, 10 subs: +10%). The API redesign with more flexible pipe system maintains excellent performance while providing enhanced functionality.
 </details>
 
 ### EVG Observable Advantages
@@ -90,7 +97,7 @@ Benchmarked with minified bundles on Node.js v22.17.1 (v3.0.0 API, averaged over
 
 ### When to use RxJS instead
 
-RxJS is better when you need specialized operators like `debounceTime`, `throttleTime`, `switchMap`, `mergeMap`, `combineLatest`, `withLatestFrom`, or schedulers for async control.
+RxJS is better when you need specialized operators like `switchMap`, `mergeMap`, `combineLatest`, `withLatestFrom`, or schedulers for async control.
 
 **For 80% of reactive programming tasks, EVG Observable provides sufficient functionality with significant performance and size benefits.**
 
@@ -103,7 +110,7 @@ Comparison with lightweight libraries in the same weight category (observable-fn
 | Metric | EVG Observable | observable-fns |
 |--------|----------------|----------------|
 | **Weekly downloads** | Growing | 67K |
-| **Bundle size (minified)** | 7.2 kB | 10.8 kB |
+| **Bundle size (minified)** | 9.4 kB | 9.9 kB |
 | **Implementation** | Original architecture | zen-observable re-implementation |
 | **Dependencies** | 0 | 0 |
 | **Architecture** | True hot observables | Cold observables (zen-observable API) |
@@ -334,6 +341,269 @@ observable$.next({message: "some message3", isNeedUnsubscribe: true});
 
 Observable will send a value to the listener only if condition returns "true". There is no automatic unsubscription.
 
+### pipe().throttle(ms)
+
+Throttle emissions using leading-edge strategy. The first value passes immediately; subsequent values within the cooldown interval are silently dropped.
+
+```ts
+import {Observable} from "evg_observable";
+
+const observable$ = new Observable<string>('');
+const received: string[] = [];
+
+observable$
+    .pipe()
+    .throttle(300)  // Only allow one value per 300ms
+    .subscribe((value: string) => received.push(value));
+
+observable$.next("first");   // passes immediately
+observable$.next("second");  // dropped (within 300ms)
+observable$.next("third");   // dropped (within 300ms)
+// After 300ms...
+observable$.next("fourth");  // passes (interval expired)
+```
+
+Throttle can be combined with other pipe operators:
+
+```ts
+observable$
+    .pipe()
+    .and(str => str.length > 1)    // filter short strings
+    .throttle(500)                  // throttle remaining values
+    .map<number>(str => str.length) // transform to length
+    .subscribe(listener);
+```
+
+### pipe().debounce(ms)
+
+Debounce emissions using trailing-edge strategy. Each new value resets the timer. The value is emitted after `ms` milliseconds of silence (no new values).
+
+```ts
+import {Observable} from "evg_observable";
+
+const search$ = new Observable<string>('');
+const results: string[] = [];
+
+search$
+    .pipe()
+    .debounce(300)  // Wait 300ms of silence before emitting
+    .subscribe((value: string) => results.push(value));
+
+search$.next("h");      // timer starts
+search$.next("he");     // timer resets
+search$.next("hello");  // timer resets
+// After 300ms of silence → "hello" is emitted
+```
+
+Debounce can be combined with other pipe operators:
+
+```ts
+observable$
+    .pipe()
+    .and(str => str.length > 2)    // filter short strings first
+    .debounce(200)                  // debounce remaining values
+    .map<number>(str => str.length) // transform to length
+    .subscribe(listener);
+```
+
+### pipe().distinctUntilChanged(comparator?)
+
+Suppresses consecutive duplicate values. A value is emitted only when it differs from the previously emitted value. The first value always passes through.
+
+```ts
+import {Observable} from "evg_observable";
+
+const observable$ = new Observable<number>(0);
+const results: number[] = [];
+
+observable$
+    .pipe()
+    .distinctUntilChanged()
+    .subscribe((value: number) => results.push(value));
+
+observable$.next(1);  // emitted (first value)
+observable$.next(1);  // suppressed (same as previous)
+observable$.next(2);  // emitted (different)
+observable$.next(2);  // suppressed (same as previous)
+observable$.next(1);  // emitted (different from 2)
+// results: [1, 2, 1]
+```
+
+With custom comparator for objects:
+
+```ts
+const users$ = new Observable<{id: number; name: string}>({id: 0, name: ''});
+
+users$
+    .pipe()
+    .distinctUntilChanged((prev, curr) => prev.id === curr.id)
+    .subscribe(user => console.log(user.name));
+
+users$.next({id: 1, name: 'Alice'});         // emitted
+users$.next({id: 1, name: 'Alice Updated'}); // suppressed (same id)
+users$.next({id: 2, name: 'Bob'});           // emitted
+```
+
+### pipe().tap(fn)
+
+Executes a side-effect function on the current value without modifying it. The value passes through unchanged to the next operator. Useful for logging, debugging, or triggering external actions mid-pipeline.
+
+```ts
+import {Observable} from "evg_observable";
+
+const observable$ = new Observable<number>(0);
+
+observable$
+    .pipe()
+    .tap(value => console.log('before filter:', value))
+    .and(value => value > 0)
+    .tap(value => console.log('after filter:', value))
+    .map<string>(value => `Result: ${value}`)
+    .subscribe(result => console.log(result));
+
+observable$.next(5);
+// before filter: 5
+// after filter: 5
+// Result: 5
+
+observable$.next(-1);
+// before filter: -1
+// (filtered out by .and(), tap after filter is not called)
+```
+
+#### Global debug flag pattern
+
+Use a debug flag to enable/disable all taps at once — zero runtime cost when disabled:
+
+```ts
+const DEBUG = true; // set to false in production
+
+const observable$ = new Observable<number>(0);
+
+observable$
+    .pipe()
+    .tap(value => DEBUG && console.log('[filter-in]:', value))
+    .and(value => value > 0)
+    .tap(value => DEBUG && console.log('[filter-out]:', value))
+    .map<number>(value => value * 2)
+    .tap(value => DEBUG && console.log('[mapped]:', value))
+    .subscribe(listener);
+
+observable$.next(5);
+// DEBUG=true:  [filter-in]: 5 → [filter-out]: 5 → [mapped]: 10
+// DEBUG=false: (nothing logged, V8 optimizes `false && ...` to no-op)
+```
+
+You can also use named taps for clarity in complex pipelines:
+
+```ts
+const tap_log = (name: string) => (value: any) =>
+    DEBUG && console.log(`[${name}]:`, value);
+
+observable$
+    .pipe()
+    .tap(tap_log('raw'))
+    .and(value => value > 0)
+    .tap(tap_log('filtered'))
+    .distinctUntilChanged()
+    .tap(tap_log('unique'))
+    .subscribe(listener);
+```
+
+### pipe().take(n)
+
+Passes the first N values through the pipe, then automatically unsubscribes. Generalization of `once()` — `once()` is equivalent to `take(1)`.
+
+```ts
+import {Observable} from "evg_observable";
+
+const observable$ = new Observable<string>('');
+const received: string[] = [];
+
+observable$
+    .pipe()
+    .take(3)
+    .subscribe((value: string) => received.push(value));
+
+observable$.next("a");  // received: ["a"]
+observable$.next("b");  // received: ["a", "b"]
+observable$.next("c");  // received: ["a", "b", "c"] — auto-unsubscribed
+observable$.next("d");  // not received
+```
+
+Combine with filters and transforms:
+
+```ts
+observable$
+    .pipe()
+    .and(str => str.length > 2)    // filter short strings
+    .take(2)                        // take first 2 that pass
+    .subscribe(listener);
+```
+
+### pipe().skip(n)
+
+Ignores the first N values in the pipe, then passes all subsequent values through. Mirror of `take(n)`.
+
+```ts
+import {Observable} from "evg_observable";
+
+const observable$ = new Observable<string>('');
+const received: string[] = [];
+
+observable$
+    .pipe()
+    .skip(2)
+    .subscribe((value: string) => received.push(value));
+
+observable$.next("a");  // skipped
+observable$.next("b");  // skipped
+observable$.next("c");  // received: ["c"]
+observable$.next("d");  // received: ["c", "d"]
+```
+
+Combine skip + take for window slicing:
+
+```ts
+observable$
+    .pipe()
+    .skip(2)    // skip first 2
+    .take(3)    // take next 3, then unsubscribe
+    .subscribe(listener);
+```
+
+### pipe().scan&lt;K&gt;(fn, seed)
+
+Accumulator operator — each value passes through a reducer function, the accumulated result is emitted. Like `Array.reduce()` for streams.
+
+```ts
+import {Observable} from "evg_observable";
+
+const observable$ = new Observable<number>(0);
+const sums: number[] = [];
+
+observable$
+    .pipe()
+    .scan<number>((acc, val) => acc + val, 0)
+    .subscribe((sum: number) => sums.push(sum));
+
+observable$.next(1);   // sums: [1]
+observable$.next(2);   // sums: [1, 3]
+observable$.next(3);   // sums: [1, 3, 6]
+```
+
+Type-changing scan (string → number):
+
+```ts
+const observable$ = new Observable<string>('');
+
+observable$
+    .pipe()
+    .scan<number>((acc, str) => acc + str.length, 0)
+    .and(total => total > 5)
+    .subscribe(total => console.log('Total chars:', total));
+```
+
 ### pipe().toJson()
 
 To convert the observable's data to JSON format, you can use the serialize method. This method turns the observer's
@@ -805,7 +1075,14 @@ observable$.next(-1);  // Listener 1 throws, listener 2 still receives
 | `.choice()`                          | SwitchCase object                      | transitions the pipe into switch-case mode. In this mode, only the first condition that returns a positive result is triggered, and all others are ignored. This allows you to handle multiple cases more conveniently. |
 | `.or(*condition)`                  | PipeCase object                        | Adds a condition to the chain of cases. The entire chain operates on the principle of "OR". This is different from other pipe methods which, when chained, operate on the principle of "AND".                           |
 | `.anyOf(*conditions)`            | PipeCase object                        | This method allows you to add a group of conditions for filtering cases data in the pipeline chain.                                                                                                                     |
+| `.throttle(ms: number)`              | pipe object                            | Throttles emissions using leading-edge strategy. First value passes immediately, subsequent values within `ms` interval are dropped.                                                                                    |
+| `.debounce(ms: number)`              | pipe object                            | Debounces emissions using trailing-edge strategy. Each new value resets the timer. Emits after `ms` milliseconds of silence.                                                                                            |
+| `.distinctUntilChanged(comparator?)` | pipe object                            | Suppresses consecutive duplicate values. Optional `comparator(prev, curr) => boolean` for custom equality. Defaults to `===`.                                                                                          |
+| `.tap(fn: ICallback<T>)`            | pipe object                            | Executes a side-effect function without modifying the value. The value passes through unchanged.                                                                                                                        |
+| `.take(n: number)`                   | pipe object                            | Passes the first N values, then auto-unsubscribes. Generalization of `once()`.                                                                                                                                          |
+| `.skip(n: number)`                   | pipe object                            | Ignores the first N values, then passes all subsequent values through. Mirror of `take()`.                                                                                                                              |
 | `.map<K>(transform: ICallback<T>)`  | Observable instance with new data type | This method allows transforming payload data in the pipe chain by applying user callback function. `transform` should be a function that takes the current data and returns transformed data of possibly another type.  |
+| `.scan<K>(fn, seed)`                | pipe object with new type K            | Accumulator — each value passes through reducer `fn(acc, val) => newAcc`, emits accumulated result. Like `Array.reduce()` for streams.                                                                                  |
 | `.toJson()`                       | pipe object                            | Converts the observers data into a JSON string.                                                                                                                                                                         |
 | `.fromJson<K>()`                  | pipe object                            | Converts a JSON string into an object of type K.                                                                                                                                                                        |
 | `.of<K, V>(transform?: ICallback<K>)`| pipe object                            | Iterates over array elements. For each element, emits it to subscribers. Optional transform function processes each element before emission.                                                                             |

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "evg_observable",
-  "version": "3.0.0",
-  "description": "Alternative fast and light library version - observable.",
+  "version": "3.1.0",
+  "description": "Lightweight reactive Observable library (zero dependencies) — 2-7x faster than RxJS, 1.5-3x faster than observable-fns. Pipe operators: throttle, debounce, distinctUntilChanged, map, tap. Original hot-observable architecture, not a fork or wrapper.",
   "main": "src/outLib/index.js",
   "types": "src/outLib/index.d.ts",
   "directories": {
@@ -20,7 +20,9 @@
     "benchmark:patterns-edge": "ts-node benchmarks/benchmark-patterns-edge-cases.ts",
     "benchmark:patterns-clean": "ts-node benchmarks/benchmark-patterns-clean.ts",
     "benchmark:patterns-final": "ts-node benchmarks/benchmark-patterns-fixed.ts",
-    "benchmark:patterns-vs-competitors": "ts-node benchmarks/benchmark-patterns-vs-competitors.ts"
+    "benchmark:patterns-vs-competitors": "ts-node benchmarks/benchmark-patterns-vs-competitors.ts",
+    "bundle": "esbuild src/browser-entry.ts --bundle --minify --format=iife --outfile=repo/evg_observable.js",
+    "bundle:watch": "esbuild src/browser-entry.ts --bundle --minify --format=iife --outfile=repo/evg_observable.js --watch"
   },
   "repository": {
     "type": "git",
@@ -38,6 +40,7 @@
     "@types/chai": "^4.3.4",
     "benchmark": "^2.1.4",
     "chai": "^4.3.7",
+    "esbuild": "^0.27.4",
     "microtime": "^3.1.1",
     "mocha": "^11.7.5",
     "nyc": "^17.1.0",
@@ -47,17 +50,23 @@
     "typescript": "^5.4.5"
   },
   "keywords": [
-    "EVG Observable",
-    "evg_observable",
-    "Observable",
-    "Ordered observable",
-    "Light observable",
-    "Collector",
-    "Type script",
-    "TypeScript",
-    "TS",
-    "Java script",
-    "JavaScript",
-    "JS"
+    "observable",
+    "reactive",
+    "event-emitter",
+    "rxjs-alternative",
+    "lightweight",
+    "pub-sub",
+    "subscribe",
+    "pipe",
+    "filter",
+    "map",
+    "throttle",
+    "debounce",
+    "distinctUntilChanged",
+    "tap",
+    "state-management",
+    "event-stream",
+    "typescript",
+    "zero-dependencies"
   ]
 }

package/repo/evg_observable.js

@@ -1 +1 @@
-(()=>{"use strict";function s(s,r){return s.order>r.order?1:s.order<r.order?-1:0}function r(s,r){return s.order>r.order?-1:s.order<r.order?1:0}function e(s,r){const e=s.indexOf(r);return-1!==e&&(s.splice(e,1),!0)}function i(s){return"next"in s?r=>s.next(r):s}class t{pipe;counter;constructor(s){this.pipe=s,this.counter=s.chain.length?s.chain.length:0}or(s){this.counter++;const r=this.counter,e=this.pipe.chain;return e.push(i=>{i.isAvailable=!0,s(i.payload)&&(i.isBreak=!0),r!==e.length||i.isBreak||(i.isAvailable=!1)}),this}anyOf(s){if(!Array.isArray(s))return this;for(let r=0;r<s.length;r++)this.or(s[r]);return this}}class n{chain=[];flow={isBreak:!1,isUnsubscribe:!1,isAvailable:!1,payload:null};push(s){return this.chain.push(s),this}once(){return this.push(s=>{this.listener(s.payload),s.isUnsubscribe=!0})}unsubscribeBy(s){return this.push(r=>{r.isAvailable=!0,s(r.payload)&&(r.isUnsubscribe=!0)})}and(s){return this.push(r=>s(r.payload)&&(r.isAvailable=!0))}allOf(s){if(!Array.isArray(s))return this;for(let r=0;r<s.length;r++)this.and(s[r]);return this}choice(){return new h(this)}map(s){return this.push(r=>{r.payload=s(r.payload),r.isAvailable=!0})}toJson(){return this.push(s=>{s.payload=JSON.stringify(s.payload),s.isAvailable=!0})}fromJson(){return this.push(s=>{s.payload=JSON.parse(s.payload),s.isAvailable=!0})}group(){return this}processChain(s){const r=this.chain,e=this.flow,i=r.length;for(let s=0;s<i;s++){if(e.isUnsubscribe=!1,e.isAvailable=!1,r[s](e),e.isUnsubscribe)return this.unsubscribe();if(!e.isAvailable)return;if(e.isBreak)break}return s(e.payload)}}class h extends t{subscribe(s,r){return this.pipe.subscribe(s,r)}group(){return this.pipe}}class l extends n{observer;listener;errorHandler=(s,r)=>{console.log(`(Unit of SubscribeObject).send(${s}) ERROR:`,r)};_order=0;paused=!1;piped=!1;listeners;errorHandlers;constructor(s,r){super(),this.observer=s,this.piped=!!r}subscribe(s,r){return this.listener=function(s){if(Array.isArray(s)){const r=[];for(let e=0;e<s.length;e++)r.push(i(s[e]));return s=>{for(let e=0;e<r.length;e++)r[e](s)}}return i(s)}(s),r&&(this.errorHandler=r),this}add(s,r){if(this.listeners||(this.listeners=[],this.errorHandlers=[]),Array.isArray(s))for(let e=0;e<s.length;e++){this.listeners.push(s[e]);const i=r&&Array.isArray(r)?r[e]??this.errorHandler:r||this.errorHandler;this.errorHandlers.push(i)}else{this.listeners.push(s);const e=r&&!Array.isArray(r)?r:this.errorHandler;this.errorHandlers.push(e)}return this}unsubscribe(){this.observer&&(this.observer.unSubscribe(this),this.observer=null,this.listener=null,this.chain.length=0)}send(s){const r=this.listener,e=this.listeners&&this.listeners.length>0;if(r||e){if(this.observer&&!this.paused)if(this.piped)try{if(this.flow.payload=s,this.flow.isBreak=!1,r)this.processChain(r);else{const s=this.chain,r=this.flow,e=s.length;r.isAvailable=0===e;for(let i=0;i<e;i++){if(r.isUnsubscribe=!1,r.isAvailable=!1,s[i](r),r.isUnsubscribe)return void this.unsubscribe();if(!r.isAvailable)return;if(r.isBreak)break}}if(e){const s=this.flow.payload;for(let r=0;r<this.listeners.length;r++)try{this.listeners[r](s)}catch(e){this.errorHandlers[r](s,e)}}}catch(r){this.errorHandler(s,r)}else{if(r)try{r(s)}catch(r){this.errorHandler(s,r)}if(e)for(let r=0;r<this.listeners.length;r++)try{this.listeners[r](s)}catch(e){this.errorHandlers[r](s,e)}}}else this.unsubscribe()}resume(){this.paused=!1}pause(){this.paused=!0}get order(){return this._order}set order(s){this._order=s}}class a{chain=[];flow={isBreak:!1,isAvailable:!1,payload:null};response={isOK:!1,payload:void 0};errHandler;get isEmpty(){return!this.chain.length}push(s){return this.chain.push(s),this}and(s){return this.push(r=>s(r.payload)&&(r.isAvailable=!0))}allOf(s){if(!Array.isArray(s))return this;for(let r=0;r<s.length;r++)this.and(s[r]);return this}choice(){return new o(this)}processChain(s){const r=this.chain,e=this.flow,i=this.response;i.isOK=!1,i.payload=void 0,e.payload=s,e.isBreak=!1;try{const s=r.length;for(let t=0;t<s;t++){if(e.isAvailable=!1,r[t](e),!e.isAvailable)return i;if(e.isBreak)break}}catch(s){return this.errHandler?this.errHandler(s,"Filter.processChain ERROR:"):console.log("Filter.processChain ERROR:",s),i}return i.isOK=!0,i.payload=e.payload,i}addErrorHandler(s){this.errHandler=s}}class o extends t{}class u{subs=[];enabled=!0;killed=!1;process=!1;trash=[];filters=new a;_value;constructor(s){this._value=s}addFilter(s){return s&&this.filters.addErrorHandler(s),this.filters}disable(){this.enabled=!1}enable(){this.enabled=!0}get isEnable(){return this.enabled}next(s){if(this.killed)return;if(!this.enabled)return;if(!this.subs.length)return;if(!this.filters.isEmpty&&!this.filters.processChain(s).isOK)return;this.process=!0,this._value=s;const r=this.subs,e=r.length;for(let i=0;i<e;i++)r[i].send(s);this.process=!1,this.trash.length&&this.clearTrash()}of(s){if(!this.killed&&this.enabled)for(let r=0;r<s.length;r++)this.next(s[r])}in(s){if(!this.killed&&this.enabled)for(const r in s)Object.hasOwn(s,r)&&this.next([r,s[r]])}clearTrash(){const s=this.trash.length;for(let r=0;r<s;r++)this.unSubscribe(this.trash[r]);this.trash.length=0}unSubscribe(s){this.killed||(this.process&&s?this.trash.push(s):this.subs&&e(this.subs,s))}destroy(){if(!this.killed){if(this.killed=!0,!this.process)return this._value=null,void(this.subs.length=0);Promise.resolve().then(()=>{this._value=null,this.subs.length=0})}}unsubscribeAll(){if(!this.killed){if(this.process){const s=this.subs;for(let r=0;r<s.length;r++)this.trash.push(s[r]);return}this.subs.length=0}}getValue(){if(!this.killed)return this._value}size(){return this.killed?0:this.subs.length}subscribe(s,r){if(this.killed)return;if(!this.isListener(s))return;const e=new l(this,!1);return this.addObserver(e,s,r),e}addObserver(s,r,e){s.subscribe(r,e),this.subs.push(s)}isListener(s){return!this.killed&&!!s}pipe(){if(this.killed)return;const s=new l(this,!0);return this.subs.push(s),s}get isDestroyed(){return this.killed}}class d extends l{constructor(s,r){super(s,r)}get order(){return this._order}set order(s){!this.observer||this.observer&&this.observer.isDestroyed?this._order=void 0:(this._order=s,this.observer.sortByOrder())}subscribe(s,r){return super.subscribe(s,r),this}once(){return super.once()}}const c=window;c.Observable=u,c.Collector=class{arr=[];killed=!1;collect(...s){this.killed||this.arr.push(...s)}unsubscribe(s){this.killed||(s?.unsubscribe(),e(this.arr,s))}unsubscribeAll(){if(this.killed)return;const s=this.arr;for(let r=0;r<s.length;r++)s[r].unsubscribe();s.length=0}size(){return this.killed?0:this.arr.length}destroy(){this.unsubscribeAll(),this.arr.length=0,this.arr=0,this.killed=!0}get isDestroyed(){return this.killed}},c.OrderedObservable=class extends u{sortDirection=s;ascendingSort(){return this.sortDirection=s,this.sortByOrder()}descendingSort(){return this.sortDirection=r,this.sortByOrder()}sortByOrder(){return!this.killed&&(this.subs.sort(this.sortDirection),!0)}subscribe(s,r){if(!this.isListener(s))return;const e=new d(this,!1);return this.addObserver(e,s,r),e}pipe(){if(this.killed)return;const s=new d(this,!0);return this.subs.push(s),s}unSubscribe(s){this.killed||(this.process&&s?this.trash.push(s):this.subs&&e(this.subs,s))}}})();
+"use strict";(()=>{function y(t,e){return t.order>e.order?1:t.order<e.order?-1:0}function v(t,e){return t.order>e.order?-1:t.order<e.order?1:0}function o(t,e){let r=t.indexOf(e);return r===-1?!1:(t.splice(r,1),!0)}function O(t){if(Array.isArray(t)){let e=t.length,r=new Array(e);for(let i=0;i<e;i++)r[i]=k(t[i]);return i=>{for(let s=0;s<e;s++)r[s](i)}}return k(t)}function k(t){return"next"in t?e=>t.next(e):t}var c=class{pipe;counter;constructor(e){this.pipe=e,this.counter=e.chain.length?e.chain.length:0}or(e){this.counter++;let r=this.counter,i=this.pipe.chain;return i.push(s=>{s.isAvailable=!0,e(s.payload)&&(s.isBreak=!0),r===i.length&&!s.isBreak&&(s.isAvailable=!1)}),this}anyOf(e){if(!Array.isArray(e))return this;for(let r=0;r<e.length;r++)this.or(e[r]);return this}};var I=class{chain=[];flow={isBreak:!1,isUnsubscribe:!1,isAvailable:!1,debounceMs:0,debounceTimer:0,debounceValue:void 0,debounceIndex:0,payload:null};push(e){return this.chain.push(e),this}once(){return this.push(e=>{this.listener(e.payload),e.isUnsubscribe=!0})}take(e){e<0&&(e=0);let r=0;return this.push(i=>{if(r>=e){i.isUnsubscribe=!0;return}r++,this.listener(i.payload),r>=e&&(i.isUnsubscribe=!0)})}skip(e){e<0&&(e=0);let r=0;return this.push(i=>{if(r<e){r++;return}i.isAvailable=!0})}unsubscribeBy(e){return this.push(r=>{r.isAvailable=!0,e(r.payload)&&(r.isUnsubscribe=!0)})}and(e){return this.push(r=>e(r.payload)&&(r.isAvailable=!0))}allOf(e){if(!Array.isArray(e))return this;for(let r=0;r<e.length;r++)this.and(e[r]);return this}choice(){return new T(this)}map(e){return this.push(r=>{r.payload=e(r.payload),r.isAvailable=!0})}scan(e,r){let i=r;return this.push(s=>{i=e(i,s.payload),s.payload=i,s.isAvailable=!0})}tap(e){return this.push(r=>{e(r.payload),r.isAvailable=!0})}throttle(e){let r=0;return this.push(i=>{let s=Date.now();s-r>=e&&(r=s,i.isAvailable=!0)})}debounce(e){return this.push(r=>{r.isAvailable=!0,r.debounceMs=e})}distinctUntilChanged(e){let r=!1,i;return this.push(s=>{let n=s.payload;r&&(e?e(i,n):i===n)||(r=!0,i=n,s.isAvailable=!0)})}toJson(){return this.push(e=>{e.payload=JSON.stringify(e.payload),e.isAvailable=!0})}fromJson(){return this.push(e=>{e.payload=JSON.parse(e.payload),e.isAvailable=!0})}group(){return this}processChain(e){let r=this.chain,i=this.flow,s=r.length;for(let n=0;n<s;n++){if(i.isUnsubscribe=!1,i.isAvailable=!1,i.debounceMs=0,r[n](i),i.isUnsubscribe)return this.unsubscribe();if(i.debounceMs>0){i.debounceValue=i.payload,i.debounceIndex=n+1;let l=()=>{i.debounceTimer=0,i.payload=i.debounceValue,i.isBreak=!1;for(let a=i.debounceIndex;a<s;a++){if(i.isUnsubscribe=!1,i.isAvailable=!1,i.debounceMs=0,r[a](i),i.isUnsubscribe)return this.unsubscribe();if(i.debounceMs>0){i.debounceValue=i.payload,i.debounceIndex=a+1,clearTimeout(i.debounceTimer),i.debounceTimer=setTimeout(l,i.debounceMs);return}if(!i.isAvailable)return;if(i.isBreak)break}e&&e(i.payload)};clearTimeout(i.debounceTimer),i.debounceTimer=setTimeout(l,i.debounceMs);return}if(!i.isAvailable)return;if(i.isBreak)break}i.isAvailable=!0,e&&e(i.payload)}},T=class extends c{subscribe(e,r){return this.pipe.subscribe(e,r)}group(){return this.pipe}};var u=class extends I{observer;listener;errorHandler=(e,r)=>{console.log(`(Unit of SubscribeObject).send(${e}) ERROR:`,r)};_order=0;paused=!1;piped=!1;listeners;errorHandlers;constructor(e,r){super(),this.observer=e,this.piped=!!r}subscribe(e,r){return this.listener=O(e),r&&(this.errorHandler=r),this}add(e,r){if(this.listeners||(this.listeners=[],this.errorHandlers=[]),Array.isArray(e))for(let i=0;i<e.length;i++){this.listeners.push(e[i]);let s=r&&Array.isArray(r)?r[i]??this.errorHandler:r||this.errorHandler;this.errorHandlers.push(s)}else{this.listeners.push(e);let i=r&&!Array.isArray(r)?r:this.errorHandler;this.errorHandlers.push(i)}return this}unsubscribe(){this.observer&&(clearTimeout(this.flow.debounceTimer),this.observer.unSubscribe(this),this.observer=null,this.listener=null,this.chain.length=0)}send(e){let r=this.listener,i=this.listeners&&this.listeners.length>0;if(!r&&!i){this.unsubscribe();return}if(!(!this.observer||this.paused)){if(!this.piped){if(r)try{r(e)}catch(s){this.errorHandler(e,s)}return}try{if(this.flow.payload=e,this.flow.isBreak=!1,i){let s=this.listeners,n=this.errorHandlers;this.processChain(l=>{r&&r(l);for(let a=0;a<s.length;a++)try{s[a](l)}catch(C){n[a](l,C)}})}else this.processChain(r)}catch(s){this.errorHandler(e,s)}}}resume(){this.paused=!1}pause(){this.paused=!0}get order(){return this._order}set order(e){this._order=e}};var f=class{chain=[];flow={isBreak:!1,isAvailable:!1,payload:null};response={isOK:!1,payload:void 0};errHandler;get isEmpty(){return!this.chain.length}push(e){return this.chain.push(e),this}and(e){return this.push(r=>e(r.payload)&&(r.isAvailable=!0))}allOf(e){if(!Array.isArray(e))return this;for(let r=0;r<e.length;r++)this.and(e[r]);return this}choice(){return new m(this)}processChain(e){let r=this.chain,i=this.flow,s=this.response;s.isOK=!1,s.payload=void 0,i.payload=e,i.isBreak=!1;try{let n=r.length;for(let l=0;l<n;l++){if(i.isAvailable=!1,r[l](i),!i.isAvailable)return s;if(i.isBreak)break}}catch(n){return this.errHandler?this.errHandler(n,"Filter.processChain ERROR:"):console.log("Filter.processChain ERROR:",n),s}return s.isOK=!0,s.payload=i.payload,s}addErrorHandler(e){this.errHandler=e}},m=class extends c{};var b=class{subs=[];enabled=!0;killed=!1;process=!1;trash=[];filters=new f;_value;constructor(e){this._value=e}addFilter(e){return e&&this.filters.addErrorHandler(e),this.filters}disable(){this.enabled=!1}enable(){this.enabled=!0}get isEnable(){return this.enabled}next(e){if(this.killed||!this.enabled||!this.subs.length||!this.filters.isEmpty&&!this.filters.processChain(e).isOK)return;this.process=!0,this._value=e;let r=this.subs,i=r.length;for(let s=0;s<i;s++)r[s].send(e);this.process=!1,this.trash.length&&this.clearTrash()}of(e){if(!this.killed&&this.enabled)for(let r=0;r<e.length;r++)this.next(e[r])}in(e){if(!this.killed&&this.enabled)for(let r in e)Object.hasOwn(e,r)&&this.next([r,e[r]])}clearTrash(){let e=this.trash.length;for(let r=0;r<e;r++)this.unSubscribe(this.trash[r]);this.trash.length=0}unSubscribe(e){if(!this.killed){if(this.process&&e){this.trash.push(e);return}this.subs&&o(this.subs,e)}}destroy(){if(!this.killed){if(this.killed=!0,!this.process){this.clearDebounceTimers(),this._value=null,this.subs.length=0;return}Promise.resolve().then(()=>{this.clearDebounceTimers(),this._value=null,this.subs.length=0})}}unsubscribeAll(){if(!this.killed){if(this.process){this.clearDebounceTimers();let e=this.subs;for(let r=0;r<e.length;r++)this.trash.push(e[r]);return}this.clearDebounceTimers(),this.subs.length=0}}clearDebounceTimers(){let e=this.subs;for(let r=0;r<e.length;r++)clearTimeout(e[r].flow.debounceTimer)}getValue(){if(!this.killed)return this._value}size(){return this.killed?0:this.subs.length}subscribe(e,r){if(this.killed||!this.isListener(e))return;let i=new u(this,!1);return this.addObserver(i,e,r),i}addObserver(e,r,i){e.subscribe(r,i),this.subs.push(e)}isListener(e){return this.killed?!1:!!e}pipe(){if(this.killed)return;let e=new u(this,!0);return this.subs.push(e),e}get isDestroyed(){return this.killed}};var d=class extends u{constructor(e,r){super(e,r)}get order(){return this._order}set order(e){if(!this.observer||this.observer&&this.observer.isDestroyed){this._order=void 0;return}this._order=e,this.observer.sortByOrder()}subscribe(e,r){return super.subscribe(e,r),this}once(){return super.once()}take(e){return super.take(e)}skip(e){return super.skip(e)}scan(e,r){return super.scan(e,r)}};var h=class extends b{sortDirection=y;ascendingSort(){return this.sortDirection=y,this.sortByOrder()}descendingSort(){return this.sortDirection=v,this.sortByOrder()}sortByOrder(){return this.killed?!1:(this.subs.sort(this.sortDirection),!0)}subscribe(e,r){if(!this.isListener(e))return;let i=new d(this,!1);return this.addObserver(i,e,r),i}pipe(){if(this.killed)return;let e=new d(this,!0);return this.subs.push(e),e}unSubscribe(e){if(!this.killed){if(this.process&&e){this.trash.push(e);return}this.subs&&o(this.subs,e)}}};var p=class{arr=[];killed=!1;collect(...e){this.killed||this.arr.push(...e)}unsubscribe(e){this.killed||(e?.unsubscribe(),o(this.arr,e))}unsubscribeAll(){if(this.killed)return;let e=this.arr;for(let r=0;r<e.length;r++)e[r].unsubscribe();e.length=0}size(){return this.killed?0:this.arr.length}destroy(){this.unsubscribeAll(),this.arr.length=0,this.arr=0,this.killed=!0}get isDestroyed(){return this.killed}};var S=window;S.Observable=b;S.OrderedObservable=h;S.Collector=p;})();

package/src/outLib/FunctionLibs.js

@@ -36,11 +36,12 @@ function quickDeleteFromArray(arr, component) {
 }
 function getListener(listenerGroup) {
     if (Array.isArray(listenerGroup)) {
-        const group = [];
-        for (let i = 0; i < listenerGroup.length; i++)
-            group.push(wrapListener(listenerGroup[i]));
+        const len = listenerGroup.length;
+        const group = new Array(len);
+        for (let i = 0; i < len; i++)
+            group[i] = wrapListener(listenerGroup[i]);
         return (data) => {
-            for (let i = 0; i < group.length; i++)
+            for (let i = 0; i < len; i++)
                 group[i](data);
         };
     }

package/src/outLib/Observable.d.ts

@@ -21,6 +21,7 @@ export declare class Observable<T> implements IObserver<T>, IStream<T>, IAddFilt
     unSubscribe(listener: ISubscriptionLike): void;
     destroy(): void;
     unsubscribeAll(): void;
+    protected clearDebounceTimers(): void;
     getValue(): T | undefined;
     size(): number;
     subscribe(observer: ISubscribeGroup<T>, errorHandler?: IErrorCallback): ISubscriptionLike | undefined;

package/src/outLib/Observable.js

@@ -86,11 +86,13 @@ class Observable {
             return;
         this.killed = true;
         if (!this.process) {
+            this.clearDebounceTimers();
             this._value = null;
             this.subs.length = 0;
             return;
         }
         Promise.resolve().then(() => {
+            this.clearDebounceTimers();
             this._value = null;
             this.subs.length = 0;
         });
@@ -99,13 +101,20 @@ class Observable {
         if (this.killed)
             return;
         if (this.process) {
+            this.clearDebounceTimers();
             const subs = this.subs;
             for (let i = 0; i < subs.length; i++)
                 this.trash.push(subs[i]);
             return;
         }
+        this.clearDebounceTimers();
         this.subs.length = 0;
     }
+    clearDebounceTimers() {
+        const subs = this.subs;
+        for (let i = 0; i < subs.length; i++)
+            clearTimeout(subs[i].flow.debounceTimer);
+    }
     getValue() {
         if (this.killed)
             return undefined;

package/src/outLib/OrderedSubscribeObject.d.ts

@@ -7,4 +7,7 @@ export declare class OrderedSubscribeObject<T> extends SubscribeObject<T> implem
     set order(value: number);
     subscribe(observer: IListener<T> | ISetObservableValue, errorHandler?: IErrorCallback): IOrderedSubscriptionLike;
     once(): IOrderedSubscribe<T>;
+    take(n: number): IOrderedSubscribe<T>;
+    skip(n: number): IOrderedSetup<T>;
+    scan<K>(fn: (accumulator: K, value: T) => K, seed: K): IOrderedSetup<K>;
 }

package/src/outLib/OrderedSubscribeObject.js

@@ -25,5 +25,14 @@ class OrderedSubscribeObject extends SubscribeObject_1.SubscribeObject {
     once() {
         return super.once();
     }
+    take(n) {
+        return super.take(n);
+    }
+    skip(n) {
+        return super.skip(n);
+    }
+    scan(fn, seed) {
+        return super.scan(fn, seed);
+    }
 }
 exports.OrderedSubscribeObject = OrderedSubscribeObject;

package/src/outLib/Pipe.d.ts

@@ -6,15 +6,22 @@ export declare abstract class Pipe<T> implements ISubscribe<T> {
     abstract subscribe(listener: IListener<T> | ISetObservableValue, errorHandler?: IErrorCallback): ISubscriptionLike | undefined;
     private push;
     once(): ISubscribe<T>;
+    take(n: number): ISubscribe<T>;
+    skip(n: number): ISetup<T>;
     unsubscribeBy(condition: ICallback<T>): ISetup<T>;
     and(condition: ICallback<T>): ISetup<T>;
     allOf(conditions: ICallback<any>[]): ISetup<T>;
     choice(): PipeSwitchCase<T>;
     map<K>(condition: ICallback<T>): ISetup<K>;
+    scan<K>(fn: (accumulator: K, value: T) => K, seed: K): ISetup<K>;
+    tap(fn: ICallback<T>): ISetup<T>;
+    throttle(ms: number): ISetup<T>;
+    debounce(ms: number): ISetup<T>;
+    distinctUntilChanged(comparator?: (previous: T, current: T) => boolean): ISetup<T>;
     toJson(): ISetup<string>;
     fromJson<K>(): ISetup<K>;
     group(): IGroupSubscription<T>;
-    processChain(listener: IListener<T>): void;
+    processChain(listener?: IListener<T>): void;
 }
 export declare class PipeSwitchCase<T> extends SwitchCase<T, Pipe<T>, IPipeCase<T>> implements ISubscribe<T> {
     subscribe(listener: IListener<T> | ISetObservableValue, errorHandler?: IErrorCallback): ISubscriptionLike | undefined;

package/src/outLib/Pipe.js

@@ -4,7 +4,16 @@ exports.PipeSwitchCase = exports.Pipe = void 0;
 const AbstractSwitchCase_1 = require("./AbstractSwitchCase");
 class Pipe {
     chain = [];
-    flow = { isBreak: false, isUnsubscribe: false, isAvailable: false, payload: null };
+    flow = {
+        isBreak: false,
+        isUnsubscribe: false,
+        isAvailable: false,
+        debounceMs: 0,
+        debounceTimer: 0,
+        debounceValue: undefined,
+        debounceIndex: 0,
+        payload: null
+    };
     push(callback) {
         this.chain.push(callback);
         return this;
@@ -15,6 +24,33 @@ class Pipe {
             data.isUnsubscribe = true;
         });
     }
+    take(n) {
+        if (n < 0)
+            n = 0;
+        let count = 0;
+        return this.push((data) => {
+            if (count >= n) {
+                data.isUnsubscribe = true;
+                return;
+            }
+            count++;
+            this.listener(data.payload);
+            if (count >= n)
+                data.isUnsubscribe = true;
+        });
+    }
+    skip(n) {
+        if (n < 0)
+            n = 0;
+        let count = 0;
+        return this.push((data) => {
+            if (count < n) {
+                count++;
+                return;
+            }
+            data.isAvailable = true;
+        });
+    }
     unsubscribeBy(condition) {
         return this.push((data) => {
             data.isAvailable = true;
@@ -41,6 +77,53 @@ class Pipe {
             data.isAvailable = true;
         });
     }
+    scan(fn, seed) {
+        let accumulator = seed;
+        return this.push((data) => {
+            accumulator = fn(accumulator, data.payload);
+            data.payload = accumulator;
+            data.isAvailable = true;
+        });
+    }
+    tap(fn) {
+        return this.push((data) => {
+            fn(data.payload);
+            data.isAvailable = true;
+        });
+    }
+    throttle(ms) {
+        let lastEmitTime = 0;
+        return this.push((data) => {
+            const now = Date.now();
+            if (now - lastEmitTime >= ms) {
+                lastEmitTime = now;
+                data.isAvailable = true;
+            }
+        });
+    }
+    debounce(ms) {
+        return this.push((data) => {
+            data.isAvailable = true;
+            data.debounceMs = ms;
+        });
+    }
+    distinctUntilChanged(comparator) {
+        let hasPrevious = false;
+        let previousValue;
+        return this.push((data) => {
+            const current = data.payload;
+            if (hasPrevious) {
+                const isSame = comparator
+                    ? comparator(previousValue, current)
+                    : previousValue === current;
+                if (isSame)
+                    return;
+            }
+            hasPrevious = true;
+            previousValue = current;
+            data.isAvailable = true;
+        });
+    }
     toJson() {
         return this.push((data) => {
             data.payload = JSON.stringify(data.payload);
@@ -63,15 +146,51 @@ class Pipe {
         for (let i = 0; i < len; i++) {
             data.isUnsubscribe = false;
             data.isAvailable = false;
+            data.debounceMs = 0;
             chain[i](data);
             if (data.isUnsubscribe)
                 return this.unsubscribe();
+            if (data.debounceMs > 0) {
+                data.debounceValue = data.payload;
+                data.debounceIndex = i + 1;
+                const continueChain = () => {
+                    data.debounceTimer = 0;
+                    data.payload = data.debounceValue;
+                    data.isBreak = false;
+                    for (let j = data.debounceIndex; j < len; j++) {
+                        data.isUnsubscribe = false;
+                        data.isAvailable = false;
+                        data.debounceMs = 0;
+                        chain[j](data);
+                        if (data.isUnsubscribe)
+                            return this.unsubscribe();
+                        if (data.debounceMs > 0) {
+                            data.debounceValue = data.payload;
+                            data.debounceIndex = j + 1;
+                            clearTimeout(data.debounceTimer);
+                            data.debounceTimer = setTimeout(continueChain, data.debounceMs);
+                            return;
+                        }
+                        if (!data.isAvailable)
+                            return;
+                        if (data.isBreak)
+                            break;
+                    }
+                    if (listener)
+                        listener(data.payload);
+                };
+                clearTimeout(data.debounceTimer);
+                data.debounceTimer = setTimeout(continueChain, data.debounceMs);
+                return;
+            }
             if (!data.isAvailable)
                 return;
             if (data.isBreak)
                 break;
         }
-        return listener(data.payload);
+        data.isAvailable = true;
+        if (listener)
+            listener(data.payload);
     }
 }
 exports.Pipe = Pipe;

package/src/outLib/SubscribeObject.js

@@ -50,6 +50,7 @@ class SubscribeObject extends Pipe_1.Pipe {
     unsubscribe() {
         if (!this.observer)
             return;
+        clearTimeout(this.flow.debounceTimer);
         this.observer.unSubscribe(this);
         this.observer = null;
         this.listener = null;
@@ -73,53 +74,29 @@ class SubscribeObject extends Pipe_1.Pipe {
                     this.errorHandler(value, err);
                 }
             }
-            if (hasGroupListeners) {
-                for (let i = 0; i < this.listeners.length; i++) {
-                    try {
-                        this.listeners[i](value);
-                    }
-                    catch (err) {
-                        this.errorHandlers[i](value, err);
-                    }
-                }
-            }
             return;
         }
         try {
             this.flow.payload = value;
             this.flow.isBreak = false;
-            if (listener) {
-                this.processChain(listener);
-            }
-            else {
-                const chain = this.chain;
-                const data = this.flow;
-                const len = chain.length;
-                data.isAvailable = len === 0;
-                for (let i = 0; i < len; i++) {
-                    data.isUnsubscribe = false;
-                    data.isAvailable = false;
-                    chain[i](data);
-                    if (data.isUnsubscribe) {
-                        this.unsubscribe();
-                        return;
-                    }
-                    if (!data.isAvailable)
-                        return;
-                    if (data.isBreak)
-                        break;
-                }
-            }
             if (hasGroupListeners) {
-                const processedValue = this.flow.payload;
-                for (let i = 0; i < this.listeners.length; i++) {
-                    try {
-                        this.listeners[i](processedValue);
-                    }
-                    catch (err) {
-                        this.errorHandlers[i](processedValue, err);
+                const groupListeners = this.listeners;
+                const groupErrorHandlers = this.errorHandlers;
+                this.processChain((value) => {
+                    if (listener)
+                        listener(value);
+                    for (let i = 0; i < groupListeners.length; i++) {
+                        try {
+                            groupListeners[i](value);
+                        }
+                        catch (err) {
+                            groupErrorHandlers[i](value, err);
+                        }
                     }
-                }
+                });
+            }
+            else {
+                this.processChain(listener);
             }
         }
         catch (err) {

package/src/outLib/Types.d.ts

@@ -31,6 +31,24 @@ export type IOnce<T> = {
 export type IOrderedOnce<T> = {
     once(): IOrderedSubscribe<T>;
 };
+export type ITake<T> = {
+    take(n: number): ISubscribe<T>;
+};
+export type IOrderedTake<T> = {
+    take(n: number): IOrderedSubscribe<T>;
+};
+export type ISkip<T> = {
+    skip(n: number): ISetup<T>;
+};
+export type IOrderedSkip<T> = {
+    skip(n: number): IOrderedSetup<T>;
+};
+export type IScan<T> = {
+    scan<K>(fn: (accumulator: K, value: T) => K, seed: K): ISetup<K>;
+};
+export type IOrderedScan<T> = {
+    scan<K>(fn: (accumulator: K, value: T) => K, seed: K): IOrderedSetup<K>;
+};
 export type ISetObservableValue = {
     next(value: any): void;
 };
@@ -40,8 +58,8 @@ export type ISubscriptionLike = {
 export type IGroupSubscription<T> = ISubscriptionLike & {
     add(listener: IListener<T> | IListener<T>[], errorHandler?: IErrorCallback | IErrorCallback[]): IGroupSubscription<T>;
 };
-export type ISetup<T> = IUnsubscribeByPositive<T> & IEmitByPositive<T> & IOnce<T> & ISwitch<T> & ITransform<T> & ISerialisation & IGroup<T> & ISubscribe<T>;
-export type IOrderedSetup<T> = IOrderedUnsubscribeByPositive<T> & IOrderedEmitByPositive<T> & IOrderedOnce<T> & IOrderedSwitch<T> & IOrderedTransform<T> & IOrderedSerialisation & IOrderedGroup<T> & IOrderedSubscribe<T>;
+export type ISetup<T> = IUnsubscribeByPositive<T> & IEmitByPositive<T> & IOnce<T> & ITake<T> & ISkip<T> & IScan<T> & ISwitch<T> & ITransform<T> & IThrottle<T> & IDebounce<T> & IDistinctUntilChanged<T> & ITap<T> & ISerialisation & IGroup<T> & ISubscribe<T>;
+export type IOrderedSetup<T> = IOrderedUnsubscribeByPositive<T> & IOrderedEmitByPositive<T> & IOrderedOnce<T> & IOrderedTake<T> & IOrderedSkip<T> & IOrderedScan<T> & IOrderedSwitch<T> & IOrderedTransform<T> & IOrderedThrottle<T> & IOrderedDebounce<T> & IOrderedDistinctUntilChanged<T> & IOrderedTap<T> & IOrderedSerialisation & IOrderedGroup<T> & IOrderedSubscribe<T>;
 export type ISubscribeObject<T> = ISubscriptionLike & IPause & IOrder & ISend<T> & ISetup<T>;
 export type ISubscribeCounter = {
     size(): number;
@@ -100,6 +118,9 @@ export type IEmitByPositive<T> = {
 export type ITransform<T> = {
     map<K>(condition: ICallback<T>): ISetup<K>;
 };
+export type IThrottle<T> = {
+    throttle(ms: number): ISetup<T>;
+};
 export type ISerialisation = {
     toJson(): ISetup<string>;
     fromJson<K>(): ISetup<K>;
@@ -111,6 +132,27 @@ export type IOrderedEmitByPositive<T> = {
 export type IOrderedTransform<T> = {
     map<K>(condition: ICallback<T>): ISetup<K>;
 };
+export type IOrderedThrottle<T> = {
+    throttle(ms: number): ISetup<T>;
+};
+export type IDebounce<T> = {
+    debounce(ms: number): ISetup<T>;
+};
+export type IOrderedDebounce<T> = {
+    debounce(ms: number): ISetup<T>;
+};
+export type IDistinctUntilChanged<T> = {
+    distinctUntilChanged(comparator?: (previous: T, current: T) => boolean): ISetup<T>;
+};
+export type IOrderedDistinctUntilChanged<T> = {
+    distinctUntilChanged(comparator?: (previous: T, current: T) => boolean): ISetup<T>;
+};
+export type ITap<T> = {
+    tap(fn: ICallback<T>): ISetup<T>;
+};
+export type IOrderedTap<T> = {
+    tap(fn: ICallback<T>): ISetup<T>;
+};
 export type IOrderedSerialisation = {
     toJson(): ISetup<string>;
     fromJson<K>(): ISetup<K>;
@@ -141,6 +183,10 @@ export type IPipePayload = {
     isBreak: boolean;
     isUnsubscribe: boolean;
     isAvailable: boolean;
+    debounceMs: number;
+    debounceTimer: any;
+    debounceValue: any;
+    debounceIndex: number;
     payload: any;
 };
 export type IChainCallback = (data: IPipePayload) => void;

package/BENCHMARK_BUNDLE_RESULTS.md

@@ -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

@@ -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

@@ -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.