@relicloops/cathode 2.0.0

package/lib/inject.js

@@ -0,0 +1,27 @@
+import { render } from './runtime.js';
+function renderToFragment(node) {
+    const temp = document.createElement('div');
+    render(node, temp);
+    const fragment = document.createDocumentFragment();
+    while (temp.firstChild) {
+        fragment.appendChild(temp.firstChild);
+    }
+    return fragment;
+}
+export async function inject(node, parent, options) {
+    const mode = options?.mode ?? 'replace';
+    if (mode === 'replace') {
+        render(node, parent);
+        return;
+    }
+    const fragment = renderToFragment(node);
+    if (mode === 'append') {
+        parent.appendChild(fragment);
+        return;
+    }
+    if (mode === 'prepend') {
+        parent.insertBefore(fragment, parent.firstChild);
+        return;
+    }
+    render(node, parent);
+}

package/lib/lazy-helpers.js

@@ -0,0 +1,98 @@
+/**
+ * Returns event props that trigger lazy loading on hover
+ *
+ * @example
+ * const Dashboard = lazyOnDemand(() => import('./Dashboard.js'));
+ * const hoverProps = lazyOnHover(Dashboard);
+ * <a href="/dashboard" {...hoverProps}>Dashboard</a>
+ */
+export function lazyOnHover(component) {
+    return {
+        onMouseEnter: () => {
+            // console.trace( '[lazyOnHover] Mouse enter, status:', component.__status );
+            if (component.__status === 'pending') {
+                component.awake();
+            }
+        }
+    };
+}
+/**
+ * Triggers lazy loading after a delay
+ *
+ * @param component - The lazy component to load
+ * @param delayMs - Delay in milliseconds before loading
+ * @returns Cleanup function to cancel the timeout
+ *
+ * @example
+ * const Analytics = lazyOnDemand(() => import('./Analytics.js'));
+ * lazyAfterDelay(Analytics, 5000); // Load after 5 seconds
+ */
+export function lazyAfterDelay(component, delayMs) {
+    // console.trace( '[lazyAfterDelay] Setting up delay:', delayMs, 'ms, status:', component.__status );
+    if (component.__status !== 'pending') {
+        return () => { };
+    }
+    const timeoutId = window.setTimeout(() => {
+        // console.trace( '[lazyAfterDelay] Delay elapsed, calling awake()' );
+        component.awake();
+    }, delayMs);
+    return () => clearTimeout(timeoutId);
+}
+/**
+ * Triggers lazy loading when the browser is idle
+ *
+ * @param component - The lazy component to load
+ * @param timeout - Maximum time to wait before loading (default: 5000ms)
+ * @returns Cleanup function to cancel the idle callback
+ *
+ * @example
+ * const ChatWidget = lazyOnDemand(() => import('./ChatWidget.js'));
+ * lazyWhenIdle(ChatWidget); // Load when browser idle
+ */
+export function lazyWhenIdle(component, timeout = 5000) {
+    // console.trace( '[lazyWhenIdle] Setting up idle callback, timeout:', timeout, 'ms, status:', component.__status );
+    if (typeof requestIdleCallback === 'undefined') {
+        // console.trace( '[lazyWhenIdle] requestIdleCallback not available, using delay fallback' );
+        return lazyAfterDelay(component, timeout);
+    }
+    if (component.__status !== 'pending') {
+        return () => { };
+    }
+    const requestId = requestIdleCallback(() => {
+        // console.trace( '[lazyWhenIdle] Idle callback triggered, calling awake()' );
+        component.awake();
+    }, { timeout });
+    return () => cancelIdleCallback(requestId);
+}
+/**
+ * Component wrapper that triggers lazy loading when scrolled into view
+ *
+ * @param props.component - The lazy component to load
+ * @param props.componentProps - Props to pass to the component when loaded
+ * @param props.fallback - Content to show before component is visible
+ * @param props.rootMargin - Margin around root for intersection detection (e.g., "200px")
+ * @param props.threshold - Visibility threshold (0-1) that triggers loading
+ *
+ * @example
+ * const Footer = lazyOnDemand(() => import('./Footer.js'));
+ * <LazyOnVisible
+ *   component={Footer}
+ *   fallback={<div style="height: 200px">Scroll to load footer</div>}
+ *   rootMargin="200px"
+ * />
+ */
+export function LazyOnVisible(props) {
+    return {
+        type: '__lazy_onvisible__',
+        props: {
+            component: props.component,
+            componentProps: props.componentProps || {},
+            fallback: props.fallback || null,
+            observerOptions: {
+                rootMargin: props.rootMargin,
+                threshold: props.threshold
+            }
+        },
+        children: []
+    };
+}

package/lib/lazy.js

@@ -0,0 +1,96 @@
+import { h } from './runtime.js';
+const autoLoadCache = new Map();
+const onDemandCache = new Map();
+function createLazyComponent(loader, autoLoad) {
+    const cache = autoLoad ? autoLoadCache : onDemandCache;
+    let warnedDeprecatedLoad = false;
+    if (cache.has(loader)) {
+        return cache.get(loader);
+    }
+    const LazyWrapper = ((props) => {
+        // console.trace( '[LazyWrapper] Called, autoLoad:', autoLoad, 'status:', LazyWrapper.__status );
+        if (LazyWrapper.__status === 'resolved' && LazyWrapper.__component) {
+            // console.trace( '[LazyWrapper] Returning resolved component' );
+            return h(LazyWrapper.__component, props);
+        }
+        if (LazyWrapper.__status === 'rejected') {
+            // console.trace( '[LazyWrapper] Returning error' );
+            return {
+                type: '__lazy_error__',
+                props: { error: LazyWrapper.__error },
+                children: []
+            };
+        }
+        if (!LazyWrapper.__promise && LazyWrapper.__autoLoad) {
+            // console.trace( '[LazyWrapper] Auto-loading' );
+            LazyWrapper.awake();
+        }
+        const vnode = {
+            type: LazyWrapper.__autoLoad ? '__lazy_pending__' : '__lazy_ondemand_pending__',
+            props: { wrapper: LazyWrapper, componentProps: props },
+            children: []
+        };
+        // console.trace( '[LazyWrapper] Returning VNode with type:', vnode.type );
+        return vnode;
+    });
+    LazyWrapper.__lazy = true;
+    LazyWrapper.__status = 'pending';
+    LazyWrapper.__component = null;
+    LazyWrapper.__error = null;
+    LazyWrapper.__promise = null;
+    LazyWrapper.__autoLoad = autoLoad;
+    LazyWrapper.awake = () => {
+        // console.trace( '[LazyWrapper.awake] Called, autoLoad:', autoLoad, 'has promise:', !!LazyWrapper.__promise );
+        if (LazyWrapper.__promise) {
+            // console.trace( '[LazyWrapper.awake] Promise already exists, returning it' );
+            return LazyWrapper.__promise;
+        }
+        // SSR safety
+        if (typeof document === 'undefined') {
+            return Promise.resolve();
+        }
+        // console.trace( '[LazyWrapper.awake] Starting loader()' );
+        LazyWrapper.__promise = loader()
+            .then(mod => {
+            let component = null;
+            if (mod && typeof mod === 'object' && 'default' in mod && mod.default) {
+                component = mod.default;
+            }
+            else if (typeof mod === 'function') {
+                component = mod;
+            }
+            else if (mod && typeof mod === 'object') {
+                const candidates = Object.values(mod).filter((value) => typeof value === 'function');
+                if (candidates.length === 1) {
+                    component = candidates[0];
+                }
+            }
+            if (!component) {
+                const keys = mod && typeof mod === 'object' ? Object.keys(mod) : [];
+                throw new Error(`Cathode lazy loader: missing component export. Provide a default export or a single named export. Found: [${keys.join(', ')}]`);
+            }
+            LazyWrapper.__component = component;
+            LazyWrapper.__status = 'resolved';
+        })
+            .catch(err => {
+            LazyWrapper.__error = err;
+            LazyWrapper.__status = 'rejected';
+        });
+        return LazyWrapper.__promise;
+    };
+    LazyWrapper.__load = () => {
+        if (!warnedDeprecatedLoad && typeof console !== 'undefined') {
+            console.warn('[Cathode] Lazy component __load() is deprecated. Use awake() instead.');
+            warnedDeprecatedLoad = true;
+        }
+        return LazyWrapper.awake();
+    };
+    cache.set(loader, LazyWrapper);
+    return LazyWrapper;
+}
+export function lazy(loader) {
+    return createLazyComponent(loader, true);
+}
+export function lazyOnDemand(loader) {
+    return createLazyComponent(loader, false);
+}

package/lib/mount.js

@@ -0,0 +1,17 @@
+import { render } from './runtime.js';
+const mountedParents = new WeakSet();
+export async function mount(node, parent) {
+    render(node, parent);
+    mountedParents.add(parent);
+    return {
+        unmount: async () => unmount(parent),
+        cleanup: async () => cleanup(parent),
+    };
+}
+export async function unmount(parent) {
+    parent.innerHTML = '';
+    mountedParents.delete(parent);
+}
+export async function cleanup(parent) {
+    await unmount(parent);
+}

package/lib/runtime.js

@@ -0,0 +1,188 @@
+import { findLazyPending } from './suspense.js';
+export function h(type, props, ...children) {
+    return { type, props: props || {}, children };
+}
+export const Fragment = (props) => Array.isArray(props.children) ? props.children : [props.children];
+export function render(node, parent) {
+    parent.innerHTML = '';
+    parent.appendChild(toDOM(node));
+}
+function toDOM(node) {
+    if (node === null || node === undefined) {
+        return document.createTextNode('');
+    }
+    if (typeof node === 'string' || typeof node === 'number') {
+        return document.createTextNode(String(node));
+    }
+    if (Array.isArray(node)) {
+        const frag = document.createDocumentFragment();
+        node.forEach(child => frag.appendChild(toDOM(child)));
+        return frag;
+    }
+    // Debug: log VNode type
+    if (node.type === '__lazy_ondemand_pending__') {
+        // console.trace( '[DEBUG] toDOM processing __lazy_ondemand_pending__' );
+    }
+    // Handle Suspense boundary
+    if (node.type === '__suspense__') {
+        const { fallback, children } = node.props;
+        const pending = findLazyPending(children);
+        if (pending.length === 0) {
+            return toDOM(children);
+        }
+        const container = document.createElement('div');
+        container.setAttribute('data-cathode-suspense', 'true');
+        container.appendChild(toDOM(fallback));
+        Promise.all(pending.map(lc => lc.awake())).then(() => {
+            const content = toDOM(children);
+            container.innerHTML = '';
+            container.appendChild(content);
+        });
+        return container;
+    }
+    // Handle lazy pending marker
+    if (node.type === '__lazy_pending__') {
+        const { wrapper, componentProps } = node.props;
+        const placeholder = document.createElement('div');
+        placeholder.setAttribute('data-cathode-lazy', 'pending');
+        wrapper.awake().then(() => {
+            if (wrapper.__status === 'resolved') {
+                const resolved = toDOM(h(wrapper.__component, componentProps));
+                placeholder.replaceWith(resolved);
+            }
+        });
+        return placeholder;
+    }
+    // Handle lazy ondemand pending marker
+    if (node.type === '__lazy_ondemand_pending__') {
+        const { wrapper, componentProps } = node.props;
+        const placeholder = document.createElement('div');
+        placeholder.setAttribute('data-cathode-lazy', 'ondemand-pending');
+        placeholder.style.display = 'none';
+        // Store reference for manual re-render after load
+        placeholder.__lazyComponent = wrapper;
+        placeholder.__componentProps = componentProps;
+        // Set up a mechanism to watch for when awake() is called
+        // console.trace( '[lazy ondemand] Created placeholder, status:', wrapper.__status, 'has promise:', !!wrapper.__promise );
+        let stopPolling = false;
+        let pollCount = 0;
+        const checkAndRender = () => {
+            pollCount++;
+            // Stop if placeholder is no longer in the document
+            if (stopPolling) {
+                // console.trace( '[lazy ondemand] Stopped polling, stopPolling:', stopPolling );
+                return;
+            }
+            // Wait for element to be connected before checking
+            if (!placeholder.isConnected) {
+                if (pollCount % 10 === 0) {
+                    // console.trace( '[lazy ondemand] Waiting for connection...', pollCount );
+                }
+                setTimeout(checkAndRender, 100);
+                return;
+            }
+            if (wrapper.__promise) {
+                // console.trace( '[lazy ondemand] Found promise after', pollCount, 'polls, status:', wrapper.__status );
+                stopPolling = true; // Stop polling once we find the promise
+                wrapper.__promise.then(() => {
+                    // console.trace( '[lazy ondemand] Component loaded:', wrapper.__component?.name, 'status:', wrapper.__status, 'connected:', placeholder.isConnected );
+                    if (wrapper.__status === 'resolved' && placeholder.isConnected) {
+                        const resolved = toDOM(h(wrapper.__component, componentProps));
+                        // console.trace( '[lazy ondemand] Replacing placeholder with resolved component' );
+                        placeholder.replaceWith(resolved);
+                    }
+                });
+            }
+            else {
+                if (pollCount % 10 === 0) {
+                    // console.trace( '[lazy ondemand] Still polling...', pollCount, 'status:', wrapper.__status );
+                }
+                // Check again after a short delay
+                setTimeout(checkAndRender, 100);
+            }
+        };
+        // Start checking after a small delay to allow DOM connection
+        setTimeout(checkAndRender, 0);
+        return placeholder;
+    }
+    // Handle lazy onvisible marker
+    if (node.type === '__lazy_onvisible__') {
+        const { component, componentProps, fallback, observerOptions } = node.props;
+        const container = document.createElement('div');
+        container.setAttribute('data-cathode-lazy', 'onvisible');
+        if (fallback) {
+            container.appendChild(toDOM(fallback));
+        }
+        if (typeof IntersectionObserver !== 'undefined') {
+            const observer = new IntersectionObserver((entries) => {
+                entries.forEach((entry) => {
+                    if (entry.isIntersecting) {
+                        component.awake().then(() => {
+                            if (component.__status === 'resolved') {
+                                const resolved = toDOM(h(component, componentProps));
+                                container.innerHTML = '';
+                                container.appendChild(resolved);
+                            }
+                        });
+                        observer.disconnect();
+                    }
+                });
+            }, observerOptions);
+            observer.observe(container);
+        }
+        else {
+            // SSR or old browser fallback
+            component.awake();
+        }
+        return container;
+    }
+    // Handle lazy error marker
+    if (node.type === '__lazy_error__') {
+        const errorDiv = document.createElement('div');
+        errorDiv.setAttribute('data-cathode-lazy', 'error');
+        errorDiv.textContent = `Error: ${node.props.error?.message || 'Unknown'}`;
+        return errorDiv;
+    }
+    // Handle error boundary
+    if (node.type === '__error_boundary__') {
+        const { fallback, children } = node.props;
+        try {
+            return toDOM(children);
+        }
+        catch (error) {
+            if (typeof fallback === 'function') {
+                return toDOM(fallback(error));
+            }
+            return toDOM(fallback);
+        }
+    }
+    if (typeof node.type === 'function') {
+        return toDOM(node.type({ ...node.props, children: node.children }));
+    }
+    const el = document.createElement(node.type);
+    const props = node.props || {};
+    Object.entries(props).forEach(([key, value]) => {
+        if (key === 'className') {
+            if (typeof value === 'string') {
+                el.setAttribute('class', value);
+            }
+        }
+        else if (key.startsWith('on') && typeof value === 'function') {
+            el[key.toLowerCase()] = value;
+        }
+        else if (value !== false && value !== null) {
+            el.setAttribute(key, String(value));
+        }
+    });
+    if (node.children) {
+        node.children.forEach((child) => {
+            el.appendChild(toDOM(child));
+        });
+    }
+    return el;
+}
+// Expose globals for JSX pragma usage when bundled.
+if (typeof globalThis !== 'undefined') {
+    globalThis.h = h;
+    globalThis.Fragment = Fragment;
+}

package/lib/suspense.js

@@ -0,0 +1,40 @@
+export function Suspense(props) {
+    return {
+        type: '__suspense__',
+        props: {
+            fallback: props.fallback,
+            children: props.children
+        },
+        children: Array.isArray(props.children) ? props.children : [props.children]
+    };
+}
+export function findLazyPending(node) {
+    if (!node || typeof node === 'string' || typeof node === 'number') {
+        return [];
+    }
+    if (Array.isArray(node)) {
+        return node.flatMap(n => findLazyPending(n));
+    }
+    const vnode = node;
+    // Check if type is a lazy component function (has __lazy marker)
+    if (typeof vnode.type === 'function' && vnode.type.__lazy) {
+        const lazyComp = vnode.type;
+        // Only return if still pending AND (autoLoad OR already manually loading)
+        if (lazyComp.__status === 'pending' && (lazyComp.__autoLoad || lazyComp.__promise)) {
+            return [lazyComp];
+        }
+    }
+    // Also check for already-rendered lazy pending marker
+    if (vnode.type === '__lazy_pending__') {
+        return [vnode.props.wrapper];
+    }
+    // Skip ondemand pending markers (not auto-loading)
+    if (vnode.type === '__lazy_ondemand_pending__') {
+        return [];
+    }
+    // Recurse into children
+    if (vnode.children) {
+        return vnode.children.flatMap(c => findLazyPending(c));
+    }
+    return [];
+}

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "@relicloops/cathode",
+  "version": "2.0.0",
+  "license": "Apache-2.0",
+  "description": "Lightweight JSX runtime.",
+  "type": "module",
+  "main": "index.js",
+  "types": "./types/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./types/index.d.ts",
+      "default": "./index.js"
+    },
+    "./jsx-runtime": {
+      "types": "./types/jsx-runtime.d.ts",
+      "default": "./jsx-runtime.js"
+    },
+    "./jsx-dev-runtime": {
+      "types": "./types/jsx-dev-runtime.d.ts",
+      "default": "./jsx-dev-runtime.js"
+    }
+  },
+  "files": [
+    "index.js",
+    "jsx-runtime.js",
+    "jsx-dev-runtime.js",
+    "lib/**/*.js",
+    "types/**/*.d.ts",
+    "README.md",
+    "LICENSE"
+  ],
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/types/index.d.ts

@@ -0,0 +1,21 @@
+export * from './lib/runtime.js';
+export { inject } from './lib/inject.js';
+export type { InjectMode, InjectOptions } from './lib/inject.js';
+export { eject } from './lib/eject.js';
+export { mount, unmount, cleanup } from './lib/mount.js';
+export type { MountHandle } from './lib/mount.js';
+export { css } from './lib/css.js';
+export type { CSSOptions } from './lib/css.js';
+export { lazy, lazyOnDemand } from './lib/lazy.js';
+export type { ComponentType, LazyComponent } from './lib/lazy.js';
+export { lazyOnHover, lazyAfterDelay, lazyWhenIdle, LazyOnVisible } from './lib/lazy-helpers.js';
+export { Suspense } from './lib/suspense.js';
+export type { SuspenseProps } from './lib/suspense.js';
+export { ErrorBoundary } from './lib/error-boundary.js';
+export type { ErrorBoundaryProps } from './lib/error-boundary.js';
+declare global {
+    namespace JSX {
+        interface IntrinsicElements extends Record<string, any> {
+        }
+    }
+}

package/types/jsx-dev-runtime.d.ts

@@ -0,0 +1 @@
+export * from './jsx-runtime.js';

package/types/jsx-runtime.d.ts

@@ -0,0 +1,17 @@
+import type { VNode } from './lib/runtime.js';
+import { Fragment } from './lib/runtime.js';
+export { Fragment };
+export type { VNode };
+type JSXProps = Record<string, unknown> & {
+    children?: unknown;
+};
+export declare namespace JSX {
+    interface Element extends VNode {
+    }
+    interface IntrinsicElements extends Record<string, any> {
+    }
+}
+export type JSXIntrinsicElements = JSX.IntrinsicElements;
+export declare function jsx(type: VNode['type'], props: JSXProps | null, key?: unknown): JSX.Element;
+export declare const jsxs: typeof jsx;
+export declare const jsxDEV: typeof jsx;

package/types/lib/css.d.ts

@@ -0,0 +1,4 @@
+export interface CSSOptions {
+    inline?: boolean;
+}
+export declare function css(urlOrContent: string, options?: CSSOptions): void;

package/types/lib/eject.d.ts

@@ -0,0 +1 @@
+export declare function eject(parent: HTMLElement): Promise<void>;

package/types/lib/error-boundary.d.ts

@@ -0,0 +1,6 @@
+import type { VNode } from './runtime.js';
+export interface ErrorBoundaryProps {
+    fallback: VNode | string | ((error: Error) => VNode | string);
+    children?: any;
+}
+export declare function ErrorBoundary(props: ErrorBoundaryProps): VNode;

package/types/lib/inject.d.ts

@@ -0,0 +1,5 @@
+export type InjectMode = 'append' | 'prepend' | 'replace';
+export type InjectOptions = {
+    mode?: InjectMode;
+};
+export declare function inject(node: any, parent: HTMLElement, options?: InjectOptions): Promise<void>;

package/types/lib/lazy-helpers.d.ts

@@ -0,0 +1,61 @@
+import type { LazyComponent } from './lazy.js';
+import type { VNode } from './runtime.js';
+/**
+ * Returns event props that trigger lazy loading on hover
+ *
+ * @example
+ * const Dashboard = lazyOnDemand(() => import('./Dashboard.js'));
+ * const hoverProps = lazyOnHover(Dashboard);
+ * <a href="/dashboard" {...hoverProps}>Dashboard</a>
+ */
+export declare function lazyOnHover<P = any>(component: LazyComponent<P>): {
+    onMouseEnter: () => void;
+};
+/**
+ * Triggers lazy loading after a delay
+ *
+ * @param component - The lazy component to load
+ * @param delayMs - Delay in milliseconds before loading
+ * @returns Cleanup function to cancel the timeout
+ *
+ * @example
+ * const Analytics = lazyOnDemand(() => import('./Analytics.js'));
+ * lazyAfterDelay(Analytics, 5000); // Load after 5 seconds
+ */
+export declare function lazyAfterDelay<P = any>(component: LazyComponent<P>, delayMs: number): () => void;
+/**
+ * Triggers lazy loading when the browser is idle
+ *
+ * @param component - The lazy component to load
+ * @param timeout - Maximum time to wait before loading (default: 5000ms)
+ * @returns Cleanup function to cancel the idle callback
+ *
+ * @example
+ * const ChatWidget = lazyOnDemand(() => import('./ChatWidget.js'));
+ * lazyWhenIdle(ChatWidget); // Load when browser idle
+ */
+export declare function lazyWhenIdle<P = any>(component: LazyComponent<P>, timeout?: number): () => void;
+/**
+ * Component wrapper that triggers lazy loading when scrolled into view
+ *
+ * @param props.component - The lazy component to load
+ * @param props.componentProps - Props to pass to the component when loaded
+ * @param props.fallback - Content to show before component is visible
+ * @param props.rootMargin - Margin around root for intersection detection (e.g., "200px")
+ * @param props.threshold - Visibility threshold (0-1) that triggers loading
+ *
+ * @example
+ * const Footer = lazyOnDemand(() => import('./Footer.js'));
+ * <LazyOnVisible
+ *   component={Footer}
+ *   fallback={<div style="height: 200px">Scroll to load footer</div>}
+ *   rootMargin="200px"
+ * />
+ */
+export declare function LazyOnVisible<P = any>(props: {
+    component: LazyComponent<P>;
+    componentProps?: P;
+    fallback?: VNode | string;
+    rootMargin?: string;
+    threshold?: number;
+}): VNode;

package/types/lib/lazy.d.ts

@@ -0,0 +1,20 @@
+import type { VNode } from './runtime.js';
+export type ComponentType<P = any> = (props: P) => VNode | VNode[] | string | number | null | undefined;
+type LazyLoader<P = any> = () => Promise<{
+    default: ComponentType<P>;
+}>;
+export interface LazyComponent<P = any> {
+    (props: P): VNode;
+    __lazy: true;
+    __status: 'pending' | 'resolved' | 'rejected';
+    __component: ComponentType<P> | null;
+    __error: Error | null;
+    __promise: Promise<void> | null;
+    /** @deprecated Use awake() instead. */
+    __load: () => Promise<void>;
+    awake: () => Promise<void>;
+    __autoLoad: boolean;
+}
+export declare function lazy<P = any>(loader: LazyLoader<P>): LazyComponent<P>;
+export declare function lazyOnDemand<P = any>(loader: LazyLoader<P>): LazyComponent<P>;
+export {};

package/types/lib/mount.d.ts

@@ -0,0 +1,7 @@
+export type MountHandle = {
+    unmount: () => Promise<void>;
+    cleanup: () => Promise<void>;
+};
+export declare function mount(node: any, parent: HTMLElement): Promise<MountHandle>;
+export declare function unmount(parent: HTMLElement): Promise<void>;
+export declare function cleanup(parent: HTMLElement): Promise<void>;

package/types/lib/runtime.d.ts

@@ -0,0 +1,10 @@
+export type VNode = {
+    type: string | ((props: any) => VNode | VNode[] | string | number | null | undefined);
+    props: Record<string, any>;
+    children: Array<VNode | string | number | null | undefined>;
+};
+export declare function h(type: VNode['type'], props: Record<string, any> | null, ...children: Array<VNode | string | number | null | undefined>): VNode;
+export declare const Fragment: (props: {
+    children?: any;
+}) => any[];
+export declare function render(node: any, parent: HTMLElement): void;