@odoo/owl 1.4.10 → 2.0.0-alpha.3

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

@@ -1,301 +1,22 @@
-import { Observer } from "../core/observer";
-import { CompiledTemplate, QWeb } from "../qweb/index";
-import { VNode } from "../vdom/index";
-import "./directive";
-import { Fiber } from "./fiber";
-import "./props_validation";
-import { Scheduler } from "./scheduler";
-import { Browser } from "../browser";
-/**
- * Owl Component System
- *
- * This file introduces a declarative and composable component system. It
- * contains:
- *
- * - the Env interface (generic type for the environment)
- * - the Internal interface (the owl specific metadata attached to a component)
- * - the Component class
- */
-/**
- * An Env (environment) is an object that will be (mostly) shared between all
- * components of an Owl application.  It is the location which should contain
- * the qweb instance necessary to render all components.
- *
- * Note that it is totally fine to extend the environment with application
- * specific keys/objects/whatever.  For example, a key `isMobile` (to declare
- * if we are in "mobile" mode), or a shared bus could be useful.
- */
-export interface Env {
-    qweb: QWeb;
-    browser: Browser;
-}
-export declare type MountPosition = "first-child" | "last-child" | "self";
-interface MountOptions {
-    position?: MountPosition;
-}
-export declare const enum STATUS {
-    CREATED = 0,
-    WILLSTARTED = 1,
-    RENDERED = 2,
-    MOUNTED = 3,
-    UNMOUNTED = 4,
-    DESTROYED = 5
-}
-/**
- * This is mostly an internal detail of implementation. The Meta interface is
- * useful to typecheck and describe the internal keys used by Owl to manage the
- * component tree.
- */
-interface Internal<T extends Env> {
-    readonly id: number;
-    depth: number;
-    vnode: VNode | null;
-    pvnode: VNode | null;
-    status: STATUS;
-    parent: Component<any, T> | null;
-    children: {
-        [key: number]: Component<any, T>;
-    };
-    cmap: {
-        [key: number]: number;
-    };
-    currentFiber: Fiber | null;
-    parentLastFiberId: number;
-    scope: any;
-    boundHandlers: {
-        [key: number]: any;
-    };
-    observer: Observer | null;
-    renderFn: CompiledTemplate;
-    mountedCB: Function | null;
-    willUnmountCB: Function | null;
-    willPatchCB: Function | null;
-    patchedCB: Function | null;
-    willStartCB: Function | null;
-    willUpdatePropsCB: Function | null;
-    classObj: {
-        [key: string]: boolean;
-    } | null;
-    refs: {
-        [key: string]: Component<any, T> | HTMLElement | undefined;
-    } | null;
+import type { ComponentNode } from "./component_node";
+declare type Props = {
+    [key: string]: any;
+};
+interface StaticComponentProperties {
+    template: string;
+    defaultProps?: any;
+    props?: any;
 }
-export declare const portalSymbol: unique symbol;
-export declare class Component<Props extends {} = any, T extends Env = Env> {
-    readonly __owl__: Internal<T>;
-    static template?: string | null;
-    static _template?: string | null;
-    static current: Component | null;
-    static components: {};
+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> {
+    static template: string;
     static props?: any;
     static defaultProps?: any;
-    static env: any;
-    static scheduler: Scheduler;
-    /**
-     * The `el` is the root element of the component.  Note that it could be null:
-     * this is the case if the component is not mounted yet, or is destroyed.
-     */
-    get el(): HTMLElement | null;
-    env: T;
     props: Props;
-    /**
-     * Creates an instance of Component.
-     *
-     * Note that most of the time, only the root component needs to be created by
-     * hand.  Other components should be created automatically by the framework (with
-     * the t-component directive in a template)
-     */
-    constructor(parent?: Component<any, T> | null, props?: Props);
-    /**
-     * setup is run just after the component is constructed. This is the standard
-     * location where the component can setup its hooks. It has some advantages
-     * over the constructor:
-     *  - it can be patched (useful in odoo ecosystem)
-     *  - it does not need to propagate the arguments to the super call
-     *
-     * Note: this method should not be called manually.
-     */
+    env: Env;
+    __owl__: ComponentNode;
+    constructor(props: Props, env: Env, node: ComponentNode);
     setup(): void;
-    /**
-     * willStart is an asynchronous hook that can be implemented to perform some
-     * action before the initial rendering of a component.
-     *
-     * It will be called exactly once before the initial rendering. It is useful
-     * in some cases, for example, to load external assets (such as a JS library)
-     * before the component is rendered.
-     *
-     * Note that a slow willStart method will slow down the rendering of the user
-     * interface.  Therefore, some effort should be made to make this method as
-     * fast as possible.
-     *
-     * Note: this method should not be called manually.
-     */
-    willStart(): Promise<void>;
-    /**
-     * mounted is a hook that is called each time a component is attached to the
-     * DOM. This is a good place to add some listeners, or to interact with the
-     * DOM, if the component needs to perform some measure for example.
-     *
-     * Note: this method should not be called manually.
-     *
-     * @see willUnmount
-     */
-    mounted(): void;
-    /**
-     * The willUpdateProps is an asynchronous hook, called just before new props
-     * are set. This is useful if the component needs some asynchronous task
-     * performed, depending on the props (for example, assuming that the props are
-     * some record Id, fetching the record data).
-     *
-     * This hook is not called during the first render (but willStart is called
-     * and performs a similar job).
-     */
-    willUpdateProps(nextProps: Props): Promise<void>;
-    /**
-     * The willPatch hook is called just before the DOM patching process starts.
-     * It is not called on the initial render.  This is useful to get some
-     * information which are in the DOM.  For example, the current position of the
-     * scrollbar
-     */
-    willPatch(): any;
-    /**
-     * This hook is called whenever a component did actually update its props,
-     * state or env.
-     *
-     * This method is not called on the initial render. It is useful to interact
-     * with the DOM (for example, through an external library) whenever the
-     * component was updated.
-     *
-     * Updating the component state in this hook is possible, but not encouraged.
-     * One need to be careful, because updates here will cause rerender, which in
-     * turn will cause other calls to updated. So, we need to be particularly
-     * careful at avoiding endless cycles.
-     */
-    patched(): void;
-    /**
-     * willUnmount is a hook that is called each time just before a component is
-     * unmounted from the DOM. This is a good place to remove some listeners, for
-     * example.
-     *
-     * Note: this method should not be called manually.
-     *
-     * @see mounted
-     */
-    willUnmount(): void;
-    /**
-     * catchError is a method called whenever some error happens in the rendering or
-     * lifecycle hooks of a child.
-     *
-     * It needs to be implemented by a component that is designed to handle the
-     * error properly.
-     */
-    catchError?(error?: Error): void;
-    /**
-     * Mount the component to a target element.
-     *
-     * This should only be done if the component was created manually. Components
-     * created declaratively in templates are managed by the Owl system.
-     *
-     * Note that a component can be mounted an unmounted several times
-     */
-    mount(target: HTMLElement | DocumentFragment, options?: MountOptions): Promise<void>;
-    /**
-     * The unmount method is the opposite of the mount method.  It is useful
-     * to call willUnmount calls and remove the component from the DOM.
-     */
-    unmount(): void;
-    /**
-     * The render method is the main entry point to render a component (once it
-     * is ready. This method is not initially called when the component is
-     * rendered the first time).
-     *
-     * This method will cause all its sub components to potentially rerender
-     * themselves.  Note that `render` is not called if a component is updated via
-     * its props.
-     */
-    render(force?: boolean): Promise<void>;
-    /**
-     * Destroy the component.  This operation is quite complex:
-     *  - it recursively destroy all children
-     *  - call the willUnmount hooks if necessary
-     *  - remove the dom node from the dom
-     *
-     * This should only be called manually if you created the component.  Most
-     * components will be automatically destroyed.
-     */
-    destroy(): void;
-    /**
-     * This method is called by the component system whenever its props are
-     * updated. If it returns true, then the component will be rendered.
-     * Otherwise, it will skip the rendering (also, its props will not be updated)
-     */
-    shouldUpdate(nextProps: Props): boolean;
-    /**
-     * Emit a custom event of type 'eventType' with the given 'payload' on the
-     * component's el, if it exists. However, note that the event will only bubble
-     * up to the parent DOM nodes. Thus, it must be called between mounted() and
-     * willUnmount().
-     */
-    trigger<T = any>(eventType: string, payload?: T): void;
-    /**
-     * Private helper to perform a full destroy, from the point of view of an Owl
-     * component. It does not remove the el (this is done only once on the top
-     * level destroyed component, for performance reasons).
-     *
-     * The job of this method is mostly to call willUnmount hooks, and to perform
-     * all necessary internal cleanup.
-     *
-     * Note that it does not call the __callWillUnmount method to avoid visiting
-     * all children many times.
-     */
-    __destroy(parent: Component | null): void;
-    __callMounted(): void;
-    __callWillUnmount(): void;
-    /**
-     * Private trigger method, allows to choose the component which triggered
-     * the event in the first place
-     */
-    __trigger<T>(component: Component, eventType: string, payload?: T): void;
-    /**
-     * The __updateProps method is called by the t-component directive whenever
-     * it updates a component (so, when the parent template is rerendered).
-     */
-    __updateProps(nextProps: Props, parentFiber: Fiber, scope: any): Promise<void>;
-    /**
-     * Main patching method. We call the virtual dom patch method here to convert
-     * a virtual dom vnode into some actual dom.
-     */
-    __patch(target: HTMLElement | VNode | DocumentFragment, vnode: VNode): void;
-    /**
-     * The __prepare method is only called by the t-component directive, when a
-     * subcomponent is created. It gets its scope, if any, from the
-     * parent template.
-     */
-    __prepare(parentFiber: Fiber, scope: any, cb: CallableFunction): Fiber;
-    /**
-     * Apply the stylesheets defined by the component. Note that we need to make
-     * sure all inherited stylesheets are applied as well.  We then delete the
-     * `style` key from the constructor to make sure we do not apply it again.
-     */
-    private __applyStyles;
-    __getTemplate(qweb: QWeb): string;
-    __prepareAndRender(fiber: Fiber, cb: CallableFunction): Promise<void>;
-    __render(fiber: Fiber): void;
-    /**
-     * Apply default props (only top level).
-     *
-     * Note that this method does modify in place the props
-     */
-    __applyDefaultProps(props: Object, defaultProps: Object): void;
-}
-interface MountParameters {
-    env?: Env;
-    target: HTMLElement | DocumentFragment;
-    props?: any;
-    position?: MountOptions["position"];
-}
-interface Type<T> extends Function {
-    new (...args: any[]): T;
+    render(deep?: boolean): void;
 }
-export declare function mount<T extends Type<Component>>(C: T, params: MountParameters): Promise<InstanceType<T>>;
 export {};

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

@@ -0,0 +1,67 @@
+import type { App, Env } from "../app/app";
+import { BDom, VNode } from "../blockdom";
+import { Reactive, NonReactive } from "../reactivity";
+import { Component, ComponentConstructor } from "./component";
+import { Fiber, MountFiber, MountOptions, RootFiber } from "./fibers";
+import { STATUS } from "./status";
+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): Reactive<T> | NonReactive<T>;
+export declare function component<P extends object>(name: string | ComponentConstructor<P>, props: P, key: string, ctx: ComponentNode, parent: any): ComponentNode<P>;
+declare type LifecycleHook = Function;
+export declare class ComponentNode<P extends object = any, E = any> implements VNode<ComponentNode<P, E>> {
+    el?: HTMLElement | Text | undefined;
+    app: App;
+    fiber: Fiber | null;
+    component: Component<P, E>;
+    bdom: BDom | null;
+    status: STATUS;
+    renderFn: Function;
+    parent: ComponentNode | null;
+    level: number;
+    childEnv: Env;
+    children: {
+        [key: string]: ComponentNode;
+    };
+    refs: any;
+    willStart: LifecycleHook[];
+    willUpdateProps: LifecycleHook[];
+    willUnmount: LifecycleHook[];
+    mounted: LifecycleHook[];
+    willPatch: LifecycleHook[];
+    patched: LifecycleHook[];
+    willDestroy: LifecycleHook[];
+    constructor(C: ComponentConstructor<P, E>, props: P, app: App, parent?: ComponentNode);
+    mountComponent(target: any, options?: MountOptions): void;
+    initiateRender(fiber: Fiber | MountFiber): Promise<void>;
+    render(deep?: boolean): Promise<void>;
+    _render(fiber: Fiber | RootFiber): void;
+    destroy(): void;
+    _destroy(): void;
+    updateAndRender(props: 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;
+    moveBefore(other: ComponentNode | null, afterNode: Node | null): void;
+    patch(): void;
+    _patch(): void;
+    beforeRemove(): void;
+    remove(): void;
+    cleanOutdatedChildren(): void;
+}
+export {};

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

@@ -0,0 +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 {};

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

@@ -0,0 +1,33 @@
+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;
+    constructor(node: ComponentNode, parent: Fiber | null);
+}
+export declare class RootFiber extends Fiber {
+    counter: number;
+    willPatch: Fiber[];
+    patched: Fiber[];
+    mounted: Fiber[];
+    locked: boolean;
+    complete(): 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 {};

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

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

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

@@ -0,0 +1,12 @@
+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: () => Promise<void> | any | void): void;
+export declare function onPatched(fn: () => void | any): void;
+export declare function onWillUnmount(fn: () => Promise<void> | void | any): void;
+export declare function onWillDestroy(fn: () => Promise<void> | 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 {};

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

@@ -1 +1,14 @@
-export {};
+import { ComponentConstructor } from "./component";
+/**
+ * Apply default props (only top level).
+ *
+ * Note that this method does modify in place the props
+ */
+export declare function applyDefaultProps<P>(props: P, ComponentClass: ComponentConstructor<P>): void;
+/**
+ * Validate the component props (or next props) against the (static) props
+ * description.  This is potentially an expensive operation: it may needs to
+ * visit recursively the props and all the children to check if they are valid.
+ * This is why it is only done in 'dev' mode.
+ */
+export declare function validateProps<P>(name: string | ComponentConstructor<P>, props: P, parent?: any): void;

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

@@ -1,27 +1,13 @@
-import { Fiber } from "./fiber";
-/**
- * Owl Scheduler Class
- *
- * The scheduler is the part of Owl that will effectively apply a rendering
- * whenever a fiber is ready.
- *
- * Briefly, it can be used to register root fibers.  Whenever there is an
- * active root fiber, it will poll continuously each animation frame (so, about
- * once every 16ms) and whenever a root fiber is ready, it will apply it.
- */
-interface Task {
-    fiber: Fiber;
-    callback: (err?: Error) => void;
-}
+import { Fiber, RootFiber } from "./fibers";
 export declare class Scheduler {
-    tasks: Task[];
+    static requestAnimationFrame: ((callback: FrameRequestCallback) => number) & typeof requestAnimationFrame;
+    tasks: Set<RootFiber>;
     isRunning: boolean;
     requestAnimationFrame: Window["requestAnimationFrame"];
-    constructor(requestAnimationFrame: Window["requestAnimationFrame"]);
+    constructor();
     start(): void;
     stop(): void;
-    addFiber(fiber: Fiber): Promise<void>;
-    rejectFiber(fiber: Fiber, reason: string): void;
+    addFiber(fiber: Fiber): void;
     /**
      * Process all current tasks. This only applies to the fibers that are ready.
      * Other tasks are left unchanged.
@@ -29,5 +15,3 @@ export declare class Scheduler {
     flush(): void;
     scheduleTasks(): void;
 }
-export declare const scheduler: Scheduler;
-export {};

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

@@ -0,0 +1,9 @@
+import type { Component } from "./component";
+export declare const enum STATUS {
+    NEW = 0,
+    MOUNTED = 1,
+    DESTROYED = 2
+}
+declare type STATUS_DESCR = "new" | "mounted" | "destroyed";
+export declare function status(component: Component): STATUS_DESCR;
+export {};

package/dist/types/hooks.d.ts

@@ -1,40 +1,11 @@
-import { Component, Env } from "./component/component";
-/**
- * Owl Hook System
- *
- * This file introduces the concept of hooks, similar to React or Vue hooks.
- * We have currently an implementation of:
- * - useState (reactive state)
- * - onMounted
- * - onWillUnmount
- * - useRef
- */
-/**
- * This is the main way a component can be made reactive.  The useState hook
- * will return an observed object (or array).  Changes to that value will then
- * trigger a rerendering of the current component.
- */
-export declare function useState<T>(state: T): T;
-export declare const onMounted: (cb: any) => void;
-export declare const onWillUnmount: (cb: any) => void;
-export declare const onWillPatch: (cb: any) => void;
-export declare const onPatched: (cb: any) => void;
-export declare const onWillStart: (cb: any) => void;
-export declare const onWillUpdateProps: (cb: any) => void;
+import type { Env } from "./app/app";
 /**
  * The purpose of this hook is to allow components to get a reference to a sub
  * html node or component.
  */
-interface Ref<C extends Component = Component> {
-    el: HTMLElement | null;
-    comp: C | null;
-}
-export declare function useRef<C extends Component = Component>(name: string): Ref<C>;
-/**
- * This hook is useful as a building block for some customized hooks, that may
- * need a reference to the component calling them.
- */
-export declare function useComponent<P, E extends Env>(): Component<P, E>;
+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.
@@ -45,7 +16,27 @@ export declare function useEnv<E extends Env>(): E;
  * like for all hooks, it is important that this is only called in the
  * constructor method.
  */
-export declare function useSubEnv(nextEnv: any): void;
+export declare function useSubEnv(envExtension: Env): void;
+export declare function useChildSubEnv(envExtension: Env): void;
+/**
+ * @param {...any} dependencies the dependencies computed by computeDependencies
+ * @returns {void|(()=>void)} a cleanup function that reverses the side
+ *      effects of the effect callback.
+ */
+declare type Effect = (...dependencies: any[]) => 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.
+ *
+ * @param {Effect} effect the effect to run on component mount and/or patch
+ * @param {()=>any[]} [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(effect: Effect, computeDependencies?: () => any[]): 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.
@@ -59,5 +50,5 @@ export declare function useSubEnv(nextEnv: any): void;
  *  in the constructor of the OWL component that needs to be notified,
  *  `useExternalListener(window, 'click', this._doSomething);`
  * */
-export declare function useExternalListener(target: HTMLElement | typeof window, eventName: string, handler: any, eventParams?: any): void;
+export declare function useExternalListener(target: HTMLElement | typeof window, eventName: string, handler: EventListener, eventParams?: AddEventListenerOptions): void;
 export {};

package/dist/types/index.d.ts

@@ -1,49 +1,29 @@
-/**
- * This file is the main file packaged by rollup (see rollup.config.js).  From
- * this file, we export all public owl elements.
- *
- * Note that dynamic values, such as a date or a commit hash are added by rollup
- */
-import { EventBus } from "./core/event_bus";
-import { Observer } from "./core/observer";
-import { QWeb } from "./qweb/index";
-import { config } from "./config";
-import * as _store from "./store";
-import * as _utils from "./utils";
-import * as _tags from "./tags";
-import { AsyncRoot } from "./misc/async_root";
-import { Portal } from "./misc/portal";
-import * as _hooks from "./hooks";
-import * as _context from "./context";
-import { Link } from "./router/link";
-import { RouteComponent } from "./router/route_component";
-import { Router } from "./router/router";
-export { Component, mount } from "./component/component";
-export { QWeb };
-export { config };
-export { browser } from "./browser";
-export declare const Context: typeof _context.Context;
-export declare const useState: typeof _hooks.useState;
-export declare const core: {
-    EventBus: typeof EventBus;
-    Observer: typeof Observer;
-};
-export declare const router: {
-    Router: typeof Router;
-    RouteComponent: typeof RouteComponent;
-    Link: typeof Link;
-};
-export declare const Store: typeof _store.Store;
-export declare const utils: typeof _utils;
-export declare const tags: typeof _tags;
-export declare const misc: {
-    AsyncRoot: typeof AsyncRoot;
-    Portal: typeof Portal;
-};
-export declare const hooks: typeof _hooks & {
-    useContext: typeof _context.useContext;
-    useDispatch: typeof _store.useDispatch;
-    useGetters: typeof _store.useGetters;
-    useStore: typeof _store.useStore;
+import { createBlock, html, list, mount as blockMount, multi, patch, remove, text, toggler, comment } from "./blockdom";
+export type { Reactive } from "./reactivity";
+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/app";
+export { Component } from "./component/component";
+export { useComponent, useState } from "./component/component_node";
+export { status } from "./component/status";
+export { Memo } from "./memo";
+export { xml } from "./app/template_set";
+export { reactive, markRaw, toRaw } from "./reactivity";
+export { useEffect, useEnv, useExternalListener, useRef, useChildSubEnv, useSubEnv } from "./hooks";
+export { EventBus, whenReady, loadFile, markup } from "./utils";
+export { onWillStart, onMounted, onWillUnmount, onWillUpdateProps, onWillPatch, onPatched, onWillRender, onRendered, onWillDestroy, onError, } from "./component/lifecycle_hooks";
 export declare const __info__: {};