rask-ui 0.1.0 → 0.1.1

package/dist/component.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"component.d.ts","sourceRoot":"","sources":["../src/component.ts"],"names":[],"mappings":"AAAA,OAAO,EAAS,KAAK,KAAK,EAAkB,MAAM,UAAU,CAAC;AAE7D,OAAO,EAAsB,QAAQ,EAAU,MAAM,eAAe,CAAC;AACrE,OAAO,EAAc,SAAS,EAAE,MAAM,UAAU,CAAC;AAGjD,MAAM,MAAM,SAAS,CAAC,CAAC,IAAI,CAAC,CAAC,KAAK,EAAE,CAAC,KAAK,MAAM,KAAK,CAAC,GAAG,CAAC,MAAM,MAAM,KAAK,CAAC,CAAC;AAE7E,MAAM,MAAM,iBAAiB,GAAG;IAC9B,MAAM,EAAE,iBAAiB,GAAG,IAAI,CAAC;IACjC,SAAS,EAAE,SAAS,CAAC,GAAG,CAAC,CAAC;IAC1B,QAAQ,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,IAAI,CAAC;IACrC,QAAQ,EAAE,KAAK,CAAC,MAAM,IAAI,CAAC,CAAC;IAC5B,UAAU,EAAE,KAAK,CAAC,MAAM,IAAI,CAAC,CAAC;IAC9B,QAAQ,CAAC,EAAE,KAAK,CAAC;IACjB,QAAQ,EAAE,QAAQ,CAAC;IACnB,aAAa,EAAE,MAAM,CAAC;IACtB,KAAK,EAAE,OAAO,CAAC;IACf,WAAW,CAAC,KAAK,EAAE,OAAO,GAAG,IAAI,CAAC;CACnC,CAAC;AAIF,wBAAgB,mBAAmB,sBAElC;AAED,wBAAgB,OAAO,CAAC,EAAE,EAAE,MAAM,IAAI,QAQrC;AAED,wBAAgB,SAAS,CAAC,EAAE,EAAE,MAAM,IAAI,QAQvC;AAwGD,wBAAgB,eAAe,CAC7B,SAAS,EAAE,SAAS,CAAC,GAAG,CAAC,EACzB,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC9B,QAAQ,EAAE,SAAS,EAAE,GAAG,SAAS,4BAOlC"}
+{"version":3,"file":"component.d.ts","sourceRoot":"","sources":["../src/component.ts"],"names":[],"mappings":"AAAA,OAAO,EAAS,KAAK,KAAK,EAAkB,MAAM,UAAU,CAAC;AAE7D,OAAO,EAAsB,QAAQ,EAAU,MAAM,eAAe,CAAC;AACrE,OAAO,EAAc,SAAS,EAAE,MAAM,UAAU,CAAC;AAGjD,MAAM,MAAM,SAAS,CAAC,CAAC,IAAI,CAAC,CAAC,KAAK,EAAE,CAAC,KAAK,MAAM,KAAK,CAAC,GAAG,CAAC,MAAM,MAAM,KAAK,CAAC,CAAC;AAE7E,MAAM,MAAM,iBAAiB,GAAG;IAC9B,MAAM,EAAE,iBAAiB,GAAG,IAAI,CAAC;IACjC,SAAS,EAAE,SAAS,CAAC,GAAG,CAAC,CAAC;IAC1B,QAAQ,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,IAAI,CAAC;IACrC,QAAQ,EAAE,KAAK,CAAC,MAAM,IAAI,CAAC,CAAC;IAC5B,UAAU,EAAE,KAAK,CAAC,MAAM,IAAI,CAAC,CAAC;IAC9B,QAAQ,CAAC,EAAE,KAAK,CAAC;IACjB,QAAQ,EAAE,QAAQ,CAAC;IACnB,aAAa,EAAE,MAAM,CAAC;IACtB,KAAK,EAAE,OAAO,CAAC;IACf,WAAW,CAAC,KAAK,EAAE,OAAO,GAAG,IAAI,CAAC;CACnC,CAAC;AAIF,wBAAgB,mBAAmB,sBAElC;AAED,wBAAgB,OAAO,CAAC,EAAE,EAAE,MAAM,IAAI,QAQrC;AAED,wBAAgB,SAAS,CAAC,EAAE,EAAE,MAAM,IAAI,QAQvC;AAuGD,wBAAgB,eAAe,CAC7B,SAAS,EAAE,SAAS,CAAC,GAAG,CAAC,EACzB,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC9B,QAAQ,EAAE,SAAS,EAAE,GAAG,SAAS,4BAWlC"}

package/dist/component.js

@@ -26,7 +26,6 @@ const hook = {
         vnode.data.componentInstance.onMounts.forEach((cb) => cb());
     },
     destroy(vnode) {
-        componentStack.shift();
         vnode.data.componentInstance.onCleanups.forEach((cb) => cb());
     },
     prepatch(oldVnode, thunk) {
@@ -69,7 +68,7 @@ const hook = {
             }, Array.isArray(renderResult) ? renderResult : [renderResult]);
         };
         const instance = {
-            parent: getCurrentComponent(),
+            parent: thunk.data.parentComponent || null,
             component,
             contexts: null,
             onMounts: [],
@@ -116,6 +115,9 @@ const hook = {
 export function createComponent(component, props, children) {
     const thunkNode = thunk("component", props.key, component, [props, children]);
     Object.assign(thunkNode.data.hook, hook);
+    // Capture the parent component at vnode creation time (during render)
+    // rather than at init time, to ensure correct parent relationships
+    thunkNode.data.parentComponent = getCurrentComponent();
     return thunkNode;
 }
 function copyToThunk(vnode, thunk) {

package/dist/createAsync.test.d.ts

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

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

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

package/dist/createAsync.test.js

@@ -0,0 +1,110 @@
+import { describe, it, expect } from 'vitest';
+import { createAsync } from './createAsync';
+describe('createAsync', () => {
+    it('should start in pending state', () => {
+        const promise = new Promise(() => { });
+        const async = createAsync(promise);
+        expect(async.isPending).toBe(true);
+        expect(async.value).toBeNull();
+        expect(async.error).toBeNull();
+    });
+    it('should resolve to value state on success', async () => {
+        const promise = Promise.resolve('success');
+        const async = createAsync(promise);
+        expect(async.isPending).toBe(true);
+        await promise;
+        // Wait for state update
+        await new Promise((resolve) => setTimeout(resolve, 0));
+        expect(async.isPending).toBe(false);
+        expect(async.value).toBe('success');
+        expect(async.error).toBeNull();
+    });
+    it('should resolve to error state on rejection', async () => {
+        const promise = Promise.reject(new Error('failed'));
+        const async = createAsync(promise);
+        expect(async.isPending).toBe(true);
+        try {
+            await promise;
+        }
+        catch {
+            // Ignore
+        }
+        // Wait for state update
+        await new Promise((resolve) => setTimeout(resolve, 0));
+        expect(async.isPending).toBe(false);
+        expect(async.value).toBeNull();
+        expect(async.error).toContain('failed');
+    });
+    it('should handle numeric values', async () => {
+        const promise = Promise.resolve(42);
+        const async = createAsync(promise);
+        await promise;
+        await new Promise((resolve) => setTimeout(resolve, 0));
+        expect(async.value).toBe(42);
+    });
+    it('should handle object values', async () => {
+        const data = { id: 1, name: 'Test' };
+        const promise = Promise.resolve(data);
+        const async = createAsync(promise);
+        await promise;
+        await new Promise((resolve) => setTimeout(resolve, 0));
+        expect(async.value).toEqual(data);
+    });
+    it('should handle array values', async () => {
+        const data = [1, 2, 3, 4, 5];
+        const promise = Promise.resolve(data);
+        const async = createAsync(promise);
+        await promise;
+        await new Promise((resolve) => setTimeout(resolve, 0));
+        expect(async.value).toEqual(data);
+    });
+    it('should convert error to string', async () => {
+        const promise = Promise.reject('string error');
+        const async = createAsync(promise);
+        try {
+            await promise;
+        }
+        catch {
+            // Ignore
+        }
+        await new Promise((resolve) => setTimeout(resolve, 0));
+        expect(typeof async.error).toBe('string');
+        expect(async.error).toBe('string error');
+    });
+    it('should handle error objects', async () => {
+        const error = new Error('Something went wrong');
+        const promise = Promise.reject(error);
+        const async = createAsync(promise);
+        try {
+            await promise;
+        }
+        catch {
+            // Ignore
+        }
+        await new Promise((resolve) => setTimeout(resolve, 0));
+        expect(async.error).toContain('Something went wrong');
+    });
+    it('should create reactive state', async () => {
+        const promise = new Promise((resolve) => {
+            setTimeout(() => resolve('delayed'), 10);
+        });
+        const async = createAsync(promise);
+        expect(async.isPending).toBe(true);
+        await promise;
+        await new Promise((resolve) => setTimeout(resolve, 20));
+        expect(async.isPending).toBe(false);
+        expect(async.value).toBe('delayed');
+    });
+    it('should handle immediate resolution', async () => {
+        const async = createAsync(Promise.resolve('immediate'));
+        await new Promise((resolve) => setTimeout(resolve, 0));
+        expect(async.isPending).toBe(false);
+        expect(async.value).toBe('immediate');
+    });
+    it('should handle immediate rejection', async () => {
+        const async = createAsync(Promise.reject('immediate error'));
+        await new Promise((resolve) => setTimeout(resolve, 0));
+        expect(async.isPending).toBe(false);
+        expect(async.error).toBe('immediate error');
+    });
+});

package/dist/createMutation.test.d.ts

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

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

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

package/dist/createMutation.test.js

@@ -0,0 +1,168 @@
+import { describe, it, expect, vi } from 'vitest';
+import { createMutation } from './createMutation';
+describe('createMutation', () => {
+    it('should start in idle state', () => {
+        const mutator = vi.fn(() => Promise.resolve(null));
+        const mutation = createMutation(mutator);
+        expect(mutation.isPending).toBe(false);
+        expect(mutation.params).toBeNull();
+        expect(mutation.error).toBeNull();
+        expect(mutator).not.toHaveBeenCalled();
+    });
+    it('should execute mutator when mutate is called', async () => {
+        const mutator = vi.fn((params) => Promise.resolve(params));
+        const mutation = createMutation(mutator);
+        mutation.mutate('test');
+        expect(mutation.isPending).toBe(true);
+        expect(mutation.params).toBe('test');
+        expect(mutator).toHaveBeenCalledWith('test');
+        await new Promise((resolve) => setTimeout(resolve, 10));
+        expect(mutation.isPending).toBe(false);
+        expect(mutation.params).toBeNull();
+    });
+    it('should handle successful mutations', async () => {
+        const mutator = (params) => Promise.resolve(params);
+        const mutation = createMutation(mutator);
+        mutation.mutate({ id: 1 });
+        expect(mutation.isPending).toBe(true);
+        await new Promise((resolve) => setTimeout(resolve, 10));
+        expect(mutation.isPending).toBe(false);
+        expect(mutation.error).toBeNull();
+        expect(mutation.params).toBeNull();
+    });
+    it('should handle mutation errors', async () => {
+        const mutator = (params) => Promise.reject(new Error('Mutation failed'));
+        const mutation = createMutation(mutator);
+        mutation.mutate('test');
+        expect(mutation.isPending).toBe(true);
+        await new Promise((resolve) => setTimeout(resolve, 10));
+        expect(mutation.isPending).toBe(false);
+        expect(mutation.error).toContain('Mutation failed');
+        expect(mutation.params).toBeNull();
+    });
+    it('should cancel previous mutation on new mutate call', async () => {
+        let resolveFirst;
+        let resolveSecond;
+        const firstPromise = new Promise((resolve) => {
+            resolveFirst = resolve;
+        });
+        const secondPromise = new Promise((resolve) => {
+            resolveSecond = resolve;
+        });
+        const mutator = vi
+            .fn()
+            .mockReturnValueOnce(firstPromise)
+            .mockReturnValueOnce(secondPromise);
+        const mutation = createMutation(mutator);
+        mutation.mutate('first');
+        expect(mutation.params).toBe('first');
+        // Trigger second mutation before first completes
+        mutation.mutate('second');
+        expect(mutation.params).toBe('second');
+        // Resolve first (should be ignored due to cancellation)
+        resolveFirst('first');
+        await new Promise((resolve) => setTimeout(resolve, 10));
+        expect(mutation.isPending).toBe(true); // Still pending second
+        // Resolve second
+        resolveSecond('second');
+        await new Promise((resolve) => setTimeout(resolve, 10));
+        expect(mutation.isPending).toBe(false);
+        expect(mutation.params).toBeNull();
+    });
+    it('should handle rapid successive mutations', async () => {
+        let counter = 0;
+        const mutator = vi.fn(() => Promise.resolve(++counter));
+        const mutation = createMutation(mutator);
+        // Rapid mutations
+        mutation.mutate('1');
+        mutation.mutate('2');
+        mutation.mutate('3');
+        await new Promise((resolve) => setTimeout(resolve, 20));
+        // Only the last mutation should complete
+        expect(mutator).toHaveBeenCalledTimes(3);
+        expect(mutation.isPending).toBe(false);
+        expect(mutation.params).toBeNull();
+    });
+    it('should clear error on successful retry', async () => {
+        const mutator = vi
+            .fn()
+            .mockRejectedValueOnce(new Error('First error'))
+            .mockResolvedValueOnce('success');
+        const mutation = createMutation(mutator);
+        mutation.mutate('attempt1');
+        await new Promise((resolve) => setTimeout(resolve, 10));
+        expect(mutation.error).toContain('First error');
+        mutation.mutate('attempt2');
+        await new Promise((resolve) => setTimeout(resolve, 10));
+        expect(mutation.error).toBeNull();
+        expect(mutation.isPending).toBe(false);
+    });
+    it('should handle different parameter types', async () => {
+        const mutator = vi.fn((params) => Promise.resolve(params));
+        const mutation = createMutation(mutator);
+        // Object params
+        mutation.mutate({ id: 1, name: 'test' });
+        expect(mutation.params).toEqual({ id: 1, name: 'test' });
+        await new Promise((resolve) => setTimeout(resolve, 10));
+        // Array params
+        const mutation2 = createMutation(mutator);
+        mutation2.mutate([1, 2, 3]);
+        expect(mutation2.params).toEqual([1, 2, 3]);
+        await new Promise((resolve) => setTimeout(resolve, 10));
+        // String params
+        const mutation3 = createMutation(mutator);
+        mutation3.mutate('string');
+        expect(mutation3.params).toBe('string');
+    });
+    it('should convert errors to strings', async () => {
+        const mutator = (params) => Promise.reject('string error');
+        const mutation = createMutation(mutator);
+        mutation.mutate('test');
+        await new Promise((resolve) => setTimeout(resolve, 10));
+        expect(typeof mutation.error).toBe('string');
+        expect(mutation.error).toBe('string error');
+    });
+    it('should handle AbortController cancellation correctly', async () => {
+        const abortedPromise = new Promise((_, reject) => {
+            const error = new Error('Aborted');
+            error.name = 'AbortError';
+            setTimeout(() => reject(error), 5);
+        });
+        const successPromise = Promise.resolve('success');
+        const mutator = vi
+            .fn()
+            .mockReturnValueOnce(abortedPromise)
+            .mockReturnValueOnce(successPromise);
+        const mutation = createMutation(mutator);
+        mutation.mutate('first');
+        // Immediately trigger second mutation to abort first
+        mutation.mutate('second');
+        await new Promise((resolve) => setTimeout(resolve, 20));
+        expect(mutation.isPending).toBe(false);
+        expect(mutation.error).toBeNull();
+    });
+    it('should track params during pending state', () => {
+        const mutator = () => new Promise((resolve) => setTimeout(() => resolve(null), 100));
+        const mutation = createMutation(mutator);
+        const params = { id: 123, action: 'update' };
+        mutation.mutate(params);
+        expect(mutation.isPending).toBe(true);
+        expect(mutation.params).toEqual(params);
+    });
+    it('should expose reactive getters', async () => {
+        const mutator = () => Promise.resolve('data');
+        const mutation = createMutation(mutator);
+        // Access getters before mutation
+        expect(mutation.isPending).toBe(false);
+        expect(mutation.params).toBeNull();
+        expect(mutation.error).toBeNull();
+        mutation.mutate('test');
+        // Access getters during mutation
+        expect(mutation.isPending).toBe(true);
+        expect(mutation.params).toBe('test');
+        await new Promise((resolve) => setTimeout(resolve, 10));
+        // Access getters after mutation
+        expect(mutation.isPending).toBe(false);
+        expect(mutation.params).toBeNull();
+    });
+});

package/dist/createQuery.test.d.ts

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

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

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

package/dist/createQuery.test.js

@@ -0,0 +1,156 @@
+import { describe, it, expect, vi } from 'vitest';
+import { createQuery } from './createQuery';
+describe('createQuery', () => {
+    it('should start in pending state and fetch immediately', async () => {
+        const fetcher = vi.fn(() => Promise.resolve('data'));
+        const query = createQuery(fetcher);
+        expect(query.isPending).toBe(true);
+        expect(query.data).toBeNull();
+        expect(query.error).toBeNull();
+        expect(fetcher).toHaveBeenCalledTimes(1);
+        await new Promise((resolve) => setTimeout(resolve, 10));
+        expect(query.isPending).toBe(false);
+        expect(query.data).toBe('data');
+    });
+    it('should resolve to data state on success', async () => {
+        const fetcher = () => Promise.resolve({ id: 1, name: 'Test' });
+        const query = createQuery(fetcher);
+        await new Promise((resolve) => setTimeout(resolve, 10));
+        expect(query.isPending).toBe(false);
+        expect(query.data).toEqual({ id: 1, name: 'Test' });
+        expect(query.error).toBeNull();
+    });
+    it('should resolve to error state on failure', async () => {
+        const fetcher = () => Promise.reject(new Error('Network error'));
+        const query = createQuery(fetcher);
+        await new Promise((resolve) => setTimeout(resolve, 10));
+        expect(query.isPending).toBe(false);
+        expect(query.data).toBeNull();
+        expect(query.error).toContain('Network error');
+    });
+    it('should allow manual refetch', async () => {
+        const fetcher = vi.fn(() => Promise.resolve('data'));
+        const query = createQuery(fetcher);
+        await new Promise((resolve) => setTimeout(resolve, 10));
+        expect(fetcher).toHaveBeenCalledTimes(1);
+        query.fetch();
+        expect(query.isPending).toBe(true);
+        await new Promise((resolve) => setTimeout(resolve, 10));
+        expect(fetcher).toHaveBeenCalledTimes(2);
+        expect(query.isPending).toBe(false);
+    });
+    it('should retain old data during refetch by default', async () => {
+        const fetcher = vi
+            .fn()
+            .mockResolvedValueOnce('data1')
+            .mockResolvedValueOnce('data2');
+        const query = createQuery(fetcher);
+        await new Promise((resolve) => setTimeout(resolve, 10));
+        expect(query.data).toBe('data1');
+        query.fetch();
+        expect(query.isPending).toBe(true);
+        expect(query.data).toBe('data1'); // Old data retained
+        await new Promise((resolve) => setTimeout(resolve, 10));
+        expect(query.data).toBe('data2');
+    });
+    it('should clear old data when force refetch is used', async () => {
+        const fetcher = vi
+            .fn()
+            .mockResolvedValueOnce('data1')
+            .mockResolvedValueOnce('data2');
+        const query = createQuery(fetcher);
+        await new Promise((resolve) => setTimeout(resolve, 10));
+        expect(query.data).toBe('data1');
+        query.fetch(true); // Force refresh
+        expect(query.isPending).toBe(true);
+        expect(query.data).toBeNull(); // Old data cleared
+        await new Promise((resolve) => setTimeout(resolve, 10));
+        expect(query.data).toBe('data2');
+    });
+    it('should cancel previous request on new fetch', async () => {
+        let resolveFirst;
+        let resolveSecond;
+        const firstPromise = new Promise((resolve) => {
+            resolveFirst = resolve;
+        });
+        const secondPromise = new Promise((resolve) => {
+            resolveSecond = resolve;
+        });
+        const fetcher = vi
+            .fn()
+            .mockReturnValueOnce(firstPromise)
+            .mockReturnValueOnce(secondPromise);
+        const query = createQuery(fetcher);
+        expect(query.isPending).toBe(true);
+        // Trigger second fetch before first completes
+        query.fetch();
+        // Resolve first (should be ignored due to cancellation)
+        resolveFirst('first');
+        await new Promise((resolve) => setTimeout(resolve, 10));
+        expect(query.data).toBeNull(); // First result ignored
+        // Resolve second
+        resolveSecond('second');
+        await new Promise((resolve) => setTimeout(resolve, 10));
+        expect(query.data).toBe('second');
+    });
+    it('should handle rapid successive fetches', async () => {
+        let counter = 0;
+        const fetcher = vi.fn(() => Promise.resolve(`data-${++counter}`));
+        const query = createQuery(fetcher);
+        await new Promise((resolve) => setTimeout(resolve, 10));
+        // Rapid fetches
+        query.fetch();
+        query.fetch();
+        query.fetch();
+        await new Promise((resolve) => setTimeout(resolve, 20));
+        // Only the last fetch should matter
+        expect(fetcher).toHaveBeenCalledTimes(4); // Initial + 3 fetches
+        expect(query.data).toBe('data-4');
+    });
+    it('should cancel on error and allow refetch', async () => {
+        const fetcher = vi
+            .fn()
+            .mockRejectedValueOnce(new Error('First error'))
+            .mockResolvedValueOnce('success');
+        const query = createQuery(fetcher);
+        await new Promise((resolve) => setTimeout(resolve, 10));
+        expect(query.error).toContain('First error');
+        expect(query.data).toBeNull();
+        query.fetch();
+        await new Promise((resolve) => setTimeout(resolve, 10));
+        expect(query.error).toBeNull();
+        expect(query.data).toBe('success');
+    });
+    it('should handle AbortController cancellation correctly', async () => {
+        const abortedPromise = new Promise((_, reject) => {
+            const error = new Error('Aborted');
+            error.name = 'AbortError';
+            setTimeout(() => reject(error), 5);
+        });
+        const successPromise = Promise.resolve('success');
+        const fetcher = vi
+            .fn()
+            .mockReturnValueOnce(abortedPromise)
+            .mockReturnValueOnce(successPromise);
+        const query = createQuery(fetcher);
+        // Immediately trigger second fetch to abort first
+        query.fetch();
+        await new Promise((resolve) => setTimeout(resolve, 20));
+        expect(query.data).toBe('success');
+        expect(query.error).toBeNull();
+    });
+    it('should expose reactive getters', async () => {
+        const fetcher = () => Promise.resolve('data');
+        const query = createQuery(fetcher);
+        // Access getters
+        const pending1 = query.isPending;
+        const data1 = query.data;
+        const error1 = query.error;
+        expect(pending1).toBe(true);
+        expect(data1).toBeNull();
+        expect(error1).toBeNull();
+        await new Promise((resolve) => setTimeout(resolve, 10));
+        expect(query.isPending).toBe(false);
+        expect(query.data).toBe('data');
+    });
+});

package/dist/createState.test.d.ts

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

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

package/dist/error.js

@@ -1,7 +1,21 @@
 import { getCurrentComponent } from "./component";
 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 () => {
-        return component.error ? props.error(component.error) : props.children;
+        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];
+        children.forEach((child) => {
+            if (child?.data?.parentComponent) {
+                child.data.parentComponent = component;
+            }
+        });
+        return props.children;
     };
 }

package/dist/observation.test.d.ts

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

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

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

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

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

package/dist/render-test.js

@@ -0,0 +1,21 @@
+// Quick test to understand Snabbdom's behavior
+import { patch } from './render';
+import { h } from 'snabbdom';
+import { JSDOM } from 'jsdom';
+const dom = new JSDOM('<!DOCTYPE html><html><body><div id="app"></div></body></html>');
+global.window = dom.window;
+global.document = dom.window.document;
+const container = document.getElementById('app');
+const parent = container.parentElement;
+console.log('Before patch:');
+console.log('Container id:', container.id);
+console.log('Parent children:', parent.children.length);
+console.log('Parent innerHTML:', parent.innerHTML);
+const vnode = h('div', { props: { id: 'app' } }, [h('span', {}, 'Hello')]);
+const result = patch(container, vnode);
+console.log('\nAfter patch:');
+console.log('Result:', result);
+console.log('Result.elm:', result.elm);
+console.log('Parent children:', parent.children.length);
+console.log('Parent innerHTML:', parent.innerHTML);
+console.log('Container still in DOM?:', document.getElementById('app'));

package/dist/render.d.ts

@@ -2,6 +2,6 @@ import { type VNode } from "snabbdom";
 import { type Component } from "./component";
 export declare const patch: (oldVnode: VNode | Element | DocumentFragment, vnode: VNode) => VNode;
 export type ChildNode = VNode | string | null | number;
-export declare function render(vnode: VNode, container: HTMLElement): void;
+export declare function render(vnode: VNode, container: HTMLElement): VNode;
 export declare function jsx(type: string | Component<any>, props: Record<string, unknown>, children: ChildNode[]): VNode;
 //# sourceMappingURL=render.d.ts.map

package/dist/render.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"render.d.ts","sourceRoot":"","sources":["../src/render.ts"],"names":[],"mappings":"AAAA,OAAO,EAOL,KAAK,KAAK,EAEX,MAAM,UAAU,CAAC;AAClB,OAAO,EAAmB,KAAK,SAAS,EAAE,MAAM,aAAa,CAAC;AAE9D,eAAO,MAAM,KAAK,uEAOhB,CAAC;AAEH,MAAM,MAAM,SAAS,GAAG,KAAK,GAAG,MAAM,GAAG,IAAI,GAAG,MAAM,CAAC;AAEvD,wBAAgB,MAAM,CAAC,KAAK,EAAE,KAAK,EAAE,SAAS,EAAE,WAAW,QAK1D;AAED,wBAAgB,GAAG,CACjB,IAAI,EAAE,MAAM,GAAG,SAAS,CAAC,GAAG,CAAC,EAC7B,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC9B,QAAQ,EAAE,SAAS,EAAE,SA6DtB"}
+{"version":3,"file":"render.d.ts","sourceRoot":"","sources":["../src/render.ts"],"names":[],"mappings":"AAAA,OAAO,EAOL,KAAK,KAAK,EAEX,MAAM,UAAU,CAAC;AAClB,OAAO,EAAmB,KAAK,SAAS,EAAE,MAAM,aAAa,CAAC;AAE9D,eAAO,MAAM,KAAK,uEAOhB,CAAC;AAEH,MAAM,MAAM,SAAS,GAAG,KAAK,GAAG,MAAM,GAAG,IAAI,GAAG,MAAM,CAAC;AAEvD,wBAAgB,MAAM,CAAC,KAAK,EAAE,KAAK,EAAE,SAAS,EAAE,WAAW,SAK1D;AAED,wBAAgB,GAAG,CACjB,IAAI,EAAE,MAAM,GAAG,SAAS,CAAC,GAAG,CAAC,EAC7B,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC9B,QAAQ,EAAE,SAAS,EAAE,SAyEtB"}

package/dist/render.js

@@ -12,7 +12,7 @@ export function render(vnode, container) {
     const style = document.createElement("style");
     style.innerHTML = "component { display: contents; }";
     document.head.appendChild(style);
-    patch(container, vnode);
+    return patch(container, vnode);
 }
 export function jsx(type, props, children) {
     let flatChildren = children.flat();
@@ -31,6 +31,18 @@ export function jsx(type, props, children) {
                 data.style = props[key];
                 continue;
             }
+            if (key === "class") {
+                // Snabbdom's classModule expects an object like { 'class-name': true }
+                // If it's a string, convert it to the object format
+                const classValue = props[key];
+                if (typeof classValue === 'string') {
+                    data.class = { [classValue]: true };
+                }
+                else {
+                    data.class = classValue;
+                }
+                continue;
+            }
             if (key === "ref") {
                 data.hook = data.hook || {};
                 const existingInsertHook = data.hook?.insert;

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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rask-ui",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",