;
+};
+
+// MountInfos
+export type MountInfos = { target: any; options?: MountOptions };
diff --git a/src/runtime/app.ts b/src/runtime/app.ts
index 7c13ae315..0c462dfc5 100644
--- a/src/runtime/app.ts
+++ b/src/runtime/app.ts
@@ -213,7 +213,6 @@ export class App<
};
}
- const updateAndRender = ComponentNode.prototype.updateAndRender;
const initiateRender = ComponentNode.prototype.initiateRender;
return (props: P, key: string, ctx: ComponentNode, parent: any, C: any) => {
@@ -223,12 +222,7 @@ export class App<
node = undefined;
}
const parentFiber = ctx.fiber!;
- if (node) {
- if (arePropsDifferent(node.props, props) || parentFiber.deep || node.forceNextRender) {
- node.forceNextRender = false;
- updateAndRender.call(node, props, parentFiber);
- }
- } else {
+ if (!node) {
// new component
if (isStatic) {
const components = parent.constructor.components;
@@ -248,7 +242,7 @@ export class App<
}
node = new ComponentNode(C, props, this, ctx, key);
children[key] = node;
- initiateRender.call(node, new Fiber(node, parentFiber));
+ initiateRender.call(node);
}
parentFiber.childrenMap[key] = node;
return node;
diff --git a/src/runtime/blockdom/toggler.ts b/src/runtime/blockdom/toggler.ts
index 22415439c..238ab9939 100644
--- a/src/runtime/blockdom/toggler.ts
+++ b/src/runtime/blockdom/toggler.ts
@@ -17,6 +17,9 @@ class VToggler {
mount(parent: HTMLElement, afterNode: Node | null) {
this.parentEl = parent;
+ if (!(typeof this.child.mount === "function")) {
+ debugger;
+ }
this.child.mount(parent, afterNode);
}
diff --git a/src/runtime/component_node.ts b/src/runtime/component_node.ts
index 31d4d9330..7531053d8 100644
--- a/src/runtime/component_node.ts
+++ b/src/runtime/component_node.ts
@@ -1,12 +1,26 @@
+import { OwlError } from "../common/owl_error";
+import {
+ Atom,
+ ComponentNodeRenderTransaction,
+ Computation,
+ ComputationState,
+ MountInfos,
+ Transaction,
+} from "../common/types";
import type { App, Env } from "./app";
import { BDom, VNode } from "./blockdom";
import { Component, ComponentConstructor, Props } from "./component";
-import { fibersInError } from "./error_handling";
-import { OwlError } from "../common/owl_error";
-import { Fiber, makeChildFiber, makeRootFiber, MountFiber, MountOptions } from "./fibers";
-import { clearReactivesForCallback, getSubscriptions, reactive, targets } from "./reactivity";
+import { Fiber, makeChildFiber, MountOptions } from "./fibers";
+import { reactive } from "./reactivity";
+import {
+ derivedAsync,
+ effect,
+ getCurrentComputation,
+ setComputation,
+ withoutReactivity,
+} from "./signals";
import { STATUS } from "./status";
-import { batched, Callback } from "./utils";
+import { getCurrentTransaction, makeTransaction, withTransaction } from "./suspense";
let currentNode: ComponentNode | null = null;
@@ -42,7 +56,7 @@ function applyDefaultProps(props: P, defaultProps: Partial
)
// Integration with reactivity system (useState)
// -----------------------------------------------------------------------------
-const batchedRenderFunctions = new WeakMap();
+// const batchedRenderFunctions = new WeakMap();
/**
* Creates a reactive object that will be observed by the current component.
* Reading data from the returned object (eg during rendering) will cause the
@@ -54,15 +68,7 @@ const batchedRenderFunctions = new WeakMap();
* @see reactive
*/
export function useState(state: T): T {
- const node = getCurrent();
- let render = batchedRenderFunctions.get(node)!;
- if (!render) {
- render = batched(node.render.bind(node, false));
- batchedRenderFunctions.set(node, render);
- // manual implementation of onWillDestroy to break cyclic dependency
- node.willDestroy.push(clearReactivesForCallback.bind(null, render));
- }
- return reactive(state, render);
+ return reactive(state);
}
// -----------------------------------------------------------------------------
@@ -96,6 +102,9 @@ export class ComponentNode implements VNode void;
constructor(
C: ComponentConstructor,
@@ -109,6 +118,16 @@ export class ComponentNode implements VNode {
+ this.render(false);
+ },
+ sources: new Set(),
+ state: ComputationState.STALE,
+ name: `ComponentNode(${C.name})`,
+ };
const defaultProps = C.defaultProps;
props = Object.assign({}, props);
if (defaultProps) {
@@ -116,89 +135,119 @@ export class ComponentNode implements VNode
+ withoutReactivity(() => Promise.all(this.willStart.map((f) => f.call(component))))
+ );
+ const renderBDom = () => {
+ const transaction = getCurrentTransaction();
+ transaction.increment();
+ willStartDerived();
+ if (willStartDerived.loading) return;
+ transaction;
+ transaction.data.nodeToBDomMap.set(this.renderFn());
+ transaction.decrement();
+ };
+ this.renderBDom = renderBDom;
}
mountComponent(target: any, options?: MountOptions) {
- const fiber = new MountFiber(this, target, options);
- this.app.scheduler.addFiber(fiber);
- this.initiateRender(fiber);
+ this.initiateRender({ mountInfos: { target, options } });
}
- async initiateRender(fiber: Fiber | MountFiber) {
- this.fiber = fiber;
- if (this.mounted.length) {
- fiber.root!.mounted.push(fiber);
- }
- const component = this.component;
- try {
- await Promise.all(this.willStart.map((f) => f.call(component)));
- } catch (e) {
- this.app.handleError({ node: this, error: e });
- return;
- }
- if (this.status === STATUS.NEW && this.fiber === fiber) {
- fiber.render();
- }
+ async initiateRender({ mountInfos }: { mountInfos?: MountInfos } = {}) {
+ // if (this.mounted.length) {
+ // fiber.root!.mounted.push(fiber);
+ // }
+
+ // todo: handle error. do it in derivedAsync?
+ const renderBDom = this.renderBDom;
+
+ const renderWithTransaction = () => {
+ let transaction = getCurrentTransaction();
+ if (transaction) return withTransaction(transaction, renderBDom);
+
+ transaction = makeTransaction({
+ data: {
+ // node: this,
+ nodeToBDomMap: new Map(),
+ },
+ onComplete: (isAsync) => {
+ // re-render if any async occured.
+ // if (isAsync) withTransaction(transaction, renderBDom);
+ onTransactionComplete(this, mountInfos);
+ },
+ });
+ withTransaction(transaction, renderBDom);
+ };
+
+ effect(renderWithTransaction, { withChildren: false });
+
+ // if (this.status === STATUS.NEW && this.fiber === fiber) {
+ // fiber.render();
+ // }
}
async render(deep: boolean) {
- if (this.status >= STATUS.CANCELLED) {
- return;
- }
- let current = this.fiber;
- if (current && (current.root!.locked || (current as any).bdom === true)) {
- await Promise.resolve();
- // situation may have changed after the microtask tick
- current = this.fiber;
- }
- if (current) {
- if (!current.bdom && !fibersInError.has(current)) {
- if (deep) {
- // we want the render from this point on to be with deep=true
- current.deep = deep;
- }
- return;
- }
- // if current rendering was with deep=true, we want this one to be the same
- deep = deep || current.deep;
- } else if (!this.bdom) {
- return;
- }
-
- const fiber = makeRootFiber(this);
- fiber.deep = deep;
- this.fiber = fiber;
-
- this.app.scheduler.addFiber(fiber);
- await Promise.resolve();
- if (this.status >= STATUS.CANCELLED) {
- return;
- }
- // We only want to actually render the component if the following two
- // conditions are true:
- // * this.fiber: it could be null, in which case the render has been cancelled
- // * (current || !fiber.parent): if current is not null, this means that the
- // render function was called when a render was already occurring. In this
- // case, the pending rendering was cancelled, and the fiber needs to be
- // rendered to complete the work. If current is null, we check that the
- // fiber has no parent. If that is the case, the fiber was downgraded from
- // a root fiber to a child fiber in the previous microtick, because it was
- // embedded in a rendering coming from above, so the fiber will be rendered
- // in the next microtick anyway, so we should not render it again.
- if (this.fiber === fiber && (current || !fiber.parent)) {
- fiber.render();
- }
+ // if (this.status >= STATUS.CANCELLED) {
+ // return;
+ // }
+ // let current = this.fiber;
+ // if (current && (current.root!.locked || (current as any).bdom === true)) {
+ // await Promise.resolve();
+ // // situation may have changed after the microtask tick
+ // current = this.fiber;
+ // }
+ // if (current) {
+ // if (!current.bdom && !fibersInError.has(current)) {
+ // if (deep) {
+ // // we want the render from this point on to be with deep=true
+ // current.deep = deep;
+ // }
+ // return;
+ // }
+ // // if current rendering was with deep=true, we want this one to be the same
+ // deep = deep || current.deep;
+ // } else if (!this.bdom) {
+ // return;
+ // }
+ // const fiber = makeRootFiber(this);
+ // fiber.deep = deep;
+ // this.fiber = fiber;
+ // this.app.scheduler.addFiber(fiber);
+ // await Promise.resolve();
+ // if (this.status >= STATUS.CANCELLED) {
+ // return;
+ // }
+ // // We only want to actually render the component if the following two
+ // // conditions are true:
+ // // * this.fiber: it could be null, in which case the render has been cancelled
+ // // * (current || !fiber.parent): if current is not null, this means that the
+ // // render function was called when a render was already occurring. In this
+ // // case, the pending rendering was cancelled, and the fiber needs to be
+ // // rendered to complete the work. If current is null, we check that the
+ // // fiber has no parent. If that is the case, the fiber was downgraded from
+ // // a root fiber to a child fiber in the previous microtick, because it was
+ // // embedded in a rendering coming from above, so the fiber will be rendered
+ // // in the next microtick anyway, so we should not render it again.
+ // if (this.fiber === fiber && (current || !fiber.parent)) {
+ // fiber.render();
+ // }
}
cancel() {
@@ -257,16 +306,11 @@ export class ComponentNode implements VNode f.call(component, props)));
- await prom;
+ let prom: Promise;
+ withoutReactivity(() => {
+ prom = Promise.all(this.willUpdateProps.map((f) => f.call(component, props)));
+ });
+ await prom!;
if (fiber !== this.fiber) {
return;
}
@@ -384,8 +428,34 @@ export class ComponentNode implements VNode {
- const render = batchedRenderFunctions.get(this);
- return render ? getSubscriptions(render) : [];
+ // get subscriptions(): ReturnType {
+ // const render = batchedRenderFunctions.get(this);
+ // return render ? getSubscriptions(render) : [];
+ // }
+}
+
+function onTransactionComplete(
+ node: ComponentNode,
+ mountInfos?: { target: any; options?: MountOptions }
+) {
+ console.warn(`transactionComplete`);
+ try {
+ // Step 1: calling all willPatch lifecycle hooks
+ // Step 2: patching the dom
+ node._patch();
+ // Step 4: calling all mounted lifecycle hooks
+ // Step 5: calling all patched hooks
+ } catch (e) {
+ // if mountedFibers is not empty, this means that a crash occured while
+ // calling the mounted hooks of some component. So, there may still be
+ // some component that have been mounted, but for which the mounted hooks
+ // have not been called. Here, we remove the willUnmount hooks for these
+ // specific component to prevent a worse situation (willUnmount being
+ // called even though mounted has not been called)
+ // for (let fiber of mountedFibers) {
+ // fiber.node.willUnmount = [];
+ // }
+ // this.locked = false;
+ // node.app.handleError({ fiber: current || this, error: e });
}
}
diff --git a/src/runtime/contextualPromise.ts b/src/runtime/contextualPromise.ts
new file mode 100644
index 000000000..eb5d99577
--- /dev/null
+++ b/src/runtime/contextualPromise.ts
@@ -0,0 +1,95 @@
+import { CancellablePromise, PromiseContext, Task } from "../common/types";
+
+export function makeTask(
+ cb: Function,
+ onRestoreContext?: PromiseContext["onRestoreContext"],
+ onCleanContext?: PromiseContext["onCleanContext"],
+ onCancel?: PromiseContext["onCancel"]
+): Task {
+ const context: PromiseContext = {
+ cancelled: false,
+ onRestoreContext,
+ onCleanContext,
+ onCancel,
+ };
+ const start = () => {
+ const tmp = setPromiseContext(context);
+ patchPromise();
+ const promise = cb();
+ restorePromise();
+ resetPromiseContext(tmp);
+ return promise;
+ };
+
+ return {
+ cancel: () => {
+ if (context.cancelled) return;
+ context.cancelled = true;
+ onCancel?.();
+ },
+ get isCancel() {
+ return context.cancelled;
+ },
+ start,
+ };
+}
+
+let currentPromiseContext: PromiseContext | undefined;
+export const getPromiseContext = () => currentPromiseContext;
+export const setPromiseContext = (ctx: PromiseContext | undefined) => {
+ const tmpContext = ctx;
+ currentPromiseContext = ctx;
+ return tmpContext;
+};
+export const resetPromiseContext = (ctx: PromiseContext | undefined) => {
+ currentPromiseContext = ctx;
+};
+
+const OriginalPromise = Promise;
+const originalThen = Promise.prototype.then;
+
+const ProxyPromise = new Proxy(OriginalPromise, {
+ construct(target, args, newTarget) {
+ const instance = Reflect.construct(target, args, newTarget);
+ const obj = Object.create(instance);
+ obj.execContext = currentPromiseContext;
+ obj.then = proxyThen;
+ return obj;
+ },
+});
+const proxyThen = function (
+ this: CancellablePromise,
+ onFulfilled?: (value: T) => any,
+ onRejected?: (reason: any) => any
+): Promise {
+ const ctx = this.execContext;
+ return originalThen.call(
+ (this as any).__proto__,
+ onFulfilled ? (...args: [T]) => _exec(ctx, onFulfilled!, args) : undefined,
+ onRejected ? (...args: [any]) => _exec(ctx, onRejected!, args) : undefined
+ );
+};
+const _exec = (execContext: PromiseContext | undefined, cb: Function, args: any[]) => {
+ if (execContext?.cancelled) return;
+ let tmp = currentPromiseContext;
+ originalThen.call(OriginalPromise.resolve(), () => {
+ patchPromise();
+ execContext?.onRestoreContext?.();
+ currentPromiseContext = execContext;
+ });
+ currentPromiseContext = execContext;
+ const result = cb(...args);
+ originalThen.call(OriginalPromise.resolve(), () => {
+ restorePromise();
+ execContext?.onCleanContext?.();
+ currentPromiseContext = tmp;
+ });
+ return result;
+};
+
+function patchPromise() {
+ window.Promise = ProxyPromise;
+}
+function restorePromise() {
+ window.Promise = OriginalPromise;
+}
diff --git a/src/runtime/executionContext.ts b/src/runtime/executionContext.ts
new file mode 100644
index 000000000..9485e48d7
--- /dev/null
+++ b/src/runtime/executionContext.ts
@@ -0,0 +1,26 @@
+// import { ExecutionContext } from "../common/types";
+
+// export const executionContexts: ExecutionContext[] = [];
+// (window as any).executionContexts = executionContexts;
+// export const scheduledContexts: Set = new Set();
+
+// export function getExecutionContext() {
+// return executionContexts[executionContexts.length - 1];
+// }
+
+// export function pushExecutionContext(context: ExecutionContext) {
+// executionContexts.push(context);
+// }
+
+// export function popExecutionContext() {
+// executionContexts.pop();
+// }
+
+// export function makeExecutionContext({ update, meta }: { update: () => void; meta?: any }) {
+// const executionContext: ExecutionContext = {
+// update,
+// atoms: new Set(),
+// meta: meta || {},
+// };
+// return executionContext;
+// }
diff --git a/src/runtime/fibers.ts b/src/runtime/fibers.ts
index 7dea4a466..1694c49c6 100644
--- a/src/runtime/fibers.ts
+++ b/src/runtime/fibers.ts
@@ -1,7 +1,9 @@
+import { OwlError } from "../common/owl_error";
+import { ComputationState } from "../common/types";
import { BDom, mount } from "./blockdom";
import type { ComponentNode } from "./component_node";
import { fibersInError } from "./error_handling";
-import { OwlError } from "../common/owl_error";
+import { runWithComputation } from "./signals";
import { STATUS } from "./status";
export function makeChildFiber(node: ComponentNode, parent: Fiber): Fiber {
@@ -12,7 +14,7 @@ export function makeChildFiber(node: ComponentNode, parent: Fiber): Fiber {
}
return new Fiber(node, parent);
}
-
+jest.setTimeout(100_000_000_000);
export function makeRootFiber(node: ComponentNode): Fiber {
let current = node.fiber;
if (current) {
@@ -129,16 +131,34 @@ export class Fiber {
this._render();
}
- _render() {
+ async _render() {
const node = this.node;
const root = this.root;
if (root) {
- try {
- (this.bdom as any) = true;
- this.bdom = node.renderFn();
- } catch (e) {
- node.app.handleError({ node, error: e });
- }
+ // pushTaskContext(node.taskContext);
+ // todo: should use updateComputation somewhere else.
+ const computation = node.signalComputation;
+ runWithComputation(computation, () => {
+ try {
+ root.setCounter(root.counter + 1);
+ (this.bdom as any) = true;
+ const exec = () => {
+ this.bdom = node.renderFn();
+ root.setCounter(root.counter - 1);
+ };
+ exec();
+
+ // const async = computation.async;
+ // if (async) {
+ // root.setCounter(root.counter + 1);
+ // }
+ } catch (e) {
+ node.app.handleError({ node, error: e });
+ }
+ node.signalComputation.state = ComputationState.EXECUTED;
+ });
+ // popTaskContext();
+
root.setCounter(root.counter - 1);
}
}
diff --git a/src/runtime/hooks.ts b/src/runtime/hooks.ts
index 2741b06a0..06e564c55 100644
--- a/src/runtime/hooks.ts
+++ b/src/runtime/hooks.ts
@@ -1,6 +1,7 @@
import type { Env } from "./app";
import { getCurrent } from "./component_node";
import { onMounted, onPatched, onWillUnmount } from "./lifecycle_hooks";
+import { runWithComputation } from "./signals";
import { inOwnerDocument } from "./utils";
// -----------------------------------------------------------------------------
@@ -86,22 +87,31 @@ export function useEffect(
effect: Effect,
computeDependencies: () => [...T] = () => [NaN] as never
) {
+ const context = getCurrent().component.__owl__.signalComputation;
+
let cleanup: (() => void) | void;
- let dependencies: T;
+
+ let dependencies: any;
+ const runEffect = () =>
+ runWithComputation(context, () => {
+ cleanup = effect(...dependencies);
+ });
+ const computeDependenciesWithContext = () => runWithComputation(context, computeDependencies);
+
onMounted(() => {
- dependencies = computeDependencies();
- cleanup = effect(...dependencies);
+ dependencies = computeDependenciesWithContext();
+ runEffect();
});
onPatched(() => {
- const newDeps = computeDependencies();
- const shouldReapply = newDeps.some((val, i) => val !== dependencies[i]);
+ const newDeps = computeDependenciesWithContext();
+ const shouldReapply = newDeps.some((val: any, i: number) => val !== dependencies[i]);
if (shouldReapply) {
dependencies = newDeps;
if (cleanup) {
cleanup();
}
- cleanup = effect(...dependencies);
+ runEffect();
}
});
diff --git a/src/runtime/index.ts b/src/runtime/index.ts
index 002e8b8c3..0a28e6d76 100644
--- a/src/runtime/index.ts
+++ b/src/runtime/index.ts
@@ -32,14 +32,12 @@ export const blockDom = {
html,
comment,
};
-
export { App, mount } from "./app";
export { xml } from "./template_set";
export { Component } from "./component";
export type { ComponentConstructor } from "./component";
export { useComponent, useState } from "./component_node";
export { status } from "./status";
-export { reactive, markRaw, toRaw } from "./reactivity";
export { useEffect, useEnv, useExternalListener, useRef, useChildSubEnv, useSubEnv } from "./hooks";
export { batched, EventBus, htmlEscape, whenReady, loadFile, markup } from "./utils";
export {
@@ -56,6 +54,14 @@ export {
} from "./lifecycle_hooks";
export { validate, validateType } from "./validation";
export { OwlError } from "../common/owl_error";
+export { reactive, markRaw, toRaw } from "./reactivity";
+export { effect, withoutReactivity, derived, processEffects } from "./signals";
+export { loadRecordWithRelated, flushDataToLoad } from "./relationalModel/store";
+export { Model } from "./relationalModel/model";
+export { getRecordChanges, commitRecordChanges } from "./relationalModel/modelData";
+export { getOrMakeModel, makeModelFromWeb } from "./relationalModel/web/webModel";
+export { WebRecord } from "./relationalModel/web/WebRecord";
+export { makeTask } from "./contextualPromise";
export const __info__ = {
version: App.version,
diff --git a/src/runtime/listOperation.ts b/src/runtime/listOperation.ts
new file mode 100644
index 000000000..3e68ba1aa
--- /dev/null
+++ b/src/runtime/listOperation.ts
@@ -0,0 +1,35 @@
+// import { derived, getChangeItem, onReadAtom } from "./signals";
+
+// export function listenChanges(obj, key, fn) {
+// getTargetKeyAtom(obj, key);
+// }
+
+export function reactiveMap(arr: A[], fn: (a: A, index: number) => B) {
+ // return derived(() => );
+
+ // const item = getChangeItem(arr)!;
+ // const atom = item[0];
+ // let mappedArray: B[];
+
+ // return derived(() => {
+ // onReadAtom(atom);
+ // const changes = item[1];
+
+ // if (!mappedArray) {
+ // mappedArray = arr.map(fn);
+ // return mappedArray;
+ // }
+
+ // for (const [key, receiver] of changes) {
+ // // console.warn(`receiver:`, receiver);
+ // receiver;
+ // if (key === "length") {
+ // mappedArray.length = arr.length;
+ // } else if (typeof key === "number") {
+ // // mappedArray[key] = fn(arr[key], key);
+ // }
+ // }
+ // return mappedArray;
+ // });
+ return undefined as any;
+}
diff --git a/src/runtime/reactivity.ts b/src/runtime/reactivity.ts
index 12d61a7d5..51e0add9b 100644
--- a/src/runtime/reactivity.ts
+++ b/src/runtime/reactivity.ts
@@ -1,13 +1,9 @@
-import type { Callback } from "./utils";
import { OwlError } from "../common/owl_error";
+import { Atom } from "../common/types";
+import { onReadAtom, onWriteAtom } from "./signals";
// Special key to subscribe to, to be notified of key creation/deletion
const KEYCHANGES = Symbol("Key changes");
-// Used to specify the absence of a callback, can be used as WeakMap key but
-// should only be used as a sentinel value and never called.
-const NO_CALLBACK = () => {
- throw new Error("Called NO_CALLBACK. Owl is broken, please report this to the maintainers.");
-};
// The following types only exist to signify places where objects are expected
// to be reactive or not, they provide no type checking benefit over "object"
@@ -55,8 +51,8 @@ function canBeMadeReactive(value: any): boolean {
* @param value the value make reactive
* @returns a reactive for the given object when possible, the original otherwise
*/
-function possiblyReactive(val: any, cb: Callback) {
- return canBeMadeReactive(val) ? reactive(val, cb) : val;
+function possiblyReactive(val: any) {
+ return canBeMadeReactive(val) ? reactive(val) : val;
}
const skipped = new WeakSet();
@@ -81,7 +77,25 @@ export function toRaw>(value: U | T): T
return targets.has(value) ? (targets.get(value) as T) : value;
}
-const targetToKeysToCallbacks = new WeakMap>>();
+const targetToKeysToAtomItem = new WeakMap>();
+
+export function getTargetKeyAtom(target: Target, key: PropertyKey): Atom {
+ let keyToAtomItem: Map = targetToKeysToAtomItem.get(target)!;
+ if (!keyToAtomItem) {
+ keyToAtomItem = new Map();
+ targetToKeysToAtomItem.set(target, keyToAtomItem);
+ }
+ let atom = keyToAtomItem.get(key)!;
+ if (!atom) {
+ atom = {
+ value: undefined,
+ observers: new Set(),
+ };
+ keyToAtomItem.set(key, atom);
+ }
+ return atom;
+}
+
/**
* Observes a given key on a target with an callback. The callback will be
* called when the given key changes on the target.
@@ -91,23 +105,10 @@ const targetToKeysToCallbacks = new WeakMap>();
-/**
- * Clears all subscriptions of the Reactives associated with a given callback.
- *
- * @param callback the callback for which the reactives need to be cleared
- */
-export function clearReactivesForCallback(callback: Callback): void {
- const targetsToClear = callbacksToTargets.get(callback);
- if (!targetsToClear) {
- return;
+function onWriteTargetKey(target: Target, key: PropertyKey, receiver?: any): void {
+ if (key === "reactiveChanges") {
+ debugger;
}
- for (const target of targetsToClear) {
- const observedKeys = targetToKeysToCallbacks.get(target);
- if (!observedKeys) {
- continue;
- }
- for (const [key, callbacks] of observedKeys.entries()) {
- callbacks.delete(callback);
- if (!callbacks.size) {
- observedKeys.delete(key);
- }
- }
- }
- targetsToClear.clear();
+ const keyToAtomItem = targetToKeysToAtomItem.get(target)!;
+ if (!keyToAtomItem) return;
+ const atom = keyToAtomItem.get(key);
+ if (!atom) return;
+ onWriteAtom(atom);
}
-export function getSubscriptions(callback: Callback) {
- const targets = callbacksToTargets.get(callback) || [];
- return [...targets].map((target) => {
- const keysToCallbacks = targetToKeysToCallbacks.get(target);
- let keys = [];
- if (keysToCallbacks) {
- for (const [key, cbs] of keysToCallbacks) {
- if (cbs.has(callback)) {
- keys.push(key);
- }
- }
- }
- return { target, keys };
- });
-}
// Maps reactive objects to the underlying target
export const targets = new WeakMap, Target>();
-const reactiveCache = new WeakMap>>();
+const reactiveCache = new WeakMap>();
/**
* 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
@@ -204,7 +159,7 @@ const reactiveCache = new WeakMap>>()
* reactive has changed
* @returns a proxy that tracks changes to it
*/
-export function reactive(target: T, callback: Callback = NO_CALLBACK): T {
+export function reactive(target: T): T {
if (!canBeMadeReactive(target)) {
throw new OwlError(`Cannot make the given value reactive`);
}
@@ -213,30 +168,30 @@ export function reactive(target: T, callback: Callback = NO_CA
}
if (targets.has(target)) {
// target is reactive, create a reactive on the underlying object instead
- return reactive(targets.get(target) as T, callback);
- }
- if (!reactiveCache.has(target)) {
- reactiveCache.set(target, new WeakMap());
- }
- const reactivesForTarget = reactiveCache.get(target)!;
- if (!reactivesForTarget.has(callback)) {
- const targetRawType = rawType(target);
- const handler = COLLECTION_RAW_TYPES.includes(targetRawType)
- ? collectionsProxyHandler(target as Collection, callback, targetRawType as CollectionRawType)
- : basicProxyHandler(callback);
- const proxy = new Proxy(target, handler as ProxyHandler) as Reactive;
- reactivesForTarget.set(callback, proxy);
- targets.set(proxy, target);
+ return target;
}
- return reactivesForTarget.get(callback) as Reactive;
+ const reactive = reactiveCache.get(target)!;
+ if (reactive) return reactive as T;
+
+ const targetRawType = rawType(target);
+ const handler = COLLECTION_RAW_TYPES.includes(targetRawType)
+ ? collectionsProxyHandler(target as Collection, targetRawType as CollectionRawType)
+ : basicProxyHandler();
+ const proxy = new Proxy(target, handler as ProxyHandler) as Reactive;
+
+ reactiveCache.set(target, proxy);
+ targets.set(proxy, target);
+
+ return proxy;
}
+
/**
* Creates a basic proxy handler for regular objects and arrays.
*
* @param callback @see reactive
* @returns a proxy handler object
*/
-function basicProxyHandler(callback: Callback): ProxyHandler {
+function basicProxyHandler(): ProxyHandler {
return {
get(target, key, receiver) {
// non-writable non-configurable properties cannot be made reactive
@@ -244,15 +199,15 @@ function basicProxyHandler(callback: Callback): ProxyHandler(callback: Callback): ProxyHandler;
@@ -293,11 +248,11 @@ function basicProxyHandler(callback: Callback): ProxyHandler {
key = toRaw(key);
- observeTargetKey(target, key, callback);
- return possiblyReactive(target[methodName](key), callback);
+ onReadTargetKey(target, key);
+ return possiblyReactive(target[methodName](key));
};
}
/**
@@ -310,16 +265,15 @@ function makeKeyObserver(methodName: "has" | "get", target: any, callback: Callb
*/
function makeIteratorObserver(
methodName: "keys" | "values" | "entries" | typeof Symbol.iterator,
- target: any,
- callback: Callback
+ target: any
) {
return function* () {
- observeTargetKey(target, KEYCHANGES, callback);
+ onReadTargetKey(target, KEYCHANGES);
const keys = target.keys();
for (const item of target[methodName]()) {
const key = keys.next().value;
- observeTargetKey(target, key, callback);
- yield possiblyReactive(item, callback);
+ onReadTargetKey(target, key);
+ yield possiblyReactive(item);
}
};
}
@@ -331,16 +285,16 @@ function makeIteratorObserver(
* @param target @see reactive
* @param callback @see reactive
*/
-function makeForEachObserver(target: any, callback: Callback) {
+function makeForEachObserver(target: any) {
return function forEach(forEachCb: (val: any, key: any, target: any) => void, thisArg: any) {
- observeTargetKey(target, KEYCHANGES, callback);
+ onReadTargetKey(target, KEYCHANGES);
target.forEach(function (val: any, key: any, targetObj: any) {
- observeTargetKey(target, key, callback);
+ onReadTargetKey(target, key);
forEachCb.call(
thisArg,
- possiblyReactive(val, callback),
- possiblyReactive(key, callback),
- possiblyReactive(targetObj, callback)
+ possiblyReactive(val),
+ possiblyReactive(key),
+ possiblyReactive(targetObj)
);
}, thisArg);
};
@@ -367,10 +321,10 @@ function delegateAndNotify(
const ret = target[setterName](key, value);
const hasKey = target.has(key);
if (hadKey !== hasKey) {
- notifyReactives(target, KEYCHANGES);
+ onWriteTargetKey(target, KEYCHANGES);
}
if (originalValue !== target[getterName](key)) {
- notifyReactives(target, key);
+ onWriteTargetKey(target, key);
}
return ret;
};
@@ -385,9 +339,9 @@ function makeClearNotifier(target: Map | Set) {
return () => {
const allKeys = [...target.keys()];
target.clear();
- notifyReactives(target, KEYCHANGES);
+ onWriteTargetKey(target, KEYCHANGES);
for (const key of allKeys) {
- notifyReactives(target, key);
+ onWriteTargetKey(target, key);
}
};
}
@@ -399,40 +353,40 @@ function makeClearNotifier(target: Map | Set) {
* reactives that the key which is being added or deleted has been modified.
*/
const rawTypeToFuncHandlers = {
- Set: (target: any, callback: Callback) => ({
- has: makeKeyObserver("has", target, callback),
+ Set: (target: any) => ({
+ has: makeKeyObserver("has", target),
add: delegateAndNotify("add", "has", target),
delete: delegateAndNotify("delete", "has", target),
- keys: makeIteratorObserver("keys", target, callback),
- values: makeIteratorObserver("values", target, callback),
- entries: makeIteratorObserver("entries", target, callback),
- [Symbol.iterator]: makeIteratorObserver(Symbol.iterator, target, callback),
- forEach: makeForEachObserver(target, callback),
+ keys: makeIteratorObserver("keys", target),
+ values: makeIteratorObserver("values", target),
+ entries: makeIteratorObserver("entries", target),
+ [Symbol.iterator]: makeIteratorObserver(Symbol.iterator, target),
+ forEach: makeForEachObserver(target),
clear: makeClearNotifier(target),
get size() {
- observeTargetKey(target, KEYCHANGES, callback);
+ onReadTargetKey(target, KEYCHANGES);
return target.size;
},
}),
- Map: (target: any, callback: Callback) => ({
- has: makeKeyObserver("has", target, callback),
- get: makeKeyObserver("get", target, callback),
+ Map: (target: any) => ({
+ has: makeKeyObserver("has", target),
+ get: makeKeyObserver("get", target),
set: delegateAndNotify("set", "get", target),
delete: delegateAndNotify("delete", "has", target),
- keys: makeIteratorObserver("keys", target, callback),
- values: makeIteratorObserver("values", target, callback),
- entries: makeIteratorObserver("entries", target, callback),
- [Symbol.iterator]: makeIteratorObserver(Symbol.iterator, target, callback),
- forEach: makeForEachObserver(target, callback),
+ keys: makeIteratorObserver("keys", target),
+ values: makeIteratorObserver("values", target),
+ entries: makeIteratorObserver("entries", target),
+ [Symbol.iterator]: makeIteratorObserver(Symbol.iterator, target),
+ forEach: makeForEachObserver(target),
clear: makeClearNotifier(target),
get size() {
- observeTargetKey(target, KEYCHANGES, callback);
+ onReadTargetKey(target, KEYCHANGES);
return target.size;
},
}),
- WeakMap: (target: any, callback: Callback) => ({
- has: makeKeyObserver("has", target, callback),
- get: makeKeyObserver("get", target, callback),
+ WeakMap: (target: any) => ({
+ has: makeKeyObserver("has", target),
+ get: makeKeyObserver("get", target),
set: delegateAndNotify("set", "get", target),
delete: delegateAndNotify("delete", "has", target),
}),
@@ -446,20 +400,19 @@ const rawTypeToFuncHandlers = {
*/
function collectionsProxyHandler(
target: T,
- callback: Callback,
targetRawType: CollectionRawType
): ProxyHandler {
// TODO: if performance is an issue we can create the special handlers lazily when each
// property is read.
- const specialHandlers = rawTypeToFuncHandlers[targetRawType](target, callback);
- return Object.assign(basicProxyHandler(callback), {
+ const specialHandlers = rawTypeToFuncHandlers[targetRawType](target);
+ return Object.assign(basicProxyHandler(), {
// FIXME: probably broken when part of prototype chain since we ignore the receiver
get(target: any, key: PropertyKey) {
if (objectHasOwnProperty.call(specialHandlers, key)) {
return (specialHandlers as any)[key];
}
- observeTargetKey(target, key, callback);
- return possiblyReactive(target[key], callback);
+ onReadTargetKey(target, key);
+ return possiblyReactive(target[key]);
},
}) as ProxyHandler;
}
diff --git a/src/runtime/relationalModel/discussModel.ts b/src/runtime/relationalModel/discussModel.ts
new file mode 100644
index 000000000..d71cbdb95
--- /dev/null
+++ b/src/runtime/relationalModel/discussModel.ts
@@ -0,0 +1,60 @@
+import {
+ AttrParams,
+ DateParams,
+ DatetimeParams,
+ HtmlParams,
+ ManyParams,
+ RelationParams,
+} from "./discussModelTypes";
+import { fieldAny, fieldMany2Many, fieldMany2One, fieldOne2Many } from "./field";
+import { Model } from "./model";
+import { FieldDefinition } from "./types";
+
+export class DiscussRecord {
+ static Model: typeof Model;
+ static fields: Record = {};
+
+ static register() {
+ const name = this.name;
+ const fields = this.fields;
+ const Mod = {
+ [name]: class extends Model {
+ static id = name;
+ static fields = fields;
+ },
+ }[name];
+ Mod.register();
+ this.Model = Mod;
+ }
+ static insert(data: Partial): any {
+ const Constructor = this.constructor as typeof DiscussRecord;
+ const record = this.Model.create(data);
+ const m = new Constructor();
+ m.record = record;
+ return m;
+ }
+
+ record!: Model;
+
+ constructor() {
+ return new Proxy(this, {
+ get(target, prop, receiver) {
+ return Reflect.get(target.record, prop, receiver);
+ },
+ });
+ }
+}
+
+export const fields = {
+ One: (modelName: string, params: RelationParams = {}) => fieldMany2One(modelName),
+ Many: (modelName: string, params: ManyParams = {}) =>
+ params.inverse
+ ? fieldOne2Many(modelName, {
+ relatedField: params.inverse,
+ })
+ : fieldMany2Many(modelName),
+ Attr: (defaultValue: string, params: AttrParams = {}) => fieldAny(),
+ Html: (defaultValue: string, params: HtmlParams = {}) => fieldAny(),
+ Date: (params: DateParams = {}) => fieldAny(),
+ Datetime: (params: DatetimeParams = {}) => fieldAny(),
+};
diff --git a/src/runtime/relationalModel/discussModelTypes.ts b/src/runtime/relationalModel/discussModelTypes.ts
new file mode 100644
index 000000000..c4c0ecb59
--- /dev/null
+++ b/src/runtime/relationalModel/discussModelTypes.ts
@@ -0,0 +1,24 @@
+import { DiscussRecord } from "./discussModel";
+
+export type FieldCommonParams = {
+ compute?: (record: DiscussRecord) => any;
+ eager?: boolean;
+ onUpdate?: (record: DiscussRecord) => void;
+};
+export type RelationParams = FieldCommonParams & {
+ inverse?: string;
+ onAdd?: (record: DiscussRecord) => void;
+ onDelete?: (record: DiscussRecord) => void;
+};
+export type ManyParams = RelationParams & {
+ sort?: (a: DiscussRecord, b: DiscussRecord) => number;
+};
+export type AttrParams = FieldCommonParams & {
+ sort?: (a: DiscussRecord, b: DiscussRecord) => number;
+ type?: string;
+};
+export type HtmlParams = FieldCommonParams;
+export type DateParams = FieldCommonParams;
+export type DatetimeParams = FieldCommonParams;
+
+export type DManyFn = () => T[];
diff --git a/src/runtime/relationalModel/field.ts b/src/runtime/relationalModel/field.ts
new file mode 100644
index 000000000..3dcc28447
--- /dev/null
+++ b/src/runtime/relationalModel/field.ts
@@ -0,0 +1,48 @@
+import {
+ FieldDefinition,
+ FieldDefinitionAny,
+ FieldDefinitionChar,
+ FieldDefinitionDate,
+ FieldDefinitionDatetime,
+ FieldDefinitionHtml,
+ FieldDefinitionMany2One,
+ FieldDefinitionMany2OneReference,
+ FieldDefinitionNumber,
+ FieldDefinitionOne2Many,
+ FieldDefinitionProperties,
+ FieldDefinitionReference,
+ FieldDefinitionSelection,
+ FieldDefinitionText,
+ FieldTypes,
+ ModelId,
+} from "./types";
+
+export const fieldAny = () => field("any", {}) as FieldDefinitionAny;
+
+export const fieldNumber = () => field("number", {}) as FieldDefinitionNumber;
+export const fieldChar = () => field("char", {}) as FieldDefinitionChar;
+export const fieldText = () => field("text", {}) as FieldDefinitionText;
+export const fieldHtml = () => field("html", {}) as FieldDefinitionHtml;
+export const fieldDate = () => field("date", {}) as FieldDefinitionDate;
+export const fieldDatetime = () => field("datetime", {}) as FieldDefinitionDatetime;
+export const fieldSelection = (selection: any) =>
+ field("selection", { selection }) as FieldDefinitionSelection;
+export const fieldReference = () => field("reference", {}) as FieldDefinitionReference;
+
+export const fieldProperties = () => field("properties", {}) as FieldDefinitionProperties;
+
+export const fieldOne2Many = (modelId: ModelId, { relatedField }: { relatedField?: string } = {}) =>
+ field("one2many", { modelId, relatedField }) as FieldDefinitionOne2Many;
+export const fieldMany2One = (modelId: ModelId) =>
+ field("many2one", { modelId }) as FieldDefinitionMany2One;
+export const fieldMany2Many = (modelId: ModelId, opts: { relationTableName?: string } = {}) =>
+ field("many2many", { modelId, ...opts });
+
+export const fieldMany2OneReference = () =>
+ field("many2one_reference", {}) as FieldDefinitionMany2OneReference;
+
+export const field = (type: FieldTypes, opts: any = {}): FieldDefinition => ({
+ fieldName: undefined,
+ type,
+ ...opts,
+});
diff --git a/src/runtime/relationalModel/model.ts b/src/runtime/relationalModel/model.ts
new file mode 100644
index 000000000..e19cf12fa
--- /dev/null
+++ b/src/runtime/relationalModel/model.ts
@@ -0,0 +1,562 @@
+import { MakeGetSet } from "../../common/types";
+import { reactive } from "../reactivity";
+import { derived } from "../signals";
+import { Models } from "./modelRegistry";
+import { globalStore } from "./store";
+import {
+ ModelId,
+ InstanceId,
+ FieldDefinition,
+ RecordItem,
+ ManyFn,
+ X2ManyFieldDefinition,
+ RelationChanges,
+ DraftContext,
+} from "./types";
+
+export class Model {
+ static id: ModelId;
+ static fields: Record = Object.create(null);
+ static relatedFields: Record = Object.create(null);
+ static recordsItems: Record;
+
+ static create(this: T, data: Partial>): InstanceType {
+ const m = new this(undefined, { createData: data });
+ return m as InstanceType;
+ }
+ static get(
+ this: T,
+ id: InstanceId,
+ context: DraftContext = CurrentDraftContext
+ ): InstanceType {
+ return context ? this.getContextInstance(id, context) : this.getGlobalInstance(id);
+ }
+ static getAll(this: T): InstanceType[] {
+ if ((this as any)._getAll) return (this as any)._getAll();
+ const modelId = this.id;
+ const ids = globalStore.searches[modelId]?.["[]"]!.ids;
+ (this as any)._getAll = derived(() => {
+ return ids.map((id) => this.get(id)) as InstanceType[];
+ });
+ return (this as any)._getAll();
+ }
+
+ static register(this: T) {
+ const targetModelId = this.id;
+ this.recordsItems = globalStore.getModelData(targetModelId);
+ Models[targetModelId] = this;
+ for (const [fieldName, def] of Object.entries(this.fields)) {
+ def.fieldName = fieldName;
+ switch (def.type) {
+ case "many2many":
+ attachMany2ManyField(this, fieldName, def.modelId);
+ break;
+ case "one2many":
+ attachOne2ManyField(this, fieldName, def.modelId);
+ break;
+ case "many2one":
+ attachMany2OneField(this, fieldName, def.modelId);
+ break;
+ default:
+ attachBaseField(this, fieldName);
+ break;
+ }
+ }
+ return this;
+ }
+ static getRecordItem(id: InstanceId, defaultData?: Record): RecordItem {
+ const modelData = this.recordsItems;
+ let recordItem = modelData[id];
+ if (recordItem) {
+ return recordItem;
+ }
+ const data = defaultData || {};
+ recordItem = modelData[id] = { data } as RecordItem;
+ const reactiveData = reactive(data);
+ recordItem.reactiveData = reactiveData;
+ recordItem.instance = undefined!;
+ return recordItem;
+ }
+ static getGlobalInstance(this: T, id: InstanceId): InstanceType {
+ const recordItem = this.getRecordItem(id);
+ const instance = recordItem.instance as InstanceType | undefined;
+ return instance || (new this(id) as InstanceType);
+ }
+ static getContextInstance(
+ this: T,
+ id: InstanceId,
+ draftContext: DraftContext = CurrentDraftContext!
+ ): InstanceType {
+ const modelStore = draftContext!.store;
+ let recordModelStore = modelStore[this.id];
+ if (!recordModelStore) recordModelStore = modelStore[this.id] = {};
+ const instance = recordModelStore[id] as InstanceType;
+ const parentContext = draftContext.parent;
+ const parentInstance = parentContext
+ ? this.getContextInstance(id, parentContext)
+ : this.getGlobalInstance(id);
+ return instance || (new this(parentInstance, { draftContext }) as InstanceType);
+ }
+
+ // Instance properties and methods
+
+ id?: InstanceId;
+ data!: RecordItem["data"];
+ reactiveData!: RecordItem["reactiveData"];
+ changes: RelationChanges = {};
+ reactiveChanges: RelationChanges = reactive(this.changes);
+ parentRecord?: Model;
+ childRecords: Model[] = [];
+ draftContext?: DraftContext;
+
+ constructor(
+ idOrParentRecord?: InstanceId | Model,
+ params: {
+ createData?: Record;
+ draftContext?: DraftContext;
+ } = {
+ draftContext: CurrentDraftContext,
+ }
+ ) {
+ const parentRecord: Model | null =
+ typeof idOrParentRecord === "object" ? idOrParentRecord : null;
+ const parentId: InstanceId | undefined = parentRecord?.id;
+ if (parentRecord) {
+ this.parentRecord = parentRecord;
+ this.draftContext = params.draftContext || makeDraftContext(parentRecord.draftContext);
+ this._setDraftItem(parentId!);
+ } else {
+ const id = parentId || idOrParentRecord || getNextId();
+ const C = this.constructor as typeof Model;
+ const recordItem = C.getRecordItem(params.createData?.id || id!);
+ this.data = recordItem.data;
+ this.data.id ??= id;
+ this.reactiveData = recordItem.reactiveData;
+ recordItem.instance = this;
+ }
+
+ // todo: this should not be store in data, change it when using proper
+ // signals.
+ // this.data.id = id === 0 || id ? id : getNextId();
+ defineLazyProperty(this, "id", () => {
+ const get = derived(() =>
+ this.parentRecord ? this.parentRecord.id : (this.reactiveData.id as InstanceId | undefined)
+ );
+ return [get] as const;
+ });
+ }
+
+ delete() {
+ // get all many2one fields in the static fields
+ const constructor = this.constructor as typeof Model;
+ for (const [fieldName, def] of Object.entries(constructor.fields)) {
+ switch (def.type) {
+ case "many2one":
+ (this as any)[fieldName] = null;
+ break;
+ case "many2many":
+ case "one2many":
+ const manyField = (this as any)[fieldName] as ManyFn;
+ const records = manyField();
+ for (var i = records.length - 1; i >= 0; i--) {
+ manyField.delete(records[i]);
+ }
+ break;
+ }
+ }
+ }
+ isNew() {
+ return typeof this.id === "string";
+ }
+ hasChanges() {
+ return Object.keys(this.reactiveChanges).length > 0;
+ }
+
+ // Draft methods
+
+ makeDraft() {
+ const Mod = this.constructor as typeof Model;
+ const newInstance = new Mod(this);
+ this.childRecords.push(newInstance);
+ return newInstance as this;
+ }
+
+ saveDraft() {
+ if (!this.parentRecord) {
+ throw new Error("Cannot save draft without a parent record");
+ }
+ const draftContext = this.draftContext!;
+ const parentContext = draftContext.parent;
+ for (const instances of Object.values(draftContext.store)) {
+ for (const instance of Object.values(instances)) {
+ instance._saveDraft(parentContext!);
+ }
+ }
+ }
+ _saveDraft(parentDraftContext: DraftContext) {
+ const Mod = this.constructor as typeof Model;
+ const parent = Mod.get(this.id!, parentDraftContext);
+ const parentReactiveChanges = parent.reactiveChanges;
+ const thisChanges = this.reactiveChanges;
+ for (const [key, value] of Object.entries(thisChanges)) {
+ if (!Array.isArray(value)) {
+ parentReactiveChanges[key] = value;
+ } else {
+ const [deleteList, addList] = value;
+ let parentChanges = parentReactiveChanges[key] as [InstanceId[], InstanceId[]] | undefined;
+ if (!parentChanges) {
+ parentChanges = parentReactiveChanges[key] = [[], []];
+ }
+ const [parentDeleteList, parentAddList] = parentChanges;
+ for (const id of deleteList) {
+ arrayDelete(parentAddList, id);
+ parentDeleteList.push(id);
+ }
+ for (const id of addList) {
+ arrayDelete(parentDeleteList, id);
+ parentAddList.push(id);
+ }
+ }
+ delete thisChanges[key];
+ }
+ }
+ withContext(fn: () => void) {
+ return withDraftContext(this.draftContext, fn);
+ }
+ _setDraftItem(id: InstanceId) {
+ if (!this.draftContext) return;
+ const modelStore = this.draftContext.store;
+ let recordModelStore = modelStore[(this.constructor as typeof Model).id];
+ if (!recordModelStore) {
+ recordModelStore = modelStore[(this.constructor as typeof Model).id] = {};
+ }
+ recordModelStore[id] = this;
+ }
+}
+
+function attachBaseField(target: typeof Model, fieldName: string) {
+ // todo: use instance instead of this
+ defineLazyProperty(target.prototype, fieldName, (obj: Model) => {
+ return [
+ () => {
+ return fieldName in obj.reactiveChanges
+ ? obj.reactiveChanges[fieldName]
+ : getBaseFieldValue(obj, fieldName);
+ },
+ (value: any) => {
+ obj.reactiveChanges[fieldName] = value;
+ },
+ ] as const;
+ });
+}
+function attachOne2ManyField(target: typeof Model, fieldName: string, relatedModelId: ModelId) {
+ const fieldInfos = getFieldInfos(target, fieldName, relatedModelId);
+ defineLazyProperty(target.prototype, fieldName, (obj: Model) => {
+ const { relatedFieldName, RelatedModel } = fieldInfos;
+ if (!relatedFieldName) {
+ const get = () => [] as Model[];
+ return [() => get] as const;
+ }
+ const ctx = obj.draftContext;
+ const get = getRelatedList(obj, fieldName, RelatedModel);
+ get.add = (m2oRecord: Model) => {
+ m2oRecord = ensureContext(ctx, m2oRecord)!;
+ const o2MRecordFrom = ensureContext(ctx, (m2oRecord as any)[relatedFieldName] as Model);
+ setMany2One(relatedFieldName, m2oRecord, fieldName, o2MRecordFrom, obj);
+ };
+ get.delete = (m2oRecord: Model) => {
+ m2oRecord = ensureContext(ctx, m2oRecord)!;
+ setMany2One(relatedFieldName, m2oRecord, fieldName, obj, undefined);
+ };
+ return [() => get] as const;
+ });
+}
+function attachMany2ManyField(target: typeof Model, fieldName: string, relatedModelId: ModelId) {
+ const fieldInfos = getFieldInfos(target, fieldName, relatedModelId);
+ defineLazyProperty(target.prototype, fieldName, (obj: Model) => {
+ const { relatedFieldName, RelatedModel } = fieldInfos;
+ if (!relatedFieldName) {
+ const get = () => [] as Model[];
+ return [() => get] as const;
+ }
+ const ctx = obj.draftContext;
+ const get = getRelatedList(obj, fieldName, RelatedModel);
+ get.add = (m2mRecord: Model) => {
+ m2mRecord = ensureContext(ctx, m2mRecord)!;
+ recordArrayAdd(obj, fieldName, m2mRecord.id!);
+ recordArrayAdd(m2mRecord, relatedFieldName, obj.id!);
+ };
+ get.delete = (m2mRecord: Model) => {
+ m2mRecord = ensureContext(ctx, m2mRecord)!;
+ recordArrayDelete(obj, fieldName, m2mRecord.id!);
+ recordArrayDelete(m2mRecord, relatedFieldName, obj.id!);
+ };
+ return [() => get] as const;
+ });
+}
+function attachMany2OneField(target: typeof Model, fieldName: string, relatedModelId: ModelId) {
+ const fieldInfos = getFieldInfos(target, fieldName, relatedModelId);
+ defineLazyProperty(target.prototype, fieldName, (obj: Model) => {
+ const ctx = obj.draftContext;
+ const _get = derived(() => {
+ const { RelatedModel } = fieldInfos;
+ const id =
+ fieldName in obj.reactiveChanges
+ ? obj.reactiveChanges[fieldName]
+ : getM2OValue(obj, fieldName);
+ if (id === undefined || id === null) {
+ return null;
+ }
+ return RelatedModel.get(id, ctx);
+ });
+ const get = () => _get() && ensureContext(CurrentDraftContext, _get()!)!;
+ const set = (o2mRecordTo: Model | number) => {
+ const { relatedFieldName, RelatedModel } = fieldInfos;
+ if (!relatedFieldName) throw new Error("Related field name is undefined");
+ if (typeof o2mRecordTo === "number") {
+ o2mRecordTo = RelatedModel.get(o2mRecordTo, ctx);
+ } else {
+ o2mRecordTo = o2mRecordTo && ensureContext(ctx, o2mRecordTo)!;
+ }
+ const o2mRecordIdFrom = obj.reactiveData[fieldName] as number | undefined;
+ const o2mRecordFrom = o2mRecordIdFrom ? RelatedModel.get(o2mRecordIdFrom, ctx) : undefined;
+ setMany2One(fieldName, obj, relatedFieldName, o2mRecordFrom, o2mRecordTo);
+ };
+ return [get, set] as const;
+ });
+}
+function getFieldInfos(target: typeof Model, fieldName: string, relatedModelId: ModelId) {
+ return {
+ get relatedFieldName() {
+ const relatedFieldName = getRelatedFieldName(target, fieldName);
+ Object.defineProperty(this, "relatedFieldName", { get: () => relatedFieldName });
+ return relatedFieldName;
+ },
+ get RelatedModel() {
+ const RelatedModel = Models[relatedModelId];
+ Object.defineProperty(this, "RelatedModel", { get: () => RelatedModel });
+ return RelatedModel;
+ },
+ };
+}
+/**
+ * Define a lazy property on an object that computes its getter and setter on first access.
+ * Allowing to delay some computation until the property is actually used.
+ *
+ * @param object The object on which to define the property.
+ * @param property The name of the property to define.
+ * @param makeGetSet A function that returns a tuple containing the getter and optional setter.
+ * @example
+ * defineLazyProperty(MyClass.prototype, "myProperty", function() {
+ * // Some computing that will only run once, on first access.
+ * return [
+ * () => this._myProperty,
+ * (value) => { this._myProperty = value; }
+ * ];
+ * });
+ */
+export function defineLazyProperty(
+ object: object,
+ property: string,
+ makeGetSet: MakeGetSet
+) {
+ function makeAndRedefineProperty(obj: T) {
+ const tuple = makeGetSet(obj);
+ Object.defineProperty(obj, property, { get: tuple[0], set: tuple[1] });
+ return tuple;
+ }
+ Object.defineProperty(object, property, {
+ get() {
+ const get = makeAndRedefineProperty(this as T)[0];
+ return get();
+ },
+ set(value) {
+ const set = makeAndRedefineProperty(this as T)[1];
+ set?.call(this as T, value);
+ },
+ configurable: true,
+ enumerable: true,
+ });
+}
+
+/**
+ * Get the field of the related model that relates back to this model.
+ *
+ * @param fieldName The field name in this model.
+ */
+function getRelatedFieldName(Mod: typeof Model, fieldName: string) {
+ // Could be already set by the related model.
+ if (Mod.relatedFields[fieldName]) return Mod.relatedFields[fieldName];
+ const def = Mod.fields[fieldName] as X2ManyFieldDefinition;
+ const RelatedModel = Models[def.modelId];
+ const modelId = Mod.id;
+ switch (def.type) {
+ case "one2many":
+ const relatedFieldName =
+ def.relatedField ||
+ Object.values(RelatedModel.fields).find(
+ (d) => d.type === "many2one" && d.modelId === modelId
+ )?.fieldName;
+ if (!relatedFieldName) {
+ return;
+ }
+ Mod.relatedFields[fieldName] = relatedFieldName;
+ RelatedModel.relatedFields[relatedFieldName] = fieldName;
+ return relatedFieldName;
+ case "many2many": {
+ const { relationTableName } = def;
+ const relatedFieldName = Object.values(RelatedModel.fields).find(
+ (d) =>
+ d.type === "many2many" &&
+ d.modelId === modelId &&
+ (!relationTableName || d.relationTableName === relationTableName)
+ )?.fieldName;
+ if (!relatedFieldName) {
+ return;
+ }
+ Mod.relatedFields[fieldName] = relatedFieldName;
+ RelatedModel.relatedFields[relatedFieldName] = fieldName;
+ return relatedFieldName;
+ }
+ case "many2one": {
+ for (const fieldName of Object.keys(RelatedModel.fields)) {
+ getRelatedFieldName(RelatedModel, fieldName);
+ // The many2one is set by the one2many field.
+ }
+ const relatedFieldName = Mod.relatedFields[fieldName];
+ if (!relatedFieldName) {
+ return;
+ }
+ return relatedFieldName;
+ }
+ }
+}
+
+function setMany2One(
+ m2oFieldName: string,
+ m2oRecord: Model,
+ o2mFieldName: string,
+ o2mRecordFrom?: Model,
+ o2mRecordTo?: Model
+) {
+ if (o2mRecordFrom === o2mRecordTo) return;
+ if (o2mRecordFrom) recordArrayDelete(o2mRecordFrom, o2mFieldName, m2oRecord.id);
+ if (o2mRecordTo) recordArrayAdd(o2mRecordTo, o2mFieldName, m2oRecord.id);
+ m2oRecord.reactiveChanges[m2oFieldName] = o2mRecordTo ? o2mRecordTo.id! : null;
+}
+function recordArrayDelete(record: Model, fieldName: string, value: any) {
+ const [deleteList, addList] = getChanges(record, fieldName);
+ arrayDelete(addList, value);
+ deleteList.push(value);
+}
+function recordArrayAdd(record: Model, fieldName: string, value: any) {
+ const [deleteList, addList] = getChanges(record, fieldName);
+ arrayDelete(deleteList, value);
+ addList.push(value);
+}
+
+function getBaseFieldValue(record: Model, fieldName: string) {
+ return record.parentRecord
+ ? (record.parentRecord as any)[fieldName] // get the computed field
+ : record.reactiveData[fieldName];
+}
+function getM2OValue(record: Model, fieldName: string) {
+ return record.parentRecord
+ ? (record.parentRecord as any)[fieldName]?.id // get the computed field
+ : record.reactiveData[fieldName];
+}
+function getBaseManyFieldValue(record: Model, fieldName: string) {
+ return record.parentRecord
+ ? (record.parentRecord as any)[fieldName].ids() // get the computed field
+ : record.reactiveData[fieldName];
+}
+function getRelatedList(
+ record: Model,
+ fieldName: string,
+ RelatedModel: typeof Model
+): ManyFn {
+ const draftContext = record.draftContext;
+ const getInstance = (id: InstanceId) => RelatedModel.get(id, draftContext);
+ const getIds = derived(() => {
+ const source = getBaseManyFieldValue(record, fieldName) as InstanceId[];
+ const changes = record.reactiveChanges[fieldName] as [InstanceId[], InstanceId[]];
+ const [deleteList, addList] = changes || [[], []];
+ return combineLists(source, deleteList, addList);
+ });
+ const getInstances = derived(() => {
+ return getIds().map(getInstance);
+ }) as ManyFn;
+ getInstances.ids = getIds;
+ return getInstances;
+}
+function arrayDelete(array: any[], value: any) {
+ const index = array.indexOf(value);
+ if (index !== -1) {
+ array.splice(index, 1);
+ }
+}
+function getChanges(record: Model, fieldName: string) {
+ const allChanges = record.reactiveChanges;
+ let changes = allChanges[fieldName] as [InstanceId[], InstanceId[]];
+ if (!changes) {
+ changes = [[], []];
+ allChanges[fieldName] = changes;
+ }
+ return changes;
+}
+export function combineLists(listA: InstanceId[], deleteList: InstanceId[], addList: InstanceId[]) {
+ const set = new Set(listA);
+ for (const id of deleteList) {
+ set.delete(id);
+ }
+ for (const id of addList) {
+ set.add(id);
+ }
+ return Array.from(set);
+}
+
+// Drafts helpers
+
+let CurrentDraftContext: DraftContext;
+
+export function ensureContext(context: DraftContext, record: Model) {
+ if (!record) return;
+ if (record.draftContext === context) return record;
+ if (!context) return (record.constructor as typeof Model).getGlobalInstance(record.id!);
+ return (record.constructor as typeof Model).getContextInstance(record.id!, context);
+}
+export function withDraftContext(context: DraftContext, fn: () => T): T {
+ const previousContext = CurrentDraftContext;
+ CurrentDraftContext = context;
+ try {
+ return fn();
+ } finally {
+ CurrentDraftContext = previousContext;
+ }
+}
+export function saveDraftContext(context: DraftContext) {
+ for (const modelId of Object.keys(context!.store)) {
+ const recordModelStore = context!.store[modelId];
+ for (const instance of Object.values(recordModelStore)) {
+ instance.saveDraft();
+ }
+ }
+}
+export function makeDraftContext(parent?: DraftContext): DraftContext {
+ const draftContext: DraftContext = { parent, store: {} };
+ return draftContext;
+}
+
+// Id helpers
+
+let lastId = 0;
+function getNextId() {
+ lastId += 1;
+ return formatId(lastId);
+}
+export function formatId(number: number) {
+ return `virtual_${number}`;
+}
+export function resetIdCounter() {
+ lastId = 0;
+}
diff --git a/src/runtime/relationalModel/modelData.ts b/src/runtime/relationalModel/modelData.ts
new file mode 100644
index 000000000..bbaec77cf
--- /dev/null
+++ b/src/runtime/relationalModel/modelData.ts
@@ -0,0 +1,151 @@
+import { combineLists, Model } from "./model";
+import { Models } from "./modelRegistry";
+import { isMany2OneField, isX2ManyField } from "./modelUtils";
+import { InstanceId, ModelId, RelationChanges } from "./types";
+
+export type DataToSave = Record>;
+
+const lastModelIds: Record = {};
+
+export const saveHooks = {
+ onSave: (data: DataToSave) => {},
+};
+
+export const x2ManyCommands = {
+ // (0, virtualID | false, { values })
+ CREATE: 0,
+ // (1, id, { values })
+ UPDATE: 1,
+ // (2, id[, _])
+ DELETE: 2,
+ // (3, id[, _]) removes relation, but not linked record itself
+ UNLINK: 3,
+ // (4, id[, _])
+ LINK: 4,
+ // (5[, _[, _]])
+ CLEAR: 5,
+ // (6, _, ids) replaces all linked records with provided ids
+ SET: 6,
+};
+
+export function getRecordChanges(
+ record: Model,
+ dataToSave: DataToSave = {},
+ processedRecords = new Set()
+) {
+ const Mod = record.constructor as typeof Model;
+ if (processedRecords.has(record)) return dataToSave;
+
+ let itemChanges: Record = {};
+ for (const key of Object.keys(record.changes)) {
+ if (key === "id") continue; // we can't change the id field
+ const fieldDef = Mod.fields[key];
+ if (!fieldDef) continue;
+ const fieldType = fieldDef.type;
+ if (isX2ManyField(fieldType)) {
+ const relatedRecords: Model[] = (record as any)[key]();
+ const relatedChanges: any[] = [];
+ for (const record of relatedRecords) {
+ const changes = getRecordChanges(record, dataToSave, processedRecords);
+ delete changes.id;
+ if (Object.keys(changes).length < 1) continue;
+ const isNew = record.isNew();
+ relatedChanges.push(
+ isNew
+ ? [x2ManyCommands.CREATE, record.id, changes]
+ : [x2ManyCommands.UPDATE, record.id, changes]
+ );
+ }
+ if (relatedChanges.length < 1) continue;
+ itemChanges[key] = relatedChanges;
+ continue;
+ }
+ if (isMany2OneField(fieldType)) {
+ // const relatedRecord: Model = (record as any)[key];
+ // const relatedChanges = getRecordChanges(relatedRecord, dataToSave, processedRecords);
+ // if (Object.keys(relatedChanges).length > 0) {
+ // // there are changes to save in the related record
+ // delete relatedChanges.id;
+ // const isNew = relatedRecord.isNew();
+ // itemChanges[key] = isNew
+ // ? [x2ManyCommands.CREATE, null, relatedChanges]
+ // : [x2ManyCommands.UPDATE, relatedRecord.id, relatedChanges];
+ // }
+
+ continue;
+ }
+ const { changes } = record;
+ if (!(key in changes)) continue;
+ itemChanges[key] = deepClone(changes[key]);
+ }
+ if (Object.keys(itemChanges).length > 0) itemChanges.id = record.id;
+ return itemChanges;
+}
+
+export function saveModels() {
+ const dataToSave: DataToSave = {};
+ for (const Model of Object.values(Models)) {
+ for (const item of Object.values(Model.recordsItems)) {
+ const instance = item.instance;
+ if (!instance) continue;
+ let itemChanges: Record = {};
+ for (const key of Object.keys(instance.changes)) {
+ // skip one2many fields
+ if (Model.fields[key]?.type === "one2many") continue;
+ itemChanges[key] = deepClone(instance.changes[key]);
+ const change = instance.changes[key];
+ if (Array.isArray(change)) {
+ // many2many or one2many field
+ const [deleteList, addList] = change;
+ const currentList = instance.data[key] as InstanceId[];
+ instance.reactiveData[key] = combineLists(currentList, deleteList, addList);
+ } else {
+ // many2one or simple field
+ instance.reactiveData[key] = change;
+ }
+ delete instance.reactiveChanges[key];
+ }
+ if (Object.keys(itemChanges).length > 0) {
+ dataToSave[Model.id] = dataToSave[Model.id] || {};
+ dataToSave[Model.id][instance.id!] = itemChanges;
+ }
+ }
+ }
+ saveHooks.onSave(dataToSave);
+ // simulate what the server returning new ids for created records
+ for (const Model of Object.values(Models)) {
+ let lastId = lastModelIds[Model.id] || 1000;
+ for (const item of Object.values(Model.recordsItems)) {
+ const instance = item.instance;
+ if (!instance || typeof instance.id !== "string") continue;
+ lastId++;
+ item.instance!.reactiveData.id = lastId;
+ }
+ lastModelIds[Model.id] = lastId;
+ }
+}
+
+export function commitRecordChanges(record: Model) {
+ const Mod = record.constructor as typeof Model;
+ for (const key of Object.keys(record.changes)) {
+ const field = Mod.fields[key];
+ if (!field) continue;
+ const change = record.changes[key];
+ const reactiveData = record.reactiveData;
+ if (Array.isArray(change)) {
+ // many2many or one2many field
+ const [deleteList, addList] = change;
+ const currentList = record.data[key] as InstanceId[];
+ reactiveData[key] = combineLists(currentList, deleteList, addList);
+ delete record.reactiveChanges[key];
+ } else {
+ // many2one or simple field
+ reactiveData[key] = change;
+ delete record.reactiveChanges[key];
+ }
+ }
+}
+
+function deepClone(obj: any): any {
+ return JSON.parse(JSON.stringify(obj));
+}
diff --git a/src/runtime/relationalModel/modelRegistry.ts b/src/runtime/relationalModel/modelRegistry.ts
new file mode 100644
index 000000000..95627a16c
--- /dev/null
+++ b/src/runtime/relationalModel/modelRegistry.ts
@@ -0,0 +1,9 @@
+import { Model } from "./model";
+
+export const Models: Record = {};
+
+export function clearModelRegistry() {
+ for (const key of Object.keys(Models)) {
+ delete Models[key];
+ }
+}
diff --git a/src/runtime/relationalModel/modelUtils.ts b/src/runtime/relationalModel/modelUtils.ts
new file mode 100644
index 000000000..328d4b6ec
--- /dev/null
+++ b/src/runtime/relationalModel/modelUtils.ts
@@ -0,0 +1,12 @@
+export function isRelatedField(fieldType: string): boolean {
+ return fieldType === "many2one" || fieldType === "one2many" || fieldType === "many2many";
+}
+export function isX2ManyField(fieldType: string): boolean {
+ return fieldType === "one2many" || fieldType === "many2many";
+}
+export function isOne2ManyField(fieldType: string): boolean {
+ return fieldType === "one2many";
+}
+export function isMany2OneField(fieldType: string): boolean {
+ return fieldType === "many2one";
+}
diff --git a/src/runtime/relationalModel/store.ts b/src/runtime/relationalModel/store.ts
new file mode 100644
index 000000000..133f06cf4
--- /dev/null
+++ b/src/runtime/relationalModel/store.ts
@@ -0,0 +1,114 @@
+import { reactive } from "../reactivity";
+import { Model } from "./model";
+import { Models } from "./modelRegistry";
+import {
+ ModelId,
+ InstanceId,
+ RecordItem,
+ NormalizedDomain,
+ SearchEntry,
+ X2ManyFieldDefinition,
+ DraftContextStore,
+} from "./types";
+import { RawStore } from "../../../tests/model.test";
+
+export type StoreData = Record>;
+class Store {
+ searches: Record> = {};
+ data: Record> = {};
+
+ getModelData(modelId: ModelId) {
+ return (this.data[modelId] ??= {});
+ }
+}
+
+export const globalStore = new Store();
+
+// store shoulde be RawStore
+export function setStore(store: any) {
+ for (const modelId of Object.keys(store)) {
+ const Model = Models[modelId];
+ const recordIds = Object.keys(store[modelId]).map((id) => Number(id));
+ for (const id of recordIds) {
+ const newData = store[modelId][id as unknown as number];
+ Object.assign(Model.getRecordItem(id).data, newData);
+ }
+ globalStore.searches[modelId] = {
+ "[]": {
+ ids: reactive(recordIds.map((id) => id)),
+ },
+ };
+ }
+}
+export function destroyStore() {
+ globalStore.data = {};
+ globalStore.searches = {};
+}
+
+export function loadRecord(modelId: ModelId, instanceId: InstanceId, data: Record) {
+ const Model = Models[modelId];
+ const instance = Model.get(instanceId);
+ Object.assign(instance.reactiveData, data);
+}
+
+export function loadRecordWithRelated(Mod: typeof Model, instanceData: Record) {
+ const id = instanceData.id;
+ if (id === undefined) {
+ throw new Error("Instance data must have an id field");
+ }
+ const instance = Mod.get(id);
+ let item: RecordItem;
+ for (const fieldName in instanceData) {
+ const field = Mod.fields[fieldName];
+ if (!field) {
+ item ??= Mod.getRecordItem(id);
+ item.dataToLoad ??= {};
+ item.dataToLoad[fieldName] = instanceData[fieldName];
+ continue;
+ }
+ const win = window as any;
+ instanceData[fieldName] = win.parseServerValue(field, instanceData[fieldName]);
+ const value = instanceData[fieldName];
+ if (Array.isArray(value) && (field.type === "one2many" || field.type === "many2many")) {
+ const f = field as X2ManyFieldDefinition;
+ const ids = value.map((itemOrId) => {
+ if (typeof itemOrId !== "object") return itemOrId;
+ const RelatedModel = Models[f.modelId];
+ loadRecordWithRelated(RelatedModel, itemOrId);
+ return itemOrId.id;
+ });
+ instance.reactiveData[fieldName] = ids;
+ } else if (typeof value === "object" && value !== null && field.type === "many2one") {
+ const f = field as X2ManyFieldDefinition;
+ const RelatedModel = Models[f.modelId];
+ loadRecordWithRelated(RelatedModel, value);
+ instance.reactiveData[fieldName] = value.id;
+ } else {
+ instance.reactiveData[fieldName] = value;
+ }
+ }
+ return instance;
+}
+export function flushDataToLoad() {
+ for (const Model of Object.values(Models)) {
+ for (const item of Object.values(Model.recordsItems)) {
+ const dataToLoad = item.dataToLoad;
+ if (!dataToLoad) continue;
+ delete item.dataToLoad;
+ loadRecordWithRelated(Model, dataToLoad);
+ }
+ }
+}
+(window as any).globalStore = globalStore;
+
+export function getStoreChanges(store: DraftContextStore) {
+ const changes: RawStore = {};
+ for (const modelId of Object.keys(store)) {
+ changes[modelId] = {};
+ const modelStore = store[modelId];
+ for (const instanceId of Object.keys(modelStore)) {
+ changes[modelId][instanceId] = modelStore[instanceId].changes;
+ }
+ }
+ return changes;
+}
diff --git a/src/runtime/relationalModel/types.ts b/src/runtime/relationalModel/types.ts
new file mode 100644
index 000000000..6d7a79fe8
--- /dev/null
+++ b/src/runtime/relationalModel/types.ts
@@ -0,0 +1,81 @@
+import { Model } from "./model";
+
+export type FieldTypes = FieldDefinition["type"];
+export type ModelId = string;
+export type NormalizedDomain = string;
+export type InstanceId = number | string;
+export type FieldName = string;
+export type ItemData = Record;
+export type RecordItem = {
+ data: ItemData;
+ reactiveData: ItemData;
+ instance: Model;
+
+ // This data is stored here in case we load data before a model or a related
+ // model is defined.
+ dataToLoad?: ItemData;
+};
+export type RelationChanges = Record;
+
+export type FieldDefinitionBase = { fieldName: string };
+export type FieldDefinitionAny = FieldDefinitionBase & { type: "any" };
+export type FieldDefinitionString = FieldDefinitionBase & { type: "string" };
+export type FieldDefinitionChar = FieldDefinitionBase & { type: "char" };
+export type FieldDefinitionText = FieldDefinitionBase & { type: "text" };
+export type FieldDefinitionHtml = FieldDefinitionBase & { type: "html" };
+export type FieldDefinitionDate = FieldDefinitionBase & { type: "date" };
+export type FieldDefinitionDatetime = FieldDefinitionBase & { type: "datetime" };
+export type FieldDefinitionSelection = FieldDefinitionBase & {
+ type: "selection";
+ selection: any;
+};
+export type FieldDefinitionReference = FieldDefinitionBase & { type: "reference" };
+export type FieldDefinitionMany2OneReference = FieldDefinitionBase & { type: "many2one_reference" };
+// Removed duplicate FieldDefinitionMany2One definition (already defined as FieldDefinitionX2Many & { type: "many2one" })
+export type FieldDefinitionProperties = FieldDefinitionBase & { type: "properties" };
+export type FieldDefinitionNumber = FieldDefinitionBase & { type: "number" };
+export type FieldDefinitionX2Many = FieldDefinitionBase & { modelId: ModelId };
+export type FieldDefinitionOne2Many = FieldDefinitionX2Many & {
+ type: "one2many";
+ relatedField?: string;
+};
+export type FieldDefinitionMany2One = FieldDefinitionX2Many & { type: "many2one" };
+export type FieldDefinitionMany2Many = FieldDefinitionX2Many & {
+ type: "many2many";
+ relationTableName?: string;
+};
+export type X2ManyFieldDefinition =
+ | FieldDefinitionOne2Many
+ | FieldDefinitionMany2One
+ | FieldDefinitionMany2Many;
+export type FieldDefinition =
+ | FieldDefinitionAny
+ | FieldDefinitionString
+ | FieldDefinitionChar
+ | FieldDefinitionText
+ | FieldDefinitionHtml
+ | FieldDefinitionDate
+ | FieldDefinitionDatetime
+ | FieldDefinitionSelection
+ | FieldDefinitionReference
+ | FieldDefinitionMany2OneReference
+ | FieldDefinitionProperties
+ | FieldDefinitionNumber
+ | X2ManyFieldDefinition;
+
+export type ManyFn = (() => T[]) & {
+ add: (m: T) => void;
+ delete: (m: T) => void;
+ ids: () => InstanceId[];
+};
+
+export type SearchEntry = {
+ ids: InstanceId[];
+};
+export type DraftContextStore = Record>;
+export type DraftContext =
+ | {
+ parent?: DraftContext;
+ store: DraftContextStore;
+ }
+ | undefined;
diff --git a/src/runtime/relationalModel/util.ts b/src/runtime/relationalModel/util.ts
new file mode 100644
index 000000000..99ef3b9e6
--- /dev/null
+++ b/src/runtime/relationalModel/util.ts
@@ -0,0 +1,6 @@
+export function mapEntries(
+ obj: Record,
+ fn: (entry: [string, T]) => [string, U]
+): Record {
+ return Object.fromEntries(Object.entries(obj).map(fn));
+}
diff --git a/src/runtime/relationalModel/web/WebDataPoint.ts b/src/runtime/relationalModel/web/WebDataPoint.ts
new file mode 100644
index 000000000..a6fe5692e
--- /dev/null
+++ b/src/runtime/relationalModel/web/WebDataPoint.ts
@@ -0,0 +1,55 @@
+export class DataPoint {
+ /**
+ * @param {RelationalModel} model
+ * @param {RelationalModelConfig} config
+ * @param {Record} data
+ * @param {unknown} [options]
+ */
+ model: any;
+ _config: any;
+ // constructor(model: any, config: any, data: any, options: any) {
+ // this._constructor(model, config, data, options);
+ // }
+ _constructor(model: any, config: any, data: any, options: any) {
+ // this.id = getId("datapoint");
+ this.model = model;
+ /** @type {RelationalModelConfig} */
+ this._config = config;
+ this.setup(config, data, options);
+ }
+
+ /**
+ * @abstract
+ * @template [O={}]
+ * @param {RelationalModelConfig} _config
+ * @param {Record} _data
+ * @param {O | undefined} _options
+ */
+ setup(_config: any, _data: any, _options: any) {}
+
+ get activeFields() {
+ return this.config.activeFields;
+ }
+
+ get fields() {
+ return this.config.fields;
+ }
+
+ get fieldNames() {
+ return Object.keys(this.activeFields).filter(
+ (fieldName) => !this.fields[fieldName].relatedPropertyField
+ );
+ }
+
+ get resModel() {
+ return this.config.resModel;
+ }
+
+ get config() {
+ return this._config;
+ }
+
+ get context() {
+ return this.config.context;
+ }
+}
diff --git a/src/runtime/relationalModel/web/WebRecord.ts b/src/runtime/relationalModel/web/WebRecord.ts
new file mode 100644
index 000000000..888dfe5ed
--- /dev/null
+++ b/src/runtime/relationalModel/web/WebRecord.ts
@@ -0,0 +1,1394 @@
+import { defineLazyProperty, ensureContext, Model } from "../model";
+import { getRecordChanges } from "../modelData";
+import { flushDataToLoad, loadRecordWithRelated } from "../store";
+import { DataPoint } from "./WebDataPoint";
+import { makeModelFromWeb } from "./webModel";
+import { StaticList, StaticListConfig } from "./WebStaticList";
+
+export type MakeWebRecord = (model: any, config: any, data: any, options: any) => WebRecord;
+const makeWebRecord: MakeWebRecord = (...args) => new WebRecord(...args);
+
+export class WebRecord extends DataPoint {
+ static type = "Record";
+ orecord!: Model;
+ data!: Record;
+ evalContext!: Record;
+ evalContextWithVirtualIds!: Record;
+ _isEvalContextReady = false;
+ canSaveOnUpdate: boolean = true;
+ selected: boolean | undefined;
+
+ constructor(...args: Parameters) {
+ super();
+ this._constructor(...args);
+ }
+
+ setup(_config: any, data: any, options: any = {}) {
+ // options.orecord is created by static list
+ if (options.orecord) {
+ this.orecord = options.orecord;
+ this.data = makeFieldObject(this, this.orecord);
+ this._setEvalContext();
+ return;
+ }
+
+ const OModel = makeModelFromWeb(_config);
+ this.orecord = new OModel(this.config.resId);
+ if (options.draftContext) {
+ this.orecord = ensureContext(options.draftContext, this.orecord)!;
+ } else if (this.config.resId) {
+ this.orecord = this.orecord.makeDraft();
+ (this.orecord.draftContext as any).name ??= "main";
+ }
+ loadRecordWithRelated(OModel, { id: this.orecord.id, ...data });
+ flushDataToLoad();
+ this.data = makeFieldObject(this, this.orecord);
+ // this.evalContext = reactive({});
+ // this.evalContextWithVirtualIds = reactive({});
+ this._setEvalContext();
+ }
+
+ // record infos - basic ----------------------------------------------------
+ get id() {
+ return this.orecord.id;
+ }
+ get resId() {
+ const { orecord } = this;
+ return !orecord.isNew() && orecord.id;
+ }
+ get isNew() {
+ return this.orecord.isNew();
+ }
+ get dirty() {
+ return this.orecord.hasChanges();
+ }
+ // required, number
+ get isValid() {
+ return true;
+ // return !this._invalidFields.size;
+ }
+
+ _isRequired(fieldName: string) {
+ const win = window as any;
+ const required = this.activeFields[fieldName].required;
+ return required ? win.evaluateBooleanExpr(required, this.evalContextWithVirtualIds) : false;
+ }
+ // record infos - odoo specific --------------------------------------------
+ // is archived
+ get isActive() {
+ const data = this.data;
+ if ("active" in data) {
+ return data.active;
+ } else if ("x_active" in data) {
+ return data.x_active;
+ }
+ return true;
+ }
+ _isInvisible(fieldName: string) {
+ const win = window as any;
+ const invisible = this.activeFields[fieldName].invisible;
+ return invisible ? win.evaluateBooleanExpr(invisible, this.evalContextWithVirtualIds) : false;
+ }
+ _isReadonly(fieldName: string) {
+ const win = window as any;
+ const readonly = this.activeFields[fieldName].readonly;
+ return readonly ? win.evaluateBooleanExpr(readonly, this.evalContextWithVirtualIds) : false;
+ }
+ // record update -----------------------------------------------------------
+ update(changes: any, { save }: any = {}) {
+ if (this.model._urgentSave) {
+ return this._updateORecord(this.orecord, changes);
+ // return this._update(changes);
+ }
+ return this.model.mutex.exec(async () => {
+ // await this._update(changes, { withoutOnchange: save });
+ await this._updateORecord(this.orecord, changes);
+ if (save && this.canSaveOnUpdate) {
+ return this._save();
+ }
+ });
+ // save;
+ }
+ async _updateORecord(orecord: any, changes: any) {
+ for (const key in changes) {
+ if (key === "id") {
+ continue;
+ }
+ const field = orecord.constructor.fields[key];
+ if (field.type === "many2one") {
+ this._updateORecord(orecord[key], changes[key]);
+ continue;
+ }
+ if (["one2many", "many2many"].includes(field?.type)) {
+ throw new Error("debug me");
+ }
+ (this.orecord as any)[key] = changes[key];
+ }
+ }
+ async _update(changes: any, { withoutOnchange, withoutParentUpdate }: any = {}) {
+ throw new Error("debug me");
+ // this.dirty = true;
+ // const prom = Promise.all([
+ // this._preprocessMany2oneChanges(changes),
+ // this._preprocessMany2OneReferenceChanges(changes),
+ // this._preprocessReferenceChanges(changes),
+ // this._preprocessX2manyChanges(changes),
+ // this._preprocessPropertiesChanges(changes),
+ // this._preprocessHtmlChanges(changes),
+ // ]);
+ // if (!this.model._urgentSave) {
+ // await prom;
+ // }
+ // if (this.selected && this.model.multiEdit) {
+ // return this.model.root._multiSave(this, changes);
+ // }
+ // let onchangeServerValues = {};
+ // if (!this.model._urgentSave && !withoutOnchange) {
+ // onchangeServerValues = await this._getOnchangeValues(changes);
+ // }
+ // // changes inside the record set as value for a many2one field must trigger the onchange,
+ // // but can't be considered as changes on the parent record, so here we detect if many2one
+ // // fields really changed, and if not, we delete them from changes
+ // for (const fieldName in changes) {
+ // if (this.fields[fieldName].type === "many2one") {
+ // const curVal = toRaw(this.data[fieldName]);
+ // const nextVal = changes[fieldName];
+ // if (
+ // curVal &&
+ // nextVal &&
+ // curVal.id === nextVal.id &&
+ // curVal.display_name === nextVal.display_name
+ // ) {
+ // delete changes[fieldName];
+ // }
+ // }
+ // }
+ // const undoChanges = this._applyChanges(changes, onchangeServerValues);
+ // if (Object.keys(changes).length > 0 || Object.keys(onchangeServerValues).length > 0) {
+ // try {
+ // await this._onUpdate({ withoutParentUpdate });
+ // } catch (e) {
+ // undoChanges();
+ // throw e;
+ // }
+ // await this.model.hooks.onRecordChanged(this, this._getChanges());
+ // }
+ }
+
+ // Context -----------------------------------------------------------------
+ _setEvalContext() {
+ // todo: what is this?
+ const win = window as any;
+ const evalContext = win.getBasicEvalContext(this.config);
+ const dataContext = this._computeDataContext();
+ this.evalContext ??= {};
+ this.evalContextWithVirtualIds ??= {};
+ Object.assign(this.evalContext, evalContext, dataContext.withoutVirtualIds);
+ Object.assign(this.evalContextWithVirtualIds, evalContext, dataContext.withVirtualIds);
+ this._isEvalContextReady = true;
+
+ // if (!this._parentRecord || this._parentRecord._isEvalContextReady) {
+ // for (const [fieldName, value] of Object.entries(toRaw(this.data))) {
+ // if (["one2many", "many2many"].includes(this.fields[fieldName].type)) {
+ // value._updateContext(getFieldContext(this, fieldName));
+ // }
+ // }
+ // }
+ }
+ _computeDataContext() {
+ const dataContext: Record = {};
+ const x2manyDataContext: Record = {
+ withVirtualIds: {},
+ withoutVirtualIds: {},
+ };
+ const data = { ...this.data };
+ for (const fieldName in data) {
+ const value = data[fieldName];
+ const field = this.fields[fieldName];
+ if (field.relatedPropertyField) {
+ continue;
+ }
+ const win = window as any;
+ if (["char", "text", "html"].includes(field.type)) {
+ dataContext[fieldName] = data[fieldName];
+ } else if (field.type === "one2many" || field.type === "many2many") {
+ x2manyDataContext.withVirtualIds[fieldName] = value;
+ x2manyDataContext.withoutVirtualIds[fieldName] = value.filter(
+ (id: any) => typeof id === "number"
+ );
+ } else if (value && field.type === "date") {
+ dataContext[fieldName] = win.serializeDate(value);
+ } else if (value && field.type === "datetime") {
+ dataContext[fieldName] = win.serializeDateTime(value);
+ } else if (value && field.type === "many2one") {
+ dataContext[fieldName] = value;
+ } else if (value && field.type === "reference") {
+ dataContext[fieldName] = `${value.resModel},${value.resId}`;
+ } else if (field.type === "properties") {
+ // dataContext[fieldName] = value.filter(
+ // (property: any) => !property.definition_deleted !== false
+ // );
+ dataContext[fieldName] = null;
+ } else {
+ dataContext[fieldName] = value;
+ }
+ }
+ dataContext.id = this.resId || false;
+ return {
+ withVirtualIds: { ...dataContext, ...x2manyDataContext.withVirtualIds },
+ withoutVirtualIds: { ...dataContext, ...x2manyDataContext.withoutVirtualIds },
+ };
+ }
+
+ // Server / save -----------------------------------------------------------
+ /**
+ * @param {Parameters[0]} options
+ */
+ async save(options: any) {
+ await this.model._askChanges();
+ return this.model.mutex.exec(() => this._save(options));
+ }
+ async _save({ reload = true, onError, nextId }: any = {}) {
+ if (this.model._closeUrgentSaveNotification) {
+ this.model._closeUrgentSaveNotification();
+ }
+ if (nextId) {
+ debugger;
+ }
+ // const creation = !this.resId;
+ // if (nextId) {
+ // if (creation) {
+ // throw new Error("Cannot set nextId on a new record");
+ // }
+ // reload = true;
+ // }
+ // // before saving, abandon new invalid, untouched records in x2manys
+ // for (const fieldName in this.activeFields) {
+ // const field = this.fields[fieldName];
+ // if (["one2many", "many2many"].includes(field.type) && !field.relatedPropertyField) {
+ // this.data[fieldName]._abandonRecords();
+ // }
+ // }
+ // if (!this._checkValidity({ displayNotification: true })) {
+ // return false;
+ // }
+ // const changes = this._getChanges();
+ const changes = this._getChanges();
+ console.warn(`changes:`, changes);
+ // delete changes.id; // id never changes, and should not be written
+ // if (!creation && !Object.keys(changes).length) {
+ // if (nextId) {
+ // return this.model.load({ resId: nextId });
+ // }
+ // this._changes = markRaw({});
+ // this.data2 = { ...this._values };
+ // this.dirty = false;
+ // return true;
+ // }
+ // if (
+ // this.model._urgentSave &&
+ // this.model.useSendBeaconToSaveUrgently &&
+ // !this.model.env.inDialog
+ // ) {
+ // // We are trying to save urgently because the user is closing the page. To
+ // // ensure that the save succeeds, we can't do a classic rpc, as these requests
+ // // can be cancelled (payload too heavy, network too slow, computer too fast...).
+ // // We instead use sendBeacon, which isn't cancellable. However, it has limited
+ // // payload (typically < 64k). So we try to save with sendBeacon, and if it
+ // // doesn't work, we will prevent the page from unloading.
+ // const route = `/web/dataset/call_kw/${this.resModel}/web_save`;
+ // const params = {
+ // model: this.resModel,
+ // method: "web_save",
+ // args: [this.resId ? [this.resId] : [], changes],
+ // kwargs: { context: this.context, specification: {} },
+ // };
+ // const data = { jsonrpc: "2.0", method: "call", params };
+ // const blob = new Blob([JSON.stringify(data)], { type: "application/json" });
+ // const succeeded = navigator.sendBeacon(route, blob);
+ // if (succeeded) {
+ // this._changes = markRaw({});
+ // this.dirty = false;
+ // } else {
+ // this.model._closeUrgentSaveNotification = this.model.notification.add(
+ // _t(
+ // `Heads up! Your recent changes are too large to save automatically. Please click the %(upload_icon)s button now to ensure your work is saved before you exit this tab.`,
+ // { upload_icon: markup`) => {
+ // should not be necessary
+ // if (this.resId) {
+ // this.model._updateSimilarRecords(this, values);
+ // }
+ this._setData(values);
+ },
+ });
+ }
+
+ // UI state - pager --------------------------------------------------------
+ // form pager, is it really used?
+ get resIds() {
+ return this.config.resIds;
+ }
+ // UI state - data presence ------------------------------------------------
+ // feature: 1) for no-content helper 2) fake data with sample_server.js, 3) maybe more
+ get hasData() {
+ return true;
+ }
+
+ // UI state - editable list ------------------------------------------------
+ get isInEdition() {
+ const { mode } = this.config;
+ if (mode === "readonly") {
+ return false;
+ }
+ return mode === "edit" || !this.resId;
+ }
+ /**
+ * @param {Mode} mode
+ */
+ switchMode(mode: any) {
+ return this.model.mutex.exec(() => this._switchMode(mode));
+ }
+ /**
+ * @param {Mode} mode
+ */
+ _switchMode(mode: any) {
+ // why is it necessary?
+ this.model._updateConfig(this.config, { mode }, { reload: false });
+ if (mode === "readonly") {
+ // this._noUpdateParent = false;
+ // this._invalidFields.clear();
+ }
+ }
+ // list vue editable, can we discard the record (with key nav)
+ get canBeAbandoned() {
+ // return this.isNew && !this.dirty && this._manuallyAdded;
+ return false;
+ }
+ // UI state - dirty --------------------------------------------------------
+ async isDirty() {
+ await this.model._askChanges();
+ return this.dirty;
+ }
+ // UI state - selection ----------------------------------------------------
+ toggleSelection(selected: any) {
+ return this.model.mutex.exec(() => {
+ this._toggleSelection(selected);
+ });
+ }
+ _toggleSelection(selected: any) {
+ if (typeof selected === "boolean") {
+ this.selected = selected;
+ } else {
+ this.selected = !this.selected;
+ }
+ if (!this.selected && this.model.root.isDomainSelected) {
+ this.model.root._selectDomain(false);
+ }
+ }
+ // UI state - multi create (calendar, gantt) -------------------------------
+ async getChanges({ withReadonly }: any = {}) {
+ coucou("getChanges");
+ await this.model._askChanges();
+ return this.model.mutex.exec(() => this._getChanges());
+ }
+
+ // Server / onchange -------------------------------------------------------
+ async _getOnchangeValues(changes: any) {
+ // const win = window as any;
+ // for (const fieldName in changes) {
+ // if (changes[fieldName] instanceof win.Operation) {
+ // changes[fieldName] = changes[fieldName].compute(this.data[fieldName]);
+ // }
+ // }
+ // const onChangeFields = Object.keys(changes).filter(
+ // (fieldName) => this.activeFields[fieldName] && this.activeFields[fieldName].onChange
+ // );
+ // if (!onChangeFields.length) {
+ // return {};
+ // }
+ // const localChanges = this._getChanges({ ...this._changes, ...changes }, { withReadonly: true });
+ // if (this.config.relationField) {
+ // const parentRecord = this._parentRecord;
+ // localChanges[this.config.relationField] = parentRecord._getChanges(parentRecord._changes, {
+ // withReadonly: true,
+ // });
+ // if (!this._parentRecord.isNew) {
+ // localChanges[this.config.relationField].id = this._parentRecord.resId;
+ // }
+ // }
+ // return this.model._onchange(this.config, {
+ // changes: localChanges,
+ // fieldNames: onChangeFields,
+ // evalContext: toRaw(this.evalContext),
+ // onError: (e) => {
+ // // We apply changes and revert them after to force a render of the Field components
+ // const undoChanges = this._applyChanges(changes);
+ // undoChanges();
+ // throw e;
+ // },
+ // });
+ }
+
+ // Server / parsing --------------------------------------------------------
+ /**
+ * @param {RecordType} serverValues
+ * @param {FieldSpecifications} [params]
+ */
+ _parseServerValues(serverValues: any, { currentValues, orderBys }: any = {}) {
+ // const parsedValues = {};
+ // if (!serverValues) {
+ // return parsedValues;
+ // }
+ // for (const fieldName in serverValues) {
+ // const value = serverValues[fieldName];
+ // if (!this.activeFields[fieldName]) {
+ // continue;
+ // }
+ // const field = this.fields[fieldName];
+ // if (field.type === "one2many" || field.type === "many2many") {
+ // let staticList = currentValues?.[fieldName];
+ // let valueIsCommandList = true;
+ // // value can be a list of records or a list of commands (new record)
+ // valueIsCommandList = value.length > 0 && Array.isArray(value[0]);
+ // if (!staticList) {
+ // let data = valueIsCommandList ? [] : value;
+ // if (data.length > 0 && typeof data[0] === "number") {
+ // data = data.map((resId) => ({ id: resId }));
+ // }
+ // staticList = this._createStaticListDatapoint(data, fieldName, { orderBys });
+ // if (valueIsCommandList) {
+ // staticList._applyInitialCommands(value);
+ // }
+ // } else if (valueIsCommandList) {
+ // staticList._applyCommands(value);
+ // }
+ // parsedValues[fieldName] = staticList;
+ // } else {
+ // parsedValues[fieldName] = parseServerValue(field, value);
+ // if (field.type === "properties") {
+ // const parent = serverValues[field.definition_record];
+ // Object.assign(
+ // parsedValues,
+ // this._processProperties(parsedValues[fieldName], fieldName, parent, currentValues)
+ // );
+ // }
+ // }
+ // }
+ // return parsedValues;
+ }
+ // Server / serialization --------------------------------------------------
+ _formatServerValue(fieldType: string, value: any) {
+ // if (fieldType === "date") {
+ // return value ? serializeDate(value) : false;
+ // } else if (fieldType === "datetime") {
+ // return value ? serializeDateTime(value) : false;
+ // } else if (fieldType === "char" || fieldType === "text") {
+ // return value !== "" ? value : false;
+ // } else if (fieldType === "html") {
+ // return value && value.length ? value : false;
+ // } else if (fieldType === "many2one") {
+ // return value ? value.id : false;
+ // } else if (fieldType === "many2one_reference") {
+ // return value ? value.resId : 0;
+ // } else if (fieldType === "reference") {
+ // return value && value.resModel && value.resId ? `${value.resModel},${value.resId}` : false;
+ // } else if (fieldType === "properties") {
+ // return value.map((property) => {
+ // property = { ...property };
+ // for (const key of ["value", "default"]) {
+ // let value;
+ // if (property.type === "many2one") {
+ // value = property[key] && [property[key].id, property[key].display_name];
+ // } else if (
+ // (property.type === "date" || property.type === "datetime") &&
+ // typeof property[key] === "string"
+ // ) {
+ // // TO REMOVE: need refactoring PropertyField to use the same format as the server
+ // value = property[key];
+ // } else if (property[key] !== undefined) {
+ // value = this._formatServerValue(property.type, property[key]);
+ // }
+ // property[key] = value;
+ // }
+ // return property;
+ // });
+ // }
+ // return value;
+ }
+
+ // Server / checks ---------------------------------------------------------
+ async checkValidity({ displayNotification }: any = {}) {
+ coucou("checkValidity");
+ return true;
+ // if (!this._urgentSave) {
+ // await this.model._askChanges();
+ // }
+ // return this._checkValidity({ displayNotification });
+ }
+ _checkValidity({ silent, displayNotification, removeInvalidOnly }: any = {}) {
+ // const unsetRequiredFields = new Set();
+ // for (const fieldName in this.activeFields) {
+ // const fieldType = this.fields[fieldName].type;
+ // if (this._isInvisible(fieldName) || this.fields[fieldName].relatedPropertyField) {
+ // continue;
+ // }
+ // switch (fieldType) {
+ // case "boolean":
+ // case "float":
+ // case "integer":
+ // case "monetary":
+ // continue;
+ // case "html":
+ // if (this._isRequired(fieldName) && this.data[fieldName].length === 0) {
+ // unsetRequiredFields.add(fieldName);
+ // }
+ // break;
+ // case "one2many":
+ // case "many2many": {
+ // const list = this.data[fieldName];
+ // if (
+ // (this._isRequired(fieldName) && !list.count) ||
+ // !list.records.every((r) => !r.dirty || r._checkValidity({ silent, removeInvalidOnly }))
+ // ) {
+ // unsetRequiredFields.add(fieldName);
+ // }
+ // break;
+ // }
+ // case "properties": {
+ // const value = this.data[fieldName];
+ // if (value) {
+ // const ok = value.every(
+ // (propertyDefinition) =>
+ // propertyDefinition.name &&
+ // propertyDefinition.name.length &&
+ // propertyDefinition.string &&
+ // propertyDefinition.string.length
+ // );
+ // if (!ok) {
+ // unsetRequiredFields.add(fieldName);
+ // }
+ // }
+ // break;
+ // }
+ // case "json": {
+ // if (
+ // this._isRequired(fieldName) &&
+ // (!this.data[fieldName] || !Object.keys(this.data[fieldName]).length)
+ // ) {
+ // unsetRequiredFields.add(fieldName);
+ // }
+ // break;
+ // }
+ // default:
+ // if (!this.data[fieldName] && this._isRequired(fieldName)) {
+ // unsetRequiredFields.add(fieldName);
+ // }
+ // }
+ // }
+ // if (silent) {
+ // return !unsetRequiredFields.size;
+ // }
+ // if (removeInvalidOnly) {
+ // for (const fieldName of Array.from(this._unsetRequiredFields)) {
+ // if (!unsetRequiredFields.has(fieldName)) {
+ // this._unsetRequiredFields.delete(fieldName);
+ // this._invalidFields.delete(fieldName);
+ // }
+ // }
+ // } else {
+ // for (const fieldName of Array.from(this._unsetRequiredFields)) {
+ // this._invalidFields.delete(fieldName);
+ // }
+ // this._unsetRequiredFields.clear();
+ // for (const fieldName of unsetRequiredFields) {
+ // this._unsetRequiredFields.add(fieldName);
+ // this._invalidFields.add(fieldName);
+ // }
+ // }
+ // const isValid = !this._invalidFields.size;
+ // if (!isValid && displayNotification) {
+ // this._closeInvalidFieldsNotification = this._displayInvalidFieldNotification();
+ // }
+ // return isValid;
+ }
+ /**
+ * @param {string} fieldName
+ */
+ isFieldInvalid(fieldName: string) {
+ return false;
+ // return this._invalidFields.has(fieldName);
+ }
+ /**
+ * @param {string} fieldName
+ */
+ async setInvalidField(fieldName: string) {
+ // this.dirty = true;
+ // return this._setInvalidField(fieldName);
+ }
+ async _setInvalidField(fieldName: string) {
+ // // what is this ?
+ // const canProceed = this.model.hooks.onWillSetInvalidField(this, fieldName);
+ // if (canProceed === false) {
+ // return;
+ // }
+ // if (toRaw(this._invalidFields).has(fieldName)) {
+ // return;
+ // }
+ // this._invalidFields.add(fieldName);
+ // if (this.selected && this.model.multiEdit && this.model.root._recordToDiscard !== this) {
+ // this._displayInvalidFieldNotification();
+ // await this.discard();
+ // this.switchMode("readonly");
+ // }
+ }
+ /**
+ * @param {string} fieldName
+ */
+ async resetFieldValidity(fieldName: string) {
+ // this.dirty = true;
+ // return this._resetFieldValidity(fieldName);
+ }
+ _resetFieldValidity(fieldName: string) {
+ // this._invalidFields.delete(fieldName);
+ }
+ _removeInvalidFields(...fieldNames: string[]) {
+ // for (const fieldName of fieldNames) {
+ // this._invalidFields.delete(fieldName);
+ // }
+ }
+
+ _displayInvalidFieldNotification() {
+ // return this.model.notification.add(_t("Missing required fields"), { type: "danger" });
+ }
+
+ // Data management / setters -------------------------------------------------
+
+ _setData(data: Record, { orderBys, keepChanges }: any = {}) {
+ // this._isEvalContextReady = false;
+ // if (this.resId) {
+ // this._values = this._parseServerValues(data, { orderBys });
+ // Object.assign(this._textValues, this._getTextValues(data));
+ // } else {
+ // const allVals = { ...this._getDefaultValues(), ...data };
+ // this._values = markRaw(this._parseServerValues(allVals, { orderBys }));
+ // Object.assign(this._textValues, this._getTextValues(allVals));
+ // }
+ // if (!keepChanges) {
+ // this._changes = markRaw({});
+ // }
+ // this.dirty = false;
+ // deleteKeys(this.orecord.reactiveData);
+ // Object.assign(this.orecord.reactiveData, this._values, this._changes);
+ // this.data = {};
+ // makeGetSet(this.data, Object.keys(this.orecord.reactiveData), this.orecord.reactiveData);
+ // this._setEvalContext();
+ // // this._initialTextValues = { ...this._textValues };
+ // // this._invalidFields.clear();
+ // if (!this.isNew && this.isInEdition && !this._parentRecord) {
+ // this._checkValidity();
+ // }
+ // this._savePoint = undefined;
+ // window.d = true;
+ }
+ _applyValues(values: Record) {
+ // const newValues = this._parseServerValues(values);
+ // Object.assign(this._values, newValues);
+ // for (const fieldName in newValues) {
+ // if (fieldName in this._changes) {
+ // if (["one2many", "many2many"].includes(this.fields[fieldName].type)) {
+ // this._changes[fieldName] = newValues[fieldName];
+ // }
+ // }
+ // }
+ // Object.assign(this.data, this._values, this._changes);
+ // const textValues = this._getTextValues(values);
+ // Object.assign(this._initialTextValues, textValues);
+ // Object.assign(this._textValues, textValues, this._getTextValues(this._changes));
+ // this._setEvalContext();
+ }
+ _applyChanges(changes: Record, serverChanges = {}) {
+ // // We need to generate the undo function before applying the changes
+ // const initialTextValues = { ...this._textValues };
+ // const initialChanges = { ...this._changes };
+ // const initialData = { ...toRaw(this.data) };
+ // const invalidFields = [...toRaw(this._invalidFields)];
+ // const undoChanges = () => {
+ // for (const fieldName of invalidFields) {
+ // this.setInvalidField(fieldName);
+ // }
+ // Object.assign(this.data, initialData);
+ // this._changes = markRaw(initialChanges);
+ // Object.assign(this._textValues, initialTextValues);
+ // this._setEvalContext();
+ // };
+ //
+ // // Apply changes
+ // for (const fieldName in changes) {
+ // let change = changes[fieldName];
+ // // todo: what is this?
+ // if (change instanceof Operation) {
+ // change = change.compute(this.data[fieldName]);
+ // }
+ // // this._changes[fieldName] = change;
+ // // this.data[fieldName] = change;
+ // if (this.fields[fieldName].type === "html") {
+ // this._textValues[fieldName] = change === false ? false : change.toString();
+ // } else if (["char", "text"].includes(this.fields[fieldName].type)) {
+ // this._textValues[fieldName] = change;
+ // }
+ // }
+ //
+ // // Apply server changes
+ // const parsedChanges = this._parseServerValues(serverChanges, { currentValues: this.data });
+ // for (const fieldName in parsedChanges) {
+ // this._changes[fieldName] = parsedChanges[fieldName];
+ // this.data[fieldName] = parsedChanges[fieldName];
+ // }
+ // Object.assign(this._textValues, this._getTextValues(serverChanges));
+ // this._setEvalContext();
+ // mark changed fields as valid if they were not, and re-evaluate required attributes
+ // for all fields, as some of them might still be unset but become valid with those changes
+ // this._removeInvalidFields(...Object.keys(changes), ...Object.keys(serverChanges));
+ // this._checkValidity({ removeInvalidOnly: true });
+ // return undoChanges;
+ }
+
+ // Server / default values -------------------------------------------------
+ _applyDefaultValues() {
+ // const fieldNames = this.fieldNames.filter((fieldName) => !(fieldName in this.data));
+ // const defaultValues = this._getDefaultValues(fieldNames);
+ // if (this.isNew) {
+ // this._applyChanges({}, defaultValues);
+ // } else {
+ // this._applyValues(defaultValues);
+ // }
+ }
+ _getDefaultValues(fieldNames = this.fieldNames) {
+ // const defaultValues = {};
+ // for (const fieldName of fieldNames) {
+ // switch (this.fields[fieldName].type) {
+ // case "integer":
+ // case "float":
+ // case "monetary":
+ // defaultValues[fieldName] = fieldName === "id" ? false : 0;
+ // break;
+ // case "one2many":
+ // case "many2many":
+ // defaultValues[fieldName] = [];
+ // break;
+ // default:
+ // defaultValues[fieldName] = false;
+ // }
+ // }
+ // return defaultValues;
+ }
+
+ // Server / properties -----------------------------------------------------
+ /**
+ * This function extracts all properties and adds them to fields and activeFields.
+ *
+ * @param {Object[]} properties the list of properties to be extracted
+ * @param {string} fieldName name of the field containing the properties
+ * @param {Array} parent Array with ['id, 'display_name'], representing the record to which the definition of properties is linked
+ * @param {Object} currentValues current values of the record
+ * @returns An object containing as key `${fieldName}.${property.name}` and as value the value of the property
+ */
+ _processProperties(
+ properties: Array,
+ fieldName: string,
+ parent: Array,
+ currentValues: Object = {}
+ ) {
+ // const data = {};
+ // const hasCurrentValues = Object.keys(currentValues).length > 0;
+ // for (const property of properties) {
+ // const propertyFieldName = `${fieldName}.${property.name}`;
+ // // Add Unknown Property Field and ActiveField
+ // if (hasCurrentValues || !this.fields[propertyFieldName]) {
+ // this.fields[propertyFieldName] = {
+ // ...property,
+ // name: propertyFieldName,
+ // relatedPropertyField: {
+ // name: fieldName,
+ // },
+ // propertyName: property.name,
+ // relation: property.comodel,
+ // sortable: !["many2one", "many2many", "tags"].includes(property.type),
+ // };
+ // }
+ // if (hasCurrentValues || !this.activeFields[propertyFieldName]) {
+ // this.activeFields[propertyFieldName] = createPropertyActiveField(property);
+ // }
+ // if (!this.activeFields[propertyFieldName].relatedPropertyField) {
+ // this.activeFields[propertyFieldName].relatedPropertyField = {
+ // name: fieldName,
+ // id: parent?.id,
+ // displayName: parent?.display_name,
+ // };
+ // }
+ // // Extract property data
+ // if (property.type === "many2many") {
+ // let staticList = currentValues[propertyFieldName];
+ // if (!staticList) {
+ // staticList = this._createStaticListDatapoint(
+ // (property.value || []).map((record) => ({
+ // id: record[0],
+ // display_name: record[1],
+ // })),
+ // propertyFieldName
+ // );
+ // }
+ // data[propertyFieldName] = staticList;
+ // } else if (property.type === "many2one") {
+ // data[propertyFieldName] =
+ // property.value && property.value.display_name === null
+ // ? { id: property.value.id, display_name: _t("No Access") }
+ // : property.value;
+ // } else {
+ // data[propertyFieldName] = property.value ?? false;
+ // }
+ // }
+ // return data;
+ }
+
+ // Server / preprocessing ? what is that -----------------------------------
+ async _preprocessMany2oneChanges(changes: any) {
+ // const proms = Object.entries(changes)
+ // .filter(([fieldName]) => this.fields[fieldName].type === "many2one")
+ // .map(async ([fieldName, value]) => {
+ // if (!value) {
+ // changes[fieldName] = false;
+ // } else if (!this.activeFields[fieldName]) {
+ // changes[fieldName] = value;
+ // } else {
+ // const relation = this.fields[fieldName].relation;
+ // return this._completeMany2OneValue(value, fieldName, relation).then((v) => {
+ // changes[fieldName] = v;
+ // });
+ // }
+ // });
+ // return Promise.all(proms);
+ }
+
+ async _preprocessMany2OneReferenceChanges(changes: any) {
+ // const proms = Object.entries(changes)
+ // .filter(([fieldName]) => this.fields[fieldName].type === "many2one_reference")
+ // .map(async ([fieldName, value]) => {
+ // if (!value) {
+ // changes[fieldName] = false;
+ // } else if (typeof value === "number") {
+ // // Many2OneReferenceInteger field only manipulates the id
+ // changes[fieldName] = { resId: value };
+ // } else {
+ // const relation = this.data[this.fields[fieldName].model_field];
+ // return this._completeMany2OneValue(
+ // { id: value.resId, display_name: value.displayName },
+ // fieldName,
+ // relation
+ // ).then((v) => {
+ // changes[fieldName] = { resId: v.id, displayName: v.display_name };
+ // });
+ // }
+ // });
+ // return Promise.all(proms);
+ }
+
+ async _preprocessReferenceChanges(changes: any) {
+ // const proms = Object.entries(changes)
+ // .filter(([fieldName]) => this.fields[fieldName].type === "reference")
+ // .map(async ([fieldName, value]) => {
+ // if (!value) {
+ // changes[fieldName] = false;
+ // } else {
+ // return this._completeMany2OneValue(
+ // { id: value.resId, display_name: value.displayName },
+ // fieldName,
+ // value.resModel
+ // ).then((v) => {
+ // changes[fieldName] = {
+ // resId: v.id,
+ // resModel: value.resModel,
+ // displayName: v.display_name,
+ // };
+ // });
+ // }
+ // });
+ // return Promise.all(proms);
+ }
+
+ async _preprocessX2manyChanges(changes: any) {
+ // for (const [fieldName, value] of Object.entries(changes)) {
+ // if (
+ // this.fields[fieldName].type !== "one2many" &&
+ // this.fields[fieldName].type !== "many2many"
+ // ) {
+ // continue;
+ // }
+ // const list = this.data[fieldName];
+ // for (const command of value) {
+ // switch (command[0]) {
+ // case x2ManyCommands.SET:
+ // await list._replaceWith(command[2]);
+ // break;
+ // default:
+ // await list._applyCommands([command]);
+ // }
+ // }
+ // changes[fieldName] = list;
+ // }
+ }
+
+ _preprocessPropertiesChanges(changes: any) {
+ // for (const [fieldName, value] of Object.entries(changes)) {
+ // const field = this.fields[fieldName];
+ // if (field.type === "properties") {
+ // const parent = changes[field.definition_record] || this.data[field.definition_record];
+ // Object.assign(changes, this._processProperties(value, fieldName, parent, this.data));
+ // } else if (field && field.relatedPropertyField) {
+ // const [propertyFieldName, propertyName] = field.name.split(".");
+ // const propertiesData = this.data[propertyFieldName] || [];
+ // if (!propertiesData.find((property) => property.name === propertyName)) {
+ // // try to change the value of a properties that has a different parent
+ // this.model.notification.add(
+ // _t("This record belongs to a different parent so you can not change this property."),
+ // { type: "warning" }
+ // );
+ // return;
+ // }
+ // changes[propertyFieldName] = propertiesData.map((property) =>
+ // property.name === propertyName ? { ...property, value } : property
+ // );
+ // }
+ // }
+ }
+
+ _preprocessHtmlChanges(changes: any) {
+ // for (const [fieldName, value] of Object.entries(changes)) {
+ // if (this.fields[fieldName].type === "html") {
+ // changes[fieldName] = value === false ? false : markup(value);
+ // }
+ // }
+ }
+ /**
+ * Given a possibily incomplete value for a many2one field (i.e. a object { id, display_name } but
+ * with id and/or display_name being undefined), return the complete value as follows:
+ * - if a display_name is given but no id, perform a name_create to get an id
+ * - if an id is given but display_name is undefined, call web_read to get the display_name
+ * - if both id and display_name are given, return the value as is
+ * - in any other cases, return false
+ *
+ * @param {{ id?: number; display_name?: string }} value
+ * @param {string} fieldName
+ * @param {string} resModel
+ * @returns {Promise} the completed record { id, display_name } or false
+ */
+ async _completeMany2OneValue(
+ value: { id?: number; display_name?: string },
+ fieldName: string,
+ resModel: string
+ ) {
+ // const resId = value.id;
+ // const displayName = value.display_name;
+ // // why check for displayName?
+ // if (!resId && !displayName) {
+ // return false;
+ // }
+ // const context = getFieldContext(this, fieldName);
+ // if (!resId && displayName !== undefined) {
+ // const pair = await this.model.orm.call(resModel, "name_create", [displayName], {
+ // context,
+ // });
+ // return pair && { id: pair[0], display_name: pair[1] };
+ // }
+ // if (resId && displayName === undefined) {
+ // const fieldSpec = { display_name: {} };
+ // if (this.activeFields[fieldName].related) {
+ // Object.assign(
+ // fieldSpec,
+ // getFieldsSpec(
+ // this.activeFields[fieldName].related.activeFields,
+ // this.activeFields[fieldName].related.fields,
+ // getBasicEvalContext(this.config)
+ // )
+ // );
+ // }
+ // const kwargs = {
+ // context,
+ // specification: fieldSpec,
+ // };
+ // const records = await this.model.orm.webRead(resModel, [resId], kwargs);
+ // return records[0];
+ // }
+ // return value;
+ }
+
+ // Actions -----------------------------------------------------------------
+ async discard() {
+ coucou("discard");
+ // if (this.model._closeUrgentSaveNotification) {
+ // this.model._closeUrgentSaveNotification();
+ // }
+ // await this.model._askChanges();
+ // return this.model.mutex.exec(() => this._discard());
+ }
+ _discard() {
+ // todo: discard
+ // for (const fieldName in this._changes) {
+ // if (["one2many", "many2many"].includes(this.fields[fieldName].type)) {
+ // this._changes[fieldName]._discard();
+ // }
+ // }
+ // if (this._savePoint) {
+ // this.dirty = this._savePoint.dirty;
+ // this._changes = markRaw({ ...this._savePoint.changes });
+ // this._textValues = markRaw({ ...this._savePoint.textValues });
+ // } else {
+ // this.dirty = false;
+ // this._changes = markRaw({});
+ // this._textValues = markRaw({ ...this._initialTextValues });
+ // }
+ // this.data = { ...this._values, ...this._changes };
+ // this._savePoint = undefined;
+ // this._setEvalContext();
+ // this._invalidFields.clear();
+ // if (!this.isNew) {
+ // this._checkValidity();
+ // }
+ // this._closeInvalidFieldsNotification();
+ // this._closeInvalidFieldsNotification = () => {};
+ // this._restoreActiveFields();
+ }
+
+ duplicate() {
+ coucou("duplicate");
+ // return this.model.mutex.exec(async () => {
+ // const kwargs = { context: this.context };
+ // const index = this.resIds.indexOf(this.resId);
+ // const [resId] = await this.model.orm.call(this.resModel, "copy", [[this.resId]], kwargs);
+ // const resIds = this.resIds.slice();
+ // resIds.splice(index + 1, 0, resId);
+ // await this.model.load({ resId, resIds, mode: "edit" });
+ // });
+ }
+ delete() {
+ coucou("delete");
+ // return this.model.mutex.exec(async () => {
+ // const unlinked = await this.model.orm.unlink(this.resModel, [this.resId], {
+ // context: this.context,
+ // });
+ // if (!unlinked) {
+ // return false;
+ // }
+ // const resIds = this.resIds.slice();
+ // const index = resIds.indexOf(this.resId);
+ // resIds.splice(index, 1);
+ // const resId = resIds[Math.min(index, resIds.length - 1)] || false;
+ // if (resId) {
+ // await this.model.load({ resId, resIds });
+ // } else {
+ // this.model._updateConfig(this.config, { resId: false }, { reload: false });
+ // this.dirty = false;
+ // this._changes = markRaw({});
+ // this._values = markRaw(this._parseServerValues(this._getDefaultValues()));
+ // this._textValues = markRaw({});
+ // this.data2 = { ...this._values };
+ // this._setEvalContext();
+ // }
+ // });
+ }
+
+ // Actions - archive/unarchive ---------------------------------------------
+ archive() {
+ coucou("archive");
+ // return this.model.mutex.exec(() => this._toggleArchive(true));
+ }
+ unarchive() {
+ coucou("unarchive");
+ // return this.model.mutex.exec(() => this._toggleArchive(false));
+ }
+ async _toggleArchive(state: boolean) {
+ // const method = state ? "action_archive" : "action_unarchive";
+ // const action = await this.model.orm.call(this.resModel, method, [[this.resId]], {
+ // context: this.context,
+ // });
+ // if (action && Object.keys(action).length) {
+ // this.model.action.doAction(action, { onClose: () => this._load() });
+ // } else {
+ // return this._load();
+ // }
+ }
+
+ // Should not be necessary -------------------------------------------------
+
+ _getTextValues(values: any) {
+ // const textValues = {};
+ // for (const fieldName in values) {
+ // if (!this.activeFields[fieldName]) {
+ // continue;
+ // }
+ // if (["char", "text", "html"].includes(this.fields[fieldName].type)) {
+ // textValues[fieldName] = values[fieldName];
+ // }
+ // }
+ // return textValues;
+ }
+
+ _addSavePoint() {
+ // this._savePoint = markRaw({
+ // dirty: this.dirty,
+ // textValues: { ...this._textValues },
+ // changes: { ...this._changes },
+ // });
+ // for (const fieldName in this._changes) {
+ // if (["one2many", "many2many"].includes(this.fields[fieldName].type)) {
+ // this._changes[fieldName]._addSavePoint();
+ // }
+ // }
+ }
+
+ _createStaticListDatapoint(data: any, fieldName: string, { orderBys }: any = {}) {
+ // const { related, limit, defaultOrderBy } = this.activeFields[fieldName];
+ // const relatedActiveFields = (related && related.activeFields) || {};
+ // const config = {
+ // resModel: this.fields[fieldName].relation,
+ // activeFields: relatedActiveFields,
+ // fields: (related && related.fields) || {},
+ // relationField: this.fields[fieldName].relation_field || false,
+ // offset: 0,
+ // resIds: data.map((r) => r.id),
+ // orderBy: orderBys?.[fieldName] || defaultOrderBy || [],
+ // limit: limit || (Object.keys(relatedActiveFields).length ? Number.MAX_SAFE_INTEGER : 1),
+ // context: {}, // will be set afterwards, see "_updateContext" in "_setEvalContext"
+ // };
+ // const options = {
+ // onUpdate: ({ withoutOnchange } = {}) =>
+ // this._update({ [fieldName]: [] }, { withoutOnchange }),
+ // parent: this,
+ // };
+ // return new this.model.constructor.StaticList(this.model, config, data, options);
+ }
+}
+
+export function makeFieldObject(record: any, orecord: Model) {
+ const Mod = orecord.constructor as typeof Model;
+ const fields = Mod.fields;
+ const prototype = Object.create(null);
+ const fieldObject = Object.create(prototype);
+ for (const field of Object.values(fields)) {
+ const { fieldName, type } = field;
+ switch (type) {
+ case "one2many":
+ defineLazyProperty(prototype, fieldName, (obj: any) => {
+ const staticConfig: StaticListConfig = {
+ parentRecord: record,
+ orecord,
+ fieldName,
+ makeWebRecord,
+ // resModel: ,
+ // activeFields: ,
+ // fields: ,
+
+ // relationField: ,
+ // resIds: ,
+ //
+ // offset: 0,
+ // orderBy: [],
+ // limit: 100,
+ //
+ // context: {},
+ };
+ const staticList = new StaticList(staticConfig);
+ return [() => staticList] as const;
+ });
+ break;
+ case "many2one":
+ Object.defineProperty(fieldObject, fieldName, {
+ get() {
+ return (orecord as any)[fieldName];
+ },
+ set(value: any) {
+ (orecord as any)[fieldName] = value;
+ },
+ enumerable: true,
+ });
+ break;
+ case "many2many":
+ break;
+ default:
+ Object.defineProperty(fieldObject, fieldName, {
+ get() {
+ return (orecord as any)[fieldName];
+ },
+ set(value: any) {
+ (orecord as any)[fieldName] = value;
+ },
+ enumerable: true,
+ });
+ break;
+ }
+ }
+ return fieldObject;
+}
+
+function coucou(s: string) {
+ console.warn(s);
+ return s;
+}
diff --git a/src/runtime/relationalModel/web/WebStaticList.ts b/src/runtime/relationalModel/web/WebStaticList.ts
new file mode 100644
index 000000000..872751bfb
--- /dev/null
+++ b/src/runtime/relationalModel/web/WebStaticList.ts
@@ -0,0 +1,490 @@
+import { derived } from "../../signals";
+import { Model } from "../model";
+import { loadRecordWithRelated } from "../store";
+import { DraftContext, InstanceId, ManyFn } from "../types";
+import { DataPoint } from "./WebDataPoint";
+import { MakeWebRecord, WebRecord } from "./WebRecord";
+
+export type StaticListConfig = {
+ parentRecord: any;
+ orecord: Model;
+ fieldName: string;
+ makeWebRecord: MakeWebRecord;
+};
+export type MakeNewRecordParams = {
+ activeFields: Object;
+ fields: Object;
+ context?: Object;
+ withoutParent?: boolean;
+ mode?: string;
+};
+
+export class StaticList extends DataPoint {
+ _records!: () => WebRecord[];
+ orecordList!: ManyFn;
+ _webRecords: Record = {};
+ _draftRecord: Map = new Map();
+ draftContext: DraftContext = {
+ store: {},
+ };
+ draftORecord!: Model;
+
+ constructor(public sconfig: StaticListConfig) {
+ super();
+ this._constructor(sconfig);
+ }
+
+ _constructor(sconfig: StaticListConfig): void {
+ const parent = sconfig.parentRecord;
+ const fieldName = sconfig.fieldName;
+ const { related, limit, defaultOrderBy } = parent.activeFields[fieldName];
+ const relatedActiveFields = (related && related.activeFields) || {};
+ const config = {
+ resModel: parent.fields[fieldName].relation,
+ activeFields: relatedActiveFields,
+ fields: (related && related.fields) || {},
+ relationField: parent.fields[fieldName].relation_field || false,
+ offset: 0,
+ // resIds: data.map((r) => r.id),
+ // orderBy: orderBys?.[fieldName] || defaultOrderBy || [],
+ orderBy: defaultOrderBy || [],
+ limit: limit || (Object.keys(relatedActiveFields).length ? Number.MAX_SAFE_INTEGER : 1),
+ context: {}, // will be set afterwards, see "_updateContext" in "_setEvalContext"
+ };
+ this.model = parent.model;
+ this._config = config;
+
+ this.draftORecord = sconfig.orecord.makeDraft();
+ (this.draftORecord.draftContext as any).name = "staticlist";
+ this.orecordList = (sconfig.orecord as any)[sconfig.fieldName] as ManyFn;
+ this._defineRecords();
+ }
+ _defineRecords() {
+ // const Mod = this.sconfig.orecord.constructor as typeof Model;
+ // const modelId = Mod.id;
+
+ // return { config } as any;
+ this._records = derived(() => this.orecordList().map(this._getRecord.bind(this)));
+ }
+ _getRecord(record: Model) {
+ const id = record.id!;
+ if (this._webRecords[id]) return this._webRecords[id];
+
+ const config = {
+ context: this.sconfig.parentRecord.context,
+ // activeFields: Object.assign({}, params.activeFields || this.activeFields),
+ activeFields: Object.assign({}, this.activeFields),
+ resModel: this.resModel,
+ // fields: params.fields || this.fields,
+ fields: this.fields,
+ relationField: this.config.relationField,
+ resId: id,
+ resIds: id ? [id] : [],
+ // mode: params.mode || "readonly",
+ mode: "readonly",
+ isMonoRecord: true,
+ };
+
+ const wrecord = this.sconfig.makeWebRecord(this.model, config, undefined, {
+ orecord: record,
+ });
+ this._webRecords[id] = wrecord;
+ return wrecord;
+ }
+
+ get count() {
+ return this._records().length;
+ }
+ get records() {
+ return this._records();
+ }
+
+ // List infos - basic --------------------------------------------------------
+ get resIds() {
+ coucou("resIds");
+ return this.orecordList.ids();
+ }
+ get currentIds() {
+ return coucou("currentIds");
+ }
+
+ // List infos - config -------------------------------------------------------
+ get limit() {
+ coucou("limit");
+ return 100;
+ }
+ get offset() {
+ coucou("offset");
+ return 0;
+ }
+ get orderBy() {
+ coucou("orderBy");
+ return [];
+ }
+
+ // Context -------------------------------------------------------------------
+ get evalContext() {
+ coucou("evalContext");
+ const win = window as any;
+ const evalContext = win.getBasicEvalContext(this.config);
+ evalContext.parent = this.sconfig.parentRecord.evalContext;
+ return evalContext;
+ }
+
+ // Draft ---------------------------------------------------------------------
+ async extendRecord(params: MakeNewRecordParams, record: WebRecord) {
+ coucou("extendRecord");
+ return this.model.mutex.exec(async () => {
+ // extend fields and activeFields of the list with those given in params
+ completeActiveFields(this.config.activeFields, params.activeFields);
+ Object.assign(this.fields, params.fields);
+ const activeFields = this._getActiveFields(params);
+
+ if (record) {
+ return await this._getDraftRecord(params, record, activeFields);
+ } else if (!record) {
+ record = await this._makeNewRecord({
+ activeFields,
+ context: params.context,
+ withoutParent: params.withoutParent,
+ // manuallyAdded: true,
+ });
+ }
+ return record;
+ });
+ }
+ async _getDraftRecord(
+ params: MakeNewRecordParams,
+ webrecord: WebRecord,
+ activeFields: Record
+ ) {
+ const orecord = webrecord.orecord;
+ const config = {
+ ...webrecord.config,
+ ...params,
+ activeFields,
+ };
+
+ let draftWebRecord = this._draftRecord.get(orecord.id!);
+ if (draftWebRecord) {
+ this.model._updateConfig(webrecord.config, config, { reload: false });
+ return draftWebRecord;
+ }
+
+ let data = {};
+ if (!orecord.isNew()) {
+ const evalContext = Object.assign({}, webrecord.evalContext, config.context);
+ const resIds = [webrecord.resId];
+ [data] = await this.model._loadRecords({ ...config, resIds }, evalContext);
+ loadRecordWithRelated(orecord.constructor as typeof Model, { id: orecord.id, ...data });
+ }
+ this.model._updateConfig(webrecord.config, config, { reload: false });
+ // webrecord._applyDefaultValues();
+ // for (const fieldName in webrecord.activeFields) {
+ // if (["one2many", "many2many"].includes(webrecord.fields[fieldName].type)) {
+ // const list = webrecord.data[fieldName];
+ // const patch = {
+ // activeFields: activeFields[fieldName].related.activeFields,
+ // fields: activeFields[fieldName].related.fields,
+ // };
+ // // todo: what is this?
+ // // for (const subRecord of Object.values(list._cache)) {
+ // // this.model._updateConfig(subRecord.config, patch, {
+ // // reload: false,
+ // // });
+ // // }
+ // this.model._updateConfig(list.config, patch, { reload: false });
+ // }
+ // }
+
+ const Mod = orecord.constructor as typeof Model;
+ const parentDraftContext = this.sconfig.parentRecord.orecord.draftContext;
+ console.warn(`parentDraftContext:`, parentDraftContext);
+ const orecordDraft = Mod.get(orecord.id!, this.draftORecord.draftContext);
+ console.warn(`orecordDraft.draftContext:`, orecordDraft.draftContext);
+
+ const wrecord = this.sconfig.makeWebRecord(this.model, config, undefined, {
+ orecord: orecordDraft,
+ mode: "edit",
+ });
+ console.warn(`wrecord:`, wrecord);
+ this._draftRecord.set(orecord.id!, wrecord);
+ return wrecord;
+ }
+ validateExtendedRecord(record: WebRecord) {
+ coucou("validateExtendedRecord");
+ // let draftWebRecord = this._draftRecord.get(record.orecord.id!)!;
+ // draftWebRecord.orecord.saveDraft();
+ this.orecordList.add(record.orecord);
+ this.draftORecord.saveDraft();
+ }
+ _getActiveFields(params: MakeNewRecordParams) {
+ const activeFields: Record = { ...params.activeFields };
+ for (const fieldName in this.activeFields) {
+ if (fieldName in activeFields) {
+ patchActiveFields(activeFields[fieldName], this.activeFields[fieldName]);
+ } else {
+ activeFields[fieldName] = this.activeFields[fieldName];
+ }
+ }
+ return activeFields;
+ }
+ async _makeNewRecord(params: any) {
+ const changes = {};
+ // if (!params.withoutParent && this.config.relationField) {
+ // changes[this.config.relationField] = this._parent._getChanges();
+ // if (!this._parent.isNew) {
+ // changes[this.config.relationField].id = this._parent.resId;
+ // }
+ // }
+ const values = await this.model._loadNewRecord(
+ {
+ resModel: this.resModel,
+ activeFields: params.activeFields || this.activeFields,
+ fields: this.fields,
+ context: Object.assign({}, this.context, params.context),
+ },
+ { changes, evalContext: this.evalContext }
+ );
+
+ return this._createRecordDatapoint(values, {
+ mode: params.mode || "edit",
+ // virtualId: getId("virtual"),
+ activeFields: params.activeFields,
+ manuallyAdded: params.manuallyAdded,
+ });
+ }
+ _createRecordDatapoint(data: any, params: any = {}) {
+ // const resId = data.id || false;
+ // if (!resId && !params.virtualId) {
+ // throw new Error("You must provide a virtualId if the record has no id");
+ // }
+ // const id = resId || params.virtualId;
+ const config = {
+ context: this.context,
+ activeFields: Object.assign({}, params.activeFields || this.activeFields),
+ resModel: this.resModel,
+ fields: params.fields || this.fields,
+ relationField: this.config.relationField,
+ // resId,
+ // resIds: resId ? [resId] : [],
+ mode: params.mode || "readonly",
+ isMonoRecord: true,
+ };
+ // const { CREATE, UPDATE } = x2ManyCommands;
+ // const options = {
+ // parentRecord: this._parent,
+ // onUpdate: async ({ withoutParentUpdate }) => {
+ // const id = record.isNew ? record._virtualId : record.resId;
+ // if (!this.currentIds.includes(id)) {
+ // // the record hasn't been added to the list yet (we're currently creating it
+ // // from a dialog)
+ // return;
+ // }
+ // const hasCommand = this._commands.some(
+ // (c) => (c[0] === CREATE || c[0] === UPDATE) && c[1] === id
+ // );
+ // if (!hasCommand) {
+ // this._commands.push([UPDATE, id]);
+ // }
+ // if (record._noUpdateParent) {
+ // // the record is edited from a dialog, so we don't want to notify the parent
+ // // record to be notified at each change inside the dialog (it will be notified
+ // // at the end when the dialog is saved)
+ // return;
+ // }
+ // if (!withoutParentUpdate) {
+ // await this._onUpdate({
+ // withoutOnchange: !record._checkValidity({ silent: true }),
+ // });
+ // }
+ // },
+ // virtualId: params.virtualId,
+ // manuallyAdded: params.manuallyAdded,
+ // };
+ const webRecord = this.sconfig.makeWebRecord(this.model, config, data, {
+ parentRecord: this.sconfig.parentRecord,
+ draftContext: this.draftORecord.draftContext,
+ });
+ this._webRecords[webRecord.orecord.id!] = webRecord;
+
+ return webRecord;
+ // this._cache[id] = record;
+ // if (!params.dontApplyCommands) {
+ // const commands = this._unknownRecordCommands[id];
+ // if (commands) {
+ // delete this._unknownRecordCommands[id];
+ // this._applyCommands(commands);
+ // }
+ // }
+ }
+
+ // UI state - editable list --------------------------------------------------
+ get editedRecord() {
+ coucou("editedRecord");
+ return null;
+ }
+ enterEditMode() {
+ coucou("enterEditMode");
+ }
+ leaveEditMode() {
+ coucou("leaveEditMode");
+ }
+
+ // UI state - selection ------------------------------------------------------
+ get selection() {
+ return [];
+ }
+
+ // resequencing --------------------------------------------------------------
+ canResequence() {
+ coucou("canResequence");
+ }
+ resequence() {
+ coucou("resequence");
+ }
+
+ // Server / load -------------------------------------------------------------
+ load() {
+ coucou("load");
+ }
+
+ // Re-sort -------------------------------------------------------------------
+ sortBy() {
+ coucou("sortBy");
+ }
+
+ // Mutations -----------------------------------------------------------------
+ addNewRecord() {
+ coucou("addNewRecord");
+ }
+ addNewRecordAtIndex() {
+ coucou("addNewRecordAtIndex");
+ }
+ applyCommands() {
+ coucou("applyCommands");
+ }
+ linkTo() {
+ coucou("linkTo");
+ }
+ unlinkFrom() {
+ coucou("unlinkFrom");
+ }
+ forget() {
+ coucou("forget");
+ }
+ moveRecord() {
+ coucou("moveRecord");
+ }
+
+ addAndRemove() {
+ coucou("addAndRemove");
+ }
+
+ // Actions -------------------------------------------------------------------
+ duplicateRecords() {
+ coucou("duplicateRecords");
+ }
+ delete() {
+ coucou("delete");
+ }
+}
+
+function coucou(s: string) {
+ // console.warn(s);
+ return s;
+}
+
+export function completeActiveFields(
+ activeFields: Record,
+ extraActiveFields: Record
+) {
+ for (const fieldName in extraActiveFields) {
+ const extraActiveField = {
+ ...extraActiveFields[fieldName],
+ invisible: "True",
+ };
+ if (fieldName in activeFields) {
+ completeActiveField(activeFields[fieldName], extraActiveField);
+ } else {
+ activeFields[fieldName] = extraActiveField;
+ }
+ }
+}
+function completeActiveField(activeField: any, extra: any) {
+ if (extra.related) {
+ for (const fieldName in extra.related.activeFields) {
+ if (fieldName in activeField.related.activeFields) {
+ completeActiveField(
+ activeField.related.activeFields[fieldName],
+ extra.related.activeFields[fieldName]
+ );
+ } else {
+ activeField.related.activeFields[fieldName] = {
+ ...extra.related.activeFields[fieldName],
+ };
+ }
+ }
+ Object.assign(activeField.related.fields, extra.related.fields);
+ }
+}
+
+function combineModifiers(
+ mod1: string | undefined,
+ mod2: string | undefined,
+ operator: "AND" | "OR"
+): string | undefined {
+ if (operator === "AND") {
+ if (!mod1 || mod1 === "False" || !mod2 || mod2 === "False") {
+ return "False";
+ }
+ if (mod1 === "True") {
+ return mod2;
+ }
+ if (mod2 === "True") {
+ return mod1;
+ }
+ return "(" + mod1 + ") and (" + mod2 + ")";
+ } else if (operator === "OR") {
+ if (mod1 === "True" || mod2 === "True") {
+ return "True";
+ }
+ if (!mod1 || mod1 === "False") {
+ return mod2;
+ }
+ if (!mod2 || mod2 === "False") {
+ return mod1;
+ }
+ return "(" + mod1 + ") or (" + mod2 + ")";
+ }
+ throw new Error(
+ `Operator provided to "combineModifiers" must be "AND" or "OR", received ${operator}`
+ );
+}
+
+function patchActiveFields(activeField: any, patch: any) {
+ activeField.invisible = combineModifiers(activeField.invisible, patch.invisible, "AND");
+ activeField.readonly = combineModifiers(activeField.readonly, patch.readonly, "AND");
+ activeField.required = combineModifiers(activeField.required, patch.required, "OR");
+ activeField.onChange = activeField.onChange || patch.onChange;
+ activeField.forceSave = activeField.forceSave || patch.forceSave;
+ activeField.isHandle = activeField.isHandle || patch.isHandle;
+ // x2manys
+ if (patch.related) {
+ const related = activeField.related;
+ for (const fieldName in patch.related.activeFields) {
+ if (fieldName in related.activeFields) {
+ patchActiveFields(related.activeFields[fieldName], patch.related.activeFields[fieldName]);
+ } else {
+ related.activeFields[fieldName] = { ...patch.related.activeFields[fieldName] };
+ }
+ }
+ Object.assign(related.fields, patch.related.fields);
+ }
+ if ("limit" in patch) {
+ activeField.limit = patch.limit;
+ }
+ if (patch.defaultOrderBy) {
+ activeField.defaultOrderBy = patch.defaultOrderBy;
+ }
+}
diff --git a/src/runtime/relationalModel/web/webModel.ts b/src/runtime/relationalModel/web/webModel.ts
new file mode 100644
index 000000000..9ecda3baf
--- /dev/null
+++ b/src/runtime/relationalModel/web/webModel.ts
@@ -0,0 +1,134 @@
+import {
+ fieldAny,
+ fieldChar,
+ fieldDate,
+ fieldDatetime,
+ fieldMany2Many,
+ fieldMany2One,
+ fieldNumber,
+ fieldOne2Many,
+ fieldProperties,
+ fieldSelection,
+} from "../field";
+import { Model } from "../model";
+import { Models } from "../modelRegistry";
+import { ModelId } from "../types";
+import { WebModelConfig } from "./webModelTypes";
+
+// function foo(test) {}
+
+export function getOrMakeModel(modelId: ModelId): typeof Model {
+ let Mod = Models[modelId];
+ if (Mod) return Mod;
+ Mod = makeNewModel(modelId);
+ Mod.register();
+ return Mod;
+}
+
+function makeNewModel(modelId: ModelId): typeof Model {
+ const Mod = {
+ [modelId]: class extends Model {
+ static id = modelId;
+ },
+ }[modelId];
+ return Mod;
+}
+
+export function makeModelFromWeb(
+ config: WebModelConfig,
+ processedModel = new Set()
+): typeof Model {
+ if (processedModel.has(config.resModel!)) {
+ return Models[config.resModel!];
+ }
+ const modelId = config.resModel!;
+ processedModel.add(modelId);
+ const Mod = Models[modelId] || makeNewModel(modelId);
+
+ const fields = mapObject(config.fields, (fieldInfo) => {
+ switch (fieldInfo.type) {
+ case "many2one":
+ return fieldMany2One(fieldInfo.relation!);
+ case "one2many":
+ return fieldOne2Many(fieldInfo.relation!, {
+ relatedField: fieldInfo.relation_field,
+ });
+ case "many2many":
+ return fieldMany2Many(fieldInfo.relation!);
+ case "integer":
+ return fieldNumber();
+ case "char":
+ return fieldChar();
+ // case "boolean":
+ // return fieldBoolean();
+ case "selection":
+ return fieldSelection(fieldInfo.selection || []);
+ case "date":
+ return fieldDate();
+ case "datetime":
+ return fieldDatetime();
+ case "properties":
+ return fieldProperties();
+ case "binary":
+ case "html":
+ case "json":
+ case "datetime":
+ case "float":
+ case "monetary":
+ case "text":
+ default:
+ return fieldAny();
+ }
+ });
+
+ Mod.fields = { ...Mod.fields, ...fields };
+ Mod.register();
+ createRelatedModelsFromWeb(config, processedModel);
+ return Mod;
+}
+// make related models
+function createRelatedModelsFromWeb(config: WebModelConfig, processedModel: Set) {
+ const fields = config.fields;
+
+ const relatedConfigs: Record = {};
+ for (const fieldName in fields) {
+ const fieldInfo = fields[fieldName];
+ if (!["many2one", "one2many", "many2many"].includes(fieldInfo.type!)) {
+ continue;
+ }
+ const relatedModelName = fieldInfo.relation!;
+ // produce a fieldInfo for the related model
+ relatedConfigs[relatedModelName] ||= {
+ resModel: relatedModelName,
+ fields: {},
+ } as any;
+ const config = relatedConfigs[relatedModelName];
+ if (fieldInfo.type === "one2many") {
+ // add the inverse many2one field
+ config.fields[fieldInfo.relation_field!] = {
+ type: "many2one",
+ relation: config.resModel,
+ };
+ } else if (fieldInfo.type === "many2many") {
+ // add a many2many field back to this model
+ // config.fields[`${config.resModel.toLowerCase()}_ids`] = {
+ // type: "many2many",
+ // relation: config.resModel,
+ // };
+ } else if (fieldInfo.type === "many2one") {
+ // add a one2many field back to this model
+ // config.fields[`${config.resModel.toLowerCase()}_ids`] = {
+ // type: "one2many",
+ // relation: config.resModel,
+ // relation_field: fieldName,
+ // };
+ }
+ }
+ for (const relatedModelName in relatedConfigs) {
+ makeModelFromWeb(relatedConfigs[relatedModelName], processedModel);
+ }
+}
+
+function mapObject(object: Record, fn: (value: T) => U): Record {
+ return Object.fromEntries(Object.entries(object).map(([k, v]) => [k, fn(v)]));
+}
diff --git a/src/runtime/relationalModel/web/webModelTypes.ts b/src/runtime/relationalModel/web/webModelTypes.ts
new file mode 100644
index 000000000..b3d203d56
--- /dev/null
+++ b/src/runtime/relationalModel/web/webModelTypes.ts
@@ -0,0 +1,149 @@
+export interface WebModelConfig {
+ isMonoRecord: boolean;
+ context: Record;
+ 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[]; // Domain type might need more specific definition
+ orderBy: OrderBy[];
+ groups?: Record;
+ offset: number;
+ limit: number;
+ countLimit: number;
+ currentGroups?: {
+ params: string;
+ groups: any[]; // More specific type if possible
+ };
+ loadId?: string;
+ openGroupsByDefault?: boolean;
+ [key: string]: any; // Allow other properties
+}
+
+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[];
+}
+
+// Define types for parameters and configurations based on usage
+export interface RelationalModelParams {
+ config: {
+ activeFields: {
+ [key: string]: ActiveFieldInfo;
+ };
+ [key: string]: any;
+ };
+ limit?: number;
+ groupsLimit?: number;
+ countLimit?: number;
+ defaultOrderBy?: OrderBy[];
+ maxGroupByDepth?: number;
+ groupByInfo?: Record;
+ multiEdit?: boolean;
+ activeIdsLimit?: number;
+ state?: {
+ specialDataCaches?: Record;
+ };
+ useSendBeaconToSaveUrgently?: boolean;
+ hooks?: Partial;
+ [key: string]: any; // Allow other properties
+}
+
+export interface OrderBy {
+ name: string;
+ asc?: boolean;
+}
+
+export interface SearchParams {
+ context?: Record;
+ resId?: number | false;
+ resIds?: number[];
+ domain?: any[];
+ groupBy?: string[];
+ orderBy?: OrderBy[];
+ limit?: number;
+ offset?: number;
+ countLimit?: number;
+}
+
+export interface Services {
+ action: any; // Define ActionService type
+ dialog: any; // Define DialogService type
+ notification: any; // Define NotificationService type
+ orm: any; // Define ORMService type
+}
+
+export interface OnChangeParams {
+ changes?: Record;
+ fieldNames?: string[];
+ evalContext?: Record;
+ onError?: (error: any) => void;
+ cache?: any;
+}
+
+export interface RelationalModelHooks {
+ onWillLoadRoot: (config: WebModelConfig) => Promise;
+ onRootLoaded: (root: any) => Promise; // DataPoint type
+ onWillDisplayOnchangeWarning: (warning: any) => Promise;
+}
diff --git a/src/runtime/signals.ts b/src/runtime/signals.ts
new file mode 100644
index 000000000..9ce151b05
--- /dev/null
+++ b/src/runtime/signals.ts
@@ -0,0 +1,449 @@
+import {
+ Atom,
+ Computation,
+ ComputationAsync,
+ ComputationState,
+ Derived,
+ DerivedAsyncRead,
+ DerivedAsyncReturn,
+ DerivedAsyncStates,
+ Opts,
+ Transaction,
+} from "../common/types";
+import { makeTask } from "./contextualPromise";
+import { getCurrentTransaction, setCurrentTransaction } from "./suspense";
+import { batched } from "./utils";
+
+let Effects: Computation[];
+let CurrentComputation: Computation;
+
+export function signal(value: T, opts?: Opts) {
+ const atom: Atom = {
+ value,
+ observers: new Set(),
+ };
+ const read = () => {
+ onReadAtom(atom);
+ return atom.value;
+ };
+ const write = (newValue: T | ((prevValue: T) => T)) => {
+ if (typeof newValue === "function") {
+ newValue = (newValue as (prevValue: T) => T)(atom.value);
+ }
+ if (Object.is(atom.value, newValue)) return;
+ atom.value = newValue;
+ onWriteAtom(atom);
+ };
+ return [read, write] as const;
+}
+export function effect(
+ fn: () => T,
+ { name, withChildren = true }: Opts & { withChildren?: boolean } = {}
+) {
+ const effectComputation: Computation = {
+ state: ComputationState.STALE,
+ value: undefined,
+ compute() {
+ // In case the cleanup read an atom.
+ // todo: test it
+ CurrentComputation = undefined!;
+ // `removeSources` is made by `runComputation`.
+ unsubscribeEffect(effectComputation);
+ CurrentComputation = effectComputation;
+ return fn();
+ },
+ sources: new Set(),
+ name: name,
+ };
+ if (withChildren) effectComputation.childrenEffect = [];
+ CurrentComputation?.childrenEffect?.push?.(effectComputation);
+ updateComputation(effectComputation);
+
+ // Remove sources and unsubscribe
+ return () => {
+ // In case the cleanup read an atom.
+ // todo: test it
+ const previousComputation = CurrentComputation;
+ CurrentComputation = undefined!;
+ unsubscribeEffect(effectComputation);
+ CurrentComputation = previousComputation!;
+ };
+}
+export function computed(fn: () => T, opts?: Opts) {
+ // todo: handle cleanup
+ let computedComputation: Computation = {
+ state: ComputationState.STALE,
+ sources: new Set(),
+ isEager: true,
+ compute: () => {
+ return fn();
+ },
+ value: undefined,
+ name: opts?.name,
+ };
+ updateComputation(computedComputation);
+}
+export function derived(fn: () => T, opts?: Opts): () => T {
+ // todo: handle cleanup
+ let derivedComputation: Derived;
+ return () => {
+ derivedComputation ??= {
+ state: ComputationState.STALE,
+ sources: new Set(),
+ compute: () => {
+ onWriteAtom(derivedComputation);
+ return fn();
+ },
+ isDerived: true,
+ value: undefined,
+ observers: new Set(),
+ name: opts?.name,
+ };
+ onDerived?.(derivedComputation);
+ updateComputation(derivedComputation);
+ return derivedComputation.value;
+ };
+}
+
+export function onReadAtom(atom: Atom) {
+ if (!CurrentComputation) return;
+ CurrentComputation.sources!.add(atom);
+ atom.observers.add(CurrentComputation);
+}
+
+export function onWriteAtom(atom: Atom) {
+ // reset async directly
+ for (const ctx of atom.observers) {
+ resetAsync(ctx);
+ }
+ collectEffects(() => {
+ for (const ctx of atom.observers) {
+ if (ctx.state === ComputationState.EXECUTED) {
+ if (ctx.isDerived) markDownstream(ctx as Derived);
+ else Effects.push(ctx);
+ }
+ // resetAsync(ctx);
+ ctx.state = ComputationState.STALE;
+ }
+ });
+ batchProcessEffects();
+}
+function collectEffects(fn: Function) {
+ if (Effects) return fn();
+ Effects = [];
+ try {
+ return fn();
+ } finally {
+ // processEffects();
+ true;
+ }
+}
+const batchProcessEffects = batched(processEffects);
+// todo: the export is a temporary hack remove before merge
+export function processEffects() {
+ if (!Effects) return;
+ for (const computation of Effects) {
+ updateComputation(computation);
+ }
+ Effects = undefined!;
+}
+
+export function withoutReactivity any>(fn: T): ReturnType {
+ return runWithComputation(undefined!, fn);
+}
+export function getCurrentComputation() {
+ return CurrentComputation;
+}
+export function setComputation(computation: Computation) {
+ CurrentComputation = computation;
+}
+// todo: should probably use updateComputation instead.
+export function runWithComputation(computation: Computation, fn: () => T): T {
+ const previousComputation = CurrentComputation;
+ CurrentComputation = computation;
+ let result: T;
+ try {
+ result = fn();
+ } finally {
+ if (computation) computation.state = ComputationState.EXECUTED;
+ CurrentComputation = previousComputation!;
+ }
+ return result;
+}
+
+function updateComputation(computation: Computation) {
+ const state = computation.state;
+ if (computation.isDerived) onReadAtom(computation as Derived);
+ if (state === ComputationState.EXECUTED) return;
+ if (state === ComputationState.PENDING) {
+ computeSources(computation as Derived);
+ // If the state is still not stale after processing the sources, it means
+ // none of the dependencies have changed.
+ // todo: test it
+ if (computation.state !== ComputationState.STALE) {
+ computation.state = ComputationState.EXECUTED;
+ return;
+ }
+ }
+ // todo: test performance. We might want to avoid removing the atoms to
+ // directly re-add them at compute. Especially as we are making them stale.
+ removeSources(computation);
+ const previousComputation = CurrentComputation;
+ CurrentComputation = computation;
+ if (!computation.isAsync) {
+ computation.value = computation.compute?.();
+ computation.state = ComputationState.EXECUTED;
+ CurrentComputation = previousComputation;
+ } else {
+ updateAsyncComputation(computation as Derived);
+ }
+}
+function removeSources(computation: Computation) {
+ const sources = computation.sources;
+ for (const source of sources) {
+ const observers = source.observers;
+ observers.delete(computation);
+ // todo: if source has no effect observer anymore, remove its sources too
+ // todo: test it
+ }
+ sources.clear();
+}
+
+function unsubscribeEffect(effectComputation: Computation) {
+ removeSources(effectComputation);
+ cleanupEffect(effectComputation);
+ const childrenEffect = effectComputation.childrenEffect;
+ if (!childrenEffect) return;
+ for (const children of childrenEffect) {
+ // Consider it executed to avoid it's re-execution
+ // todo: make a test for it
+ children.state = ComputationState.EXECUTED;
+ removeSources(children);
+ unsubscribeEffect(children);
+ }
+ childrenEffect.length = 0;
+}
+function cleanupEffect(computation: Computation) {
+ // the computation.value of an effect is a cleanup function
+ const cleanupFn = computation.value;
+ if (cleanupFn && typeof cleanupFn === "function") {
+ cleanupFn();
+ computation.value = undefined;
+ }
+}
+
+function markDownstream(derived: Derived) {
+ for (const observer of derived.observers) {
+ // if the state has already been marked, skip it
+ // todo: check async
+ if (observer.state) continue;
+ observer.state = ComputationState.PENDING;
+ if (observer.isDerived) markDownstream(observer as Derived);
+ else Effects.push(observer);
+ }
+}
+function resetAsync(computation: Computation) {
+ const async = computation.async;
+ if (async) {
+ async.task.cancel();
+ computation.async = undefined;
+ }
+}
+function computeSources(derived: Derived) {
+ for (const source of derived.sources) {
+ if (!("compute" in source)) continue;
+ updateComputation(source as Derived);
+ }
+}
+
+export function derivedAsync(fn: () => Promise, opts?: Opts) {
+ let derivedComputation: Derived;
+ const [value, setValue] = signal(undefined);
+ const [state, setState] = signal("unresolved");
+ const [error, setError] = signal(undefined);
+
+ const _load = async () => {
+ setState("pending");
+ try {
+ setValue(await fn());
+ } catch (e) {
+ setError(e);
+ setValue(undefined);
+ setState("errored");
+ return;
+ }
+ setState("ready");
+ };
+ const load = () => {
+ derivedComputation ??= {
+ // get state() {
+ // return state;
+ // },
+ // set state(value: ComputationState) {
+ // // if (opts?.debug && (window as any).d) {
+ // // debugger;
+ // // }
+ // // state = value;
+ // },
+ state: ComputationState.STALE,
+ sources: new Set(),
+ compute: _load,
+ isDerived: true,
+ value: undefined,
+ observers: new Set(),
+ name: opts?.name,
+ isAsync: true,
+ async: undefined,
+ // transaction: getCurrentTransaction(),
+ };
+ onDerived?.(derivedComputation);
+ updateComputation(derivedComputation);
+ };
+
+ const read = () => {
+ withoutReactivity(load);
+ return value();
+ };
+
+ Object.defineProperties(read, {
+ state: { get: state },
+ error: { get: error },
+ loading: {
+ get() {
+ const s = state();
+ return s === "pending" || s === "refreshing";
+ },
+ },
+ // latest: {
+ // get() {
+ // // if (!resolved) return read();
+ // // const err = error();
+ // // if (err && !pr) throw err;
+ // // return value();
+ // return undefined;
+ // },
+ // },
+ });
+
+ return [read as DerivedAsyncRead] as const;
+}
+
+function updateAsyncComputation(computation: Derived) {
+ if (computation.async) return;
+ const transaction = getCurrentTransaction();
+ const length = Effects?.length || 0;
+ for (let i = 0; i < length; i++) {
+ transaction.effects.add(Effects[i]);
+ }
+
+ const async: ComputationAsync = {
+ task: undefined!,
+ transaction,
+ };
+ computation.async = async;
+ computation.value = undefined;
+ // computation.state = ComputationState.ASYNC_PENDING;
+
+ let lastComputation: Computation;
+ let lastTransaction: Transaction;
+ const setContext = () => {
+ lastComputation = CurrentComputation;
+ lastTransaction = getCurrentTransaction();
+ CurrentComputation = computation;
+ setCurrentTransaction(transaction);
+ };
+ const resetContext = () => {
+ CurrentComputation = lastComputation;
+ setCurrentTransaction(lastTransaction);
+ };
+ const onSuccess = (value: any) => {
+ computation.value = value;
+ onWriteAtom(computation);
+ teardown();
+ };
+ const teardown = () => {
+ computation.async = undefined;
+ computation.state = ComputationState.EXECUTED;
+ transaction.decrement();
+ let previousEffects = Effects;
+ Effects = [...transaction.effects];
+ processEffects();
+ Effects = previousEffects;
+ };
+ const task = makeTask(computation.compute, setContext, resetContext, teardown);
+ async.task = task;
+
+ transaction.increment();
+ task.start().then(onSuccess, teardown);
+}
+
+// For tests
+
+let onDerived: (derived: Derived) => void;
+
+export function setSignalHooks(hooks: { onDerived: (derived: Derived) => void }) {
+ if (hooks.onDerived) onDerived = hooks.onDerived;
+}
+export function resetSignalHooks() {
+ onDerived = (void 0)!;
+}
+
+// function delay(ms = 0) {
+// return new Promise((resolve) => setTimeout(resolve, ms));
+// }
+
+// type Deferred = { promise: Promise; resolve: (value: any) => void };
+// function withResolvers(): Deferred {
+// let resolve: (value: T) => void;
+// const promise = new Promise((res) => {
+// resolve = res;
+// });
+// // @ts-ignore
+// return { promise, resolve };
+// }
+// const steps: string[] = [];
+// function step(message: string) {
+// steps.push(message);
+// }
+// const deffereds: Record = {};
+// const deferred = (key: string) => {
+// deffereds[key] ||= withResolvers();
+// return deffereds[key].promise;
+// };
+// const resolve = async (key: string) => {
+// deffereds[key] ||= withResolvers();
+// deffereds[key].resolve(key);
+// await delay();
+// return;
+// };
+
+// function verifySteps(expectedSteps: string[]) {
+// // expect(steps).toEqual(expectedSteps);
+// steps.length = 0;
+// }
+
+// (async () => {
+// patchPromise();
+// const context = getCancellableTask(async () => {
+// step("a before");
+// await deferred("a value");
+// step("a after");
+// const asyncFunction = async () => {
+// step("b before");
+// await deferred("b value");
+// step("b after");
+// };
+// await asyncFunction();
+// step("gen end");
+// });
+// console.warn(`context:`, context);
+
+// verifySteps(["a before"]);
+// await resolve("a value");
+// verifySteps(["a after", "b before"]);
+// context.cancel();
+// await resolve("b value");
+// expect(context.isCancel).toBe(true);
+// verifySteps([]);
+// restorePromise();
+// })();
diff --git a/src/runtime/suspense.ts b/src/runtime/suspense.ts
new file mode 100644
index 000000000..de979c0a8
--- /dev/null
+++ b/src/runtime/suspense.ts
@@ -0,0 +1,63 @@
+import { DerivedAsyncStates, Transaction, TransitionState } from "../common/types";
+import { ComponentNode } from "./component_node";
+import { signal, withoutReactivity } from "./signals";
+
+let currentTransaction: Transaction | undefined;
+export function getCurrentTransaction() {
+ return currentTransaction;
+}
+export function setCurrentTransaction(t: Transaction | undefined) {
+ currentTransaction = t;
+}
+export function withTransaction(transaction: Transaction | undefined, cb: () => T): T {
+ const previousTransaction = currentTransaction;
+ currentTransaction = transaction;
+ const result = cb();
+ currentTransaction = previousTransaction;
+ return result;
+}
+export function makeTransaction({
+ parent,
+ data,
+ onComplete,
+}: {
+ parent?: Transaction;
+ data?: T;
+ onComplete?: (isAsync: boolean) => void;
+} = {}): Transaction {
+ parent?.increment();
+ let count = 0;
+ const [error, setError] = signal(undefined);
+ const [state, setState] = signal("sync");
+ let isASync = false;
+ return {
+ state,
+ increment() {
+ setState("pending");
+ count++;
+ isASync ||= count > 1;
+ },
+ decrement() {
+ count--;
+ if (count === 0) {
+ setState("ready");
+ onComplete(isASync);
+ isASync = false;
+ parent?.decrement();
+ }
+ },
+ effects: new Set(),
+ error,
+ setError: (e: Error) => {
+ // todo: think more thoroughly about error handling in transactions
+ setState("errored");
+ count = 0;
+ setError(e);
+ parent.decrement();
+ },
+ data,
+ get count() {
+ return count;
+ },
+ } as any;
+}
diff --git a/tests/__snapshots__/reactivity.test.ts.snap b/tests/__snapshots__/reactivity.test.ts.snap
index ed1f942f2..95ed87298 100644
--- a/tests/__snapshots__/reactivity.test.ts.snap
+++ b/tests/__snapshots__/reactivity.test.ts.snap
@@ -1,51 +1,5 @@
// Jest Snapshot v1, https://goo.gl/fbAQLP
-exports[`Reactivity: useState concurrent renderings 1`] = `
-"function anonymous(bdom, helpers
-) {
- let { text, createBlock, list, multi, html, toggler, component } = bdom;
- let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
-
- let block1 = createBlock(\`
\`);
-
- return function template(ctx, node, key = \\"\\") {
- let b2 = component(\`ComponentC\`, {key: ctx['props'].key}, key + \`__1\`, node, ctx);
- return block1([], [b2]);
- }
-}"
-`;
-
-exports[`Reactivity: useState concurrent renderings 3`] = `
-"function anonymous(bdom, helpers
-) {
- let { text, createBlock, list, multi, html, toggler, component } = bdom;
- let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
-
- let block1 = createBlock(\`
\`);
-
- return function template(ctx, node, key = \\"\\") {
- let b2 = component(\`ComponentB\`, {key: ctx['context'].key}, key + \`__1\`, node, ctx);
- return block1([], [b2]);
- }
-}"
-`;
-
exports[`Reactivity: useState destroyed component before being mounted is inactive 1`] = `
"function anonymous(app, bdom, helpers
) {
@@ -155,69 +109,6 @@ exports[`Reactivity: useState parent and children subscribed to same context 2`]
}"
`;
-exports[`Reactivity: useState several nodes on different level use same context 1`] = `
-"function anonymous(bdom, helpers
-) {
- let { text, createBlock, list, multi, html, toggler, component } = bdom;
- let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
-
- let block1 = createBlock(\`
\`);
-
- return function template(ctx, node, key = \\"\\") {
- let d1 = ctx['contextObj'].a;
- let d2 = ctx['contextObj'].b;
- return block1([d1, d2]);
- }
-}"
-`;
-
-exports[`Reactivity: useState several nodes on different level use same context 2`] = `
-"function anonymous(bdom, helpers
-) {
- let { text, createBlock, list, multi, html, toggler, component } = bdom;
- let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
-
- let block1 = createBlock(\`
\`);
-
- return function template(ctx, node, key = \\"\\") {
- let d1 = ctx['contextObj'].b;
- return block1([d1]);
- }
-}"
-`;
-
-exports[`Reactivity: useState several nodes on different level use same context 3`] = `
-"function anonymous(bdom, helpers
-) {
- let { text, createBlock, list, multi, html, toggler, component } = bdom;
- let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
-
- let block1 = createBlock(\`
\`);
-
- return function template(ctx, node, key = \\"\\") {
- let d1 = ctx['contextObj'].a;
- let b2 = component(\`L3A\`, {}, key + \`__1\`, node, ctx);
- return block1([d1], [b2]);
- }
-}"
-`;
-
-exports[`Reactivity: useState several nodes on different level use same context 4`] = `
-"function anonymous(bdom, helpers
-) {
- let { text, createBlock, list, multi, html, toggler, component } = bdom;
- let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
-
- let block1 = createBlock(\`
\`);
-
- return function template(ctx, node, key = \\"\\") {
- let b2 = component(\`L2A\`, {}, key + \`__1\`, node, ctx);
- let b3 = component(\`L2B\`, {}, key + \`__2\`, node, ctx);
- return block1([], [b2, b3]);
- }
-}"
-`;
-
exports[`Reactivity: useState two components are updated in parallel 1`] = `
"function anonymous(app, bdom, helpers
) {
diff --git a/tests/cancelablePromise.test.ts b/tests/cancelablePromise.test.ts
new file mode 100644
index 000000000..493df156b
--- /dev/null
+++ b/tests/cancelablePromise.test.ts
@@ -0,0 +1,115 @@
+import { getCancellableTask } from "../src/runtime/cancellablePromise";
+
+function delay(ms = 0) {
+ return new Promise((resolve) => setTimeout(resolve, ms));
+}
+const steps: string[] = [];
+beforeEach(() => {
+ steps.length = 0;
+});
+function step(message: string) {
+ steps.push(message);
+}
+function verifySteps(expectedSteps: string[]) {
+ expect(steps).toEqual(expectedSteps);
+ steps.length = 0;
+}
+
+const deffereds: Record = {};
+const deferred = (key: string) => {
+ deffereds[key] ||= withResolvers();
+ return deffereds[key].promise;
+};
+const resolve = async (key: string) => {
+ deffereds[key] ||= withResolvers();
+ deffereds[key].resolve(key);
+ await delay();
+ return;
+};
+
+beforeEach(() => {
+ for (const key in deffereds) {
+ delete deffereds[key];
+ }
+});
+
+type Deferred = { promise: Promise; resolve: (value: any) => void };
+function withResolvers(): Deferred {
+ let resolve: (value: T) => void;
+ const promise = new Promise((res) => {
+ resolve = res;
+ });
+ // @ts-ignore
+ return { promise, resolve };
+}
+
+describe("cancellablePromise", () => {
+ test("should cancel a simple promise", async () => {
+ // const { getPromise, resolve } = prepare();
+ const context = getCancellableTask(async () => {
+ step("a before");
+ await deferred("a value");
+ step("a after");
+ const asyncFunction = async () => {
+ step("b before");
+ await deferred("b value");
+ step("b after");
+ };
+ await asyncFunction();
+ step("gen end");
+ });
+ verifySteps(["a before"]);
+ await resolve("a value");
+ verifySteps(["a after", "b before"]);
+ context.cancel();
+ await resolve("b value");
+ expect(context.isCancel).toBe(true);
+ verifySteps([]);
+ });
+ test("should cancel in a sub promise", async () => {
+ const context = getCancellableTask(async () => {
+ let result;
+ step("a before");
+ result = await deferred("a value");
+ step(`a after:${result}`);
+ const asyncFunction = async () => {
+ let result;
+ step("b.1 before");
+ result = await deferred("b.1 value");
+ step(`b.1 after:${result}`);
+ const asyncFunction = async () => {
+ let result;
+ step("b.1.1 before");
+ result = await deferred("b.1.1 value");
+ step(`b.1.1 after:${result}`);
+ result = await deferred("b.1.2 value");
+ step(`b.1.2 after:${result}`);
+ return result;
+ };
+ result = await asyncFunction();
+ step(`sub-sub result:${result}`);
+ result = await deferred("b.2 value");
+ step(`b.2 after:${result}`);
+ return result;
+ };
+ result = await asyncFunction();
+ step(`sub result:${result}`);
+ result = await deferred("b value");
+ step(`b after:${result}`);
+ });
+ verifySteps(["a before"]);
+ await resolve("a value");
+ verifySteps(["a after:a value", "b.1 before"]);
+ await resolve("b.1 value");
+ verifySteps(["b.1 after:b.1 value", "b.1.1 before"]);
+ await resolve("b.1.1 value");
+ verifySteps(["b.1.1 after:b.1.1 value"]);
+ context.cancel();
+
+ expect(context.isCancel).toBe(true);
+ await resolve("b.1.2 value");
+ await resolve("b.2 value");
+ await resolve("b value");
+ verifySteps([]);
+ });
+});
diff --git a/tests/components/__snapshots__/reactivity.test.ts.snap b/tests/components/__snapshots__/reactivity.test.ts.snap
index 763ab45fe..7f34b77dc 100644
--- a/tests/components/__snapshots__/reactivity.test.ts.snap
+++ b/tests/components/__snapshots__/reactivity.test.ts.snap
@@ -52,6 +52,36 @@ exports[`reactivity in lifecycle Component is automatically subscribed to reacti
}"
`;
+exports[`reactivity in lifecycle an external reactive object should be tracked 1`] = `
+"function anonymous(app, bdom, helpers
+) {
+ let { text, createBlock, list, multi, html, toggler, comment } = bdom;
+ const comp1 = app.createComponent(\`TestSubComponent\`, true, false, false, []);
+
+ let block1 = createBlock(\`
\`);
+
+ return function template(ctx, node, key = \\"\\") {
+ let txt1 = ctx['obj1'].value;
+ const b2 = comp1({}, key + \`__1\`, node, this, null);
+ return block1([txt1], [b2]);
+ }
+}"
+`;
+
+exports[`reactivity in lifecycle an external reactive object should be tracked 2`] = `
+"function anonymous(app, bdom, helpers
+) {
+ let { text, createBlock, list, multi, html, toggler, comment } = bdom;
+
+ let block1 = createBlock(\`
\`);
+
+ return function template(ctx, node, key = \\"\\") {
+ let txt1 = ctx['obj2'].value;
+ return block1([txt1]);
+ }
+}"
+`;
+
exports[`reactivity in lifecycle can use a state hook 1`] = `
"function anonymous(app, bdom, helpers
) {
@@ -140,39 +170,3 @@ exports[`reactivity in lifecycle state changes in willUnmount do not trigger rer
}
}"
`;
-
-exports[`subscriptions subscriptions returns the keys and targets observed by the component 1`] = `
-"function anonymous(app, bdom, helpers
-) {
- let { text, createBlock, list, multi, html, toggler, comment } = bdom;
-
- return function template(ctx, node, key = \\"\\") {
- return text(ctx['state'].a);
- }
-}"
-`;
-
-exports[`subscriptions subscriptions returns the keys observed by the component 1`] = `
-"function anonymous(app, bdom, helpers
-) {
- let { text, createBlock, list, multi, html, toggler, comment } = bdom;
- const comp1 = app.createComponent(\`Child\`, true, false, false, [\\"state\\"]);
-
- return function template(ctx, node, key = \\"\\") {
- const b2 = text(ctx['state'].a);
- const b3 = comp1({state: ctx['state']}, key + \`__1\`, node, this, null);
- return multi([b2, b3]);
- }
-}"
-`;
-
-exports[`subscriptions subscriptions returns the keys observed by the component 2`] = `
-"function anonymous(app, bdom, helpers
-) {
- let { text, createBlock, list, multi, html, toggler, comment } = bdom;
-
- return function template(ctx, node, key = \\"\\") {
- return text(ctx['props'].state.b);
- }
-}"
-`;
diff --git a/tests/components/basics.test.ts b/tests/components/basics.test.ts
index 264fceb2e..90a80f965 100644
--- a/tests/components/basics.test.ts
+++ b/tests/components/basics.test.ts
@@ -386,7 +386,7 @@ describe("basics", () => {
await nextTick();
expect(fixture.innerHTML).toBe("simple vnode
");
});
-
+ // jest.setTimeout(10000000);
test("text after a conditional component", async () => {
class Child extends Component {
static template = xml`simple vnode
`;
@@ -410,6 +410,7 @@ describe("basics", () => {
expect(fixture.innerHTML).toBe("");
parent.state.hasChild = false;
+ debugger;
parent.state.text = "2";
await nextTick();
expect(fixture.innerHTML).toBe("2
");
diff --git a/tests/components/derivedAsync.test.ts b/tests/components/derivedAsync.test.ts
new file mode 100644
index 000000000..944b5d1ed
--- /dev/null
+++ b/tests/components/derivedAsync.test.ts
@@ -0,0 +1,175 @@
+import { Component, mount, onWillStart, onWillUpdateProps, xml } from "../../src";
+import { elem, makeDeferred, makeTestFixture, nextTick, snapshotEverything } from "../helpers";
+import {
+ signal,
+ derivedAsync,
+ derived,
+ getCurrentComputation,
+ effect,
+} from "../../src/runtime/signals";
+import { Deffered } from "./task.test";
+
+let fixture: HTMLElement;
+
+// snapshotEverything();
+
+beforeEach(() => {
+ fixture = makeTestFixture();
+});
+
+const steps: string[] = [];
+beforeEach(() => {
+ steps.length = 0;
+});
+function step(message: string) {
+ steps.push(message);
+}
+function verifySteps(expectedSteps: string[]) {
+ expect(steps).toEqual(expectedSteps);
+ steps.length = 0;
+}
+
+// jest.setTimeout(100_000_000);
+describe("derivedAsync", () => {
+ test.only("test async", async () => {
+ const [a, setA] = signal(1);
+ class Child extends Component {
+ static props = {
+ n: Number,
+ };
+ setup() {
+ // onWillUpdateProps(async (nextProps) => {
+ // // console.log("updating props");
+ // await nextTick();
+ // return nextProps;
+ // });
+ // onWillStart(async () => {
+ // // console.log("will start2");
+ // });
+ }
+ static template = xml`n: `;
+ static components = { Child };
+ setup() {
+ // onWillStart(async () => {
+ // // console.log("will start");
+ // });
+ }
+ }
+
+ const component = await mount(Test, fixture);
+
+ await nextTick();
+ expect(fixture.innerHTML).toBe("n: 1, 1 ");
+ (window as any).d = true;
+ setA(2);
+ await nextTick();
+ await nextTick();
+
+ expect(fixture.innerHTML).toBe("n: 2, 2 ");
+ });
+ describe.skip("derivedAsync with effects", () => {
+ test("basic async derived with effect", async () => {
+ const [a, setA] = signal(1);
+ const deferreds: Deffered[] = [];
+ const spy = jest.fn(async () => {
+ const deferred = makeDeferred();
+ deferreds.push(deferred);
+ const b = await new Promise((resolve) => setTimeout(() => resolve(10), 10));
+ return (a() + b).toString() as string;
+ });
+ const [d1] = derivedAsync(spy);
+ effect(() => {
+ step(d1()!);
+ });
+ expect(steps).toEqual([11]);
+ });
+ });
+ test.only("basic async derived - read before await", async () => {
+ const [a, setA] = signal(1);
+ const deferreds: Deffered[] = [];
+ const d1 = derivedAsync(async () => {
+ const deferred = makeDeferred();
+ deferreds.push(deferred);
+ const _a = a();
+ const b = await deferred;
+ return _a + b;
+ });
+ class Test extends Component {
+ d1 = d1;
+ static template = xml`n: `;
+ }
+
+ const componentPromise = mount(Test, fixture);
+
+ await nextTick();
+ expect(fixture.innerHTML).toBe("");
+
+ expect(deferreds.length).toBe(1);
+ deferreds[0].resolve(10);
+ const component = await componentPromise;
+ await nextTick();
+ await nextTick();
+ expect(fixture.innerHTML).toBe("n: 11 ");
+
+ setA(2);
+ await nextTick();
+ expect(deferreds.length).toBe(2);
+ expect(fixture.innerHTML).toBe("n: 11 ");
+ deferreds[1].resolve(20);
+ await nextTick();
+ expect(fixture.innerHTML).toBe("n: 22 ");
+
+ expect(elem(component)).toEqual(fixture.querySelector("span"));
+ });
+ test("basic async derived - read after await", async () => {
+ const [a, setA] = signal(1);
+ const deferreds: Deffered[] = [];
+ const [d1] = derivedAsync(
+ async () => {
+ const deferred = makeDeferred();
+ deferreds.push(deferred);
+ const b = await deferred;
+ return a() + b;
+ },
+ {
+ name: "d1",
+ debug: true,
+ }
+ );
+ class Test extends Component {
+ d1 = () => {
+ const result = d1();
+ console.log("result", result);
+ return result;
+ };
+ static template = xml`n: 11 ");
+
+ (window as any).d = true;
+ setA(2);
+ await nextTick();
+ expect(deferreds.length).toBe(2);
+ expect(fixture.innerHTML).toBe("n: 11 ");
+ deferreds[1].resolve(20);
+ await nextTick();
+ expect(fixture.innerHTML).toBe("n: 22 ");
+
+ expect(elem(component)).toEqual(fixture.querySelector("span"));
+ });
+});
diff --git a/tests/components/error_handling.test.ts b/tests/components/error_handling.test.ts
index 672544277..501c55f39 100644
--- a/tests/components/error_handling.test.ts
+++ b/tests/components/error_handling.test.ts
@@ -1,27 +1,28 @@
import { App, Component, mount, onWillDestroy } from "../../src";
+import { OwlError } from "../../src/common/owl_error";
import {
onError,
onMounted,
onPatched,
+ onRendered,
onWillPatch,
- onWillStart,
onWillRender,
- onRendered,
+ onWillStart,
onWillUnmount,
useState,
xml,
} from "../../src/index";
+import { getCurrent } from "../../src/runtime/component_node";
import {
logStep,
makeTestFixture,
- nextTick,
+ nextAppError,
nextMicroTick,
+ nextTick,
snapshotEverything,
- useLogLifecycle,
- nextAppError,
steps,
+ useLogLifecycle,
} from "../helpers";
-import { OwlError } from "../../src/common/owl_error";
let fixture: HTMLElement;
@@ -45,7 +46,7 @@ afterEach(() => {
console.warn = originalconsoleWarn;
});
-describe("basics", () => {
+describe.skip("basics", () => {
test("no component catching error lead to full app destruction", async () => {
class ErrorComponent extends Component {
static template = xml`hey
`;
@@ -235,7 +236,7 @@ function(app, bdom, helpers) {
});
});
-describe("errors and promises", () => {
+describe.skip("errors and promises", () => {
test("a rendering error will reject the mount promise", async () => {
// we do not catch error in willPatch anymore
class Root extends Component {
@@ -530,7 +531,7 @@ describe("errors and promises", () => {
});
});
-describe("can catch errors", () => {
+describe.skip("can catch errors", () => {
test("can catch an error in a component render function", async () => {
class ErrorComponent extends Component {
static template = xml`hey
`;
@@ -647,7 +648,7 @@ describe("can catch errors", () => {
setup() {
onWillStart(() => {
- this.state = useState({ value: 2 });
+ getCurrent();
});
}
}
diff --git a/tests/components/lifecycle.test.ts b/tests/components/lifecycle.test.ts
index af1ec4021..420456be3 100644
--- a/tests/components/lifecycle.test.ts
+++ b/tests/components/lifecycle.test.ts
@@ -1051,6 +1051,8 @@ describe("lifecycle hooks", () => {
fixture.querySelector("button")!.click();
await nextTick();
+ await nextTick();
+ await nextTick();
expect(steps.splice(0)).toMatchInlineSnapshot(`Array []`);
fixture.querySelector("button")!.click();
diff --git a/tests/components/props.test.ts b/tests/components/props.test.ts
index 2611e4359..2824c69ad 100644
--- a/tests/components/props.test.ts
+++ b/tests/components/props.test.ts
@@ -450,14 +450,10 @@ test(".alike suffix in a list", async () => {
expect(fixture.innerHTML).toBe("1V 2V ");
expect(steps.splice(0)).toMatchInlineSnapshot(`
Array [
- "Parent:willRender",
- "Parent:rendered",
"Todo:willRender",
"Todo:rendered",
"Todo:willPatch",
"Todo:patched",
- "Parent:willPatch",
- "Parent:patched",
]
`);
});
diff --git a/tests/components/props_validation.test.ts b/tests/components/props_validation.test.ts
index 40c4ad245..8f9e883f9 100644
--- a/tests/components/props_validation.test.ts
+++ b/tests/components/props_validation.test.ts
@@ -702,7 +702,7 @@ describe("props validation", () => {
const app = new App(Parent, { test: true });
await app.mount(fixture);
expect(fixture.innerHTML).toBe("12");
- expect(app.root!.subscriptions).toEqual([{ keys: ["otherValue"], target: obj }]);
+ // expect(app.root!.subscriptions).toEqual([{ keys: ["otherValue"], target: obj }]);
});
test("props are validated whenever component is updated", async () => {
diff --git a/tests/components/reactivity.test.ts b/tests/components/reactivity.test.ts
index 042757d56..cb17a2207 100644
--- a/tests/components/reactivity.test.ts
+++ b/tests/components/reactivity.test.ts
@@ -2,12 +2,11 @@ import {
Component,
mount,
onPatched,
- onWillRender,
onWillPatch,
+ onWillRender,
onWillUnmount,
- useState,
+ reactive,
xml,
- toRaw,
} from "../../src";
import { makeTestFixture, nextTick, snapshotEverything, steps, useLogLifecycle } from "../helpers";
@@ -20,10 +19,36 @@ beforeEach(() => {
});
describe("reactivity in lifecycle", () => {
+ test("an external reactive object should be tracked", async () => {
+ const obj1 = reactive({ value: 1 });
+ const obj2 = reactive({ value: 100 });
+ class TestSubComponent extends Component {
+ obj2 = obj2;
+
+ static template = xml`
+
`;
+ }
+ class TestComponent extends Component {
+ obj1 = obj1;
+ static template = xml`
+
`;
+ static components = { TestSubComponent };
+ }
+ await mount(TestComponent, fixture);
+ expect(fixture.innerHTML).toBe("");
+ obj1.value = 2;
+ obj2.value = 200;
+ await nextTick();
+
+ expect(fixture.innerHTML).toBe("");
+ });
test("can use a state hook", async () => {
class Counter extends Component {
static template = xml`
`;
- counter = useState({ value: 42 });
+ counter = reactive({ value: 42 });
}
const counter = await mount(Counter, fixture);
expect(fixture.innerHTML).toBe("42
");
@@ -36,7 +61,7 @@ describe("reactivity in lifecycle", () => {
let n = 0;
class Comp extends Component {
static template = xml`
`;
- state = useState({ a: 5, b: 7 });
+ state = reactive({ a: 5, b: 7 });
setup() {
onWillRender(() => n++);
}
@@ -57,7 +82,7 @@ describe("reactivity in lifecycle", () => {
test("can use a state hook on Map", async () => {
class Counter extends Component {
static template = xml`
`;
- counter = useState(new Map([["value", 42]]));
+ counter = reactive(new Map([["value", 42]]));
}
const counter = await mount(Counter, fixture);
expect(fixture.innerHTML).toBe("42
");
@@ -72,7 +97,7 @@ describe("reactivity in lifecycle", () => {
static template = xml`
`;
- state = useState({ val: 1 });
+ state = reactive({ val: 1 });
setup() {
STATE = this.state;
onWillRender(() => {
@@ -167,7 +192,7 @@ describe("reactivity in lifecycle", () => {
class Parent extends Component {
static template = xml` & {
+ resolve: (value: any) => void;
+ reject: (reason: any) => void;
+};
+
+interface TaskWithResolvers {
+ promise: Promise;
+ resolve: (value: T | PromiseLike) => void;
+ reject: (reason?: any) => void;
+}
+
+let resolvers: Record> = {};
+function getTask(id: string) {
+ const resolver: {
+ task?: Task;
+ resolve?: (value: string | PromiseLike) => void;
+ reject?: (reason?: any) => void;
+ } = {};
+
+ const promise = new Task((res, rej) => {
+ resolver.resolve = res;
+ resolver.reject = rej;
+ });
+ resolver.task = promise;
+
+ resolvers[id] = resolver as TaskWithResolvers;
+ return promise;
+}
+function tick() {
+ return new Promise((r) => setTimeout(r, 0));
+}
+
+// const timeoutTask = (ms: number) => new Task((resolve) => setTimeout(() => resolve(ms), ms));
+
+const steps: string[] = [];
+function step(msg: string) {
+ steps.push(msg);
+}
+function verifySteps(expected: string[]) {
+ expect(steps).toEqual(expected);
+ steps.length = 0;
+}
+
+afterEach(() => {
+ resolvers = {};
+});
+
+describe("task", () => {
+ test("should run a task properly", async () => {
+ taskEffect(async () => {
+ let result;
+ step(`a:begin`);
+ result = await getTask("a");
+ step(`a:${result}`);
+ result = await getTask("b");
+ step(`b:${result}`);
+ });
+
+ verifySteps(["a:begin"]);
+ resolvers["a"].resolve("a");
+ await tick();
+ verifySteps(["a:a"]);
+ resolvers["b"].resolve("b");
+ await tick();
+ verifySteps(["b:b"]);
+ });
+
+ test("should cancel a task properly", async () => {
+ const ctx = taskEffect(async () => {
+ let result;
+ step(`a:begin`);
+ result = await getTask("a");
+ step(`a:${result}`);
+ result = await getTask("b");
+ step(`b:${result}`);
+ });
+
+ verifySteps(["a:begin"]);
+ resolvers["a"].resolve("a");
+ await tick();
+ verifySteps(["a:a"]);
+ ctx.cancel();
+ resolvers["b"].resolve("b");
+ await tick();
+ verifySteps([]);
+ });
+
+ test("should run a task with subtasks properly", async () => {
+ taskEffect(async () => {
+ let result;
+ step(`a:begin`);
+ result = await getTask("a");
+ step(`a:${result}`);
+ result = await getTask("b");
+ step(`b:${result}`);
+ });
+
+ verifySteps(["a:begin"]);
+ resolvers["a"].resolve("a");
+ await tick();
+ verifySteps(["a:a"]);
+ resolvers["b"].resolve("b");
+ await tick();
+ verifySteps(["b:b"]);
+ });
+});
diff --git a/tests/derived.test.ts b/tests/derived.test.ts
new file mode 100644
index 000000000..4230bade4
--- /dev/null
+++ b/tests/derived.test.ts
@@ -0,0 +1,301 @@
+import { reactive } from "../src";
+import { Derived } from "../src/common/types";
+import { derived, resetSignalHooks, setSignalHooks } from "../src/runtime/signals";
+import { expectSpy, spyDerived, spyEffect, waitScheduler } from "./helpers";
+
+describe("derived", () => {
+ test("derived returns correct initial value", () => {
+ const state = reactive({ a: 1, b: 2 });
+ const d = derived(() => state.a + state.b);
+ expect(d()).toBe(3);
+ });
+
+ test("derived should not run until being called", () => {
+ const state = reactive({ a: 1 });
+ const d = spyDerived(() => state.a + 100);
+ expect(d.spy).not.toHaveBeenCalled();
+ expect(d()).toBe(101);
+ expect(d.spy).toHaveBeenCalledTimes(1);
+ });
+
+ test("derived updates when dependencies change", async () => {
+ const state = reactive({ a: 1, b: 2 });
+
+ const d = spyDerived(() => state.a * state.b);
+ const e = spyEffect(() => d());
+ e();
+
+ expectSpy(e.spy, 1);
+ expectSpy(d.spy, 1, { result: 2 });
+ state.a = 3;
+ await waitScheduler();
+ expectSpy(e.spy, 2);
+ expectSpy(d.spy, 2, { result: 6 });
+ state.b = 4;
+ await waitScheduler();
+ expectSpy(e.spy, 3);
+ expectSpy(d.spy, 3, { result: 12 });
+ });
+
+ test("derived should not update even if the effect updates", async () => {
+ const state = reactive({ a: 1, b: 2 });
+ const d = spyDerived(() => state.a);
+ const e = spyEffect(() => state.b + d());
+ e();
+ expectSpy(e.spy, 1);
+ expectSpy(d.spy, 1, { result: 1 });
+ // change unrelated state
+ state.b = 3;
+ await waitScheduler();
+ expectSpy(e.spy, 2);
+ expectSpy(d.spy, 1, { result: 1 });
+ });
+
+ test("derived does not update when unrelated property changes, but updates when dependencies change", async () => {
+ const state = reactive({ a: 1, b: 2, c: 3 });
+ const d = spyDerived(() => state.a + state.b);
+ const e = spyEffect(() => d());
+ e();
+
+ expectSpy(e.spy, 1);
+ expectSpy(d.spy, 1, { result: 3 });
+
+ state.c = 10;
+ await waitScheduler();
+ expectSpy(e.spy, 1);
+ expectSpy(d.spy, 1, { result: 3 });
+ });
+
+ test("derived does not notify when value is unchanged", async () => {
+ const state = reactive({ a: 1, b: 2 });
+ const d = spyDerived(() => state.a + state.b);
+ const e = spyEffect(() => d());
+ e();
+ expectSpy(e.spy, 1);
+ expectSpy(d.spy, 1, { result: 3 });
+ state.a = 1;
+ state.b = 2;
+ await waitScheduler();
+ expectSpy(e.spy, 1);
+ expectSpy(d.spy, 1, { result: 3 });
+ });
+
+ test("multiple deriveds can depend on same state", async () => {
+ const state = reactive({ a: 1, b: 2 });
+ const d1 = spyDerived(() => state.a + state.b);
+ const d2 = spyDerived(() => state.a * state.b);
+ const e1 = spyEffect(() => d1());
+ const e2 = spyEffect(() => d2());
+ e1();
+ e2();
+ expectSpy(e1.spy, 1);
+ expectSpy(d1.spy, 1, { result: 3 });
+ expectSpy(e2.spy, 1);
+ expectSpy(d2.spy, 1, { result: 2 });
+ state.a = 3;
+ await waitScheduler();
+ expectSpy(e1.spy, 2);
+ expectSpy(d1.spy, 2, { result: 5 });
+ expectSpy(e2.spy, 2);
+ expectSpy(d2.spy, 2, { result: 6 });
+ });
+
+ test("derived can depend on arrays", async () => {
+ const state = reactive({ arr: [1, 2, 3] });
+ const d = spyDerived(() => state.arr.reduce((a, b) => a + b, 0));
+ const e = spyEffect(() => d());
+ e();
+ expectSpy(e.spy, 1);
+ expectSpy(d.spy, 1, { result: 6 });
+ state.arr.push(4);
+ await waitScheduler();
+ expectSpy(e.spy, 2);
+ expectSpy(d.spy, 2, { result: 10 });
+ state.arr[0] = 10;
+ await waitScheduler();
+ expectSpy(e.spy, 3);
+ expectSpy(d.spy, 3, { result: 19 });
+ });
+
+ test("derived can depend on nested reactives", async () => {
+ const state = reactive({ nested: { a: 1 } });
+ const d = spyDerived(() => state.nested.a * 2);
+ const e = spyEffect(() => d());
+ e();
+ expectSpy(e.spy, 1);
+ expectSpy(d.spy, 1, { result: 2 });
+ state.nested.a = 5;
+ await waitScheduler();
+ expectSpy(e.spy, 2);
+ expectSpy(d.spy, 2, { result: 10 });
+ });
+
+ test("derived can be called multiple times and returns same value if unchanged", async () => {
+ const state = reactive({ a: 1, b: 2 });
+
+ const d = spyDerived(() => state.a + state.b);
+ expect(d.spy).not.toHaveBeenCalled();
+ expect(d()).toBe(3);
+ expectSpy(d.spy, 1, { result: 3 });
+ expect(d()).toBe(3);
+ expectSpy(d.spy, 1, { result: 3 });
+ state.a = 2;
+ await waitScheduler();
+ expectSpy(d.spy, 1, { result: 3 });
+ expect(d()).toBe(4);
+ expectSpy(d.spy, 2, { result: 4 });
+ expect(d()).toBe(4);
+ expectSpy(d.spy, 2, { result: 4 });
+ });
+
+ test("derived should not subscribe to change if no effect is using it", async () => {
+ const state = reactive({ a: 1, b: 10 });
+ const d = spyDerived(() => state.a);
+ expect(d.spy).not.toHaveBeenCalled();
+ const e = spyEffect(() => {
+ d();
+ });
+ const unsubscribe = e();
+ expectSpy(e.spy, 1);
+ expectSpy(d.spy, 1, { result: 1 });
+ state.a = 2;
+ await waitScheduler();
+ expectSpy(e.spy, 2);
+ expectSpy(d.spy, 2, { result: 2 });
+ unsubscribe();
+ state.a = 3;
+ await waitScheduler();
+ expectSpy(e.spy, 2);
+ expectSpy(d.spy, 2, { result: 2 });
+ });
+
+ test("derived should not be recomputed when called from effect if none of its source changed", async () => {
+ const state = reactive({ a: 1 });
+ const d = spyDerived(() => state.a * 0);
+ expect(d.spy).not.toHaveBeenCalled();
+ const e = spyEffect(() => {
+ d();
+ });
+ e();
+ expectSpy(e.spy, 1);
+ expectSpy(d.spy, 1, { result: 0 });
+ state.a = 2;
+ await waitScheduler();
+ expectSpy(e.spy, 2);
+ expectSpy(d.spy, 2, { result: 0 });
+ });
+});
+describe("unsubscription", () => {
+ const deriveds: Derived[] = [];
+ beforeAll(() => {
+ setSignalHooks({ onDerived: (m: Derived) => deriveds.push(m) });
+ });
+ afterAll(() => {
+ resetSignalHooks();
+ });
+ afterEach(() => {
+ deriveds.length = 0;
+ });
+
+ test("derived shoud unsubscribes from dependencies when effect is unsubscribed", async () => {
+ const state = reactive({ a: 1, b: 2 });
+ const d = spyDerived(() => state.a + state.b);
+ const e = spyEffect(() => d());
+ d();
+ expect(deriveds[0]!.observers.size).toBe(0);
+ const unsubscribe = e();
+ expect(deriveds[0]!.observers.size).toBe(1);
+ unsubscribe();
+ expect(deriveds[0]!.observers.size).toBe(0);
+ });
+});
+describe("nested derived", () => {
+ test("derived can depend on another derived", async () => {
+ const state = reactive({ a: 1, b: 2 });
+ const d1 = spyDerived(() => state.a + state.b);
+ const d2 = spyDerived(() => d1() * 2);
+ const e = spyEffect(() => d2());
+ e();
+ expectSpy(e.spy, 1);
+ expectSpy(d1.spy, 1, { result: 3 });
+ expectSpy(d2.spy, 1, { result: 6 });
+ state.a = 3;
+ await waitScheduler();
+ expectSpy(e.spy, 2);
+ expectSpy(d1.spy, 2, { result: 5 });
+ expectSpy(d2.spy, 2, { result: 10 });
+ });
+ test("nested derived should not recompute if none of its sources changed", async () => {
+ /**
+ * s1
+ * ↓
+ * d1 = s1 * 0
+ * ↓
+ * d2 = d1
+ * ↓
+ * e1
+ *
+ * change s1
+ * -> d1 should recomputes but d2 should not
+ */
+ const state = reactive({ a: 1 });
+ const d1 = spyDerived(() => state.a);
+ const d2 = spyDerived(() => d1() * 0);
+ const e = spyEffect(() => d2());
+ e();
+ expectSpy(e.spy, 1);
+ expectSpy(d1.spy, 1, { result: 1 });
+ expectSpy(d2.spy, 1, { result: 0 });
+ state.a = 3;
+ await waitScheduler();
+ expectSpy(e.spy, 2);
+ expectSpy(d1.spy, 2, { result: 3 });
+ expectSpy(d2.spy, 2, { result: 0 });
+ });
+ test("find a better name", async () => {
+ /**
+ * +-------+
+ * | s1 |
+ * +-------+
+ * v
+ * +-------+
+ * | d1 |
+ * +-------+
+ * v v
+ * +-------+ +-------+
+ * | d2 | | d3 |
+ * +-------+ +-------+
+ * | v v
+ * | +-------+
+ * | | d4 |
+ * | +-------+
+ * | |
+ * v v
+ * +-------+
+ * | e1 |
+ * +-------+
+ *
+ * change s1
+ * -> d1, d2, d3, d4, e1 should recomputes
+ */
+ const state = reactive({ a: 1 });
+ const d1 = spyDerived(() => state.a);
+ const d2 = spyDerived(() => d1() + 1); // 1 + 1 = 2
+ const d3 = spyDerived(() => d1() + 2); // 1 + 2 = 3
+ const d4 = spyDerived(() => d2() + d3()); // 2 + 3 = 5
+ const e = spyEffect(() => d4());
+ e();
+ expectSpy(e.spy, 1);
+ expectSpy(d1.spy, 1, { result: 1 });
+ expectSpy(d2.spy, 1, { result: 2 });
+ expectSpy(d3.spy, 1, { result: 3 });
+ expectSpy(d4.spy, 1, { result: 5 });
+ state.a = 2;
+ await waitScheduler();
+ expectSpy(e.spy, 2);
+ expectSpy(d1.spy, 2, { result: 2 });
+ expectSpy(d2.spy, 2, { result: 3 });
+ expectSpy(d3.spy, 2, { result: 4 });
+ expectSpy(d4.spy, 2, { result: 7 });
+ });
+});
diff --git a/tests/derivedAsync.test.ts b/tests/derivedAsync.test.ts
new file mode 100644
index 000000000..1150d10d3
--- /dev/null
+++ b/tests/derivedAsync.test.ts
@@ -0,0 +1,303 @@
+import { reactive } from "../src";
+import { Derived } from "../src/common/types";
+import { derivedAsync, resetSignalHooks, setSignalHooks } from "../src/runtime/signals";
+import { expectSpy, spyDerived, spyEffect, waitScheduler } from "./helpers";
+
+describe("derived async", () => {
+ test.skip("derived returns correct initial value", () => {
+ const state = reactive({ a: 1, b: 2 });
+ const d = derivedAsync(async () => state.a + state.b);
+ expect(d()).toBe(3);
+ });
+
+ describe.skip("skip", () => {
+ test("derived should not run until being called", () => {
+ const state = reactive({ a: 1 });
+ const d = spyDerived(() => state.a + 100);
+ expect(d.spy).not.toHaveBeenCalled();
+ expect(d()).toBe(101);
+ expect(d.spy).toHaveBeenCalledTimes(1);
+ });
+
+ test("derived updates when dependencies change", async () => {
+ const state = reactive({ a: 1, b: 2 });
+
+ const d = spyDerived(() => state.a * state.b);
+ const e = spyEffect(() => d());
+ e();
+
+ expectSpy(e.spy, 1);
+ expectSpy(d.spy, 1, { result: 2 });
+ state.a = 3;
+ await waitScheduler();
+ expectSpy(e.spy, 2);
+ expectSpy(d.spy, 2, { result: 6 });
+ state.b = 4;
+ await waitScheduler();
+ expectSpy(e.spy, 3);
+ expectSpy(d.spy, 3, { result: 12 });
+ });
+
+ test("derived should not update even if the effect updates", async () => {
+ const state = reactive({ a: 1, b: 2 });
+ const d = spyDerived(() => state.a);
+ const e = spyEffect(() => state.b + d());
+ e();
+ expectSpy(e.spy, 1);
+ expectSpy(d.spy, 1, { result: 1 });
+ // change unrelated state
+ state.b = 3;
+ await waitScheduler();
+ expectSpy(e.spy, 2);
+ expectSpy(d.spy, 1, { result: 1 });
+ });
+
+ test("derived does not update when unrelated property changes, but updates when dependencies change", async () => {
+ const state = reactive({ a: 1, b: 2, c: 3 });
+ const d = spyDerived(() => state.a + state.b);
+ const e = spyEffect(() => d());
+ e();
+
+ expectSpy(e.spy, 1);
+ expectSpy(d.spy, 1, { result: 3 });
+
+ state.c = 10;
+ await waitScheduler();
+ expectSpy(e.spy, 1);
+ expectSpy(d.spy, 1, { result: 3 });
+ });
+
+ test("derived does not notify when value is unchanged", async () => {
+ const state = reactive({ a: 1, b: 2 });
+ const d = spyDerived(() => state.a + state.b);
+ const e = spyEffect(() => d());
+ e();
+ expectSpy(e.spy, 1);
+ expectSpy(d.spy, 1, { result: 3 });
+ state.a = 1;
+ state.b = 2;
+ await waitScheduler();
+ expectSpy(e.spy, 1);
+ expectSpy(d.spy, 1, { result: 3 });
+ });
+
+ test("multiple deriveds can depend on same state", async () => {
+ const state = reactive({ a: 1, b: 2 });
+ const d1 = spyDerived(() => state.a + state.b);
+ const d2 = spyDerived(() => state.a * state.b);
+ const e1 = spyEffect(() => d1());
+ const e2 = spyEffect(() => d2());
+ e1();
+ e2();
+ expectSpy(e1.spy, 1);
+ expectSpy(d1.spy, 1, { result: 3 });
+ expectSpy(e2.spy, 1);
+ expectSpy(d2.spy, 1, { result: 2 });
+ state.a = 3;
+ await waitScheduler();
+ expectSpy(e1.spy, 2);
+ expectSpy(d1.spy, 2, { result: 5 });
+ expectSpy(e2.spy, 2);
+ expectSpy(d2.spy, 2, { result: 6 });
+ });
+
+ test("derived can depend on arrays", async () => {
+ const state = reactive({ arr: [1, 2, 3] });
+ const d = spyDerived(() => state.arr.reduce((a, b) => a + b, 0));
+ const e = spyEffect(() => d());
+ e();
+ expectSpy(e.spy, 1);
+ expectSpy(d.spy, 1, { result: 6 });
+ state.arr.push(4);
+ await waitScheduler();
+ expectSpy(e.spy, 2);
+ expectSpy(d.spy, 2, { result: 10 });
+ state.arr[0] = 10;
+ await waitScheduler();
+ expectSpy(e.spy, 3);
+ expectSpy(d.spy, 3, { result: 19 });
+ });
+
+ test("derived can depend on nested reactives", async () => {
+ const state = reactive({ nested: { a: 1 } });
+ const d = spyDerived(() => state.nested.a * 2);
+ const e = spyEffect(() => d());
+ e();
+ expectSpy(e.spy, 1);
+ expectSpy(d.spy, 1, { result: 2 });
+ state.nested.a = 5;
+ await waitScheduler();
+ expectSpy(e.spy, 2);
+ expectSpy(d.spy, 2, { result: 10 });
+ });
+
+ test("derived can be called multiple times and returns same value if unchanged", async () => {
+ const state = reactive({ a: 1, b: 2 });
+
+ const d = spyDerived(() => state.a + state.b);
+ expect(d.spy).not.toHaveBeenCalled();
+ expect(d()).toBe(3);
+ expectSpy(d.spy, 1, { result: 3 });
+ expect(d()).toBe(3);
+ expectSpy(d.spy, 1, { result: 3 });
+ state.a = 2;
+ await waitScheduler();
+ expectSpy(d.spy, 1, { result: 3 });
+ expect(d()).toBe(4);
+ expectSpy(d.spy, 2, { result: 4 });
+ expect(d()).toBe(4);
+ expectSpy(d.spy, 2, { result: 4 });
+ });
+
+ test("derived should not subscribe to change if no effect is using it", async () => {
+ const state = reactive({ a: 1, b: 10 });
+ const d = spyDerived(() => state.a);
+ expect(d.spy).not.toHaveBeenCalled();
+ const e = spyEffect(() => {
+ d();
+ });
+ const unsubscribe = e();
+ expectSpy(e.spy, 1);
+ expectSpy(d.spy, 1, { result: 1 });
+ state.a = 2;
+ await waitScheduler();
+ expectSpy(e.spy, 2);
+ expectSpy(d.spy, 2, { result: 2 });
+ unsubscribe();
+ state.a = 3;
+ await waitScheduler();
+ expectSpy(e.spy, 2);
+ expectSpy(d.spy, 2, { result: 2 });
+ });
+
+ test("derived should not be recomputed when called from effect if none of its source changed", async () => {
+ const state = reactive({ a: 1 });
+ const d = spyDerived(() => state.a * 0);
+ expect(d.spy).not.toHaveBeenCalled();
+ const e = spyEffect(() => {
+ d();
+ });
+ e();
+ expectSpy(e.spy, 1);
+ expectSpy(d.spy, 1, { result: 0 });
+ state.a = 2;
+ await waitScheduler();
+ expectSpy(e.spy, 2);
+ expectSpy(d.spy, 2, { result: 0 });
+ });
+ });
+ describe("unsubscription", () => {
+ const deriveds: Derived[] = [];
+ beforeAll(() => {
+ setSignalHooks({ onDerived: (m: Derived) => deriveds.push(m) });
+ });
+ afterAll(() => {
+ resetSignalHooks();
+ });
+ afterEach(() => {
+ deriveds.length = 0;
+ });
+
+ test("derived shoud unsubscribes from dependencies when effect is unsubscribed", async () => {
+ const state = reactive({ a: 1, b: 2 });
+ const d = spyDerived(() => state.a + state.b);
+ const e = spyEffect(() => d());
+ d();
+ expect(deriveds[0]!.observers.size).toBe(0);
+ const unsubscribe = e();
+ expect(deriveds[0]!.observers.size).toBe(1);
+ unsubscribe();
+ expect(deriveds[0]!.observers.size).toBe(0);
+ });
+ });
+ describe("nested derived", () => {
+ test("derived can depend on another derived", async () => {
+ const state = reactive({ a: 1, b: 2 });
+ const d1 = spyDerived(() => state.a + state.b);
+ const d2 = spyDerived(() => d1() * 2);
+ const e = spyEffect(() => d2());
+ e();
+ expectSpy(e.spy, 1);
+ expectSpy(d1.spy, 1, { result: 3 });
+ expectSpy(d2.spy, 1, { result: 6 });
+ state.a = 3;
+ await waitScheduler();
+ expectSpy(e.spy, 2);
+ expectSpy(d1.spy, 2, { result: 5 });
+ expectSpy(d2.spy, 2, { result: 10 });
+ });
+ test("nested derived should not recompute if none of its sources changed", async () => {
+ /**
+ * s1
+ * ↓
+ * d1 = s1 * 0
+ * ↓
+ * d2 = d1
+ * ↓
+ * e1
+ *
+ * change s1
+ * -> d1 should recomputes but d2 should not
+ */
+ const state = reactive({ a: 1 });
+ const d1 = spyDerived(() => state.a);
+ const d2 = spyDerived(() => d1() * 0);
+ const e = spyEffect(() => d2());
+ e();
+ expectSpy(e.spy, 1);
+ expectSpy(d1.spy, 1, { result: 1 });
+ expectSpy(d2.spy, 1, { result: 0 });
+ state.a = 3;
+ await waitScheduler();
+ expectSpy(e.spy, 2);
+ expectSpy(d1.spy, 2, { result: 3 });
+ expectSpy(d2.spy, 2, { result: 0 });
+ });
+ test("find a better name", async () => {
+ /**
+ * +-------+
+ * | s1 |
+ * +-------+
+ * v
+ * +-------+
+ * | d1 |
+ * +-------+
+ * v v
+ * +-------+ +-------+
+ * | d2 | | d3 |
+ * +-------+ +-------+
+ * | v v
+ * | +-------+
+ * | | d4 |
+ * | +-------+
+ * | |
+ * v v
+ * +-------+
+ * | e1 |
+ * +-------+
+ *
+ * change s1
+ * -> d1, d2, d3, d4, e1 should recomputes
+ */
+ const state = reactive({ a: 1 });
+ const d1 = spyDerived(() => state.a);
+ const d2 = spyDerived(() => d1() + 1); // 1 + 1 = 2
+ const d3 = spyDerived(() => d1() + 2); // 1 + 2 = 3
+ const d4 = spyDerived(() => d2() + d3()); // 2 + 3 = 5
+ const e = spyEffect(() => d4());
+ e();
+ expectSpy(e.spy, 1);
+ expectSpy(d1.spy, 1, { result: 1 });
+ expectSpy(d2.spy, 1, { result: 2 });
+ expectSpy(d3.spy, 1, { result: 3 });
+ expectSpy(d4.spy, 1, { result: 5 });
+ state.a = 2;
+ await waitScheduler();
+ expectSpy(e.spy, 2);
+ expectSpy(d1.spy, 2, { result: 2 });
+ expectSpy(d2.spy, 2, { result: 3 });
+ expectSpy(d3.spy, 2, { result: 4 });
+ expectSpy(d4.spy, 2, { result: 7 });
+ });
+ });
+});
diff --git a/tests/discussModel.test.ts b/tests/discussModel.test.ts
new file mode 100644
index 000000000..a7cac6ba1
--- /dev/null
+++ b/tests/discussModel.test.ts
@@ -0,0 +1,120 @@
+import { DiscussRecord, fields } from "../src/runtime/relationalModel/discussModel";
+import { DManyFn } from "../src/runtime/relationalModel/discussModelTypes";
+import { clearModelRegistry } from "../src/runtime/relationalModel/modelRegistry";
+import { InstanceId, ModelId } from "../src/runtime/relationalModel/types";
+
+export type RawStore = Record