verstak 0.94.25032 → 0.95.25044

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

@@ -1,4 +1,4 @@
-import { ReactiveTreeNode, Mode, runNonReactively } from "reactronic";
+import { ReactiveTreeNode, Mode, declare, derivative, launch, runNonReactive } from "reactronic";
 import { ElKind, Direction } from "./El.js";
 import { clamp } from "./ElUtils.js";
 import { Constants, CursorCommandDriver, ElDriver, ElLayoutInfo, InitialElLayoutInfo } from "./ElDriver.js";
@@ -6,24 +6,24 @@ import { getPrioritiesForEmptySpaceDistribution, getPrioritiesForSizeChanging, r
 import { Axis, BodyFontSize, Dimension, toPx } from "./Sizes.js";
 import { HtmlDriver, StaticDriver } from "./WebDriver.js";
 export function Window(scriptOrDeclaration, scriptAsync, key, mode, preparation, preparationAsync, finalization, triggers, basis) {
-    const driver = new StaticDriver(global.document.body, "Page", false, el => el.kind = ElKind.division);
-    return ReactiveTreeNode.declare(driver, scriptOrDeclaration, scriptAsync, key, mode, preparation, preparationAsync, finalization, triggers, basis);
+    const driver = new StaticDriver(global.document.body, "Page", false, el => el.kind = ElKind.block);
+    return declare(driver, scriptOrDeclaration, scriptAsync, key, mode, preparation, preparationAsync, finalization, triggers, basis);
 }
-export function Division(scriptOrDeclaration, scriptAsync, key, mode, preparation, preparationAsync, finalization, triggers, basis) {
-    return ReactiveTreeNode.declare(Drivers.division, scriptOrDeclaration, scriptAsync, key, mode, preparation, preparationAsync, finalization, triggers, basis);
+export function Block(scriptOrDeclaration, scriptAsync, key, mode, preparation, preparationAsync, finalization, triggers, basis) {
+    return declare(Drivers.block, scriptOrDeclaration, scriptAsync, key, mode, preparation, preparationAsync, finalization, triggers, basis);
 }
 export function Table(scriptOrDeclaration, scriptAsync, key, mode, preparation, preparationAsync, finalization, triggers, basis) {
-    return ReactiveTreeNode.declare(Drivers.table, scriptOrDeclaration, scriptAsync, key, mode, preparation, preparationAsync, finalization, triggers, basis);
+    return declare(Drivers.table, scriptOrDeclaration, scriptAsync, key, mode, preparation, preparationAsync, finalization, triggers, basis);
 }
 export function row(builder, shiftCursorDown) {
     rowBreak(shiftCursorDown);
     builder === null || builder === void 0 ? void 0 : builder();
 }
 export function Splitter(scriptOrDeclaration, scriptAsync, key, mode, preparation, preparationAsync, finalization, triggers, basis) {
-    return ReactiveTreeNode.declare(Drivers.splitter, scriptOrDeclaration, scriptAsync, key, mode, preparation, preparationAsync, finalization, triggers, basis);
+    return declare(Drivers.splitter, scriptOrDeclaration, scriptAsync, key, mode, preparation, preparationAsync, finalization, triggers, basis);
 }
 export function rowBreak(shiftCursorDown) {
-    ReactiveTreeNode.declare(Drivers.partition);
+    declare(Drivers.partition);
 }
 export function declareSplitter(index, splitViewNode) {
     const key = `splitter-${index}`;
@@ -51,7 +51,7 @@ export function declareSplitter(index, splitViewNode) {
                             for (const item of initialSizesPx) {
                                 clonedSizesPx.push({ node: item.node, sizePx: item.sizePx });
                             }
-                            runNonReactively(() => relayoutUsingSplitter(splitViewNode, deltaPx, index, clonedSizesPx));
+                            runNonReactive(() => relayoutUsingSplitter(splitViewNode, deltaPx, index, clonedSizesPx));
                             if (pointer.dropped) {
                                 (_a = model === null || model === void 0 ? void 0 : model.droppedAction) === null || _a === void 0 ? void 0 : _a.call(model, pointer);
                             }
@@ -79,14 +79,14 @@ export function declareSplitter(index, splitViewNode) {
     }));
 }
 export function cursor(place) {
-    ReactiveTreeNode.declare(Drivers.cursor, {
+    declare(Drivers.cursor, {
         script: el => {
             el.place = place;
         },
     });
 }
 export function JustText(content, formatted, declaration) {
-    return ReactiveTreeNode.declare(Drivers.text, ReactiveTreeNode.withBasis(declaration, {
+    return declare(Drivers.text, derivative(declaration, {
         script: el => {
             if (formatted)
                 el.native.innerHTML = content;
@@ -96,15 +96,15 @@ export function JustText(content, formatted, declaration) {
     }));
 }
 export function Group(scriptOrDeclaration, scriptAsync, key, mode, preparation, preparationAsync, finalization, triggers, basis) {
-    return ReactiveTreeNode.declare(Drivers.group, scriptOrDeclaration, scriptAsync, key, mode, preparation, preparationAsync, finalization, triggers, basis);
+    return declare(Drivers.group, scriptOrDeclaration, scriptAsync, key, mode, preparation, preparationAsync, finalization, triggers, basis);
 }
 export function Fragment(script) {
     return PseudoElement({ mode: Mode.autonomous, script });
 }
 export function PseudoElement(scriptOrDeclaration, scriptAsync, key, mode, preparation, preparationAsync, finalization, triggers, basis) {
-    return ReactiveTreeNode.declare(Drivers.pseudo, scriptOrDeclaration, scriptAsync, key, mode, preparation, preparationAsync, finalization, triggers, basis);
+    return declare(Drivers.pseudo, scriptOrDeclaration, scriptAsync, key, mode, preparation, preparationAsync, finalization, triggers, basis);
 }
-export class DivisionDriver extends HtmlDriver {
+export class BlockDriver extends HtmlDriver {
     runScript(node) {
         rowBreak();
         const el = node.element;
@@ -168,13 +168,13 @@ export class DivisionDriver extends HtmlDriver {
                         const priorities = preferred.length > 0
                             ? getPrioritiesForSizeChanging(isHorizontal, node.children, preferred)
                             : getPrioritiesForEmptySpaceDistribution(isHorizontal, node.children);
-                        runNonReactively(() => relayout(node, priorities.resizable, priorities.manuallyResizable, sizesPx));
+                        runNonReactive(() => relayout(node, priorities.resizable, priorities.manuallyResizable, sizesPx));
                     }
                 },
             });
-            ReactiveTreeNode.runNestedNodeScriptsThenDo(() => {
+            ReactiveTreeNode.launchNestedNodesThenDo(() => {
                 layoutInfo.isUpdateFinished = true;
-                ReactiveTreeNode.triggerScriptRun(relayoutEl, { stamp: node.stamp });
+                launch(relayoutEl, { stamp: node.stamp });
             });
         }
         return result;
@@ -208,7 +208,7 @@ export class DivisionDriver extends HtmlDriver {
         }
         else {
             if (childDriver.isPartition) {
-                const last = ownerNode.children.lastMergedItem();
+                const last = ownerNode.children.lastItem();
                 if (((_a = last === null || last === void 0 ? void 0 : last.instance) === null || _a === void 0 ? void 0 : _a.driver) === childDriver)
                     result = last;
             }
@@ -231,7 +231,7 @@ export class PartitionDriver extends HtmlDriver {
         const ownerEl = node.owner.element;
         if (ownerEl.sealed !== undefined) {
             node.element.style.flexGrow = "1";
-            ReactiveTreeNode.declare(Drivers.wrapper, {
+            declare(Drivers.wrapper, {
                 script: el => {
                     const ownerEl = el.node.owner.owner.element;
                     if (ownerEl.splitView !== undefined) {
@@ -261,14 +261,14 @@ export class PartitionDriver extends HtmlDriver {
         let host;
         const ownerEl = node.owner.element;
         if (ownerEl.sealed !== undefined)
-            host = node.children.firstMergedItem().instance;
+            host = node.children.firstItem().instance;
         else
             host = node;
         return host;
     }
 }
 export const Drivers = {
-    division: new DivisionDriver(Constants.element, false, el => el.kind = ElKind.division),
+    block: new BlockDriver(Constants.element, false, el => el.kind = ElKind.block),
     table: new HtmlDriver(Constants.element, false, el => el.kind = ElKind.table),
     text: new HtmlDriver(Constants.element, false, el => el.kind = ElKind.text),
     group: new HtmlDriver(Constants.group, false, el => el.kind = ElKind.group),

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

@@ -1,5 +1,5 @@
-export declare function restyler<T>(restyle: () => T): TriggeringStyles<T>;
-export declare class TriggeringStyles<T> {
+export declare function restyler<T>(restyle: () => T): ObservableStyles<T>;
+export declare class ObservableStyles<T> {
     private readonly restyle;
     constructor(restyle: () => T);
     protected cache(): T;

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

@@ -7,11 +7,11 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 var __metadata = (this && this.__metadata) || function (k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
-import { cached, runAtomically } from "reactronic";
+import { cache, runTransactional } from "reactronic";
 export function restyler(restyle) {
-    return runAtomically(() => new TriggeringStyles(restyle));
+    return runTransactional(() => new ObservableStyles(restyle));
 }
-export class TriggeringStyles {
+export class ObservableStyles {
     constructor(restyle) {
         this.restyle = restyle;
     }
@@ -23,8 +23,8 @@ export class TriggeringStyles {
     }
 }
 __decorate([
-    cached,
+    cache,
     __metadata("design:type", Function),
     __metadata("design:paramtypes", []),
     __metadata("design:returntype", Object)
-], TriggeringStyles.prototype, "cache", null);
+], ObservableStyles.prototype, "cache", null);

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

@@ -1,4 +1,4 @@
-import { ReactiveTreeNode, MergeList } from "reactronic";
+import { ReactiveTreeNode, ReconciliationList } from "reactronic";
 import { ElImpl } from "./ElDriver.js";
 export declare function equal(a: number, b: number): boolean;
 export declare function less(a: number, b: number): boolean;
@@ -17,11 +17,11 @@ export declare function resizeUsingDelta(splitViewNode: ReactiveTreeNode<ElImpl>
 }>, force?: boolean): number;
 export declare function layout(splitViewNode: ReactiveTreeNode<ElImpl>): void;
 export declare function getPrioritiesForSplitter(index: number, size: number): ReadonlyArray<number>;
-export declare function getPrioritiesForSizeChanging(isHorizontal: boolean, children: MergeList<ReactiveTreeNode>, indexes: Array<number>): {
+export declare function getPrioritiesForSizeChanging(isHorizontal: boolean, children: ReconciliationList<ReactiveTreeNode>, indexes: Array<number>): {
     resizable: ReadonlyArray<number>;
     manuallyResizable: ReadonlyArray<number>;
 };
-export declare function getPrioritiesForEmptySpaceDistribution(isHorizontal: boolean, children: MergeList<ReactiveTreeNode>): {
+export declare function getPrioritiesForEmptySpaceDistribution(isHorizontal: boolean, children: ReconciliationList<ReactiveTreeNode>): {
     resizable: ReadonlyArray<number>;
     manuallyResizable: ReadonlyArray<number>;
 };

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

@@ -148,7 +148,7 @@ export function layout(splitViewNode) {
     }
     const containerSizePx = (_e = (isHorizontal ? layoutInfo === null || layoutInfo === void 0 ? void 0 : layoutInfo.contentSizeXpx : layoutInfo === null || layoutInfo === void 0 ? void 0 : layoutInfo.contentSizeYpx)) !== null && _e !== void 0 ? _e : 0;
     const isOverflowing = greater(posPx, containerSizePx);
-    const wrapper = (_g = (_f = splitViewNode.children.firstMergedItem()) === null || _f === void 0 ? void 0 : _f.instance.children.firstMergedItem()) === null || _g === void 0 ? void 0 : _g.instance;
+    const wrapper = (_g = (_f = splitViewNode.children.firstItem()) === null || _f === void 0 ? void 0 : _f.instance.children.firstItem()) === null || _g === void 0 ? void 0 : _g.instance;
     if (wrapper !== undefined) {
         if (isHorizontal)
             wrapper.element.style.gridTemplateColumns = sizesPx.map(x => `${x}px`).join(" ");

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

@@ -2,11 +2,13 @@ import { ReactiveTreeNode, Handler } from "reactronic";
 import { El } from "./El.js";
 import { ElDriver } from "./ElDriver.js";
 export declare class WebDriver<T extends Element, M = unknown> extends ElDriver<T, M> {
-    setNativeElement(node: ReactiveTreeNode<El<T, M>>): void;
+    assignNativeElement(node: ReactiveTreeNode<El<T, M>>): void;
     runPreparation(node: ReactiveTreeNode<El<T, M>>): void | Promise<void>;
     runFinalization(node: ReactiveTreeNode<El<T, M>>, isLeader: boolean): boolean;
     runMount(node: ReactiveTreeNode<El<T, M>>): void;
     runScript(node: ReactiveTreeNode<El<T, M>>): void | Promise<void>;
+    private assignExtraAttributesAndProperties;
+    private clearExtraAttributesAndProperties;
     static getOwnNodeOfNativeElement<T extends Element>(element: T): ReactiveTreeNode<El<T>> | undefined;
     static findBrotherlyHost<T extends Element, R extends Element>(node: ReactiveTreeNode<El<T>>): ReactiveTreeNode<El<R>> | undefined;
     static findBrotherlyPrevSibling<T extends Element, R extends Element>(node: ReactiveTreeNode<El<T>>): ReactiveTreeNode<El<R>> | undefined;
@@ -16,11 +18,11 @@ export declare class WebDriver<T extends Element, M = unknown> extends ElDriver<
 export declare class StaticDriver<T extends HTMLElement> extends WebDriver<T> {
     readonly native: T;
     constructor(native: T, name: string, isRow: boolean, initialize?: Handler<El<T>>);
-    setNativeElement(node: ReactiveTreeNode<El<T>>): void;
+    assignNativeElement(node: ReactiveTreeNode<El<T>>): void;
 }
 export declare class HtmlDriver<T extends HTMLElement, M = any> extends WebDriver<T, M> {
-    setNativeElement(node: ReactiveTreeNode<El<T, M>>): void;
+    assignNativeElement(node: ReactiveTreeNode<El<T, M>>): void;
 }
 export declare class SvgDriver<T extends SVGElement, M = any> extends WebDriver<T, M> {
-    setNativeElement(node: ReactiveTreeNode<El<T, M>>): void;
+    assignNativeElement(node: ReactiveTreeNode<El<T, M>>): void;
 }

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

@@ -1,43 +1,42 @@
 import { ReactiveTreeNode, ReactiveSystem, proceedSyncOrAsync } from "reactronic";
 import { Constants, ElDriver, ElImpl } from "./ElDriver.js";
 export class WebDriver extends ElDriver {
-    setNativeElement(node) {
+    assignNativeElement(node) {
     }
     runPreparation(node) {
-        this.setNativeElement(node);
-        const e = node.element.native;
-        if (ReactiveSystem.isLogging && e !== undefined && !node.driver.isPartition)
-            e.setAttribute(Constants.keyAttrName, node.key);
+        this.assignNativeElement(node);
+        const native = node.element.native;
+        const isPartition = node.driver.isPartition;
+        if (native !== undefined && !isPartition)
+            this.assignExtraAttributesAndProperties(node);
         const result = super.runPreparation(node);
-        if (e == undefined && ReactiveSystem.isLogging && !node.driver.isPartition)
-            node.element.native.setAttribute(Constants.keyAttrName, node.key);
-        Object.defineProperty(node.element.native, Constants.ownReactiveTreeNodeKey, {
-            configurable: false, enumerable: false, value: node, writable: false,
-        });
+        if (native == undefined && node.element.native !== undefined && !isPartition)
+            this.assignExtraAttributesAndProperties(node);
         return result;
     }
     runFinalization(node, isLeader) {
         var _a;
-        const element = node.element;
-        const native = element.native;
+        const el = node.element;
+        const native = el.native;
         if (native) {
+            this.clearExtraAttributesAndProperties(node);
             (_a = native.resizeObserver) === null || _a === void 0 ? void 0 : _a.unobserve(native);
             if (isLeader)
                 native.remove();
         }
         super.runFinalization(node, isLeader);
-        element.native = null;
+        el.native = null;
         return false;
     }
     runMount(node) {
-        const element = node.element;
-        const native = element.native;
+        const el = node.element;
+        const native = el.native;
         if (native) {
             const sequential = node.owner.children.isStrict;
-            const automaticHost = ReactiveTreeNode.findMatchingHost(node, n => n.element.native instanceof HTMLElement || n.element.native instanceof SVGElement);
-            const automaticNativeHost = automaticHost !== node.owner
-                ? automaticHost === null || automaticHost === void 0 ? void 0 : automaticHost.driver.provideHost(automaticHost).element.native
-                : automaticHost === null || automaticHost === void 0 ? void 0 : automaticHost.element.native;
+            const autoHost = ReactiveTreeNode.findMatchingHost(node, n => n.element.native instanceof HTMLElement || n.element.native instanceof SVGElement);
+            const automaticNativeHost = autoHost !== node.owner
+                ? autoHost === null || autoHost === void 0 ? void 0 : autoHost.driver.provideHost(autoHost).element.native
+                : autoHost === null || autoHost === void 0 ? void 0 : autoHost.element.native;
             if (automaticNativeHost) {
                 if (sequential && !node.driver.isPartition) {
                     const after = ReactiveTreeNode.findMatchingPrevSibling(node, n => n.element.native instanceof HTMLElement || n.element.native instanceof SVGElement);
@@ -59,22 +58,36 @@ export class WebDriver extends ElDriver {
         }
     }
     runScript(node) {
-        const element = node.element;
-        if (element instanceof ElImpl)
-            element.prepareForUpdate();
+        const el = node.element;
+        if (el instanceof ElImpl)
+            el.prepareForUpdate();
         let result = super.runScript(node);
         result = proceedSyncOrAsync(result, v => {
-            if (element.place === undefined) {
+            if (el.place === undefined) {
                 const oel = node.owner.element;
                 if (oel instanceof ElImpl && oel.isTable)
-                    element.place = undefined;
+                    el.place = undefined;
             }
             if (gBlinkingEffectMarker)
-                blink(element.native, ReactiveTreeNode.currentScriptPriority, node.stamp);
+                blink(el.native, ReactiveTreeNode.currentScriptPriority, node.stamp);
         }, e => {
         });
         return result;
     }
+    assignExtraAttributesAndProperties(node) {
+        const e = node.element.native;
+        Object.defineProperty(e, Constants.ownReactiveTreeNodeKey, {
+            configurable: true, enumerable: false, value: node, writable: false,
+        });
+        if (ReactiveSystem.isLogging)
+            e.setAttribute(Constants.keyAttrName, node.key);
+    }
+    clearExtraAttributesAndProperties(node) {
+        const e = node.element.native;
+        delete e[Constants.ownReactiveTreeNodeKey];
+        if (ReactiveSystem.isLogging)
+            e.setAttribute(Constants.keyAttrName, "");
+    }
     static getOwnNodeOfNativeElement(element) {
         return element[Constants.ownReactiveTreeNodeKey];
     }
@@ -96,17 +109,17 @@ export class StaticDriver extends WebDriver {
         super(name, isRow, initialize);
         this.native = native;
     }
-    setNativeElement(node) {
+    assignNativeElement(node) {
         node.element.native = this.native;
     }
 }
 export class HtmlDriver extends WebDriver {
-    setNativeElement(node) {
+    assignNativeElement(node) {
         node.element.native = document.createElement(node.driver.name);
     }
 }
 export class SvgDriver extends WebDriver {
-    setNativeElement(node) {
+    assignNativeElement(node) {
         node.element.native = document.createElementNS("http://www.w3.org/2000/svg", node.driver.name);
     }
 }

package/build/dist/source/core/sensors/ButtonSensor.js

@@ -7,7 +7,7 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 var __metadata = (this && this.__metadata) || function (k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
-import { options, Reentrance, atomic, Transaction, LoggingLevel } from "reactronic";
+import { options, Reentrance, transaction, Transaction, LoggingLevel } from "reactronic";
 import { extractPointerButton, isPointerButtonDown, PointerButton, BasePointerSensor } from "./BasePointerSensor.js";
 import { findTargetElementData, SymDataForSensor } from "./DataForSensor.js";
 import { extractModifierKeys, KeyboardModifiers } from "./KeyboardSensor.js";
@@ -164,42 +164,42 @@ export class ButtonSensor extends BasePointerSensor {
     }
 }
 __decorate([
-    atomic,
+    transaction,
     options({ logging: LoggingLevel.Off }),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [PointerEvent]),
     __metadata("design:returntype", void 0)
 ], ButtonSensor.prototype, "press", null);
 __decorate([
-    atomic,
+    transaction,
     options({ reentrance: Reentrance.cancelPrevious, logging: LoggingLevel.Off }),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [PointerEvent]),
     __metadata("design:returntype", void 0)
 ], ButtonSensor.prototype, "selecting", null);
 __decorate([
-    atomic,
+    transaction,
     options({ logging: LoggingLevel.Off }),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [PointerEvent]),
     __metadata("design:returntype", void 0)
 ], ButtonSensor.prototype, "select", null);
 __decorate([
-    atomic,
+    transaction,
     options({ logging: LoggingLevel.Off }),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", []),
     __metadata("design:returntype", void 0)
 ], ButtonSensor.prototype, "release", null);
 __decorate([
-    atomic,
+    transaction,
     options({ logging: LoggingLevel.Off }),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", []),
     __metadata("design:returntype", void 0)
 ], ButtonSensor.prototype, "cancel", null);
 __decorate([
-    atomic,
+    transaction,
     options({ logging: LoggingLevel.Off }),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", []),

package/build/dist/source/core/sensors/FocusSensor.js

@@ -7,7 +7,7 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 var __metadata = (this && this.__metadata) || function (k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
-import { options, atomic, LoggingLevel, Transaction } from "reactronic";
+import { options, transaction, LoggingLevel, Transaction } from "reactronic";
 import { objectHasMember } from "../ElUtils.js";
 import { grabElementDataList, SymDataForSensor } from "./DataForSensor.js";
 import { HtmlElementSensor } from "./HtmlElementSensor.js";
@@ -132,32 +132,32 @@ export class FocusSensor extends HtmlElementSensor {
     }
 }
 __decorate([
-    atomic,
+    transaction,
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [Object, String]),
     __metadata("design:returntype", void 0)
 ], FocusSensor.prototype, "setActiveData", null);
 __decorate([
-    atomic,
+    transaction,
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [Boolean]),
     __metadata("design:returntype", void 0)
 ], FocusSensor.prototype, "listen", null);
 __decorate([
-    atomic,
+    transaction,
     options({ logging: LoggingLevel.Off }),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [FocusEvent]),
     __metadata("design:returntype", void 0)
 ], FocusSensor.prototype, "doFocusIn", null);
 __decorate([
-    atomic,
+    transaction,
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [FocusEvent]),
     __metadata("design:returntype", void 0)
 ], FocusSensor.prototype, "doFocusOut", null);
 __decorate([
-    atomic,
+    transaction,
     options({ logging: LoggingLevel.Off }),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [MouseEvent]),

package/build/dist/source/core/sensors/Handlers.js

@@ -7,7 +7,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-import { Mode, ToggleRef, runNonReactively } from "reactronic";
+import { Mode, ToggleRef, runNonReactive } from "reactronic";
 import { PseudoElement } from "../Elements.js";
 export function OnClick(target, action, key) {
     if (action !== undefined) {
@@ -19,10 +19,10 @@ export function OnClick(target, action, key) {
                 const pointer = target.sensors.pointer;
                 if (target.dataForSensor.click !== undefined && pointer.clicked === target.dataForSensor.click || target.dataForSensor.click === undefined && pointer.clicked) {
                     if (action instanceof Function) {
-                        runNonReactively(() => action(pointer));
+                        runNonReactive(() => action(pointer));
                     }
                     else if (action instanceof ToggleRef) {
-                        runNonReactively(() => action.toggle());
+                        runNonReactive(() => action.toggle());
                     }
                 }
             },
@@ -39,10 +39,10 @@ export function OnClickAsync(target, action, key) {
                 const pointer = target.sensors.pointer;
                 if (target.dataForSensor.click !== undefined && pointer.clicked === target.dataForSensor.click || target.dataForSensor.click === undefined && pointer.clicked) {
                     if (action instanceof Function) {
-                        yield runNonReactively(() => action(pointer));
+                        yield runNonReactive(() => action(pointer));
                     }
                     else if (action instanceof ToggleRef) {
-                        runNonReactively(() => action.toggle());
+                        runNonReactive(() => action.toggle());
                     }
                 }
             }),
@@ -94,8 +94,8 @@ export function prepareResizeHandler(action) {
     return (element) => {
         const size = element.borderBoxSize[0];
         if (action instanceof Function)
-            runNonReactively(() => action(size.inlineSize, size.blockSize));
+            runNonReactive(() => action(size.inlineSize, size.blockSize));
         else if (action instanceof ResizeData && action.handler !== undefined)
-            runNonReactively(() => action.handler(size.inlineSize, size.blockSize));
+            runNonReactive(() => action.handler(size.inlineSize, size.blockSize));
     };
 }

package/build/dist/source/core/sensors/HoverSensor.js

@@ -7,7 +7,7 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 var __metadata = (this && this.__metadata) || function (k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
-import { options, atomic, LoggingLevel, Transaction } from "reactronic";
+import { options, transaction, LoggingLevel, Transaction } from "reactronic";
 import { SymDataForSensor, findTargetElementData } from "./DataForSensor.js";
 import { BasePointerSensor } from "./BasePointerSensor.js";
 import { KeyboardModifiers, extractModifierKeys } from "./KeyboardSensor.js";
@@ -90,35 +90,35 @@ export class HoverSensor extends BasePointerSensor {
     }
 }
 __decorate([
-    atomic,
+    transaction,
     options({ logging: LoggingLevel.Off }),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [PointerEvent]),
     __metadata("design:returntype", void 0)
 ], HoverSensor.prototype, "doPointerEnter", null);
 __decorate([
-    atomic,
+    transaction,
     options({ logging: LoggingLevel.Off }),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [PointerEvent]),
     __metadata("design:returntype", void 0)
 ], HoverSensor.prototype, "doPointerOver", null);
 __decorate([
-    atomic,
+    transaction,
     options({ logging: LoggingLevel.Off }),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [PointerEvent]),
     __metadata("design:returntype", void 0)
 ], HoverSensor.prototype, "doPointerMove", null);
 __decorate([
-    atomic,
+    transaction,
     options({ logging: LoggingLevel.Off }),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [PointerEvent]),
     __metadata("design:returntype", void 0)
 ], HoverSensor.prototype, "doPointerLeave", null);
 __decorate([
-    atomic,
+    transaction,
     options({ logging: LoggingLevel.Off }),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", []),