reactronic 0.23.103 → 0.23.105

package/README.md

@@ -446,6 +446,181 @@ class Reactronic {
 
 ```
 
+## API (Artel)
+
+```артель
+// Classes
+
+тип ТранзакционныйОбъект = объект { }
+тип НаблюдаемыйОбъект = объект на основе ТранзакционныйОбъект { }
+
+// Decorators & Operators
+
+// function raw(proto, prop) // field only
+// function transaction(proto, prop, pd) // method only
+// function reactive(proto, prop, pd) // method only
+// function cached(proto, prop, pd) // method only
+// function options(value: Partial<MemberOptions>): F<any>
+
+// function nonreactive<T>(func: F<T>, ...args: any[]): T
+// function sensitive<T>(sensitivity: Sensitivity, func: F<T>, ...args: any[]): T
+
+// SnapshotOptions, MemberOptions, Kind, Reentrance, Monitor, LoggingOptions, ProfilingOptions
+
+тип НастройкиТранзакции = интерфейс
+{
+  постоянная подсказка: Текст?
+  постоянное раздельно?: РежимРазделения
+  постоянный журнал: Журнал?
+  постоянное журнализация: Выборочно<НастройкиЖурнализации>
+  постоянный ключ: Нечто?
+}
+
+тип НастройкиЧленаОбъекта = интерфейс
+{
+  постоянный разновидность: Разновидность
+  постоянное раздельно?: РежимРазделения
+  постоянный порядок: Целое
+  постоянный безПобочныхЭффектов: Булево
+  постоянный триггерныеАргументы: Булево
+  постоянный дроссель: Целое // миллисекунды, -1 немедленно, Целое.Макс никогда
+  постоянный рецидив: Рецидив
+  постоянный журнал: Журнал?
+  постоянный монитор: Монитор?
+  постоянная журнализация: Выборочно<НастройкиЖурнализации>
+}
+
+тип Разновидность = вариант
+{
+  Plain = 0
+  Транзакционное = 1
+  Реактивное = 2
+  Кэшируемое = 3
+}
+
+тип Рецидив = вариант
+{
+  PreventWithError = 1, // fail with error if there is an existing call in progress (default)
+  WaitAndRestart = 0, // wait for existing call to finish and then restart current one
+  CancelPrevious = -1, // cancel previous call in favor of recent one
+  CancelAndWaitPrevious = -2, // cancel previous call in favor of recent one (but wait until canceling is completed)
+  OverwritePrevious = -2, // allow previous to complete, but overwrite it with ignoring any conflicts
+  RunSideBySide = -3 // multiple simultaneous calls are allowed
+}
+
+тип Монитор = объект
+{
+  постоянное активно: Булево
+  постоянный счетчик: Целое
+  постоянные работы: ЧитаемоеМножество<Работа>
+  при создании(подсказка: Текст,
+    задержкаАктивации: Целое, задержкаДеактивации: Целое)
+}
+
+тип Работа = интерфейс
+{
+  постоянный код: Целое
+  постоянная подсказка: Текст
+  отменено: Булево
+  завершено: Булево
+  операция отменить(о: Ошибка?, повторПосле: Транзакция?)
+  параллельная операция ожидание-окончания()
+}
+
+тип НастройкиЖурнализации = интерфейс
+{
+  постоянный выключено: Булево
+  постоянный транзакция: Булево
+  постоянный операция: Булево
+  постоянный шаг: Булево
+  постоянный монитор: Булево
+  постоянный чтение: Булево
+  постоянный запись: Булево
+  постоянный изменение: Булево
+  постоянный аннулирование: Булево
+  постоянный ошибка: Булево
+  постоянный предупреждение: Булево
+  постоянный уборка-мусора: Булево
+}
+
+тип НастройкиПрофилирования =
+{
+  порогПредупрежденияПриМногократномИспользовании: Целое // 10 раз
+  порогПредупрежденияПриБлокировкеГлавногоПотока: Целое // 16.6 мс
+  порогПредупрежденияПриДлительномПараллельномВыполнении: Целое // 150 мс
+}
+
+// Транзакция
+
+тип Ф<Т> = операция(арг: Элементы<Нечто>): Т
+
+тип Транзакция = объект на основе Работа
+{
+  общая охраняемая типом текущая: Транзакция
+
+  охраняемый типом код: Целое
+  охраняемая типом подсказка: Текст
+
+  
+  исполнить<Т>(ф: Ф<Т>, арг: Элементы<Нечто>): Т
+  wrap<T>(func: F<T>): F<T>
+  зафиксировать()
+  опечатать() // a1.seal().whenFinished().then(fulfill, reject)
+  отменить(о: Ошибка?, повтор-после: Транзакция? = пусто)
+  отменено: Булево
+  завершено: Булево
+  whenFinished(): Promise<void>
+  join<T>(p: Promise<T>): Promise<T>
+
+  общая операция создать(настройки: НастройкиСнимка?): Транзакция
+  общая операция исполнить<Т>(настройки: НастройкиСнимка?, ф: Ф<Т>, арг: Элементы<Т>): Т
+  общая операция вне-транзакции<Т>(ф: Ф<Т>, арг: Элементы<Нечто>): Т
+
+  общая операция фрейм-окончен(шаг: Целое, лимит-времени: Целое): Булево
+  общая параллельная операция запросить-следующий-фрейм(время-сна: Целое)
+  общее отменено: Булево
+}
+
+// Контролер
+
+тип Контролер = объект
+{
+  охраняемое типом options: Options
+  охраняемое типом args: ReadonlyArray<any>
+  охраняемое типом value: T
+  охраняемое типом error: any
+  охраняемое типом stamp: number
+  охраняемое типом isUpToDate: boolean
+
+  настроить(настройки: Выборочно<Настройки>): Настройки
+  аннулировать(): Булево
+  взять-последний-результат<Т>(арг: Элементы<Нечто>): Т?
+}
+
+// Реактроник
+
+тип Реактроник = объект
+{
+  общая операция почему(кратко: Булево = нет): Текст
+  общая операция взятьКэшОперации<Т>(о: Оп<Т>): Кэш<Т>
+  общая операция configureCurrentOperation(options: Partial<Options>): Options
+  общая операция взятьРевизию(о: Нечто): Целое
+  общая операция взятьСнимок<Т>(о: Т): Т
+  общая операция dispose(obj: Нечто)
+  общая операция reactivityAutoStartDisabled: boolean
+  общее охраняемое журнализация-включена: Булево
+  общая охраняемое настройки-журнализации: НастройкиЖурнализации
+  общая операция пустьРежимЖурнализации(
+    вкл: Булево, настройки: НастройкиЖурнализации? = пусто)
+  общая операция пустьПодсказкаЖурнализации<Т extends Объект>(
+    о: Т, подсказка: Текст?)
+  общая операция взятьПодсказкуЖурнализации<Т extends Объект>(о: Т): Текст?
+  общая операция пустьРежимПрофилирования(
+    вкл: Булево, настройки: Выборочно<НастройкиЖурнализации>? = пусто)
+}
+
+```
+
 ## Contribution
 
 By contributing, you agree that your contributions will be

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

@@ -1,4 +1,4 @@
-import { ObservableObject } from './impl/Mvcc';
+import { ObservableObject } from './impl/Mvcc.js';
 export declare abstract class Buffer<T> extends ObservableObject {
     abstract readonly capacity: number;
     abstract readonly count: number;

package/build/dist/source/Buffer.js

@@ -1,4 +1,4 @@
-import { ObservableObject } from './impl/Mvcc';
+import { ObservableObject } from './impl/Mvcc.js';
 export class Buffer extends ObservableObject {
     static create(hint, capacity) { throw new Error('not implemented'); }
 }

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

@@ -0,0 +1,12 @@
+import { ObservableObject } from './impl/Mvcc.js';
+export declare class Clock extends ObservableObject {
+    hour: number;
+    minute: number;
+    second: number;
+    ms: number;
+    interval: number;
+    paused: boolean;
+    constructor(interval?: number);
+    pause(value?: boolean): void;
+    private tick;
+}

package/build/dist/source/Clock.js

@@ -0,0 +1,53 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import { ObservableObject } from './impl/Mvcc.js';
+import { transactional } from './Rx.js';
+export class Clock extends ObservableObject {
+    constructor(interval = 1000) {
+        super();
+        this.hour = 0;
+        this.minute = 0;
+        this.second = 0;
+        this.ms = 0;
+        this.interval = 0;
+        this.paused = false;
+        this.interval = interval;
+        this.tick();
+    }
+    pause(value = true) {
+        this.paused = value;
+    }
+    tick() {
+        let calibration = 0;
+        try {
+            const now = new Date();
+            this.hour = now.getHours();
+            this.minute = now.getMinutes();
+            this.second = now.getSeconds();
+            this.ms = now.getMilliseconds();
+            calibration = now.getTime() % this.interval;
+        }
+        finally {
+            setTimeout(() => this.tick(), this.interval - calibration);
+        }
+    }
+}
+__decorate([
+    transactional,
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Boolean]),
+    __metadata("design:returntype", void 0)
+], Clock.prototype, "pause", null);
+__decorate([
+    transactional,
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", void 0)
+], Clock.prototype, "tick", null);

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

@@ -1,4 +1,4 @@
-import { MemberOptions } from './Options';
+import { MemberOptions } from './Options.js';
 export declare abstract class Controller<T> {
     abstract readonly options: MemberOptions;
     abstract readonly args: ReadonlyArray<any>;

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

@@ -1,9 +1,9 @@
-import { LoggingOptions } from './Logging';
-import { SeparationMode } from './impl/Data';
-export { LoggingLevel } from './Logging';
-export type { LoggingOptions, ProfilingOptions } from './Logging';
-import { Journal } from './impl/Journal';
-import { Monitor } from './impl/Monitor';
+import { LoggingOptions } from './Logging.js';
+import { SeparationMode } from './impl/Data.js';
+export { LoggingLevel } from './Logging.js';
+export type { LoggingOptions, ProfilingOptions } from './Logging.js';
+import { Journal } from './impl/Journal.js';
+import { Monitor } from './impl/Monitor.js';
 export interface SnapshotOptions {
     readonly hint?: string;
     readonly separation?: SeparationMode;

package/build/dist/source/Options.js

@@ -1,4 +1,4 @@
-export { LoggingLevel } from './Logging';
+export { LoggingLevel } from './Logging.js';
 export var Kind;
 (function (Kind) {
     Kind[Kind["Plain"] = 0] = "Plain";

package/build/dist/source/Ref.js

@@ -1,5 +1,5 @@
-import { Transaction } from './impl/Transaction';
-import { nonreactive } from './Rx';
+import { Transaction } from './impl/Transaction.js';
+import { nonreactive } from './Rx.js';
 export function refs(owner) {
     return new Proxy(owner, RefGettingProxy);
 }

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

@@ -1,6 +1,6 @@
-import { F } from './util/Utils';
-import { Controller } from './Controller';
-import { MemberOptions, LoggingOptions, ProfilingOptions } from './Options';
+import { F } from './util/Utils.js';
+import { Controller } from './Controller.js';
+import { MemberOptions, LoggingOptions, ProfilingOptions } from './Options.js';
 export declare class Rx {
     static why(brief?: boolean): string;
     static getController<T>(method: F<T>): Controller<T>;

package/build/dist/source/Rx.js

@@ -1,9 +1,9 @@
-import { Log } from './util/Dbg';
-import { Kind } from './Options';
-import { Meta, ObjectHandle } from './impl/Data';
-import { Changeset } from './impl/Changeset';
-import { Mvcc } from './impl/Mvcc';
-import { OperationController } from './impl/Operation';
+import { Log } from './util/Dbg.js';
+import { Kind } from './Options.js';
+import { Meta, ObjectHandle } from './impl/Data.js';
+import { Changeset } from './impl/Changeset.js';
+import { Mvcc } from './impl/Mvcc.js';
+import { OperationController } from './impl/Operation.js';
 export class Rx {
     static why(brief = false) { return brief ? OperationController.briefWhy() : OperationController.why(); }
     static getController(method) { return OperationController.getControllerOf(method); }

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

@@ -1,20 +1,21 @@
-export { all, pause } from './util/Utils';
-export { Collection } from './util/Collection';
-export type { Item, CollectionReader } from './util/Collection';
-export { SealedArray } from './util/SealedArray';
-export { SealedMap } from './util/SealedMap';
-export { SealedSet } from './util/SealedSet';
-export { Kind, Reentrance, LoggingLevel } from './Options';
-export type { MemberOptions, SnapshotOptions, LoggingOptions, ProfilingOptions } from './Options';
-export type { Worker } from './Worker';
-export { Controller } from './Controller';
-export { Ref, ToggleRef, refs, toggleRefs, customToggleRefs } from './Ref';
-export type { BoolOnly, GivenTypeOnly } from './Ref';
-export { TransactionalObject, ObservableObject } from './impl/Mvcc';
-export { TransactionalArray, ObservableArray } from './impl/MvccArray';
-export { TransactionalMap, ObservableMap } from './impl/MvccMap';
-export { Changeset } from './impl/Changeset';
-export { Transaction } from './impl/Transaction';
-export { Monitor } from './impl/Monitor';
-export { Journal } from './impl/Journal';
-export { Rx, raw, observable, transactional, reactive, cached, nonreactive, sensitive, options } from './Rx';
+export { all, pause } from './util/Utils.js';
+export { Collection } from './util/Collection.js';
+export type { Item, CollectionReader } from './util/Collection.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 { MemberOptions, SnapshotOptions, LoggingOptions, ProfilingOptions } from './Options.js';
+export type { Worker } from './Worker.js';
+export { Controller } from './Controller.js';
+export { Ref, ToggleRef, refs, toggleRefs, customToggleRefs } from './Ref.js';
+export type { BoolOnly, GivenTypeOnly } from './Ref.js';
+export { TransactionalObject, ObservableObject } from './impl/Mvcc.js';
+export { TransactionalArray, ObservableArray } from './impl/MvccArray.js';
+export { TransactionalMap, ObservableMap } from './impl/MvccMap.js';
+export { Changeset } from './impl/Changeset.js';
+export { Transaction } from './impl/Transaction.js';
+export { Monitor } from './impl/Monitor.js';
+export { Journal } from './impl/Journal.js';
+export { Rx, raw, observable, transactional, reactive, cached, nonreactive, sensitive, options } from './Rx.js';
+export { Clock } from './Clock.js';

package/build/dist/source/api.js

@@ -1,16 +1,17 @@
-export { all, pause } from './util/Utils';
-export { Collection } from './util/Collection';
-export { SealedArray } from './util/SealedArray';
-export { SealedMap } from './util/SealedMap';
-export { SealedSet } from './util/SealedSet';
-export { Kind, Reentrance, LoggingLevel } from './Options';
-export { Controller } from './Controller';
-export { Ref, ToggleRef, refs, toggleRefs, customToggleRefs } from './Ref';
-export { TransactionalObject, ObservableObject } from './impl/Mvcc';
-export { TransactionalArray, ObservableArray } from './impl/MvccArray';
-export { TransactionalMap, ObservableMap } from './impl/MvccMap';
-export { Changeset } from './impl/Changeset';
-export { Transaction } from './impl/Transaction';
-export { Monitor } from './impl/Monitor';
-export { Journal } from './impl/Journal';
-export { Rx, raw, observable, transactional, reactive, cached, nonreactive, sensitive, options } from './Rx';
+export { all, pause } from './util/Utils.js';
+export { Collection } from './util/Collection.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 { Controller } from './Controller.js';
+export { Ref, ToggleRef, refs, toggleRefs, customToggleRefs } from './Ref.js';
+export { TransactionalObject, ObservableObject } from './impl/Mvcc.js';
+export { TransactionalArray, ObservableArray } from './impl/MvccArray.js';
+export { TransactionalMap, ObservableMap } from './impl/MvccMap.js';
+export { Changeset } from './impl/Changeset.js';
+export { Transaction } from './impl/Transaction.js';
+export { Monitor } from './impl/Monitor.js';
+export { Journal } from './impl/Journal.js';
+export { Rx, raw, observable, transactional, reactive, cached, nonreactive, sensitive, options } from './Rx.js';
+export { Clock } from './Clock.js';

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

@@ -1,5 +1,5 @@
-import { Kind, SnapshotOptions } from '../Options';
-import { AbstractChangeset, ObjectSnapshot, MemberName, ObjectHandle, Observable, Observer } from './Data';
+import { Kind, SnapshotOptions } from '../Options.js';
+import { AbstractChangeset, ObjectSnapshot, MemberName, ObjectHandle, ObservableValue, Observer } from './Data.js';
 export declare const MAX_REVISION: number;
 export declare const UNDEFINED_REVISION: number;
 export declare class Changeset implements AbstractChangeset {
@@ -23,7 +23,7 @@ export declare class Changeset implements AbstractChangeset {
     constructor(options: SnapshotOptions | null);
     static current: () => Changeset;
     static edit: () => Changeset;
-    static markUsed: (observable: Observable, os: ObjectSnapshot, m: MemberName, h: ObjectHandle, kind: Kind, weak: boolean) => void;
+    static markUsed: (observable: ObservableValue, 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;
@@ -42,7 +42,7 @@ export declare class Changeset implements AbstractChangeset {
     private merge;
     applyOrDiscard(error?: any): Array<Observer>;
     static sealObjectSnapshot(h: ObjectHandle, os: ObjectSnapshot): void;
-    static sealObservable(o: Observable | symbol, m: MemberName, typeName: string): void;
+    static sealObservableValue(o: ObservableValue | 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) => 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?: Observable): string;
+    static snapshot2(h: ObjectHandle, s: AbstractChangeset, m?: MemberName, o?: ObservableValue): 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

@@ -1,10 +1,10 @@
-import { Utils, UNDEF } from '../util/Utils';
-import { Log, misuse } from '../util/Dbg';
-import { Sealant } from '../util/Sealant';
-import { SealedArray } from '../util/SealedArray';
-import { SealedMap } from '../util/SealedMap';
-import { SealedSet } from '../util/SealedSet';
-import { ObjectSnapshot, ObjectHandle, Observable, Meta } from './Data';
+import { Utils, UNDEF } from '../util/Utils.js';
+import { Log, misuse } from '../util/Dbg.js';
+import { Sealant } from '../util/Sealant.js';
+import { SealedArray } from '../util/SealedArray.js';
+import { SealedMap } from '../util/SealedMap.js';
+import { SealedSet } from '../util/SealedSet.js';
+import { ObjectSnapshot, ObjectHandle, ObservableValue, Meta } from './Data.js';
 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 Observable)
+            if (v instanceof ObservableValue)
                 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 Observable(revision));
+                Meta.set(data, Meta.Revision, new ObservableValue(revision));
                 os = new ObjectSnapshot(this, os, data);
                 this.items.set(h, os);
                 h.editing = os;
@@ -218,15 +218,15 @@ export class Changeset {
     }
     static sealObjectSnapshot(h, os) {
         if (!os.disposed)
-            os.changes.forEach((o, m) => Changeset.sealObservable(os.data[m], m, h.proxy.constructor.name));
+            os.changes.forEach((o, m) => Changeset.sealObservableValue(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 sealObservable(o, m, typeName) {
-        if (o instanceof Observable) {
+    static sealObservableValue(o, m, typeName) {
+        if (o instanceof ObservableValue) {
             const value = o.content;
             if (value !== undefined && value !== null) {
                 const sealedType = Object.getPrototypeOf(value)[Sealant.SealedType];

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

@@ -1,11 +1,11 @@
-export { Meta } from './Meta';
+export { Meta } from './Meta.js';
 export interface AbstractChangeset {
     readonly id: number;
     readonly hint: string;
     readonly timestamp: number;
     readonly sealed: boolean;
 }
-export declare class Observable {
+export declare class ObservableValue {
     content: any;
     observers?: Set<Observer>;
     get isOperation(): boolean;
@@ -15,10 +15,10 @@ export declare class Observable {
 export type SeparationMode = boolean | 'isolated' | 'disposal';
 export interface Observer {
     readonly order: number;
-    readonly observables: Map<Observable, Subscription> | undefined;
+    readonly observables: Map<ObservableValue, Subscription> | undefined;
     readonly obsoleteSince: number;
     hint(nop?: boolean): string;
-    markObsoleteDueTo(observable: Observable, m: MemberName, changeset: AbstractChangeset, h: ObjectHandle, outer: string, since: number, reactive: Array<Observer>): void;
+    markObsoleteDueTo(observable: ObservableValue, m: MemberName, changeset: AbstractChangeset, h: ObjectHandle, outer: string, since: number, reactive: Array<Observer>): void;
     runIfNotUpToDate(now: boolean, nothrow: boolean): void;
 }
 export type MemberName = PropertyKey;

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 Observable {
+import { Log } from '../util/Dbg.js';
+import { Meta } from './Meta.js';
+export { Meta } from './Meta.js';
+export class ObservableValue {
     get isOperation() { return false; }
     get originSnapshotId() { return 0; }
     constructor(content) { this.content = content; }

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

@@ -1,5 +1,5 @@
-import { ObservableObject } from './Mvcc';
-import { ObjectHandle, ObjectSnapshot, PatchSet } from './Data';
+import { ObservableObject } from './Mvcc.js';
+import { ObjectHandle, ObjectSnapshot, PatchSet } from './Data.js';
 export type Saver = (patch: PatchSet) => Promise<void>;
 export declare abstract class Journal extends ObservableObject {
     abstract capacity: number;

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

@@ -1,8 +1,8 @@
-import { ObservableObject } from './Mvcc';
-import { Meta, Observable } from './Data';
-import { Changeset, EMPTY_SNAPSHOT } from './Changeset';
-import { Transaction } from './Transaction';
-import { Sealant } from '../util/Sealant';
+import { ObservableObject } from './Mvcc.js';
+import { Meta, ObservableValue } from './Data.js';
+import { Changeset, EMPTY_SNAPSHOT } from './Changeset.js';
+import { Transaction } from './Transaction.js';
+import { Sealant } from '../util/Sealant.js';
 export class Journal extends ObservableObject {
     static create() { return new JournalImpl(); }
 }
@@ -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 Observable(value);
+                        os.data[m] = new ObservableValue(value);
                         const existing = os.former.snapshot.data[m];
                         Changeset.markEdited(existing, value, existing !== value, os, m, h);
                     }

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

@@ -1,5 +1,5 @@
-import { Worker } from '../Worker';
-import { ObservableObject } from './Mvcc';
+import { Worker } from '../Worker.js';
+import { ObservableObject } from './Mvcc.js';
 export declare abstract class Monitor extends ObservableObject {
     abstract readonly isActive: boolean;
     abstract readonly counter: number;

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

@@ -1,5 +1,5 @@
-import { ObservableObject, Mvcc } from './Mvcc';
-import { Transaction } from './Transaction';
+import { ObservableObject, Mvcc } from './Mvcc.js';
+import { Transaction } from './Transaction.js';
 export class Monitor extends ObservableObject {
     static create(hint, activationDelay, deactivationDelay, durationResolution) {
         return MonitorImpl.create(hint, activationDelay, deactivationDelay, durationResolution);

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

@@ -1,9 +1,9 @@
-import { F } from '../util/Utils';
-import { MemberOptions, Kind, Reentrance } from '../Options';
-import { LoggingOptions, ProfilingOptions } from '../Logging';
-import { MemberName, ObjectHandle, SeparationMode } from './Data';
-import { Journal } from './Journal';
-import { Monitor } from './Monitor';
+import { F } from '../util/Utils.js';
+import { MemberOptions, Kind, Reentrance } from '../Options.js';
+import { LoggingOptions, ProfilingOptions } from '../Logging.js';
+import { MemberName, ObjectHandle, SeparationMode } from './Data.js';
+import { Journal } from './Journal.js';
+import { Monitor } from './Monitor.js';
 export declare abstract class MvccObject {
     protected constructor(observable: boolean);
     [Symbol.toStringTag](): string;

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

@@ -1,8 +1,8 @@
-import { UNDEF } from '../util/Utils';
-import { Log, misuse } from '../util/Dbg';
-import { Kind, Reentrance } from '../Options';
-import { ObjectSnapshot, ObjectHandle, Observable, Meta } from './Data';
-import { Changeset, Dump, EMPTY_SNAPSHOT } from './Changeset';
+import { UNDEF } from '../util/Utils.js';
+import { Log, misuse } from '../util/Dbg.js';
+import { Kind, Reentrance } from '../Options.js';
+import { ObjectSnapshot, ObjectHandle, ObservableValue, Meta } from './Data.js';
+import { Changeset, Dump, EMPTY_SNAPSHOT } from './Changeset.js';
 export class MvccObject {
     constructor(observable) {
         const proto = new.target.prototype;
@@ -72,7 +72,7 @@ export class Mvcc {
             const cs = Changeset.current();
             const os = cs.getObjectSnapshot(h, m);
             result = os.data[m];
-            if (result instanceof Observable && !result.isOperation) {
+            if (result instanceof ObservableValue && !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 Observable(value);
+                        curr = os.data[m] = new ObservableValue(value);
                         Changeset.markEdited(existing, value, true, os, m, h);
                     }
                     else {
@@ -130,14 +130,14 @@ export class Mvcc {
         const result = [];
         for (const m of Object.getOwnPropertyNames(os.data)) {
             const value = os.data[m];
-            if (!(value instanceof Observable) || !value.isOperation)
+            if (!(value instanceof ObservableValue) || !value.isOperation)
                 result.push(m);
         }
         return result;
     }
     static decorateData(isObservable, proto, member) {
         if (isObservable) {
-            Meta.acquire(proto, Meta.Initial)[member] = new Observable(undefined);
+            Meta.acquire(proto, Meta.Initial)[member] = new ObservableValue(undefined);
             const get = function () {
                 const h = Mvcc.acquireHandle(this);
                 return Mvcc.observable.get(h, member, this);
@@ -196,7 +196,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 Observable(1));
+            Meta.set(os.data, Meta.Revision, new ObservableValue(1));
         }
         return h;
     }

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

@@ -1,4 +1,4 @@
-import { MvccObject } from './Mvcc';
+import { MvccObject } from './Mvcc.js';
 export declare class MvccArray<T> extends MvccObject {
     private impl;
     constructor(isObservable: boolean, array: Array<T>);

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

@@ -1,5 +1,5 @@
-import { Sealant } from '../util/Sealant';
-import { MvccObject } from './Mvcc';
+import { Sealant } from '../util/Sealant.js';
+import { MvccObject } from './Mvcc.js';
 export class MvccArray extends MvccObject {
     constructor(isObservable, array) {
         super(isObservable);

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

@@ -1,5 +1,5 @@
-import { Collection, Item, CollectionReader } from '../util/Collection';
-import { ObservableObject } from './Mvcc';
+import { Collection, Item, CollectionReader } from '../util/Collection.js';
+import { ObservableObject } from './Mvcc.js';
 export declare abstract class ObservableCollection<T> extends ObservableObject implements CollectionReader<T> {
     protected abstract impl: Collection<T>;
     get isStrict(): boolean;

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

@@ -1,4 +1,4 @@
-import { ObservableObject } from './Mvcc';
+import { ObservableObject } from './Mvcc.js';
 export class ObservableCollection extends ObservableObject {
     get isStrict() { return this.impl.isStrict; }
     get count() { return this.impl.count; }

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

@@ -1,4 +1,4 @@
-import { MvccObject } from './Mvcc';
+import { MvccObject } from './Mvcc.js';
 export declare class MvccMap<K, V> extends MvccObject {
     private impl;
     constructor(isObservable: boolean, map: Map<K, V>);

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

@@ -1,5 +1,5 @@
-import { Sealant } from '../util/Sealant';
-import { MvccObject } from './Mvcc';
+import { Sealant } from '../util/Sealant.js';
+import { MvccObject } from './Mvcc.js';
 export class MvccMap extends MvccObject {
     constructor(isObservable, map) {
         super(isObservable);

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

@@ -1,9 +1,9 @@
-import { F } from '../util/Utils';
-import { MemberOptions } from '../Options';
-import { Controller } from '../Controller';
-import { MemberName, ObjectHandle, Observable, Observer, Subscription, AbstractChangeset } from './Data';
-import { Transaction } from './Transaction';
-import { OptionsImpl } from './Mvcc';
+import { F } from '../util/Utils.js';
+import { MemberOptions } from '../Options.js';
+import { Controller } from '../Controller.js';
+import { MemberName, ObjectHandle, ObservableValue, Observer, Subscription, AbstractChangeset } from './Data.js';
+import { Transaction } from './Transaction.js';
+import { OptionsImpl } from './Mvcc.js';
 export declare class OperationController extends Controller<any> {
     readonly objectHandle: ObjectHandle;
     readonly memberName: MemberName;
@@ -32,7 +32,7 @@ export declare class OperationController extends Controller<any> {
     private run;
     private static markObsolete;
 }
-declare class Operation extends Observable implements Observer {
+declare class Operation extends ObservableValue implements Observer {
     static current?: Operation;
     static queuedReactiveFunctions: Array<Observer>;
     static deferredReactiveFunctions: Array<Operation>;
@@ -40,7 +40,7 @@ declare class Operation extends Observable implements Observer {
     readonly transaction: Transaction;
     readonly controller: OperationController;
     readonly changeset: AbstractChangeset;
-    observables: Map<Observable, Subscription> | undefined;
+    observables: Map<ObservableValue, Subscription> | undefined;
     options: OptionsImpl;
     cause: string | undefined;
     args: any[];
@@ -61,7 +61,7 @@ declare class Operation extends Observable implements Observer {
     dependencies(): string[];
     wrap<T>(func: F<T>): F<T>;
     run(proxy: any, args: any[] | undefined): void;
-    markObsoleteDueTo(observable: Observable, m: MemberName, changeset: AbstractChangeset, h: ObjectHandle, outer: string, since: number, reactive: Observer[]): void;
+    markObsoleteDueTo(observable: ObservableValue, 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;
@@ -83,7 +83,7 @@ declare class Operation extends Observable implements Observer {
     private static runQueuedReactiveLoop;
     private unsubscribeFromAllObservables;
     private subscribeTo;
-    private static canSubscribe;
+    private static canSubscribeTo;
     private static createOperation;
     private static rememberOperationOptions;
     static init(): void;

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

@@ -1,12 +1,12 @@
-import { Log, misuse } from '../util/Dbg';
-import { Kind, Reentrance } from '../Options';
-import { Controller } from '../Controller';
-import { ObjectHandle, Observable, Meta } from './Data';
-import { Changeset, Dump, EMPTY_SNAPSHOT, MAX_REVISION } from './Changeset';
-import { Transaction } from './Transaction';
-import { MonitorImpl } from './Monitor';
-import { Mvcc, OptionsImpl } from './Mvcc';
-import { JournalImpl } from './Journal';
+import { Log, misuse } from '../util/Dbg.js';
+import { Kind, Reentrance } from '../Options.js';
+import { Controller } from '../Controller.js';
+import { ObjectHandle, ObservableValue, Meta } from './Data.js';
+import { Changeset, Dump, EMPTY_SNAPSHOT, MAX_REVISION } from './Changeset.js';
+import { Transaction } from './Transaction.js';
+import { MonitorImpl } from './Monitor.js';
+import { Mvcc, OptionsImpl } from './Mvcc.js';
+import { JournalImpl } from './Journal.js';
 const BOOT_ARGS = [];
 const BOOT_CAUSE = '<boot>';
 const EMPTY_HANDLE = new ObjectHandle(undefined, undefined, Mvcc.observable, EMPTY_SNAPSHOT, '<boot>');
@@ -199,7 +199,7 @@ 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 Observable {
+class Operation extends ObservableValue {
     constructor(controller, changeset, former) {
         super(undefined);
         this.margin = Operation.current ? Operation.current.margin + 1 : 1;
@@ -499,7 +499,7 @@ class Operation extends Observable {
         const curr = os.data[m];
         if (reactive) {
             const former = os.former.snapshot.data[m];
-            if (former !== undefined && former instanceof Observable) {
+            if (former !== undefined && former instanceof ObservableValue) {
                 const why = `T${os.changeset.id}[${os.changeset.hint}]`;
                 if (former instanceof Operation) {
                     if ((former.obsoleteSince === MAX_REVISION || former.obsoleteSince <= 0)) {
@@ -530,7 +530,7 @@ class Operation extends Observable {
                     curr.unsubscribeFromAllObservables();
             }
         }
-        else if (curr instanceof Observable && curr.observers) {
+        else if (curr instanceof ObservableValue && curr.observers) {
         }
     }
     static enqueueReactiveFunctionsToRun(reactive) {
@@ -563,7 +563,7 @@ class Operation extends Observable {
     }
     subscribeTo(observable, os, m, h, timestamp) {
         var _a, _b, _c;
-        const ok = Operation.canSubscribe(observable, os, m, h, timestamp);
+        const ok = Operation.canSubscribeTo(observable, os, m, h, timestamp);
         if (ok) {
             let times = 0;
             if (Mvcc.repetitiveUsageWarningThreshold < Number.MAX_SAFE_INTEGER) {
@@ -588,7 +588,7 @@ class Operation extends Observable {
         }
         return ok;
     }
-    static canSubscribe(observable, os, m, h, timestamp) {
+    static canSubscribeTo(observable, os, m, h, timestamp) {
         const observableHead = h.head.data[m];
         let result = observable === observableHead || (!os.changeset.sealed && os.former.snapshot.data[m] === observableHead);
         if (result && timestamp !== -1)

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

@@ -1,7 +1,7 @@
-import { F } from '../util/Utils';
-import { Worker } from '../Worker';
-import { SnapshotOptions } from '../Options';
-import { Changeset } from './Changeset';
+import { F } from '../util/Utils.js';
+import { Worker } from '../Worker.js';
+import { SnapshotOptions } from '../Options.js';
+import { Changeset } from './Changeset.js';
 export declare abstract class Transaction implements Worker {
     static get current(): Transaction;
     abstract readonly id: number;

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

@@ -7,9 +7,9 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-import { UNDEF, pause } from '../util/Utils';
-import { Log, misuse, error, fatal } from '../util/Dbg';
-import { Changeset, Dump } from './Changeset';
+import { UNDEF, pause } from '../util/Utils.js';
+import { Log, misuse, error, fatal } from '../util/Dbg.js';
+import { Changeset, Dump } from './Changeset.js';
 export class Transaction {
     static get current() { return TransactionImpl.current; }
     whenFinished() {

package/build/dist/source/util/Dbg.d.ts

@@ -1,4 +1,4 @@
-import { LoggingOptions } from '../Logging';
+import { LoggingOptions } from '../Logging.js';
 export declare function error(message: string, dump: Error | undefined): Error;
 export declare function misuse(message: string, dump?: any): Error;
 export declare function fatal(error: Error): Error;

package/build/dist/source/util/Sealant.js

@@ -1,4 +1,4 @@
-import { Log, misuse } from './Dbg';
+import { Log, misuse } from './Dbg.js';
 export class Sealant {
     static seal(collection, sealedType, typeName, member) {
         let result = collection;

package/build/dist/source/util/SealedArray.d.ts

@@ -1,4 +1,4 @@
-import { Sealant, Sealed } from './Sealant';
+import { Sealant, Sealed } from './Sealant.js';
 declare global {
     interface Array<T> {
         toMutable(): Array<T>;

package/build/dist/source/util/SealedArray.js

@@ -1,4 +1,4 @@
-import { Sealant } from './Sealant';
+import { Sealant } from './Sealant.js';
 export class SealedArray extends Array {
     pop() { throw Sealant.error(this); }
     push(...items) { throw Sealant.error(this); }

package/build/dist/source/util/SealedMap.d.ts

@@ -1,4 +1,4 @@
-import { Sealant, Sealed } from './Sealant';
+import { Sealant, Sealed } from './Sealant.js';
 declare global {
     interface Map<K, V> {
         toMutable(): Map<K, V>;

package/build/dist/source/util/SealedMap.js

@@ -1,4 +1,4 @@
-import { Sealant } from './Sealant';
+import { Sealant } from './Sealant.js';
 export class SealedMap extends Map {
     clear() { throw Sealant.error(this); }
     delete(key) { throw Sealant.error(this); }

package/build/dist/source/util/SealedSet.d.ts

@@ -1,4 +1,4 @@
-import { Sealant, Sealed } from './Sealant';
+import { Sealant, Sealed } from './Sealant.js';
 declare global {
     interface Set<T> {
         toMutable(): Set<T>;

package/build/dist/source/util/SealedSet.js

@@ -1,4 +1,4 @@
-import { Sealant } from './Sealant';
+import { Sealant } from './Sealant.js';
 export class SealedSet extends Set {
     add(value) { throw Sealant.error(this); }
     clear() { throw Sealant.error(this); }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "reactronic",
-  "version": "0.23.103",
+  "version": "0.23.105",
   "description": "Reactronic - Transactional Reactive State Management",
   "publisher": "Nezaboodka Software",
   "license": "Apache-2.0",
@@ -31,21 +31,21 @@
   },
   "homepage": "https://github.com/nezaboodka/reactronic/blob/master/README.md#readme",
   "devDependencies": {
-    "@types/node": "18.11.18",
-    "@types/react": "18.0.26",
-    "@typescript-eslint/eslint-plugin": "5.47.1",
-    "@typescript-eslint/parser": "5.47.1",
-    "ava": "4.3.3",
-    "c8": "7.12.0",
-    "eslint": "8.30.0",
+    "@types/node": "20.6.3",
+    "@types/react": "18.2.22",
+    "@typescript-eslint/eslint-plugin": "6.7.2",
+    "@typescript-eslint/parser": "6.7.2",
+    "ava": "5.3.1",
+    "c8": "8.0.1",
+    "eslint": "8.49.0",
     "react": "18.2.0",
     "ts-node": "10.9.1",
-    "typescript": "4.9.4"
+    "typescript": "5.2.2"
   },
   "scripts": {
-    "build": "eslint source/**/*.ts test/**/*.ts react/**/*.tsx && tsc",
-    "fix": "eslint --fix source/**/*.ts test/**/*.ts react/**/*.tsx",
-    "pack": "eslint source/**/*.ts test/**/*.ts react/**/*.tsx && tsc --sourceMap false --removeComments true",
+    "build": "eslint source/**/*.ts test/**/*.test.ts react/**/*.tsx && tsc",
+    "fix": "eslint --fix source/**/*.ts test/**/*.test.ts react/**/*.tsx",
+    "pack": "eslint source/**/*.ts test/**/*.test.ts react/**/*.tsx && tsc --sourceMap false --removeComments true",
     "test": "ava",
     "cover": "c8 ava && open build/coverage/index.html"
   }