@odoo/owl 1.4.10 → 2.0.0-alpha.3

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;

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

@@ -1,101 +0,0 @@
-/**
- * Owl VDOM
- *
- * This file contains an implementation of a virtual DOM, which is a system that
- * can generate in-memory representations of a DOM tree, compare them, and
- * eventually change a concrete DOM tree to match its representation, in an
- * hopefully efficient way.
- *
- * Note that this code is a fork of Snabbdom, slightly tweaked/optimized for our
- * needs (see https://github.com/snabbdom/snabbdom).
- *
- * The main exported values are:
- * - interface VNode
- * - h function (a helper function to generate a vnode)
- * - patch function (to apply a vnode to an actual DOM node)
- */
-declare global {
-    interface Element {
-        setAttribute(name: string, value: string | number | boolean): void;
-        setAttributeNS(namespaceURI: string, qualifiedName: string, value: string | number | boolean): void;
-    }
-}
-declare type Props = Record<string, any>;
-declare type Attrs = Record<string, string | number | boolean>;
-declare type On = {
-    [N in keyof HTMLElementEventMap]?: (ev: HTMLElementEventMap[N]) => void;
-} & {
-    [event: string]: EventListener;
-};
-export interface Module {
-    pre: PreHook;
-    create: CreateHook;
-    update: UpdateHook;
-    destroy: DestroyHook;
-    remove: RemoveHook;
-    post: PostHook;
-}
-declare type Key = string | number;
-export interface VNode {
-    sel: string | undefined;
-    data: VNodeData | undefined;
-    children: Array<VNode | string> | undefined;
-    elm: Node | undefined;
-    text: string | undefined;
-    key: Key | undefined;
-}
-export interface VNodeData {
-    props?: Props;
-    attrs?: Attrs;
-    on?: On;
-    hook?: Hooks;
-    key?: Key;
-    ns?: string;
-    [key: string]: any;
-}
-export declare function init(modules: Array<Partial<Module>>, domApi?: DOMAPI): (oldVnode: VNode | Element, vnode: VNode) => VNode;
-interface DOMAPI {
-    createElement: (tagName: any) => HTMLElement;
-    createElementNS: (namespaceURI: string, qualifiedName: string) => Element;
-    createTextNode: (text: string) => Text;
-    createComment: (text: string) => Comment;
-    insertBefore: (parentNode: Node, newNode: Node, referenceNode: Node | null) => void;
-    removeChild: (node: Node, child: Node) => void;
-    appendChild: (node: Node, child: Node) => void;
-    parentNode: (node: Node) => Node;
-    nextSibling: (node: Node) => Node;
-    tagName: (elm: Element) => string;
-    setTextContent: (node: Node, text: string | null) => void;
-}
-declare type PreHook = () => any;
-declare type InitHook = (vNode: VNode) => any;
-declare type CreateHook = (emptyVNode: VNode, vNode: VNode) => any;
-declare type InsertHook = (vNode: VNode) => any;
-declare type PrePatchHook = (oldVNode: VNode, vNode: VNode) => any;
-declare type UpdateHook = (oldVNode: VNode, vNode: VNode) => any;
-declare type PostPatchHook = (oldVNode: VNode, vNode: VNode) => any;
-declare type DestroyHook = (vNode: VNode) => any;
-declare type RemoveHook = (vNode: VNode, removeCallback: () => void) => any;
-declare type PostHook = () => any;
-interface Hooks {
-    pre?: PreHook;
-    init?: InitHook;
-    create?: CreateHook;
-    insert?: InsertHook;
-    prepatch?: PrePatchHook;
-    update?: UpdateHook;
-    postpatch?: PostPatchHook;
-    destroy?: DestroyHook;
-    remove?: RemoveHook;
-    post?: PostHook;
-}
-declare type VNodes = Array<VNode>;
-declare type VNodeChildElement = VNode | string | number | undefined | null;
-declare type ArrayOrElement<T> = T | T[];
-declare type VNodeChildren = ArrayOrElement<VNodeChildElement>;
-export declare function addNS(data: any, children: VNodes | undefined, sel: string | undefined): void;
-export declare function h(sel: string): VNode;
-export declare function h(sel: string, data: VNodeData): VNode;
-export declare function h(sel: string, children: VNodeChildren): VNode;
-export declare function h(sel: string, data: VNodeData, children: VNodeChildren): VNode;
-export {};