rask-ui 0.2.1 → 0.2.3

package/dist/observation.d.ts

@@ -5,11 +5,10 @@ export declare class Signal {
     notify(): void;
 }
 export declare class Observer {
-    private _isDisposed;
+    isDisposed: boolean;
     private signalDisposers;
     private clearSignals;
     private onNotify;
-    private isQueued;
     constructor(onNotify: () => void);
     subscribeSignal(signal: Signal): void;
     observe(): () => void;

package/dist/observation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"observation.d.ts","sourceRoot":"","sources":["../src/observation.ts"],"names":[],"mappings":"AAEA,wBAAgB,kBAAkB,aAEjC;AAED,qBAAa,MAAM;IACjB,OAAO,CAAC,WAAW,CAAyB;IAC5C,SAAS,CAAC,EAAE,EAAE,MAAM,IAAI;IAOxB,MAAM;CAGP;AAED,qBAAa,QAAQ;IACnB,OAAO,CAAC,WAAW,CAAS;IAC5B,OAAO,CAAC,eAAe,CAAyB;IAChD,OAAO,CAAC,YAAY;IAIpB,OAAO,CAAC,QAAQ,CAAa;IAC7B,OAAO,CAAC,QAAQ,CAAS;gBACb,QAAQ,EAAE,MAAM,IAAI;IAmBhC,eAAe,CAAC,MAAM,EAAE,MAAM;IAG9B,OAAO;IAOP,OAAO;CAIR"}
+{"version":3,"file":"observation.d.ts","sourceRoot":"","sources":["../src/observation.ts"],"names":[],"mappings":"AAEA,wBAAgB,kBAAkB,aAEjC;AAED,qBAAa,MAAM;IACjB,OAAO,CAAC,WAAW,CAAyB;IAC5C,SAAS,CAAC,EAAE,EAAE,MAAM,IAAI;IAOxB,MAAM;CAGP;AAED,qBAAa,QAAQ;IACnB,UAAU,UAAS;IACnB,OAAO,CAAC,eAAe,CAAyB;IAChD,OAAO,CAAC,YAAY;IAIpB,OAAO,CAAC,QAAQ,CAAa;gBACjB,QAAQ,EAAE,MAAM,IAAI;IAGhC,eAAe,CAAC,MAAM,EAAE,MAAM;IAG9B,OAAO;IAOP,OAAO;CAIR"}

package/dist/observation.js

@@ -15,28 +15,15 @@ export class Signal {
     }
 }
 export class Observer {
-    _isDisposed = false;
+    isDisposed = false;
     signalDisposers = new Set();
     clearSignals() {
         this.signalDisposers.forEach((dispose) => dispose());
         this.signalDisposers.clear();
     }
     onNotify;
-    isQueued = false;
     constructor(onNotify) {
-        this.onNotify = () => {
-            if (this.isQueued) {
-                return;
-            }
-            queueMicrotask(() => {
-                this.isQueued = false;
-                if (this._isDisposed) {
-                    return;
-                }
-                onNotify();
-            });
-            this.isQueued = true;
-        };
+        this.onNotify = onNotify;
     }
     subscribeSignal(signal) {
         this.signalDisposers.add(signal.subscribe(this.onNotify));
@@ -50,6 +37,6 @@ export class Observer {
     }
     dispose() {
         this.clearSignals();
-        this._isDisposed = true;
+        this.isDisposed = true;
     }
 }

package/dist/observation.test.js

@@ -1,150 +1,113 @@
-import { describe, it, expect, vi } from 'vitest';
-import { Signal, Observer, getCurrentObserver } from './observation';
-describe('Signal', () => {
-    it('should allow subscribing to notifications', () => {
-        const signal = new Signal();
-        const callback = vi.fn();
-        signal.subscribe(callback);
-        signal.notify();
-        expect(callback).toHaveBeenCalledTimes(1);
-    });
-    it('should return a disposer function', () => {
-        const signal = new Signal();
-        const callback = vi.fn();
-        const dispose = signal.subscribe(callback);
-        dispose();
-        signal.notify();
-        expect(callback).not.toHaveBeenCalled();
-    });
-    it('should handle multiple subscribers', () => {
-        const signal = new Signal();
-        const callback1 = vi.fn();
-        const callback2 = vi.fn();
-        signal.subscribe(callback1);
-        signal.subscribe(callback2);
-        signal.notify();
-        expect(callback1).toHaveBeenCalledTimes(1);
-        expect(callback2).toHaveBeenCalledTimes(1);
-    });
-    it('should allow unsubscribing individual callbacks', () => {
-        const signal = new Signal();
-        const callback1 = vi.fn();
-        const callback2 = vi.fn();
-        const dispose1 = signal.subscribe(callback1);
-        signal.subscribe(callback2);
-        dispose1();
-        signal.notify();
-        expect(callback1).not.toHaveBeenCalled();
-        expect(callback2).toHaveBeenCalledTimes(1);
-    });
+import { describe, it, expect, vi } from "vitest";
+import { Signal, Observer, getCurrentObserver } from "./observation";
+describe("Signal", () => {
+  it("should allow subscribing to notifications", () => {
+    const signal = new Signal();
+    const callback = vi.fn();
+    signal.subscribe(callback);
+    signal.notify();
+    expect(callback).toHaveBeenCalledTimes(1);
+  });
+  it("should return a disposer function", () => {
+    const signal = new Signal();
+    const callback = vi.fn();
+    const dispose = signal.subscribe(callback);
+    dispose();
+    signal.notify();
+    expect(callback).not.toHaveBeenCalled();
+  });
+  it("should handle multiple subscribers", () => {
+    const signal = new Signal();
+    const callback1 = vi.fn();
+    const callback2 = vi.fn();
+    signal.subscribe(callback1);
+    signal.subscribe(callback2);
+    signal.notify();
+    expect(callback1).toHaveBeenCalledTimes(1);
+    expect(callback2).toHaveBeenCalledTimes(1);
+  });
+  it("should allow unsubscribing individual callbacks", () => {
+    const signal = new Signal();
+    const callback1 = vi.fn();
+    const callback2 = vi.fn();
+    const dispose1 = signal.subscribe(callback1);
+    signal.subscribe(callback2);
+    dispose1();
+    signal.notify();
+    expect(callback1).not.toHaveBeenCalled();
+    expect(callback2).toHaveBeenCalledTimes(1);
+  });
 });
-describe('Observer', () => {
-    it('should queue notifications in microtasks', async () => {
-        let callCount = 0;
-        const observer = new Observer(() => {
-            callCount++;
-        });
-        const signal = new Signal();
-        const dispose = observer.observe();
-        observer.subscribeSignal(signal);
-        dispose();
-        // Trigger multiple notifications
-        signal.notify();
-        signal.notify();
-        signal.notify();
-        // Should not be called synchronously
-        expect(callCount).toBe(0);
-        // Wait for microtask
-        await new Promise((resolve) => queueMicrotask(() => resolve()));
-        // Should be called only once due to queuing
-        expect(callCount).toBe(1);
-    });
-    it('should track signals during observation', () => {
-        const callback = vi.fn();
-        const observer = new Observer(callback);
-        const signal = new Signal();
-        const dispose = observer.observe();
-        observer.subscribeSignal(signal);
-        dispose();
-        signal.notify();
-        return new Promise((resolve) => {
-            queueMicrotask(() => {
-                expect(callback).toHaveBeenCalledTimes(1);
-                resolve(undefined);
-            });
-        });
-    });
-    it('should clear signals when observing again', async () => {
-        let callCount = 0;
-        const observer = new Observer(() => {
-            callCount++;
-        });
-        const signal1 = new Signal();
-        const signal2 = new Signal();
-        // First observation
-        let dispose = observer.observe();
-        observer.subscribeSignal(signal1);
-        dispose();
-        // Second observation - should clear previous signals
-        dispose = observer.observe();
-        observer.subscribeSignal(signal2);
-        dispose();
-        // Notify first signal - should not trigger observer
-        signal1.notify();
-        await new Promise((resolve) => queueMicrotask(() => resolve()));
-        expect(callCount).toBe(0);
-        // Notify second signal - should trigger observer
-        signal2.notify();
-        await new Promise((resolve) => queueMicrotask(() => resolve()));
-        expect(callCount).toBe(1);
-    });
-    it('should dispose of all signal subscriptions', async () => {
-        const callback = vi.fn();
-        const observer = new Observer(callback);
-        const signal = new Signal();
-        const dispose = observer.observe();
-        observer.subscribeSignal(signal);
-        dispose();
-        observer.dispose();
-        signal.notify();
-        await new Promise((resolve) => queueMicrotask(() => resolve()));
-        expect(callback).not.toHaveBeenCalled();
-    });
-    it('should set current observer during observation', () => {
-        const observer = new Observer(() => { });
-        expect(getCurrentObserver()).toBeUndefined();
-        const dispose = observer.observe();
-        expect(getCurrentObserver()).toBe(observer);
-        dispose();
-        expect(getCurrentObserver()).toBeUndefined();
-    });
-    it('should handle nested observations with stack', () => {
-        const observer1 = new Observer(() => { });
-        const observer2 = new Observer(() => { });
-        const dispose1 = observer1.observe();
-        expect(getCurrentObserver()).toBe(observer1);
-        const dispose2 = observer2.observe();
-        expect(getCurrentObserver()).toBe(observer2);
-        dispose2();
-        expect(getCurrentObserver()).toBe(observer1);
-        dispose1();
-        expect(getCurrentObserver()).toBeUndefined();
+describe("Observer", () => {
+  it("should track signals during observation", () => {
+    const callback = vi.fn();
+    const observer = new Observer(callback);
+    const signal = new Signal();
+    const dispose = observer.observe();
+    observer.subscribeSignal(signal);
+    dispose();
+    signal.notify();
+    return new Promise((resolve) => {
+      queueMicrotask(() => {
+        expect(callback).toHaveBeenCalledTimes(1);
+        resolve(undefined);
+      });
     });
-    it('should prevent duplicate notifications while queued', async () => {
-        let callCount = 0;
-        const observer = new Observer(() => {
-            callCount++;
-        });
-        const signal = new Signal();
-        const dispose = observer.observe();
-        observer.subscribeSignal(signal);
-        dispose();
-        // Rapid-fire notifications
-        for (let i = 0; i < 100; i++) {
-            signal.notify();
-        }
-        await new Promise((resolve) => queueMicrotask(() => resolve()));
-        // Should only be called once
-        expect(callCount).toBe(1);
+  });
+  it("should clear signals when observing again", async () => {
+    let callCount = 0;
+    const observer = new Observer(() => {
+      callCount++;
     });
+    const signal1 = new Signal();
+    const signal2 = new Signal();
+    // First observation
+    let dispose = observer.observe();
+    observer.subscribeSignal(signal1);
+    dispose();
+    // Second observation - should clear previous signals
+    dispose = observer.observe();
+    observer.subscribeSignal(signal2);
+    dispose();
+    // Notify first signal - should not trigger observer
+    signal1.notify();
+    await new Promise((resolve) => queueMicrotask(() => resolve()));
+    expect(callCount).toBe(0);
+    // Notify second signal - should trigger observer
+    signal2.notify();
+    await new Promise((resolve) => queueMicrotask(() => resolve()));
+    expect(callCount).toBe(1);
+  });
+  it("should dispose of all signal subscriptions", async () => {
+    const callback = vi.fn();
+    const observer = new Observer(callback);
+    const signal = new Signal();
+    const dispose = observer.observe();
+    observer.subscribeSignal(signal);
+    dispose();
+    observer.dispose();
+    signal.notify();
+    await new Promise((resolve) => queueMicrotask(() => resolve()));
+    expect(callback).not.toHaveBeenCalled();
+  });
+  it("should set current observer during observation", () => {
+    const observer = new Observer(() => {});
+    expect(getCurrentObserver()).toBeUndefined();
+    const dispose = observer.observe();
+    expect(getCurrentObserver()).toBe(observer);
+    dispose();
+    expect(getCurrentObserver()).toBeUndefined();
+  });
+  it("should handle nested observations with stack", () => {
+    const observer1 = new Observer(() => {});
+    const observer2 = new Observer(() => {});
+    const dispose1 = observer1.observe();
+    expect(getCurrentObserver()).toBe(observer1);
+    const dispose2 = observer2.observe();
+    expect(getCurrentObserver()).toBe(observer2);
+    dispose2();
+    expect(getCurrentObserver()).toBe(observer1);
+    dispose1();
+    expect(getCurrentObserver()).toBeUndefined();
+  });
 });

package/dist/tests/observation.test.js

@@ -39,26 +39,6 @@ describe("Signal", () => {
     });
 });
 describe("Observer", () => {
-    it("should queue notifications in microtasks", async () => {
-        let callCount = 0;
-        const observer = new Observer(() => {
-            callCount++;
-        });
-        const signal = new Signal();
-        const dispose = observer.observe();
-        observer.subscribeSignal(signal);
-        dispose();
-        // Trigger multiple notifications
-        signal.notify();
-        signal.notify();
-        signal.notify();
-        // Should not be called synchronously
-        expect(callCount).toBe(0);
-        // Wait for microtask
-        await new Promise((resolve) => queueMicrotask(() => resolve()));
-        // Should be called only once due to queuing
-        expect(callCount).toBe(1);
-    });
     it("should track signals during observation", () => {
         const callback = vi.fn();
         const observer = new Observer(callback);
@@ -130,21 +110,4 @@ describe("Observer", () => {
         dispose1();
         expect(getCurrentObserver()).toBeUndefined();
     });
-    it("should prevent duplicate notifications while queued", async () => {
-        let callCount = 0;
-        const observer = new Observer(() => {
-            callCount++;
-        });
-        const signal = new Signal();
-        const dispose = observer.observe();
-        observer.subscribeSignal(signal);
-        dispose();
-        // Rapid-fire notifications
-        for (let i = 0; i < 100; i++) {
-            signal.notify();
-        }
-        await new Promise((resolve) => queueMicrotask(() => resolve()));
-        // Should only be called once
-        expect(callCount).toBe(1);
-    });
 });