@odoo/owl 3.0.0-alpha.2 → 3.0.0-alpha.21

package/dist/types/runtime/component_node.d.ts

@@ -1,83 +1,59 @@
-import { Computation } from "../common/types";
-import type { App, Env } from "./app";
-import { BDom, VNode } from "./blockdom";
-import { Component, ComponentConstructor, Props } from "./component";
-import { Fiber, MountFiber, MountOptions } from "./fibers";
-import { PluginManager } from "./plugins";
-import { STATUS } from "./status";
-export declare function saveCurrent(): () => void;
-export declare function getCurrent(): ComponentNode;
-export declare function useComponent(): Component;
-/**
- * Creates a reactive object that will be observed by the current component.
- * Reading data from the returned object (eg during rendering) will cause the
- * component to subscribe to that data and be rerendered when it changes.
- *
- * @param state the state to observe
- * @returns a reactive object that will cause the component to re-render on
- *  relevant changes
- * @see reactive
- */
-export declare function useState<T extends object>(state: T): T;
-declare type LifecycleHook = Function;
-export declare class ComponentNode<P extends Props = any, Plugins = any, E = any> implements VNode<ComponentNode<P, E>> {
-    el?: HTMLElement | Text | undefined;
-    app: App;
-    fiber: Fiber | null;
-    component: Component<P, Plugins, E>;
-    bdom: BDom | null;
-    status: STATUS;
-    forceNextRender: boolean;
-    parentKey: string | null;
-    props: P;
-    nextProps: P | null;
-    renderFn: Function;
-    parent: ComponentNode | null;
-    childEnv: Env;
-    children: {
-        [key: string]: ComponentNode;
-    };
-    refs: any;
-    willStart: LifecycleHook[];
-    willUpdateProps: LifecycleHook[];
-    willUnmount: LifecycleHook[];
-    mounted: LifecycleHook[];
-    willPatch: LifecycleHook[];
-    patched: LifecycleHook[];
-    willDestroy: LifecycleHook[];
-    signalComputation: Computation;
-    pluginManager: PluginManager;
-    constructor(C: ComponentConstructor<P, Plugins, E>, props: P, app: App, parent: ComponentNode | null, parentKey: string | null);
-    mountComponent(target: any, options?: MountOptions): void;
-    initiateRender(fiber: Fiber | MountFiber): Promise<void>;
-    render(deep: boolean): Promise<void>;
-    cancel(): void;
-    _cancel(): void;
-    destroy(): void;
-    _destroy(): void;
-    updateAndRender(props: P, parentFiber: Fiber): Promise<void>;
-    /**
-     * Finds a child that has dom that is not yet updated, and update it. This
-     * method is meant to be used only in the context of repatching the dom after
-     * a mounted hook failed and was handled.
-     */
-    updateDom(): void;
-    /**
-     * Sets a ref to a given HTMLElement.
-     *
-     * @param name the name of the ref to set
-     * @param el the HTMLElement to set the ref to. The ref is not set if the el
-     *  is null, but useRef will not return elements that are not in the DOM
-     */
-    setRef(name: string, el: HTMLElement | null): void;
-    firstNode(): Node | undefined;
-    mount(parent: HTMLElement, anchor: ChildNode): void;
-    moveBeforeDOMNode(node: Node | null, parent?: HTMLElement): void;
-    moveBeforeVNode(other: ComponentNode<P, E> | null, afterNode: Node | null): void;
-    patch(): void;
-    _patch(): void;
-    beforeRemove(): void;
-    remove(): void;
-    get name(): string;
-}
-export {};
+import type { App } from "./app";
+import { BDom, VNode } from "./blockdom";
+import { Component, ComponentConstructor } from "./component";
+import { PluginManager } from "./plugin_manager";
+import { ComputationAtom } from "./reactivity/computations";
+import { Fiber, MountFiber, MountOptions } from "./rendering/fibers";
+import { STATUS } from "./status";
+type LifecycleHook = Function;
+export declare class ComponentNode implements VNode<ComponentNode> {
+    el?: HTMLElement | Text | undefined;
+    app: App;
+    fiber: Fiber | null;
+    component: Component;
+    bdom: BDom | null;
+    status: STATUS;
+    forceNextRender: boolean;
+    parentKey: string | null;
+    props: Record<string, any>;
+    defaultProps: Record<string, any>;
+    renderFn: Function;
+    parent: ComponentNode | null;
+    children: {
+        [key: string]: ComponentNode;
+    };
+    willStart: LifecycleHook[];
+    willUpdateProps: LifecycleHook[];
+    willUnmount: LifecycleHook[];
+    mounted: LifecycleHook[];
+    willPatch: LifecycleHook[];
+    patched: LifecycleHook[];
+    willDestroy: LifecycleHook[];
+    signalComputation: ComputationAtom;
+    computations: ComputationAtom[];
+    pluginManager: PluginManager;
+    constructor(C: ComponentConstructor, props: Record<string, any>, app: App, parent: ComponentNode | null, parentKey: string | null);
+    mountComponent(target: any, options?: MountOptions): void;
+    initiateRender(fiber: Fiber | MountFiber): Promise<void>;
+    render(deep: boolean): Promise<void>;
+    cancel(): void;
+    _cancel(): void;
+    destroy(): void;
+    _destroy(): void;
+    updateAndRender(props: Record<string, any>, parentFiber: Fiber): Promise<void>;
+    /**
+     * Finds a child that has dom that is not yet updated, and update it. This
+     * method is meant to be used only in the context of repatching the dom after
+     * a mounted hook failed and was handled.
+     */
+    updateDom(): void;
+    firstNode(): Node | undefined;
+    mount(parent: HTMLElement, anchor: ChildNode): void;
+    moveBeforeDOMNode(node: Node | null, parent?: HTMLElement): void;
+    moveBeforeVNode(other: ComponentNode | null, afterNode: Node | null): void;
+    patch(): void;
+    _patch(): void;
+    beforeRemove(): void;
+    remove(): void;
+}
+export {};

package/dist/types/runtime/context.d.ts

@@ -0,0 +1,36 @@
+import type { App } from "./app";
+import { type ComponentNode } from "./component_node";
+import { PluginManager } from "./plugin_manager";
+import { STATUS } from "./status";
+interface ComponentContext {
+    type: "component";
+    app: App;
+    componentName: string;
+    node: ComponentNode;
+    status: STATUS;
+}
+interface PluginContext {
+    type: "plugin";
+    app: App;
+    manager: PluginManager;
+    status: STATUS;
+}
+type Contexts = {
+    plugin: PluginContext;
+    component: ComponentContext;
+};
+type Context = Contexts[keyof Contexts];
+export declare let contextStack: Context[];
+export declare function saveContext(): () => void;
+export declare function getContext<K extends keyof Contexts>(type?: K): K extends string ? Contexts[K] : Context;
+export interface CapturedContext {
+    run<T = void>(callback: () => T): T;
+    protectAsync<P extends any[], R>(callback: (...args: P) => Promise<R>): (...args: P) => Promise<R>;
+    runWithAsyncProtection<T>(callback: () => Promise<T>): Promise<T>;
+}
+/**
+ * Captures the current context and gives methods to run
+ * functions within the captured context.
+ */
+export declare function useContext(): CapturedContext;
+export {};

package/dist/types/runtime/error_handling.d.ts

@@ -1,13 +1,13 @@
-import type { ComponentNode } from "./component_node";
-import type { Fiber } from "./fibers";
-export declare const fibersInError: WeakMap<Fiber, any>;
-export declare const nodeErrorHandlers: WeakMap<ComponentNode, ((error: any) => void)[]>;
-declare type ErrorParams = {
-    error: any;
-} & ({
-    node: ComponentNode;
-} | {
-    fiber: Fiber;
-});
-export declare function handleError(params: ErrorParams): void;
-export {};
+import type { ComponentNode } from "./component_node";
+import type { Fiber } from "./fibers";
+export declare const fibersInError: WeakMap<Fiber, any>;
+export declare const nodeErrorHandlers: WeakMap<ComponentNode, ((error: any) => void)[]>;
+type ErrorParams = {
+    error: any;
+} & ({
+    node: ComponentNode;
+} | {
+    fiber: Fiber;
+});
+export declare function handleError(params: ErrorParams): void;
+export {};

package/dist/types/runtime/event_handling.d.ts

@@ -1 +1 @@
-export declare const mainEventHandler: (data: any, ev: Event, currentTarget?: EventTarget | null | undefined) => boolean;
+export declare const mainEventHandler: (data: any, ev: Event, currentTarget?: EventTarget | null) => boolean;

package/dist/types/runtime/fibers.d.ts

@@ -1,37 +1,37 @@
-import { BDom } from "./blockdom";
-import type { ComponentNode } from "./component_node";
-export declare function makeChildFiber(node: ComponentNode, parent: Fiber): Fiber;
-export declare function makeRootFiber(node: ComponentNode): Fiber;
-export declare class Fiber {
-    node: ComponentNode;
-    bdom: BDom | null;
-    root: RootFiber | null;
-    parent: Fiber | null;
-    children: Fiber[];
-    appliedToDom: boolean;
-    deep: boolean;
-    childrenMap: ComponentNode["children"];
-    constructor(node: ComponentNode, parent: Fiber | null);
-    render(): void;
-    _render(): void;
-}
-export declare class RootFiber extends Fiber {
-    counter: number;
-    willPatch: Fiber[];
-    patched: Fiber[];
-    mounted: Fiber[];
-    locked: boolean;
-    complete(): void;
-    setCounter(newValue: number): void;
-}
-declare type Position = "first-child" | "last-child";
-export interface MountOptions {
-    position?: Position;
-}
-export declare class MountFiber extends RootFiber {
-    target: HTMLElement;
-    position: Position;
-    constructor(node: ComponentNode, target: HTMLElement, options?: MountOptions);
-    complete(): void;
-}
-export {};
+import { BDom } from "./blockdom";
+import type { ComponentNode } from "./component_node";
+export declare function makeChildFiber(node: ComponentNode, parent: Fiber): Fiber;
+export declare function makeRootFiber(node: ComponentNode): Fiber;
+export declare class Fiber {
+    node: ComponentNode;
+    bdom: BDom | null;
+    root: RootFiber | null;
+    parent: Fiber | null;
+    children: Fiber[];
+    appliedToDom: boolean;
+    deep: boolean;
+    childrenMap: ComponentNode["children"];
+    constructor(node: ComponentNode, parent: Fiber | null);
+    render(): void;
+    _render(): void;
+}
+export declare class RootFiber extends Fiber {
+    counter: number;
+    willPatch: Fiber[];
+    patched: Fiber[];
+    mounted: Fiber[];
+    locked: boolean;
+    complete(): void;
+    setCounter(newValue: number): void;
+}
+type Position = "first-child" | "last-child";
+export interface MountOptions {
+    position?: Position;
+}
+export declare class MountFiber extends RootFiber {
+    target: HTMLElement;
+    position: Position;
+    constructor(node: ComponentNode, target: HTMLElement, options?: MountOptions);
+    complete(): void;
+}
+export {};

package/dist/types/runtime/hooks.d.ts

@@ -1,57 +1,32 @@
-import type { Env } from "./app";
-/**
- * The purpose of this hook is to allow components to get a reference to a sub
- * html node or component.
- */
-export declare function useRef<T extends HTMLElement = HTMLElement>(name: string): {
-    el: T | null;
-};
-/**
- * This hook is useful as a building block for some customized hooks, that may
- * need a reference to the env of the component calling them.
- */
-export declare function useEnv<E extends Env>(): E;
-/**
- * This hook is a simple way to let components use a sub environment.  Note that
- * like for all hooks, it is important that this is only called in the
- * constructor method.
- */
-export declare function useSubEnv(envExtension: Env): void;
-export declare function useChildSubEnv(envExtension: Env): void;
-declare type EffectDeps<T extends unknown[]> = T | (T extends [...infer H, never] ? EffectDeps<H> : never);
-/**
- * @template T
- * @param {...T} dependencies the dependencies computed by computeDependencies
- * @returns {void|(()=>void)} a cleanup function that reverses the side
- *      effects of the effect callback.
- */
-declare type Effect<T extends unknown[]> = (...dependencies: EffectDeps<T>) => void | (() => void);
-/**
- * This hook will run a callback when a component is mounted and patched, and
- * will run a cleanup function before patching and before unmounting the
- * the component.
- *
- * @template T
- * @param {Effect<T>} effect the effect to run on component mount and/or patch
- * @param {()=>[...T]} [computeDependencies=()=>[NaN]] a callback to compute
- *      dependencies that will decide if the effect needs to be cleaned up and
- *      run again. If the dependencies did not change, the effect will not run
- *      again. The default value returns an array containing only NaN because
- *      NaN !== NaN, which will cause the effect to rerun on every patch.
- */
-export declare function useEffect<T extends unknown[]>(effect: Effect<T>, computeDependencies?: () => [...T]): void;
-/**
- * When a component needs to listen to DOM Events on element(s) that are not
- * part of his hierarchy, we can use the `useExternalListener` hook.
- * It will correctly add and remove the event listener, whenever the
- * component is mounted and unmounted.
- *
- * Example:
- *  a menu needs to listen to the click on window to be closed automatically
- *
- * Usage:
- *  in the constructor of the OWL component that needs to be notified,
- *  `useExternalListener(window, 'click', this._doSomething);`
- * */
-export declare function useExternalListener(target: EventTarget, eventName: string, handler: EventListener, eventParams?: AddEventListenerOptions): void;
-export {};
+import { App } from "./app";
+import { effect } from "./reactivity/effect";
+import { Signal } from "./reactivity/signal";
+/**
+ * This hook will run a callback when a component is mounted and patched, and
+ * will run a cleanup function before patching and before unmounting the
+ * the component.
+ *
+ * @template T
+ * @param {Effect<T>} effect the effect to run on component mount and/or patch
+ * @param {()=>[...T]} [computeDependencies=()=>[NaN]] a callback to compute
+ *      dependencies that will decide if the effect needs to be cleaned up and
+ *      run again. If the dependencies did not change, the effect will not run
+ *      again. The default value returns an array containing only NaN because
+ *      NaN !== NaN, which will cause the effect to rerun on every patch.
+ */
+export declare function useEffect(fn: Parameters<typeof effect>[0]): void;
+/**
+ * When a component needs to listen to DOM Events on element(s) that are not
+ * part of his hierarchy, we can use the `useListener` hook.
+ * It will immediately add the listener, and remove it whenever the plugin or
+ * component is destroyed.
+ *
+ * Example:
+ *  a menu needs to listen to the click on window to be closed automatically
+ *
+ * Usage:
+ *  in the constructor of the OWL component that needs to be notified,
+ *  `useListener(window, 'click', () => this._doSomething());`
+ * */
+export declare function useListener(target: EventTarget | Signal<EventTarget | null>, eventName: string, handler: EventListener, eventParams?: AddEventListenerOptions): void;
+export declare function useApp(): App;

package/dist/types/runtime/index.d.ts

@@ -1,35 +1,46 @@
-import { createBlock, html, list, mount as blockMount, multi, patch, remove, text, toggler, comment } from "./blockdom";
-export { Registry } from "./registry";
-export declare const blockDom: {
-    config: {
-        shouldNormalizeDom: boolean;
-        mainEventHandler: (data: any, ev: Event, currentTarget?: EventTarget | null | undefined) => boolean;
-    };
-    mount: typeof blockMount;
-    patch: typeof patch;
-    remove: typeof remove;
-    list: typeof list;
-    multi: typeof multi;
-    text: typeof text;
-    toggler: typeof toggler;
-    createBlock: typeof createBlock;
-    html: typeof html;
-    comment: typeof comment;
-};
-export { App, mount } from "./app";
-export { xml } from "./template_set";
-export { Component } from "./component";
-export type { ComponentConstructor } from "./component";
-export { useComponent, useState } from "./component_node";
-export { status } from "./status";
-export { reactive, markRaw, toRaw } from "./reactivity";
-export { effect, withoutReactivity, derived, signal } from "./signals";
-export { useEffect, useEnv, useExternalListener, useRef, useChildSubEnv, useSubEnv } from "./hooks";
-export { batched, EventBus, htmlEscape, whenReady, loadFile, markup } from "./utils";
-export { onWillStart, onMounted, onWillUnmount, onWillUpdateProps, onWillPatch, onPatched, onWillRender, onRendered, onWillDestroy, onError, } from "./lifecycle_hooks";
-export { validate, validateType } from "./validation";
-export { OwlError } from "../common/owl_error";
-export declare const __info__: {
-    version: string;
-};
-export { Plugin, PluginManager, usePlugins } from "./plugins";
+import { createBlock, html, list, mount as blockMount, multi, patch, remove, text, toggler, comment } from "./blockdom";
+export { Resource, useResource } from "./resource";
+export { Registry } from "./registry";
+export declare const blockDom: {
+    config: {
+        shouldNormalizeDom: boolean;
+        mainEventHandler: (data: any, ev: Event, currentTarget?: EventTarget | null) => boolean;
+    };
+    mount: typeof blockMount;
+    patch: typeof patch;
+    remove: typeof remove;
+    list: typeof list;
+    multi: typeof multi;
+    text: typeof text;
+    toggler: typeof toggler;
+    createBlock: typeof createBlock;
+    html: typeof html;
+    comment: typeof comment;
+};
+export { App, mount } from "./app";
+export { xml } from "./template_set";
+export { Component } from "./component";
+export type { ComponentConstructor } from "./component";
+export { props } from "./props";
+export type { GetProps } from "./props";
+export { status } from "./status";
+export { proxy, markRaw, toRaw } from "./reactivity/proxy";
+export { untrack, type ReactiveValue } from "./reactivity/computations";
+export { signal, type Signal } from "./reactivity/signal";
+export { computed } from "./reactivity/computed";
+export { effect } from "./reactivity/effect";
+export { useEffect, useListener, useApp } from "./hooks";
+export { batched, EventBus, htmlEscape, whenReady, markup } from "./utils";
+export { onWillStart, onMounted, onWillUnmount, onWillUpdateProps, onWillPatch, onPatched, onWillDestroy, onError, } from "./lifecycle_hooks";
+export { assertType, validateType } from "./validation";
+export { types } from "./types";
+export { OwlError } from "../common/owl_error";
+export { config, plugin, providePlugins } from "./plugin_hooks";
+export type { PluginInstance } from "./plugin_hooks";
+export { Plugin } from "./plugin_manager";
+export type { PluginConstructor } from "./plugin_manager";
+export { useContext } from "./context";
+export type { CapturedContext } from "./context";
+export declare const __info__: {
+    version: string;
+};

package/dist/types/runtime/lifecycle_hooks.d.ts

@@ -1,12 +1,10 @@
-export declare function onWillStart(fn: () => Promise<void> | void | any): void;
-export declare function onWillUpdateProps(fn: (nextProps: any) => Promise<void> | void | any): void;
-export declare function onMounted(fn: () => void | any): void;
-export declare function onWillPatch(fn: () => any | void): void;
-export declare function onPatched(fn: () => void | any): void;
-export declare function onWillUnmount(fn: () => void | any): void;
-export declare function onWillDestroy(fn: () => void | any): void;
-export declare function onWillRender(fn: () => void | any): void;
-export declare function onRendered(fn: () => void | any): void;
-declare type OnErrorCallback = (error: any) => void | any;
-export declare function onError(callback: OnErrorCallback): void;
-export {};
+export declare function onWillStart(fn: () => Promise<void> | void | any): void;
+export declare function onWillUpdateProps(fn: (nextProps: any) => Promise<void> | void | any): void;
+export declare function onMounted(fn: () => void | any): void;
+export declare function onWillPatch(fn: () => any | void): void;
+export declare function onPatched(fn: () => void | any): void;
+export declare function onWillUnmount(fn: () => void | any): void;
+export declare function onWillDestroy(fn: () => void | any): void;
+type OnErrorCallback = (error: any) => void | any;
+export declare function onError(callback: OnErrorCallback): void;
+export {};

package/dist/types/runtime/plugin_hooks.d.ts

@@ -0,0 +1,6 @@
+import { PluginConstructor } from "./plugin_manager";
+import { Resource } from "./resource";
+export type PluginInstance<T extends PluginConstructor> = Omit<InstanceType<T>, "setup">;
+export declare function plugin<T extends PluginConstructor>(pluginType: T): PluginInstance<T>;
+export declare function config<T = any>(name: string, type?: T): T;
+export declare function providePlugins(pluginConstructors: PluginConstructor[] | Resource<PluginConstructor>, config?: Record<string, any>): void;

package/dist/types/runtime/plugin_manager.d.ts

@@ -0,0 +1,36 @@
+import { App } from "./app";
+import { ComputationAtom } from "./reactivity/computations";
+import { Resource } from "./resource";
+import { STATUS } from "./status";
+export interface PluginConstructor {
+    new (...args: any[]): Plugin;
+    id: string;
+}
+export declare class Plugin {
+    private static _shadowId;
+    static get id(): string;
+    static set id(shadowId: string);
+    __owl__: PluginManager;
+    constructor(manager: PluginManager);
+    setup(): void;
+}
+interface PluginManagerOptions {
+    parent?: PluginManager | null;
+    config?: Record<string, any>;
+}
+export declare class PluginManager {
+    app: App;
+    config: Record<string, any>;
+    onDestroyCb: Function[];
+    computations: ComputationAtom[];
+    plugins: Record<string, Plugin>;
+    status: STATUS;
+    constructor(app: App, options?: PluginManagerOptions);
+    destroy(): void;
+    getPluginById<T extends Plugin>(id: string): T | null;
+    getPlugin<T extends PluginConstructor>(pluginConstructor: T): InstanceType<T> | null;
+    startPlugin<T extends PluginConstructor>(pluginConstructor: T): InstanceType<T> | null;
+    startPlugins(pluginConstructors: PluginConstructor[]): void;
+}
+export declare function startPlugins(manager: PluginManager, plugins: PluginConstructor[] | Resource<PluginConstructor>): void;
+export {};

package/dist/types/runtime/props.d.ts

@@ -0,0 +1,21 @@
+import { GetOptionalEntries, KeyedObject, PrettifyShape, ResolveObjectType } from "./types";
+declare const isProps: unique symbol;
+export type WithDefaults<T, D> = T & Required<D>;
+export type Props<T extends {}> = T & {
+    [isProps]: true;
+};
+type GetPropsDefaults<T extends object> = PrettifyShape<GetOptionalEntries<T>>;
+type GetPropsWithOptionals<T> = T extends Props<infer P> ? (P extends WithDefaults<infer R, any> ? R : P) : never;
+export type GetProps<T> = {
+    [K in keyof T]: T[K] extends {
+        [isProps]: true;
+    } ? (x: GetPropsWithOptionals<T[K]>) => void : never;
+}[keyof T] extends (x: infer I) => void ? {
+    [K in keyof I]: I[K];
+} : never;
+export declare function props(): Props<Record<string, any>>;
+export declare function props<const Keys extends string[]>(keys: Keys): Props<ResolveObjectType<Keys>>;
+export declare function props<const Keys extends string[], Defaults>(keys: Keys, defaults: Defaults & GetPropsDefaults<KeyedObject<Keys>>): Props<WithDefaults<ResolveObjectType<Keys>, Defaults>>;
+export declare function props<Shape extends {}>(shape: Shape): Props<ResolveObjectType<Shape>>;
+export declare function props<Shape extends {}, Defaults>(shape: Shape, defaults: Defaults & GetPropsDefaults<Shape>): Props<WithDefaults<ResolveObjectType<Shape>, Defaults>>;
+export {};

package/dist/types/runtime/reactivity/computations.d.ts

@@ -0,0 +1,34 @@
+export interface ReactiveValue<TRead, TWrite = TRead> {
+    (): TRead;
+    /**
+     * Update the value of the reactive with a new value. If the new value is different
+     * from the previous values, all computations that depends on this reactive will
+     * be invalidated, and effects will rerun.
+     */
+    set(nextValue: TWrite): void;
+}
+export declare enum ComputationState {
+    EXECUTED = 0,
+    STALE = 1,
+    PENDING = 2
+}
+export interface Atom<T = any> {
+    observers: Set<ComputationAtom>;
+    value: T;
+}
+export interface ComputationAtom<T = any> extends Atom<T> {
+    compute: () => T;
+    isDerived: boolean;
+    sources: Set<Atom>;
+    state: ComputationState;
+}
+export declare const atomSymbol: unique symbol;
+export declare function createComputation(compute: () => any, isDerived: boolean, state?: ComputationState): ComputationAtom;
+export declare function onReadAtom(atom: Atom): void;
+export declare function onWriteAtom(atom: Atom): void;
+export declare function getCurrentComputation(): ComputationAtom<any> | undefined;
+export declare function setComputation(computation: ComputationAtom | undefined): void;
+export declare function updateComputation(computation: ComputationAtom): void;
+export declare function removeSources(computation: ComputationAtom): void;
+export declare function disposeComputation(computation: ComputationAtom): void;
+export declare function untrack<T>(fn: (...args: any[]) => T): T;

package/dist/types/runtime/reactivity/computed.d.ts

@@ -0,0 +1,6 @@
+import { ReactiveValue } from "./computations";
+interface ComputedOptions<TWrite> {
+    set?(value: TWrite): void;
+}
+export declare function computed<TRead, TWrite = TRead>(getter: () => TRead, options?: ComputedOptions<TWrite>): ReactiveValue<TRead, TWrite>;
+export {};

package/dist/types/runtime/reactivity/effect.d.ts

@@ -0,0 +1 @@
+export declare function effect<T>(fn: () => T): () => void;