reactronic 0.24.125 → 0.24.127

package/README.md

@@ -253,11 +253,11 @@ of recurring changes:
 **Reentrance** option defines how to handle reentrant calls of transactional
 and reactive functions:
 
-  - `PreventWithError` - fail with error if there is an existing call in progress;
-  - `WaitAndRestart` - wait for previous call to finish and then restart current one;
-  - `CancelPrevious` - cancel previous call in favor of recent one;
-  - `CancelAndWaitPrevious` - cancel previous call in favor of recent one (but wait until canceling is completed)
-  - `RunSideBySide` - multiple simultaneous calls are allowed.
+  - `preventWithError` - fail with error if there is an existing call in progress;
+  - `waitAndRestart` - wait for previous call to finish and then restart current one;
+  - `cancelPrevious` - cancel previous call in favor of recent one;
+  - `cancelAndWaitPrevious` - cancel previous call in favor of recent one (but wait until canceling is completed)
+  - `runSideBySide` - multiple simultaneous calls are allowed.
 
 **Monitor** is an object that maintains status of running functions,
 which it is attached to. A single monitor object can be shared between
@@ -330,19 +330,19 @@ type MemberOptions = {
 }
 
 enum Kind {
-  Plain = 0,
-  Transactional = 1,
-  Reactive = 2,
-  Cached = 3
+  plain = 0,
+  transactional = 1,
+  reactive = 2,
+  cached = 3
 }
 
 enum Reentrance {
-  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
+  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
 }
 
 class Monitor {
@@ -446,181 +446,6 @@ 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 unobs<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/Options.d.ts

@@ -24,18 +24,18 @@ export type MemberOptions = {
     readonly logging?: Partial<LoggingOptions>;
 };
 export declare enum Kind {
-    Plain = 0,
-    Transactional = 1,
-    Reactive = 2,
-    Cached = 3
+    plain = 0,
+    transactional = 1,
+    reactive = 2,
+    cached = 3
 }
 export declare enum Reentrance {
-    PreventWithError = 1,
-    WaitAndRestart = 0,
-    CancelPrevious = -1,
-    CancelAndWaitPrevious = -2,
-    OverwritePrevious = -3,
-    RunSideBySide = -4
+    preventWithError = 1,
+    waitAndRestart = 0,
+    cancelPrevious = -1,
+    cancelAndWaitPrevious = -2,
+    overwritePrevious = -3,
+    runSideBySide = -4
 }
 export type AbstractReaction<T> = {
     readonly options: MemberOptions;

package/build/dist/source/Options.js

@@ -1,17 +1,17 @@
 export { LoggingLevel } from "./Logging.js";
 export var Kind;
 (function (Kind) {
-    Kind[Kind["Plain"] = 0] = "Plain";
-    Kind[Kind["Transactional"] = 1] = "Transactional";
-    Kind[Kind["Reactive"] = 2] = "Reactive";
-    Kind[Kind["Cached"] = 3] = "Cached";
+    Kind[Kind["plain"] = 0] = "plain";
+    Kind[Kind["transactional"] = 1] = "transactional";
+    Kind[Kind["reactive"] = 2] = "reactive";
+    Kind[Kind["cached"] = 3] = "cached";
 })(Kind || (Kind = {}));
 export var Reentrance;
 (function (Reentrance) {
-    Reentrance[Reentrance["PreventWithError"] = 1] = "PreventWithError";
-    Reentrance[Reentrance["WaitAndRestart"] = 0] = "WaitAndRestart";
-    Reentrance[Reentrance["CancelPrevious"] = -1] = "CancelPrevious";
-    Reentrance[Reentrance["CancelAndWaitPrevious"] = -2] = "CancelAndWaitPrevious";
-    Reentrance[Reentrance["OverwritePrevious"] = -3] = "OverwritePrevious";
-    Reentrance[Reentrance["RunSideBySide"] = -4] = "RunSideBySide";
+    Reentrance[Reentrance["preventWithError"] = 1] = "preventWithError";
+    Reentrance[Reentrance["waitAndRestart"] = 0] = "waitAndRestart";
+    Reentrance[Reentrance["cancelPrevious"] = -1] = "cancelPrevious";
+    Reentrance[Reentrance["cancelAndWaitPrevious"] = -2] = "cancelAndWaitPrevious";
+    Reentrance[Reentrance["overwritePrevious"] = -3] = "overwritePrevious";
+    Reentrance[Reentrance["runSideBySide"] = -4] = "runSideBySide";
 })(Reentrance || (Reentrance = {}));

package/build/dist/source/RxSystem.js

@@ -38,15 +38,15 @@ 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 };
     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, 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, noSideEffects: true };
     return Mvcc.decorateOperation(true, cached, opts, proto, prop, pd);
 }
 export function options(value) {

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

@@ -26,13 +26,13 @@ export class ObservableObject extends MvccObject {
     }
 }
 const DEFAULT_OPTIONS = Object.freeze({
-    kind: Kind.Plain,
+    kind: Kind.plain,
     separation: false,
     order: 0,
     noSideEffects: false,
     triggeringArgs: false,
     throttling: Number.MAX_SAFE_INTEGER,
-    reentrance: Reentrance.PreventWithError,
+    reentrance: Reentrance.preventWithError,
     journal: undefined,
     monitor: null,
     logging: undefined,
@@ -74,7 +74,7 @@ export class Mvcc {
             result = os.data[m];
             if (result instanceof ValueSnapshot && !result.isOperation) {
                 if (this.isObservable)
-                    Changeset.markUsed(result, os, m, h, Kind.Plain, false);
+                    Changeset.markUsed(result, os, m, h, Kind.plain, false);
                 result = result.content;
             }
             else

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

@@ -79,7 +79,7 @@ declare class Launch extends ValueSnapshot implements Observer {
     private static revokeAllSubscriptions;
     private static propagateMemberChangeThroughSubscriptions;
     private static enqueueReactiveFunctionsToRun;
-    private static runQueuedReactiveFunctions;
+    private static processQueuedReactiveFunctions;
     private unsubscribeFromAllObservables;
     private subscribeTo;
     private static canSubscribeTo;

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

@@ -34,9 +34,9 @@ export class ReactionImpl {
             && (!weak || launch.cause === BOOT_CAUSE || !launch.successor ||
                 launch.successor.transaction.isFinished)) {
             const outerOpts = (_a = Launch.current) === null || _a === void 0 ? void 0 : _a.options;
-            const separation = weak || opts.separation !== false || opts.kind === Kind.Reactive ||
-                (opts.kind === Kind.Transactional && outerOpts && (outerOpts.noSideEffects || outerOpts.kind === Kind.Cached)) ||
-                (opts.kind === Kind.Cached && (ror.snapshot.changeset.sealed ||
+            const separation = weak || opts.separation !== false || opts.kind === Kind.reactive ||
+                (opts.kind === Kind.transactional && outerOpts && (outerOpts.noSideEffects || outerOpts.kind === Kind.cached)) ||
+                (opts.kind === Kind.cached && (ror.snapshot.changeset.sealed ||
                     ror.snapshot.former.snapshot !== EMPTY_SNAPSHOT));
             const token = opts.noSideEffects ? this : undefined;
             const ror2 = this.relaunch(ror, separation, opts, token, args);
@@ -103,7 +103,7 @@ export class ReactionImpl {
         const ctx = Changeset.current();
         const os = ctx.lookupObjectSnapshot(this.objectHandle, this.memberName);
         const launch = this.acquireFromSnapshot(os, args);
-        const isValid = launch.options.kind !== Kind.Transactional && launch.cause !== BOOT_CAUSE &&
+        const isValid = launch.options.kind !== Kind.transactional && launch.cause !== BOOT_CAUSE &&
             (ctx === launch.changeset || ctx.timestamp < launch.obsoleteSince) &&
             (!launch.options.triggeringArgs || args === undefined ||
                 launch.args.length === args.length && launch.args.every((t, i) => t === args[i])) || os.disposed;
@@ -179,7 +179,7 @@ export class ReactionImpl {
             }
             else {
                 ror = this.peek(argsx);
-                if (ror.launch.options.kind === Kind.Transactional || !ror.isUpToDate) {
+                if (ror.launch.options.kind === Kind.transactional || !ror.isUpToDate) {
                     ror = this.edit();
                     if (Log.isOn && Log.opt.operation)
                         Log.write("║", "  o", `${ror.launch.why()}`);
@@ -231,7 +231,7 @@ class Launch extends ValueSnapshot {
         let cause;
         if (this.cause)
             cause = `   ◀◀   ${this.cause}`;
-        else if (this.reaction.options.kind === Kind.Transactional)
+        else if (this.reaction.options.kind === Kind.transactional)
             cause = "   ◀◀   operation";
         else
             cause = `   ◀◀   T${this.changeset.id}[${this.changeset.hint}]`;
@@ -274,7 +274,7 @@ class Launch extends ValueSnapshot {
                 changeset === this.changeset;
             if (!skip) {
                 const why = `${Dump.snapshot2(h, changeset, m, observable)}    ◀◀    ${outer}`;
-                const isReactive = this.options.kind === Kind.Reactive;
+                const isReactive = this.options.kind === Kind.reactive;
                 this.obsoleteDueTo = why;
                 this.obsoleteSince = since;
                 if (Log.isOn && (Log.opt.obsolete || ((_a = this.options.logging) === null || _a === void 0 ? void 0 : _a.obsolete)))
@@ -306,14 +306,14 @@ class Launch extends ValueSnapshot {
                     const launch = this.reaction.reuseOrRelaunch(false, undefined);
                     if (launch.result instanceof Promise)
                         launch.result.catch(error => {
-                            if (launch.options.kind === Kind.Reactive)
+                            if (launch.options.kind === Kind.reactive)
                                 misuse(`reactive function ${launch.hint()} failed and will not run anymore: ${error}`, error);
                         });
                 }
                 catch (e) {
                     if (!nothrow)
                         throw e;
-                    else if (this.options.kind === Kind.Reactive)
+                    else if (this.options.kind === Kind.reactive)
                         misuse(`reactive ${this.hint()} failed and will not run anymore: ${e}`, e);
                 }
             }
@@ -326,7 +326,7 @@ class Launch extends ValueSnapshot {
         }
     }
     isNotUpToDate() {
-        return !this.error && (this.options.kind === Kind.Transactional ||
+        return !this.error && (this.options.kind === Kind.transactional ||
             !this.successor || this.successor.transaction.isCanceled);
     }
     reenterOver(head) {
@@ -336,25 +336,25 @@ class Launch extends ValueSnapshot {
             if (Log.isOn && Log.opt.obsolete)
                 Log.write("║", " [!]", `${this.hint()} is trying to re-enter over ${opponent.hint()}`);
             switch (head.options.reentrance) {
-                case Reentrance.PreventWithError:
+                case Reentrance.preventWithError:
                     if (!opponent.transaction.isCanceled)
                         throw misuse(`${head.hint()} (${head.why()}) is not reentrant over ${opponent.hint()} (${opponent.why()})`);
                     error = new Error(`T${this.transaction.id}[${this.transaction.hint}] is on hold/PreventWithError due to canceled T${opponent.transaction.id}[${opponent.transaction.hint}]`);
                     this.transaction.cancel(error, opponent.transaction);
                     break;
-                case Reentrance.WaitAndRestart:
+                case Reentrance.waitAndRestart:
                     error = new Error(`T${this.transaction.id}[${this.transaction.hint}] is on hold/WaitAndRestart due to active T${opponent.transaction.id}[${opponent.transaction.hint}]`);
                     this.transaction.cancel(error, opponent.transaction);
                     break;
-                case Reentrance.CancelAndWaitPrevious:
+                case Reentrance.cancelAndWaitPrevious:
                     error = new Error(`T${this.transaction.id}[${this.transaction.hint}] is on hold/CancelAndWaitPrevious due to active T${opponent.transaction.id}[${opponent.transaction.hint}]`);
                     this.transaction.cancel(error, opponent.transaction);
                     opponent.transaction.cancel(new Error(`T${opponent.transaction.id}[${opponent.transaction.hint}] is canceled due to re-entering T${this.transaction.id}[${this.transaction.hint}]`), null);
                     break;
-                case Reentrance.CancelPrevious:
+                case Reentrance.cancelPrevious:
                     opponent.transaction.cancel(new Error(`T${opponent.transaction.id}[${opponent.transaction.hint}] is canceled due to re-entering T${this.transaction.id}[${this.transaction.hint}]`), null);
                     break;
-                case Reentrance.RunSideBySide:
+                case Reentrance.runSideBySide:
                     break;
             }
         }
@@ -447,9 +447,9 @@ class Launch extends ValueSnapshot {
             x.relaunchIfNotUpToDate(true, true);
     }
     static markUsed(observable, os, m, h, kind, weak) {
-        if (kind !== Kind.Transactional) {
+        if (kind !== Kind.transactional) {
             const launch = Launch.current;
-            if (launch && launch.options.kind !== Kind.Transactional &&
+            if (launch && launch.options.kind !== Kind.transactional &&
                 launch.transaction === Transaction.current && m !== Meta.Handle) {
                 const ctx = Changeset.current();
                 if (ctx !== os.changeset)
@@ -537,9 +537,9 @@ class Launch extends ValueSnapshot {
         for (const r of reactive)
             queue.push(r);
         if (isReactiveLoopRequired)
-            ReactionImpl.proceedWithinGivenLaunch(undefined, Launch.runQueuedReactiveFunctions);
+            ReactionImpl.proceedWithinGivenLaunch(undefined, Launch.processQueuedReactiveFunctions);
     }
-    static runQueuedReactiveFunctions() {
+    static processQueuedReactiveFunctions() {
         const queue = Launch.queuedReactiveFunctions;
         let i = 0;
         while (i < queue.length) {
@@ -607,11 +607,11 @@ class Launch extends ValueSnapshot {
         const rx = launch ? launch.reaction : new ReactionImpl(EMPTY_HANDLE, m);
         const opts = launch ? launch.options : OptionsImpl.INITIAL;
         initial[m] = launch = new Launch(rx, EMPTY_SNAPSHOT.changeset, new OptionsImpl(getter, setter, opts, options, implicit));
-        if (launch.options.kind === Kind.Reactive && launch.options.throttling < Number.MAX_SAFE_INTEGER) {
+        if (launch.options.kind === Kind.reactive && launch.options.throttling < Number.MAX_SAFE_INTEGER) {
             const reactive = Meta.acquire(proto, Meta.Reactive);
             reactive[m] = launch;
         }
-        else if (launch.options.kind === Kind.Reactive && launch.options.throttling >= Number.MAX_SAFE_INTEGER) {
+        else if (launch.options.kind === Kind.reactive && launch.options.throttling >= Number.MAX_SAFE_INTEGER) {
             const reactive = Meta.getFrom(proto, Meta.Reactive);
             delete reactive[m];
         }

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

@@ -4,14 +4,14 @@ import { MemberOptions } from "../Options.js";
 export type Delegate<T> = (element: T, base: () => void) => void;
 export type SimpleDelegate<T = unknown, R = void> = (element: T) => R;
 export declare enum Mode {
-    Default = 0,
-    IndependentUpdate = 1,
-    ManualMount = 2
+    default = 0,
+    independentUpdate = 1,
+    manualMount = 2
 }
 export declare const enum Priority {
-    Realtime = 0,
-    Normal = 1,
-    Background = 2
+    realtime = 0,
+    normal = 1,
+    background = 2
 }
 export declare abstract class RxNode<E = unknown> {
     abstract readonly key: string;
@@ -45,6 +45,7 @@ export declare abstract class RxNode<E = unknown> {
     static get childrenShuffling(): boolean;
     static set childrenShuffling(value: boolean);
     static triggerUpdate(node: RxNode<any>, triggers: unknown): void;
+    static triggerFinalize(node: RxNode<any>): void;
     static updateNestedNodesThenDo(action: (error: unknown) => void): void;
     static markAsMounted(node: RxNode<any>, yes: boolean): void;
     static findMatchingHost<E = unknown, R = unknown>(node: RxNode<E>, match: SimpleDelegate<RxNode<E>, boolean>): RxNode<R> | undefined;

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

@@ -24,15 +24,15 @@ import { Transaction } from "../core/Transaction.js";
 import { RxSystem, options, raw, reactive, unobs } from "../RxSystem.js";
 export var Mode;
 (function (Mode) {
-    Mode[Mode["Default"] = 0] = "Default";
-    Mode[Mode["IndependentUpdate"] = 1] = "IndependentUpdate";
-    Mode[Mode["ManualMount"] = 2] = "ManualMount";
+    Mode[Mode["default"] = 0] = "default";
+    Mode[Mode["independentUpdate"] = 1] = "independentUpdate";
+    Mode[Mode["manualMount"] = 2] = "manualMount";
 })(Mode || (Mode = {}));
 export var Priority;
 (function (Priority) {
-    Priority[Priority["Realtime"] = 0] = "Realtime";
-    Priority[Priority["Normal"] = 1] = "Normal";
-    Priority[Priority["Background"] = 2] = "Background";
+    Priority[Priority["realtime"] = 0] = "realtime";
+    Priority[Priority["normal"] = 1] = "normal";
+    Priority[Priority["background"] = 2] = "background";
 })(Priority || (Priority = {}));
 export class RxNode {
     static acquire(driver, declaration, preset) {
@@ -106,6 +106,10 @@ export class RxNode {
             triggerUpdateViaSeat(impl.seat);
         }
     }
+    static triggerFinalize(node) {
+        const impl = node;
+        triggerFinalization(impl.seat, true, true);
+    }
     static updateNestedNodesThenDo(action) {
         runUpdateNestedNodesThenDo(undefined, action);
     }
@@ -143,7 +147,7 @@ export class RxNode {
 }
 RxNode.shortFrameDuration = 16;
 RxNode.longFrameDuration = 300;
-RxNode.currentUpdatePriority = Priority.Realtime;
+RxNode.currentUpdatePriority = Priority.realtime;
 RxNode.frameDuration = RxNode.longFrameDuration;
 export class BaseDriver {
     constructor(name, isPartitionSeparator, predefine) {
@@ -192,7 +196,7 @@ function generateKey(owner) {
 }
 function getModeViaPresetChain(declaration) {
     var _a;
-    return (_a = declaration === null || declaration === void 0 ? void 0 : declaration.mode) !== null && _a !== void 0 ? _a : ((declaration === null || declaration === void 0 ? void 0 : declaration.preset) ? getModeViaPresetChain(declaration === null || declaration === void 0 ? void 0 : declaration.preset) : Mode.Default);
+    return (_a = declaration === null || declaration === void 0 ? void 0 : declaration.mode) !== null && _a !== void 0 ? _a : ((declaration === null || declaration === void 0 ? void 0 : declaration.preset) ? getModeViaPresetChain(declaration === null || declaration === void 0 ? void 0 : declaration.preset) : Mode.default);
 }
 function initializeViaPresetChain(element, declaration) {
     const preset = declaration.preset;
@@ -259,10 +263,10 @@ class RxNodeImpl extends RxNode {
         this.stamp = Number.MAX_SAFE_INTEGER;
         this.context = undefined;
         this.numerator = 0;
-        this.priority = Priority.Realtime;
+        this.priority = Priority.realtime;
         this.childrenShuffling = false;
         RxNodeImpl.grandNodeCount++;
-        if (this.has(Mode.IndependentUpdate))
+        if (this.has(Mode.independentUpdate))
             RxNodeImpl.disposableNodeCount++;
     }
     get strictOrder() { return this.children.isStrict; }
@@ -275,7 +279,7 @@ class RxNodeImpl extends RxNode {
         updateNow(this.seat);
     }
     configureReactronic(options) {
-        if (this.stamp < Number.MAX_SAFE_INTEGER - 1 || !this.has(Mode.IndependentUpdate))
+        if (this.stamp < Number.MAX_SAFE_INTEGER - 1 || !this.has(Mode.independentUpdate))
             throw new Error("reactronic can be configured only for elements with independent update mode and only inside initialize");
         return RxSystem.getReaction(this.update).configure(options);
     }
@@ -329,7 +333,7 @@ RxNodeImpl.disposableNodeCount = 0;
 __decorate([
     reactive,
     options({
-        reentrance: Reentrance.CancelPrevious,
+        reentrance: Reentrance.cancelPrevious,
         triggeringArgs: true,
         noSideEffects: false,
     }),
@@ -363,11 +367,11 @@ function runUpdateNestedNodesThenDo(error, action) {
                     const childNode = child.instance;
                     const isPart = childNode.driver.isPartitionSeparator;
                     const host = isPart ? owner : partition;
-                    const p = (_a = childNode.priority) !== null && _a !== void 0 ? _a : Priority.Realtime;
+                    const p = (_a = childNode.priority) !== null && _a !== void 0 ? _a : Priority.realtime;
                     mounting = markToMountIfNecessary(mounting, host, child, children, sequential);
-                    if (p === Priority.Realtime)
+                    if (p === Priority.realtime)
                         triggerUpdateViaSeat(child);
-                    else if (p === Priority.Normal)
+                    else if (p === Priority.normal)
                         p1 = push(child, p1);
                     else
                         p2 = push(child, p2);
@@ -386,7 +390,7 @@ function runUpdateNestedNodesThenDo(error, action) {
 }
 function markToMountIfNecessary(mounting, host, seat, children, sequential) {
     const node = seat.instance;
-    if (node.element.native && !node.has(Mode.ManualMount)) {
+    if (node.element.native && !node.has(Mode.manualMount)) {
         if (mounting || node.host !== host) {
             children.markAsMoved(seat);
             mounting = false;
@@ -401,9 +405,9 @@ function startIncrementalUpdate(ownerSeat, allChildren, priority1, priority2) {
     return __awaiter(this, void 0, void 0, function* () {
         const stamp = ownerSeat.instance.stamp;
         if (priority1)
-            yield updateIncrementally(ownerSeat, stamp, allChildren, priority1, Priority.Normal);
+            yield updateIncrementally(ownerSeat, stamp, allChildren, priority1, Priority.normal);
         if (priority2)
-            yield updateIncrementally(ownerSeat, stamp, allChildren, priority2, Priority.Background);
+            yield updateIncrementally(ownerSeat, stamp, allChildren, priority2, Priority.background);
     });
 }
 function updateIncrementally(owner, stamp, allChildren, items, priority) {
@@ -416,7 +420,7 @@ function updateIncrementally(owner, stamp, allChildren, items, priority) {
             try {
                 if (node.childrenShuffling)
                     shuffle(items);
-                const frameDurationLimit = priority === Priority.Background ? RxNode.shortFrameDuration : Infinity;
+                const frameDurationLimit = priority === Priority.background ? RxNode.shortFrameDuration : Infinity;
                 let frameDuration = Math.min(frameDurationLimit, Math.max(RxNode.frameDuration / 4, RxNode.shortFrameDuration));
                 for (const child of items) {
                     triggerUpdateViaSeat(child);
@@ -440,7 +444,7 @@ function updateIncrementally(owner, stamp, allChildren, items, priority) {
 function triggerUpdateViaSeat(seat) {
     const node = seat.instance;
     if (node.stamp >= 0) {
-        if (node.has(Mode.IndependentUpdate)) {
+        if (node.has(Mode.independentUpdate)) {
             if (node.stamp === Number.MAX_SAFE_INTEGER) {
                 Transaction.outside(() => {
                     if (RxSystem.isLogging)
@@ -462,14 +466,14 @@ function mountOrRemountIfNecessary(node) {
         unobs(() => {
             node.stamp = Number.MAX_SAFE_INTEGER - 1;
             driver.initialize(node);
-            if (!node.has(Mode.ManualMount)) {
+            if (!node.has(Mode.manualMount)) {
                 node.stamp = 0;
                 if (node.host !== node)
                     driver.mount(node);
             }
         });
     }
-    else if (node.isMoved && !node.has(Mode.ManualMount) && node.host !== node)
+    else if (node.isMoved && !node.has(Mode.manualMount) && node.host !== node)
         unobs(() => driver.mount(node));
 }
 function updateNow(seat) {
@@ -507,7 +511,7 @@ function triggerFinalization(seat, isLeader, individual) {
             console.log(`WARNING: it is recommended to assign explicit key for conditional element in order to avoid unexpected side effects: ${node.key}`);
         node.stamp = ~node.stamp;
         const childrenAreLeaders = unobs(() => driver.finalize(node, isLeader));
-        if (node.has(Mode.IndependentUpdate)) {
+        if (node.has(Mode.independentUpdate)) {
             seat.aux = undefined;
             const last = gLastToDispose;
             if (last)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "reactronic",
-  "version": "0.24.125",
+  "version": "0.24.127",
   "description": "Reactronic - Transactional Reactive State Management",
   "publisher": "Nezaboodka Software",
   "license": "Apache-2.0",
@@ -31,16 +31,16 @@
   },
   "homepage": "https://github.com/nezaboodka/reactronic/blob/master/README.md#readme",
   "devDependencies": {
-    "@types/node": "20.10.0",
-    "@types/react": "18.2.39",
-    "@typescript-eslint/eslint-plugin": "6.13.1",
-    "@typescript-eslint/parser": "6.13.1",
-    "ava": "5.3.1",
-    "c8": "8.0.1",
-    "eslint": "8.54.0",
+    "@types/node": "20.11.16",
+    "@types/react": "18.2.52",
+    "@typescript-eslint/eslint-plugin": "6.20.0",
+    "@typescript-eslint/parser": "6.20.0",
+    "ava": "6.1.1",
+    "c8": "9.1.0",
+    "eslint": "8.56.0",
     "react": "18.2.0",
-    "ts-node": "10.9.1",
-    "typescript": "5.2.2"
+    "ts-node": "10.9.2",
+    "typescript": "5.3.2"
   },
   "scripts": {
     "build": "eslint source/**.ts test/**.test.ts react/**.tsx && tsc",