rask-ui 0.20.1 → 0.20.3

package/dist/createState.js

@@ -1,9 +1,4 @@
-import { getCurrentComponent } from "./component";
-import { INSPECT_MARKER, INSPECTOR_ENABLED } from "./inspect";
 import { getCurrentObserver, Signal } from "./observation";
-export function assignState(state, newState) {
-    return Object.assign(state, newState);
-}
 /**
  * Creates a reactive state object that tracks property access and notifies observers on changes.
  *
@@ -29,14 +24,11 @@ export function assignState(state, newState) {
  * @returns A reactive proxy of the state object
  */
 export function createState(state) {
-    if (getCurrentComponent()?.isRendering) {
-        throw new Error("createState cannot be called during render. Call it in component setup or globally.");
-    }
-    return getProxy(state, {});
+    return getProxy(state);
 }
 const proxyCache = new WeakMap();
-export const PROXY_MARKER = Symbol("isProxy");
-function getProxy(value, notifyInspectorRef) {
+const PROXY_MARKER = Symbol("isProxy");
+function getProxy(value) {
     // Check if already a proxy to avoid double-wrapping
     if (PROXY_MARKER in value) {
         return value;
@@ -51,9 +43,6 @@ function getProxy(value, notifyInspectorRef) {
             if (key === PROXY_MARKER) {
                 return true;
             }
-            if (INSPECTOR_ENABLED && key === INSPECT_MARKER) {
-                return true;
-            }
             return Reflect.has(target, key);
         },
         get(target, key) {
@@ -61,9 +50,6 @@ function getProxy(value, notifyInspectorRef) {
             if (key === PROXY_MARKER) {
                 return true;
             }
-            if (INSPECTOR_ENABLED && key === INSPECT_MARKER) {
-                return !notifyInspectorRef.current;
-            }
             const value = Reflect.get(target, key);
             if (typeof key === "symbol" || typeof value === "function") {
                 return value;
@@ -75,26 +61,11 @@ function getProxy(value, notifyInspectorRef) {
             }
             if (Array.isArray(value) ||
                 (typeof value === "object" && value !== null)) {
-                return getProxy(value, INSPECTOR_ENABLED && notifyInspectorRef.current
-                    ? {
-                        current: {
-                            notify: notifyInspectorRef.current.notify,
-                            path: notifyInspectorRef.current.path.concat(key),
-                        },
-                    }
-                    : notifyInspectorRef);
+                return getProxy(value);
             }
             return value;
         },
         set(target, key, newValue) {
-            if (INSPECTOR_ENABLED && key === INSPECT_MARKER) {
-                Object.defineProperty(notifyInspectorRef, "current", {
-                    get() {
-                        return newValue.current;
-                    },
-                });
-                return Reflect.set(target, key, newValue);
-            }
             if (typeof key === "symbol") {
                 return Reflect.set(target, key, newValue);
             }
@@ -102,16 +73,10 @@ function getProxy(value, notifyInspectorRef) {
             const setResult = Reflect.set(target, key, newValue);
             // We only notify if actual change, though array length actually updates under the hood
             if (newValue !== oldValue || (Array.isArray(value) && key === "length")) {
+                console.log("WTF", key, newValue);
                 const signal = signals[key];
                 signal?.notify();
             }
-            if (INSPECTOR_ENABLED) {
-                notifyInspectorRef.current?.notify({
-                    type: "mutation",
-                    path: notifyInspectorRef.current.path,
-                    value: newValue,
-                });
-            }
             return setResult;
         },
         deleteProperty(target, key) {

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

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

package/dist/createState.test.js

@@ -0,0 +1,111 @@
+import { describe, it, expect } from 'vitest';
+import { createState } from './createState';
+import { Observer } from './observation';
+describe('createState', () => {
+    it('should create a reactive proxy from an object', () => {
+        const state = createState({ count: 0 });
+        expect(state.count).toBe(0);
+    });
+    it('should allow mutations', () => {
+        const state = createState({ count: 0 });
+        state.count = 5;
+        expect(state.count).toBe(5);
+    });
+    it('should return the same proxy for the same object', () => {
+        const obj = { count: 0 };
+        const proxy1 = createState(obj);
+        const proxy2 = createState(obj);
+        expect(proxy1).toBe(proxy2);
+    });
+    it('should create nested proxies for nested objects', () => {
+        const state = createState({ user: { name: 'Alice', age: 30 } });
+        state.user.name = 'Bob';
+        expect(state.user.name).toBe('Bob');
+    });
+    it('should handle arrays reactively', () => {
+        const state = createState({ items: [1, 2, 3] });
+        state.items.push(4);
+        expect(state.items).toEqual([1, 2, 3, 4]);
+    });
+    it('should track property access in observers', () => {
+        const state = createState({ count: 0 });
+        let renderCount = 0;
+        const observer = new Observer(() => {
+            renderCount++;
+        });
+        const dispose = observer.observe();
+        state.count; // Access property to track it
+        dispose();
+        expect(renderCount).toBe(0);
+        // Mutate after observation setup
+        const dispose2 = observer.observe();
+        const value = state.count; // Track
+        dispose2(); // Stop observing, subscriptions are now active
+        state.count = 1;
+        // Wait for microtask
+        return new Promise((resolve) => {
+            queueMicrotask(() => {
+                expect(renderCount).toBeGreaterThan(0);
+                resolve(undefined);
+            });
+        });
+    });
+    it('should handle property deletion', () => {
+        const state = createState({ count: 0, temp: 'value' });
+        delete state.temp;
+        expect(state.temp).toBeUndefined();
+        expect('temp' in state).toBe(false);
+    });
+    it('should not create proxies for functions', () => {
+        const fn = () => 'hello';
+        const state = createState({ method: fn });
+        expect(state.method).toBe(fn);
+        expect(state.method()).toBe('hello');
+    });
+    it('should handle symbol properties', () => {
+        const sym = Symbol('test');
+        const state = createState({ [sym]: 'value' });
+        expect(state[sym]).toBe('value');
+    });
+    it('should notify observers only on actual changes', () => {
+        const state = createState({ count: 0 });
+        let notifyCount = 0;
+        const observer = new Observer(() => {
+            notifyCount++;
+        });
+        const dispose = observer.observe();
+        state.count; // Track
+        dispose();
+        state.count = 0; // Same value - should still notify per current implementation
+        state.count = 0;
+        return new Promise((resolve) => {
+            queueMicrotask(() => {
+                // The implementation notifies even for same value, except for optimization cases
+                observer.dispose();
+                resolve(undefined);
+            });
+        });
+    });
+    it('should handle deeply nested objects', () => {
+        const state = createState({
+            level1: {
+                level2: {
+                    level3: {
+                        value: 'deep',
+                    },
+                },
+            },
+        });
+        state.level1.level2.level3.value = 'modified';
+        expect(state.level1.level2.level3.value).toBe('modified');
+    });
+    it('should handle array mutations correctly', () => {
+        const state = createState({ items: [1, 2, 3] });
+        state.items.pop();
+        expect(state.items).toEqual([1, 2]);
+        state.items.unshift(0);
+        expect(state.items).toEqual([0, 1, 2]);
+        state.items.splice(1, 1, 99);
+        expect(state.items).toEqual([0, 99, 2]);
+    });
+});

package/dist/createView.d.ts

@@ -1,28 +1,54 @@
-type Simplify<T> = T extends any ? {
+type Simplify<T> = {
     [K in keyof T]: T[K];
-} : never;
-type UndefinedKeys<T> = {
-    [K in keyof T]-?: [T[K]] extends [undefined] ? K : never;
-}[keyof T];
-type MergeTwo<A extends object, B extends object> = A extends any ? Simplify<Omit<A, keyof B> & Omit<B, UndefinedKeys<B>>> : never;
+} & {};
+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[]
-] ? MergeManyAcc<H, R> : {};
-type MergeManyAcc<Acc extends object, Rest extends object[]> = Rest extends [
-    infer H extends object,
-    ...infer R extends object[]
-] ? MergeManyAcc<MergeTwo<Acc, H>, R> : Acc;
+] ? 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.
+ * 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
  *
- * ⚠️ Do not destructure the returned view object; always read properties
- * directly from the view to preserve reactivity.
+ * @param args - Objects to merge (reactive or plain objects)
+ * @returns A view object with getters for all properties, maintaining reactivity
  */
-export declare function createView<A extends object>(a: A): A;
-export declare function createView<A extends object, B extends object>(a: A, b: B): MergeTwo<A, B>;
 export declare function createView<T extends readonly object[]>(...args: T): MergeMany<T>;
 export {};
 //# sourceMappingURL=createView.d.ts.map

package/dist/createView.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"createView.d.ts","sourceRoot":"","sources":["../src/createView.ts"],"names":[],"mappings":"AAGA,KAAK,QAAQ,CAAC,CAAC,IAAI,CAAC,SAAS,GAAG,GAAG;KAAG,CAAC,IAAI,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;CAAE,GAAG,KAAK,CAAC;AAEpE,KAAK,aAAa,CAAC,CAAC,IAAI;KACrB,CAAC,IAAI,MAAM,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,SAAS,CAAC,GAAG,CAAC,GAAG,KAAK;CACzD,CAAC,MAAM,CAAC,CAAC,CAAC;AAEX,KAAK,QAAQ,CAAC,CAAC,SAAS,MAAM,EAAE,CAAC,SAAS,MAAM,IAAI,CAAC,SAAS,GAAG,GAC7D,QAAQ,CAAC,IAAI,CAAC,CAAC,EAAE,MAAM,CAAC,CAAC,GAAG,IAAI,CAAC,CAAC,EAAE,aAAa,CAAC,CAAC,CAAC,CAAC,CAAC,GACtD,KAAK,CAAC;AAEV,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,YAAY,CAAC,CAAC,EAAE,CAAC,CAAC,GAClB,EAAE,CAAC;AAEP,KAAK,YAAY,CAAC,GAAG,SAAS,MAAM,EAAE,IAAI,SAAS,MAAM,EAAE,IAAI,IAAI,SAAS;IAC1E,MAAM,CAAC,SAAS,MAAM;IACtB,GAAG,MAAM,CAAC,SAAS,MAAM,EAAE;CAC5B,GACG,YAAY,CAAC,QAAQ,CAAC,GAAG,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,GACjC,GAAG,CAAC;AAER;;;;;;;GAOG;AACH,wBAAgB,UAAU,CAAC,CAAC,SAAS,MAAM,EAAE,CAAC,EAAE,CAAC,GAAG,CAAC,CAAC;AACtD,wBAAgB,UAAU,CAAC,CAAC,SAAS,MAAM,EAAE,CAAC,SAAS,MAAM,EAC3D,CAAC,EAAE,CAAC,EACJ,CAAC,EAAE,CAAC,GACH,QAAQ,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;AAClB,wBAAgB,UAAU,CAAC,CAAC,SAAS,SAAS,MAAM,EAAE,EACpD,GAAG,IAAI,EAAE,CAAC,GACT,SAAS,CAAC,CAAC,CAAC,CAAC"}
+{"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

@@ -1,77 +1,68 @@
-import { getCurrentComponent } from "./component";
-import { INSPECT_MARKER, INSPECTOR_ENABLED } from "./inspect";
+/**
+ * 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) {
-    if (!getCurrentComponent()) {
-        throw new Error("Only use createView in component setup");
-    }
     const result = {};
     const seen = new Set();
-    let notifyInspectorRef = {};
     for (let i = args.length - 1; i >= 0; i--) {
         const src = args[i];
-        if (!src)
-            continue;
-        if (INSPECTOR_ENABLED && src[INSPECT_MARKER]) {
-            src[INSPECT_MARKER] = notifyInspectorRef;
-        }
-        // Mimic Object.assign: only enumerable own property keys
+        // 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: () => {
-                    const value = src[key];
-                    if (!INSPECTOR_ENABLED || !notifyInspectorRef.current) {
-                        return value;
-                    }
-                    // Propagate inspector marker into nested observables
-                    if (value?.[INSPECT_MARKER]) {
-                        value[INSPECT_MARKER] = {
-                            current: {
-                                notify: notifyInspectorRef.current.notify,
-                                path: notifyInspectorRef.current.path.concat(key),
-                            },
-                        };
-                    }
-                    else if (typeof value === "function") {
-                        // Wrap actions to notify inspector
-                        return (...params) => {
-                            notifyInspectorRef.current.notify({
-                                type: "action",
-                                path: notifyInspectorRef.current.path.concat(key),
-                                params,
-                            });
-                            return value(...params);
-                        };
-                    }
-                    return value;
-                },
+                get: () => src[key],
+                // Optional write-through (commented out by default):
+                // set: (value) => { (src as any)[key as any] = value; },
             });
             seen.add(key);
         }
     }
-    if (INSPECTOR_ENABLED) {
-        Object.defineProperty(result, INSPECT_MARKER, {
-            enumerable: false,
-            configurable: false,
-            get() {
-                return !notifyInspectorRef.current;
-            },
-            set: (value) => {
-                Object.defineProperty(notifyInspectorRef, "current", {
-                    configurable: true,
-                    get() {
-                        return value.current;
-                    },
-                });
-            },
-        });
-    }
-    // The overload signatures expose a precise type; this is the shared impl.
     return result;
 }

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/{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"}