evg_observable 3.0.1 → 3.1.1

package/scripts/claude-pr-prep.sh

@@ -0,0 +1,73 @@
+#!/bin/bash
+# scripts/claude-pr-prep.sh
+# Run tests and generate a PR description for the current branch.
+#
+# Usage:
+#   ./scripts/claude-pr-prep.sh          # auto-detect base branch
+#   ./scripts/claude-pr-prep.sh dev      # explicit base branch
+
+set -e
+
+# Determine base branch
+if [ -n "$1" ]; then
+  BASE="$1"
+else
+  for branch in dev stage main master; do
+    if git rev-parse --verify "$branch" >/dev/null 2>&1; then
+      BASE="$branch"
+      break
+    fi
+  done
+fi
+
+if [ -z "$BASE" ]; then
+  echo "Error: no base branch found (tried: dev, stage, main, master)"
+  exit 1
+fi
+
+CURRENT=$(git branch --show-current)
+
+echo "Preparing branch '$CURRENT' for PR into '$BASE'..."
+echo ""
+
+# Run tests
+echo "=== Running tests ==="
+TEST_OUTPUT=$(npm test 2>&1) || true
+echo "$TEST_OUTPUT" | tail -5
+echo ""
+
+# Get commit log
+COMMITS=$(git log "$BASE".."$CURRENT" --oneline 2>/dev/null)
+
+if [ -z "$COMMITS" ]; then
+  echo "No commits between '$CURRENT' and '$BASE'. Nothing to prepare."
+  exit 0
+fi
+
+# Generate PR description
+echo "=== Generating PR description ==="
+echo ""
+
+claude -p "Generate a pull request description for the EVG Observable library.
+
+Branch: $CURRENT -> $BASE
+
+Commits:
+$COMMITS
+
+Test results (last 5 lines):
+$(echo "$TEST_OUTPUT" | tail -5)
+
+Write a PR description in this format:
+## Summary
+<2-4 bullet points describing what changed and why>
+
+## Changes
+<list of key changes grouped by category>
+
+## Test plan
+<what was tested, test results summary>
+
+Be concise and specific to this library." \
+  --print \
+  --max-turns 3

package/scripts/claude-review-files.sh

@@ -0,0 +1,61 @@
+#!/bin/bash
+# scripts/claude-review-files.sh
+# Review current branch changes against base branch using Claude headless mode.
+# Checks: correctness, types, naming, resource cleanup, regression risk.
+#
+# Usage:
+#   ./scripts/claude-review-files.sh          # auto-detect base branch
+#   ./scripts/claude-review-files.sh dev      # explicit base branch
+
+set -e
+
+# Determine base branch
+if [ -n "$1" ]; then
+  BASE="$1"
+else
+  for branch in dev stage main master; do
+    if git rev-parse --verify "$branch" >/dev/null 2>&1; then
+      BASE="$branch"
+      break
+    fi
+  done
+fi
+
+if [ -z "$BASE" ]; then
+  echo "Error: no base branch found (tried: dev, stage, main, master)"
+  exit 1
+fi
+
+CURRENT=$(git branch --show-current)
+DIFF=$(git diff "$BASE"..."$CURRENT" 2>/dev/null)
+
+if [ -z "$DIFF" ]; then
+  echo "No changes between '$CURRENT' and '$BASE'. Nothing to review."
+  exit 0
+fi
+
+echo "Reviewing branch '$CURRENT' against '$BASE'..."
+echo ""
+
+claude -p "You are reviewing a code diff for the EVG Observable library.
+
+Base branch: $BASE
+Current branch: $CURRENT
+
+Here is the diff:
+
+$DIFF
+
+Review this diff. For each changed file evaluate:
+- **Correctness**: Does the code do what it should?
+- **Edge cases**: Boundary conditions handled? (null, undefined, empty arrays)
+- **Type safety**: Proper TypeScript types, no unnecessary \`any\`
+- **Naming**: PascalCase classes, camelCase methods, \`I\` prefix for interfaces, \`\$\` suffix for observables
+- **Style**: 2-space indent, JSDoc on public methods
+- **Resource cleanup**: Are subscriptions cleaned up? destroy()/unsubscribe() where needed?
+- **Regression risk**: Could this break existing behavior?
+
+Output a table of issues found with severity (critical/major/minor), file, line, and description.
+If no issues found, say so. Be specific and concise." \
+  --print \
+  --max-turns 5

package/src/outLib/CoreTypes.d.ts

@@ -0,0 +1,42 @@
+export type ICallback<T> = (value?: T) => any;
+export type IErrorCallback = (errorData: any, errorMessage: any) => void;
+export type IListener<T> = ICallback<T>;
+export type IDestroy = {
+    destroy(): void;
+    isDestroyed: boolean;
+};
+export type IOrder = {
+    order: number;
+};
+export type ISetObservableValue = {
+    next(value: any): void;
+};
+export type IPause = {
+    pause(): void;
+    resume(): void;
+};
+export type ISubscribeCounter = {
+    size(): number;
+};
+export type IStream<T> = {
+    of(value: T[]): void;
+};
+export type ISend<T> = {
+    send(value: T): void;
+};
+export type IChainContainer = {
+    chain: any[];
+};
+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;
+export type ICombinedSubscriber<T> = IListener<T> | ISetObservableValue;
+export type ISubscribeGroup<T> = ICombinedSubscriber<T> | ICombinedSubscriber<T>[];

package/src/outLib/CoreTypes.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/src/outLib/FilterCollection.js

@@ -15,7 +15,8 @@ class FilterCollection {
         return this;
     }
     and(condition) {
-        return this.push((data) => condition(data.payload) && (data.isAvailable = true));
+        return this.push((data) => { if (condition(data.payload))
+            data.isAvailable = true; });
     }
     allOf(conditions) {
         if (!Array.isArray(conditions))

package/src/outLib/FilterTypes.d.ts

@@ -0,0 +1,27 @@
+import { FilterSwitchCase } from "./FilterCollection";
+import { ICallback } from "./CoreTypes";
+export type IFilterPayload = {
+    isBreak: boolean;
+    isAvailable: boolean;
+    payload: any;
+};
+export type IFilterChainCallback = (data: IFilterPayload) => void;
+export type IFilterResponse = {
+    isOK: boolean;
+    payload: any;
+};
+export type IFilter<T> = {
+    and(condition: ICallback<any>): IFilterSetup<T>;
+    allOf(conditions: ICallback<any>[]): IFilterSetup<T>;
+};
+export type IFilterSetup<T> = IFilter<T> & IFilterSwitch<T>;
+export type IFilterSwitch<T> = {
+    choice(): FilterSwitchCase<T>;
+};
+export type IFilterCase<T> = {
+    or(condition: ICallback<any>): IFilterCase<T>;
+    anyOf(conditions: ICallback<any>[]): IFilterCase<T>;
+};
+export type IAddFilter<T> = {
+    addFilter(): IFilterSetup<T>;
+};

package/src/outLib/FilterTypes.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -8,7 +8,7 @@ export declare class Observable<T> implements IObserver<T>, IStream<T>, IAddFilt
     protected process: boolean;
     protected trash: ISubscriptionLike[];
     protected filters: FilterCollection<T>;
-    protected _value: T;
+    protected _value: T | null;
     constructor(value: T);
     addFilter(errorHandler?: IErrorCallback): IFilterSetup<T>;
     disable(): void;
@@ -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

@@ -45,6 +45,12 @@ class Observable {
         for (let i = 0; i < len; i++)
             subs[i].send(value);
         this.process = false;
+        if (this.killed) {
+            this.clearDebounceTimers();
+            this._value = null;
+            this.subs.length = 0;
+            return;
+        }
         this.trash.length && this.clearTrash();
     }
     of(values) {
@@ -86,26 +92,29 @@ class Observable {
             return;
         this.killed = true;
         if (!this.process) {
+            this.clearDebounceTimers();
             this._value = null;
             this.subs.length = 0;
-            return;
         }
-        Promise.resolve().then(() => {
-            this._value = null;
-            this.subs.length = 0;
-        });
     }
     unsubscribeAll() {
         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;
@@ -23,7 +59,8 @@ class Pipe {
         });
     }
     and(condition) {
-        return this.push((data) => condition(data.payload) && (data.isAvailable = true));
+        return this.push((data) => { if (condition(data.payload))
+            data.isAvailable = true; });
     }
     allOf(conditions) {
         if (!Array.isArray(conditions))
@@ -41,6 +78,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 +147,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/PipeTypes.d.ts

@@ -0,0 +1,77 @@
+import { PipeSwitchCase } from "./Pipe";
+import { ICallback, IPause, IOrder, ISend } from "./CoreTypes";
+import { ISubscribe, IOrderedSubscribe, ISubscriptionLike, IGroupSubscription } from "./SubscriptionTypes";
+export type ISwitch<T> = {
+    choice(): PipeSwitchCase<T>;
+};
+export type IGroup<T> = {
+    group(): IGroupSubscription<T>;
+};
+export type IOrderedGroup<T> = {
+    group(): IGroupSubscription<T>;
+};
+export type IOnce<T> = {
+    once(): ISubscribe<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 IUnsubscribeByPositive<T> = {
+    unsubscribeBy(condition: ICallback<T>): ISetup<T>;
+};
+export type IOrderedUnsubscribeByPositive<T> = {
+    unsubscribeBy(condition: ICallback<T>): ISetup<T>;
+};
+export type IEmitByPositive<T> = {
+    and(condition: ICallback<T>): ISetup<T>;
+    allOf(conditions: ICallback<T>[]): ISetup<T>;
+};
+export type IOrderedEmitByPositive<T> = {
+    and(condition: ICallback<any>): ISetup<T>;
+    allOf(conditions: ICallback<any>[]): ISetup<T>;
+};
+export type ITransform<T> = {
+    map<K>(condition: ICallback<T>): ISetup<K>;
+};
+export type IThrottle<T> = {
+    throttle(ms: number): ISetup<T>;
+};
+export type IDebounce<T> = {
+    debounce(ms: number): ISetup<T>;
+};
+export type IDistinctUntilChanged<T> = {
+    distinctUntilChanged(comparator?: (previous: T, current: T) => boolean): ISetup<T>;
+};
+export type ITap<T> = {
+    tap(fn: ICallback<T>): ISetup<T>;
+};
+export type ISerialisation = {
+    toJson(): ISetup<string>;
+    fromJson<K>(): ISetup<K>;
+};
+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> & ISwitch<T> & ITransform<T> & IThrottle<T> & IDebounce<T> & IDistinctUntilChanged<T> & ITap<T> & ISerialisation & IOrderedGroup<T> & IOrderedSubscribe<T>;
+export type ISubscribeObject<T> = ISubscriptionLike & IPause & IOrder & ISend<T> & ISetup<T>;
+export type IPipeCase<T> = ISubscribe<T> & {
+    or(condition: ICallback<any>): IPipeCase<T> & ISubscribe<T>;
+    anyOf(conditions: ICallback<any>[]): IPipeCase<T> & ISubscribe<T>;
+    group(): IGroupSubscription<T>;
+};

package/src/outLib/PipeTypes.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });