reactronic 0.22.504 → 0.22.506

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

@@ -4,6 +4,15 @@ export declare type BoolOnly<T> = Pick<T, {
 export declare type GivenTypeOnly<T, V> = Pick<T, {
     [P in keyof T]: T[P] extends V ? P : never;
 }[keyof T]>;
+export declare function refs<O extends object = object>(owner: O): {
+    readonly [P in keyof O]-?: Ref<O[P]>;
+};
+export declare function toggleRefs<O extends object = object>(owner: O): {
+    readonly [P in keyof BoolOnly<O>]: ToggleRef<O[P]>;
+};
+export declare function customToggleRefs<T, O extends object = any>(owner: O, value1: T, value2: T): {
+    readonly [P in keyof GivenTypeOnly<O, T | any>]: ToggleRef<O[P]>;
+};
 export declare class Ref<T = any> {
     readonly owner: any;
     readonly name: string;
@@ -14,15 +23,6 @@ export declare class Ref<T = any> {
     unobservable(): T;
     observe(): T;
     unobserve(): T;
-    static to<O extends object = object>(owner: O): {
-        readonly [P in keyof O]-?: Ref<O[P]>;
-    };
-    static toToggle<O extends object = object>(owner: O): {
-        readonly [P in keyof BoolOnly<O>]: ToggleRef<O[P]>;
-    };
-    static toCustomToggle<T, O extends object = any>(owner: O, value1: T, value2: T): {
-        readonly [P in keyof GivenTypeOnly<O, T | any>]: ToggleRef<O[P]>;
-    };
     static sameRefs(v1: Ref, v2: Ref): boolean;
     static similarRefs(v1: Ref, v2: Ref): boolean;
 }

package/build/dist/source/Ref.js

@@ -1,5 +1,15 @@
 import { Transaction } from './impl/Transaction';
 import { nonreactive } from './Rx';
+export function refs(owner) {
+    return new Proxy(owner, RefGettingProxy);
+}
+export function toggleRefs(owner) {
+    return new Proxy(owner, BoolRefGettingProxy);
+}
+export function customToggleRefs(owner, value1, value2) {
+    const handler = new CustomToggleRefGettingProxy(value1, value2);
+    return new Proxy(owner, handler);
+}
 export class Ref {
     constructor(owner, name, index = -1) {
         this.owner = owner;
@@ -27,16 +37,6 @@ export class Ref {
     unobserve() {
         throw new Error('not implemented');
     }
-    static to(owner) {
-        return new Proxy(owner, RefGettingProxy);
-    }
-    static toToggle(owner) {
-        return new Proxy(owner, BoolRefGettingProxy);
-    }
-    static toCustomToggle(owner, value1, value2) {
-        const handler = new CustomToggleRefGettingProxy(value1, value2);
-        return new Proxy(owner, handler);
-    }
     static sameRefs(v1, v2) {
         return v1.owner === v2.owner && v1.name === v2.name && v1.index === v2.index;
     }

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

@@ -21,6 +21,7 @@ export declare class Rx {
 export declare function nonreactive<T>(func: F<T>, ...args: any[]): T;
 export declare function sensitive<T>(sensitivity: boolean, func: F<T>, ...args: any[]): T;
 export declare function raw(proto: object, prop: PropertyKey): any;
+export declare function observable(proto: object, prop: PropertyKey): any;
 export declare function transactional(proto: object, prop: PropertyKey, pd: PropertyDescriptor): any;
 export declare function reactive(proto: object, prop: PropertyKey, pd: PropertyDescriptor): any;
 export declare function cached(proto: object, prop: PropertyKey, pd: PropertyDescriptor): any;

package/build/dist/source/Rx.js

@@ -30,6 +30,9 @@ export function sensitive(sensitivity, func, ...args) {
 export function raw(proto, prop) {
     return Mvcc.decorateData(false, proto, prop);
 }
+export function observable(proto, prop) {
+    return Mvcc.decorateData(true, proto, prop);
+}
 export function transactional(proto, prop, pd) {
     const opts = { kind: Kind.Transactional };
     return Mvcc.decorateOperation(true, transactional, opts, proto, prop, pd);

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

@@ -17,4 +17,4 @@ export { Changeset } from './impl/Changeset';
 export { Transaction } from './impl/Transaction';
 export { Monitor } from './impl/Monitor';
 export { Journal } from './impl/Journal';
-export { Rx, raw, transactional, reactive, cached, nonreactive, sensitive, options } from './Rx';
+export { Rx, raw, observable, transactional, reactive, cached, nonreactive, sensitive, options } from './Rx';

package/build/dist/source/api.js

@@ -13,4 +13,4 @@ export { Changeset } from './impl/Changeset';
 export { Transaction } from './impl/Transaction';
 export { Monitor } from './impl/Monitor';
 export { Journal } from './impl/Journal';
-export { Rx, raw, transactional, reactive, cached, nonreactive, sensitive, options } from './Rx';
+export { Rx, raw, observable, transactional, reactive, cached, nonreactive, sensitive, options } from './Rx';

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

@@ -1,5 +1,5 @@
 import { Kind, SnapshotOptions } from '../Options';
-import { AbstractChangeset, ObjectSnapshot, MemberName, ObjectHandle, Subscription, Subscriber } from './Data';
+import { AbstractChangeset, ObjectSnapshot, MemberName, ObjectHandle, Observable, Observer } from './Data';
 export declare const MAX_REVISION: number;
 export declare const UNDEFINED_REVISION: number;
 export declare class Changeset implements AbstractChangeset {
@@ -18,17 +18,17 @@ export declare class Changeset implements AbstractChangeset {
     private revision;
     private bumper;
     items: Map<ObjectHandle, ObjectSnapshot>;
-    reactive: Subscriber[];
+    reactive: Observer[];
     sealed: boolean;
     constructor(options: SnapshotOptions | null);
     static current: () => Changeset;
     static edit: () => Changeset;
-    static markUsed: (subscription: Subscription, os: ObjectSnapshot, m: MemberName, h: ObjectHandle, kind: Kind, weak: boolean) => void;
+    static markUsed: (observable: Observable, 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 isConflicting: (oldValue: any, newValue: any) => boolean;
     static propagateAllChangesThroughSubscriptions: (changeset: Changeset) => void;
     static revokeAllSubscriptions: (changeset: Changeset) => void;
-    static enqueueReactiveFunctionsToRun: (reactive: Array<Subscriber>) => 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;
@@ -40,9 +40,9 @@ export declare class Changeset implements AbstractChangeset {
     bumpBy(timestamp: number): void;
     rebase(): ObjectSnapshot[] | undefined;
     private merge;
-    applyOrDiscard(error?: any): Array<Subscriber>;
+    applyOrDiscard(error?: any): Array<Observer>;
     static sealObjectSnapshot(h: ObjectHandle, os: ObjectSnapshot): void;
-    static sealSubscription(subscription: Subscription | symbol, m: MemberName, typeName: string): void;
+    static sealObservable(o: Observable | symbol, m: MemberName, typeName: string): void;
     static freezeObjectSnapshot(os: ObjectSnapshot): ObjectSnapshot;
     triggerGarbageCollection(): void;
     private unlinkHistory;
@@ -51,7 +51,7 @@ export declare class Changeset implements AbstractChangeset {
 export declare class Dump {
     static valueHint: (value: any, m?: MemberName) => 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?: Subscription): string;
+    static snapshot2(h: ObjectHandle, s: AbstractChangeset, m?: MemberName, o?: Observable): string;
     static snapshot(os: ObjectSnapshot, m?: MemberName): string;
     static conflicts(conflicts: ObjectSnapshot[]): string;
     static conflictingMemberHint(m: MemberName, ours: ObjectSnapshot, theirs: ObjectSnapshot): string;

package/build/dist/source/impl/Changeset.js

@@ -4,7 +4,7 @@ import { Sealant } from '../util/Sealant';
 import { SealedArray } from '../util/SealedArray';
 import { SealedMap } from '../util/SealedMap';
 import { SealedSet } from '../util/SealedSet';
-import { ObjectSnapshot, ObjectHandle, Subscription, Meta } from './Data';
+import { ObjectSnapshot, ObjectHandle, Observable, Meta } from './Data';
 export const MAX_REVISION = Number.MAX_SAFE_INTEGER;
 export const UNDEFINED_REVISION = MAX_REVISION - 1;
 Object.defineProperty(ObjectHandle.prototype, '#this#', {
@@ -14,7 +14,7 @@ Object.defineProperty(ObjectHandle.prototype, '#this#', {
         const data = Changeset.current().getObjectSnapshot(this, '#this#').data;
         for (const m in data) {
             const v = data[m];
-            if (v instanceof Subscription)
+            if (v instanceof Observable)
                 result[m] = v.content;
             else if (v === Meta.Raw)
                 result[m] = this.data[m];
@@ -67,7 +67,7 @@ export class Changeset {
                 const revision = m === Meta.Handle ? 1 : os.revision + 1;
                 const data = Object.assign({}, m === Meta.Handle ? value : os.data);
                 Meta.set(data, Meta.Handle, h);
-                Meta.set(data, Meta.Revision, new Subscription(revision));
+                Meta.set(data, Meta.Revision, new Observable(revision));
                 os = new ObjectSnapshot(this, os, data);
                 this.items.set(h, os);
                 h.editing = os;
@@ -218,20 +218,20 @@ export class Changeset {
     }
     static sealObjectSnapshot(h, os) {
         if (!os.disposed)
-            os.changes.forEach((o, m) => Changeset.sealSubscription(os.data[m], m, h.proxy.constructor.name));
+            os.changes.forEach((o, m) => Changeset.sealObservable(os.data[m], m, h.proxy.constructor.name));
         else
             for (const m in os.former.snapshot.data)
                 os.data[m] = Meta.Undefined;
         if (Log.isOn)
             Changeset.freezeObjectSnapshot(os);
     }
-    static sealSubscription(subscription, m, typeName) {
-        if (subscription instanceof Subscription) {
-            const value = subscription.content;
+    static sealObservable(o, m, typeName) {
+        if (o instanceof Observable) {
+            const value = o.content;
             if (value !== undefined && value !== null) {
                 const sealedType = Object.getPrototypeOf(value)[Sealant.SealedType];
                 if (sealedType)
-                    subscription.content = Sealant.seal(value, sealedType, typeName, m);
+                    o.content = Sealant.seal(value, sealedType, typeName, m);
             }
         }
     }

package/build/dist/source/impl/Data.d.ts

@@ -5,24 +5,24 @@ export interface AbstractChangeset {
     readonly timestamp: number;
     readonly sealed: boolean;
 }
-export declare class Subscription {
+export declare class Observable {
     content: any;
-    subscribers?: Set<Subscriber>;
+    observers?: Set<Observer>;
     get isOperation(): boolean;
     get originSnapshotId(): number | undefined;
     constructor(content: any);
 }
 export declare type SeparationMode = boolean | 'isolated' | 'disposal';
-export interface Subscriber {
+export interface Observer {
     readonly order: number;
-    readonly subscriptions: Map<Subscription, SubscriptionInfo> | undefined;
+    readonly observables: Map<Observable, Subscription> | undefined;
     readonly obsoleteSince: number;
     hint(nop?: boolean): string;
-    markObsoleteDueTo(subscription: Subscription, m: MemberName, changeset: AbstractChangeset, h: ObjectHandle, outer: string, since: number, reactive: Array<Subscriber>): void;
+    markObsoleteDueTo(observable: Observable, m: MemberName, changeset: AbstractChangeset, h: ObjectHandle, outer: string, since: number, reactive: Array<Observer>): void;
     runIfNotUpToDate(now: boolean, nothrow: boolean): void;
 }
 export declare type MemberName = PropertyKey;
-export interface SubscriptionInfo {
+export interface Subscription {
     readonly memberHint: string;
     readonly usageCount: number;
 }

package/build/dist/source/impl/Data.js

@@ -1,7 +1,7 @@
 import { Log } from '../util/Dbg';
 import { Meta } from './Meta';
 export { Meta } from './Meta';
-export class Subscription {
+export class Observable {
     constructor(content) { this.content = content; }
     get isOperation() { return false; }
     get originSnapshotId() { return 0; }

package/build/dist/source/impl/Journal.js

@@ -1,5 +1,5 @@
 import { ObservableObject } from './Mvcc';
-import { Meta, Subscription } from './Data';
+import { Meta, Observable } from './Data';
 import { Changeset, EMPTY_SNAPSHOT } from './Changeset';
 import { Transaction } from './Transaction';
 import { Sealant } from '../util/Sealant';
@@ -99,7 +99,7 @@ export class JournalImpl extends Journal {
                     const value = undoing ? vp.formerValue : vp.freshValue;
                     const os = ctx.getEditableObjectSnapshot(h, m, value);
                     if (os.changeset === ctx) {
-                        os.data[m] = new Subscription(value);
+                        os.data[m] = new Observable(value);
                         const existing = os.former.snapshot.data[m];
                         Changeset.markEdited(existing, value, existing !== value, os, m, h);
                     }
@@ -137,8 +137,8 @@ export class JournalImpl extends Journal {
         });
     }
 }
-function unseal(subscription) {
-    const result = subscription.content;
+function unseal(o) {
+    const result = o.content;
     const createCopy = result === null || result === void 0 ? void 0 : result[Sealant.CreateCopy];
     return createCopy !== undefined ? createCopy.call(result) : result;
 }

package/build/dist/source/impl/Mvcc.d.ts

@@ -44,9 +44,10 @@ export declare class Mvcc implements ProxyHandler<ObjectHandle> {
     get(h: ObjectHandle, m: MemberName, receiver: any): any;
     set(h: ObjectHandle, m: MemberName, value: any, receiver: any): boolean;
     has(h: ObjectHandle, m: MemberName): boolean;
+    defineProperty?(h: ObjectHandle, m: string | symbol, attributes: PropertyDescriptor): boolean;
     getOwnPropertyDescriptor(h: ObjectHandle, m: MemberName): PropertyDescriptor | undefined;
     ownKeys(h: ObjectHandle): Array<string | symbol>;
-    static decorateData(isObservable: boolean, proto: any, m: MemberName): any;
+    static decorateData(isObservable: boolean, proto: any, member: MemberName): any;
     static decorateOperation(implicit: boolean, decorator: Function, options: Partial<MemberOptions>, proto: any, member: MemberName, pd: PropertyDescriptor | undefined): any;
     static decorateOperationParametrized(decorator: Function, options: Partial<MemberOptions>): F<any>;
     static acquireHandle(obj: any): ObjectHandle;

package/build/dist/source/impl/Mvcc.js

@@ -1,7 +1,7 @@
 import { UNDEF } from '../util/Utils';
 import { Log, misuse } from '../util/Dbg';
 import { Kind, Reentrance } from '../Options';
-import { ObjectSnapshot, ObjectHandle, Subscription, Meta } from './Data';
+import { ObjectSnapshot, ObjectHandle, Observable, Meta } from './Data';
 import { Changeset, Dump, EMPTY_SNAPSHOT } from './Changeset';
 export class MvccObject {
     constructor(observable) {
@@ -72,7 +72,7 @@ export class Mvcc {
             const cs = Changeset.current();
             const os = cs.getObjectSnapshot(h, m);
             result = os.data[m];
-            if (result instanceof Subscription && !result.isOperation) {
+            if (result instanceof Observable && !result.isOperation) {
                 if (this.isObservable)
                     Changeset.markUsed(result, os, m, h, Kind.Plain, false);
                 result = result.content;
@@ -92,7 +92,7 @@ export class Mvcc {
                 if (curr === undefined || curr.content !== value || Mvcc.sensitivity) {
                     const existing = curr === null || curr === void 0 ? void 0 : curr.content;
                     if (os.former.snapshot.data[m] === curr) {
-                        curr = os.data[m] = new Subscription(value);
+                        curr = os.data[m] = new Observable(value);
                         Changeset.markEdited(existing, value, true, os, m, h);
                     }
                     else {
@@ -112,6 +112,14 @@ export class Mvcc {
         const os = Changeset.current().getObjectSnapshot(h, m);
         return m in os.data || m in h.data;
     }
+    defineProperty(h, m, attributes) {
+        if (attributes.get && attributes.set) {
+            Object.defineProperty(h.data, m, attributes);
+            return true;
+        }
+        else
+            throw new Error('not implemented');
+    }
     getOwnPropertyDescriptor(h, m) {
         const os = Changeset.current().getObjectSnapshot(h, m);
         const pd = Reflect.getOwnPropertyDescriptor(os.data, m);
@@ -124,27 +132,28 @@ export class Mvcc {
         const result = [];
         for (const m of Object.getOwnPropertyNames(os.data)) {
             const value = os.data[m];
-            if (!(value instanceof Subscription) || !value.isOperation)
+            if (!(value instanceof Observable) || !value.isOperation)
                 result.push(m);
         }
         return result;
     }
-    static decorateData(isObservable, proto, m) {
+    static decorateData(isObservable, proto, member) {
         if (isObservable) {
+            Meta.acquire(proto, Meta.Initial)[member] = new Observable(undefined);
             const get = function () {
                 const h = Mvcc.acquireHandle(this);
-                return Mvcc.observable.get(h, m, this);
+                return Mvcc.observable.get(h, member, this);
             };
             const set = function (value) {
                 const h = Mvcc.acquireHandle(this);
-                return Mvcc.observable.set(h, m, value, this);
+                return Mvcc.observable.set(h, member, value, this);
             };
             const enumerable = true;
             const configurable = false;
-            return Object.defineProperty(proto, m, { get, set, enumerable, configurable });
+            return Object.defineProperty(proto, member, { get, set, enumerable, configurable });
         }
         else
-            Meta.acquire(proto, Meta.Initial)[m] = Meta.Raw;
+            Meta.acquire(proto, Meta.Initial)[member] = Meta.Raw;
     }
     static decorateOperation(implicit, decorator, options, proto, member, pd) {
         var _a, _b, _c, _d;
@@ -189,7 +198,7 @@ export class Mvcc {
             h = new ObjectHandle(obj, obj, Mvcc.observable, os, obj.constructor.name);
             Meta.set(os.data, Meta.Handle, h);
             Meta.set(obj, Meta.Handle, h);
-            Meta.set(os.data, Meta.Revision, new Subscription(1));
+            Meta.set(os.data, Meta.Revision, new Observable(1));
         }
         return h;
     }

package/build/dist/source/impl/Operation.d.ts

@@ -1,7 +1,7 @@
 import { F } from '../util/Utils';
 import { MemberOptions } from '../Options';
 import { Controller } from '../Controller';
-import { MemberName, ObjectHandle, Subscription, Subscriber, SubscriptionInfo, AbstractChangeset } from './Data';
+import { MemberName, ObjectHandle, Observable, Observer, Subscription, AbstractChangeset } from './Data';
 import { Transaction } from './Transaction';
 import { OptionsImpl } from './Mvcc';
 export declare class OperationController extends Controller<any> {
@@ -32,15 +32,15 @@ export declare class OperationController extends Controller<any> {
     private run;
     private static markObsolete;
 }
-declare class Operation extends Subscription implements Subscriber {
+declare class Operation extends Observable implements Observer {
     static current?: Operation;
-    static queuedReactiveFunctions: Array<Subscriber>;
+    static queuedReactiveFunctions: Array<Observer>;
     static deferredReactiveFunctions: Array<Operation>;
     readonly margin: number;
     readonly transaction: Transaction;
     readonly controller: OperationController;
     readonly changeset: AbstractChangeset;
-    subscriptions: Map<Subscription, SubscriptionInfo> | undefined;
+    observables: Map<Observable, Subscription> | undefined;
     options: OptionsImpl;
     cause: string | undefined;
     args: any[];
@@ -61,7 +61,7 @@ declare class Operation extends Subscription implements Subscriber {
     dependencies(): string[];
     wrap<T>(func: F<T>): F<T>;
     run(proxy: any, args: any[] | undefined): void;
-    markObsoleteDueTo(subscription: Subscription, m: MemberName, changeset: AbstractChangeset, h: ObjectHandle, outer: string, since: number, reactive: Subscriber[]): void;
+    markObsoleteDueTo(observable: Observable, m: MemberName, changeset: AbstractChangeset, h: ObjectHandle, outer: string, since: number, reactive: Observer[]): void;
     runIfNotUpToDate(now: boolean, nothrow: boolean): void;
     isNotUpToDate(): boolean;
     reenterOver(head: Operation): this;
@@ -81,7 +81,7 @@ declare class Operation extends Subscription implements Subscriber {
     private static propagateMemberChangeThroughSubscriptions;
     private static enqueueReactiveFunctionsToRun;
     private static runQueuedReactiveLoop;
-    private unsubscribeFromAllSubscriptions;
+    private unsubscribeFromAllObservables;
     private subscribeTo;
     private static canSubscribe;
     private static createOperation;

package/build/dist/source/impl/Operation.js

@@ -1,7 +1,7 @@
 import { Log, misuse } from '../util/Dbg';
 import { Kind, Reentrance } from '../Options';
 import { Controller } from '../Controller';
-import { ObjectHandle, Subscription, Meta } from './Data';
+import { ObjectHandle, Observable, Meta } from './Data';
 import { Changeset, Dump, EMPTY_SNAPSHOT, MAX_REVISION } from './Changeset';
 import { Transaction } from './Transaction';
 import { MonitorImpl } from './Monitor';
@@ -199,14 +199,14 @@ export class OperationController extends Controller {
         oc.operation.markObsoleteDueTo(oc.operation, self.memberName, EMPTY_SNAPSHOT.changeset, EMPTY_HANDLE, BOOT_CAUSE, ctx.timestamp, ctx.reactive);
     }
 }
-class Operation extends Subscription {
+class Operation extends Observable {
     constructor(controller, changeset, former) {
         super(undefined);
         this.margin = Operation.current ? Operation.current.margin + 1 : 1;
         this.transaction = Transaction.current;
         this.controller = controller;
         this.changeset = changeset;
-        this.subscriptions = new Map();
+        this.observables = new Map();
         if (former instanceof Operation) {
             this.options = former.options;
             this.args = former.args;
@@ -269,13 +269,13 @@ class Operation extends Subscription {
         else
             this.result = Promise.reject(this.error);
     }
-    markObsoleteDueTo(subscription, m, changeset, h, outer, since, reactive) {
+    markObsoleteDueTo(observable, m, changeset, h, outer, since, reactive) {
         var _a, _b, _c;
-        if (this.subscriptions !== undefined) {
-            const skip = !subscription.isOperation &&
+        if (this.observables !== undefined) {
+            const skip = !observable.isOperation &&
                 changeset === this.changeset;
             if (!skip) {
-                const why = `${Dump.snapshot2(h, changeset, m, subscription)}    <<    ${outer}`;
+                const why = `${Dump.snapshot2(h, changeset, m, observable)}    <<    ${outer}`;
                 const isReactive = this.options.kind === Kind.Reactive;
                 this.obsoleteDueTo = why;
                 this.obsoleteSince = since;
@@ -283,15 +283,15 @@ class Operation extends Subscription {
                     Log.write(Log.opt.transaction && !Changeset.current().sealed ? '║' : ' ', isReactive ? '█' : '▒', isReactive && changeset === EMPTY_SNAPSHOT.changeset
                         ? `${this.hint()} is a reactive and will run automatically (order ${this.options.order})`
                         : `${this.hint()} is obsolete due to ${Dump.snapshot2(h, changeset, m)} since v${since}${isReactive ? ` and will run automatically (order ${this.options.order})` : ''}`);
-                this.unsubscribeFromAllSubscriptions();
+                this.unsubscribeFromAllObservables();
                 if (isReactive)
                     reactive.push(this);
                 else
-                    (_b = this.subscribers) === null || _b === void 0 ? void 0 : _b.forEach(s => s.markObsoleteDueTo(this, this.controller.memberName, this.changeset, this.controller.objectHandle, why, since, reactive));
+                    (_b = this.observers) === null || _b === void 0 ? void 0 : _b.forEach(s => s.markObsoleteDueTo(this, this.controller.memberName, this.changeset, this.controller.objectHandle, why, since, reactive));
                 const tran = this.transaction;
                 if (tran.changeset === changeset) {
                 }
-                else if (!tran.isFinished && this !== subscription)
+                else if (!tran.isFinished && this !== observable)
                     tran.cancel(new Error(`T${tran.id}[${tran.hint}] is canceled due to obsolete ${Dump.snapshot2(h, changeset, m)} changed by T${changeset.id}[${changeset.hint}]`), null);
             }
             else if (Log.isOn && (Log.opt.obsolete || ((_c = this.options.logging) === null || _c === void 0 ? void 0 : _c.obsolete)))
@@ -448,7 +448,7 @@ class Operation extends Subscription {
         for (const x of deferred)
             x.runIfNotUpToDate(true, true);
     }
-    static markUsed(subscription, os, m, h, kind, weak) {
+    static markUsed(observable, os, m, h, kind, weak) {
         if (kind !== Kind.Transactional) {
             const op = Operation.current;
             if (op && op.options.kind !== Kind.Transactional &&
@@ -457,8 +457,8 @@ class Operation extends Subscription {
                 if (ctx !== os.changeset)
                     ctx.bumpBy(os.changeset.timestamp);
                 const t = weak ? -1 : ctx.timestamp;
-                if (!op.subscribeTo(subscription, os, m, h, t))
-                    op.markObsoleteDueTo(subscription, m, os.changeset, h, BOOT_CAUSE, ctx.timestamp, ctx.reactive);
+                if (!op.subscribeTo(observable, os, m, h, t))
+                    op.markObsoleteDueTo(observable, m, os.changeset, h, BOOT_CAUSE, ctx.timestamp, ctx.reactive);
             }
         }
     }
@@ -499,13 +499,13 @@ class Operation extends Subscription {
         const curr = os.data[m];
         if (reactive) {
             const former = os.former.snapshot.data[m];
-            if (former !== undefined && former instanceof Subscription) {
+            if (former !== undefined && former instanceof Observable) {
                 const why = `T${os.changeset.id}[${os.changeset.hint}]`;
                 if (former instanceof Operation) {
                     if ((former.obsoleteSince === MAX_REVISION || former.obsoleteSince <= 0)) {
                         former.obsoleteDueTo = why;
                         former.obsoleteSince = timestamp;
-                        former.unsubscribeFromAllSubscriptions();
+                        former.unsubscribeFromAllObservables();
                     }
                     const formerSuccessor = former.successor;
                     if (formerSuccessor !== curr) {
@@ -515,22 +515,22 @@ class Operation extends Subscription {
                     else
                         former.successor = undefined;
                 }
-                (_a = former.subscribers) === null || _a === void 0 ? void 0 : _a.forEach(s => s.markObsoleteDueTo(former, m, os.changeset, h, why, timestamp, reactive));
+                (_a = former.observers) === null || _a === void 0 ? void 0 : _a.forEach(s => s.markObsoleteDueTo(former, m, os.changeset, h, why, timestamp, reactive));
             }
         }
         if (curr instanceof Operation) {
-            if (curr.changeset === os.changeset && curr.subscriptions !== undefined) {
+            if (curr.changeset === os.changeset && curr.observables !== undefined) {
                 if (Mvcc.repetitiveUsageWarningThreshold < Number.MAX_SAFE_INTEGER) {
-                    curr.subscriptions.forEach((info, v) => {
+                    curr.observables.forEach((info, v) => {
                         if (info.usageCount > Mvcc.repetitiveUsageWarningThreshold)
                             Log.write('', '[!]', `${curr.hint()} uses ${info.memberHint} ${info.usageCount} times (consider remembering it in a local variable)`, 0, ' *** WARNING ***');
                     });
                 }
                 if (unsubscribe)
-                    curr.unsubscribeFromAllSubscriptions();
+                    curr.unsubscribeFromAllObservables();
             }
         }
-        else if (curr instanceof Subscription && curr.subscribers) {
+        else if (curr instanceof Observable && curr.observers) {
         }
     }
     static enqueueReactiveFunctionsToRun(reactive) {
@@ -551,33 +551,33 @@ class Operation extends Subscription {
         }
         Operation.queuedReactiveFunctions = [];
     }
-    unsubscribeFromAllSubscriptions() {
+    unsubscribeFromAllObservables() {
         var _a;
-        (_a = this.subscriptions) === null || _a === void 0 ? void 0 : _a.forEach((info, value) => {
+        (_a = this.observables) === null || _a === void 0 ? void 0 : _a.forEach((info, value) => {
             var _a;
-            value.subscribers.delete(this);
+            value.observers.delete(this);
             if (Log.isOn && (Log.opt.read || ((_a = this.options.logging) === null || _a === void 0 ? void 0 : _a.read)))
                 Log.write(Log.opt.transaction && !Changeset.current().sealed ? '║' : ' ', '-', `${this.hint()} is unsubscribed from ${info.memberHint}`);
         });
-        this.subscriptions = undefined;
+        this.observables = undefined;
     }
-    subscribeTo(subscription, os, m, h, timestamp) {
+    subscribeTo(observable, os, m, h, timestamp) {
         var _a, _b, _c;
-        const ok = Operation.canSubscribe(subscription, os, m, h, timestamp);
+        const ok = Operation.canSubscribe(observable, os, m, h, timestamp);
         if (ok) {
             let times = 0;
             if (Mvcc.repetitiveUsageWarningThreshold < Number.MAX_SAFE_INTEGER) {
-                const existing = this.subscriptions.get(subscription);
+                const existing = this.observables.get(observable);
                 times = existing ? existing.usageCount + 1 : 1;
             }
-            if (this.subscriptions !== undefined) {
-                if (!subscription.subscribers)
-                    subscription.subscribers = new Set();
-                const info = { memberHint: Dump.snapshot2(h, os.changeset, m), usageCount: times };
-                subscription.subscribers.add(this);
-                this.subscriptions.set(subscription, info);
+            if (this.observables !== undefined) {
+                if (!observable.observers)
+                    observable.observers = new Set();
+                const subscription = { memberHint: Dump.snapshot2(h, os.changeset, m), usageCount: times };
+                observable.observers.add(this);
+                this.observables.set(observable, subscription);
                 if (Log.isOn && (Log.opt.read || ((_a = this.options.logging) === null || _a === void 0 ? void 0 : _a.read)))
-                    Log.write('║', '  ∞ ', `${this.hint()} is subscribed to ${Dump.snapshot2(h, os.changeset, m)}${info.usageCount > 1 ? ` (${info.usageCount} times)` : ''}`);
+                    Log.write('║', '  ∞ ', `${this.hint()} is subscribed to ${Dump.snapshot2(h, os.changeset, m)}${subscription.usageCount > 1 ? ` (${subscription.usageCount} times)` : ''}`);
             }
             else if (Log.isOn && (Log.opt.read || ((_b = this.options.logging) === null || _b === void 0 ? void 0 : _b.read)))
                 Log.write('║', '  x ', `${this.hint()} is obsolete and is NOT subscribed to ${Dump.snapshot2(h, os.changeset, m)}`);
@@ -588,10 +588,10 @@ class Operation extends Subscription {
         }
         return ok;
     }
-    static canSubscribe(subscription, os, m, h, timestamp) {
-        let result = !os.changeset.sealed || subscription === h.head.data[m];
+    static canSubscribe(observable, os, m, h, timestamp) {
+        let result = !os.changeset.sealed || observable === h.head.data[m];
         if (result && timestamp !== -1)
-            result = !(subscription instanceof Operation && timestamp >= subscription.obsoleteSince);
+            result = !(observable instanceof Operation && timestamp >= observable.obsoleteSince);
         return result;
     }
     static createOperation(h, m, options) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "reactronic",
-  "version": "0.22.504",
+  "version": "0.22.506",
   "description": "Reactronic - Transactional Reactive State Management",
   "publisher": "Nezaboodka Software",
   "license": "Apache-2.0",