reactronic 0.93.25025 → 0.94.25027

package/build/dist/source/core/Transaction.d.ts

@@ -1,7 +1,7 @@
 import { F } from "../util/Utils.js";
 import { Worker } from "../Worker.js";
 import { SnapshotOptions } from "../Options.js";
-import { ObjectHandle, ObjectVersion, Reaction, FieldVersion, FieldKey } from "./Data.js";
+import { ObjectHandle, ObjectVersion, OperationFootprint, ContentFootprint, FieldKey } from "./Data.js";
 import { Changeset } from "./Changeset.js";
 export declare abstract class Transaction implements Worker {
     static get current(): Transaction;
@@ -78,13 +78,13 @@ export declare class TransactionImpl extends Transaction {
     private checkForConflicts;
     private tryResolveConflicts;
     private applyOrDiscard;
-    applyOrDiscardChangeset(): Array<Reaction>;
+    applyOrDiscardChangeset(): Array<OperationFootprint>;
     applyObjectChanges(h: ObjectHandle, ov: ObjectVersion): void;
     static migrateObjectChangesToAnotherTransaction(h: ObjectHandle, ov: ObjectVersion, tParent: Transaction): void;
     static migrateFieldVersionToAnotherTransaction(h: ObjectHandle, fk: FieldKey, ov: ObjectVersion, ovParent: ObjectVersion, tParent: Transaction): void;
     private acquirePromise;
     private static getCurrentChangeset;
     private static getEditableChangeset;
-    static migrateFieldVersion: (fv: FieldVersion, target: Transaction) => FieldVersion;
+    static migrateContentFootprint: (fv: ContentFootprint, target: Transaction) => ContentFootprint;
     static _init(): void;
 }

package/build/dist/source/core/Transaction.js

@@ -9,7 +9,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 import { UNDEF, pause } from "../util/Utils.js";
 import { Log, misuse, error, fatal } from "../util/Dbg.js";
-import { Isolation } from "../Options.js";
+import { Isolation } from "../Enums.js";
 import { Meta } from "./Data.js";
 import { Changeset, Dump, EMPTY_OBJECT_VERSION, UNDEFINED_REVISION } from "./Changeset.js";
 export class Transaction {
@@ -354,73 +354,73 @@ export class TransactionImpl extends Transaction {
     }
     static migrateFieldVersionToAnotherTransaction(h, fk, ov, ovParent, tParent) {
         const csParent = tParent.changeset;
-        const fv = ov.data[fk];
-        const fvParent = ovParent.data[fk];
-        if (fv.isLaunch) {
-            const migrated = TransactionImpl.migrateFieldVersion(fv, tParent);
-            if (ovParent.former.objectVersion.data[fk] !== fvParent) {
-                let reactions = fvParent.reactions;
-                if (reactions) {
-                    const migratedReactions = migrated.reactions = new Set();
-                    reactions.forEach(o => {
-                        const conformingTriggers = o.triggers;
-                        const sub = conformingTriggers.get(fvParent);
-                        conformingTriggers.delete(fvParent);
-                        conformingTriggers.set(migrated, sub);
-                        migratedReactions.add(o);
+        const cf = ov.data[fk];
+        const cfParent = ovParent.data[fk];
+        if (cf.isComputed) {
+            const migrated = TransactionImpl.migrateContentFootprint(cf, tParent);
+            if (ovParent.former.objectVersion.data[fk] !== cfParent) {
+                let subscribers = cfParent.subscribers;
+                if (subscribers) {
+                    const migratedSubscribers = migrated.subscribers = new Set();
+                    subscribers.forEach(o => {
+                        const conformingObservables = o.observables;
+                        const sub = conformingObservables.get(cfParent);
+                        conformingObservables.delete(cfParent);
+                        conformingObservables.set(migrated, sub);
+                        migratedSubscribers.add(o);
                     });
-                    fvParent.reactions = undefined;
+                    cfParent.subscribers = undefined;
                 }
-                reactions = fv.reactions;
-                if (reactions) {
-                    let migratedReactions = migrated.reactions;
-                    if (migratedReactions === undefined)
-                        migratedReactions = migrated.reactions = new Set();
-                    reactions.forEach(o => {
-                        const conformingTriggers = o.triggers;
-                        const sub = conformingTriggers.get(fv);
-                        conformingTriggers.delete(fv);
-                        conformingTriggers.set(migrated, sub);
-                        migratedReactions.add(o);
+                subscribers = cf.subscribers;
+                if (subscribers) {
+                    let migratedSubscribers = migrated.subscribers;
+                    if (migratedSubscribers === undefined)
+                        migratedSubscribers = migrated.subscribers = new Set();
+                    subscribers.forEach(o => {
+                        const conformingObservables = o.observables;
+                        const sub = conformingObservables.get(cf);
+                        conformingObservables.delete(cf);
+                        conformingObservables.set(migrated, sub);
+                        migratedSubscribers.add(o);
                     });
-                    fv.reactions = undefined;
+                    cf.subscribers = undefined;
                 }
-                const triggers = fv.triggers;
-                const migratedTriggers = migrated.triggers;
-                if (triggers) {
-                    triggers.forEach((s, o) => {
-                        const conformingReactions = o.reactions;
-                        conformingReactions.delete(fv);
-                        conformingReactions.add(migrated);
-                        migratedTriggers.set(o, s);
+                const observables = cf.observables;
+                const migratedObservables = migrated.observables;
+                if (observables) {
+                    observables.forEach((s, o) => {
+                        const conformingSubscribers = o.subscribers;
+                        conformingSubscribers.delete(cf);
+                        conformingSubscribers.add(migrated);
+                        migratedObservables.set(o, s);
                     });
-                    triggers.clear();
+                    observables.clear();
                 }
                 ovParent.data[fk] = migrated;
             }
             else {
-                const reactions = fv.reactions;
-                if (reactions) {
-                    const migratedReactions = migrated.reactions = new Set();
-                    reactions.forEach(o => {
-                        const conformingTriggers = o.triggers;
-                        const sub = conformingTriggers.get(fv);
-                        conformingTriggers.delete(fv);
-                        conformingTriggers.set(migrated, sub);
+                const subscribers = cf.subscribers;
+                if (subscribers) {
+                    const migratedReactions = migrated.subscribers = new Set();
+                    subscribers.forEach(o => {
+                        const conformingObservables = o.observables;
+                        const sub = conformingObservables.get(cf);
+                        conformingObservables.delete(cf);
+                        conformingObservables.set(migrated, sub);
                         migratedReactions.add(o);
                     });
-                    fv.reactions = undefined;
+                    cf.subscribers = undefined;
                 }
-                const triggers = fv.triggers;
-                const migratedTriggers = migrated.triggers;
-                if (triggers) {
-                    triggers.forEach((s, o) => {
-                        const conformingReactions = o.reactions;
-                        conformingReactions.delete(fv);
-                        conformingReactions.add(migrated);
-                        migratedTriggers.set(o, s);
+                const observables = cf.observables;
+                const migratedObservables = migrated.observables;
+                if (observables) {
+                    observables.forEach((s, o) => {
+                        const conformingSubscribers = o.subscribers;
+                        conformingSubscribers.delete(cf);
+                        conformingSubscribers.add(migrated);
+                        migratedObservables.set(o, s);
                     });
-                    triggers.clear();
+                    observables.clear();
                 }
                 ovParent.data[fk] = migrated;
             }
@@ -428,25 +428,25 @@ export class TransactionImpl extends Transaction {
             Changeset.markEdited(undefined, migrated, true, ovParent, fk, h);
         }
         else {
-            const parentContent = fvParent === null || fvParent === void 0 ? void 0 : fvParent.content;
-            if (ovParent.former.objectVersion.data[fk] !== fvParent) {
-                fvParent.content = fv.content;
-                const reactions = fv.reactions;
-                if (reactions) {
-                    if (fvParent.reactions === undefined)
-                        fvParent.reactions = new Set();
-                    reactions.forEach(o => {
-                        const conformingTriggers = o.triggers;
-                        const sub = conformingTriggers.get(fv);
-                        conformingTriggers.delete(fv);
-                        conformingTriggers.set(fvParent, sub);
-                        fvParent.reactions.add(o);
+            const parentContent = cfParent === null || cfParent === void 0 ? void 0 : cfParent.content;
+            if (ovParent.former.objectVersion.data[fk] !== cfParent) {
+                cfParent.content = cf.content;
+                const subscribers = cf.subscribers;
+                if (subscribers) {
+                    if (cfParent.subscribers === undefined)
+                        cfParent.subscribers = new Set();
+                    subscribers.forEach(o => {
+                        const conformingObservables = o.observables;
+                        const sub = conformingObservables.get(cf);
+                        conformingObservables.delete(cf);
+                        conformingObservables.set(cfParent, sub);
+                        cfParent.subscribers.add(o);
                     });
                 }
             }
             else
-                ovParent.data[fk] = fv;
-            Changeset.markEdited(parentContent, fv.content, true, ovParent, fk, h);
+                ovParent.data[fk] = cf;
+            Changeset.markEdited(parentContent, cf.content, true, ovParent, fk, h);
         }
     }
     acquirePromise() {
@@ -479,7 +479,7 @@ TransactionImpl.gCurr = TransactionImpl.none;
 TransactionImpl.isInspectionMode = false;
 TransactionImpl.frameStartTime = 0;
 TransactionImpl.frameOverCounter = 0;
-TransactionImpl.migrateFieldVersion = function (fv, target) {
-    throw misuse("this implementation of cloneLaunch should never be called");
+TransactionImpl.migrateContentFootprint = function (fv, target) {
+    throw misuse("this implementation of migrateContentFootprint should never be called");
 };
 TransactionImpl._init();

package/build/dist/source/core/Tree.d.ts

@@ -0,0 +1,26 @@
+import { Priority, Mode } from "../Enums.js";
+import { ReactiveTreeNodeDriver, ReactiveTreeNodeDecl, Script, ScriptAsync, Handler, ReactiveTreeNode } from "./TreeNode.js";
+import { LoggingOptions } from "../Logging.js";
+export declare class ReactiveTree {
+    static declare<E = void>(driver: ReactiveTreeNodeDriver<E>, script?: Script<E>, scriptAsync?: ScriptAsync<E>, key?: string, mode?: Mode, preparation?: Script<E>, preparationAsync?: ScriptAsync<E>, finalization?: Script<E>, triggers?: unknown, basis?: ReactiveTreeNodeDecl<E>): ReactiveTreeNode<E>;
+    static declare<E = void>(driver: ReactiveTreeNodeDriver<E>, declaration?: ReactiveTreeNodeDecl<E>): ReactiveTreeNode<E>;
+    static declare<E = void>(driver: ReactiveTreeNodeDriver<E>, scriptOrDeclaration?: Script<E> | ReactiveTreeNodeDecl<E>, scriptAsync?: ScriptAsync<E>, key?: string, mode?: Mode, preparation?: Script<E>, preparationAsync?: ScriptAsync<E>, finalization?: Script<E>, triggers?: unknown, basis?: ReactiveTreeNodeDecl<E>): ReactiveTreeNode<E>;
+    static withBasis<E = void>(declaration?: ReactiveTreeNodeDecl<E>, basis?: ReactiveTreeNodeDecl<E>): ReactiveTreeNodeDecl<E>;
+    static get isFirstScriptRun(): boolean;
+    static get key(): string;
+    static get stamp(): number;
+    static get triggers(): unknown;
+    static get priority(): Priority;
+    static set priority(value: Priority);
+    static get childrenShuffling(): boolean;
+    static set childrenShuffling(value: boolean);
+    static triggerScriptRun(node: ReactiveTreeNode<any>, triggers: unknown): void;
+    static triggerFinalization(node: ReactiveTreeNode<any>): void;
+    static runNestedNodeScriptsThenDo(action: (error: unknown) => void): void;
+    static markAsMounted(node: ReactiveTreeNode<any>, yes: boolean): void;
+    static findMatchingHost<E = unknown, R = unknown>(node: ReactiveTreeNode<E>, match: Handler<ReactiveTreeNode<E>, boolean>): ReactiveTreeNode<R> | undefined;
+    static findMatchingPrevSibling<E = unknown, R = unknown>(node: ReactiveTreeNode<E>, match: Handler<ReactiveTreeNode<E>, boolean>): ReactiveTreeNode<R> | undefined;
+    static forEachChildRecursively<E = unknown>(node: ReactiveTreeNode<E>, action: Handler<ReactiveTreeNode<E>>): void;
+    static getDefaultLoggingOptions(): LoggingOptions | undefined;
+    static setDefaultLoggingOptions(logging?: LoggingOptions): void;
+}

package/build/dist/source/core/Tree.js

@@ -0,0 +1,120 @@
+import { Mode } from "../Enums.js";
+import { generateKey, observablesAreEqual } from "./TreeNode.js";
+import { MergeList } from "../util/MergeList.js";
+export class ReactiveTree {
+    static declare(driver, scriptOrDeclaration, scriptAsync, key, mode, preparation, preparationAsync, finalization, triggers, basis) {
+        let result;
+        let declaration;
+        if (scriptOrDeclaration instanceof Function) {
+            declaration = {
+                script: scriptOrDeclaration, scriptAsync, key, mode,
+                preparation, preparationAsync, finalization, triggers, basis,
+            };
+        }
+        else
+            declaration = scriptOrDeclaration !== null && scriptOrDeclaration !== void 0 ? scriptOrDeclaration : {};
+        let effectiveKey = declaration.key;
+        const owner = (getModeUsingBasisChain(declaration) & Mode.rootNode) !== Mode.rootNode ? gNodeSlot === null || gNodeSlot === void 0 ? void 0 : gNodeSlot.instance : undefined;
+        if (owner) {
+            let existing = owner.driver.declareChild(owner, driver, declaration, declaration.basis);
+            const children = owner.children;
+            existing !== null && existing !== void 0 ? existing : (existing = children.tryMergeAsExisting(effectiveKey = effectiveKey || generateKey(owner), undefined, "nested elements can be declared inside 'script' only"));
+            if (existing) {
+                result = existing.instance;
+                if (result.driver !== driver && driver !== undefined)
+                    throw new Error(`changing element driver is not yet supported: "${result.driver.name}" -> "${driver === null || driver === void 0 ? void 0 : driver.name}"`);
+                const exTriggers = result.declaration.triggers;
+                if (observablesAreEqual(declaration.triggers, exTriggers))
+                    declaration.triggers = exTriggers;
+                result.declaration = declaration;
+            }
+            else {
+                result = new ReactiveTreeNodeImpl(effectiveKey || generateKey(owner), driver, declaration, owner);
+                result.slot = children.mergeAsAdded(result);
+            }
+        }
+        else {
+            result = new ReactiveTreeNodeImpl(effectiveKey || "", driver, declaration, owner);
+            result.slot = MergeList.createItem(result);
+            triggerScriptRunViaSlot(result.slot);
+        }
+        return result;
+    }
+    static withBasis(declaration, basis) {
+        if (declaration)
+            declaration.basis = basis;
+        else
+            declaration = basis !== null && basis !== void 0 ? basis : {};
+        return declaration;
+    }
+    static get isFirstScriptRun() {
+        return ReactiveTreeNodeImpl.nodeSlot.instance.stamp === 1;
+    }
+    static get key() {
+        return ReactiveTreeNodeImpl.nodeSlot.instance.key;
+    }
+    static get stamp() {
+        return ReactiveTreeNodeImpl.nodeSlot.instance.stamp;
+    }
+    static get triggers() {
+        return ReactiveTreeNodeImpl.nodeSlot.instance.declaration.triggers;
+    }
+    static get priority() {
+        return ReactiveTreeNodeImpl.nodeSlot.instance.priority;
+    }
+    static set priority(value) {
+        ReactiveTreeNodeImpl.nodeSlot.instance.priority = value;
+    }
+    static get childrenShuffling() {
+        return ReactiveTreeNodeImpl.nodeSlot.instance.childrenShuffling;
+    }
+    static set childrenShuffling(value) {
+        ReactiveTreeNodeImpl.nodeSlot.instance.childrenShuffling = value;
+    }
+    static triggerScriptRun(node, triggers) {
+        const impl = node;
+        const declaration = impl.declaration;
+        if (!observablesAreEqual(triggers, declaration.triggers)) {
+            declaration.triggers = triggers;
+            triggerScriptRunViaSlot(impl.slot);
+        }
+    }
+    static triggerFinalization(node) {
+        const impl = node;
+        triggerFinalization(impl.slot, true, true);
+    }
+    static runNestedNodeScriptsThenDo(action) {
+        runNestedNodeScriptsThenDoImpl(ReactiveTreeNodeImpl.nodeSlot, undefined, action);
+    }
+    static markAsMounted(node, yes) {
+        const n = node;
+        if (n.stamp < 0)
+            throw new Error("deactivated node cannot be mounted or unmounted");
+        if (n.stamp >= Number.MAX_SAFE_INTEGER)
+            throw new Error("node must be activated before mounting");
+        n.stamp = yes ? 0 : Number.MAX_SAFE_INTEGER - 1;
+    }
+    static findMatchingHost(node, match) {
+        let p = node.host;
+        while (p !== p.host && !match(p))
+            p = p.host;
+        return p;
+    }
+    static findMatchingPrevSibling(node, match) {
+        let p = node.slot.prev;
+        while (p && !match(p.instance))
+            p = p.prev;
+        return p === null || p === void 0 ? void 0 : p.instance;
+    }
+    static forEachChildRecursively(node, action) {
+        action(node);
+        for (const child of node.children.items())
+            ReactiveTree.forEachChildRecursively(child.instance, action);
+    }
+    static getDefaultLoggingOptions() {
+        return ReactiveTreeNodeImpl.logging;
+    }
+    static setDefaultLoggingOptions(logging) {
+        ReactiveTreeNodeImpl.logging = logging;
+    }
+}

package/build/dist/source/core/TreeNode.d.ts

@@ -0,0 +1,117 @@
+import { LoggingOptions } from "../Logging.js";
+import { MergeList, MergeListReader, MergedItem } from "../util/MergeList.js";
+import { Priority, Mode } from "../Enums.js";
+import { ReactivityOptions } from "../Options.js";
+import { ObservableObject } from "../core/Mvcc.js";
+export type Script<E> = (el: E, basis: () => void) => void;
+export type ScriptAsync<E> = (el: E, basis: () => Promise<void>) => Promise<void>;
+export type Handler<E = unknown, R = void> = (el: E) => R;
+export declare abstract class ReactiveTreeNode<E = unknown> {
+    abstract readonly key: string;
+    abstract readonly driver: ReactiveTreeNodeDriver<E>;
+    abstract readonly declaration: Readonly<ReactiveTreeNodeDecl<E>>;
+    abstract readonly level: number;
+    abstract readonly owner: ReactiveTreeNode;
+    abstract element: E;
+    abstract readonly host: ReactiveTreeNode;
+    abstract readonly children: MergeListReader<ReactiveTreeNode>;
+    abstract readonly slot: MergedItem<ReactiveTreeNode<E>> | undefined;
+    abstract readonly stamp: number;
+    abstract readonly outer: ReactiveTreeNode;
+    abstract readonly context: ReactiveTreeNodeContext | undefined;
+    abstract priority?: Priority;
+    abstract childrenShuffling: boolean;
+    abstract strictOrder: boolean;
+    abstract has(mode: Mode): boolean;
+    abstract configureReactronic(options: Partial<ReactivityOptions>): ReactivityOptions;
+}
+export type ReactiveTreeNodeDecl<E = unknown> = {
+    script?: Script<E>;
+    scriptAsync?: ScriptAsync<E>;
+    key?: string;
+    mode?: Mode;
+    preparation?: Script<E>;
+    preparationAsync?: ScriptAsync<E>;
+    finalization?: Script<E>;
+    triggers?: unknown;
+    basis?: ReactiveTreeNodeDecl<E>;
+};
+export type ReactiveTreeNodeDriver<E = unknown> = {
+    readonly name: string;
+    readonly isPartition: boolean;
+    readonly initialize?: Handler<E>;
+    create(node: ReactiveTreeNode<E>): E;
+    runPreparation(node: ReactiveTreeNode<E>): void;
+    runFinalization(node: ReactiveTreeNode<E>, isLeader: boolean): boolean;
+    runMount(node: ReactiveTreeNode<E>): void;
+    runScript(node: ReactiveTreeNode<E>): void | Promise<void>;
+    declareChild(ownerNode: ReactiveTreeNode<E>, childDriver: ReactiveTreeNodeDriver<any>, childDeclaration?: ReactiveTreeNodeDecl<any>, childBasis?: ReactiveTreeNodeDecl<any>): MergedItem<ReactiveTreeNode> | undefined;
+    provideHost(node: ReactiveTreeNode<E>): ReactiveTreeNode<E>;
+};
+export type ReactiveTreeNodeContext<T extends Object = Object> = {
+    value: T;
+};
+export declare abstract class BaseDriver<E = unknown> implements ReactiveTreeNodeDriver<E> {
+    readonly name: string;
+    readonly isPartition: boolean;
+    readonly initialize?: Handler<E> | undefined;
+    constructor(name: string, isPartition: boolean, initialize?: Handler<E> | undefined);
+    abstract create(node: ReactiveTreeNode<E>): E;
+    runPreparation(node: ReactiveTreeNode<E>): void | Promise<void>;
+    runFinalization(node: ReactiveTreeNode<E>, isLeader: boolean): boolean;
+    runMount(node: ReactiveTreeNode<E>): void;
+    runScript(node: ReactiveTreeNode<E>): void | Promise<void>;
+    declareChild(ownerNode: ReactiveTreeNode<E>, childDriver: ReactiveTreeNodeDriver<any>, childDeclaration?: ReactiveTreeNodeDecl<any>, childBasis?: ReactiveTreeNodeDecl<any>): MergedItem<ReactiveTreeNode> | undefined;
+    provideHost(node: ReactiveTreeNode<E>): ReactiveTreeNode<E>;
+}
+export declare class ReactiveTreeVariable<T extends Object = Object> {
+    readonly defaultValue: T | undefined;
+    constructor(defaultValue?: T);
+    set value(value: T);
+    get value(): T;
+    get valueOrUndefined(): T | undefined;
+}
+export declare function generateKey(owner: ReactiveTreeNodeImpl): string;
+declare class ReactiveTreeNodeContextImpl<T extends Object = Object> extends ObservableObject implements ReactiveTreeNodeContext<T> {
+    next: ReactiveTreeNodeContextImpl<object> | undefined;
+    variable: ReactiveTreeVariable<T>;
+    value: T;
+    constructor(variable: ReactiveTreeVariable<T>, value: T);
+}
+declare class ReactiveTreeNodeImpl<E = unknown> extends ReactiveTreeNode<E> {
+    static logging: LoggingOptions | undefined;
+    static grandNodeCount: number;
+    static disposableNodeCount: number;
+    static readonly shortFrameDuration = 16;
+    static readonly longFrameDuration = 300;
+    static currentScriptPriority: Priority;
+    static frameDuration: number;
+    readonly key: string;
+    readonly driver: ReactiveTreeNodeDriver<E>;
+    declaration: ReactiveTreeNodeDecl<E>;
+    readonly level: number;
+    readonly owner: ReactiveTreeNodeImpl;
+    readonly element: E;
+    host: ReactiveTreeNodeImpl;
+    readonly children: MergeList<ReactiveTreeNodeImpl>;
+    slot: MergedItem<ReactiveTreeNodeImpl<E>> | undefined;
+    stamp: number;
+    outer: ReactiveTreeNodeImpl;
+    context: ReactiveTreeNodeContextImpl<any> | undefined;
+    numerator: number;
+    priority: Priority;
+    childrenShuffling: boolean;
+    constructor(key: string, driver: ReactiveTreeNodeDriver<E>, declaration: Readonly<ReactiveTreeNodeDecl<E>>, owner: ReactiveTreeNodeImpl | undefined);
+    get strictOrder(): boolean;
+    set strictOrder(value: boolean);
+    get isMoved(): boolean;
+    has(mode: Mode): boolean;
+    script(_triggers: unknown): void;
+    configureReactronic(options: Partial<ReactivityOptions>): ReactivityOptions;
+    static get nodeSlot(): MergedItem<ReactiveTreeNodeImpl>;
+    static tryUseNodeVariableValue<T extends Object>(variable: ReactiveTreeVariable<T>): T | undefined;
+    static useNodeVariableValue<T extends Object>(variable: ReactiveTreeVariable<T>): T;
+    static setNodeVariableValue<T extends Object>(variable: ReactiveTreeVariable<T>, value: T | undefined): void;
+}
+export declare function observablesAreEqual(a1: any, a2: any): boolean;
+export {};