rask-ui 0.1.1 → 0.2.1

package/dist/vdom/ComponentVNode.d.ts

@@ -0,0 +1,48 @@
+import { Observer } from "../observation";
+import { AbstractVNode } from "./AbstractVNode";
+import { Props, VNode } from "./types";
+export type ComponentChild = VNode | string | null | number | undefined | boolean;
+export type ComponentChildren = ComponentChild | ComponentChild[];
+/**
+ * Component function type. Components receive reactive props that should not be destructured.
+ *
+ * @warning **Do not destructure props!** Props are wrapped in a reactive proxy, and destructuring
+ * breaks reactivity. This is the same rule as Solid.js.
+ *
+ * @example
+ * // ❌ Bad - destructuring props loses reactivity
+ * function MyComponent({ count, name }) {
+ *   return () => <div>{count} {name}</div>; // Won't update!
+ * }
+ *
+ * // ✅ Good - access props directly in render
+ * function MyComponent(props) {
+ *   return () => <div>{props.count} {props.name}</div>; // Reactive!
+ * }
+ */
+export type Component<P extends Props> = ((props: P) => () => ComponentChildren) | (() => () => ComponentChildren);
+export type ComponentInstance = {
+    parent?: VNode;
+    contexts: Map<object, unknown> | null;
+    onMounts: Array<() => void>;
+    onCleanups: Array<() => void>;
+    observer: Observer;
+    reactiveProps: object;
+    error: unknown;
+    notifyError(error: unknown): void;
+};
+export declare function getCurrentComponent(): ComponentInstance;
+export declare function onMount(cb: () => void): void;
+export declare function onCleanup(cb: () => void): void;
+export declare class ComponentVNode extends AbstractVNode {
+    component: Component<any>;
+    props: Props;
+    children: VNode[];
+    instance?: ComponentInstance;
+    constructor(component: Component<any>, props: Props, children: VNode[], key?: string);
+    rerender(): void;
+    mount(parent?: VNode): Node[];
+    patch(newNode: ComponentVNode): void;
+    unmount(): void;
+}
+//# sourceMappingURL=ComponentVNode.d.ts.map

package/dist/vdom/ComponentVNode.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ComponentVNode.d.ts","sourceRoot":"","sources":["../../src/vdom/ComponentVNode.ts"],"names":[],"mappings":"AAAA,OAAO,EAAsB,QAAQ,EAAU,MAAM,gBAAgB,CAAC;AACtE,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAGhD,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAGvC,MAAM,MAAM,cAAc,GACtB,KAAK,GACL,MAAM,GACN,IAAI,GACJ,MAAM,GACN,SAAS,GACT,OAAO,CAAC;AACZ,MAAM,MAAM,iBAAiB,GAAG,cAAc,GAAG,cAAc,EAAE,CAAC;AAElE;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,MAAM,SAAS,CAAC,CAAC,SAAS,KAAK,IACjC,CAAC,CAAC,KAAK,EAAE,CAAC,KAAK,MAAM,iBAAiB,CAAC,GACvC,CAAC,MAAM,MAAM,iBAAiB,CAAC,CAAC;AAEpC,MAAM,MAAM,iBAAiB,GAAG;IAC9B,MAAM,CAAC,EAAE,KAAK,CAAC;IACf,QAAQ,EAAE,GAAG,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAAC;IACtC,QAAQ,EAAE,KAAK,CAAC,MAAM,IAAI,CAAC,CAAC;IAC5B,UAAU,EAAE,KAAK,CAAC,MAAM,IAAI,CAAC,CAAC;IAC9B,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;AAKF,wBAAgB,mBAAmB,sBAYlC;AAED,wBAAgB,OAAO,CAAC,EAAE,EAAE,MAAM,IAAI,QAYrC;AAED,wBAAgB,SAAS,CAAC,EAAE,EAAE,MAAM,IAAI,QAYvC;AAED,qBAAa,cAAe,SAAQ,aAAa;IAC/C,SAAS,EAAE,SAAS,CAAC,GAAG,CAAC,CAAC;IAC1B,KAAK,EAAE,KAAK,CAAC;IAEb,QAAQ,EAAE,KAAK,EAAE,CAAM;IACvB,QAAQ,CAAC,EAAE,iBAAiB,CAAC;gBAE3B,SAAS,EAAE,SAAS,CAAC,GAAG,CAAC,EACzB,KAAK,EAAE,KAAK,EACZ,QAAQ,EAAE,KAAK,EAAE,EACjB,GAAG,CAAC,EAAE,MAAM;IAWd,QAAQ,IAAI,IAAI;IAGhB,KAAK,CAAC,MAAM,CAAC,EAAE,KAAK,GAAG,IAAI,EAAE;IAyH7B,KAAK,CAAC,OAAO,EAAE,cAAc;IAW7B,OAAO;CAcR"}

package/dist/vdom/ComponentVNode.js

@@ -0,0 +1,209 @@
+import { getCurrentObserver, Observer, Signal } from "../observation";
+import { AbstractVNode } from "./AbstractVNode";
+import { FragmentVNode } from "./FragmentVNode";
+import { RootVNode } from "./RootVNode";
+import { normalizeChildren } from "./utils";
+import { currentRoot } from "./RootVNode";
+import { ElementVNode } from "./ElementVNode";
+export function getCurrentComponent() {
+    if (!currentRoot) {
+        throw new Error("No current root");
+    }
+    const currentComponent = currentRoot.componentStack[0];
+    if (!currentComponent) {
+        throw new Error("No current component");
+    }
+    return currentComponent;
+}
+export function onMount(cb) {
+    if (!currentRoot) {
+        throw new Error("Only use onCleanup in component setup");
+    }
+    const current = currentRoot.componentStack[0];
+    if (!current) {
+        throw new Error("Only use onCleanup in component setup");
+    }
+    current.onMounts.push(cb);
+}
+export function onCleanup(cb) {
+    if (!currentRoot) {
+        throw new Error("Only use onCleanup in component setup");
+    }
+    const current = currentRoot.componentStack[0];
+    if (!current) {
+        throw new Error("Only use onCleanup in component setup");
+    }
+    current.onCleanups.push(cb);
+}
+export class ComponentVNode extends AbstractVNode {
+    component;
+    props;
+    // These are the actual current children returned by component
+    children = [];
+    instance;
+    constructor(component, props, children, key) {
+        super();
+        this.component = component;
+        this.props = {
+            ...props,
+            children,
+        };
+        this.children = [];
+        this.key = key;
+    }
+    rerender() {
+        this.parent?.rerender();
+    }
+    mount(parent) {
+        this.parent = parent;
+        if (parent instanceof RootVNode) {
+            this.root = parent;
+        }
+        else {
+            this.root = parent?.root;
+        }
+        let errorSignal;
+        let error;
+        const executeRender = () => {
+            const stopObserving = instance.observer.observe();
+            let renderResult = new FragmentVNode([]);
+            try {
+                renderResult = render();
+            }
+            catch (error) {
+                instance.notifyError(error);
+            }
+            finally {
+                stopObserving();
+            }
+            return normalizeChildren(renderResult);
+        };
+        const instance = (this.instance = {
+            parent,
+            contexts: null,
+            onCleanups: [],
+            onMounts: [],
+            observer: new Observer(() => {
+                this.root?.setAsCurrent();
+                const newChildren = executeRender();
+                const prevChildren = this.children;
+                this.children = this.patchChildren(newChildren);
+                // Typically components return a single element, which does
+                // not require the parent to apply elements to the DOM again
+                const canSelfUpdate = prevChildren.length === 1 &&
+                    this.children.length === 1 &&
+                    prevChildren[0] instanceof ElementVNode &&
+                    this.children[0] instanceof ElementVNode &&
+                    this.canPatch(prevChildren[0], this.children[0]);
+                if (!canSelfUpdate) {
+                    this.parent?.rerender();
+                }
+                this.root?.flushLifecycle();
+                this.root?.clearCurrent();
+            }),
+            reactiveProps: createReactiveProps(this.props),
+            get error() {
+                if (!errorSignal) {
+                    errorSignal = new Signal();
+                }
+                const observer = getCurrentObserver();
+                if (observer) {
+                    observer.subscribeSignal(errorSignal);
+                }
+                return error;
+            },
+            notifyError(childError) {
+                if (errorSignal) {
+                    error = childError;
+                    errorSignal.notify();
+                }
+                else if (instance.parent) {
+                    let parent = instance.parent;
+                    while (parent && !(parent instanceof ComponentVNode)) {
+                        parent = parent?.parent;
+                    }
+                    // Only call notifyError if we found a ComponentVNode parent
+                    if (parent instanceof ComponentVNode) {
+                        parent.instance?.notifyError(childError);
+                    }
+                    // Otherwise there's no ErrorBoundary, so do nothing
+                }
+                else {
+                    throw childError;
+                }
+            },
+        });
+        this.root?.setAsCurrent();
+        this.root?.pushComponent(instance);
+        const render = this.component(instance.reactiveProps);
+        // Validate that render is a function
+        if (typeof render !== "function") {
+            const initError = new Error(`Component must return a render function, but got ${render instanceof AbstractVNode ? "JSX" : typeof render}. ` +
+                `Components should return a function that returns JSX: \`return () => <div>...</div>\``);
+            console.error("Error initializing component:", initError);
+            error = initError;
+            instance.notifyError(initError);
+            this.root?.popComponent();
+            this.root?.clearCurrent();
+            return [];
+        }
+        this.children = executeRender();
+        this.root?.popComponent();
+        this.root?.clearCurrent();
+        const childElements = this.children
+            .map((child) => child.mount(this))
+            .flat();
+        // Queue onMount callbacks after children are mounted
+        // This ensures refs and other child lifecycle hooks run before parent onMount
+        instance.onMounts.forEach((cb) => {
+            this.root?.queueMount(cb);
+        });
+        return childElements;
+    }
+    patch(newNode) {
+        this.root?.setAsCurrent();
+        this.root?.pushComponent(this.instance);
+        for (const prop in newNode.props) {
+            this.instance.reactiveProps[prop] = newNode.props[prop];
+        }
+        this.root?.popComponent();
+        this.root?.clearCurrent();
+    }
+    unmount() {
+        this.instance.observer.dispose();
+        this.children.forEach((child) => child.unmount());
+        this.root?.queueUnmount(() => {
+            this.instance.onCleanups.forEach((cb) => {
+                try {
+                    cb();
+                }
+                catch (error) {
+                    // Log error but continue executing remaining cleanups
+                    console.error("Error during cleanup:", error);
+                }
+            });
+        });
+    }
+}
+function createReactiveProps(props) {
+    const reactiveProps = {};
+    for (const prop in props) {
+        const signal = new Signal();
+        Object.defineProperty(reactiveProps, prop, {
+            get() {
+                const observer = getCurrentObserver();
+                if (observer) {
+                    observer.subscribeSignal(signal);
+                }
+                return props[prop];
+            },
+            set(value) {
+                if (props[prop] !== value) {
+                    props[prop] = value;
+                    signal.notify();
+                }
+            },
+        });
+    }
+    return reactiveProps;
+}

package/dist/vdom/ElementVNode.d.ts

@@ -0,0 +1,24 @@
+import { AbstractVNode } from "./AbstractVNode";
+import { Props, VNode } from "./types";
+export declare class ElementVNode extends AbstractVNode {
+    tag: string;
+    props: Props;
+    children: VNode[];
+    key?: string;
+    private ref?;
+    private eventListeners?;
+    constructor(tag: string, { ref, ...props }: Props, children: VNode[], key?: string);
+    rerender(): void;
+    mount(parent?: VNode): Node;
+    /**
+     * An ELEMENT patch goes through three operations
+     * - Patch or replace the element
+     * - Patch the children
+     */
+    patch(newNode: ElementVNode): void;
+    unmount(): void;
+    private setProp;
+    private patchProps;
+    private addEventListener;
+}
+//# sourceMappingURL=ElementVNode.d.ts.map

package/dist/vdom/ElementVNode.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ElementVNode.d.ts","sourceRoot":"","sources":["../../src/vdom/ElementVNode.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAGhD,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAUvC,qBAAa,YAAa,SAAQ,aAAa;IAC7C,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,KAAK,CAAC;IACb,QAAQ,EAAE,KAAK,EAAE,CAAC;IAClB,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,OAAO,CAAC,GAAG,CAAC,CAA0D;IACtE,OAAO,CAAC,cAAc,CAAC,CAA6B;gBAElD,GAAG,EAAE,MAAM,EACX,EAAE,GAAG,EAAE,GAAG,KAAK,EAAE,EAAE,KAAK,EACxB,QAAQ,EAAE,KAAK,EAAE,EACjB,GAAG,CAAC,EAAE,MAAM;IASd,QAAQ,IAAI,IAAI;IAOhB,KAAK,CAAC,MAAM,CAAC,EAAE,KAAK,GAAG,IAAI;IAkC3B;;;;OAIG;IACH,KAAK,CAAC,OAAO,EAAE,YAAY;IAW3B,OAAO;IAYP,OAAO,CAAC,OAAO,CAoCb;IACF,OAAO,CAAC,UAAU;IAGlB,OAAO,CAAC,gBAAgB;CAgBzB"}

package/dist/vdom/ElementVNode.js

@@ -0,0 +1,126 @@
+import { AbstractVNode } from "./AbstractVNode";
+import { RootVNode } from "./RootVNode";
+import { isEventProp, setElementAttr, setElementProp, setElementStyle, setElementClass, } from "./dom-utils";
+import { diffObjectKeys } from "./utils";
+export class ElementVNode extends AbstractVNode {
+    tag;
+    props;
+    children;
+    key;
+    ref;
+    eventListeners;
+    constructor(tag, { ref, ...props }, children, key) {
+        super();
+        this.tag = tag;
+        this.props = props;
+        this.children = children;
+        this.key = key;
+        this.ref = ref;
+    }
+    rerender() {
+        const childrenElms = this.children
+            .map((child) => child.getElements())
+            .flat();
+        this.elm.replaceChildren(...childrenElms);
+    }
+    mount(parent) {
+        this.parent = parent;
+        if (parent instanceof RootVNode) {
+            this.root = parent;
+        }
+        else {
+            this.root = parent?.root;
+        }
+        const elm = (this.elm = document.createElement(this.tag));
+        for (const prop in this.props) {
+            this.setProp(prop, this.props[prop]);
+        }
+        if (this.ref) {
+            const ref = this.ref;
+            this.root?.queueMount(() => {
+                ref(elm);
+            });
+        }
+        this.children.forEach((child) => {
+            const childrenElms = child.mount(this);
+            if (Array.isArray(childrenElms)) {
+                childrenElms.forEach((node) => this.elm.appendChild(node));
+            }
+            else {
+                elm.appendChild(childrenElms);
+            }
+        });
+        return elm;
+    }
+    /**
+     * An ELEMENT patch goes through three operations
+     * - Patch or replace the element
+     * - Patch the children
+     */
+    patch(newNode) {
+        this.patchProps(newNode.props);
+        this.props = newNode.props;
+        this.children = this.patchChildren(newNode.children);
+        const childrenElms = this.children
+            .map((child) => child.getElements())
+            .flat();
+        this.elm.replaceChildren(...childrenElms);
+    }
+    unmount() {
+        this.children.forEach((child) => child.unmount());
+        this.root?.queueUnmount(() => {
+            if (this.eventListeners) {
+                for (const type in this.eventListeners) {
+                    this.elm.removeEventListener(type, this.eventListeners[type]);
+                }
+            }
+            delete this.elm;
+            delete this.parent;
+        });
+    }
+    setProp = (prop, value) => {
+        const elm = this.getHTMLElement();
+        if (prop === "children") {
+            return;
+        }
+        if (prop === "class") {
+            setElementClass(elm, value);
+            return;
+        }
+        // Skip className if class is present (class takes precedence)
+        if (prop === "className" && "class" in this.props) {
+            return;
+        }
+        if (prop === "style") {
+            setElementStyle(elm, value);
+            return;
+        }
+        if (prop.startsWith("data-") || prop.startsWith("aria-")) {
+            setElementAttr(elm, prop, value);
+            return;
+        }
+        if (isEventProp(prop)) {
+            this.addEventListener(prop.slice(2).toLowerCase(), value);
+            return;
+        }
+        setElementProp(elm, prop, value);
+    };
+    patchProps(newProps) {
+        diffObjectKeys(this.props, newProps, this.setProp);
+    }
+    addEventListener(type, cb) {
+        if (!this.eventListeners) {
+            this.eventListeners = {};
+        }
+        if (this.eventListeners[type]) {
+            this.elm.removeEventListener(type, this.eventListeners[type]);
+        }
+        if (typeof cb === "function") {
+            this.elm.addEventListener(type, cb);
+            this.eventListeners[type] = cb;
+        }
+        else {
+            delete this.eventListeners[type];
+        }
+    }
+}

package/dist/vdom/FragmentVNode.d.ts

@@ -0,0 +1,13 @@
+import { AbstractVNode } from "./AbstractVNode";
+import { VNode } from "./types";
+export declare const Fragment: unique symbol;
+export declare class FragmentVNode extends AbstractVNode {
+    children: VNode[];
+    key?: string;
+    constructor(children: VNode[], key?: string);
+    mount(parent?: VNode): Node[];
+    rerender(): void;
+    patch(newNode: FragmentVNode): void;
+    unmount(): void;
+}
+//# sourceMappingURL=FragmentVNode.d.ts.map

package/dist/vdom/FragmentVNode.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FragmentVNode.d.ts","sourceRoot":"","sources":["../../src/vdom/FragmentVNode.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAKhD,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAEhC,eAAO,MAAM,QAAQ,eAAqB,CAAC;AAE3C,qBAAa,aAAc,SAAQ,aAAa;IAC9C,QAAQ,EAAE,KAAK,EAAE,CAAC;IAClB,GAAG,CAAC,EAAE,MAAM,CAAC;gBAED,QAAQ,EAAE,KAAK,EAAE,EAAE,GAAG,CAAC,EAAE,MAAM;IAK3C,KAAK,CAAC,MAAM,CAAC,EAAE,KAAK,GAAG,IAAI,EAAE;IAW7B,QAAQ,IAAI,IAAI;IAGhB,KAAK,CAAC,OAAO,EAAE,aAAa;IAG5B,OAAO;CAMR"}

package/dist/vdom/FragmentVNode.js

@@ -0,0 +1,34 @@
+import { AbstractVNode } from "./AbstractVNode";
+import { RootVNode } from "./RootVNode";
+export const Fragment = Symbol("Fragment");
+export class FragmentVNode extends AbstractVNode {
+    children;
+    key;
+    constructor(children, key) {
+        super();
+        this.children = children;
+        this.key = key;
+    }
+    mount(parent) {
+        this.parent = parent;
+        if (parent instanceof RootVNode) {
+            this.root = parent;
+        }
+        else {
+            this.root = parent?.root;
+        }
+        return this.children.map((child) => child.mount(this)).flat();
+    }
+    rerender() {
+        this.parent?.rerender();
+    }
+    patch(newNode) {
+        this.children = this.patchChildren(newNode.children);
+    }
+    unmount() {
+        this.children.forEach((child) => child.unmount());
+        this.root?.queueUnmount(() => {
+            delete this.parent;
+        });
+    }
+}

package/dist/vdom/RootVNode.d.ts

@@ -0,0 +1,22 @@
+import { AbstractVNode } from "./AbstractVNode";
+import { VNode } from "./types";
+import { ComponentInstance } from "./ComponentVNode";
+export declare let currentRoot: RootVNode | undefined;
+export declare class RootVNode extends AbstractVNode {
+    children: VNode[];
+    componentStack: ComponentInstance[];
+    private lifecycleQueue;
+    constructor(rootNode: VNode, container: HTMLElement);
+    queueMount(cb: () => void): void;
+    queueUnmount(cb: () => void): void;
+    flushLifecycle(): void;
+    pushComponent(instance: ComponentInstance): void;
+    popComponent(): void;
+    setAsCurrent(): void;
+    clearCurrent(): void;
+    mount(): Node | Node[];
+    patch(): void;
+    rerender(): void;
+    unmount(): void;
+}
+//# sourceMappingURL=RootVNode.d.ts.map

package/dist/vdom/RootVNode.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RootVNode.d.ts","sourceRoot":"","sources":["../../src/vdom/RootVNode.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAChD,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAChC,OAAO,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAC;AAIrD,eAAO,IAAI,WAAW,EAAE,SAAS,GAAG,SAAS,CAAC;AAE9C,qBAAa,SAAU,SAAQ,aAAa;IAC1C,QAAQ,EAAE,KAAK,EAAE,CAAC;IAClB,cAAc,EAAE,iBAAiB,EAAE,CAAM;IACzC,OAAO,CAAC,cAAc,CAGpB;gBAEU,QAAQ,EAAE,KAAK,EAAE,SAAS,EAAE,WAAW;IAMnD,UAAU,CAAC,EAAE,EAAE,MAAM,IAAI;IAIzB,YAAY,CAAC,EAAE,EAAE,MAAM,IAAI;IAI3B,cAAc;IAOd,aAAa,CAAC,QAAQ,EAAE,iBAAiB;IAIzC,YAAY;IAIZ,YAAY;IAIZ,YAAY;IAMZ,KAAK,IAAI,IAAI,GAAG,IAAI,EAAE;IAGtB,KAAK,IAAI,IAAI;IACb,QAAQ,IAAI,IAAI;IAShB,OAAO,IAAI,IAAI;CAChB"}

package/dist/vdom/RootVNode.js

@@ -0,0 +1,55 @@
+import { AbstractVNode } from "./AbstractVNode";
+// Global reference to the currently executing root
+// Safe because JS is single-threaded - only one render executes at a time
+export let currentRoot;
+export class RootVNode extends AbstractVNode {
+    children;
+    componentStack = [];
+    lifecycleQueue = {
+        toMount: [],
+        toUnmount: [],
+    };
+    constructor(rootNode, container) {
+        super();
+        this.elm = container;
+        this.children = [rootNode];
+    }
+    queueMount(cb) {
+        this.lifecycleQueue.toMount.push(cb);
+    }
+    queueUnmount(cb) {
+        this.lifecycleQueue.toUnmount.push(cb);
+    }
+    flushLifecycle() {
+        this.lifecycleQueue.toUnmount.forEach((cb) => cb());
+        this.lifecycleQueue.toUnmount = [];
+        this.lifecycleQueue.toMount.forEach((cb) => cb());
+        this.lifecycleQueue.toMount = [];
+    }
+    pushComponent(instance) {
+        this.componentStack.unshift(instance);
+    }
+    popComponent() {
+        this.componentStack.shift();
+    }
+    setAsCurrent() {
+        currentRoot = this;
+    }
+    clearCurrent() {
+        if (currentRoot === this) {
+            currentRoot = undefined;
+        }
+    }
+    mount() {
+        return this.children.map((childNode) => childNode.mount(this)).flat();
+    }
+    patch() { }
+    rerender() {
+        const childrenElms = this.children
+            .map((child) => child.getElements())
+            .flat();
+        this.elm.replaceChildren(...childrenElms);
+        this.flushLifecycle();
+    }
+    unmount() { }
+}

package/dist/vdom/TextVNode.d.ts

@@ -0,0 +1,11 @@
+import { AbstractVNode } from "./AbstractVNode";
+import { VNode } from "./types";
+export declare class TextVNode extends AbstractVNode {
+    text: string;
+    constructor(text: string);
+    mount(parent?: VNode): Node;
+    patch(newNode: TextVNode): void;
+    rerender(): void;
+    unmount(): void;
+}
+//# sourceMappingURL=TextVNode.d.ts.map

package/dist/vdom/TextVNode.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TextVNode.d.ts","sourceRoot":"","sources":["../../src/vdom/TextVNode.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAEhD,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAEhC,qBAAa,SAAU,SAAQ,aAAa;IAC1C,IAAI,EAAE,MAAM,CAAC;gBACD,IAAI,EAAE,MAAM;IAIxB,KAAK,CAAC,MAAM,CAAC,EAAE,KAAK,GAAG,IAAI;IAe3B,KAAK,CAAC,OAAO,EAAE,SAAS;IAIxB,QAAQ,IAAI,IAAI;IAChB,OAAO;CAMR"}

package/dist/vdom/TextVNode.js

@@ -0,0 +1,32 @@
+import { AbstractVNode } from "./AbstractVNode";
+import { RootVNode } from "./RootVNode";
+export class TextVNode extends AbstractVNode {
+    text;
+    constructor(text) {
+        super();
+        this.text = text;
+    }
+    mount(parent) {
+        this.parent = parent;
+        if (parent instanceof RootVNode) {
+            this.root = parent;
+        }
+        else {
+            this.root = parent?.root;
+        }
+        const textNode = document.createTextNode(this.text);
+        this.elm = textNode;
+        return textNode;
+    }
+    patch(newNode) {
+        this.text = newNode.text;
+        this.elm.textContent = this.text;
+    }
+    rerender() { }
+    unmount() {
+        this.root?.queueUnmount(() => {
+            delete this.elm;
+            delete this.parent;
+        });
+    }
+}

package/dist/vdom/class.test.d.ts

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

package/dist/vdom/class.test.d.ts.map

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