@odoo/owl 1.4.7 → 2.0.0-alpha.1

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

@@ -0,0 +1,54 @@
+import type { App, Env } from "../app/app";
+import { BDom, VNode } from "../blockdom";
+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;
+export declare function component(name: string | typeof Component, props: any, key: string, ctx: ComponentNode, parent: any): ComponentNode;
+declare type LifecycleHook = Function;
+export declare class ComponentNode<P = 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(): 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;
+    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,32 @@
+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;
+    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 } 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 { 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__: {};

package/dist/types/memo.d.ts

@@ -0,0 +1,6 @@
+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);
+}

package/dist/types/portal.d.ts

@@ -0,0 +1,11 @@
+import { Component } from "./component/component";
+export declare class Portal extends Component {
+    static template: string;
+    static props: {
+        target: {
+            type: StringConstructor;
+        };
+        slots: boolean;
+    };
+    setup(): void;
+}

package/dist/types/reactivity.d.ts

@@ -0,0 +1,64 @@
+import { Callback } from "./utils";
+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 & {
+    [SKIP]: any;
+};
+/**
+ * Mark an object or array so that it is ignored by the reactivity system
+ *
+ * @param value the value to mark
+ * @returns the object itself
+ */
+export declare function markRaw<T extends Target>(value: T): NonReactive<T>;
+/**
+ * Given a reactive objet, return the raw (non reactive) underlying object
+ *
+ * @param value a reactive value
+ * @returns the underlying value
+ */
+export declare function toRaw<T extends object>(value: Reactive<T>): T;
+/**
+ * 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
+ * notify callback to be called if there are suscriptions to that data. Nested
+ * objects and arrays are automatically made reactive as well.
+ *
+ * Whenever you are notified of a change, all subscriptions are cleared, and if
+ * you would like to be notified of any further changes, you should go read
+ * the underlying data again. We assume that if you don't go read it again after
+ * being notified, it means that you are no longer interested in that data.
+ *
+ * Subscriptions:
+ * + Reading a property on an object will subscribe you to changes in the value
+ *    of that property.
+ * + Accessing an object keys (eg with Object.keys or with `for..in`) will
+ *    subscribe you to the creation/deletion of keys. Checking the presence of a
+ *    key on the object with 'in' has the same effect.
+ * - getOwnPropertyDescriptor does not currently subscribe you to the property.
+ *    This is a choice that was made because changing a key's value will trigger
+ *    this trap and we do not want to subscribe by writes. This also means that
+ *    Object.hasOwnProperty doesn't subscribe as it goes through this trap.
+ *
+ * @param target the object for which to create a reactive proxy
+ * @param callback the function to call when an observed property of the
+ *  reactive has changed
+ * @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

@@ -1,25 +1,18 @@
+export declare type Callback = () => void;
 /**
- * Owl Utils
+ * Creates a batched version of a callback so that all calls to it in the same
+ * microtick will only call the original callback once.
  *
- * We have here a small collection of utility functions:
- *
- * - whenReady
- * - loadJS
- * - loadFile
- * - escape
- * - debounce
+ * @param callback the callback to batch
+ * @returns a batched version of the original callback
  */
-export declare function whenReady(fn?: any): Promise<unknown>;
-export declare function loadJS(url: string): Promise<void>;
+export declare function batched(callback: Callback): Callback;
+export declare function validateTarget(target: HTMLElement): void;
+export declare class EventBus extends EventTarget {
+    trigger(name: string, payload?: any): void;
+}
+export declare function whenReady(fn?: any): Promise<void>;
 export declare function loadFile(url: string): Promise<string>;
-export declare function escape(str: string | number | undefined): string;
-/**
- * Returns a function, that, as long as it continues to be invoked, will not
- * be triggered. The function will be called after it stops being called for
- * N milliseconds. If `immediate` is passed, trigger the function on the
- * leading edge, instead of the trailing.
- *
- * Inspired by https://davidwalsh.name/javascript-debounce-function
- */
-export declare function debounce(func: Function, wait: number, immediate?: boolean): Function;
-export declare function shallowEqual(p1: any, p2: any): boolean;
+export declare class Markup extends String {
+}
+export declare function markup(value: any): Markup;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@odoo/owl",
-  "version": "1.4.7",
+  "version": "2.0.0-alpha.1",
   "description": "Odoo Web Library (OWL)",
   "main": "dist/owl.cjs.js",
   "browser": "dist/owl.iife.js",
@@ -13,14 +13,15 @@
     "node": ">=12.18.3"
   },
   "scripts": {
-    "build:bundle": "rollup -c",
+    "build:bundle": "rollup -c --failAfterWarnings",
     "build": "npm run build:bundle",
     "test": "jest",
+    "test:debug": "node --inspect-brk node_modules/.bin/jest --runInBand --watch --testTimeout=5000000",
     "test:watch": "jest --watch",
-    "tools:serve": "python3 tools/server.py || python tools/server.py",
-    "tools": "npm run build && npm run tools:serve",
-    "pretools:watch": "npm run build",
-    "tools:watch": "npm-run-all  --parallel tools:serve \"build:* -- --watch\"",
+    "playground:serve": "python3 tools/server.py || python tools/server.py",
+    "playground": "npm run build && npm run playground:serve",
+    "preplayground:watch": "npm run build",
+    "playground:watch": "npm-run-all  --parallel playground:serve \"build:* -- --watch\"",
     "prettier": "prettier {src/*.ts,src/**/*.ts,tests/*.ts,tests/**/*.ts,doc/*.md,doc/**/*.md} --write",
     "check-formatting": "prettier {src/*.ts,src/**/*.ts,tests/*.ts,tests/**/*.ts,doc/*.md,doc/**/*.md} --check",
     "publish": "npm run build && npm publish",
@@ -45,17 +46,18 @@
     "git-rev-sync": "^1.12.0",
     "github-api": "^3.3.0",
     "jest": "^27.1.0",
+    "jest-diff": "^27.3.1",
     "jest-environment-jsdom": "^27.1.0",
     "live-server": "^1.2.1",
     "npm-run-all": "^4.1.5",
-    "prettier": "^2.0.4",
+    "prettier": "2.4.1",
     "rollup": "^2.56.3",
     "rollup-plugin-terser": "^7.0.2",
-    "rollup-plugin-typescript2": "^0.30.0",
+    "rollup-plugin-typescript2": "^0.31.1",
     "sass": "^1.16.1",
     "source-map-support": "^0.5.10",
     "ts-jest": "^27.0.5",
-    "typescript": "^3.7.2",
+    "typescript": "4.5.2",
     "uglify-es": "^3.3.9"
   },
   "jest": {
@@ -64,6 +66,9 @@
       "<rootDir>/src",
       "<rootDir>/tests"
     ],
+    "setupFiles": [
+      "./tests/mocks/mockEventTarget.js"
+    ],
     "transform": {
       "^.+\\.ts?$": "ts-jest"
     },

package/dist/types/browser.d.ts

@@ -1,12 +0,0 @@
-export interface Browser {
-    setTimeout: Window["setTimeout"];
-    clearTimeout: Window["clearTimeout"];
-    setInterval: Window["setInterval"];
-    clearInterval: Window["clearInterval"];
-    requestAnimationFrame: Window["requestAnimationFrame"];
-    random: Math["random"];
-    Date: typeof Date;
-    fetch: Window["fetch"];
-    localStorage: Window["localStorage"];
-}
-export declare const browser: Browser;

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

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

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

@@ -1,75 +0,0 @@
-import { VNode } from "../vdom/index";
-import { Component, MountPosition } from "./component";
-/**
- * Owl Fiber Class
- *
- * Fibers are small abstractions designed to contain all the internal state
- * associated with a "rendering work unit", relative to a specific component.
- *
- * A rendering will cause the creation of a fiber for each impacted components.
- *
- * Fibers capture all that necessary information, which is critical to owl
- * asynchronous rendering pipeline. Fibers can be cancelled, can be in different
- * states and in general determine the state of the rendering.
- */
-export declare class Fiber {
-    static nextId: number;
-    id: number;
-    force: boolean;
-    isCompleted: boolean;
-    shouldPatch: boolean;
-    isRendered: boolean;
-    counter: number;
-    target: HTMLElement | DocumentFragment | null;
-    position: MountPosition | null;
-    scope: any;
-    component: Component;
-    vnode: VNode | null;
-    root: Fiber;
-    child: Fiber | null;
-    sibling: Fiber | null;
-    lastChild: Fiber | null;
-    parent: Fiber | null;
-    error?: Error;
-    constructor(parent: Fiber | null, component: Component, force: boolean, target: HTMLElement | DocumentFragment | null, position: MountPosition | null);
-    /**
-     * When the oldFiber is not completed yet, and both oldFiber and this fiber
-     * are root fibers, we want to reuse the oldFiber instead of creating a new
-     * one. Doing so will guarantee that the initiator(s) of those renderings will
-     * be notified (the promise will resolve) when the last rendering will be done.
-     *
-     * This function thus assumes that oldFiber is a root fiber.
-     */
-    _reuseFiber(oldFiber: Fiber): void;
-    /**
-     * In some cases, a rendering initiated at some component can detect that it
-     * should be part of a larger rendering initiated somewhere up the component
-     * tree.  In that case, it needs to cancel the previous rendering and
-     * remap itself as a part of the current parent rendering.
-     */
-    _remapFiber(oldFiber: Fiber): void;
-    /**
-     * This function has been taken from
-     * https://medium.com/react-in-depth/the-how-and-why-on-reacts-usage-of-linked-list-in-fiber-67f1014d0eb7
-     */
-    _walk(doWork: (f: Fiber) => Fiber | null): void;
-    /**
-     * Successfully complete the work of the fiber: call the mount or patch hooks
-     * and patch the DOM. This function is called once the fiber and its children
-     * are ready, and the scheduler decides to process it.
-     */
-    complete(): void;
-    /**
-     * Cancel a fiber and all its children.
-     */
-    cancel(): void;
-    /**
-     * This is the global error handler for errors occurring in Owl main lifecycle
-     * methods.  Caught errors are triggered on the QWeb instance, and are
-     * potentially given to some parent component which implements `catchError`.
-     *
-     * If there are no such component, we destroy everything. This is better than
-     * being in a corrupted state.
-     */
-    handleError(error: Error): void;
-}

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

@@ -1,12 +0,0 @@
-/**
- * Owl Style System
- *
- * This files contains the Owl code related to processing (extended) css strings
- * and creating/adding <style> tags to the document head.
- */
-export declare const STYLESHEETS: {
-    [id: string]: HTMLStyleElement;
-};
-export declare function processSheet(str: string): string;
-export declare function registerSheet(id: string, css: string): void;
-export declare function activateSheet(id: any, name: any): void;

package/dist/types/config.d.ts

@@ -1,12 +0,0 @@
-/**
- * This file creates and exports the OWL 'config' object, with keys:
- *  - 'mode': 'prod' or 'dev',
- *  - 'env': the environment to use in root components.
- */
-interface Config {
-    mode: string;
-    enableTransitions: boolean;
-    translatableAttributes: string[];
-}
-export declare const config: Config;
-export {};