@odoo/owl 3.0.0-alpha.2 → 3.0.0-alpha.21

package/dist/types/runtime/reactivity/proxy.d.ts

@@ -0,0 +1,47 @@
+import { Atom } from "./computations";
+type Target = object;
+type Reactive<T extends Target> = T;
+/**
+ * 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): T;
+/**
+ * Given a proxy objet, return the raw (non proxy) underlying object
+ *
+ * @param value a proxy value
+ * @returns the underlying value
+ */
+export declare function toRaw<T extends Target, U extends Reactive<T>>(value: U | T): T;
+export declare function proxifyTarget<T extends Target>(target: T, atom: Atom | null): T;
+/**
+ * Creates a reactive proxy for an object. Reading data on the proxy 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's 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 proxy proxy
+ * @param callback the function to call when an observed property of the
+ *  proxy has changed
+ * @returns a proxy that tracks changes to it
+ */
+export declare function proxy<T extends Target>(target: T): T;
+export {};

package/dist/types/runtime/reactivity/signal.d.ts

@@ -0,0 +1,31 @@
+import { ReactiveValue } from "./computations";
+export interface Signal<T> extends ReactiveValue<T> {
+    /**
+     * Update the value of the signal with a new value. If the new value is different
+     * from the previous values, all computations that depends on this signal will
+     * be invalidated, and effects will rerun.
+     */
+    set(nextValue: T): void;
+}
+interface SignalOptions<T> {
+    type?: T;
+}
+declare function invalidateSignal(signal: Signal<any>): void;
+declare function signalArray<T>(initialValue: T[], options?: SignalOptions<T>): Signal<T[]>;
+declare function signalObject<T extends Record<PropertyKey, any>>(initialValue: T, options?: SignalOptions<T>): Signal<T>;
+interface MapSignalOptions<K, V> {
+    name?: string;
+    keyType?: K;
+    valueType?: V;
+}
+declare function signalMap<K, V>(initialValue: Map<K, V>, options?: MapSignalOptions<K, V>): Signal<Map<K, V>>;
+declare function signalSet<T>(initialValue: Set<T>, options?: SignalOptions<T>): Signal<Set<T>>;
+export declare function signal<T>(value: T, options?: SignalOptions<T>): Signal<T>;
+export declare namespace signal {
+    var invalidate: typeof invalidateSignal;
+    var Array: typeof signalArray;
+    var Map: typeof signalMap;
+    var Object: typeof signalObject;
+    var Set: typeof signalSet;
+}
+export {};

package/dist/types/runtime/reactivity.d.ts

@@ -1,46 +1,57 @@
-declare type Target = object;
-declare type Reactive<T extends Target> = T;
-/**
- * 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): 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 Target, U extends Reactive<T>>(value: U | T): T;
-export declare const targets: WeakMap<object, object>;
-/**
- * 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's 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): T;
-export {};
+import type { Callback } from "./utils";
+type Target = object;
+type Reactive<T extends Target> = T;
+/**
+ * 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): 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 Target, U extends Reactive<T>>(value: U | 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: (string | number | symbol)[];
+}[];
+export declare const targets: WeakMap<object, object>;
+/**
+ * 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's 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): T;
+export {};

package/dist/types/runtime/registry.d.ts

@@ -1,15 +1,24 @@
-import { Schema } from "./validation";
-declare type Fn<T> = () => T;
-export declare class Registry<T> {
-    _map: {
-        [key: string]: [number, T];
-    };
-    _name: string;
-    _schema?: Schema;
-    items: Fn<T[]>;
-    entries: Fn<[string, T][]>;
-    constructor(name?: string, schema?: Schema);
-    set(key: string, value: T, sequence?: number): void;
-    get(key: string, defaultValue?: T): T;
-}
-export {};
+interface RegistryOptions<T> {
+    name?: string;
+    validation?: T;
+}
+export declare class Registry<T> {
+    private _map;
+    private _name;
+    private _validation?;
+    constructor(options?: RegistryOptions<T>);
+    entries: import(".").ReactiveValue<[string, T][], [string, T][]>;
+    items: import(".").ReactiveValue<T[], T[]>;
+    addById<U extends {
+        id: string;
+    } & T>(item: U, options?: {
+        sequence?: number;
+    }): Registry<T>;
+    add(key: string, value: T, options?: {
+        sequence?: number;
+    }): Registry<T>;
+    get(key: string, defaultValue?: T): T;
+    delete(key: string): void;
+    has(key: string): boolean;
+}
+export {};

package/dist/types/runtime/rendering/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, finalize: Function) => void)[]>;
+type ErrorParams = {
+    error: any;
+} & ({
+    node: ComponentNode;
+} | {
+    fiber: Fiber;
+});
+export declare function handleError(params: ErrorParams): void;
+export {};

package/dist/types/runtime/rendering/fibers.d.ts

@@ -0,0 +1,37 @@
+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;
+    deep: boolean;
+    childrenMap: ComponentNode["children"];
+    constructor(node: ComponentNode, parent: Fiber | null);
+    render(): void;
+    _render(): void;
+}
+export declare class RootFiber extends Fiber {
+    counter: number;
+    willPatch: Fiber[];
+    patched: Fiber[];
+    mounted: Fiber[];
+    locked: boolean;
+    complete(): void;
+    setCounter(newValue: number): void;
+}
+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/runtime/rendering/scheduler.d.ts

@@ -0,0 +1,21 @@
+import type { ComponentNode } from "../component_node";
+import { Fiber, RootFiber } from "./fibers";
+export declare class Scheduler {
+    static requestAnimationFrame: (callback: FrameRequestCallback) => number;
+    tasks: Set<RootFiber>;
+    requestAnimationFrame: Window["requestAnimationFrame"];
+    frame: number;
+    delayedRenders: Fiber[];
+    cancelledNodes: Set<ComponentNode>;
+    processing: boolean;
+    constructor();
+    addFiber(fiber: Fiber): void;
+    scheduleDestroy(node: ComponentNode): void;
+    /**
+     * Process all current tasks. This only applies to the fibers that are ready.
+     * Other tasks are left unchanged.
+     */
+    flush(): void;
+    processTasks(): void;
+    processFiber(fiber: RootFiber): void;
+}

package/dist/types/runtime/rendering/template_helpers.d.ts

@@ -0,0 +1,51 @@
+import { OwlError } from "../../common/owl_error";
+import { App } from "../app";
+import { BDom, createCatcher, toggler } from "../blockdom";
+import { ComponentNode } from "../component_node";
+import { markRaw } from "../reactivity/proxy";
+/**
+ * This file contains utility functions that will be injected in each template,
+ * to perform various useful tasks in the compiled code.
+ */
+declare function withDefault(value: any, defaultValue: any): any;
+declare function callSlot(ctx: any, parent: any, key: string, name: string, dynamic: boolean, extra: any, defaultContent?: (ctx: any, node: any, key: string) => BDom): BDom;
+declare function withKey(elem: any, k: string): any;
+declare function prepareList(collection: unknown): [unknown[], unknown[], number, undefined[]];
+declare function toNumber(val: string): number | string;
+declare function shallowEqual(l1: any[], l2: any[]): boolean;
+declare class LazyValue {
+    fn: any;
+    ctx: any;
+    component: any;
+    node: any;
+    key: any;
+    constructor(fn: any, ctx: any, component: any, node: any, key: any);
+    evaluate(): any;
+    toString(): any;
+}
+export declare function safeOutput(value: any, defaultValue?: any): ReturnType<typeof toggler>;
+declare function createRef(ref: any): (el: HTMLElement | null, previousEl: HTMLElement | null) => void;
+declare function callHandler(fn: any, ctx: any, ev: Event): void;
+declare function modelExpr(value: any): any;
+declare function createComponent<P extends Record<string, any>>(app: App, name: string | null, isStatic: boolean, hasSlotsProp: boolean, hasDynamicPropList: boolean, propList: string[]): (props: P, key: string, ctx: ComponentNode, parent: any, C: any) => any;
+declare function callTemplate(subTemplate: string, owner: any, app: App, ctx: any, parent: any, key: any): any;
+export declare const helpers: {
+    withDefault: typeof withDefault;
+    zero: symbol;
+    callSlot: typeof callSlot;
+    withKey: typeof withKey;
+    prepareList: typeof prepareList;
+    shallowEqual: typeof shallowEqual;
+    toNumber: typeof toNumber;
+    LazyValue: typeof LazyValue;
+    safeOutput: typeof safeOutput;
+    createCatcher: typeof createCatcher;
+    markRaw: typeof markRaw;
+    OwlError: typeof OwlError;
+    createRef: typeof createRef;
+    modelExpr: typeof modelExpr;
+    createComponent: typeof createComponent;
+    callTemplate: typeof callTemplate;
+    callHandler: typeof callHandler;
+};
+export {};

package/dist/types/runtime/resource.d.ts

@@ -0,0 +1,18 @@
+interface ResourceOptions<T> {
+    name?: string;
+    validation?: T;
+}
+export declare class Resource<T> {
+    private _items;
+    private _name?;
+    private _validation?;
+    constructor(options?: ResourceOptions<T>);
+    items: import(".").ReactiveValue<T[], T[]>;
+    add(item: T, options?: {
+        sequence?: number;
+    }): Resource<T>;
+    delete(item: T): Resource<T>;
+    has(item: T): boolean;
+}
+export declare function useResource<T>(r: Resource<T>, elements: T[]): void;
+export {};

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

@@ -1,21 +1,21 @@
-import type { ComponentNode } from "./component_node";
-import { Fiber, RootFiber } from "./fibers";
-export declare class Scheduler {
-    static requestAnimationFrame: ((callback: FrameRequestCallback) => number) & typeof requestAnimationFrame;
-    tasks: Set<RootFiber>;
-    requestAnimationFrame: Window["requestAnimationFrame"];
-    frame: number;
-    delayedRenders: Fiber[];
-    cancelledNodes: Set<ComponentNode>;
-    processing: boolean;
-    constructor();
-    addFiber(fiber: Fiber): void;
-    scheduleDestroy(node: ComponentNode): void;
-    /**
-     * Process all current tasks. This only applies to the fibers that are ready.
-     * Other tasks are left unchanged.
-     */
-    flush(): void;
-    processTasks(): void;
-    processFiber(fiber: RootFiber): void;
-}
+import type { ComponentNode } from "./component_node";
+import { Fiber, RootFiber } from "./fibers";
+export declare class Scheduler {
+    static requestAnimationFrame: ((callback: FrameRequestCallback) => number) & typeof requestAnimationFrame;
+    tasks: Set<RootFiber>;
+    requestAnimationFrame: Window["requestAnimationFrame"];
+    frame: number;
+    delayedRenders: Fiber[];
+    cancelledNodes: Set<ComponentNode>;
+    processing: boolean;
+    constructor();
+    addFiber(fiber: Fiber): void;
+    scheduleDestroy(node: ComponentNode): void;
+    /**
+     * Process all current tasks. This only applies to the fibers that are ready.
+     * Other tasks are left unchanged.
+     */
+    flush(): void;
+    processTasks(): void;
+    processFiber(fiber: RootFiber): void;
+}

package/dist/types/runtime/status.d.ts

@@ -1,10 +1,11 @@
-import type { Component } from "./component";
-export declare const enum STATUS {
-    NEW = 0,
-    MOUNTED = 1,
-    CANCELLED = 2,
-    DESTROYED = 3
-}
-declare type STATUS_DESCR = "new" | "mounted" | "cancelled" | "destroyed";
-export declare function status(component: Component): STATUS_DESCR;
-export {};
+import type { Component } from "./component";
+import { Plugin } from "./plugin_manager";
+export declare const enum STATUS {
+    NEW = 0,
+    MOUNTED = 1,// is ready, and in DOM. It has a valid el
+    CANCELLED = 2,
+    DESTROYED = 3
+}
+type STATUS_DESCR = "new" | "started" | "mounted" | "cancelled" | "destroyed";
+export declare function status(entity: Component | Plugin): STATUS_DESCR;
+export {};

package/dist/types/runtime/template_set.d.ts

@@ -1,40 +1,36 @@
-import { compile, Template, TemplateFunction } from "../compiler";
-import { Portal } from "./portal";
-import type { customDirectives } from "../common/types";
-export interface TemplateSetConfig {
-    dev?: boolean;
-    translatableAttributes?: string[];
-    translateFn?: (s: string, translationCtx: string) => string;
-    templates?: string | Document | Record<string, string>;
-    getTemplate?: (s: string) => Element | Function | string | void;
-    customDirectives?: customDirectives;
-    globalValues?: object;
-}
-export declare class TemplateSet {
-    static registerTemplate(name: string, fn: TemplateFunction): void;
-    dev: boolean;
-    rawTemplates: typeof globalTemplates;
-    templates: {
-        [name: string]: Template;
-    };
-    getRawTemplate?: (s: string) => Element | Function | string | void;
-    translateFn?: (s: string, translationCtx: string) => string;
-    translatableAttributes?: string[];
-    Portal: typeof Portal;
-    customDirectives: customDirectives;
-    runtimeUtils: object;
-    hasGlobalValues: boolean;
-    constructor(config?: TemplateSetConfig);
-    addTemplate(name: string, template: string | Element): void;
-    addTemplates(xml: string | Document): void;
-    getTemplate(name: string): Template;
-    _compileTemplate(name: string, template: string | Element): ReturnType<typeof compile>;
-    callTemplate(owner: any, subTemplate: string, ctx: any, parent: any, key: any): any;
-}
-export declare const globalTemplates: {
-    [key: string]: string | Element | TemplateFunction;
-};
-export declare function xml(...args: Parameters<typeof String.raw>): string;
-export declare namespace xml {
-    var nextId: number;
-}
+import { CustomDirectives, Template, TemplateFunction } from "../compiler";
+export interface TemplateSetConfig {
+    dev?: boolean;
+    translatableAttributes?: string[];
+    translateFn?: (s: string, translationCtx: string) => string;
+    templates?: string | Document | Record<string, string>;
+    getTemplate?: (s: string) => Element | Function | string | void;
+    customDirectives?: CustomDirectives;
+    globalValues?: object;
+}
+export declare class TemplateSet {
+    static registerTemplate(name: string, fn: TemplateFunction): void;
+    dev: boolean;
+    rawTemplates: typeof globalTemplates;
+    templates: {
+        [name: string]: Template;
+    };
+    getRawTemplate?: (s: string) => Element | Function | string | void;
+    translateFn?: (s: string, translationCtx: string) => string;
+    translatableAttributes?: string[];
+    customDirectives: CustomDirectives;
+    runtimeUtils: object;
+    hasGlobalValues: boolean;
+    constructor(config?: TemplateSetConfig);
+    addTemplate(name: string, template: string | Element): void;
+    addTemplates(xml: string | Document): void;
+    getTemplate(name: string): Template;
+    private _compileTemplate;
+}
+export declare const globalTemplates: {
+    [key: string]: string | Element | TemplateFunction;
+};
+export declare function xml(...args: Parameters<typeof String.raw>): string;
+export declare namespace xml {
+    var nextId: number;
+}

package/dist/types/runtime/types.d.ts

@@ -0,0 +1,70 @@
+import { ReactiveValue } from "./reactivity/computations";
+type Constructor<T = any> = {
+    new (...args: any[]): T;
+};
+export type GetOptionalEntries<T> = {
+    [K in keyof T as K extends `${infer P}?` ? P : never]?: T[K];
+};
+export type GetRequiredEntries<T> = {
+    [K in keyof T as K extends `${string}?` ? never : K]: T[K];
+};
+export type PrettifyShape<T> = T extends Function ? T : {
+    [K in keyof T]: T[K];
+};
+type ResolveOptionalEntries<T> = PrettifyShape<GetRequiredEntries<T> & GetOptionalEntries<T>>;
+export type KeyedObject<K extends string[]> = {
+    [P in K[number]]: any;
+};
+type ResolveShapedObject<T extends {}> = PrettifyShape<ResolveOptionalEntries<T>>;
+export type ResolveObjectType<T extends {}> = ResolveShapedObject<T extends string[] ? KeyedObject<T> : T>;
+type UnionToIntersection<U> = (U extends any ? (_: U) => any : never) extends (_: infer I) => void ? I : never;
+declare function arrayType(): any[];
+declare function arrayType<T>(elementType: T): T[];
+declare function constructorType<T extends Constructor>(constructor: T): T;
+declare function customValidator<T>(type: T, validator: (value: T) => boolean, errorMessage?: string): T;
+declare function functionType(): (...parameters: any[]) => any;
+declare function functionType<const P extends any[]>(parameters: P): (...parameters: P) => void;
+declare function functionType<const P extends any[], R>(parameters: P, result: R): (...parameters: P) => R;
+declare function instanceType<T extends Constructor>(constructor: T): InstanceType<T>;
+declare function intersection<T extends any[]>(types: T): UnionToIntersection<T[number]>;
+type LiteralTypes = number | string | boolean | null | undefined;
+declare function literalType<const T extends LiteralTypes>(literal: T): T;
+declare function literalSelection<const T extends LiteralTypes>(literals: T[]): T;
+declare function objectType(): Record<string, any>;
+declare function objectType<const Keys extends string[]>(keys: Keys): ResolveOptionalEntries<KeyedObject<Keys>>;
+declare function objectType<Shape extends {}>(shape: Shape): ResolveOptionalEntries<Shape>;
+declare function strictObjectType<const Keys extends string[]>(keys: Keys): ResolveOptionalEntries<KeyedObject<Keys>>;
+declare function strictObjectType<Shape extends {}>(shape: Shape): ResolveOptionalEntries<Shape>;
+declare function promiseType(): Promise<void>;
+declare function promiseType<T>(type: T): Promise<T>;
+declare function recordType(): Record<PropertyKey, any>;
+declare function recordType<V>(valueType: V): Record<PropertyKey, V>;
+declare function tuple<const T extends any[]>(types: T): T;
+declare function union<T extends any[]>(types: T): T[number];
+declare function reactiveValueType(): ReactiveValue<any>;
+declare function reactiveValueType<T>(type: T): ReactiveValue<T>;
+declare function ref(): HTMLElement | null;
+declare function ref<T extends Constructor<HTMLElement>>(type: T): InstanceType<T> | null;
+export declare const types: {
+    and: typeof intersection;
+    any: any;
+    array: typeof arrayType;
+    boolean: boolean;
+    constructor: typeof constructorType;
+    customValidator: typeof customValidator;
+    function: typeof functionType;
+    instanceOf: typeof instanceType;
+    literal: typeof literalType;
+    number: number;
+    object: typeof objectType;
+    or: typeof union;
+    promise: typeof promiseType;
+    record: typeof recordType;
+    ref: typeof ref;
+    selection: typeof literalSelection;
+    signal: typeof reactiveValueType;
+    strictObject: typeof strictObjectType;
+    string: string;
+    tuple: typeof tuple;
+};
+export {};

package/dist/types/runtime/utils.d.ts

@@ -1,25 +1,24 @@
-export declare type Callback = () => void;
-/**
- * Creates a batched version of a callback so that all calls to it in the same
- * microtick will only call the original callback once.
- *
- * @param callback the callback to batch
- * @returns a batched version of the original callback
- */
-export declare function batched(callback: Callback): Callback;
-/**
- * Determine whether the given element is contained in its ownerDocument:
- * either directly or with a shadow root in between.
- */
-export declare function inOwnerDocument(el?: HTMLElement): boolean;
-export declare function validateTarget(target: HTMLElement | ShadowRoot): 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 class Markup extends String {
-}
-export declare function htmlEscape(str: any): Markup;
-export declare function markup(strings: TemplateStringsArray, ...placeholders: unknown[]): Markup;
-export declare function markup(value: string): Markup;
+export type Callback = (...args: any[]) => void;
+/**
+ * Creates a batched version of a callback so that all calls to it in the same
+ * microtick will only call the original callback once.
+ *
+ * @param callback the callback to batch
+ * @returns a batched version of the original callback
+ */
+export declare function batched(callback: Callback): Callback;
+/**
+ * Determine whether the given element is contained in its ownerDocument:
+ * either directly or with a shadow root in between.
+ */
+export declare function inOwnerDocument(el?: HTMLElement): boolean;
+export declare function validateTarget(target: HTMLElement | ShadowRoot): void;
+export declare class EventBus extends EventTarget {
+    trigger(name: string, payload?: any): void;
+}
+export declare function whenReady(fn?: any): Promise<void>;
+export declare class Markup extends String {
+}
+export declare function htmlEscape(str: any): Markup;
+export declare function markup(strings: TemplateStringsArray, ...placeholders: unknown[]): Markup;
+export declare function markup(value: string): Markup;