@odoo/owl 1.4.8 → 2.0.0-alpha.2

package/dist/types/blockdom/text.d.ts

@@ -0,0 +1,25 @@
+import type { VNode } from "./index";
+declare abstract class VSimpleNode {
+    text: string | String;
+    parentEl?: HTMLElement | undefined;
+    el?: any;
+    constructor(text: string | String);
+    mountNode(node: Node, parent: HTMLElement, afterNode: Node | null): void;
+    moveBefore(other: VText | null, afterNode: Node | null): void;
+    beforeRemove(): void;
+    remove(): void;
+    firstNode(): Node;
+    toString(): string | String;
+}
+declare class VText extends VSimpleNode {
+    mount(parent: HTMLElement, afterNode: Node | null): void;
+    patch(other: VText): void;
+}
+declare class VComment extends VSimpleNode {
+    mount(parent: HTMLElement, afterNode: Node | null): void;
+    patch(): void;
+}
+export declare function text(str: string | String): VNode<VText>;
+export declare function comment(str: string): VNode<VComment>;
+export declare function toText(value: any): string;
+export {};

package/dist/types/blockdom/toggler.d.ts

@@ -0,0 +1,16 @@
+import type { VNode } from "./index";
+declare class VToggler {
+    key: string;
+    child: VNode;
+    parentEl?: HTMLElement | undefined;
+    constructor(key: string, child: VNode);
+    mount(parent: HTMLElement, afterNode: Node | null): void;
+    moveBefore(other: VToggler | null, afterNode: Node | null): void;
+    patch(other: VToggler, withBeforeRemove: boolean): void;
+    beforeRemove(): void;
+    remove(): void;
+    firstNode(): Node | undefined;
+    toString(): string;
+}
+export declare function toggler(key: string, child: VNode): VNode<VToggler>;
+export {};

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

@@ -0,0 +1,144 @@
+import { AST, ASTComment, ASTComponent, ASTDebug, ASTDomNode, ASTLog, ASTMulti, ASTSlot, ASTTCall, ASTTCallBlock, ASTTEsc, ASTText, ASTTForEach, ASTTif, ASTTKey, ASTTOut, ASTTSet, ASTTranslation, ASTTPortal } from "./parser";
+declare type BlockType = "block" | "text" | "multi" | "list" | "html" | "comment";
+export interface Config {
+    translateFn?: (s: string) => string;
+    translatableAttributes?: string[];
+    dev?: boolean;
+}
+export interface CodeGenOptions extends Config {
+    hasSafeContext?: boolean;
+    name?: string;
+}
+declare class BlockDescription {
+    static nextBlockId: number;
+    static nextDataIds: {
+        [key: string]: number;
+    };
+    static generateId(prefix: string): string;
+    varName: string;
+    blockName: string;
+    dynamicTagName: string | null;
+    isRoot: boolean;
+    hasDynamicChildren: boolean;
+    children: BlockDescription[];
+    data: string[];
+    dom?: Node;
+    currentDom?: Element;
+    childNumber: number;
+    target: CodeTarget;
+    type: BlockType;
+    parentVar: string;
+    id: number;
+    constructor(target: CodeTarget, type: BlockType);
+    insertData(str: string, prefix?: string): number;
+    insert(dom: Node): void;
+    generateExpr(expr: string): string;
+    asXmlString(): string;
+}
+interface Context {
+    block: BlockDescription | null;
+    index: number | string;
+    forceNewBlock: boolean;
+    preventRoot?: boolean;
+    isLast?: boolean;
+    translate: boolean;
+    tKeyExpr: string | null;
+    nameSpace?: string;
+    tModelSelectedExpr?: string;
+}
+declare class CodeTarget {
+    name: string;
+    indentLevel: number;
+    loopLevel: number;
+    code: string[];
+    hasRoot: boolean;
+    hasCache: boolean;
+    hasRef: boolean;
+    refInfo: {
+        [name: string]: [string, string];
+    };
+    shouldProtectScope: boolean;
+    constructor(name: string);
+    addLine(line: string, idx?: number): void;
+    generateCode(): string;
+}
+export declare class CodeGenerator {
+    blocks: BlockDescription[];
+    ids: {
+        [key: string]: number;
+    };
+    nextBlockId: number;
+    hasSafeContext: boolean;
+    isDebug: boolean;
+    targets: CodeTarget[];
+    target: CodeTarget;
+    templateName?: string;
+    dev: boolean;
+    translateFn: (s: string) => string;
+    translatableAttributes: string[];
+    ast: AST;
+    staticCalls: {
+        id: string;
+        template: string;
+    }[];
+    helpers: Set<string>;
+    constructor(ast: AST, options: CodeGenOptions);
+    generateCode(): string;
+    compileInNewTarget(prefix: string, ast: AST, ctx: Context): string;
+    addLine(line: string): void;
+    generateId(prefix?: string): string;
+    insertAnchor(block: BlockDescription): void;
+    createBlock(parentBlock: BlockDescription | null, type: BlockType, ctx: Context): BlockDescription;
+    insertBlock(expression: string, block: BlockDescription, ctx: Context): void;
+    /**
+     * Captures variables that are used inside of an expression. This is useful
+     * because in compiled code, almost all variables are accessed through the ctx
+     * object. In the case of functions, that lookup in the context can be delayed
+     * which can cause issues if the value has changed since the function was
+     * defined.
+     *
+     * @param expr the expression to capture
+     * @param forceCapture whether the expression should capture its scope even if
+     *  it doesn't contain a function. Useful when the expression will be used as
+     *  a function body.
+     * @returns a new expression that uses the captured values
+     */
+    captureExpression(expr: string, forceCapture?: boolean): string;
+    compileAST(ast: AST, ctx: Context): void;
+    compileDebug(ast: ASTDebug, ctx: Context): void;
+    compileLog(ast: ASTLog, ctx: Context): void;
+    compileComment(ast: ASTComment, ctx: Context): void;
+    compileText(ast: ASTText, ctx: Context): void;
+    generateHandlerCode(rawEvent: string, handler: string): string;
+    compileTDomNode(ast: ASTDomNode, ctx: Context): void;
+    compileTEsc(ast: ASTTEsc, ctx: Context): void;
+    compileTOut(ast: ASTTOut, ctx: Context): void;
+    compileTIf(ast: ASTTif, ctx: Context, nextNode?: ASTDomNode): void;
+    compileTForeach(ast: ASTTForEach, ctx: Context): void;
+    compileTKey(ast: ASTTKey, ctx: Context): void;
+    compileMulti(ast: ASTMulti, ctx: Context): void;
+    compileTCall(ast: ASTTCall, ctx: Context): void;
+    compileTCallBlock(ast: ASTTCallBlock, ctx: Context): void;
+    compileTSet(ast: ASTTSet, ctx: Context): void;
+    generateComponentKey(): string;
+    /**
+     * Formats a prop name and value into a string suitable to be inserted in the
+     * generated code. For example:
+     *
+     * Name              Value            Result
+     * ---------------------------------------------------------
+     * "number"          "state"          "number: ctx['state']"
+     * "something"       ""               "something: undefined"
+     * "some-prop"       "state"          "'some-prop': ctx['state']"
+     * "onClick.bind"    "onClick"        "onClick: bind(ctx, ctx['onClick'])"
+     */
+    formatProp(name: string, value: string): string;
+    formatPropObject(obj: {
+        [prop: string]: any;
+    }): string;
+    compileComponent(ast: ASTComponent, ctx: Context): void;
+    compileTSlot(ast: ASTSlot, ctx: Context): void;
+    compileTTranslation(ast: ASTTranslation, ctx: Context): void;
+    compileTPortal(ast: ASTTPortal, ctx: Context): void;
+}
+export {};

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

@@ -0,0 +1,9 @@
+import type { BDom } from "../blockdom";
+import { Config } from "./code_generator";
+export declare type Template = (context: any, vnode: any, key?: string) => BDom;
+export declare type TemplateFunction = (blocks: any, utils: any) => Template;
+interface CompileOptions extends Config {
+    name?: string;
+}
+export declare function compile(template: string | Element, options?: CompileOptions): TemplateFunction;
+export {};

package/dist/types/{qweb/expression_parser.d.ts → compiler/inline_expressions.d.ts}

@@ -34,6 +34,7 @@ interface Token {
     size?: number;
     varName?: string;
     replace?: Function;
+    isLocal?: boolean;
 }
 /**
  * Convert a javascript expression (as a string) into a list of tokens. For
@@ -72,10 +73,8 @@ export declare function tokenize(expr: string): Token[];
  * the arrow operator, then we add the current (or some previous tokens) token to
  * the list of variables so it does not get replaced by a lookup in the context
  */
-export declare function compileExprToArray(expr: string, scope: {
-    [key: string]: QWebVar;
-}): Token[];
-export declare function compileExpr(expr: string, scope: {
-    [key: string]: QWebVar;
-}): string;
+export declare function compileExprToArray(expr: string): Token[];
+export declare function compileExpr(expr: string): string;
+export declare const INTERP_REGEXP: RegExp;
+export declare function interpolate(s: string): string;
 export {};

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

@@ -0,0 +1,157 @@
+export declare const enum ASTType {
+    Text = 0,
+    Comment = 1,
+    DomNode = 2,
+    Multi = 3,
+    TEsc = 4,
+    TIf = 5,
+    TSet = 6,
+    TCall = 7,
+    TOut = 8,
+    TForEach = 9,
+    TKey = 10,
+    TComponent = 11,
+    TDebug = 12,
+    TLog = 13,
+    TSlot = 14,
+    TCallBlock = 15,
+    TTranslation = 16,
+    TPortal = 17
+}
+export interface ASTText {
+    type: ASTType.Text;
+    value: string;
+}
+export interface ASTComment {
+    type: ASTType.Comment;
+    value: string;
+}
+interface TModelInfo {
+    hasDynamicChildren?: boolean;
+    baseExpr: string;
+    expr: string;
+    targetAttr: string;
+    specialInitTargetAttr: string | null;
+    eventType: "change" | "click" | "input";
+    shouldTrim: boolean;
+    shouldNumberize: boolean;
+}
+export interface ASTDomNode {
+    type: ASTType.DomNode;
+    tag: string;
+    dynamicTag: string | null;
+    attrs: {
+        [key: string]: string;
+    };
+    content: AST[];
+    ref: string | null;
+    on: {
+        [key: string]: string;
+    };
+    model?: TModelInfo | null;
+    ns: string | null;
+}
+export interface ASTMulti {
+    type: ASTType.Multi;
+    content: AST[];
+}
+export interface ASTTEsc {
+    type: ASTType.TEsc;
+    expr: string;
+    defaultValue: string;
+}
+export interface ASTTOut {
+    type: ASTType.TOut;
+    expr: string;
+    body: AST[] | null;
+}
+export interface ASTTif {
+    type: ASTType.TIf;
+    condition: string;
+    content: AST;
+    tElif: {
+        condition: string;
+        content: AST;
+    }[] | null;
+    tElse: AST | null;
+}
+export interface ASTTSet {
+    type: ASTType.TSet;
+    name: string;
+    value: string | null;
+    defaultValue: string | null;
+    body: AST[] | null;
+}
+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;
+}
+export interface ASTTKey {
+    type: ASTType.TKey;
+    expr: string;
+    content: AST;
+}
+export interface ASTTCall {
+    type: ASTType.TCall;
+    name: string;
+    body: AST[] | null;
+}
+export interface ASTComponent {
+    type: ASTType.TComponent;
+    name: string;
+    isDynamic: boolean;
+    dynamicProps: string | null;
+    props: {
+        [name: string]: string;
+    };
+    slots: {
+        [name: string]: {
+            content: AST;
+            attrs?: {
+                [key: string]: string;
+            };
+            scope?: string;
+        };
+    };
+}
+export interface ASTSlot {
+    type: ASTType.TSlot;
+    name: string;
+    attrs: {
+        [key: string]: string;
+    };
+    defaultContent: AST | null;
+}
+export interface ASTTCallBlock {
+    type: ASTType.TCallBlock;
+    name: string;
+}
+export interface ASTDebug {
+    type: ASTType.TDebug;
+    content: AST | null;
+}
+export interface ASTLog {
+    type: ASTType.TLog;
+    expr: string;
+    content: AST | null;
+}
+export interface ASTTranslation {
+    type: ASTType.TTranslation;
+    content: AST | null;
+}
+export interface ASTTPortal {
+    type: ASTType.TPortal;
+    target: string;
+    content: AST;
+}
+export declare type AST = ASTText | ASTComment | ASTDomNode | ASTMulti | ASTTEsc | ASTTif | ASTTSet | ASTTCall | ASTTOut | ASTTForEach | ASTTKey | ASTComponent | ASTSlot | ASTTCallBlock | ASTLog | ASTDebug | ASTTranslation | ASTTPortal;
+export declare function parse(xml: string | Element): AST;
+export {};

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(): void;
 }
-export declare function mount<T extends Type<Component>>(C: T, params: MountParameters): Promise<InstanceType<T>>;
 export {};