@odoo/owl 2.8.1 → 3.0.0-alpha.10

package/dist/types/runtime/relationalModel/web/webModelTypes.d.ts

@@ -0,0 +1,139 @@
+export interface WebModelConfig {
+    isMonoRecord: boolean;
+    context: Record<string, any>;
+    fieldsToAggregate: string[];
+    activeFields?: {
+        [key: string]: ActiveFieldInfo;
+    };
+    fields: {
+        [key: string]: FieldInfo;
+    };
+    isRoot: boolean;
+    resModel: string;
+    groupBy: string[];
+    resId?: number | false;
+    resIds?: number[];
+    mode?: "edit" | "readonly";
+    domain: any[];
+    orderBy: OrderBy[];
+    groups?: Record<string, any>;
+    offset: number;
+    limit: number;
+    countLimit: number;
+    currentGroups?: {
+        params: string;
+        groups: any[];
+    };
+    loadId?: string;
+    openGroupsByDefault?: boolean;
+    [key: string]: any;
+}
+export interface FieldInfo {
+    change_default?: boolean;
+    groupable?: boolean;
+    name?: string;
+    readonly?: boolean;
+    required?: boolean;
+    searchable?: boolean;
+    sortable?: boolean;
+    store?: boolean;
+    string?: string;
+    type?: string;
+    help?: string;
+    translate?: boolean;
+    trim?: boolean;
+    context?: {};
+    domain?: any[];
+    relation?: string;
+    related?: string;
+    selection?: Array<[string, string]>;
+    groups?: string;
+    relation_field?: string;
+    aggregator?: string;
+    digits?: [number, number];
+    size?: number;
+    currency_field?: string;
+    sanitize?: boolean;
+    sanitize_tags?: boolean;
+    definition_record?: string;
+    definition_record_field?: string;
+}
+export interface ActiveFieldInfo {
+    context: {};
+    invisible: string | boolean;
+    readonly: string | boolean;
+    required: string | boolean;
+    onChange: boolean;
+    forceSave: boolean;
+    isHandle: boolean;
+    related?: {
+        activeFields: {
+            [key: string]: ActiveFieldInfo;
+        };
+        fields: {
+            [key: string]: FieldInfo;
+        };
+    };
+}
+export interface WebModelConfigContext {
+    default_is_company: boolean;
+    lang: string;
+    tz: string;
+    uid: number;
+    allowed_company_ids: number[];
+}
+export interface RelationalModelParams {
+    config: {
+        activeFields: {
+            [key: string]: ActiveFieldInfo;
+        };
+        [key: string]: any;
+    };
+    limit?: number;
+    groupsLimit?: number;
+    countLimit?: number;
+    defaultOrderBy?: OrderBy[];
+    maxGroupByDepth?: number;
+    groupByInfo?: Record<string, any>;
+    multiEdit?: boolean;
+    activeIdsLimit?: number;
+    state?: {
+        specialDataCaches?: Record<string, any>;
+    };
+    useSendBeaconToSaveUrgently?: boolean;
+    hooks?: Partial<RelationalModelHooks>;
+    [key: string]: any;
+}
+export interface OrderBy {
+    name: string;
+    asc?: boolean;
+}
+export interface SearchParams {
+    context?: Record<string, any>;
+    resId?: number | false;
+    resIds?: number[];
+    domain?: any[];
+    groupBy?: string[];
+    orderBy?: OrderBy[];
+    limit?: number;
+    offset?: number;
+    countLimit?: number;
+}
+export interface Services {
+    action: any;
+    dialog: any;
+    notification: any;
+    orm: any;
+}
+export interface OnChangeParams {
+    changes?: Record<string, any>;
+    fieldNames?: string[];
+    evalContext?: Record<string, any>;
+    onError?: (error: any) => void;
+    cache?: any;
+}
+export interface RelationalModelHooks {
+    onWillLoadRoot: (config: WebModelConfig) => Promise<void>;
+    onRootLoaded: (root: any) => Promise<void>;
+    onWillDisplayOnchangeWarning: (warning: any) => Promise<void>;
+}

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) & 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/rendering/template_helpers.d.ts

@@ -0,0 +1,50 @@
+import { BDom, toggler, createCatcher } from "../blockdom";
+import { markRaw } from "../reactivity/proxy";
+import { OwlError } from "../../common/owl_error";
+/**
+ * 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 capture(ctx: any): any;
+declare function withKey(elem: any, k: string): any;
+declare function prepareList(collection: unknown): [unknown[], unknown[], number, undefined[]];
+declare function setContextValue(ctx: {
+    [key: string]: any;
+}, key: string, value: any): void;
+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 modelExpr(value: any): any;
+export declare const helpers: {
+    withDefault: typeof withDefault;
+    zero: symbol;
+    isBoundary: symbol;
+    callSlot: typeof callSlot;
+    capture: typeof capture;
+    withKey: typeof withKey;
+    prepareList: typeof prepareList;
+    setContextValue: typeof setContextValue;
+    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;
+};
+export {};

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

@@ -0,0 +1,12 @@
+import { TypeDescription } from "./validation";
+export declare class Resource<T> {
+    private _items;
+    private _name;
+    private _type?;
+    constructor(name?: string, type?: TypeDescription);
+    items: import("./reactivity/signal").ReactiveValue<T[]>;
+    add(item: T, sequence?: number): Resource<T>;
+    remove(item: T): Resource<T>;
+    has(item: T): boolean;
+}
+export declare function useResource<T>(r: Resource<T>, elements: T[]): void;

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

@@ -0,0 +1,19 @@
+import { Atom, Computation, Derived, Opts } from "../common/types";
+type SignalFunction<T> = () => T;
+export interface Signal<T> extends SignalFunction<T> {
+    set(value: T): void;
+}
+export declare function signal<T>(value: T, opts?: Opts): Signal<T>;
+export declare function effect<T>(fn: () => T, opts?: Opts): () => void;
+export declare function derived<T>(fn: () => T, opts?: Opts): () => T;
+export declare function onReadAtom(atom: Atom): void;
+export declare function onWriteAtom(atom: Atom): void;
+export declare function withoutReactivity<T extends (...args: any[]) => any>(fn: T): ReturnType<T>;
+export declare function getCurrentComputation(): Computation<any> | undefined;
+export declare function setComputation(computation: Computation | undefined): void;
+export declare function runWithComputation<T>(computation: Computation, fn: () => T): T;
+export declare function setSignalHooks(hooks: {
+    onDerived: (derived: Derived<any, any>) => void;
+}): void;
+export declare function resetSignalHooks(): void;
+export {};

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

@@ -1,10 +1,9 @@
-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;
+type STATUS_DESCR = "new" | "started" | "mounted" | "cancelled" | "destroyed";
+export declare function status(): () => STATUS_DESCR;
 export {};

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

@@ -0,0 +1,12 @@
+import { TaskContext } from "./cancellableContext";
+export declare class Task<T = any> {
+    _onCancelled?: Function | undefined;
+    _promise: Promise<T>;
+    _ctx?: TaskContext;
+    constructor(executor: (resolve: (value: T | PromiseLike<T>) => void, reject: (reason: any) => void) => void, _onCancelled?: Function | undefined);
+    then(onFulfilled: (value: any) => any, onRejected: (error: any) => any): Promise<any>;
+    catch(onRejected: (error: any) => any): Promise<any>;
+    finally(onFinally: () => any): Promise<T>;
+    cancel(): void;
+    get [Symbol.toStringTag](): string;
+}

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

@@ -1,13 +1,12 @@
-import { compile, Template, TemplateFunction } from "../compiler";
+import { compile, CustomDirectives, 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;
+    customDirectives?: CustomDirectives;
     globalValues?: object;
 }
 export declare class TemplateSet {
@@ -21,7 +20,7 @@ export declare class TemplateSet {
     translateFn?: (s: string, translationCtx: string) => string;
     translatableAttributes?: string[];
     Portal: typeof Portal;
-    customDirectives: customDirectives;
+    customDirectives: CustomDirectives;
     runtimeUtils: object;
     hasGlobalValues: boolean;
     constructor(config?: TemplateSetConfig);

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

@@ -1,4 +1,4 @@
-export declare type Callback = () => void;
+export 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.
@@ -17,7 +17,6 @@ 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;

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

@@ -1,4 +1,4 @@
-declare type BaseType = {
+type BaseType = {
     new (...args: any[]): any;
 } | true | "*";
 interface TypeInfo {
@@ -9,15 +9,15 @@ interface TypeInfo {
     element?: TypeDescription;
     values?: TypeDescription;
 }
-declare type ValueType = {
+type ValueType = {
     value: any;
 };
-declare type TypeDescription = BaseType | TypeInfo | ValueType | TypeDescription[];
-declare type SimplifiedSchema = string[];
-declare type NormalizedSchema = {
+export type TypeDescription = BaseType | TypeInfo | ValueType | TypeDescription[];
+type SimplifiedSchema = string[];
+type NormalizedSchema = {
     [key: string]: TypeDescription;
 };
-export declare type Schema = SimplifiedSchema | NormalizedSchema;
+export type Schema = SimplifiedSchema | NormalizedSchema;
 export declare function isOptional(t: TypeDescription): Boolean;
 /**
  * Main validate function

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

@@ -0,0 +1,15 @@
+import { Schema } from "../runtime/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 {};

package/dist/types/version.d.ts

@@ -1 +1 @@
-export declare const version = "2.8.1";
+export declare const version = "3.0.0-alpha";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@odoo/owl",
-  "version": "2.8.1",
+  "version": "3.0.0-alpha.10",
   "description": "Odoo Web Library (OWL)",
   "main": "dist/owl.cjs.js",
   "module": "dist/owl.es.js",
@@ -48,9 +48,7 @@
   },
   "homepage": "https://github.com/odoo/owl#readme",
   "devDependencies": {
-    "@types/jest": "^27.0.1",
-    "@types/jsdom": "^21.1.7",
-    "@types/node": "^14.11.8",
+    "@types/jest": "^29.5.2",
     "@typescript-eslint/eslint-plugin": "5.48.1",
     "@typescript-eslint/parser": "5.48.1",
     "chalk": "^3.0.0",
@@ -58,9 +56,9 @@
     "eslint": "8.31.0",
     "git-rev-sync": "^3.0.2",
     "github-api": "^3.3.0",
-    "jest": "^27.1.0",
+    "jest": "^29.7.0",
     "jest-diff": "^27.3.1",
-    "jest-environment-jsdom": "^27.1.0",
+    "jest-environment-jsdom": "^30.2.0",
     "npm-run-all": "^4.1.5",
     "prettier": "2.4.1",
     "rollup": "^2.56.3",
@@ -69,11 +67,13 @@
     "rollup-plugin-dts": "^4.2.2",
     "rollup-plugin-execute": "^1.1.1",
     "rollup-plugin-string": "^3.0.0",
-    "rollup-plugin-terser": "^7.0.2",
+    "@rollup/plugin-terser": "^0.3.0",
     "rollup-plugin-typescript2": "^0.31.1",
     "source-map-support": "^0.5.10",
-    "ts-jest": "^27.0.5",
-    "typescript": "4.5.2"
+    "ts-jest": "^29.4.6",
+    "@types/node": "^18.16.18",
+    "typescript": "^4.9.5",
+    "@types/jsdom": "^21.1.7"
   },
   "jest": {
     "testEnvironment": "jsdom",