rask-ui 0.20.4 → 0.21.0

package/dist/createQuery.test.js

@@ -1,156 +0,0 @@
-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/createRef.d.ts

@@ -1,6 +0,0 @@
-export declare function createRef<T>(cb?: (element: T) => (() => void) | void): {
-    (node: T | null): void;
-    current: T | null;
-    cb: ((element: T) => (() => void) | void) | undefined;
-};
-//# sourceMappingURL=createRef.d.ts.map

package/dist/createRef.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"createRef.d.ts","sourceRoot":"","sources":["../src/createRef.ts"],"names":[],"mappings":"AAAA,wBAAgB,SAAS,CAAC,CAAC,EAAE,EAAE,CAAC,EAAE,CAAC,OAAO,EAAE,CAAC,KAAK,CAAC,MAAM,IAAI,CAAC,GAAG,IAAI;WAChD,CAAC,GAAG,IAAI;;mBADe,CAAC,KAAK,CAAC,MAAM,IAAI,CAAC,GAAG,IAAI;EASpE"}

package/dist/createRef.js

@@ -1,8 +0,0 @@
-export function createRef(cb) {
-    function ref(node) {
-        ref.current = node;
-    }
-    ref.current = null;
-    ref.cb = cb;
-    return ref;
-}

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

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

package/dist/createState.test.js

@@ -1,111 +0,0 @@
-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.test.d.ts.map

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

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

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

package/dist/observation.test.js

@@ -1,150 +0,0 @@
-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/suspense.d.ts

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

package/dist/suspense.d.ts.map

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

package/dist/suspense.js

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

package/dist/test-setup.d.ts

@@ -1,16 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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

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

package/dist/test.d.ts

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

package/dist/test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"test.d.ts","sourceRoot":"","sources":["../src/test.ts"],"names":[],"mappings":"AAiBA,wBAAgB,IAAI,CAAC,SAAS,EAAE,GAAG,QA4BlC"}

package/dist/test.js

@@ -1,24 +0,0 @@
-import { init, classModule, propsModule, styleModule, eventListenersModule, h, } from "snabbdom";
-const patch = init([
-    // Init patch function with chosen modules
-    classModule, // makes it easy to toggle classes
-    propsModule, // for setting properties on DOM elements
-    styleModule, // handles styling on elements with support for animations
-    eventListenersModule, // attaches event listeners
-]);
-export function test(container) {
-    const vnode = h("div#container.two.classes", { on: { click: () => console.log("div clicked") } }, [
-        h("span", { style: { fontWeight: "bold" } }, "This is bold"),
-        " and this is just normal text",
-        h("a", { props: { href: "/foo" } }, "I'll take you places!"),
-    ]);
-    // Patch into empty DOM element – this modifies the DOM as a side effect
-    patch(container, vnode);
-    const newVnode = h("div#container.two.classes", { on: { click: () => console.log("updated div clicked") } }, [
-        h("span", { style: { fontWeight: "normal", fontStyle: "italic" } }, "This is now italic type"),
-        " and this is still just normal text",
-        h("a", { props: { href: "/bar" } }, "I'll take you places!"),
-    ]);
-    // Second `patch` invocation
-    patch(vnode, newVnode); // Snabbdom efficiently updates the old view to the new state
-}