rask-ui 0.20.1 → 0.20.2

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/index.d.ts

@@ -1,3 +1,4 @@
+import "./types";
 export { render } from "./render";
 export { useCleanup, useMountEffect, RaskStatefulComponent, RaskStatelessComponent, } from "./component";
 export { createContext, useContext, useInjectContext } from "./createContext";
@@ -13,5 +14,4 @@ export { useDerived, Derived } from "./useDerived";
 export { syncBatch } from "./batch";
 export { inspect } from "./inspect";
 export { Router, useRouter } from "./useRouter";
-export { createVNode, createComponentVNode, createFragment, createTextVNode, normalizeProps, Component, } from "inferno";
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,UAAU,CAAC;AAClC,OAAO,EACL,UAAU,EACV,cAAc,EACd,qBAAqB,EACrB,sBAAsB,GACvB,MAAM,aAAa,CAAC;AACrB,OAAO,EAAE,aAAa,EAAE,UAAU,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AAC9E,OAAO,EAAE,QAAQ,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AACnD,OAAO,EAAE,QAAQ,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AAC7C,OAAO,EAAE,SAAS,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAChD,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAC1C,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAChD,OAAO,EAAE,MAAM,EAAE,MAAM,UAAU,CAAC;AAClC,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AACpC,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AACxC,OAAO,EAAE,UAAU,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AACnD,OAAO,EAAE,SAAS,EAAE,MAAM,SAAS,CAAC;AACpC,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AACpC,OAAO,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAGhD,OAAO,EACL,WAAW,EACX,oBAAoB,EACpB,cAAc,EACd,eAAe,EACf,cAAc,EACd,SAAS,GACV,MAAM,SAAS,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AACA,OAAO,SAAS,CAAC;AAEjB,OAAO,EAAE,MAAM,EAAE,MAAM,UAAU,CAAC;AAClC,OAAO,EACL,UAAU,EACV,cAAc,EACd,qBAAqB,EACrB,sBAAsB,GACvB,MAAM,aAAa,CAAC;AACrB,OAAO,EAAE,aAAa,EAAE,UAAU,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AAC9E,OAAO,EAAE,QAAQ,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AACnD,OAAO,EAAE,QAAQ,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AAC7C,OAAO,EAAE,SAAS,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAChD,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAC1C,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAChD,OAAO,EAAE,MAAM,EAAE,MAAM,UAAU,CAAC;AAClC,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AACpC,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AACxC,OAAO,EAAE,UAAU,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AACnD,OAAO,EAAE,SAAS,EAAE,MAAM,SAAS,CAAC;AACpC,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AACpC,OAAO,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC"}

package/dist/index.js

@@ -1,3 +1,5 @@
+// Import global types - this makes the Rask namespace available globally
+import "./types";
 export { render } from "./render";
 export { useCleanup, useMountEffect, RaskStatefulComponent, RaskStatelessComponent, } from "./component";
 export { createContext, useContext, useInjectContext } from "./createContext";
@@ -13,5 +15,3 @@ export { useDerived } from "./useDerived";
 export { syncBatch } from "./batch";
 export { inspect } from "./inspect";
 export { useRouter } from "./useRouter";
-// Re-export Inferno JSX runtime functions so users don't need to install Inferno directly
-export { createVNode, createComponentVNode, createFragment, createTextVNode, normalizeProps, Component, } from "inferno";

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);
+    });
+});

package/dist/plugin.js

@@ -40,7 +40,7 @@ export default function raskPlugin(options = {}) {
                 [
                     infernoPluginPath,
                     {
-                        importSource: importSource,
+                        importSource: `${importSource}/compiler`,
                         defineAllArguments: false,
                     },
                 ],

package/dist/suspense.d.ts

@@ -0,0 +1,25 @@
+import { VNode } from "snabbdom";
+export declare function createSuspense<T extends Record<string, Promise<any>>>(promises: T): {
+    [K in keyof T]: Awaited<T[K]>;
+};
+export declare function Suspense(props: {
+    fallback: VNode;
+    children: VNode | VNode[];
+}): () => VNode | VNode[];
+type SuspensePromiseState<T> = {
+    status: "pending";
+    value: null;
+    error: null;
+} | {
+    status: "resolved";
+    value: T;
+    error: null;
+} | {
+    status: "rejected";
+    value: null;
+    error: string;
+};
+export type SuspensePromise<T> = Promise<T> & SuspensePromiseState<T>;
+export declare function createSuspensePromise<T>(promise: Promise<T>): SuspensePromise<T>;
+export {};
+//# sourceMappingURL=suspense.d.ts.map

package/dist/suspense.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"suspense.d.ts","sourceRoot":"","sources":["../src/suspense.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,UAAU,CAAC;AAKjC,wBAAgB,cAAc,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,CAAC,CAAC,EACnE,QAAQ,EAAE,CAAC,GACV;KACA,CAAC,IAAI,MAAM,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;CAC9B,CAuBA;AAQD,wBAAgB,QAAQ,CAAC,KAAK,EAAE;IAC9B,QAAQ,EAAE,KAAK,CAAC;IAChB,QAAQ,EAAE,KAAK,GAAG,KAAK,EAAE,CAAC;CAC3B,yBAmBA;AAED,KAAK,oBAAoB,CAAC,CAAC,IACvB;IACE,MAAM,EAAE,SAAS,CAAC;IAClB,KAAK,EAAE,IAAI,CAAC;IACZ,KAAK,EAAE,IAAI,CAAC;CACb,GACD;IACE,MAAM,EAAE,UAAU,CAAC;IACnB,KAAK,EAAE,CAAC,CAAC;IACT,KAAK,EAAE,IAAI,CAAC;CACb,GACD;IACE,MAAM,EAAE,UAAU,CAAC;IACnB,KAAK,EAAE,IAAI,CAAC;IACZ,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAEN,MAAM,MAAM,eAAe,CAAC,CAAC,IAAI,OAAO,CAAC,CAAC,CAAC,GAAG,oBAAoB,CAAC,CAAC,CAAC,CAAC;AAEtE,wBAAgB,qBAAqB,CAAC,CAAC,EACrC,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,GAClB,eAAe,CAAC,CAAC,CAAC,CAgEpB"}

package/dist/suspense.js

@@ -0,0 +1,97 @@
+import { getCurrentComponent } from "./component";
+import { createState } from "./createState";
+import { getCurrentObserver, Signal } from "./observation";
+export function createSuspense(promises) {
+    let currentComponent = getCurrentComponent();
+    if (!currentComponent) {
+        throw new Error("createSuspense must be used in the setup of a component");
+    }
+    const proxy = {};
+    for (const key in promises) {
+        const promise = promises[key];
+        const suspensePromise = isSuspensePromise(promise)
+            ? promise
+            : createSuspensePromise(promise);
+        currentComponent.notifyAsync(suspensePromise);
+        Object.defineProperty(proxy, key, {
+            get() {
+                return suspensePromise.value;
+            },
+        });
+    }
+    return proxy;
+}
+function isSuspensePromise(promise) {
+    return "status" in promise;
+}
+export function Suspense(props) {
+    const currentComponent = getCurrentComponent();
+    const state = createState({
+        suspendingPromises: [],
+    });
+    currentComponent.onAsync((promise) => {
+        state.suspendingPromises = state.suspendingPromises.concat(promise);
+    });
+    return () => {
+        const isAllResolved = state.suspendingPromises.every((promise) => promise.status === "resolved");
+        console.log(isAllResolved);
+        return isAllResolved ? props.children : props.fallback;
+    };
+}
+export function createSuspensePromise(promise) {
+    const signal = new Signal();
+    const state = {
+        error: null,
+        status: "pending",
+        value: null,
+    };
+    Object.defineProperty(promise, "value", {
+        get() {
+            const observer = getCurrentObserver();
+            if (observer) {
+                observer.subscribeSignal(signal);
+            }
+            return state.value;
+        },
+        set(newValue) {
+            state.value = newValue;
+            signal.notify();
+        },
+    });
+    Object.defineProperty(promise, "error", {
+        get() {
+            const observer = getCurrentObserver();
+            if (observer) {
+                observer.subscribeSignal(signal);
+            }
+            return state.error;
+        },
+    });
+    Object.defineProperty(promise, "status", {
+        get() {
+            const observer = getCurrentObserver();
+            if (observer) {
+                observer.subscribeSignal(signal);
+            }
+            return state.status;
+        },
+    });
+    promise
+        .then((value) => {
+        Object.assign(state, {
+            value,
+            error: null,
+            status: "resolved",
+        });
+        signal.notify();
+    })
+        .catch((error) => {
+        Object.assign(state, {
+            value: null,
+            error: String(error),
+            status: "rejected",
+        });
+        signal.notify();
+    });
+    return promise;
+}

package/dist/test-setup.d.ts

@@ -0,0 +1,16 @@
+import type { VNode } from 'snabbdom';
+/**
+ * Test helper to render a component and provide easy cleanup
+ *
+ * @example
+ * const { container, unmount } = renderComponent(<MyComponent />);
+ * expect(container.textContent).toBe('hello');
+ * unmount();
+ */
+export declare function renderComponent(vnode: VNode): {
+    container: HTMLElement;
+    vnode: VNode;
+    unmount: () => void;
+    rerender: (newVnode: VNode) => VNode;
+};
+//# sourceMappingURL=test-setup.d.ts.map

package/dist/test-setup.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"test-setup.d.ts","sourceRoot":"","sources":["../src/test-setup.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,UAAU,CAAC;AAUtC;;;;;;;GAOG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,KAAK;;;;yBAmBnB,KAAK;EAK7B"}

package/dist/test-setup.js

@@ -0,0 +1,40 @@
+// Test setup file for vitest
+import { afterEach } from 'vitest';
+import { render, patch } from './render';
+// Clean up after each test
+afterEach(() => {
+    document.body.innerHTML = '';
+    // Remove any style tags added by render function
+    document.querySelectorAll('style').forEach(style => style.remove());
+});
+/**
+ * Test helper to render a component and provide easy cleanup
+ *
+ * @example
+ * const { container, unmount } = renderComponent(<MyComponent />);
+ * expect(container.textContent).toBe('hello');
+ * unmount();
+ */
+export function renderComponent(vnode) {
+    const container = document.createElement('div');
+    document.body.appendChild(container);
+    let currentVnode = render(vnode, container);
+    const actualElement = currentVnode.elm;
+    return {
+        // The actual rendered DOM element (after patch replaces container)
+        container: actualElement,
+        // The vnode returned by render
+        vnode: currentVnode,
+        // Cleanup function
+        unmount: () => {
+            if (actualElement && actualElement.parentNode) {
+                actualElement.parentNode.removeChild(actualElement);
+            }
+        },
+        // Re-render with new vnode
+        rerender: (newVnode) => {
+            currentVnode = patch(currentVnode, newVnode);
+            return currentVnode;
+        }
+    };
+}

package/dist/test.d.ts

@@ -0,0 +1,2 @@
+export declare function test(container: any): void;
+//# sourceMappingURL=test.d.ts.map