evg_observable 2.15.8 → 3.0.1

package/src/outLib/OrderedSubscribeObject.d.ts

@@ -6,5 +6,5 @@ export declare class OrderedSubscribeObject<T> extends SubscribeObject<T> implem
     get order(): number;
     set order(value: number);
     subscribe(observer: IListener<T> | ISetObservableValue, errorHandler?: IErrorCallback): IOrderedSubscriptionLike;
-    setOnce(): IOrderedSubscribe<T>;
+    once(): IOrderedSubscribe<T>;
 }

package/src/outLib/OrderedSubscribeObject.js

@@ -22,8 +22,8 @@ class OrderedSubscribeObject extends SubscribeObject_1.SubscribeObject {
         super.subscribe(observer, errorHandler);
         return this;
     }
-    setOnce() {
-        return super.setOnce();
+    once() {
+        return super.once();
     }
 }
 exports.OrderedSubscribeObject = OrderedSubscribeObject;

package/src/outLib/Pipe.d.ts

@@ -1,20 +1,22 @@
-import { ICallback, IChainCallback, IErrorCallback, IListener, IPipeCase, IPipePayload, ISetObservableValue, ISetup, ISubscribe, ISubscriptionLike } from "./Types";
+import { ICallback, IChainCallback, IErrorCallback, IGroupSubscription, IListener, IPipeCase, IPipePayload, ISetObservableValue, ISetup, ISubscribe, ISubscriptionLike } from "./Types";
 import { SwitchCase } from "./AbstractSwitchCase";
 export declare abstract class Pipe<T> implements ISubscribe<T> {
     chain: IChainCallback[];
     flow: IPipePayload;
     abstract subscribe(listener: IListener<T> | ISetObservableValue, errorHandler?: IErrorCallback): ISubscriptionLike | undefined;
     private push;
-    setOnce(): ISubscribe<T>;
+    once(): ISubscribe<T>;
     unsubscribeBy(condition: ICallback<T>): ISetup<T>;
-    refine(condition: ICallback<T>): ISetup<T>;
-    pushRefiners(conditions: ICallback<any>[]): ISetup<T>;
-    switch(): PipeSwitchCase<T>;
-    then<K>(condition: ICallback<T>): ISetup<K>;
-    serialize(): ISetup<string>;
-    deserialize<K>(): ISetup<K>;
+    and(condition: ICallback<T>): ISetup<T>;
+    allOf(conditions: ICallback<any>[]): ISetup<T>;
+    choice(): PipeSwitchCase<T>;
+    map<K>(condition: ICallback<T>): ISetup<K>;
+    toJson(): ISetup<string>;
+    fromJson<K>(): ISetup<K>;
+    group(): IGroupSubscription<T>;
     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;
+    group(): IGroupSubscription<T>;
 }

package/src/outLib/Pipe.js

@@ -9,7 +9,7 @@ class Pipe {
         this.chain.push(callback);
         return this;
     }
-    setOnce() {
+    once() {
         return this.push((data) => {
             this.listener(data.payload);
             data.isUnsubscribe = true;
@@ -22,37 +22,40 @@ class Pipe {
                 data.isUnsubscribe = true;
         });
     }
-    refine(condition) {
+    and(condition) {
         return this.push((data) => condition(data.payload) && (data.isAvailable = true));
     }
-    pushRefiners(conditions) {
+    allOf(conditions) {
         if (!Array.isArray(conditions))
             return this;
         for (let i = 0; i < conditions.length; i++)
-            this.refine(conditions[i]);
+            this.and(conditions[i]);
         return this;
     }
-    switch() {
+    choice() {
         return new PipeSwitchCase(this);
     }
-    then(condition) {
+    map(condition) {
         return this.push((data) => {
             data.payload = condition(data.payload);
             data.isAvailable = true;
         });
     }
-    serialize() {
+    toJson() {
         return this.push((data) => {
             data.payload = JSON.stringify(data.payload);
             data.isAvailable = true;
         });
     }
-    deserialize() {
+    fromJson() {
         return this.push((data) => {
             data.payload = JSON.parse(data.payload);
             data.isAvailable = true;
         });
     }
+    group() {
+        return this;
+    }
     processChain(listener) {
         const chain = this.chain;
         const data = this.flow;
@@ -76,5 +79,8 @@ class PipeSwitchCase extends AbstractSwitchCase_1.SwitchCase {
     subscribe(listener, errorHandler) {
         return this.pipe.subscribe(listener, errorHandler);
     }
+    group() {
+        return this.pipe;
+    }
 }
 exports.PipeSwitchCase = PipeSwitchCase;

package/src/outLib/SubscribeObject.d.ts

@@ -1,4 +1,4 @@
-import { IErrorCallback, IListener, IObserver, ISubscribeGroup, ISubscribeObject, ISubscriptionLike } from "./Types";
+import { IErrorCallback, IGroupSubscription, IListener, IObserver, ISubscribeGroup, ISubscribeObject, ISubscriptionLike } from "./Types";
 import { Pipe } from "./Pipe";
 export declare class SubscribeObject<T> extends Pipe<T> implements ISubscribeObject<T> {
     observer: IObserver<T> | undefined;
@@ -7,8 +7,11 @@ export declare class SubscribeObject<T> extends Pipe<T> implements ISubscribeObj
     _order: number;
     paused: boolean;
     piped: boolean;
+    listeners?: IListener<T>[];
+    errorHandlers?: IErrorCallback[];
     constructor(observable?: IObserver<T>, isPipe?: boolean);
     subscribe(observer: ISubscribeGroup<T>, errorHandler?: IErrorCallback): ISubscriptionLike;
+    add(listener: IListener<T> | IListener<T>[], errorHandler?: IErrorCallback | IErrorCallback[]): IGroupSubscription<T>;
     unsubscribe(): void;
     send(value: T): void;
     resume(): void;

package/src/outLib/SubscribeObject.js

@@ -12,6 +12,8 @@ class SubscribeObject extends Pipe_1.Pipe {
     _order = 0;
     paused = false;
     piped = false;
+    listeners;
+    errorHandlers;
     constructor(observable, isPipe) {
         super();
         this.observer = observable;
@@ -22,6 +24,29 @@ class SubscribeObject extends Pipe_1.Pipe {
         errorHandler && (this.errorHandler = errorHandler);
         return this;
     }
+    add(listener, errorHandler) {
+        if (!this.listeners) {
+            this.listeners = [];
+            this.errorHandlers = [];
+        }
+        if (Array.isArray(listener)) {
+            for (let i = 0; i < listener.length; i++) {
+                this.listeners.push(listener[i]);
+                const handler = (errorHandler && Array.isArray(errorHandler))
+                    ? (errorHandler[i] ?? this.errorHandler)
+                    : (errorHandler || this.errorHandler);
+                this.errorHandlers.push(handler);
+            }
+        }
+        else {
+            this.listeners.push(listener);
+            const handler = (errorHandler && !Array.isArray(errorHandler))
+                ? errorHandler
+                : this.errorHandler;
+            this.errorHandlers.push(handler);
+        }
+        return this;
+    }
     unsubscribe() {
         if (!this.observer)
             return;
@@ -32,25 +57,70 @@ class SubscribeObject extends Pipe_1.Pipe {
     }
     send(value) {
         const listener = this.listener;
-        if (!listener) {
+        const hasGroupListeners = this.listeners && this.listeners.length > 0;
+        if (!listener && !hasGroupListeners) {
             this.unsubscribe();
             return;
         }
         if (!this.observer || this.paused)
             return;
         if (!this.piped) {
-            try {
-                listener(value);
+            if (listener) {
+                try {
+                    listener(value);
+                }
+                catch (err) {
+                    this.errorHandler(value, err);
+                }
             }
-            catch (err) {
-                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;
-            this.processChain(listener);
+            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);
+                    }
+                }
+            }
         }
         catch (err) {
             this.errorHandler(value, err);

package/src/outLib/Types.d.ts

@@ -14,16 +14,22 @@ export type IOrder = {
     order: number;
 };
 export type ISwitch<T> = {
-    switch(): PipeSwitchCase<T>;
+    choice(): PipeSwitchCase<T>;
 };
 export type IOrderedSwitch<T> = {
-    switch(): PipeSwitchCase<T>;
+    choice(): PipeSwitchCase<T>;
+};
+export type IGroup<T> = {
+    group(): IGroupSubscription<T>;
+};
+export type IOrderedGroup<T> = {
+    group(): IGroupSubscription<T>;
 };
 export type IOnce<T> = {
-    setOnce(): ISubscribe<T>;
+    once(): ISubscribe<T>;
 };
 export type IOrderedOnce<T> = {
-    setOnce(): IOrderedSubscribe<T>;
+    once(): IOrderedSubscribe<T>;
 };
 export type ISetObservableValue = {
     next(value: any): void;
@@ -31,8 +37,11 @@ export type ISetObservableValue = {
 export type ISubscriptionLike = {
     unsubscribe(): void;
 };
-export type ISetup<T> = IUnsubscribeByPositive<T> & IEmitByPositive<T> & IOnce<T> & ISwitch<T> & ITransform<T> & ISerialisation & ISubscribe<T>;
-export type IOrderedSetup<T> = IOrderedUnsubscribeByPositive<T> & IOrderedEmitByPositive<T> & IOrderedOnce<T> & IOrderedSwitch<T> & IOrderedTransform<T> & IOrderedSerialisation & IOrderedSubscribe<T>;
+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 ISubscribeObject<T> = ISubscriptionLike & IPause & IOrder & ISend<T> & ISetup<T>;
 export type ISubscribeCounter = {
     size(): number;
@@ -48,7 +57,10 @@ export type IObserver<T> = ISetObservableValue & ISubscriber<T> & IDestroy & ISu
     enable(): void;
 };
 export type IStream<T> = {
-    stream(value: T[]): void;
+    of(value: T[]): void;
+};
+export type IObjectStream<K extends string | number | symbol, V> = {
+    in(value: Record<K, V>): void;
 };
 export type IPause = {
     pause(): void;
@@ -82,26 +94,26 @@ export type IOrderedEmitByNegative<T> = {
     emitByNegative(condition: ICallback<T>): IOrderedSetup<T>;
 };
 export type IEmitByPositive<T> = {
-    refine(condition: ICallback<T>): ISetup<T>;
-    pushRefiners(conditions: ICallback<T>[]): ISetup<T>;
+    and(condition: ICallback<T>): ISetup<T>;
+    allOf(conditions: ICallback<T>[]): ISetup<T>;
 };
 export type ITransform<T> = {
-    then<K>(condition: ICallback<T>): ISetup<K>;
+    map<K>(condition: ICallback<T>): ISetup<K>;
 };
 export type ISerialisation = {
-    serialize(): ISetup<string>;
-    deserialize<K>(): ISetup<K>;
+    toJson(): ISetup<string>;
+    fromJson<K>(): ISetup<K>;
 };
 export type IOrderedEmitByPositive<T> = {
-    refine(condition: ICallback<any>): ISetup<T>;
-    pushRefiners(conditions: ICallback<any>[]): ISetup<T>;
+    and(condition: ICallback<any>): ISetup<T>;
+    allOf(conditions: ICallback<any>[]): ISetup<T>;
 };
 export type IOrderedTransform<T> = {
-    then<K>(condition: ICallback<T>): ISetup<K>;
+    map<K>(condition: ICallback<T>): ISetup<K>;
 };
 export type IOrderedSerialisation = {
-    serialize(): ISetup<string>;
-    deserialize<K>(): ISetup<K>;
+    toJson(): ISetup<string>;
+    fromJson<K>(): ISetup<K>;
 };
 export type IEmitMatchCondition<T> = {
     emitMatch(condition: ICallback<any>): ISetup<T>;
@@ -133,8 +145,9 @@ export type IPipePayload = {
 };
 export type IChainCallback = (data: IPipePayload) => void;
 export type IPipeCase<T> = ISubscribe<T> & {
-    case(condition: ICallback<any>): IPipeCase<T> & ISubscribe<T>;
-    pushCases(conditions: ICallback<any>[]): IPipeCase<T> & ISubscribe<T>;
+    or(condition: ICallback<any>): IPipeCase<T> & ISubscribe<T>;
+    anyOf(conditions: ICallback<any>[]): IPipeCase<T> & ISubscribe<T>;
+    group(): IGroupSubscription<T>;
 };
 export type ICombinedSubscriber<T> = IListener<T> | ISetObservableValue;
 export type ISubscribeGroup<T> = ICombinedSubscriber<T> | ICombinedSubscriber<T>[];
@@ -143,15 +156,15 @@ export type IAddFilter<T> = {
 };
 export type IFilterSetup<T> = IFilter<T> & IFilterSwitch<T>;
 export type IFilter<T> = {
-    filter(condition: ICallback<any>): IFilterSetup<T>;
-    pushFilters(conditions: ICallback<any>[]): IFilterSetup<T>;
+    and(condition: ICallback<any>): IFilterSetup<T>;
+    allOf(conditions: ICallback<any>[]): IFilterSetup<T>;
 };
 export type IFilterSwitch<T> = {
-    switch(): FilterSwitchCase<T>;
+    choice(): FilterSwitchCase<T>;
 };
 export type IFilterCase<T> = {
-    case(condition: ICallback<any>): IFilterCase<T>;
-    pushCases(conditions: ICallback<any>[]): IFilterCase<T>;
+    or(condition: ICallback<any>): IFilterCase<T>;
+    anyOf(conditions: ICallback<any>[]): IFilterCase<T>;
 };
 export type IFilterPayload = {
     isBreak: boolean;

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.