@odoo/owl 2.8.1 → 3.0.0-alpha.10

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

@@ -1,22 +1,23 @@
-import { Component, ComponentConstructor, Props } from "./component";
+import { ComponentConstructor } from "./component";
 import { ComponentNode } from "./component_node";
-import { handleError } from "./error_handling";
-import { Fiber, RootFiber, MountOptions } from "./fibers";
-import { Scheduler } from "./scheduler";
+import { handleError } from "./rendering/error_handling";
+import { Fiber, MountOptions, RootFiber } from "./rendering/fibers";
+import { Plugin, PluginManager } from "./plugins";
+import { proxy, toRaw } from "./reactivity/proxy";
+import { Scheduler } from "./rendering/scheduler";
 import { TemplateSet, TemplateSetConfig } from "./template_set";
 import { validateTarget } from "./utils";
-import { toRaw, reactive } from "./reactivity";
-export interface Env {
-    [key: string]: any;
-}
-export interface RootConfig<P, E> {
+import { GetProps } from "./props";
+type ComponentInstance<C extends ComponentConstructor> = C extends new (...args: any) => infer T ? T : never;
+interface RootConfig<P> {
+    pluginManager?: PluginManager;
     props?: P;
-    env?: E;
 }
-export interface AppConfig<P, E> extends TemplateSetConfig, RootConfig<P, E> {
+export interface AppConfig extends TemplateSetConfig {
     name?: string;
+    plugins?: (typeof Plugin)[];
+    pluginManager?: PluginManager;
     test?: boolean;
-    warnIfNoStaticProps?: boolean;
 }
 declare global {
     interface Window {
@@ -25,35 +26,32 @@ declare global {
             Fiber: typeof Fiber;
             RootFiber: typeof RootFiber;
             toRaw: typeof toRaw;
-            reactive: typeof reactive;
+            proxy: typeof proxy;
         };
     }
 }
-interface Root<P extends Props, E> {
-    node: ComponentNode<P, E>;
-    mount(target: HTMLElement | ShadowRoot, options?: MountOptions): Promise<Component<P, E>>;
+type MountTarget = HTMLElement | ShadowRoot;
+interface Root<T extends ComponentConstructor> {
+    node: ComponentNode;
+    promise: Promise<ComponentInstance<T>>;
+    mount(target: MountTarget, options?: MountOptions): Promise<ComponentInstance<T>>;
     destroy(): void;
 }
-export declare class App<T extends abstract new (...args: any) => any = any, P extends object = any, E = any> extends TemplateSet {
+export declare class App extends TemplateSet {
     static validateTarget: typeof validateTarget;
-    static apps: Set<App<any, any, any>>;
+    static apps: Set<App>;
     static version: string;
     name: string;
-    Root: ComponentConstructor<P, E>;
-    props: P;
-    env: E;
     scheduler: Scheduler;
-    subRoots: Set<ComponentNode>;
-    root: ComponentNode<P, E> | null;
-    warnIfNoStaticProps: boolean;
-    constructor(Root: ComponentConstructor<P, E>, config?: AppConfig<P, E>);
-    mount(target: HTMLElement | ShadowRoot, options?: MountOptions): Promise<Component<P, E> & InstanceType<T>>;
-    createRoot<Props extends object, SubEnv = any>(Root: ComponentConstructor<Props, E>, config?: RootConfig<Props, SubEnv>): Root<Props, SubEnv>;
-    makeNode(Component: ComponentConstructor, props: any): ComponentNode;
-    mountNode(node: ComponentNode, target: HTMLElement | ShadowRoot, options?: MountOptions): any;
+    roots: Set<Root<any>>;
+    pluginManager: PluginManager;
+    constructor(config?: AppConfig);
+    createRoot<T extends ComponentConstructor>(Root: T, config?: RootConfig<GetProps<ComponentInstance<T>>>): Root<T>;
+    makeNode<T extends ComponentConstructor>(Component: T, props: GetProps<ComponentInstance<T>>): ComponentNode;
+    mountNode(node: ComponentNode, target: HTMLElement | ShadowRoot, resolve: (c: any) => void, reject: (e: any) => void, options?: MountOptions): void;
     destroy(): void;
-    createComponent<P extends Props>(name: string | null, isStatic: boolean, hasSlotsProp: boolean, hasDynamicPropList: boolean, propList: string[]): (props: P, key: string, ctx: ComponentNode, parent: any, C: any) => any;
+    createComponent<P extends Record<string, any>>(name: string | null, isStatic: boolean, hasSlotsProp: boolean, hasDynamicPropList: boolean, propList: string[]): (props: P, key: string, ctx: ComponentNode, parent: any, C: any) => any;
     handleError(...args: Parameters<typeof handleError>): void;
 }
-export declare function mount<T extends abstract new (...args: any) => any = any, P extends object = any, E = any>(C: T & ComponentConstructor<P, E>, target: HTMLElement, config?: AppConfig<P, E> & MountOptions): Promise<Component<P, E> & InstanceType<T>>;
+export declare function mount<T extends ComponentConstructor>(C: T, target: MountTarget, config?: AppConfig & RootConfig<GetProps<ComponentInstance<T>>> & MountOptions): Promise<ComponentInstance<T>>;
 export {};

package/dist/types/runtime/blockdom/block_compiler.d.ts

@@ -1,5 +1,5 @@
 import type { VNode } from "./index";
-declare type BlockType = (data?: any[], children?: VNode[]) => VNode;
+type BlockType = (data?: any[], children?: VNode[]) => VNode;
 /**
  * Compiling blocks is a multi-step process:
  *
@@ -16,6 +16,6 @@ declare type BlockType = (data?: any[], children?: VNode[]) => VNode;
  * @returns a new block type, that can build concrete blocks
  */
 export declare function createBlock(str: string): BlockType;
-export declare type Setter<T = any> = (this: T, value: any) => void;
-export declare type Updater<T = any> = (this: T, value: any, oldVal: any) => void;
+export type Setter<T = any> = (this: T, value: any) => void;
+export type Updater<T = any> = (this: T, value: any, oldVal: any) => void;
 export {};

package/dist/types/runtime/blockdom/config.d.ts

@@ -4,5 +4,5 @@ export declare function filterOutModifiersFromData(dataList: any[]): {
 };
 export declare const config: {
     shouldNormalizeDom: boolean;
-    mainEventHandler: (data: any, ev: Event, currentTarget?: EventTarget | null | undefined) => boolean;
+    mainEventHandler: (data: any, ev: Event, currentTarget?: EventTarget | null) => boolean;
 };

package/dist/types/runtime/blockdom/event_catcher.d.ts

@@ -1,7 +1,7 @@
 import type { VNode } from "./index";
-declare type EventsSpec = {
+type EventsSpec = {
     [name: string]: number;
 };
-declare type Catcher = (child: VNode, handlers: any[]) => VNode;
+type Catcher = (child: VNode, handlers: any[]) => VNode;
 export declare function createCatcher(eventsSpec: EventsSpec): Catcher;
 export {};

package/dist/types/runtime/blockdom/events.d.ts

@@ -1,4 +1,4 @@
-declare type EventHandlerSetter = (this: HTMLElement, data: any) => void;
+type EventHandlerSetter = (this: HTMLElement, data: any) => void;
 interface EventHandlerCreator {
     setup: EventHandlerSetter;
     update: EventHandlerSetter;

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

@@ -19,7 +19,7 @@ export interface VNode<T = any> {
     isOnlyChild?: boolean | undefined;
     key?: any;
 }
-export declare type BDom = VNode<any>;
+export type BDom = VNode<any>;
 export declare function mount(vnode: VNode, fixture: HTMLElement, afterNode?: Node | null): void;
 export declare function patch(vnode1: VNode, vnode2: VNode, withBeforeRemove?: boolean): void;
 export declare function remove(vnode: VNode, withBeforeRemove?: boolean): void;

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

@@ -0,0 +1,15 @@
+export declare type TaskContext = {
+    isCancelled: boolean;
+    cancel: () => void;
+    meta: Record<string, any>;
+};
+export declare const taskContextStack: TaskContext[];
+export declare function getTaskContext(): TaskContext;
+export declare function makeTaskContext(): TaskContext;
+export declare function useTaskContext(ctx?: TaskContext): {
+    ctx: TaskContext;
+    cleanup: () => void;
+};
+export declare function pushTaskContext(context: TaskContext): void;
+export declare function popTaskContext(): void;
+export declare function taskEffect(fn: Function): TaskContext;

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

@@ -0,0 +1,15 @@
+export declare type PromiseExecContext = {
+    cancelled: boolean;
+};
+export declare type CancellablePromise<T = any> = Promise<T> & {
+    execContext?: PromiseExecContext;
+};
+export declare const setCancellableContext: (ctx: PromiseExecContext | undefined) => PromiseExecContext | undefined;
+export declare const resetCancellableContext: (ctx: PromiseExecContext | undefined) => void;
+export declare const _exec: (execContext: PromiseExecContext | undefined, cb: Function, args: any[]) => any;
+export declare function patchPromise(): void;
+export declare function restorePromise(): void;
+export declare function getCancellableTask(cb: Function): {
+    cancel: () => boolean;
+    readonly isCancel: boolean;
+};

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

@@ -1,25 +1,17 @@
-import { Schema } from "./validation";
 import type { ComponentNode } from "./component_node";
-export declare type Props = {
-    [key: string]: any;
-};
 interface StaticComponentProperties {
     template: string;
-    defaultProps?: any;
-    props?: Schema;
     components?: {
         [componentName: string]: ComponentConstructor;
     };
 }
-export declare type ComponentConstructor<P extends Props = any, E = any> = (new (props: P, env: E, node: ComponentNode) => Component<P, E>) & StaticComponentProperties;
-export declare class Component<Props = any, Env = any> {
+export interface ComponentConstructor extends StaticComponentProperties {
+    new (node: ComponentNode): Component;
+}
+export declare class Component {
     static template: string;
-    static props?: Schema;
-    static defaultProps?: any;
-    props: Props;
-    env: Env;
     __owl__: ComponentNode;
-    constructor(props: Props, env: Env, node: ComponentNode);
+    constructor(node: ComponentNode);
     setup(): void;
     render(deep?: boolean): void;
 }

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

@@ -1,42 +1,30 @@
-import type { App, Env } from "./app";
+import type { App } from "./app";
 import { BDom, VNode } from "./blockdom";
-import { Component, ComponentConstructor, Props } from "./component";
-import { Fiber, MountFiber, MountOptions } from "./fibers";
-import { getSubscriptions } from "./reactivity";
+import { Component, ComponentConstructor } from "./component";
+import { PluginManager } from "./plugins";
+import { Computation } from "./reactivity/computations";
+import { Fiber, MountFiber, MountOptions } from "./rendering/fibers";
 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, E = any> implements VNode<ComponentNode<P, E>> {
+type LifecycleHook = Function;
+export declare class ComponentNode implements VNode<ComponentNode> {
     el?: HTMLElement | Text | undefined;
     app: App;
     fiber: Fiber | null;
-    component: Component<P, E>;
+    component: Component;
     bdom: BDom | null;
     status: STATUS;
     forceNextRender: boolean;
     parentKey: string | null;
-    props: P;
-    nextProps: P | null;
+    name: string;
+    props: Record<string, any>;
     renderFn: Function;
     parent: ComponentNode | null;
-    childEnv: Env;
     children: {
         [key: string]: ComponentNode;
     };
-    refs: any;
     willStart: LifecycleHook[];
     willUpdateProps: LifecycleHook[];
     willUnmount: LifecycleHook[];
@@ -44,7 +32,9 @@ export declare class ComponentNode<P extends Props = any, E = any> implements VN
     willPatch: LifecycleHook[];
     patched: LifecycleHook[];
     willDestroy: LifecycleHook[];
-    constructor(C: ComponentConstructor<P, E>, props: P, app: App, parent: ComponentNode | null, parentKey: string | null);
+    signalComputation: Computation;
+    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>;
@@ -52,30 +42,20 @@ export declare class ComponentNode<P extends Props = any, E = any> implements VN
     _cancel(): void;
     destroy(): void;
     _destroy(): void;
-    updateAndRender(props: P, parentFiber: Fiber): Promise<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;
-    /**
-     * 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;
+    moveBeforeVNode(other: ComponentNode | null, afterNode: Node | null): void;
     patch(): void;
     _patch(): void;
     beforeRemove(): void;
     remove(): void;
-    get name(): string;
-    get subscriptions(): ReturnType<typeof getSubscriptions>;
 }
 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/hooks.d.ts

@@ -1,31 +1,5 @@
-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);
+import { PluginConstructor } from "./plugins";
+import { effect } from "./reactivity/effect";
 /**
  * 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
@@ -39,10 +13,10 @@ declare type Effect<T extends unknown[]> = (...dependencies: EffectDeps<T>) => v
  *      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;
+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 `useExternalListener` hook.
+ * part of his hierarchy, we can use the `useListener` hook.
  * It will correctly add and remove the event listener, whenever the
  * component is mounted and unmounted.
  *
@@ -51,7 +25,7 @@ export declare function useEffect<T extends unknown[]>(effect: Effect<T>, comput
  *
  * Usage:
  *  in the constructor of the OWL component that needs to be notified,
- *  `useExternalListener(window, 'click', this._doSomething);`
+ *  `useListener(window, 'click', this._doSomething);`
  * */
-export declare function useExternalListener(target: EventTarget, eventName: string, handler: EventListener, eventParams?: AddEventListenerOptions): void;
-export {};
+export declare function useListener(target: EventTarget, eventName: string, handler: EventListener, eventParams?: AddEventListenerOptions): void;
+export declare function usePlugins(Plugins: PluginConstructor[]): import("./plugins").Plugin[];

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

@@ -1,4 +1,6 @@
 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;
@@ -19,14 +21,22 @@ 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 { useComponent } from "./component_node";
+export { props } from "./props";
+export type { GetProps, PropsValidation } from "./props";
 export { status } from "./status";
-export { reactive, markRaw, toRaw } from "./reactivity";
-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 { proxy, markRaw, toRaw } from "./reactivity/proxy";
+export { untrack } from "./reactivity/computations";
+export { signal, ReactiveValue, Signal } from "./reactivity/signal";
+export { computed } from "./reactivity/computed";
+export { effect } from "./reactivity/effect";
+export { useEffect, useListener, usePlugins } from "./hooks";
+export { batched, EventBus, htmlEscape, whenReady, markup } from "./utils";
+export { onWillStart, onMounted, onWillUnmount, onWillUpdateProps, onWillPatch, onPatched, 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, plugin } from "./plugins";
+export type { PluginConstructor } from "./plugins";

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

@@ -5,8 +5,6 @@ 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;
+type OnErrorCallback = (error: any) => void | any;
 export declare function onError(callback: OnErrorCallback): void;
 export {};

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

@@ -0,0 +1 @@
+export declare function reactiveMap<A, B>(arr: A[], fn: (a: A, index: number) => B): any;

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

@@ -0,0 +1,23 @@
+import { STATUS } from "./status";
+export declare const _getCurrentPluginManager: () => PluginManager | null;
+export interface PluginConstructor {
+    new (): Plugin;
+    id: string;
+}
+export declare class Plugin {
+    static id: string;
+    setup(): void;
+}
+export declare class PluginManager {
+    private children;
+    private parent;
+    private plugins;
+    private onDestroyCb;
+    status: STATUS;
+    constructor(parent: PluginManager | null);
+    destroy(): void;
+    getPluginById<T extends Plugin>(id: string): T | null;
+    getPlugin<T extends PluginConstructor>(pluginType: T): InstanceType<T> | null;
+    startPlugins(pluginTypes: PluginConstructor[]): Plugin[];
+}
+export declare function plugin<T extends PluginConstructor>(pluginType: T): InstanceType<T>;

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

@@ -5,11 +5,9 @@ import { Component } from "./component";
 export declare function portalTemplate(app: any, bdom: any, helpers: any): (ctx: any, node: any, key?: string) => any;
 export declare class Portal extends Component {
     static template: string;
-    static props: {
-        readonly target: {
-            readonly type: StringConstructor;
-        };
-        readonly slots: true;
-    };
+    props: import("./props").Props<unknown, {
+        target: StringConstructor;
+        slots: true;
+    }>;
     setup(): void;
 }

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

@@ -0,0 +1,65 @@
+import type { Component } from "./component";
+type ConstructorTypedPropsValidation<T = any> = new (...args: any) => T;
+type UnionTypedPropsValidation = ReadonlyArray<TypedPropsValidation>;
+type OptionalSchemaTypedPropsValidation<O extends boolean> = {
+    optional: O;
+};
+type DefaultValuedSchemaTypedPropsValidation<T> = {
+    defaultValue: T;
+};
+type ValidableSchemaTypedPropsValidation = {
+    validate(value: any): boolean;
+};
+type TypeSchemaTypedPropsValidation<T> = {
+    type: new (...args: any) => T;
+};
+type MapSchemaTypedPropsValidation = {
+    type: ObjectConstructor;
+    shape: PropsValidation;
+};
+type RecordSchemaTypedPropsValidation = {
+    type: ObjectConstructor;
+    values: TypedPropsValidation;
+};
+type ArraySchemaTypedPropsValidation = {
+    type: ArrayConstructor;
+    element: TypedPropsValidation;
+};
+type SchemaTypedPropsValidation<T, O extends boolean> = {
+    type?: new (...args: any) => T;
+    optional?: O;
+    defaultValue?: T;
+    validate?(value: T): boolean;
+    shape?: PropsValidation;
+    values?: TypedPropsValidation;
+    element?: TypedPropsValidation;
+};
+type ValueTypedPropsValidation<T = any> = {
+    value: T;
+};
+type TypedPropsValidation = true | ConstructorTypedPropsValidation | UnionTypedPropsValidation | SchemaTypedPropsValidation<any, boolean> | ValueTypedPropsValidation;
+export type RecordPropsValidation = Record<string, TypedPropsValidation>;
+export type KeysPropsValidation = readonly string[];
+export type PropsValidation = RecordPropsValidation | KeysPropsValidation;
+type ConvertTypedPropsValidation<V extends TypedPropsValidation> = V extends true ? any : V extends ConstructorTypedPropsValidation<infer I> ? I : V extends UnionTypedPropsValidation ? V[number] : V extends MapSchemaTypedPropsValidation ? ConvertPropsValidation<V["shape"]> : V extends RecordSchemaTypedPropsValidation ? Record<string, ConvertTypedPropsValidation<V["values"]>> : V extends ArraySchemaTypedPropsValidation ? ConvertTypedPropsValidation<V["element"]>[] : V extends TypeSchemaTypedPropsValidation<infer I> ? I : V extends ValueTypedPropsValidation<infer T> ? T : V extends DefaultValuedSchemaTypedPropsValidation<infer T> ? T : V extends OptionalSchemaTypedPropsValidation<boolean> ? any : V extends ValidableSchemaTypedPropsValidation ? any : never;
+type ConvertPropsValidation<V extends PropsValidation> = V extends KeysPropsValidation ? {
+    [K in V[number] as K extends `${infer N}?` ? N : never]?: any;
+} & {
+    [K in V[number] as K extends `${string}?` ? never : K]: any;
+} : V extends RecordPropsValidation ? {
+    [K in keyof V as V[K] extends OptionalSchemaTypedPropsValidation<true> ? K : never]?: ConvertTypedPropsValidation<V[K]>;
+} & {
+    [K in keyof V as V[K] extends OptionalSchemaTypedPropsValidation<true> ? never : K]: ConvertTypedPropsValidation<V[K]>;
+} : never;
+declare const isProps: unique symbol;
+type IsPropsObj = {
+    [isProps]: true;
+};
+export type Props<T, V extends PropsValidation> = IsPropsObj & (unknown extends T ? ConvertPropsValidation<V> : T);
+export type GetProps<T extends Component> = {
+    [K in keyof T]: T[K] extends IsPropsObj ? (x: Omit<T[K], typeof isProps>) => void : never;
+}[keyof T] extends (x: infer I) => void ? {
+    [K in keyof I]: I[K];
+} : never;
+export declare function props<T = unknown, V extends PropsValidation = PropsValidation>(validation?: V): Props<T, V>;
+export {};

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

@@ -0,0 +1,31 @@
+export declare enum ComputationState {
+    EXECUTED = 0,
+    STALE = 1,
+    PENDING = 2
+}
+export type Computation<T = any> = {
+    compute?: () => T;
+    state: ComputationState;
+    sources: Set<Atom | Derived<any, any>>;
+    isEager?: boolean;
+    isDerived?: boolean;
+    value: T;
+    childrenEffect?: Computation[];
+} & Opts;
+export type Opts = {
+    name?: string;
+};
+export type Atom<T = any> = {
+    value: T;
+    observers: Set<Computation>;
+} & Opts;
+export interface Derived<Prev, Next = Prev> extends Atom<Next>, Computation<Next> {
+}
+export declare function onReadAtom(atom: Atom): void;
+export declare function onWriteAtom(atom: Atom): void;
+export declare function untrack<T extends (...args: any[]) => any>(fn: T): ReturnType<T>;
+export declare function getCurrentComputation(): Computation<any> | undefined;
+export declare function setComputation(computation: Computation | undefined): void;
+export declare function runWithComputation<T>(computation: Computation, fn: () => T): T;
+export declare function updateComputation(computation: Computation): void;
+export declare function removeSources(computation: Computation): void;

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

@@ -0,0 +1,7 @@
+import { Opts, Derived } from "./computations";
+import { ReactiveValue } from "./signal";
+export declare function computed<T>(fn: () => T, opts?: Opts): ReactiveValue<T>;
+export declare function setSignalHooks(hooks: {
+    onDerived: (derived: Derived<any, any>) => void;
+}): void;
+export declare function resetSignalHooks(): void;

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

@@ -0,0 +1,7 @@
+import { Opts, Derived } from "./computations";
+import { ReactiveValue } from "./signal";
+export declare function derived<T>(fn: () => T, opts?: Opts): ReactiveValue<T>;
+export declare function setSignalHooks(hooks: {
+    onDerived: (derived: Derived<any, any>) => void;
+}): void;
+export declare function resetSignalHooks(): void;

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

@@ -0,0 +1,2 @@
+import { Opts } from "./computations";
+export declare function effect<T>(fn: () => T, opts?: Opts): () => void;

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

@@ -0,0 +1,46 @@
+type Target = object;
+type Reactive<T extends Target> = T;
+/**
+ * Mark an object or array so that it is ignored by the reactivity system
+ *
+ * @param value the value to mark
+ * @returns the object itself
+ */
+export declare function markRaw<T extends Target>(value: T): T;
+/**
+ * Given a proxy objet, return the raw (non proxy) underlying object
+ *
+ * @param value a proxy value
+ * @returns the underlying value
+ */
+export declare function toRaw<T extends Target, U extends Reactive<T>>(value: U | T): T;
+export declare const targets: WeakMap<object, object>;
+/**
+ * Creates a reactive proxy for an object. Reading data on the proxy object
+ * subscribes to changes to the data. Writing data on the object will cause the
+ * notify callback to be called if there are suscriptions to that data. Nested
+ * objects and arrays are automatically made reactive as well.
+ *
+ * Whenever you are notified of a change, all subscriptions are cleared, and if
+ * you would like to be notified of any further changes, you should go read
+ * the underlying data again. We assume that if you don't go read it again after
+ * being notified, it means that you are no longer interested in that data.
+ *
+ * Subscriptions:
+ * + Reading a property on an object will subscribe you to changes in the value
+ *    of that property.
+ * + Accessing an object's keys (eg with Object.keys or with `for..in`) will
+ *    subscribe you to the creation/deletion of keys. Checking the presence of a
+ *    key on the object with 'in' has the same effect.
+ * - getOwnPropertyDescriptor does not currently subscribe you to the property.
+ *    This is a choice that was made because changing a key's value will trigger
+ *    this trap and we do not want to subscribe by writes. This also means that
+ *    Object.hasOwnProperty doesn't subscribe as it goes through this trap.
+ *
+ * @param target the object for which to create a proxy proxy
+ * @param callback the function to call when an observed property of the
+ *  proxy has changed
+ * @returns a proxy that tracks changes to it
+ */
+export declare function proxy<T extends Target>(target: T): T;
+export {};