reactronic 0.24.275 → 0.24.301

package/README.md

@@ -310,7 +310,7 @@ function sensitive<T>(sensitivity: Sensitivity, func: F<T>, ...args: any[]): T
 
 export type SnapshotOptions = {
   readonly hint?: string
-  readonly separation?: SeparationMode
+  readonly isolation?: Isolation
   readonly journal?: Journal
   readonly logging?: Partial<LoggingOptions>
   readonly token?: any
@@ -318,7 +318,7 @@ export type SnapshotOptions = {
 
 type MemberOptions = {
   readonly kind: Kind
-  readonly separation: SeparationMode
+  readonly isolation: Isolation
   readonly order: number
   readonly noSideEffects: boolean
   readonly triggeringArgs: boolean

package/build/dist/source/Options.d.ts

@@ -1,19 +1,18 @@
 import { LoggingOptions } from "./Logging.js";
-import { SeparationMode } from "./core/Data.js";
 export { LoggingLevel } from "./Logging.js";
 export type { LoggingOptions, ProfilingOptions } from "./Logging.js";
 import { Journal } from "./core/Journal.js";
 import { Indicator } from "./core/Indicator.js";
 export type SnapshotOptions = {
     readonly hint?: string;
-    readonly separation?: SeparationMode;
+    readonly isolation?: Isolation;
     readonly journal?: Journal;
     readonly logging?: Partial<LoggingOptions>;
     readonly token?: any;
 };
 export type MemberOptions = {
     readonly kind: Kind;
-    readonly separation: SeparationMode;
+    readonly isolation: Isolation;
     readonly order: number;
     readonly noSideEffects: boolean;
     readonly triggeringArgs: boolean;
@@ -37,7 +36,14 @@ export declare enum Reentrance {
     overwritePrevious = -3,
     runSideBySide = -4
 }
-export type AbstractReaction<T> = {
+export declare enum Isolation {
+    joinToCurrentTransaction = 0,
+    joinAsNestedTransaction = 1,
+    disjoinFromOuterTransaction = 2,
+    disjoinFromOuterAndInnerTransactions = 3,
+    disjoinForInternalDisposal = 4
+}
+export type Operation<T> = {
     readonly options: MemberOptions;
     readonly args: ReadonlyArray<any>;
     readonly result: T;

package/build/dist/source/Options.js

@@ -15,3 +15,11 @@ export var Reentrance;
     Reentrance[Reentrance["overwritePrevious"] = -3] = "overwritePrevious";
     Reentrance[Reentrance["runSideBySide"] = -4] = "runSideBySide";
 })(Reentrance || (Reentrance = {}));
+export var Isolation;
+(function (Isolation) {
+    Isolation[Isolation["joinToCurrentTransaction"] = 0] = "joinToCurrentTransaction";
+    Isolation[Isolation["joinAsNestedTransaction"] = 1] = "joinAsNestedTransaction";
+    Isolation[Isolation["disjoinFromOuterTransaction"] = 2] = "disjoinFromOuterTransaction";
+    Isolation[Isolation["disjoinFromOuterAndInnerTransactions"] = 3] = "disjoinFromOuterAndInnerTransactions";
+    Isolation[Isolation["disjoinForInternalDisposal"] = 4] = "disjoinForInternalDisposal";
+})(Isolation || (Isolation = {}));

package/build/dist/source/RxSystem.d.ts

@@ -1,8 +1,8 @@
 import { F } from "./util/Utils.js";
-import { AbstractReaction, MemberOptions, LoggingOptions, ProfilingOptions } from "./Options.js";
+import { Operation, MemberOptions, LoggingOptions, ProfilingOptions } from "./Options.js";
 export declare class RxSystem {
     static why(brief?: boolean): string;
-    static getReaction<T>(method: F<T>): AbstractReaction<T>;
+    static getOperation<T>(method: F<T>): Operation<T>;
     static pullLastResult<T>(method: F<Promise<T>>, args?: any[]): T | undefined;
     static configureCurrentOperation(options: Partial<MemberOptions>): MemberOptions;
     static getRevisionOf(obj: any): number;

package/build/dist/source/RxSystem.js

@@ -1,15 +1,15 @@
 import { Log } from "./util/Dbg.js";
-import { Kind } from "./Options.js";
+import { Kind, Isolation } from "./Options.js";
 import { Meta, ObjectHandle } from "./core/Data.js";
 import { Changeset } from "./core/Changeset.js";
 import { Mvcc } from "./core/Mvcc.js";
 import { Transaction } from "./core/Transaction.js";
-import { ReactionImpl } from "./core/Reaction.js";
+import { OperationImpl } from "./core/Operation.js";
 export class RxSystem {
-    static why(brief = false) { return brief ? ReactionImpl.briefWhy() : ReactionImpl.why(); }
-    static getReaction(method) { return ReactionImpl.getControllerOf(method); }
-    static pullLastResult(method, args) { return RxSystem.getReaction(method).pullLastResult(args); }
-    static configureCurrentOperation(options) { return ReactionImpl.configureImpl(undefined, options); }
+    static why(brief = false) { return brief ? OperationImpl.briefWhy() : OperationImpl.why(); }
+    static getOperation(method) { return OperationImpl.getControllerOf(method); }
+    static pullLastResult(method, args) { return RxSystem.getOperation(method).pullLastResult(args); }
+    static configureCurrentOperation(options) { return OperationImpl.configureImpl(undefined, options); }
     static getRevisionOf(obj) { return obj[Meta.Revision]; }
     static takeSnapshot(obj) { return Changeset.takeSnapshot(obj); }
     static dispose(obj) { Changeset.dispose(obj); }
@@ -26,7 +26,7 @@ export function transaction(action, ...args) {
     return Transaction.run(null, action, ...args);
 }
 export function unobs(func, ...args) {
-    return ReactionImpl.proceedWithinGivenLaunch(undefined, func, ...args);
+    return OperationImpl.proceedWithinGivenLaunch(undefined, func, ...args);
 }
 export function sensitive(sensitivity, func, ...args) {
     return Mvcc.sensitive(sensitivity, func, ...args);
@@ -38,15 +38,26 @@ export function obs(proto, prop) {
     return Mvcc.decorateData(true, proto, prop);
 }
 export function transactional(proto, prop, pd) {
-    const opts = { kind: Kind.transactional };
+    const opts = {
+        kind: Kind.transactional,
+        isolation: Isolation.joinToCurrentTransaction,
+    };
     return Mvcc.decorateOperation(true, transactional, opts, proto, prop, pd);
 }
 export function reactive(proto, prop, pd) {
-    const opts = { kind: Kind.reactive, throttling: -1 };
+    const opts = {
+        kind: Kind.reactive,
+        isolation: Isolation.joinAsNestedTransaction,
+        throttling: -1,
+    };
     return Mvcc.decorateOperation(true, reactive, opts, proto, prop, pd);
 }
 export function cached(proto, prop, pd) {
-    const opts = { kind: Kind.cached, noSideEffects: true };
+    const opts = {
+        kind: Kind.cached,
+        isolation: Isolation.joinToCurrentTransaction,
+        noSideEffects: true,
+    };
     return Mvcc.decorateOperation(true, cached, opts, proto, prop, pd);
 }
 export function options(value) {

package/build/dist/source/api.d.ts

@@ -4,8 +4,8 @@ export type { MergedItem, MergeListReader } from "./util/MergeList.js";
 export { SealedArray } from "./util/SealedArray.js";
 export { SealedMap } from "./util/SealedMap.js";
 export { SealedSet } from "./util/SealedSet.js";
-export { Kind, Reentrance, LoggingLevel } from "./Options.js";
-export type { AbstractReaction, MemberOptions, SnapshotOptions, LoggingOptions, ProfilingOptions } from "./Options.js";
+export { Kind, Reentrance, Isolation, LoggingLevel } from "./Options.js";
+export type { Operation, MemberOptions, SnapshotOptions, LoggingOptions, ProfilingOptions } from "./Options.js";
 export type { Worker } from "./Worker.js";
 export { Ref, ToggleRef, refs, toggleRefs, customToggleRefs } from "./Ref.js";
 export type { BoolOnly, GivenTypeOnly } from "./Ref.js";

package/build/dist/source/api.js

@@ -3,7 +3,7 @@ export { MergeList } from "./util/MergeList.js";
 export { SealedArray } from "./util/SealedArray.js";
 export { SealedMap } from "./util/SealedMap.js";
 export { SealedSet } from "./util/SealedSet.js";
-export { Kind, Reentrance, LoggingLevel } from "./Options.js";
+export { Kind, Reentrance, Isolation, LoggingLevel } from "./Options.js";
 export { Ref, ToggleRef, refs, toggleRefs, customToggleRefs } from "./Ref.js";
 export { TransactionalObject, ObservableObject } from "./core/Mvcc.js";
 export { TransactionalArray, ObservableArray } from "./core/MvccArray.js";

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

@@ -1,5 +1,5 @@
 import { Kind, SnapshotOptions } from "../Options.js";
-import { AbstractChangeset, ObjectSnapshot, MemberName, ObjectHandle, ValueSnapshot, Observer } from "./Data.js";
+import { AbstractChangeset, ObjectVersion, FieldKey, ObjectHandle, FieldVersion, Observer } from "./Data.js";
 export declare const MAX_REVISION: number;
 export declare const UNDEFINED_REVISION: number;
 export declare class Changeset implements AbstractChangeset {
@@ -13,48 +13,50 @@ export declare class Changeset implements AbstractChangeset {
     static totalObjectSnapshotCount: number;
     readonly id: number;
     readonly options: SnapshotOptions;
+    readonly parent?: Changeset;
     get hint(): string;
     get timestamp(): number;
     private revision;
     private bumper;
-    items: Map<ObjectHandle, ObjectSnapshot>;
+    items: Map<ObjectHandle, ObjectVersion>;
     obsolete: Observer[];
     sealed: boolean;
-    constructor(options: SnapshotOptions | null);
+    constructor(options: SnapshotOptions | null, parent?: Changeset);
     static current: () => Changeset;
     static edit: () => Changeset;
-    static markUsed: (observable: ValueSnapshot, os: ObjectSnapshot, m: MemberName, h: ObjectHandle, kind: Kind, weak: boolean) => void;
-    static markEdited: (oldValue: any, newValue: any, edited: boolean, os: ObjectSnapshot, m: MemberName, h: ObjectHandle) => void;
+    static markUsed: (fv: FieldVersion, ov: ObjectVersion, fk: FieldKey, h: ObjectHandle, kind: Kind, weak: boolean) => void;
+    static markEdited: (oldValue: any, newValue: any, edited: boolean, ov: ObjectVersion, fk: FieldKey, h: ObjectHandle) => void;
     static isConflicting: (oldValue: any, newValue: any) => boolean;
     static propagateAllChangesThroughSubscriptions: (changeset: Changeset) => void;
     static revokeAllSubscriptions: (changeset: Changeset) => void;
     static enqueueReactiveFunctionsToRun: (reactive: Array<Observer>) => void;
-    lookupObjectSnapshot(h: ObjectHandle, m: MemberName): ObjectSnapshot;
-    getObjectSnapshot(h: ObjectHandle, m: MemberName): ObjectSnapshot;
-    getEditableObjectSnapshot(h: ObjectHandle, m: MemberName, value: any, token?: any): ObjectSnapshot;
+    lookupObjectVersion(h: ObjectHandle, fk: FieldKey, editing: boolean): ObjectVersion;
+    getObjectVersion(h: ObjectHandle, fk: FieldKey): ObjectVersion;
+    getEditableObjectVersion(h: ObjectHandle, fk: FieldKey, value: any, token?: any): ObjectVersion;
+    setFieldContent(h: ObjectHandle, fk: FieldKey, ov: ObjectVersion, content: any, receiver: any, sensitivity: boolean): void;
     static takeSnapshot<T>(obj: T): T;
     static dispose(obj: any): void;
-    static doDispose(ctx: Changeset, h: ObjectHandle): ObjectSnapshot;
-    private isNewSnapshotRequired;
+    static doDispose(ctx: Changeset, h: ObjectHandle): ObjectVersion;
+    private isNewObjectVersionRequired;
     acquire(outer: Changeset): void;
     bumpBy(timestamp: number): void;
-    rebase(): ObjectSnapshot[] | undefined;
+    rebase(): ObjectVersion[] | undefined;
     private merge;
-    applyOrDiscard(error?: any): Array<Observer>;
-    static sealObjectSnapshot(h: ObjectHandle, os: ObjectSnapshot): void;
-    static sealValueSnapshot(o: ValueSnapshot | symbol, m: MemberName, typeName: string): void;
-    static freezeObjectSnapshot(os: ObjectSnapshot): ObjectSnapshot;
+    seal(): void;
+    sealObjectVersion(h: ObjectHandle, ov: ObjectVersion): void;
+    static sealFieldVersion(fv: FieldVersion | symbol, fk: FieldKey, typeName: string): void;
+    static freezeObjectVersion(ov: ObjectVersion): ObjectVersion;
     triggerGarbageCollection(): void;
     private unlinkHistory;
     static _init(): void;
 }
 export declare class Dump {
     static valueHint: (value: any) => string;
-    static obj(h: ObjectHandle | undefined, m?: MemberName | undefined, stamp?: number, snapshotId?: number, originSnapshotId?: number, value?: any): string;
-    static snapshot2(h: ObjectHandle, s: AbstractChangeset, m?: MemberName, o?: ValueSnapshot): string;
-    static snapshot(os: ObjectSnapshot, m?: MemberName): string;
-    static conflicts(conflicts: ObjectSnapshot[]): string;
-    static conflictingMemberHint(m: MemberName, ours: ObjectSnapshot, theirs: ObjectSnapshot): string;
+    static obj(h: ObjectHandle | undefined, fk?: FieldKey | undefined, stamp?: number, snapshotId?: number, originSnapshotId?: number, value?: any): string;
+    static snapshot2(h: ObjectHandle, s: AbstractChangeset, fk?: FieldKey, o?: FieldVersion): string;
+    static snapshot(ov: ObjectVersion, fk?: FieldKey): string;
+    static conflicts(conflicts: ObjectVersion[]): string;
+    static conflictingMemberHint(fk: FieldKey, ours: ObjectVersion, theirs: ObjectVersion): string;
 }
-export declare const EMPTY_SNAPSHOT: ObjectSnapshot;
+export declare const EMPTY_OBJECT_VERSION: ObjectVersion;
 export declare const DefaultSnapshotOptions: SnapshotOptions;