@odoo/owl 1.4.10 → 2.0.0-alpha.1

package/dist/types/context.d.ts

@@ -1,36 +0,0 @@
-import { Component } from "./component/component";
-import { EventBus } from "./core/event_bus";
-import { Observer } from "./core/observer";
-export declare class Context extends EventBus {
-    state: any;
-    observer: Observer;
-    rev: number;
-    mapping: {
-        [componentId: number]: number;
-    };
-    constructor(state?: Object);
-    /**
-     * Instead of using trigger to emit an update event, we actually implement
-     * our own function to do that.  The reason is that we need to be smarter than
-     * a simple trigger function: we need to wait for parent components to be
-     * done before doing children components.  More precisely, if an update
-     * as an effect of destroying a children, we do not want to call any code
-     * from the child, and certainly not render it.
-     *
-     * This method implements a simple grouping algorithm by depth. If we have
-     * connected components of depths [2, 4,4,4,4, 3,8,8], the Context will notify
-     * them in the following groups: [2], [4,4,4,4], [3], [8,8]. Each group will
-     * be updated sequentially, but each components in a given group will be done in
-     * parallel.
-     *
-     * This is a very simple algorithm, but it avoids checking if a given
-     * component is a child of another.
-     */
-    __notifyComponents(): Promise<void>;
-}
-/**
- * The`useContext` hook is the normal way for a component to register themselve
- * to context state changes. The `useContext` method returns the context state
- */
-export declare function useContext(ctx: Context): any;
-export declare function useContextWithCB(ctx: Context, component: Component, method: any): any;

package/dist/types/core/event_bus.d.ts

@@ -1,42 +0,0 @@
-/**
- * We define here a simple event bus: it can
- * - emit events
- * - add/remove listeners.
- *
- * This is a useful pattern of communication in many cases.  For OWL, each
- * components and stores are event buses.
- */
-export declare type Callback = (...args: any[]) => void;
-export interface Subscription {
-    owner: any;
-    callback: Callback;
-}
-export declare class EventBus {
-    subscriptions: {
-        [eventType: string]: Subscription[];
-    };
-    /**
-     * Add a listener for the 'eventType' events.
-     *
-     * Note that the 'owner' of this event can be anything, but will more likely
-     * be a component or a class. The idea is that the callback will be called with
-     * the proper owner bound.
-     *
-     * Also, the owner should be kind of unique. This will be used to remove the
-     * listener.
-     */
-    on(eventType: string, owner: any, callback: Callback): void;
-    /**
-     * Remove a listener
-     */
-    off(eventType: string, owner: any): void;
-    /**
-     * Emit an event of type 'eventType'.  Any extra arguments will be passed to
-     * the listeners callback.
-     */
-    trigger(eventType: string, ...args: any[]): void;
-    /**
-     * Remove all subscriptions.
-     */
-    clear(): void;
-}

package/dist/types/core/observer.d.ts

@@ -1,30 +0,0 @@
-/**
- * Owl Observer
- *
- * This code contains the logic that allows Owl to observe and react to state
- * changes.
- *
- * This is a Observer class that can observe any JS values.  The way it works
- * can be summarized thusly:
- * - primitive values are not observed at all
- * - Objects and arrays are observed by replacing them with a Proxy
- * - each object/array metadata are tracked in a weakmap, and keep a revision
- *   number
- *
- * Note that this code is loosely inspired by Vue.
- */
-export declare class Observer {
-    rev: number;
-    allowMutations: boolean;
-    weakMap: WeakMap<any, any>;
-    notifyCB(): void;
-    observe<T>(value: T, parent?: any): T;
-    revNumber(value: any): number;
-    _observe(value: any, parent: any): {
-        value: any;
-        proxy: any;
-        rev: number;
-        parent: any;
-    };
-    _updateRevNumber(target: any): void;
-}

package/dist/types/core/owl_event.d.ts

@@ -1,10 +0,0 @@
-import { Component } from "../component/component";
-/**
- * We define here OwlEvent, a subclass of CustomEvent, with an additional
- * attribute:
- *  - originalComponent: the component that triggered the event
- */
-export declare class OwlEvent<T> extends CustomEvent<T> {
-    originalComponent: Component;
-    constructor(component: any, eventType: any, options: any);
-}

package/dist/types/misc/async_root.d.ts

@@ -1,13 +0,0 @@
-import { Component } from "../component/component";
-/**
- * AsyncRoot
- *
- * Owl is by default asynchronous, and the user interface will wait for all its
- * subcomponents to be rendered before updating the DOM. This is most of the
- * time what we want, but in some cases, it makes sense to "detach" a component
- * from this coordination.  This is the goal of the AsyncRoot component.
- */
-export declare class AsyncRoot extends Component {
-    static template: string;
-    __updateProps(nextProps: any, parentFiber: any): Promise<void>;
-}

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

@@ -1,70 +0,0 @@
-import { Component } from "../component/component";
-import { VNode } from "../vdom/index";
-import { OwlEvent } from "../core/owl_event";
-/**
- * Portal
- *
- * The Portal component allows to render a part of a component outside it's DOM.
- * It is for example useful for dialogs: for css reasons, dialogs are in general
- * placed in a specific spot of the DOM (e.g. directly in the body). With the
- * Portal, a component can conditionally specify in its tempate that it contains
- * a dialog, and where this dialog should be inserted in the DOM.
- *
- * The Portal component ensures that the communication between the content of
- * the Portal and its parent properly works: business events reaching the Portal
- * are re-triggered on an empty <portal> node located in the parent's DOM.
- */
-interface Props {
-    target: string;
-}
-export declare class Portal extends Component<Props> {
-    static template: string;
-    static props: {
-        target: {
-            type: StringConstructor;
-        };
-    };
-    doTargetLookUp: boolean;
-    _handledEvents: Set<string>;
-    _handlerTunnel: (f: OwlEvent<any>) => void;
-    parentEnv: any;
-    portal: VNode | null;
-    target: Element | null;
-    constructor(parent: any, props: any);
-    /**
-     * Override to revert back to a classic Component's structure
-     *
-     * @override
-     */
-    __callWillUnmount(): void;
-    /**
-     * At each DOM change, we must ensure that the portal contains exactly one
-     * child
-     */
-    __checkVNodeStructure(vnode: VNode): void;
-    /**
-     * Ensure the target is still there at whichever time we render
-     */
-    __checkTargetPresence(): void;
-    /**
-     * Move the portal's element to the target
-     */
-    __deployPortal(): void;
-    /**
-     * Override to remove from the DOM the element we have teleported
-     *
-     * @override
-     */
-    __destroy(parent: any): void;
-    /**
-     * Override to patch the element that has been teleported
-     *
-     * @override
-     */
-    __patch(target: any, vnode: any): void;
-    /**
-     * Override to set the env
-     */
-    __trigger(component: Component, eventType: string, payload?: any): void;
-}
-export {};

package/dist/types/qweb/base_directives.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/types/qweb/compilation_context.d.ts

@@ -1,69 +0,0 @@
-import { QWebVar } from "./expression_parser";
-export declare const INTERP_REGEXP: RegExp;
-export declare class CompilationContext {
-    static nextID: number;
-    code: string[];
-    variables: {
-        [key: string]: QWebVar;
-    };
-    escaping: boolean;
-    parentNode: number | null | string;
-    parentTextNode: number | null;
-    rootNode: number | null;
-    indentLevel: number;
-    rootContext: CompilationContext;
-    shouldDefineParent: boolean;
-    shouldDefineScope: boolean;
-    protectedScopeNumber: number;
-    shouldDefineQWeb: boolean;
-    shouldDefineUtils: boolean;
-    shouldDefineRefs: boolean;
-    shouldDefineResult: boolean;
-    loopNumber: number;
-    inPreTag: boolean;
-    templateName: string;
-    allowMultipleRoots: boolean;
-    hasParentWidget: boolean;
-    hasKey0: boolean;
-    keyStack: boolean[];
-    constructor(name?: string);
-    generateID(): number;
-    /**
-     * This method generates a "template key", which is basically a unique key
-     * which depends on the currently set keys, and on the iteration numbers (if
-     * we are in a loop).
-     *
-     * Such a key is necessary when we need to associate an id to some element
-     * generated by a template (for example, a component)
-     */
-    generateTemplateKey(prefix?: string): string;
-    generateCode(): string[];
-    withParent(node: number): CompilationContext;
-    subContext(key: keyof CompilationContext, value: any): CompilationContext;
-    indent(): void;
-    dedent(): void;
-    addLine(line: string): number;
-    addIf(condition: string): void;
-    addElse(): void;
-    closeIf(): void;
-    getValue(val: any): QWebVar | string;
-    /**
-     * Prepare an expression for being consumed at render time.  Its main job
-     * is to
-     * - replace unknown variables by a lookup in the context
-     * - replace already defined variables by their internal name
-     */
-    formatExpression(expr: string): string;
-    captureExpression(expr: string): string;
-    /**
-     * Perform string interpolation on the given string. Note that if the whole
-     * string is an expression, it simply returns it (formatted and enclosed in
-     * parentheses).
-     * For instance:
-     *   'Hello {{x}}!' -> `Hello ${x}`
-     *   '{{x ? 'a': 'b'}}' -> (x ? 'a' : 'b')
-     */
-    interpolate(s: string): string;
-    startProtectScope(codeBlock?: boolean): number;
-    stopProtectScope(protectID: number): void;
-}

package/dist/types/qweb/extensions.d.ts

@@ -1,28 +0,0 @@
-/**
- * Owl QWeb Extensions
- *
- * This file contains the implementation of non standard QWeb directives, added
- * by Owl and that will only work on Owl projects:
- *
- * - t-on
- * - t-ref
- * - t-transition
- * - t-mounted
- * - t-slot
- * - t-model
- */
-export declare const MODS_CODE: {
-    prevent: string;
-    self: string;
-    stop: string;
-};
-interface HandlerInfo {
-    event: string;
-    handler: string;
-}
-export declare function makeHandlerCode(ctx: any, fullName: any, value: any, putInCache: boolean, modcodes?: {
-    prevent: string;
-    self: string;
-    stop: string;
-}): HandlerInfo;
-export {};

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

@@ -1,3 +0,0 @@
-import "./base_directives";
-import "./extensions";
-export { CompiledTemplate, QWeb } from "./qweb";

package/dist/types/qweb/qweb.d.ts

@@ -1,141 +0,0 @@
-import { EventBus } from "../core/event_bus";
-import { h, VNode } from "../vdom/index";
-import { CompilationContext } from "./compilation_context";
-/**
- * Owl QWeb Engine
- *
- * In this file, you will find a QWeb engine/template compiler.  It is the core
- * of how Owl component works.
- *
- * Briefly, Owl QWeb compiles XML templates into functions that output a virtual
- * DOM representation.
- *
- * We have here:
- * - a CompilationContext class, which is an internal object that contains all
- *   compilation specific information, while a template is being compiled.
- * - a QWeb class: this is the code of the QWeb compiler.
- *
- * Note that this file does not contain the implementation of the QWeb
- * directives (see qweb_directives.ts and qweb_extensions.ts).
- */
-export declare type EvalContext = {
-    [key: string]: any;
-};
-export declare type CompiledTemplate = (context: EvalContext, extra: any) => VNode;
-interface Template {
-    elem: Element;
-    fn: CompiledTemplate;
-}
-interface CompilationInfo {
-    node: Element;
-    qweb: QWeb;
-    ctx: CompilationContext;
-    fullName: string;
-    value: string;
-}
-interface NodeCreationCompilationInfo extends CompilationInfo {
-    nodeID: number;
-    addNodeHook: Function;
-}
-export interface Directive {
-    name: string;
-    extraNames?: string[];
-    priority: number;
-    atNodeEncounter?(info: CompilationInfo): boolean | void;
-    atNodeCreation?(info: NodeCreationCompilationInfo): void;
-    finalize?(info: CompilationInfo): void;
-}
-interface QWebConfig {
-    templates?: string;
-    translateFn?(text: string): string;
-}
-export declare const TRANSLATABLE_ATTRS: string[];
-interface Utils {
-    toClassObj(expr: any): Object;
-    shallowEqual(p1: Object, p2: Object): boolean;
-    [key: string]: any;
-}
-export declare class QWeb extends EventBus {
-    templates: {
-        [name: string]: Template;
-    };
-    static utils: Utils;
-    static components: any;
-    static DIRECTIVE_NAMES: {
-        [key: string]: 1;
-    };
-    static DIRECTIVES: Directive[];
-    static TEMPLATES: {
-        [name: string]: Template;
-    };
-    static nextId: number;
-    h: typeof h;
-    static dev: boolean;
-    static enableTransitions: boolean;
-    static slots: {};
-    static nextSlotId: number;
-    subTemplates: {
-        [key: string]: number;
-    };
-    static subTemplates: {
-        [id: number]: Function;
-    };
-    isUpdating: boolean;
-    translateFn?: QWebConfig["translateFn"];
-    constructor(config?: QWebConfig);
-    static addDirective(directive: Directive): void;
-    static registerComponent(name: string, Component: any): void;
-    /**
-     * Register globally a template.  All QWeb instances will obtain their
-     * templates from their own template map, and then, from the global static
-     * TEMPLATES property.
-     */
-    static registerTemplate(name: string, template: string): void;
-    /**
-     * Add a template to the internal template map.  Note that it is not
-     * immediately compiled.
-     */
-    addTemplate(name: string, xmlString: string, allowDuplicate?: boolean): void;
-    /**
-     * Load templates from a xml (as a string or xml document).  This will look up
-     * for the first <templates> tag, and will consider each child of this as a
-     * template, with the name given by the t-name attribute.
-     */
-    addTemplates(xmlstr: string | Document): void;
-    _addTemplate(name: string, elem: Element): void;
-    _processTemplate(elem: Element): void;
-    /**
-     * Render a template
-     *
-     * @param {string} name the template should already have been added
-     */
-    render(name: string, context?: EvalContext, extra?: any): VNode;
-    /**
-     * Render a template to a html string.
-     *
-     * Note that this is more limited than the `render` method: it is not suitable
-     * to render a full component tree, since this is an asynchronous operation.
-     * This method can only render templates without components.
-     */
-    renderToString(name: string, context?: EvalContext, extra?: any): string;
-    /**
-     * Force all widgets connected to this QWeb instance to rerender themselves.
-     *
-     * This method is mostly useful for external code that want to modify the
-     * application in some cases.  For example, a router plugin.
-     */
-    forceUpdate(): void;
-    _compile(name: string, options?: {
-        elem?: Element;
-        hasParent?: boolean;
-        defineKey?: boolean;
-    }): CompiledTemplate;
-    /**
-     * Generate code from an xml node
-     *
-     */
-    _compileNode(node: ChildNode, ctx: CompilationContext): void;
-    _compileGenericNode(node: ChildNode, ctx: CompilationContext, withHandlers?: boolean): number;
-    _compileChildren(node: ChildNode, ctx: CompilationContext): void;
-}
-export {};

package/dist/types/router/link.d.ts

@@ -1,11 +0,0 @@
-import { Component } from "../component/component";
-import { Destination, RouterEnv } from "./router";
-declare type Props = Destination;
-export declare class Link<Env extends RouterEnv> extends Component<Props, Env> {
-    static template: string;
-    href: string;
-    willUpdateProps(nextProps: any): Promise<void>;
-    get isActive(): boolean;
-    navigate(ev: any): void;
-}
-export {};

package/dist/types/router/route_component.d.ts

@@ -1,6 +0,0 @@
-import { Component } from "../component/component";
-import { EnvWithRouter } from "./router";
-export declare class RouteComponent extends Component<{}, EnvWithRouter> {
-    static template: string;
-    get routeComponent(): any;
-}

package/dist/types/router/router.d.ts

@@ -1,57 +0,0 @@
-import { Env } from "../component/component";
-declare type NavigationGuard = (info: {
-    env: Env;
-    to: Route | null;
-    from: Route | null;
-}) => boolean | Destination;
-export interface Route {
-    name: string;
-    path: string;
-    extractionRegExp: RegExp;
-    component?: any;
-    redirect?: Destination;
-    params: string[];
-    beforeRouteEnter?: NavigationGuard;
-}
-export declare type RouteParams = {
-    [key: string]: string | number;
-};
-export interface RouterEnv extends Env {
-    router: Router;
-}
-export interface Destination {
-    path?: string;
-    to?: string;
-    params?: RouteParams;
-}
-interface Options {
-    mode: Router["mode"];
-}
-export interface EnvWithRouter extends Env {
-    router: Router;
-}
-export declare class Router {
-    currentRoute: Route | null;
-    currentParams: RouteParams | null;
-    mode: "history" | "hash";
-    routes: {
-        [id: string]: Route;
-    };
-    routeIds: string[];
-    env: RouterEnv;
-    constructor(env: Partial<EnvWithRouter>, routes: Partial<Route>[], options?: Options);
-    start(): Promise<void>;
-    navigate(to: Destination): Promise<boolean>;
-    _navigate(path: string, ev?: any): Promise<boolean>;
-    destToPath(dest: Destination): string;
-    get currentRouteName(): string | null;
-    private setUrlFromPath;
-    private validateDestination;
-    private routeToPath;
-    private currentPath;
-    private match;
-    private matchAndApplyRules;
-    private applyRules;
-    private getRouteParams;
-}
-export {};

package/dist/types/store.d.ts

@@ -1,63 +0,0 @@
-import { Env } from "./component/component";
-import { Context } from "./context";
-/**
- * Owl Store
- *
- * We have here:
- * - a Store class
- * - useStore hook
- * - useDispatch hook
- * - useGetters hook
- *
- * The Owl store is our answer to the problem of managing complex state across
- * components. The main idea is that the store owns some state, allow external
- * code to modify it through actions, and for each state changes,
- * connected component will be notified, and updated if necessary.
- *
- * Note that this code is partly inspired by VueX and React/Redux
- */
-export interface EnvWithStore extends Env {
-    store: Store;
-}
-export declare type Action = ({ state, dispatch, env, getters }: {
-    state: any;
-    dispatch: any;
-    env: any;
-    getters: any;
-}, ...payload: any) => any;
-export declare type Getter = ({ state: any, getters }: {
-    state: any;
-    getters: any;
-}, payload?: any) => any;
-interface StoreConfig {
-    env?: Env;
-    state?: any;
-    actions?: {
-        [name: string]: Action;
-    };
-    getters?: {
-        [name: string]: Getter;
-    };
-}
-export declare class Store extends Context {
-    actions: any;
-    env: any;
-    getters: {
-        [name: string]: (payload?: any) => any;
-    };
-    updateFunctions: {
-        [key: number]: (() => boolean)[];
-    };
-    constructor(config: StoreConfig);
-    dispatch(action: string, ...payload: any): Promise<void> | void;
-    __notifyComponents(): Promise<void>;
-}
-interface SelectorOptions {
-    store?: Store;
-    isEqual?: (a: any, b: any) => boolean;
-    onUpdate?: (result: any) => any;
-}
-export declare function useStore(selector: any, options?: SelectorOptions): any;
-export declare function useDispatch(store?: Store): Store["dispatch"];
-export declare function useGetters(store?: Store): Store["getters"];
-export {};

package/dist/types/tags.d.ts

@@ -1,29 +0,0 @@
-/**
- * Owl Tags
- *
- * We have here a (very) small collection of tag functions:
- *
- * - xml
- *
- * The plan is to add a few other tags such as css, globalcss.
- */
-/**
- * XML tag helper for defining templates.  With this, one can simply define
- * an inline template with just the template xml:
- * ```js
- *   class A extends Component {
- *     static template = xml`<div>some template</div>`;
- *   }
- * ```
- */
-export declare function xml(strings: any, ...args: any[]): string;
-/**
- * CSS tag helper for defining inline stylesheets.  With this, one can simply define
- * an inline stylesheet with just the following code:
- * ```js
- *   class A extends Component {
- *     static style = css`.component-a { color: red; }`;
- *   }
- * ```
- */
-export declare function css(strings: any, ...args: any[]): string;

package/dist/types/vdom/html_to_vdom.d.ts

@@ -1,2 +0,0 @@
-import { VNode } from "./vdom";
-export declare function htmlToVDOM(html: string): VNode[];

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

@@ -1,2 +0,0 @@
-export { h, VNode } from "./vdom";
-export declare const patch: (oldVnode: import("./vdom").VNode | Element, vnode: import("./vdom").VNode) => import("./vdom").VNode;

package/dist/types/vdom/modules.d.ts

@@ -1,5 +0,0 @@
-import { Module } from "./vdom";
-export declare const propsModule: Module;
-export declare const eventListenersModule: Module;
-export declare const attrsModule: Module;
-export declare const classModule: Module;