rask-ui 0.21.0 → 0.22.0

package/dist/{tests/createView.test.js → createView.test.js}

@@ -1,9 +1,9 @@
-import { describe, it, expect } from "vitest";
-import { createView } from "../createView";
-import { createState } from "../createState";
-import { Observer } from "../observation";
-describe("createView", () => {
-    it("should merge two plain objects", () => {
+import { describe, it, expect } from 'vitest';
+import { createView } from './createView';
+import { createState } from './createState';
+import { Observer } from './observation';
+describe('createView', () => {
+    it('should merge two plain objects', () => {
         const a = { x: 1, y: 2 };
         const b = { z: 3 };
         const view = createView(a, b);
@@ -11,7 +11,7 @@ describe("createView", () => {
         expect(view.y).toBe(2);
         expect(view.z).toBe(3);
     });
-    it("should allow later arguments to override earlier ones", () => {
+    it('should allow later arguments to override earlier ones', () => {
         const a = { x: 1, y: 2 };
         const b = { y: 3, z: 4 };
         const view = createView(a, b);
@@ -19,7 +19,7 @@ describe("createView", () => {
         expect(view.y).toBe(3); // b.y overrides a.y
         expect(view.z).toBe(4);
     });
-    it("should maintain reactivity with reactive objects", async () => {
+    it('should maintain reactivity with reactive objects', async () => {
         const state = createState({ count: 0 });
         const view = createView(state);
         let renderCount = 0;
@@ -42,7 +42,7 @@ describe("createView", () => {
             });
         });
     });
-    it("should merge reactive and plain objects while maintaining reactivity", () => {
+    it('should merge reactive and plain objects while maintaining reactivity', () => {
         const state = createState({ count: 0 });
         const helpers = {
             increment() {
@@ -54,36 +54,36 @@ describe("createView", () => {
         };
         const view = createView(state, helpers);
         expect(view.count).toBe(0);
-        expect(typeof view.increment).toBe("function");
-        expect(typeof view.decrement).toBe("function");
+        expect(typeof view.increment).toBe('function');
+        expect(typeof view.decrement).toBe('function');
         view.increment();
         expect(view.count).toBe(1);
         view.decrement();
         expect(view.count).toBe(0);
     });
-    it("should merge multiple reactive objects", () => {
+    it('should merge multiple reactive objects', () => {
         const state1 = createState({ count: 0 });
-        const state2 = createState({ name: "Alice" });
+        const state2 = createState({ name: 'Alice' });
         const state3 = createState({ age: 25 });
         const view = createView(state1, state2, state3);
         expect(view.count).toBe(0);
-        expect(view.name).toBe("Alice");
+        expect(view.name).toBe('Alice');
         expect(view.age).toBe(25);
         state1.count = 10;
-        state2.name = "Bob";
+        state2.name = 'Bob';
         state3.age = 30;
         expect(view.count).toBe(10);
-        expect(view.name).toBe("Bob");
+        expect(view.name).toBe('Bob');
         expect(view.age).toBe(30);
     });
-    it("should reflect changes in source objects", () => {
+    it('should reflect changes in source objects', () => {
         const source = { x: 1 };
         const view = createView(source);
         expect(view.x).toBe(1);
         source.x = 2;
         expect(view.x).toBe(2);
     });
-    it("should handle property override order correctly", () => {
+    it('should handle property override order correctly', () => {
         const a = { x: 1, y: 2, z: 3 };
         const b = { y: 20 };
         const c = { z: 30 };
@@ -92,9 +92,9 @@ describe("createView", () => {
         expect(view.y).toBe(20); // From b (overrides a)
         expect(view.z).toBe(30); // From c (overrides a)
     });
-    it("should only include enumerable properties", () => {
+    it('should only include enumerable properties', () => {
         const obj = { x: 1 };
-        Object.defineProperty(obj, "hidden", {
+        Object.defineProperty(obj, 'hidden', {
             value: 42,
             enumerable: false,
         });
@@ -102,15 +102,15 @@ describe("createView", () => {
         expect(view.x).toBe(1);
         expect(view.hidden).toBeUndefined();
     });
-    it("should handle symbol keys", () => {
-        const sym = Symbol("test");
-        const obj = { x: 1, [sym]: "symbol value" };
+    it('should handle symbol keys', () => {
+        const sym = Symbol('test');
+        const obj = { x: 1, [sym]: 'symbol value' };
         const view = createView(obj);
         expect(view.x).toBe(1);
-        expect(view[sym]).toBe("symbol value");
+        expect(view[sym]).toBe('symbol value');
     });
-    it("should track dependencies for each property independently", async () => {
-        const state = createState({ count: 0, name: "Alice" });
+    it('should track dependencies for each property independently', async () => {
+        const state = createState({ count: 0, name: 'Alice' });
         const view = createView(state);
         let countRenderCount = 0;
         let nameRenderCount = 0;
@@ -131,7 +131,7 @@ describe("createView", () => {
             });
         });
         // Change name - should NOT trigger (not tracked)
-        state.name = "Bob";
+        state.name = 'Bob';
         await new Promise((resolve) => {
             queueMicrotask(() => {
                 expect(countRenderCount).toBe(1); // Still 1
@@ -147,7 +147,7 @@ describe("createView", () => {
         dispose2();
         expect(nameRenderCount).toBe(0);
         // Change name - should trigger name observer
-        state.name = "Charlie";
+        state.name = 'Charlie';
         await new Promise((resolve) => {
             queueMicrotask(() => {
                 expect(nameRenderCount).toBe(1);
@@ -155,25 +155,25 @@ describe("createView", () => {
             });
         });
     });
-    it("should return the same value type as source", () => {
+    it('should return the same value type as source', () => {
         const obj = { nums: [1, 2, 3], nested: { x: 1 } };
         const view = createView(obj);
         expect(Array.isArray(view.nums)).toBe(true);
         expect(view.nums).toEqual([1, 2, 3]);
-        expect(typeof view.nested).toBe("object");
+        expect(typeof view.nested).toBe('object');
         expect(view.nested.x).toBe(1);
     });
-    it("should handle empty merge", () => {
+    it('should handle empty merge', () => {
         const view = createView({});
         expect(Object.keys(view).length).toBe(0);
     });
-    it("should merge single object", () => {
+    it('should merge single object', () => {
         const obj = { x: 1, y: 2 };
         const view = createView(obj);
         expect(view.x).toBe(1);
         expect(view.y).toBe(2);
     });
-    it("should maintain function context", () => {
+    it('should maintain function context', () => {
         const state = createState({ count: 0 });
         const methods = {
             increment() {
@@ -186,18 +186,18 @@ describe("createView", () => {
         expect(view.count).toBe(1);
         expect(state.count).toBe(1);
     });
-    it("should work with reactive state and computed-like patterns", () => {
-        const state = createState({ firstName: "John", lastName: "Doe" });
+    it('should work with reactive state and computed-like patterns', () => {
+        const state = createState({ firstName: 'John', lastName: 'Doe' });
         const computed = {
             get fullName() {
                 return `${state.firstName} ${state.lastName}`;
             },
         };
         const view = createView(state, computed);
-        expect(view.firstName).toBe("John");
-        expect(view.lastName).toBe("Doe");
-        expect(view.fullName).toBe("John Doe");
-        state.firstName = "Jane";
-        expect(view.fullName).toBe("Jane Doe");
+        expect(view.firstName).toBe('John');
+        expect(view.lastName).toBe('Doe');
+        expect(view.fullName).toBe('John Doe');
+        state.firstName = 'Jane';
+        expect(view.fullName).toBe('Jane Doe');
     });
 });

package/dist/error.d.ts

@@ -1,5 +1,16 @@
-export declare const CatchErrorContext: import("./createContext").Context<(error: unknown) => void>;
-export declare function useCatchError(): {
+import { Component, VNode } from "inferno";
+export declare class ErrorBoundary extends Component<{
+    children: any;
+    error: (error: unknown) => VNode;
+}, {
     error: unknown;
-};
+}> {
+    getChildContext(): {
+        notifyError: (error: unknown) => void;
+    };
+    state: {
+        error: null;
+    };
+    render(): any;
+}
 //# sourceMappingURL=error.d.ts.map

package/dist/error.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"error.d.ts","sourceRoot":"","sources":["../src/error.tsx"],"names":[],"mappings":"AAIA,eAAO,MAAM,iBAAiB,4CAAyB,OAAO,KAAK,IAAI,CAAG,CAAC;AAE3E,wBAAgB,aAAa;WAQK,OAAO;EAOxC"}
+{"version":3,"file":"error.d.ts","sourceRoot":"","sources":["../src/error.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAE3C,qBAAa,aAAc,SAAQ,SAAS,CAC1C;IAAE,QAAQ,EAAE,GAAG,CAAC;IAAC,KAAK,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,KAAK,CAAA;CAAE,EACnD;IAAE,KAAK,EAAE,OAAO,CAAA;CAAE,CACnB;IACC,eAAe;6BAEU,OAAO;;IAKhC,KAAK;;MAAmB;IAExB,MAAM;CAOP"}

package/dist/error.js

@@ -1,16 +1,17 @@
-import { useState } from "./useState";
-import { createContext, useInjectContext } from "./createContext";
-import { getCurrentComponent } from "./component";
-export const CatchErrorContext = createContext();
-export function useCatchError() {
-    const currentComponent = getCurrentComponent();
-    if (!currentComponent || currentComponent.isRendering) {
-        throw new Error("Only use the useCatchError hook in setup");
+import { Component } from "inferno";
+export class ErrorBoundary extends Component {
+    getChildContext() {
+        return {
+            notifyError: (error) => {
+                this.setState({ error });
+            },
+        };
+    }
+    state = { error: null };
+    render() {
+        if (this.state.error) {
+            return this.props.error(this.state.error);
+        }
+        return this.props.children;
     }
-    const inject = useInjectContext(CatchErrorContext);
-    const state = useState({
-        error: null,
-    });
-    inject((error) => (state.error = error));
-    return state;
 }

package/dist/jsx.d.ts

@@ -1,11 +1,257 @@
 // JSX type definitions
-// Re-export Inferno's comprehensive JSX types
-import 'inferno';
-
-// Re-export useful Inferno types for convenience
-export type {
-  InfernoNode,
-  InfernoChild,
-  Component,
-  ComponentType,
-} from 'inferno';
+// Note: This is JSXInternal, which gets renamed to JSX on export from jsx-runtime
+import type { Ref } from "./state";
+
+export namespace JSXInternal {
+  export type Element = any;
+
+  export interface ElementAttributesProperty {
+    props: {};
+  }
+
+  export interface ElementChildrenAttribute {
+    children: {};
+  }
+
+  export interface IntrinsicAttributes {
+    key?: any;
+  }
+
+  // CSS Properties
+  export type CSSProperties = {
+    [key: string]: string | number | undefined;
+  };
+
+  // Common HTML Attributes
+  export interface HTMLAttributes<T = HTMLElement> {
+    ref?: Ref<T> | ((element: T | null) => void);
+    id?: string;
+    class?: string | Record<string, boolean>;
+    style?: string | CSSProperties;
+    title?: string;
+    role?: string;
+    tabIndex?: number;
+
+    onClick?: (event: MouseEvent) => void;
+    onDblClick?: (event: MouseEvent) => void;
+    onChange?: (event: Event) => void;
+    onInput?: (event: Event) => void;
+    onSubmit?: (event: Event) => void;
+    onFocus?: (event: FocusEvent) => void;
+    onBlur?: (event: FocusEvent) => void;
+    onKeyDown?: (event: KeyboardEvent) => void;
+    onKeyUp?: (event: KeyboardEvent) => void;
+    onKeyPress?: (event: KeyboardEvent) => void;
+    onMouseDown?: (event: MouseEvent) => void;
+    onMouseUp?: (event: MouseEvent) => void;
+    onMouseEnter?: (event: MouseEvent) => void;
+    onMouseLeave?: (event: MouseEvent) => void;
+    onMouseMove?: (event: MouseEvent) => void;
+    onMouseOver?: (event: MouseEvent) => void;
+    onMouseOut?: (event: MouseEvent) => void;
+    onWheel?: (event: WheelEvent) => void;
+    onScroll?: (event: Event) => void;
+    onTouchStart?: (event: TouchEvent) => void;
+    onTouchEnd?: (event: TouchEvent) => void;
+    onTouchMove?: (event: TouchEvent) => void;
+    onTouchCancel?: (event: TouchEvent) => void;
+
+    [key: `aria-${string}`]: string | boolean | number | undefined;
+    [key: `data-${string}`]: string | boolean | number | undefined;
+
+    children?: any;
+  }
+
+  export interface AnchorHTMLAttributes<T = HTMLAnchorElement>
+    extends HTMLAttributes<T> {
+    href?: string;
+    target?: "_blank" | "_self" | "_parent" | "_top";
+    rel?: string;
+    download?: string;
+  }
+
+  export interface ButtonHTMLAttributes<T = HTMLButtonElement>
+    extends HTMLAttributes<T> {
+    type?: "button" | "submit" | "reset";
+    disabled?: boolean;
+    name?: string;
+    value?: string;
+  }
+
+  export interface FormHTMLAttributes<T = HTMLFormElement>
+    extends HTMLAttributes<T> {
+    action?: string;
+    method?: "get" | "post";
+    enctype?: string;
+    target?: string;
+    noValidate?: boolean;
+  }
+
+  export interface InputHTMLAttributes<T = HTMLInputElement>
+    extends HTMLAttributes<T> {
+    type?:
+      | "button"
+      | "checkbox"
+      | "color"
+      | "date"
+      | "datetime-local"
+      | "email"
+      | "file"
+      | "hidden"
+      | "image"
+      | "month"
+      | "number"
+      | "password"
+      | "radio"
+      | "range"
+      | "reset"
+      | "search"
+      | "submit"
+      | "tel"
+      | "text"
+      | "time"
+      | "url"
+      | "week";
+    value?: string | number;
+    defaultValue?: string | number;
+    placeholder?: string;
+    disabled?: boolean;
+    required?: boolean;
+    readOnly?: boolean;
+    name?: string;
+    checked?: boolean;
+    defaultChecked?: boolean;
+    min?: string | number;
+    max?: string | number;
+    step?: string | number;
+    pattern?: string;
+    accept?: string;
+    multiple?: boolean;
+    autoComplete?: string;
+    autoFocus?: boolean;
+  }
+
+  export interface LabelHTMLAttributes<T = HTMLLabelElement>
+    extends HTMLAttributes<T> {
+    htmlFor?: string;
+    for?: string;
+  }
+
+  export interface SelectHTMLAttributes<T = HTMLSelectElement>
+    extends HTMLAttributes<T> {
+    value?: string | string[];
+    defaultValue?: string | string[];
+    disabled?: boolean;
+    required?: boolean;
+    name?: string;
+    multiple?: boolean;
+    size?: number;
+  }
+
+  export interface OptionHTMLAttributes<T = HTMLOptionElement>
+    extends HTMLAttributes<T> {
+    value?: string | number;
+    selected?: boolean;
+    disabled?: boolean;
+    label?: string;
+  }
+
+  export interface TextareaHTMLAttributes<T = HTMLTextAreaElement>
+    extends HTMLAttributes<T> {
+    value?: string;
+    defaultValue?: string;
+    placeholder?: string;
+    disabled?: boolean;
+    required?: boolean;
+    readOnly?: boolean;
+    name?: string;
+    rows?: number;
+    cols?: number;
+    maxLength?: number;
+    wrap?: "soft" | "hard";
+  }
+
+  export interface FieldsetHTMLAttributes<T = HTMLFieldSetElement>
+    extends HTMLAttributes<T> {
+    disabled?: boolean;
+    name?: string;
+  }
+
+  export interface ImgHTMLAttributes<T = HTMLImageElement>
+    extends HTMLAttributes<T> {
+    src?: string;
+    alt?: string;
+    width?: number | string;
+    height?: number | string;
+    loading?: "eager" | "lazy";
+    crossOrigin?: "anonymous" | "use-credentials";
+  }
+
+  export interface SVGAttributes<T = SVGElement> extends HTMLAttributes<T> {
+    xmlns?: string;
+    viewBox?: string;
+    width?: number | string;
+    height?: number | string;
+    fill?: string;
+    stroke?: string;
+    strokeWidth?: number | string;
+  }
+
+  // Intrinsic Elements
+  export interface IntrinsicElements {
+    a: AnchorHTMLAttributes<HTMLAnchorElement>;
+    abbr: HTMLAttributes<HTMLElement>;
+    address: HTMLAttributes<HTMLElement>;
+    article: HTMLAttributes<HTMLElement>;
+    aside: HTMLAttributes<HTMLElement>;
+    b: HTMLAttributes<HTMLElement>;
+    blockquote: HTMLAttributes<HTMLQuoteElement>;
+    body: HTMLAttributes<HTMLBodyElement>;
+    br: HTMLAttributes<HTMLBRElement>;
+    button: ButtonHTMLAttributes<HTMLButtonElement>;
+    canvas: HTMLAttributes<HTMLCanvasElement>;
+    code: HTMLAttributes<HTMLElement>;
+    div: HTMLAttributes<HTMLDivElement>;
+    em: HTMLAttributes<HTMLElement>;
+    fieldset: FieldsetHTMLAttributes<HTMLFieldSetElement>;
+    footer: HTMLAttributes<HTMLElement>;
+    form: FormHTMLAttributes<HTMLFormElement>;
+    h1: HTMLAttributes<HTMLHeadingElement>;
+    h2: HTMLAttributes<HTMLHeadingElement>;
+    h3: HTMLAttributes<HTMLHeadingElement>;
+    h4: HTMLAttributes<HTMLHeadingElement>;
+    h5: HTMLAttributes<HTMLHeadingElement>;
+    h6: HTMLAttributes<HTMLHeadingElement>;
+    head: HTMLAttributes<HTMLHeadElement>;
+    header: HTMLAttributes<HTMLElement>;
+    hr: HTMLAttributes<HTMLHRElement>;
+    html: HTMLAttributes<HTMLHtmlElement>;
+    i: HTMLAttributes<HTMLElement>;
+    img: ImgHTMLAttributes<HTMLImageElement>;
+    input: InputHTMLAttributes<HTMLInputElement>;
+    label: LabelHTMLAttributes<HTMLLabelElement>;
+    legend: HTMLAttributes<HTMLLegendElement>;
+    li: HTMLAttributes<HTMLLIElement>;
+    main: HTMLAttributes<HTMLElement>;
+    nav: HTMLAttributes<HTMLElement>;
+    ol: HTMLAttributes<HTMLOListElement>;
+    option: OptionHTMLAttributes<HTMLOptionElement>;
+    p: HTMLAttributes<HTMLParagraphElement>;
+    pre: HTMLAttributes<HTMLPreElement>;
+    section: HTMLAttributes<HTMLElement>;
+    select: SelectHTMLAttributes<HTMLSelectElement>;
+    small: HTMLAttributes<HTMLElement>;
+    span: HTMLAttributes<HTMLSpanElement>;
+    strong: HTMLAttributes<HTMLElement>;
+    style: HTMLAttributes<HTMLStyleElement>;
+    textarea: TextareaHTMLAttributes<HTMLTextAreaElement>;
+    ul: HTMLAttributes<HTMLUListElement>;
+
+    // SVG
+    svg: SVGAttributes<SVGSVGElement>;
+    circle: SVGAttributes<SVGCircleElement>;
+    line: SVGAttributes<SVGLineElement>;
+    path: SVGAttributes<SVGPathElement>;
+    rect: SVGAttributes<SVGRectElement>;
+  }
+}

package/dist/observation.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"observation.test.d.ts","sourceRoot":"","sources":["../src/observation.test.ts"],"names":[],"mappings":""}

package/dist/observation.test.js

@@ -0,0 +1,150 @@
+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();
+    });
+    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);
+    });
+});