@manyducks.co/dolla 2.0.0-alpha.2 → 2.0.0-alpha.21

package/dist/jsx-dev-runtime.js

@@ -1,5 +1,5 @@
-import { r as s } from "./passthrough-DrtCifRF.js";
-import { P as m } from "./passthrough-DrtCifRF.js";
+import { s } from "./passthrough-6Lrg96Id.js";
+import { P as m } from "./passthrough-6Lrg96Id.js";
 function d(n, r, t, e, a, l) {
   const i = { ...o(["children", "key"], r) }, c = Array.isArray(r.children) ? r.children : [r.children];
   return s(n, i, ...c);

package/dist/jsx-runtime.js

@@ -1,5 +1,5 @@
-import { r as t } from "./passthrough-DrtCifRF.js";
-import { P as l } from "./passthrough-DrtCifRF.js";
+import { s as t } from "./passthrough-6Lrg96Id.js";
+import { P as l } from "./passthrough-6Lrg96Id.js";
 function d(n, e, r) {
   return t(n, e ? { ...u(["children", "key"], e) } : void 0, e.children);
 }

package/dist/markup.d.ts

@@ -1,57 +1,78 @@
 import type { Dolla } from "./modules/dolla.js";
-import { MaybeSignal, type Signal } from "./signals.js";
+import { MaybeState, type State } from "./state.js";
 import type { Renderable, Stringable } from "./types.js";
-import { type ViewFunction, type ViewContext, type ViewResult } from "./view.js";
+import { type ViewContext, type ViewFunction, type ViewResult } from "./view.js";
 export interface ElementContext {
     /**
      * The root Dolla instance this element belongs to.
      */
     root: Dolla;
+    /**
+     * Storage for context variables.
+     */
+    data: Record<string | symbol, unknown>;
+    /**
+     * A reference to the parent context.
+     */
+    parent?: ElementContext;
     /**
      * Whether to create DOM nodes in the SVG namespace. An `<svg>` element will set this to true and pass it down to children.
      */
     isSVG?: boolean;
 }
 /**
- * Markup is a set of element metadata that hasn't been constructed into a MarkupNode yet.
+ * Markup is a set of element metadata that hasn't been constructed into a MarkupElement yet.
  */
 export interface Markup {
+    /**
+     * In the case of a view, type will be the View function itself. It can also hold an identifier for special nodes like "$cond", "$repeat", etc.
+     * DOM nodes can be created by name, such as HTML elements like "div", "ul" or "span", SVG elements like ""
+     */
     type: string | ViewFunction<any>;
+    /**
+     * Data that will be passed to a new MarkupElement instance when it is constructed.
+     */
     props?: Record<string, any>;
+    /**
+     *
+     */
     children?: Markup[];
 }
 /**
  * A DOM node that has been constructed from a Markup object.
  */
-export interface MarkupNode {
+export interface MarkupElement {
     readonly node?: Node;
     readonly isMounted: boolean;
     mount(parent: Node, after?: Node): void;
-    unmount(): void;
+    /**
+     * Disconnect from the DOM and clean up. If parentIsUnmounting, DOM operations are skipped.
+     */
+    unmount(parentIsUnmounting?: boolean): void;
 }
 export declare function isMarkup(value: unknown): value is Markup;
-export declare function isNode(value: unknown): value is MarkupNode;
+export declare function isMarkupElement(value: unknown): value is MarkupElement;
 export declare function toMarkup(renderables: Renderable | Renderable[]): Markup[];
 export interface MarkupAttributes {
     $text: {
-        value: MaybeSignal<Stringable>;
+        value: MaybeState<Stringable>;
     };
     $cond: {
-        $predicate: Signal<any>;
+        $predicate: State<any>;
         thenContent?: Renderable;
         elseContent?: Renderable;
     };
     $repeat: {
-        $items: Signal<any[]>;
+        $items: State<any[]>;
         keyFn: (value: any, index: number) => string | number | symbol;
-        renderFn: ($item: Signal<any>, $index: Signal<number>, c: ViewContext) => ViewResult;
+        renderFn: ($item: State<any>, $index: State<number>, c: ViewContext) => ViewResult;
     };
     $observer: {
-        signals: Signal<any>[];
+        states: State<any>[];
         renderFn: (...items: any) => Renderable;
     };
     $outlet: {
-        $children: Signal<MarkupNode[]>;
+        $children: State<MarkupElement[]>;
     };
     $node: {
         value: Node;
@@ -71,30 +92,22 @@ export declare const html: (strings: TemplateStringsArray, ...values: any[]) =>
 /**
  * Displays content conditionally. When `predicate` holds a truthy value, `thenContent` is displayed; when `predicate` holds a falsy value, `elseContent` is displayed.
  */
-export declare function cond(predicate: MaybeSignal<any>, thenContent?: Renderable, elseContent?: Renderable): Markup;
+export declare function cond(predicate: MaybeState<any>, thenContent?: Renderable, elseContent?: Renderable): Markup;
 /**
  * Calls `renderFn` for each item in `items`. Dynamically adds and removes views as items change.
  * The result of `keyFn` is used to compare items and decide if item was added, removed or updated.
  */
-export declare function repeat<T>(items: MaybeSignal<T[]>, keyFn: (value: T, index: number) => string | number | symbol, renderFn: ($value: Signal<T>, $index: Signal<number>, ctx: ViewContext) => ViewResult): Markup;
+export declare function repeat<T>(items: MaybeState<T[]>, keyFn: (value: T, index: number) => string | number | symbol, renderFn: ($value: State<T>, $index: State<number>, ctx: ViewContext) => ViewResult): Markup;
 /**
  * Render `content` into a `parent` node anywhere in the page, rather than at its position in the view.
  */
 export declare function portal(parent: Node, content: Renderable): Markup;
 /**
- * A special kind of signal exclusively for storing references to DOM nodes.
- */
-export declare function createRef<T extends Node>(): Ref<T>;
-export declare function isRef<T extends Node>(value: any): value is Ref<T>;
-export interface Ref<T extends Node> extends Signal<T | undefined> {
-    node: T | undefined;
-}
-/**
- * Construct Markup metadata into a set of MarkupNodes.
+ * Construct Markup metadata into a set of MarkupElements.
  */
-export declare function constructMarkup(elementContext: ElementContext, markup: Markup | Markup[]): MarkupNode[];
+export declare function constructMarkup(elementContext: ElementContext, markup: Markup | Markup[]): MarkupElement[];
 /**
- * Combines one or more MarkupNodes into a single MarkupNode.
+ * Combines one or more MarkupElements into a single MarkupElement.
  */
-export declare function mergeNodes(nodes: MarkupNode[]): MarkupNode;
+export declare function groupElements(nodes: MarkupElement[]): MarkupElement;
 export declare function isRenderable(value: unknown): value is Renderable;

package/dist/modules/dolla.d.ts

@@ -1,9 +1,9 @@
-import { createRef, isRef, MarkupNode, type Markup } from "../markup.js";
-import { createSettableSignal, createSignal, derive, designalify, signalify, toSettableSignal, watch, type Signal } from "../signals.js";
-import { type ViewFunction, type ViewNode } from "../view.js";
+import { type Markup, type MarkupElement } from "../markup.js";
+import { createRef, createSettableState, createState, createWatcher, derive, isRef, toSettableState, toState, valueOf } from "../state.js";
+import { type ViewElement, type ViewFunction } from "../view.js";
 import { type CrashViewProps } from "../views/default-crash-view.js";
 import { HTTP } from "./http.js";
-import { Language } from "./language.js";
+import { I18n } from "./i18n.js";
 import { Render } from "./render.js";
 import { Router } from "./router.js";
 export type Environment = "development" | "production";
@@ -22,6 +22,7 @@ export interface Logger {
     warn(...args: any[]): void;
     error(...args: any[]): void;
     crash(error: Error): void;
+    setName(name: string): Logger;
 }
 export interface LoggerErrorContext {
     error: Error;
@@ -41,17 +42,18 @@ export type LoggerOptions = {
 export declare class Dolla {
     #private;
     readonly http: HTTP;
-    readonly language: Language;
+    readonly i18n: I18n;
     readonly render: Render;
     readonly router: Router;
     constructor();
-    createSignal: typeof createSignal;
-    createSettableSignal: typeof createSettableSignal;
-    toSettableSignal: typeof toSettableSignal;
-    signalify: typeof signalify;
-    designalify: typeof designalify;
+    watch: <I extends import("../state.js").MaybeState<any>[]>(states: [...I], fn: (...currentValues: import("../state.js").StateValues<I>) => void) => import("../state.js").StopFunction;
+    createState: typeof createState;
+    createSettableState: typeof createSettableState;
+    toSettableState: typeof toSettableState;
+    toState: typeof toState;
+    valueOf: typeof valueOf;
     derive: typeof derive;
-    watch: typeof watch;
+    createWatcher: typeof createWatcher;
     createRef: typeof createRef;
     isRef: typeof isRef;
     /**
@@ -73,6 +75,18 @@ export declare class Dolla {
      * When a crash is reported the app will be unmounted and replaced with this crash page.
      */
     setCrashView(view: ViewFunction<CrashViewProps>): void;
+    /**
+     * Sets a context variable and returns its value. Context variables are accessible on the app and in child views.
+     */
+    set<T>(key: string | symbol, value: T): T;
+    /**
+     * Gets the value of a context variable. Returns null if the variable is not set.
+     */
+    get<T>(key: string | symbol): T | null;
+    /**
+     * Returns an object of all context variables stored at the app level.
+     */
+    getAll(): Record<string | symbol, unknown>;
     mount(selector: string, view?: ViewFunction<any>): Promise<void>;
     mount(element: HTMLElement, view?: ViewFunction<any>): Promise<void>;
     unmount(): Promise<void>;
@@ -99,13 +113,13 @@ export declare class Dolla {
      */
     setLoggles(options: Partial<Loggles>): void;
     setLogFilter(filter: string | RegExp): void;
-    createLogger(name: string | Signal<string>, options?: LoggerOptions): Logger;
+    createLogger(name: string, options?: LoggerOptions): Logger;
     /**
      *
      */
-    constructView<P>(view: ViewFunction<P>, props: P, children?: Markup[]): ViewNode;
+    constructView<P>(view: ViewFunction<P>, props: P, children?: Markup[]): ViewElement;
     /**
      *
      */
-    constructMarkup(markup: Markup | Markup[]): MarkupNode;
+    constructMarkup(markup: Markup | Markup[]): MarkupElement;
 }

package/dist/modules/i18n.d.ts

@@ -0,0 +1,129 @@
+import { type MaybeState, type State } from "../state.js";
+import type { Dolla } from "./dolla.js";
+/**
+ * A JSON object of translated strings. Values can be string templates or nested objects.
+ */
+interface LocalizedStrings extends Record<string, string | LocalizedStrings> {
+}
+/**
+ * A formatter to be applied to a variable.
+ */
+type Format = {
+    name: string;
+    options: Record<string, any>;
+};
+export interface TranslationConfig {
+    /**
+     * Name of the locale this translation is for (BCP 47 locale names recommended).
+     */
+    locale: string;
+    /**
+     * Path to a JSON file with translated strings for this language.
+     */
+    path?: string;
+    /**
+     * A callback function that returns a Promise that resolves to the translation object for this language.
+     */
+    fetch?: () => Promise<LocalizedStrings>;
+}
+export type I18nSetupOptions = {
+    /**
+     * Default locale to load on startup
+     */
+    locale?: string | null;
+    translations: TranslationConfig[];
+};
+export type TOptions = {
+    /**
+     *
+     */
+    count?: MaybeState<number>;
+    /**
+     *
+     */
+    context?: MaybeState<string>;
+    /**
+     * Override formats specified in the template with the ones in the array for each named variable.
+     *
+     * @example
+     * t("example_key", {
+     *   count: 5,
+     *   formatOverrides: {
+     *     count: [ { name: "datetime", options: { style: "currency", currency: "JPY" } } ]
+     *   }
+     * });
+     */
+    formatOverrides?: MaybeState<Record<string, Record<string, Format[]>>>;
+    [value: string]: MaybeState<any>;
+};
+export type Formatter = (locale: string, value: unknown, options: Record<string, any>) => string;
+/**
+ * Dolla's I(nternationalizatio)n module. Manages language translations and locale-based formatting.
+ */
+export declare class I18n {
+    #private;
+    $locale: State<string | undefined>;
+    constructor(dolla: Dolla);
+    get locales(): string[];
+    setup(options: I18nSetupOptions): void;
+    setLocale(name: string): Promise<void>;
+    /**
+     * Returns a State containing the value at `key`.
+    
+     * @param selector - Key to the translated value.
+     * @param options - A map of `{{placeholder}}` names and the values to replace them with.
+     *
+     * @example
+     * const $value = t("your.key.here", { count: 5 });
+     */
+    t(selector: string, options?: TOptions): State<string>;
+    /**
+     * Add a custom format callback.
+     *
+     * @example
+     * Dolla.i18n.addFormat("uppercase", (locale, value, options) => {
+     *   return value.toUpperCase();
+     * });
+     *
+     * {
+     *   "greeting": "Hello, {{name|uppercase}}!"
+     * }
+     *
+     * t("greeting", {name: "world"}); // State<"Hello, WORLD!">
+     */
+    addFormat(name: string, callback: (locale: string, value: unknown, options: Record<string, any>) => string): void;
+    /**
+     * Creates an `Intl.Collator` configured for the current locale.
+     * NOTE: The Collator remains bound to the locale it was created with, even when the app's locale changes.
+     *
+     * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/Collator/Collator#options
+     */
+    collator(options?: Intl.CollatorOptions): Intl.Collator;
+    /**
+     * Returns a State containing the number formatted for the current locale. Uses `Intl.NumberFormat` under the hood.
+     *
+     * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/NumberFormat/NumberFormat#options
+     */
+    number(count: MaybeState<number | bigint>, options?: Intl.NumberFormatOptions): State<string>;
+    /**
+     * Returns a State containing the date formatted for the current locale. Uses `Intl.DateTimeFormat` under the hood.
+     *
+     * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/DateTimeFormat/DateTimeFormat#options
+     *
+     * @example
+     * const date = new Date();
+     * const $formatted = Dolla.i18n.dateTime(date, { dateFormat: "short" });
+     */
+    dateTime(date?: MaybeState<string | number | Date | undefined>, options?: Intl.DateTimeFormatOptions): State<string>;
+    /**
+     * Returns a State containing the date formatted for the current locale. Uses `Intl.DateTimeFormat` under the hood.
+     *
+     * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/DateTimeFormat/DateTimeFormat#options
+     *
+     * @example
+     * const list = new Date();
+     * const $formatted = Dolla.i18n.list(list, {  });
+     */
+    list(list: MaybeState<Iterable<string>>, options?: Intl.ListFormatOptions): State<string>;
+}
+export {};

package/dist/modules/render.d.ts

@@ -3,15 +3,12 @@ export declare class Render {
     #private;
     constructor(dolla: Dolla);
     /**
-     * Queues a callback to run in the next render batch.
-     * Running your DOM mutations in update callbacks reduces layout thrashing.
-     * Returns a Promise that resolves once the callback has run.
+     * Queues a callback that runs before the next batch of writes.
      */
-    update(callback: () => void, key?: string): Promise<void>;
+    read(callback: () => void): void;
     /**
-     * Queues a callback that reads DOM information to run after the next render batch,
-     * ensuring all writes have been performed before reading.
-     * Returns a Promise that resolves once the callback has run.
+     * Queues a callback to run in the next render batch.
+     * Always put DOM mutations in a write callback when possible to help Dolla batch them efficiently.
      */
-    read(callback: () => void): Promise<void>;
+    write(callback: () => void, key?: string): void;
 }

package/dist/modules/router.d.ts

@@ -1,5 +1,5 @@
 import { type Stringable } from "../types.js";
-import { ViewNode, type ViewFunction } from "../view.js";
+import { type ViewElement, type ViewFunction } from "../view.js";
 import type { Dolla } from "./dolla.js";
 export interface RouteMatchContext {
     /**
@@ -100,34 +100,34 @@ export interface RouterSetupOptions {
 }
 export interface RouterElements {
     readonly rootElement?: HTMLElement;
-    readonly rootView?: ViewNode;
+    readonly rootView?: ViewElement;
 }
 export declare class Router {
     #private;
     /**
      * The currently matched route pattern, if any.
      */
-    $pattern: import("../signals.js").Signal<string | null>;
+    $pattern: import("../state.js").State<string | null>;
     /**
      * The current URL path.
      */
-    $path: import("../signals.js").Signal<string>;
+    $path: import("../state.js").State<string>;
     /**
      * The current named path params.
      */
-    $params: import("../signals.js").Signal<ParsedParams>;
+    $params: import("../state.js").State<ParsedParams>;
     /**
      * The current query params. Changes to this object will be reflected in the URL.
      */
-    $query: import("../signals.js").Signal<ParsedQuery>;
+    $query: import("../state.js").State<ParsedQuery>;
     constructor(dolla: Dolla, elements: RouterElements);
     setup(options: RouterSetupOptions): void;
     /**
      * Navigates to another route.
      *
      * @example
-     * navigate("/login"); // navigate to `/login`
-     * navigate(["/users", 215], { replace: true }); // replace current history entry with `/users/215`
+     * Dolla.router.go("/login"); // navigate to `/login`
+     * Dolla.router.go["/users", 215], { replace: true }); // replace current history entry with `/users/215`
      */
     go(path: Stringable | Stringable[], options?: NavigateOptions): void;
     /**

package/dist/nodes/cond.d.ts

@@ -1,26 +1,26 @@
-import { type MarkupNode, type ElementContext, type Markup } from "../markup.js";
-import { type Signal, type StopFunction } from "../signals.js";
+import { type MarkupElement, type ElementContext, type Markup } from "../markup.js";
+import { type State, type StopFunction } from "../state.js";
 import { type Renderable } from "../types.js";
 export interface ConditionalConfig {
-    $predicate: Signal<any>;
+    $predicate: State<any>;
     thenContent?: Renderable;
     elseContent?: Renderable;
     elementContext: ElementContext;
 }
-export declare class Conditional implements MarkupNode {
+export declare class Conditional implements MarkupElement {
     node: Node;
     endNode: Node;
-    $predicate: Signal<any>;
+    $predicate: State<any>;
     stopCallback?: StopFunction;
     thenContent?: Markup[];
     elseContent?: Markup[];
-    connectedContent: MarkupNode[];
+    connectedContent: MarkupElement[];
     elementContext: ElementContext;
     initialUpdateHappened: boolean;
     previousValue?: any;
     constructor(config: ConditionalConfig);
     get isMounted(): boolean;
     mount(parent: Node, after?: Node | undefined): void;
-    unmount(): void;
+    unmount(parentIsUnmounting?: boolean): void;
     update(value: any): void;
 }

package/dist/nodes/html.d.ts

@@ -1,26 +1,32 @@
-import { type MarkupNode, type ElementContext, type Markup } from "../markup.js";
-import { type StopFunction } from "../signals.js";
+import { type ElementContext, type Markup, type MarkupElement } from "../markup.js";
+import { type Ref, type State, type StopFunction } from "../state.js";
 type HTMLOptions = {
     elementContext: ElementContext;
     tag: string;
     props: Record<string, any>;
     children?: Markup[];
 };
-export declare class HTML implements MarkupNode {
+export declare class HTML implements MarkupElement {
     node: HTMLElement | SVGElement;
     props: Record<string, any>;
-    children: MarkupNode[];
+    children: MarkupElement[];
     stopCallbacks: StopFunction[];
     elementContext: ElementContext;
     uniqueId: string;
+    ref?: Ref<any>;
     canClickAway: boolean;
     get isMounted(): boolean;
     constructor({ tag, props, children, elementContext }: HTMLOptions);
     mount(parent: Node, after?: Node): void;
-    unmount(): void;
+    unmount(parentIsUnmounting?: boolean): void;
     getUpdateKey(type: string, value: string | number): string;
+    attachProp<T>(value: State<T> | T, callback: (value: T) => void, updateKey: string): void;
     applyProps(element: HTMLElement | SVGElement, props: Record<string, unknown>): void;
-    applyStyles(element: HTMLElement | SVGElement, styles: string | Record<string, any>, stopCallbacks: StopFunction[]): () => void;
+    applyStyles(element: HTMLElement | SVGElement, styles: unknown, stopCallbacks: StopFunction[]): () => void;
     applyClasses(element: HTMLElement | SVGElement, classes: unknown, stopCallbacks: StopFunction[]): () => void;
 }
+/**
+ * Converts a camelCase string to kebab-case.
+ */
+export declare function camelToKebab(value: string): string;
 export {};

package/dist/nodes/observer.d.ts

@@ -1,29 +1,30 @@
-import { type MarkupNode, type ElementContext } from "../markup.js";
-import { type Signal } from "../signals.js";
+import { type ElementContext, type MarkupElement } from "../markup.js";
+import { type State } from "../state.js";
 import type { Renderable } from "../types.js";
 interface ObserverOptions {
     elementContext: ElementContext;
-    signals: Signal<any>[];
+    states: State<any>[];
     renderFn: (...values: any) => Renderable;
 }
 /**
  * Displays dynamic children without a parent element.
  */
-export declare class Observer implements MarkupNode {
+export declare class Observer implements MarkupElement {
     node: Node;
     endNode: Node;
-    connectedViews: MarkupNode[];
+    connectedViews: MarkupElement[];
     renderFn: (...values: any) => Renderable;
     elementContext: ElementContext;
     observerControls: {
         start: () => void;
         stop: () => void;
     };
+    watcher: import("../state.js").StateWatcher;
     get isMounted(): boolean;
-    constructor({ signals, renderFn, elementContext }: ObserverOptions);
+    constructor({ states, renderFn, elementContext }: ObserverOptions);
     mount(parent: Node, after?: Node): void;
-    unmount(): void;
-    cleanup(): void;
+    unmount(parentIsUnmounting?: boolean): void;
+    cleanup(parentIsUnmounting: boolean): void;
     update(...children: Renderable[]): void;
 }
 export {};

package/dist/nodes/outlet.d.ts

@@ -1,22 +1,22 @@
-import { type MarkupNode, type ElementContext } from "../markup.js";
-import { type Signal, type StopFunction } from "../signals.js";
+import { type MarkupElement, type ElementContext } from "../markup.js";
+import { type State, type StopFunction } from "../state.js";
 export interface OutletConfig {
-    $children: Signal<MarkupNode[]>;
+    $children: State<MarkupElement[]>;
     elementContext: ElementContext;
 }
 /**
  * Manages an array of DOMHandles.
  */
-export declare class Outlet implements MarkupNode {
+export declare class Outlet implements MarkupElement {
     node: Node;
     endNode: Node;
-    $children: Signal<MarkupNode[]>;
+    $children: State<MarkupElement[]>;
     stopCallback?: StopFunction;
-    connectedChildren: MarkupNode[];
+    mountedChildren: MarkupElement[];
     elementContext: ElementContext;
     constructor(config: OutletConfig);
     get isMounted(): boolean;
     mount(parent: Node, after?: Node | undefined): void;
-    unmount(): void;
-    update(newChildren: MarkupNode[]): void;
+    unmount(parentIsUnmounting?: boolean): void;
+    update(newChildren: MarkupElement[]): void;
 }

package/dist/nodes/portal.d.ts

@@ -1,4 +1,4 @@
-import { type MarkupNode, type ElementContext } from "../markup.js";
+import { type MarkupElement, type ElementContext } from "../markup.js";
 import { type Renderable } from "../types.js";
 interface PortalConfig {
     content: Renderable;
@@ -8,12 +8,12 @@ interface PortalConfig {
 /**
  * Renders content into a specified parent node.
  */
-export declare class Portal implements MarkupNode {
+export declare class Portal implements MarkupElement {
     config: PortalConfig;
-    handle?: MarkupNode;
+    element?: MarkupElement;
     get isMounted(): boolean;
     constructor(config: PortalConfig);
     mount(_parent: Node, _after?: Node): void;
-    unmount(): void;
+    unmount(parentIsUnmounting?: boolean): void;
 }
 export {};

package/dist/nodes/repeat.d.ts

@@ -1,34 +1,34 @@
-import { type MarkupNode, type ElementContext } from "../markup.js";
-import { type Signal, type SignalSetter, type StopFunction } from "../signals.js";
+import { type MarkupElement, type ElementContext } from "../markup.js";
+import { type State, type Setter, type StopFunction } from "../state.js";
 import { type ViewContext, type ViewResult } from "../view.js";
 interface RepeatOptions<T> {
     elementContext: ElementContext;
-    $items: Signal<T[]>;
+    $items: State<T[]>;
     keyFn: (value: T, index: number) => string | number | symbol;
-    renderFn: ($value: Signal<T>, $index: Signal<number>, ctx: ViewContext) => ViewResult;
+    renderFn: ($value: State<T>, $index: State<number>, ctx: ViewContext) => ViewResult;
 }
 type ConnectedItem<T> = {
     key: any;
-    $value: Signal<T>;
-    setValue: SignalSetter<T>;
-    $index: Signal<number>;
-    setIndex: SignalSetter<number>;
-    handle: MarkupNode;
+    $value: State<T>;
+    setValue: Setter<T>;
+    $index: State<number>;
+    setIndex: Setter<number>;
+    element: MarkupElement;
 };
-export declare class Repeat<T> implements MarkupNode {
+export declare class Repeat<T> implements MarkupElement {
     node: Node;
     endNode: Node;
-    $items: Signal<T[]>;
+    $items: State<T[]>;
     stopCallback?: StopFunction;
     connectedItems: ConnectedItem<T>[];
     elementContext: ElementContext;
-    renderFn: ($value: Signal<T>, $index: Signal<number>, ctx: ViewContext) => ViewResult;
+    renderFn: ($value: State<T>, $index: State<number>, ctx: ViewContext) => ViewResult;
     keyFn: (value: T, index: number) => string | number | symbol;
     get isMounted(): boolean;
     constructor({ elementContext, $items, renderFn, keyFn }: RepeatOptions<T>);
     mount(parent: Node, after?: Node): void;
-    unmount(): void;
-    _cleanup(): void;
+    unmount(parentIsUnmounting?: boolean): void;
+    _cleanup(parentIsUnmounting: boolean): void;
     _update(value: T[]): void;
 }
 export {};