sibujs 1.0.2 → 1.0.3

package/dist/contracts-CMriKJ6P.d.cts

@@ -1,245 +0,0 @@
-/**
- * Higher-order component utilities for SibuJS.
- * These functions wrap or compose components to add behavior.
- */
-type Component<P = unknown> = (props: P) => HTMLElement;
-/**
- * Wraps a component with additional behavior that runs before/after rendering.
- *
- * @param WrappedComponent The component to wrap
- * @param wrapper Function that receives the component and its props, returns enhanced element
- * @returns A new component function
- *
- * @example
- * ```ts
- * const WithLogging = sbWithWrapper(MyComponent, (Comp, props) => {
- *   console.log("Rendering with props:", props);
- *   return Comp(props);
- * });
- * ```
- */
-declare function sbWithWrapper<P>(WrappedComponent: Component<P>, wrapper: (component: Component<P>, props: P) => HTMLElement): Component<P>;
-/**
- * Adds default props to a component. Missing props are filled from defaults.
- *
- * @param component The component to wrap
- * @param defaults Default prop values
- * @returns A new component with defaults applied
- *
- * @example
- * ```ts
- * const Button = sbWithDefaults(RawButton, { type: "button", disabled: false });
- * Button({ nodes: "Click" }); // type="button", disabled=false automatically
- * ```
- */
-declare function sbWithDefaults<P extends Record<string, unknown>>(component: Component<P>, defaults: Partial<P>): Component<Partial<P>>;
-/**
- * Composes multiple HOC wrappers into a single wrapper.
- * Applied from right to left (like function composition).
- *
- * @param wrappers Array of HOC functions
- * @returns A function that applies all wrappers to a component
- *
- * @example
- * ```ts
- * const enhance = sbCompose(withAuth, withLogging, withTheme);
- * const EnhancedPage = enhance(Page);
- * ```
- */
-declare function sbCompose(...wrappers: Array<(component: Component) => Component>): (component: Component) => Component;
-
-/**
- * sbComposable wraps a setup function to create reusable stateful logic.
- * Similar to Vue 3 composables — encapsulates reactive state and methods.
- */
-declare function sbComposable<T>(setup: () => T): () => T;
-/**
- * RenderProp implements the render-prop pattern.
- * The render function receives data and returns DOM nodes.
- */
-declare function RenderProp<T>(props: {
-    data: () => T;
-    render: (data: T) => HTMLElement;
-}): HTMLElement;
-/**
- * sbWithBoundary creates an isolated component boundary for debugging.
- * Wraps component output in a named container with error isolation.
- */
-declare function sbWithBoundary(name: string, component: (props?: unknown) => HTMLElement): (props?: unknown) => HTMLElement;
-/**
- * Slot pattern — provides named slots for component composition.
- */
-declare function sbCreateSlots(slots: Record<string, () => HTMLElement | HTMLElement[] | null>): {
-    renderSlot: (name: string, fallback?: () => HTMLElement) => HTMLElement | null;
-    hasSlot: (name: string) => boolean;
-};
-
-/**
- * React-style functional component props with TypeScript inference for SibuJS.
- *
- * Provides utilities to define typed components with prop defaults,
- * nodes slots, and prop mapping — all with full TypeScript inference.
- */
-/**
- * Extract the props type from a component defined with sbDefineComponent.
- *
- * @example
- * ```ts
- * const Button = sbDefineComponent<{ label: string }>({
- *   setup(props) { ... }
- * });
- * type ButtonProps = ComponentProps<typeof Button>; // { label: string }
- * ```
- */
-type ComponentProps<T> = T extends (props: infer P) => HTMLElement ? P : never;
-/**
- * Props that include an optional nodes slot.
- */
-type WithNodes<Props> = Props & {
-    nodes?: Node | Node[];
-};
-/**
- * Define a typed component with props inference, defaults, and a setup function.
- *
- * The `setup` function receives merged props (defaults + provided) and must
- * return an HTMLElement. TypeScript infers the full props type from the generic.
- *
- * @param config Component configuration with optional defaults and a setup function
- * @returns A component function that accepts props and returns an HTMLElement
- *
- * @example
- * ```ts
- * const Button = sbDefineComponent<{ label: string; variant?: 'primary' | 'secondary'; disabled?: boolean }>({
- *   defaults: { variant: 'primary', disabled: false },
- *   setup(props) {
- *     return button({
- *       class: `btn btn-${props.variant}`,
- *       disabled: props.disabled,
- *       nodes: props.label
- *     });
- *   }
- * });
- *
- * // Usage: Button({ label: 'Click me' }) — TypeScript infers props
- * ```
- */
-declare function sbDefineComponent<Props extends Record<string, unknown>>(config: {
-    defaults?: Partial<Props>;
-    setup: (props: Props) => HTMLElement;
-}): (props: Props) => HTMLElement;
-/**
- * Create a component with nodes slot support.
- *
- * Nodes are passed as a special `nodes` prop alongside the component's
- * own props. This enables composition patterns where a parent component
- * wraps arbitrary child content.
- *
- * @param config Component configuration with optional defaults and a setup function
- * @returns A component function that accepts props (including nodes) and returns an HTMLElement
- *
- * @example
- * ```ts
- * const Card = sbDefineSlottedComponent<{ title: string }>({
- *   setup(props) {
- *     const el = div({ class: 'card' });
- *     el.appendChild(h2({ nodes: props.title }));
- *     if (props.nodes) {
- *       const nodes = Array.isArray(props.nodes) ? props.nodes : [props.nodes];
- *       nodes.forEach(child => el.appendChild(child));
- *     }
- *     return el;
- *   }
- * });
- *
- * // Usage: Card({ title: 'Hello', nodes: p({ nodes: 'World' }) })
- * ```
- */
-declare function sbDefineSlottedComponent<Props extends Record<string, unknown>>(config: {
-    defaults?: Partial<Props>;
-    setup: (props: WithNodes<Props>) => HTMLElement;
-}): (props: WithNodes<Props>) => HTMLElement;
-/**
- * Higher-order helper to create a component that maps outer props to inner props.
- *
- * Useful for adapting a generic component to a specific use case by transforming
- * the prop interface without modifying the original component.
- *
- * @param component The inner component to forward mapped props to
- * @param mapProps A function that transforms outer props into inner props
- * @returns A new component that accepts outer props
- *
- * @example
- * ```ts
- * const IconButton = sbDefineComponent<{ icon: string; label: string; size: number }>({
- *   setup(props) { ... }
- * });
- *
- * const SmallIconButton = sbWithProps(IconButton, (outer: { icon: string; label: string }) => ({
- *   icon: outer.icon,
- *   label: outer.label,
- *   size: 16
- * }));
- *
- * // Usage: SmallIconButton({ icon: 'star', label: 'Favorite' })
- * ```
- */
-declare function sbWithProps<OuterProps extends Record<string, unknown>, InnerProps extends Record<string, unknown>>(component: (props: InnerProps) => HTMLElement, mapProps: (outer: OuterProps) => InnerProps): (props: OuterProps) => HTMLElement;
-
-/**
- * Runtime prop validation and strict typing contracts for SibuJS.
- * Provides runtime type checking for component props in development mode.
- */
-/** Validator function: returns true if valid, or an error message string. */
-type Validator<T = unknown> = (value: T, propName: string) => true | string;
-/** Built-in validators */
-declare const validators: {
-    string: Validator;
-    number: Validator;
-    boolean: Validator;
-    function: Validator;
-    object: Validator;
-    array: Validator;
-    required: Validator;
-    oneOf: <T>(...values: T[]) => Validator<T>;
-    instanceOf: <T>(ctor: new (...args: unknown[]) => T) => Validator<T>;
-    arrayOf: (itemValidator: Validator) => Validator<unknown[]>;
-    shape: (schema: Record<string, Validator>) => Validator<Record<string, unknown>>;
-    optional: (validator: Validator) => Validator;
-    range: (min: number, max: number) => Validator<number>;
-    pattern: (regex: RegExp) => Validator<string>;
-};
-interface PropDef<T = unknown> {
-    type?: Validator<T>;
-    required?: boolean;
-    default?: T | (() => T);
-    validator?: Validator<T>;
-}
-type PropSchema<Props> = {
-    [K in keyof Props]: PropDef<Props[K]> | Validator<Props[K]>;
-};
-/**
- * Validate props against a schema. Returns validated props with defaults applied.
- * In production mode (process.env.NODE_ENV === 'production'), validation is skipped
- * and only defaults are applied for performance.
- */
-declare function sbValidateProps<Props extends Record<string, unknown>>(props: Partial<Props>, schema: PropSchema<Props>): Props;
-/**
- * Define a component with runtime prop validation.
- * Validates props in development mode, applies defaults, then calls setup.
- */
-declare function sbDefineStrictComponent<Props extends Record<string, unknown>>(config: {
-    name: string;
-    props: PropSchema<Props>;
-    setup: (props: Props) => HTMLElement;
-}): (props: Partial<Props>) => HTMLElement;
-/**
- * Assert that a value satisfies a contract at runtime.
- * No-op in production builds.
- */
-declare function sbAssertType<T>(value: unknown, validator: Validator<T>, label?: string): asserts value is T;
-/**
- * Create a type guard function from a validator.
- */
-declare function sbCreateGuard<T>(validator: Validator<T>): (value: unknown) => value is T;
-
-export { type ComponentProps as C, type PropDef as P, RenderProp as R, type Validator as V, type PropSchema as a, sbComposable as b, sbCompose as c, sbCreateGuard as d, sbCreateSlots as e, sbDefineComponent as f, sbDefineSlottedComponent as g, sbDefineStrictComponent as h, sbValidateProps as i, sbWithBoundary as j, sbWithDefaults as k, sbWithProps as l, sbWithWrapper as m, sbAssertType as s, validators as v };

package/dist/contracts-CMriKJ6P.d.ts

@@ -1,245 +0,0 @@
-/**
- * Higher-order component utilities for SibuJS.
- * These functions wrap or compose components to add behavior.
- */
-type Component<P = unknown> = (props: P) => HTMLElement;
-/**
- * Wraps a component with additional behavior that runs before/after rendering.
- *
- * @param WrappedComponent The component to wrap
- * @param wrapper Function that receives the component and its props, returns enhanced element
- * @returns A new component function
- *
- * @example
- * ```ts
- * const WithLogging = sbWithWrapper(MyComponent, (Comp, props) => {
- *   console.log("Rendering with props:", props);
- *   return Comp(props);
- * });
- * ```
- */
-declare function sbWithWrapper<P>(WrappedComponent: Component<P>, wrapper: (component: Component<P>, props: P) => HTMLElement): Component<P>;
-/**
- * Adds default props to a component. Missing props are filled from defaults.
- *
- * @param component The component to wrap
- * @param defaults Default prop values
- * @returns A new component with defaults applied
- *
- * @example
- * ```ts
- * const Button = sbWithDefaults(RawButton, { type: "button", disabled: false });
- * Button({ nodes: "Click" }); // type="button", disabled=false automatically
- * ```
- */
-declare function sbWithDefaults<P extends Record<string, unknown>>(component: Component<P>, defaults: Partial<P>): Component<Partial<P>>;
-/**
- * Composes multiple HOC wrappers into a single wrapper.
- * Applied from right to left (like function composition).
- *
- * @param wrappers Array of HOC functions
- * @returns A function that applies all wrappers to a component
- *
- * @example
- * ```ts
- * const enhance = sbCompose(withAuth, withLogging, withTheme);
- * const EnhancedPage = enhance(Page);
- * ```
- */
-declare function sbCompose(...wrappers: Array<(component: Component) => Component>): (component: Component) => Component;
-
-/**
- * sbComposable wraps a setup function to create reusable stateful logic.
- * Similar to Vue 3 composables — encapsulates reactive state and methods.
- */
-declare function sbComposable<T>(setup: () => T): () => T;
-/**
- * RenderProp implements the render-prop pattern.
- * The render function receives data and returns DOM nodes.
- */
-declare function RenderProp<T>(props: {
-    data: () => T;
-    render: (data: T) => HTMLElement;
-}): HTMLElement;
-/**
- * sbWithBoundary creates an isolated component boundary for debugging.
- * Wraps component output in a named container with error isolation.
- */
-declare function sbWithBoundary(name: string, component: (props?: unknown) => HTMLElement): (props?: unknown) => HTMLElement;
-/**
- * Slot pattern — provides named slots for component composition.
- */
-declare function sbCreateSlots(slots: Record<string, () => HTMLElement | HTMLElement[] | null>): {
-    renderSlot: (name: string, fallback?: () => HTMLElement) => HTMLElement | null;
-    hasSlot: (name: string) => boolean;
-};
-
-/**
- * React-style functional component props with TypeScript inference for SibuJS.
- *
- * Provides utilities to define typed components with prop defaults,
- * nodes slots, and prop mapping — all with full TypeScript inference.
- */
-/**
- * Extract the props type from a component defined with sbDefineComponent.
- *
- * @example
- * ```ts
- * const Button = sbDefineComponent<{ label: string }>({
- *   setup(props) { ... }
- * });
- * type ButtonProps = ComponentProps<typeof Button>; // { label: string }
- * ```
- */
-type ComponentProps<T> = T extends (props: infer P) => HTMLElement ? P : never;
-/**
- * Props that include an optional nodes slot.
- */
-type WithNodes<Props> = Props & {
-    nodes?: Node | Node[];
-};
-/**
- * Define a typed component with props inference, defaults, and a setup function.
- *
- * The `setup` function receives merged props (defaults + provided) and must
- * return an HTMLElement. TypeScript infers the full props type from the generic.
- *
- * @param config Component configuration with optional defaults and a setup function
- * @returns A component function that accepts props and returns an HTMLElement
- *
- * @example
- * ```ts
- * const Button = sbDefineComponent<{ label: string; variant?: 'primary' | 'secondary'; disabled?: boolean }>({
- *   defaults: { variant: 'primary', disabled: false },
- *   setup(props) {
- *     return button({
- *       class: `btn btn-${props.variant}`,
- *       disabled: props.disabled,
- *       nodes: props.label
- *     });
- *   }
- * });
- *
- * // Usage: Button({ label: 'Click me' }) — TypeScript infers props
- * ```
- */
-declare function sbDefineComponent<Props extends Record<string, unknown>>(config: {
-    defaults?: Partial<Props>;
-    setup: (props: Props) => HTMLElement;
-}): (props: Props) => HTMLElement;
-/**
- * Create a component with nodes slot support.
- *
- * Nodes are passed as a special `nodes` prop alongside the component's
- * own props. This enables composition patterns where a parent component
- * wraps arbitrary child content.
- *
- * @param config Component configuration with optional defaults and a setup function
- * @returns A component function that accepts props (including nodes) and returns an HTMLElement
- *
- * @example
- * ```ts
- * const Card = sbDefineSlottedComponent<{ title: string }>({
- *   setup(props) {
- *     const el = div({ class: 'card' });
- *     el.appendChild(h2({ nodes: props.title }));
- *     if (props.nodes) {
- *       const nodes = Array.isArray(props.nodes) ? props.nodes : [props.nodes];
- *       nodes.forEach(child => el.appendChild(child));
- *     }
- *     return el;
- *   }
- * });
- *
- * // Usage: Card({ title: 'Hello', nodes: p({ nodes: 'World' }) })
- * ```
- */
-declare function sbDefineSlottedComponent<Props extends Record<string, unknown>>(config: {
-    defaults?: Partial<Props>;
-    setup: (props: WithNodes<Props>) => HTMLElement;
-}): (props: WithNodes<Props>) => HTMLElement;
-/**
- * Higher-order helper to create a component that maps outer props to inner props.
- *
- * Useful for adapting a generic component to a specific use case by transforming
- * the prop interface without modifying the original component.
- *
- * @param component The inner component to forward mapped props to
- * @param mapProps A function that transforms outer props into inner props
- * @returns A new component that accepts outer props
- *
- * @example
- * ```ts
- * const IconButton = sbDefineComponent<{ icon: string; label: string; size: number }>({
- *   setup(props) { ... }
- * });
- *
- * const SmallIconButton = sbWithProps(IconButton, (outer: { icon: string; label: string }) => ({
- *   icon: outer.icon,
- *   label: outer.label,
- *   size: 16
- * }));
- *
- * // Usage: SmallIconButton({ icon: 'star', label: 'Favorite' })
- * ```
- */
-declare function sbWithProps<OuterProps extends Record<string, unknown>, InnerProps extends Record<string, unknown>>(component: (props: InnerProps) => HTMLElement, mapProps: (outer: OuterProps) => InnerProps): (props: OuterProps) => HTMLElement;
-
-/**
- * Runtime prop validation and strict typing contracts for SibuJS.
- * Provides runtime type checking for component props in development mode.
- */
-/** Validator function: returns true if valid, or an error message string. */
-type Validator<T = unknown> = (value: T, propName: string) => true | string;
-/** Built-in validators */
-declare const validators: {
-    string: Validator;
-    number: Validator;
-    boolean: Validator;
-    function: Validator;
-    object: Validator;
-    array: Validator;
-    required: Validator;
-    oneOf: <T>(...values: T[]) => Validator<T>;
-    instanceOf: <T>(ctor: new (...args: unknown[]) => T) => Validator<T>;
-    arrayOf: (itemValidator: Validator) => Validator<unknown[]>;
-    shape: (schema: Record<string, Validator>) => Validator<Record<string, unknown>>;
-    optional: (validator: Validator) => Validator;
-    range: (min: number, max: number) => Validator<number>;
-    pattern: (regex: RegExp) => Validator<string>;
-};
-interface PropDef<T = unknown> {
-    type?: Validator<T>;
-    required?: boolean;
-    default?: T | (() => T);
-    validator?: Validator<T>;
-}
-type PropSchema<Props> = {
-    [K in keyof Props]: PropDef<Props[K]> | Validator<Props[K]>;
-};
-/**
- * Validate props against a schema. Returns validated props with defaults applied.
- * In production mode (process.env.NODE_ENV === 'production'), validation is skipped
- * and only defaults are applied for performance.
- */
-declare function sbValidateProps<Props extends Record<string, unknown>>(props: Partial<Props>, schema: PropSchema<Props>): Props;
-/**
- * Define a component with runtime prop validation.
- * Validates props in development mode, applies defaults, then calls setup.
- */
-declare function sbDefineStrictComponent<Props extends Record<string, unknown>>(config: {
-    name: string;
-    props: PropSchema<Props>;
-    setup: (props: Props) => HTMLElement;
-}): (props: Partial<Props>) => HTMLElement;
-/**
- * Assert that a value satisfies a contract at runtime.
- * No-op in production builds.
- */
-declare function sbAssertType<T>(value: unknown, validator: Validator<T>, label?: string): asserts value is T;
-/**
- * Create a type guard function from a validator.
- */
-declare function sbCreateGuard<T>(validator: Validator<T>): (value: unknown) => value is T;
-
-export { type ComponentProps as C, type PropDef as P, RenderProp as R, type Validator as V, type PropSchema as a, sbComposable as b, sbCompose as c, sbCreateGuard as d, sbCreateSlots as e, sbDefineComponent as f, sbDefineSlottedComponent as g, sbDefineStrictComponent as h, sbValidateProps as i, sbWithBoundary as j, sbWithDefaults as k, sbWithProps as l, sbWithWrapper as m, sbAssertType as s, validators as v };

package/dist/src/components/ErrorBoundary.d.ts

@@ -1,15 +0,0 @@
-export interface ErrorBoundaryProps {
-    /**
-     * Function that renders child content or throws.
-     */
-    children: () => HTMLElement;
-    /**
-     * Fallback renderer given an Error and optional retry callback.
-     */
-    fallback?: (error: Error, retry?: () => void) => HTMLElement;
-}
-/**
- * ErrorBoundary component using SibuJS reactive pattern.
- * Catches errors from children and displays fallback UI with retry functionality.
- */
-export declare function ErrorBoundary({ children, fallback }: ErrorBoundaryProps): HTMLElement;

package/dist/src/components/ErrorBoundary.js

@@ -1,119 +0,0 @@
-import { useState } from "../core/useState";
-import { div, h3, p, button, style } from "../core/html";
-// CSS styles for ErrorBoundary
-const errorBoundaryStyles = `
-  .error-fallback {
-    border: 2px solid #dc3545;
-    border-radius: 8px;
-    padding: 20px;
-    margin: 10px 0;
-    background-color: #ffebee;
-    box-shadow: 0 2px 8px rgba(220, 53, 69, 0.2);
-  }
-
-  .error-fallback .section-title {
-    margin: 0 0 15px 0;
-    color: #dc3545;
-    font-size: 1.2em;
-    font-weight: bold;
-  }
-
-  .error-fallback .text-mono {
-    font-family: 'Courier New', 'Monaco', 'Menlo', monospace;
-    background-color: #f8f9fa;
-    padding: 8px 12px;
-    border-radius: 4px;
-    border: 1px solid #e9ecef;
-    margin: 10px 0;
-    color: #495057;
-    word-break: break-word;
-  }
-
-  .error-fallback .btn {
-    display: inline-block;
-    padding: 8px 16px;
-    border: none;
-    border-radius: 4px;
-    cursor: pointer;
-    font-size: 14px;
-    font-weight: 500;
-    text-decoration: none;
-    transition: all 0.2s ease;
-    margin: 4px 0;
-  }
-
-  .error-fallback .btn:hover {
-    transform: translateY(-1px);
-    box-shadow: 0 2px 4px rgba(0, 0, 0, 0.2);
-  }
-
-  .error-fallback .btn:active {
-    transform: translateY(0);
-    box-shadow: 0 1px 2px rgba(0, 0, 0, 0.2);
-  }
-
-  .error-fallback .btn-danger {
-    background-color: #dc3545;
-    color: white;
-  }
-
-  .error-fallback .btn-danger:hover {
-    background-color: #c82333;
-  }
-`;
-// Inject styles only once
-let stylesInjected = false;
-function injectStyles() {
-    if (!stylesInjected) {
-        const styleElement = style({ children: errorBoundaryStyles });
-        document.head.appendChild(styleElement);
-        stylesInjected = true;
-    }
-}
-/**
- * ErrorBoundary component using SibuJS reactive pattern.
- * Catches errors from children and displays fallback UI with retry functionality.
- */
-export function ErrorBoundary({ children, fallback }) {
-    // Inject styles when component is used
-    injectStyles();
-    const [error, setError] = useState(null);
-    const retry = () => setError(null);
-    // Default fallback with built-in styling
-    const defaultFallback = (error, retry) => div({
-        class: "error-fallback",
-        children: [
-            h3({
-                children: "🚨 Something went wrong!",
-                class: "section-title"
-            }),
-            p({
-                children: `Error: ${error.message}`,
-                class: "text-mono"
-            }),
-            retry ? button({
-                children: "🔄 Try Again",
-                class: "btn btn-danger",
-                on: { click: retry }
-            }) : null
-        ].filter(Boolean)
-    });
-    return div({
-        children: () => {
-            const currentError = error();
-            if (currentError) {
-                return fallback ? fallback(currentError, retry) : defaultFallback(currentError, retry);
-            }
-            try {
-                return children();
-            }
-            catch (e) {
-                const errorObj = e instanceof Error ? e : new Error(String(e));
-                // Set error state and let next render cycle show the fallback
-                setError(errorObj);
-                // Return fallback immediately instead of temporary message
-                return fallback ? fallback(errorObj, retry) : defaultFallback(errorObj, retry);
-            }
-        }
-    });
-}

package/dist/src/core/catch.d.ts

@@ -1,11 +0,0 @@
-type ErrorHandler = (error: unknown, context?: any) => void;
-/**
- * Wraps any function in a try/catch block and optionally passes error to a handler.
- * This is used internally by components or boundaries.
- */
-export declare function catchError(fn: () => any, onError?: ErrorHandler): any;
-/**
- * Sets a global error handler used by default if no onError is provided.
- */
-export declare function setGlobalErrorHandler(handler: ErrorHandler): void;
-export {};

package/dist/src/core/catch.js

@@ -1,28 +0,0 @@
-let globalErrorHandler = null;
-/**
- * Wraps any function in a try/catch block and optionally passes error to a handler.
- * This is used internally by components or boundaries.
- */
-export function catchError(fn, onError) {
-    try {
-        return fn();
-    }
-    catch (err) {
-        if (onError) {
-            onError(err);
-        }
-        else if (globalErrorHandler) {
-            globalErrorHandler(err);
-        }
-        else {
-            console.error("Unhandled error in Sibu.catch:", err);
-        }
-        return null;
-    }
-}
-/**
- * Sets a global error handler used by default if no onError is provided.
- */
-export function setGlobalErrorHandler(handler) {
-    globalErrorHandler = handler;
-}

package/dist/src/core/each.d.ts

@@ -1,13 +0,0 @@
-import { NodeChild } from "./types";
-/**
- * Renders a list of nodes efficiently with key-based diffing.
- * Only removes nodes whose keys are absent, reuses existing nodes, and orders them.
- *
- * @param getArray A reactive getter returning an array.
- * @param render A function that returns a NodeChild for each item.
- * @param options A key function for unique identity of items.
- * @returns A Comment node serving as the anchor for the list.
- */
-export declare function each<T>(getArray: () => T[], render: (item: T, index: number) => NodeChild, options: {
-    key: (item: T) => string | number;
-}): Comment;