rask-ui 0.1.1 → 0.2.0

package/dist/createView.d.ts

@@ -0,0 +1,54 @@
+type Simplify<T> = {
+    [K in keyof T]: T[K];
+} & {};
+type MergeTwo<A extends object, B extends object> = Simplify<Omit<A, keyof B> & B>;
+type MergeMany<T extends readonly object[]> = T extends [
+    infer H extends object,
+    ...infer R extends object[]
+] ? MergeTwo<H, MergeMany<R>> : {};
+/**
+ * Creates a view that merges multiple objects (reactive or not) into a single object while
+ * maintaining reactivity through getters. Properties from later arguments override earlier ones.
+ *
+ * @warning **Do not destructure the returned view object!** Destructuring breaks reactivity
+ * because it extracts plain values instead of maintaining getter access. This is the same rule
+ * as other reactive primitives.
+ *
+ * @example
+ * // ❌ Bad - destructuring loses reactivity
+ * function Component() {
+ *   const state = createState({ count: 0 });
+ *   const helpers = { increment: () => state.count++ };
+ *   const view = createView(state, helpers);
+ *   const { count, increment } = view; // Don't do this!
+ *   return () => <button onClick={increment}>{count}</button>; // Won't update!
+ * }
+ *
+ * // ✅ Good - access properties directly in render
+ * function Component() {
+ *   const state = createState({ count: 0 });
+ *   const helpers = { increment: () => state.count++ };
+ *   const view = createView(state, helpers);
+ *   return () => <button onClick={view.increment}>{view.count}</button>; // Reactive!
+ * }
+ *
+ * @example
+ * // Merge multiple reactive objects
+ * const state = createState({ count: 0 });
+ * const user = createState({ name: "Alice" });
+ * const view = createView(state, user);
+ * // view has both count and name properties, maintaining reactivity
+ *
+ * @example
+ * // Later arguments override earlier ones
+ * const a = { x: 1, y: 2 };
+ * const b = { y: 3, z: 4 };
+ * const view = createView(a, b);
+ * // view.x === 1, view.y === 3, view.z === 4
+ *
+ * @param args - Objects to merge (reactive or plain objects)
+ * @returns A view object with getters for all properties, maintaining reactivity
+ */
+export declare function createView<T extends readonly object[]>(...args: T): MergeMany<T>;
+export {};
+//# sourceMappingURL=createView.d.ts.map

package/dist/createView.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createView.d.ts","sourceRoot":"","sources":["../src/createView.ts"],"names":[],"mappings":"AAAA,KAAK,QAAQ,CAAC,CAAC,IAAI;KAAG,CAAC,IAAI,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;CAAE,GAAG,EAAE,CAAC;AAEjD,KAAK,QAAQ,CAAC,CAAC,SAAS,MAAM,EAAE,CAAC,SAAS,MAAM,IAAI,QAAQ,CAC1D,IAAI,CAAC,CAAC,EAAE,MAAM,CAAC,CAAC,GAAG,CAAC,CACrB,CAAC;AAEF,KAAK,SAAS,CAAC,CAAC,SAAS,SAAS,MAAM,EAAE,IAAI,CAAC,SAAS;IACtD,MAAM,CAAC,SAAS,MAAM;IACtB,GAAG,MAAM,CAAC,SAAS,MAAM,EAAE;CAC5B,GACG,QAAQ,CAAC,CAAC,EAAE,SAAS,CAAC,CAAC,CAAC,CAAC,GACzB,EAAE,CAAC;AAEP;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;AACH,wBAAgB,UAAU,CAAC,CAAC,SAAS,SAAS,MAAM,EAAE,EACpD,GAAG,IAAI,EAAE,CAAC,GACT,SAAS,CAAC,CAAC,CAAC,CA0Bd"}

package/dist/createView.js

@@ -0,0 +1,68 @@
+/**
+ * Creates a view that merges multiple objects (reactive or not) into a single object while
+ * maintaining reactivity through getters. Properties from later arguments override earlier ones.
+ *
+ * @warning **Do not destructure the returned view object!** Destructuring breaks reactivity
+ * because it extracts plain values instead of maintaining getter access. This is the same rule
+ * as other reactive primitives.
+ *
+ * @example
+ * // ❌ Bad - destructuring loses reactivity
+ * function Component() {
+ *   const state = createState({ count: 0 });
+ *   const helpers = { increment: () => state.count++ };
+ *   const view = createView(state, helpers);
+ *   const { count, increment } = view; // Don't do this!
+ *   return () => <button onClick={increment}>{count}</button>; // Won't update!
+ * }
+ *
+ * // ✅ Good - access properties directly in render
+ * function Component() {
+ *   const state = createState({ count: 0 });
+ *   const helpers = { increment: () => state.count++ };
+ *   const view = createView(state, helpers);
+ *   return () => <button onClick={view.increment}>{view.count}</button>; // Reactive!
+ * }
+ *
+ * @example
+ * // Merge multiple reactive objects
+ * const state = createState({ count: 0 });
+ * const user = createState({ name: "Alice" });
+ * const view = createView(state, user);
+ * // view has both count and name properties, maintaining reactivity
+ *
+ * @example
+ * // Later arguments override earlier ones
+ * const a = { x: 1, y: 2 };
+ * const b = { y: 3, z: 4 };
+ * const view = createView(a, b);
+ * // view.x === 1, view.y === 3, view.z === 4
+ *
+ * @param args - Objects to merge (reactive or plain objects)
+ * @returns A view object with getters for all properties, maintaining reactivity
+ */
+export function createView(...args) {
+    const result = {};
+    const seen = new Set();
+    for (let i = args.length - 1; i >= 0; i--) {
+        const src = args[i];
+        // mimic Object.assign: only enumerable own property keys
+        for (const key of Reflect.ownKeys(src)) {
+            if (seen.has(key))
+                continue;
+            const desc = Object.getOwnPropertyDescriptor(src, key);
+            if (!desc || !desc.enumerable)
+                continue;
+            // Capture the current source for this key (last write wins).
+            Object.defineProperty(result, key, {
+                enumerable: true,
+                configurable: true,
+                get: () => src[key],
+                // Optional write-through (commented out by default):
+                // set: (value) => { (src as any)[key as any] = value; },
+            });
+            seen.add(key);
+        }
+    }
+    return result;
+}

package/dist/createView.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=createView.test.d.ts.map

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

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

package/dist/createView.test.js

@@ -0,0 +1,203 @@
+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);
+        expect(view.x).toBe(1);
+        expect(view.y).toBe(2);
+        expect(view.z).toBe(3);
+    });
+    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);
+        expect(view.x).toBe(1);
+        expect(view.y).toBe(3); // b.y overrides a.y
+        expect(view.z).toBe(4);
+    });
+    it('should maintain reactivity with reactive objects', async () => {
+        const state = createState({ count: 0 });
+        const view = createView(state);
+        let renderCount = 0;
+        let lastValue = 0;
+        const observer = new Observer(() => {
+            renderCount++;
+        });
+        const dispose = observer.observe();
+        lastValue = view.count; // Track the property
+        dispose();
+        expect(renderCount).toBe(0);
+        state.count = 5;
+        // Wait for microtask to process notification
+        await new Promise((resolve) => {
+            queueMicrotask(() => {
+                expect(renderCount).toBe(1);
+                lastValue = view.count;
+                expect(lastValue).toBe(5);
+                resolve(undefined);
+            });
+        });
+    });
+    it('should merge reactive and plain objects while maintaining reactivity', () => {
+        const state = createState({ count: 0 });
+        const helpers = {
+            increment() {
+                state.count++;
+            },
+            decrement() {
+                state.count--;
+            },
+        };
+        const view = createView(state, helpers);
+        expect(view.count).toBe(0);
+        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', () => {
+        const state1 = createState({ count: 0 });
+        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.age).toBe(25);
+        state1.count = 10;
+        state2.name = 'Bob';
+        state3.age = 30;
+        expect(view.count).toBe(10);
+        expect(view.name).toBe('Bob');
+        expect(view.age).toBe(30);
+    });
+    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', () => {
+        const a = { x: 1, y: 2, z: 3 };
+        const b = { y: 20 };
+        const c = { z: 30 };
+        const view = createView(a, b, c);
+        expect(view.x).toBe(1); // From a
+        expect(view.y).toBe(20); // From b (overrides a)
+        expect(view.z).toBe(30); // From c (overrides a)
+    });
+    it('should only include enumerable properties', () => {
+        const obj = { x: 1 };
+        Object.defineProperty(obj, 'hidden', {
+            value: 42,
+            enumerable: false,
+        });
+        const view = createView(obj);
+        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' };
+        const view = createView(obj);
+        expect(view.x).toBe(1);
+        expect(view[sym]).toBe('symbol value');
+    });
+    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;
+        // Observer that only accesses count
+        const countObserver = new Observer(() => {
+            countRenderCount++;
+        });
+        const dispose1 = countObserver.observe();
+        view.count; // Track count
+        dispose1();
+        expect(countRenderCount).toBe(0);
+        // Change count - should trigger
+        state.count = 1;
+        await new Promise((resolve) => {
+            queueMicrotask(() => {
+                expect(countRenderCount).toBe(1);
+                resolve(undefined);
+            });
+        });
+        // Change name - should NOT trigger (not tracked)
+        state.name = 'Bob';
+        await new Promise((resolve) => {
+            queueMicrotask(() => {
+                expect(countRenderCount).toBe(1); // Still 1
+                resolve(undefined);
+            });
+        });
+        // Now track name with a different observer
+        const nameObserver = new Observer(() => {
+            nameRenderCount++;
+        });
+        const dispose2 = nameObserver.observe();
+        view.name; // Track name
+        dispose2();
+        expect(nameRenderCount).toBe(0);
+        // Change name - should trigger name observer
+        state.name = 'Charlie';
+        await new Promise((resolve) => {
+            queueMicrotask(() => {
+                expect(nameRenderCount).toBe(1);
+                resolve(undefined);
+            });
+        });
+    });
+    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(view.nested.x).toBe(1);
+    });
+    it('should handle empty merge', () => {
+        const view = createView({});
+        expect(Object.keys(view).length).toBe(0);
+    });
+    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', () => {
+        const state = createState({ count: 0 });
+        const methods = {
+            increment() {
+                state.count++;
+            },
+        };
+        const view = createView(state, methods);
+        expect(view.count).toBe(0);
+        view.increment();
+        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' });
+        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');
+    });
+});

package/dist/error.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"error.d.ts","sourceRoot":"","sources":["../src/error.ts"],"names":[],"mappings":"AAEA,wBAAgB,aAAa,CAAC,KAAK,EAAE;IACnC,KAAK,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,SAAS,GAAG,SAAS,EAAE,CAAC;IACnD,QAAQ,EAAE,GAAG,CAAC;CACf,aAsBA"}
+{"version":3,"file":"error.d.ts","sourceRoot":"","sources":["../src/error.ts"],"names":[],"mappings":"AAEA,wBAAgB,aAAa,CAAC,KAAK,EAAE;IACnC,KAAK,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,SAAS,GAAG,SAAS,EAAE,CAAC;IACnD,QAAQ,EAAE,GAAG,CAAC;CACf,aAqBA"}

package/dist/error.js

@@ -1,16 +1,15 @@
-import { getCurrentComponent } from "./component";
+import { getCurrentComponent } from "./vdom/ComponentVNode";
 export function ErrorBoundary(props) {
     const component = getCurrentComponent();
-    // Access .error during setup to ensure the error signal is created
-    // This allows child errors to be caught even during initial render
-    component.error;
     return () => {
         if (component.error) {
             return props.error(component.error);
         }
         // Fix parent relationship: children vnodes were created with wrong parent,
         // we need to update them to point to this ErrorBoundary component
-        const children = Array.isArray(props.children) ? props.children : [props.children];
+        const children = Array.isArray(props.children)
+            ? props.children
+            : [props.children];
         children.forEach((child) => {
             if (child?.data?.parentComponent) {
                 child.data.parentComponent = component;

package/dist/error.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=error.test.d.ts.map

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

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

package/dist/error.test.js

@@ -0,0 +1,144 @@
+import { jsx as _jsx, jsxs as _jsxs } from "./jsx-runtime";
+import { describe, it, expect } from "vitest";
+import { ErrorBoundary } from "./error";
+import { renderComponent } from "./test-setup";
+describe("ErrorBoundary", () => {
+    it("should render children when no error occurs", async () => {
+        function SafeChild() {
+            return () => _jsx("div", { children: "Safe content" });
+        }
+        function TestComponent() {
+            return () => (_jsx(ErrorBoundary, { error: (error) => _jsxs("div", { children: ["Error: ", String(error)] }), children: _jsx(SafeChild, {}) }));
+        }
+        const { container, unmount } = renderComponent(_jsx(TestComponent, {}));
+        await new Promise((resolve) => setTimeout(resolve, 10));
+        expect(container.textContent).toContain("Safe content");
+        expect(container.textContent).not.toContain("Error:");
+        unmount();
+    });
+    it("should catch errors thrown in child components", async () => {
+        function ThrowingChild() {
+            return () => {
+                throw new Error("Child component error");
+            };
+        }
+        function TestComponent() {
+            return () => (_jsx(ErrorBoundary, { error: (error) => _jsxs("div", { children: ["Error: ", String(error)] }), children: _jsx(ThrowingChild, {}) }));
+        }
+        const { container, unmount } = renderComponent(_jsx(TestComponent, {}));
+        await new Promise((resolve) => setTimeout(resolve, 10));
+        expect(container.textContent).toContain("Error:");
+        expect(container.textContent).toContain("Child component error");
+        unmount();
+    });
+    it("should render custom error UI", async () => {
+        function ThrowingChild() {
+            return () => {
+                throw new Error("Something went wrong");
+            };
+        }
+        function TestComponent() {
+            return () => (_jsx(ErrorBoundary, { error: (error) => (_jsxs("div", { class: "error-ui", children: [_jsx("h1", { children: "Oops!" }), _jsx("p", { children: String(error) })] })), children: _jsx(ThrowingChild, {}) }));
+        }
+        const { container, unmount } = renderComponent(_jsx(TestComponent, {}));
+        await new Promise((resolve) => setTimeout(resolve, 10));
+        const errorUI = document.querySelector(".error-ui");
+        expect(errorUI).not.toBeNull();
+        expect(errorUI?.querySelector("h1")?.textContent).toBe("Oops!");
+        expect(errorUI?.textContent).toContain("Something went wrong");
+        unmount();
+    });
+    it("should handle multiple children", async () => {
+        function SafeChild1() {
+            return () => _jsx("div", { children: "Child 1" });
+        }
+        function SafeChild2() {
+            return () => _jsx("div", { children: "Child 2" });
+        }
+        function TestComponent() {
+            return () => (_jsxs(ErrorBoundary, { error: (error) => _jsxs("div", { children: ["Error: ", String(error)] }), children: [_jsx(SafeChild1, {}), _jsx(SafeChild2, {})] }));
+        }
+        const { container, unmount } = renderComponent(_jsx(TestComponent, {}));
+        await new Promise((resolve) => setTimeout(resolve, 10));
+        expect(container.textContent).toContain("Child 1");
+        expect(container.textContent).toContain("Child 2");
+        unmount();
+    });
+    it("should catch errors from nested children", async () => {
+        function DeepChild() {
+            return () => {
+                throw new Error("Deep error");
+            };
+        }
+        function MiddleChild() {
+            return () => _jsx(DeepChild, {});
+        }
+        function TestComponent() {
+            return () => (_jsx(ErrorBoundary, { error: (error) => _jsxs("div", { children: ["Caught: ", String(error)] }), children: _jsx(MiddleChild, {}) }));
+        }
+        const { container, unmount } = renderComponent(_jsx(TestComponent, {}));
+        await new Promise((resolve) => setTimeout(resolve, 10));
+        expect(container.textContent).toContain("Caught:");
+        expect(container.textContent).toContain("Deep error");
+        unmount();
+    });
+    it("should allow nested error boundaries", async () => {
+        function ThrowingChild() {
+            return () => {
+                throw new Error("Inner error");
+            };
+        }
+        function TestComponent() {
+            return () => (_jsx(ErrorBoundary, { error: (error) => _jsxs("div", { children: ["Outer: ", String(error)] }), children: _jsx(ErrorBoundary, { error: (error) => _jsxs("div", { children: ["Inner: ", String(error)] }), children: _jsx(ThrowingChild, {}) }) }));
+        }
+        const { container, unmount } = renderComponent(_jsx(TestComponent, {}));
+        await new Promise((resolve) => setTimeout(resolve, 10));
+        // Inner boundary should catch the error
+        expect(container.textContent).toContain("Inner:");
+        expect(container.textContent).not.toContain("Outer:");
+        unmount();
+    });
+    it("should handle string errors", async () => {
+        function ThrowingChild() {
+            return () => {
+                throw "String error";
+            };
+        }
+        function TestComponent() {
+            return () => (_jsx(ErrorBoundary, { error: (error) => _jsxs("div", { children: ["Error: ", String(error)] }), children: _jsx(ThrowingChild, {}) }));
+        }
+        const { container, unmount } = renderComponent(_jsx(TestComponent, {}));
+        await new Promise((resolve) => setTimeout(resolve, 10));
+        expect(container.textContent).toContain("String error");
+        unmount();
+    });
+    it("should handle object errors", async () => {
+        function ThrowingChild() {
+            return () => {
+                throw { message: "Custom error object", code: 500 };
+            };
+        }
+        function TestComponent() {
+            return () => (_jsx(ErrorBoundary, { error: (error) => (_jsxs("div", { children: ["Error: ", error.message, " (Code: ", error.code, ")"] })), children: _jsx(ThrowingChild, {}) }));
+        }
+        const { container, unmount } = renderComponent(_jsx(TestComponent, {}));
+        await new Promise((resolve) => setTimeout(resolve, 10));
+        expect(container.textContent).toContain("Custom error object");
+        expect(container.textContent).toContain("500");
+        unmount();
+    });
+    it("should switch back to children if error is cleared", async () => {
+        // Note: This test demonstrates the current behavior
+        // In practice, error clearing would require additional implementation
+        function SafeChild() {
+            return () => _jsx("div", { children: "Safe content" });
+        }
+        function TestComponent() {
+            return () => (_jsx(ErrorBoundary, { error: (error) => _jsxs("div", { children: ["Error: ", String(error)] }), children: _jsx(SafeChild, {}) }));
+        }
+        const { container, unmount } = renderComponent(_jsx(TestComponent, {}));
+        await new Promise((resolve) => setTimeout(resolve, 10));
+        expect(container.textContent).toContain("Safe content");
+        unmount();
+    });
+});

package/dist/index.d.ts

@@ -1,5 +1,5 @@
-export { render } from "./render";
-export { onMount, onCleanup } from "./component";
+export { render } from "./vdom";
+export { onCleanup, onMount } from "./vdom/ComponentVNode";
 export { createContext } from "./createContext";
 export { createState } from "./createState";
 export { createAsync } from "./createAsync";
@@ -7,4 +7,5 @@ export { ErrorBoundary } from "./error";
 export { createQuery } from "./createQuery";
 export { createMutation } from "./createMutation";
 export { createRef } from "./createRef";
+export { createView } from "./createView";
 //# 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,EAAE,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AACjD,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAChD,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAC5C,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAC5C,OAAO,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AACxC,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAC5C,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAClD,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAChC,OAAO,EAAE,SAAS,EAAE,OAAO,EAAE,MAAM,uBAAuB,CAAC;AAC3D,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAChD,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAC5C,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAC5C,OAAO,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AACxC,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAC5C,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAClD,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AACxC,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC"}

package/dist/index.js

@@ -1,5 +1,5 @@
-export { render } from "./render";
-export { onMount, onCleanup } from "./component";
+export { render } from "./vdom";
+export { onCleanup, onMount } from "./vdom/ComponentVNode";
 export { createContext } from "./createContext";
 export { createState } from "./createState";
 export { createAsync } from "./createAsync";
@@ -7,3 +7,4 @@ export { ErrorBoundary } from "./error";
 export { createQuery } from "./createQuery";
 export { createMutation } from "./createMutation";
 export { createRef } from "./createRef";
+export { createView } from "./createView";

package/dist/integration.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=integration.test.d.ts.map

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

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