@odoo/owl 2.0.0-alpha.1 → 2.0.0-beta-4

package/dist/types/compiler/parser.d.ts

@@ -1,3 +1,9 @@
+export declare type EventHandlers = {
+    [eventName: string]: string;
+};
+export declare type Attrs = {
+    [attrs: string]: string;
+};
 export declare const enum ASTType {
     Text = 0,
     Comment = 1,
@@ -27,28 +33,24 @@ export interface ASTComment {
     value: string;
 }
 interface TModelInfo {
-    hasDynamicChildren?: boolean;
     baseExpr: string;
     expr: string;
     targetAttr: string;
-    specialInitTargetAttr: string | null;
     eventType: "change" | "click" | "input";
     shouldTrim: boolean;
     shouldNumberize: boolean;
+    hasDynamicChildren: boolean;
+    specialInitTargetAttr: string | null;
 }
 export interface ASTDomNode {
     type: ASTType.DomNode;
     tag: string;
-    dynamicTag: string | null;
-    attrs: {
-        [key: string]: string;
-    };
     content: AST[];
+    attrs: Attrs | null;
     ref: string | null;
-    on: {
-        [key: string]: string;
-    };
-    model?: TModelInfo | null;
+    on: EventHandlers | null;
+    model: TModelInfo | null;
+    dynamicTag: string | null;
     ns: string | null;
 }
 export interface ASTMulti {
@@ -86,13 +88,13 @@ export interface ASTTForEach {
     type: ASTType.TForEach;
     collection: string;
     elem: string;
-    key: string | null;
     body: AST;
     memo: string;
     hasNoFirst: boolean;
     hasNoLast: boolean;
     hasNoIndex: boolean;
     hasNoValue: boolean;
+    key: string | null;
 }
 export interface ASTTKey {
     type: ASTType.TKey;
@@ -104,30 +106,30 @@ export interface ASTTCall {
     name: string;
     body: AST[] | null;
 }
+interface SlotDefinition {
+    content: AST;
+    scope: string | null;
+    on: EventHandlers | null;
+    attrs: Attrs | null;
+}
 export interface ASTComponent {
     type: ASTType.TComponent;
     name: string;
     isDynamic: boolean;
     dynamicProps: string | null;
+    on: EventHandlers | null;
     props: {
         [name: string]: string;
-    };
+    } | null;
     slots: {
-        [name: string]: {
-            content: AST;
-            attrs?: {
-                [key: string]: string;
-            };
-            scope?: string;
-        };
-    };
+        [name: string]: SlotDefinition;
+    } | null;
 }
 export interface ASTSlot {
     type: ASTType.TSlot;
     name: string;
-    attrs: {
-        [key: string]: string;
-    };
+    attrs: Attrs | null;
+    on: EventHandlers | null;
     defaultContent: AST | null;
 }
 export interface ASTTCallBlock {

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

@@ -17,6 +17,6 @@ export declare class Component<Props = any, Env = any> {
     __owl__: ComponentNode;
     constructor(props: Props, env: Env, node: ComponentNode);
     setup(): void;
-    render(): void;
+    render(deep?: boolean): void;
 }
 export {};

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

@@ -1,19 +1,32 @@
 import type { App, Env } from "../app/app";
 import { BDom, VNode } from "../blockdom";
+import { getSubscriptions, NonReactive, Reactive } from "../reactivity";
 import { Component, ComponentConstructor } from "./component";
-import { Fiber, MountFiber, MountOptions, RootFiber } from "./fibers";
+import { Fiber, MountFiber, MountOptions } from "./fibers";
 import { STATUS } from "./status";
 export declare function getCurrent(): ComponentNode;
 export declare function useComponent(): Component;
-export declare function component(name: string | typeof Component, props: any, key: string, ctx: ComponentNode, parent: any): ComponentNode;
+/**
+ * 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 = any, E = any> implements VNode<ComponentNode<P, E>> {
+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;
+    forceNextRender: boolean;
     renderFn: Function;
     parent: ComponentNode | null;
     level: number;
@@ -32,8 +45,7 @@ export declare class ComponentNode<P = any, E = any> implements VNode<ComponentN
     constructor(C: ComponentConstructor<P, E>, props: P, app: App, parent?: ComponentNode);
     mountComponent(target: any, options?: MountOptions): void;
     initiateRender(fiber: Fiber | MountFiber): Promise<void>;
-    render(): Promise<void>;
-    _render(fiber: Fiber | RootFiber): void;
+    render(deep?: boolean): Promise<void>;
     destroy(): void;
     _destroy(): void;
     updateAndRender(props: any, parentFiber: Fiber): Promise<void>;
@@ -47,8 +59,11 @@ export declare class ComponentNode<P = any, E = any> implements VNode<ComponentN
     mount(parent: HTMLElement, anchor: ChildNode): void;
     moveBefore(other: ComponentNode | null, afterNode: Node | null): void;
     patch(): void;
+    _patch(): void;
     beforeRemove(): void;
     remove(): void;
     cleanOutdatedChildren(): void;
+    get name(): string;
+    get subscriptions(): ReturnType<typeof getSubscriptions>;
 }
 export {};

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

@@ -9,7 +9,10 @@ export declare class Fiber {
     parent: Fiber | null;
     children: Fiber[];
     appliedToDom: boolean;
+    deep: boolean;
     constructor(node: ComponentNode, parent: Fiber | null);
+    render(): void;
+    _render(): void;
 }
 export declare class RootFiber extends Fiber {
     counter: number;
@@ -17,7 +20,10 @@ export declare class RootFiber extends Fiber {
     patched: Fiber[];
     mounted: Fiber[];
     locked: boolean;
+    delayedRenders: Fiber[];
+    reachedChildren: WeakSet<ComponentNode>;
     complete(): void;
+    setCounter(newValue: number): void;
 }
 declare type Position = "first-child" | "last-child";
 export interface MountOptions {

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

@@ -2,16 +2,15 @@ import { Fiber, RootFiber } from "./fibers";
 export declare class Scheduler {
     static requestAnimationFrame: ((callback: FrameRequestCallback) => number) & typeof requestAnimationFrame;
     tasks: Set<RootFiber>;
-    isRunning: boolean;
     requestAnimationFrame: Window["requestAnimationFrame"];
+    frame: number;
+    shouldClear: boolean;
     constructor();
-    start(): void;
-    stop(): void;
     addFiber(fiber: Fiber): void;
     /**
      * Process all current tasks. This only applies to the fibers that are ready.
      * Other tasks are left unchanged.
      */
     flush(): void;
-    scheduleTasks(): void;
+    processFiber(fiber: RootFiber): void;
 }

package/dist/types/index.d.ts

@@ -18,12 +18,10 @@ export declare const blockDom: {
 };
 export { App, mount } from "./app/app";
 export { Component } from "./component/component";
-export { useComponent } from "./component/component_node";
+export { useComponent, useState } from "./component/component_node";
 export { status } from "./component/status";
-export { Memo } from "./memo";
-export { xml } from "./app/template_set";
-export { useState, reactive, markRaw, toRaw } from "./reactivity";
+export { reactive, markRaw, toRaw } from "./reactivity";
 export { useEffect, useEnv, useExternalListener, useRef, useChildSubEnv, useSubEnv } from "./hooks";
-export { EventBus, whenReady, loadFile, markup } from "./utils";
+export { EventBus, whenReady, loadFile, markup, xml } from "./utils";
 export { onWillStart, onMounted, onWillUnmount, onWillUpdateProps, onWillPatch, onPatched, onWillRender, onRendered, onWillDestroy, onError, } from "./component/lifecycle_hooks";
 export declare const __info__: {};

package/dist/types/reactivity.d.ts

@@ -1,11 +1,11 @@
 import { Callback } from "./utils";
-declare const TARGET: unique symbol;
+export declare const TARGET: unique symbol;
 declare const SKIP: unique symbol;
 declare type Target = object;
 export declare type Reactive<T extends Target = Target> = T & {
     [TARGET]: any;
 };
-declare type NonReactive<T extends Target = Target> = T & {
+export declare type NonReactive<T extends Target = Target> = T & {
     [SKIP]: any;
 };
 /**
@@ -22,6 +22,16 @@ export declare function markRaw<T extends Target>(value: T): NonReactive<T>;
  * @returns the underlying value
  */
 export declare function toRaw<T extends object>(value: Reactive<T>): T;
+/**
+ * Clears all subscriptions of the Reactives associated with a given callback.
+ *
+ * @param callback the callback for which the reactives need to be cleared
+ */
+export declare function clearReactivesForCallback(callback: Callback): void;
+export declare function getSubscriptions(callback: Callback): {
+    target: object;
+    keys: PropertyKey[];
+}[];
 /**
  * Creates a reactive proxy for an object. Reading data on the reactive object
  * subscribes to changes to the data. Writing data on the object will cause the
@@ -50,15 +60,4 @@ export declare function toRaw<T extends object>(value: Reactive<T>): T;
  * @returns a proxy that tracks changes to it
  */
 export declare function reactive<T extends Target>(target: T, callback?: Callback): Reactive<T> | NonReactive<T>;
-/**
- * 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 {};

package/dist/types/utils.d.ts

@@ -16,3 +16,10 @@ export declare function loadFile(url: string): Promise<string>;
 export declare class Markup extends String {
 }
 export declare function markup(value: any): Markup;
+export declare const globalTemplates: {
+    [key: string]: string | Element;
+};
+export declare function xml(...args: Parameters<typeof String.raw>): string;
+export declare namespace xml {
+    var nextId: number;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@odoo/owl",
-  "version": "2.0.0-alpha.1",
+  "version": "2.0.0-beta-4",
   "description": "Odoo Web Library (OWL)",
   "main": "dist/owl.cjs.js",
   "browser": "dist/owl.iife.js",

package/dist/types/memo.d.ts

@@ -1,6 +0,0 @@
-import { Component } from "./component/component";
-import type { ComponentNode } from "./component/component_node";
-export declare class Memo extends Component {
-    static template: string;
-    constructor(props: any, env: any, node: ComponentNode);
-}