reactronic 0.22.315 → 0.22.316

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

@@ -0,0 +1,60 @@
+import { MvccObject } from './Mvcc';
+export declare class MvccArray<T> extends MvccObject {
+    private all;
+    constructor(reactive: boolean, array: Array<T>);
+    get length(): number;
+    set length(n: number);
+    getItem(n: number): T;
+    setItem(n: number, item: T): void;
+    toString(): string;
+    toLocaleString(): string;
+    pop(): T | undefined;
+    push(...items: T[]): number;
+    concat(...items: (T | ConcatArray<T>)[]): T[];
+    concat(...items: ConcatArray<T>[]): T[];
+    join(separator?: string): string;
+    reverse(): T[];
+    shift(): T | undefined;
+    slice(start?: number, end?: number): T[];
+    sort(compareFn?: (a: T, b: T) => number): this;
+    splice(start: number, deleteCount?: number): T[];
+    splice(start: number, deleteCount: number, ...items: T[]): T[];
+    unshift(...items: T[]): number;
+    includes(searchElement: T, fromIndex?: number): boolean;
+    indexOf(searchElement: T, fromIndex?: number): number;
+    lastIndexOf(searchElement: T, fromIndex?: number): number;
+    every(predicate: (value: T, index: number, array: T[]) => unknown, thisArg?: any): boolean;
+    every<S extends T>(predicate: (value: T, index: number, array: T[]) => value is S, thisArg?: any): this is S[];
+    some(predicate: (value: T, index: number, array: T[]) => unknown, thisArg?: any): boolean;
+    forEach(callbackfn: (value: T, index: number, array: T[]) => void, thisArg?: any): void;
+    map<U>(callbackfn: (value: T, index: number, array: T[]) => U, thisArg?: any): U[];
+    filter(predicate: (value: T, index: number, array: T[]) => unknown, thisArg?: any): T[];
+    filter<S extends T>(predicate: (value: T, index: number, array: T[]) => value is S, thisArg?: any): S[];
+    reduce(callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: T[]) => T): T;
+    reduce(callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: T[]) => T, initialValue: T): T;
+    reduce<U>(callbackfn: (previousValue: U, currentValue: T, currentIndex: number, array: T[]) => U, initialValue: U): U;
+    reduceRight(callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: T[]) => T): T;
+    reduceRight(callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: T[]) => T, initialValue: T): T;
+    reduceRight<U>(callbackfn: (previousValue: U, currentValue: T, currentIndex: number, array: T[]) => U, initialValue: U): U;
+    find<S extends T>(predicate: (this: void, value: T, index: number, obj: T[]) => value is S, thisArg?: any): S | undefined;
+    findIndex(predicate: (value: T, index: number, obj: T[]) => unknown, thisArg?: any): number;
+    fill(value: T, start?: number, end?: number): this;
+    copyWithin(target: number, start: number, end?: number): this;
+    [Symbol.iterator](): IterableIterator<T>;
+    entries(): IterableIterator<[number, T]>;
+    keys(): IterableIterator<number>;
+    values(): IterableIterator<T>;
+    private get mutable();
+}
+export declare class TransactionalArray<T> extends MvccArray<T> {
+    constructor();
+    constructor(arrayLength: number);
+    constructor(arrayLength?: number);
+    constructor(...items: T[]);
+}
+export declare class ReactiveArray<T> extends MvccArray<T> {
+    constructor();
+    constructor(arrayLength: number);
+    constructor(arrayLength?: number);
+    constructor(...items: T[]);
+}

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

@@ -0,0 +1,58 @@
+import { Sealant } from '../util/Sealant';
+import { MvccObject } from './Mvcc';
+export class MvccArray extends MvccObject {
+    constructor(reactive, array) {
+        super(reactive);
+        this.all = array;
+    }
+    get length() { return this.all.length; }
+    set length(n) { this.mutable.length = n; }
+    getItem(n) { return this.all[n]; }
+    setItem(n, item) { this.mutable[n] = item; }
+    toString() { return this.all.toString(); }
+    toLocaleString() { return this.all.toLocaleString(); }
+    pop() { return this.mutable.pop(); }
+    push(...items) { return this.mutable.push(...items); }
+    concat(...items) { return this.all.concat(...items); }
+    join(separator) { return this.all.join(separator); }
+    reverse() { return this.mutable.reverse(); }
+    shift() { return this.mutable.shift(); }
+    slice(start, end) { return this.all.slice(start, end); }
+    sort(compareFn) { this.mutable.sort(compareFn); return this; }
+    splice(start, deleteCount, ...items) { return this.mutable.splice(start, deleteCount, ...items); }
+    unshift(...items) { return this.mutable.unshift(...items); }
+    includes(searchElement, fromIndex) { return this.all.includes(searchElement, fromIndex); }
+    indexOf(searchElement, fromIndex) { return this.all.indexOf(searchElement, fromIndex); }
+    lastIndexOf(searchElement, fromIndex) { return this.all.lastIndexOf(searchElement, fromIndex); }
+    every(predicate, thisArg) { return this.all.every(predicate, thisArg); }
+    some(predicate, thisArg) { return this.all.some(predicate, thisArg); }
+    forEach(callbackfn, thisArg) { return this.all.forEach(callbackfn, thisArg); }
+    map(callbackfn, thisArg) { return this.all.map(callbackfn, thisArg); }
+    filter(predicate, thisArg) { return this.all.filter(predicate, thisArg); }
+    reduce(callbackfn, initialValue) { return initialValue !== undefined ? this.all.reduce(callbackfn, initialValue) : this.all.reduce(callbackfn); }
+    reduceRight(callbackfn, initialValue) { return initialValue !== undefined ? this.all.reduceRight(callbackfn, initialValue) : this.all.reduceRight(callbackfn); }
+    find(predicate, thisArg) { return this.all.find(predicate, thisArg); }
+    findIndex(predicate, thisArg) { return this.all.findIndex(predicate, thisArg); }
+    fill(value, start, end) { this.mutable.fill(value, start, end); return this; }
+    copyWithin(target, start, end) { this.mutable.copyWithin(target, start, end); return this; }
+    [Symbol.iterator]() { return this.all[Symbol.iterator](); }
+    entries() { return this.all.entries(); }
+    keys() { return this.all.keys(); }
+    values() { return this.all.values(); }
+    get mutable() {
+        const createCopy = this.all[Sealant.CreateCopy];
+        if (createCopy)
+            return this.all = createCopy.call(this.all);
+        return this.all;
+    }
+}
+export class TransactionalArray extends MvccArray {
+    constructor(args) {
+        super(false, args !== undefined ? new Array(args) : new Array());
+    }
+}
+export class ReactiveArray extends MvccArray {
+    constructor(args) {
+        super(true, args !== undefined ? new Array(args) : new Array());
+    }
+}

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

@@ -0,0 +1,25 @@
+import { Collection, Item, CollectionReader } from '../util/Collection';
+import { ReactiveObject } from './Mvcc';
+export declare abstract class ReactiveCollection<T> extends ReactiveObject implements CollectionReader<T> {
+    protected abstract a: Collection<T>;
+    get strict(): boolean;
+    get count(): number;
+    get addedCount(): number;
+    get removedCount(): number;
+    get isMergeInProgress(): boolean;
+    lookup(key: string): Item<T> | undefined;
+    claim(key: string): Item<T> | undefined;
+    add(self: T): Item<T>;
+    remove(item: Item<T>): void;
+    move(item: Item<T>, after: Item<T>): void;
+    beginMerge(): void;
+    endMerge(error?: unknown): void;
+    resetAddedAndRemovedLists(): void;
+    items(): Generator<Item<T>>;
+    addedItems(reset?: boolean): Generator<Item<T>>;
+    removedItems(reset?: boolean): Generator<Item<T>>;
+    isAdded(item: Item<T>): boolean;
+    isMoved(item: Item<T>): boolean;
+    isRemoved(item: Item<T>): boolean;
+    isCurrent(item: Item<T>): boolean;
+}

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

@@ -0,0 +1,23 @@
+import { ReactiveObject } from './Mvcc';
+export class ReactiveCollection extends ReactiveObject {
+    get strict() { return this.a.strict; }
+    get count() { return this.a.count; }
+    get addedCount() { return this.a.addedCount; }
+    get removedCount() { return this.a.removedCount; }
+    get isMergeInProgress() { return this.a.isMergeInProgress; }
+    lookup(key) { return this.a.lookup(key); }
+    claim(key) { return this.a.claim(key); }
+    add(self) { return this.a.add(self); }
+    remove(item) { return this.a.remove(item); }
+    move(item, after) { this.a.move(item, after); }
+    beginMerge() { this.a.beginMerge(); }
+    endMerge(error) { this.a.endMerge(error); }
+    resetAddedAndRemovedLists() { this.a.resetAddedAndRemovedLists(); }
+    items() { return this.a.items(); }
+    addedItems(reset) { return this.a.addedItems(reset); }
+    removedItems(reset) { return this.a.removedItems(reset); }
+    isAdded(item) { return this.a.isAdded(item); }
+    isMoved(item) { return this.a.isMoved(item); }
+    isRemoved(item) { return this.a.isRemoved(item); }
+    isCurrent(item) { return this.a.isCurrent(item); }
+}

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

@@ -0,0 +1,25 @@
+import { MvccObject } from './Mvcc';
+export declare class MvccMap<K, V> extends MvccObject {
+    private all;
+    constructor(reactive: boolean, map: Map<K, V>);
+    clear(): void;
+    delete(key: K): boolean;
+    forEach(callbackfn: (value: V, key: K, map: Map<K, V>) => void, thisArg?: any): void;
+    get(key: K): V | undefined;
+    has(key: K): boolean;
+    set(key: K, value: V): this;
+    get size(): number;
+    entries(): IterableIterator<[K, V]>;
+    keys(): IterableIterator<K>;
+    values(): IterableIterator<V>;
+    [Symbol.toStringTag](): string;
+    private get mutable();
+}
+export declare class TransactionalMap<K, V> extends MvccMap<K, V> {
+    constructor();
+    constructor(iterable?: Iterable<readonly [K, V]> | null);
+}
+export declare class ReactiveMap<K, V> extends MvccMap<K, V> {
+    constructor();
+    constructor(iterable?: Iterable<readonly [K, V]> | null);
+}

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

@@ -0,0 +1,35 @@
+import { Sealant } from '../util/Sealant';
+import { MvccObject } from './Mvcc';
+export class MvccMap extends MvccObject {
+    constructor(reactive, map) {
+        super(reactive);
+        this.all = map;
+    }
+    clear() { this.mutable.clear(); }
+    delete(key) { return this.mutable.delete(key); }
+    forEach(callbackfn, thisArg) { this.all.forEach(callbackfn, thisArg); }
+    get(key) { return this.all.get(key); }
+    has(key) { return this.all.has(key); }
+    set(key, value) { this.mutable.set(key, value); return this; }
+    get size() { return this.all.size; }
+    entries() { return this.all.entries(); }
+    keys() { return this.all.keys(); }
+    values() { return this.all.values(); }
+    [Symbol.toStringTag]() { return this.all[Symbol.toStringTag]; }
+    get mutable() {
+        const createCopy = this.all[Sealant.CreateCopy];
+        if (createCopy)
+            return this.all = createCopy.call(this.all);
+        return this.all;
+    }
+}
+export class TransactionalMap extends MvccMap {
+    constructor(args) {
+        super(true, args !== undefined ? new Map(args) : new Map());
+    }
+}
+export class ReactiveMap extends MvccMap {
+    constructor(args) {
+        super(true, args !== undefined ? new Map(args) : new Map());
+    }
+}

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

@@ -3,7 +3,7 @@ import { MemberOptions } from '../Options';
 import { Controller } from '../Controller';
 import { MemberName, ObjectHandle, Subscription, Subscriber, SubscriptionInfo, AbstractChangeset } from './Data';
 import { Transaction } from './Transaction';
-import { OptionsImpl } from './Hooks';
+import { OptionsImpl } from './Mvcc';
 export declare class OperationController extends Controller<any> {
     readonly objectHandle: ObjectHandle;
     readonly memberName: MemberName;
@@ -19,7 +19,7 @@ export declare class OperationController extends Controller<any> {
     pullLastResult(args?: any[]): any;
     constructor(h: ObjectHandle, m: MemberName);
     useOrRun(weak: boolean, args: any[] | undefined): Operation;
-    static of(method: F<any>): Controller<any>;
+    static getControllerOf(method: F<any>): Controller<any>;
     static configureImpl(self: OperationController | undefined, options: Partial<MemberOptions>): MemberOptions;
     static runWithin<T>(op: Operation | undefined, func: F<T>, ...args: any[]): T;
     static why(): string;
@@ -55,7 +55,7 @@ declare class Operation extends Subscription implements Subscriber {
     get originSnapshotId(): number;
     hint(): string;
     get order(): number;
-    get ['#this'](): string;
+    get ['#this#'](): string;
     why(): string;
     briefWhy(): string;
     dependencies(): string[];

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

@@ -5,11 +5,11 @@ import { ObjectHandle, Subscription, Meta } from './Data';
 import { Changeset, Dump, EMPTY_SNAPSHOT, MAX_REVISION } from './Changeset';
 import { Transaction } from './Transaction';
 import { MonitorImpl } from './Monitor';
-import { Hooks, OptionsImpl } from './Hooks';
+import { Mvcc, OptionsImpl } from './Mvcc';
 import { JournalImpl } from './Journal';
 const BOOT_ARGS = [];
 const BOOT_CAUSE = '<boot>';
-const EMPTY_HANDLE = new ObjectHandle(undefined, undefined, Hooks.reactive, EMPTY_SNAPSHOT, '<empty>');
+const EMPTY_HANDLE = new ObjectHandle(undefined, undefined, Mvcc.reactive, EMPTY_SNAPSHOT, '<empty>');
 export class OperationController extends Controller {
     constructor(h, m) {
         super();
@@ -36,12 +36,12 @@ export class OperationController extends Controller {
             && (!weak || op.cause === BOOT_CAUSE || !op.successor ||
                 op.successor.transaction.isFinished)) {
             const outerOpts = (_a = Operation.current) === null || _a === void 0 ? void 0 : _a.options;
-            const standalone = weak || opts.standalone || opts.kind === Kind.Reaction ||
+            const separation = weak || opts.separation || opts.kind === Kind.Reaction ||
                 (opts.kind === Kind.Transaction && outerOpts && (outerOpts.noSideEffects || outerOpts.kind === Kind.Cache)) ||
                 (opts.kind === Kind.Cache && (oc.snapshot.changeset.sealed ||
                     oc.snapshot.former.snapshot !== EMPTY_SNAPSHOT));
             const token = opts.noSideEffects ? this : undefined;
-            const oc2 = this.run(oc, standalone, opts, token, args);
+            const oc2 = this.run(oc, separation, opts, token, args);
             const ctx2 = oc2.operation.changeset;
             if (!weak || ctx === ctx2 || (ctx2.sealed && ctx.timestamp >= ctx2.timestamp))
                 oc = oc2;
@@ -53,7 +53,7 @@ export class OperationController extends Controller {
         Changeset.markUsed(t, oc.snapshot, this.memberName, this.objectHandle, t.options.kind, weak);
         return t;
     }
-    static of(method) {
+    static getControllerOf(method) {
         const ctl = Meta.get(method, Meta.Controller);
         if (!ctl)
             throw misuse(`given method is not decorated as reactronic one: ${method.name}`);
@@ -137,8 +137,8 @@ export class OperationController extends Controller {
         if (op.controller !== this) {
             if (os.changeset !== EMPTY_SNAPSHOT.changeset) {
                 const hint = Log.isOn ? `${Dump.obj(this.objectHandle, m)}/boot` : 'MethodController/init';
-                const standalone = os.changeset.sealed || os.former.snapshot !== EMPTY_SNAPSHOT;
-                op = Transaction.run({ hint, standalone, token: this }, () => {
+                const separation = os.changeset.sealed || os.former.snapshot !== EMPTY_SNAPSHOT;
+                op = Transaction.run({ hint, separation, token: this }, () => {
                     const h = this.objectHandle;
                     let r2 = Changeset.current().getObjectSnapshot(h, m);
                     let op2 = r2.data[m];
@@ -168,10 +168,10 @@ export class OperationController extends Controller {
         }
         return op;
     }
-    run(existing, standalone, options, token, args) {
+    run(existing, separation, options, token, args) {
         const hint = Log.isOn ? `${Dump.obj(this.objectHandle, this.memberName)}${args && args.length > 0 && (typeof args[0] === 'number' || typeof args[0] === 'string') ? ` - ${args[0]}` : ''}` : `${Dump.obj(this.objectHandle, this.memberName)}`;
         let oc = existing;
-        const opts = { hint, standalone, journal: options.journal, logging: options.logging, token };
+        const opts = { hint, separation, journal: options.journal, logging: options.logging, token };
         const result = Transaction.run(opts, (argsx) => {
             if (!oc.operation.transaction.isCanceled) {
                 oc = this.edit();
@@ -226,7 +226,7 @@ class Operation extends Subscription {
     get originSnapshotId() { return this.changeset.id; }
     hint() { return `${Dump.snapshot2(this.controller.objectHandle, this.changeset, this.controller.memberName)}`; }
     get order() { return this.options.order; }
-    get ['#this']() {
+    get ['#this#']() {
         return `Operation: ${this.why()}`;
     }
     why() {
@@ -254,7 +254,7 @@ class Operation extends Subscription {
             const ms = Date.now() - started;
             if (Log.isOn && Log.opt.step && this.result)
                 Log.writeAs({ margin2: this.margin }, '║', '_/', `${this.hint()} - step out `, 0, this.started > 0 ? '        │' : '');
-            if (ms > Hooks.mainThreadBlockingWarningThreshold)
+            if (ms > Mvcc.mainThreadBlockingWarningThreshold)
                 Log.write('', '[!]', this.why(), ms, '    *** main thread is too busy ***');
             return result;
         };
@@ -410,7 +410,7 @@ class Operation extends Subscription {
         this.started = -this.started;
         if (Log.isOn && Log.opt.operation)
             Log.write('║', `${op}`, `${this.hint()} ${message}`, ms, highlight);
-        if (ms > (main ? Hooks.mainThreadBlockingWarningThreshold : Hooks.asyncActionDurationWarningThreshold))
+        if (ms > (main ? Mvcc.mainThreadBlockingWarningThreshold : Mvcc.asyncActionDurationWarningThreshold))
             Log.write('', '[!]', this.why(), ms, main ? '    *** main thread is too busy ***' : '    *** async is too long ***');
         this.cause = undefined;
         if (this.options.monitor)
@@ -419,17 +419,17 @@ class Operation extends Subscription {
     monitorEnter(mon) {
         const options = {
             hint: 'Monitor.enter',
-            standalone: 'isolated',
+            separation: 'isolated',
             logging: Log.isOn && Log.opt.monitor ? undefined : Log.global
         };
         OperationController.runWithin(undefined, Transaction.run, options, MonitorImpl.enter, mon, this.transaction);
     }
     monitorLeave(mon) {
-        Transaction.off(() => {
+        Transaction.outside(() => {
             const leave = () => {
                 const options = {
                     hint: 'Monitor.leave',
-                    standalone: 'isolated',
+                    separation: 'isolated',
                     logging: Log.isOn && Log.opt.monitor ? undefined : Log.DefaultLevel
                 };
                 OperationController.runWithin(undefined, Transaction.run, options, MonitorImpl.leave, mon, this.transaction);
@@ -520,9 +520,9 @@ class Operation extends Subscription {
         }
         if (curr instanceof Operation) {
             if (curr.changeset === os.changeset && curr.subscriptions !== undefined) {
-                if (Hooks.repetitiveUsageWarningThreshold < Number.MAX_SAFE_INTEGER) {
+                if (Mvcc.repetitiveUsageWarningThreshold < Number.MAX_SAFE_INTEGER) {
                     curr.subscriptions.forEach((info, v) => {
-                        if (info.usageCount > Hooks.repetitiveUsageWarningThreshold)
+                        if (info.usageCount > Mvcc.repetitiveUsageWarningThreshold)
                             Log.write('', '[!]', `${curr.hint()} uses ${info.memberHint} ${info.usageCount} times (consider remembering it in a local variable)`, 0, ' *** WARNING ***');
                     });
                 }
@@ -566,7 +566,7 @@ class Operation extends Subscription {
         const ok = Operation.canSubscribe(subscription, os, m, h, timestamp);
         if (ok) {
             let times = 0;
-            if (Hooks.repetitiveUsageWarningThreshold < Number.MAX_SAFE_INTEGER) {
+            if (Mvcc.repetitiveUsageWarningThreshold < Number.MAX_SAFE_INTEGER) {
                 const existing = this.subscriptions.get(subscription);
                 times = existing ? existing.usageCount + 1 : 1;
             }
@@ -628,8 +628,8 @@ class Operation extends Subscription {
         Changeset.propagateAllChangesThroughSubscriptions = Operation.propagateAllChangesThroughSubscriptions;
         Changeset.revokeAllSubscriptions = Operation.revokeAllSubscriptions;
         Changeset.enqueueReactionsToRun = Operation.enqueueReactionsToRun;
-        Hooks.createOperation = Operation.createOperation;
-        Hooks.rememberOperationOptions = Operation.rememberOperationOptions;
+        Mvcc.createOperation = Operation.createOperation;
+        Mvcc.rememberOperationOptions = Operation.rememberOperationOptions;
         Promise.prototype.then = reactronicHookedThen;
         try {
             Object.defineProperty(globalThis, 'rWhy', {

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

@@ -22,8 +22,8 @@ export declare abstract class Transaction implements Worker {
     whenFinished(): Promise<void>;
     static create(options: SnapshotOptions | null): Transaction;
     static run<T>(options: SnapshotOptions | null, func: F<T>, ...args: any[]): T;
-    static standalone<T>(func: F<T>, ...args: any[]): T;
-    static off<T>(func: F<T>, ...args: any[]): T;
+    static separate<T>(func: F<T>, ...args: any[]): T;
+    static outside<T>(func: F<T>, ...args: any[]): T;
     static isFrameOver(everyN?: number, timeLimit?: number): boolean;
     static requestNextFrame(sleepTime?: number): Promise<void>;
     static get isCanceled(): boolean;

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

@@ -17,8 +17,8 @@ export class Transaction {
     }
     static create(options) { return new TransactionImpl(options); }
     static run(options, func, ...args) { return TransactionImpl.run(options, func, ...args); }
-    static standalone(func, ...args) { return TransactionImpl.standalone(func, ...args); }
-    static off(func, ...args) { return TransactionImpl.off(func, ...args); }
+    static separate(func, ...args) { return TransactionImpl.separate(func, ...args); }
+    static outside(func, ...args) { return TransactionImpl.outside(func, ...args); }
     static isFrameOver(everyN = 1, timeLimit = 10) { return TransactionImpl.isFrameOver(everyN, timeLimit); }
     static requestNextFrame(sleepTime = 0) { return TransactionImpl.requestNextFrame(sleepTime); }
     static get isCanceled() { return TransactionImpl.current.isCanceled; }
@@ -118,7 +118,7 @@ class TransactionImpl extends Transaction {
         let result = t.runImpl(options === null || options === void 0 ? void 0 : options.logging, func, ...args);
         if (root) {
             if (result instanceof Promise) {
-                result = TransactionImpl.off(() => {
+                result = TransactionImpl.outside(() => {
                     return t.wrapToRetry(t.wrapToWaitUntilFinish(result), func, ...args);
                 });
             }
@@ -126,10 +126,10 @@ class TransactionImpl extends Transaction {
         }
         return result;
     }
-    static standalone(func, ...args) {
-        return TransactionImpl.run({ standalone: true }, func, ...args);
+    static separate(func, ...args) {
+        return TransactionImpl.run({ separation: true }, func, ...args);
     }
-    static off(func, ...args) {
+    static outside(func, ...args) {
         const outer = TransactionImpl.curr;
         try {
             TransactionImpl.curr = TransactionImpl.none;
@@ -153,7 +153,7 @@ class TransactionImpl extends Transaction {
     }
     static acquire(options) {
         const curr = TransactionImpl.curr;
-        if ((options === null || options === void 0 ? void 0 : options.standalone) || curr.isFinished || curr.options.standalone === 'isolated')
+        if ((options === null || options === void 0 ? void 0 : options.separation) || curr.isFinished || curr.options.separation === 'isolated')
             return new TransactionImpl(options);
         else
             return TransactionImpl.curr;
@@ -176,7 +176,7 @@ class TransactionImpl extends Transaction {
                         yield this.after.whenFinished();
                         const options = {
                             hint: `${this.hint} - restart after T${this.after.id}`,
-                            standalone: this.options.standalone === 'isolated' ? 'isolated' : true,
+                            separation: this.options.separation === 'isolated' ? 'isolated' : true,
                             logging: this.changeset.options.logging,
                             token: this.changeset.options.token,
                         };
@@ -226,7 +226,7 @@ class TransactionImpl extends Transaction {
             if (this.sealed && this.pending === 0) {
                 const reactions = this.applyOrDiscard();
                 TransactionImpl.curr = outer;
-                TransactionImpl.off(Changeset.enqueueReactionsToRun, reactions);
+                TransactionImpl.outside(Changeset.enqueueReactionsToRun, reactions);
             }
             else
                 TransactionImpl.curr = outer;

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

@@ -42,7 +42,9 @@ export declare class Collection<T> implements CollectionReader<T> {
     get removedCount(): number;
     get isMergeInProgress(): boolean;
     lookup(key: string | undefined): Item<T> | undefined;
-    claim(key: string): Item<T> | undefined;
+    claim(key: string, resolution?: {
+        isDuplicate: boolean;
+    }): Item<T> | undefined;
     add(self: T): Item<T>;
     remove(item: Item<T>): void;
     move(item: Item<T>, after: Item<T>): void;

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

@@ -37,7 +37,7 @@ export class Collection {
         }
         return result;
     }
-    claim(key) {
+    claim(key, resolution) {
         const tag = this.tag;
         if (tag < 0)
             throw new Error('merge is not in progress');
@@ -45,15 +45,23 @@ export class Collection {
         if (key !== (item ? this.getKey(item.self) : undefined))
             item = this.lookup(key);
         if (item) {
-            if (item.tag === tag)
+            if (item.tag !== tag) {
+                item.tag = tag;
+                if (this.strict && item !== this.strictNextItem)
+                    item.status = tag;
+                this.strictNextItem = item.next;
+                this.removed.exclude(item);
+                this.current.include(item);
+                if (resolution)
+                    resolution.isDuplicate = false;
+            }
+            else if (resolution)
+                resolution.isDuplicate = true;
+            else
                 throw new Error(`duplicate item: ${key}`);
-            item.tag = tag;
-            if (this.strict && item !== this.strictNextItem)
-                item.status = tag;
-            this.strictNextItem = item.next;
-            this.removed.exclude(item);
-            this.current.include(item);
         }
+        else if (resolution)
+            resolution.isDuplicate = false;
         return item;
     }
     add(self) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "reactronic",
-  "version": "0.22.315",
+  "version": "0.22.316",
   "description": "Reactronic - Transactional Reactive State Management",
   "type": "module",
   "main": "build/dist/source/api.js",

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

@@ -1,33 +0,0 @@
-import { ReactiveObject } from './Hooks';
-export declare class ReactiveArray<T> extends ReactiveObject {
-    private a;
-    get length(): number;
-    set length(n: number);
-    get(n: number): T;
-    set(n: number, item: T): void;
-    toString(): string;
-    toLocaleString(): string;
-    pop(): T | undefined;
-    push(...items: T[]): number;
-    concat(...items: (T | ConcatArray<T>)[]): T[];
-    join(separator?: string): string;
-    reverse(): T[];
-    shift(): T | undefined;
-    slice(start?: number, end?: number): T[];
-    sort(compareFn?: (a: T, b: T) => number): this;
-    splice(start: number, deleteCount?: number): T[];
-    unshift(...items: T[]): number;
-    indexOf(searchElement: T, fromIndex?: number): number;
-    lastIndexOf(searchElement: T, fromIndex?: number): number;
-    every(predicate: (value: T, index: number, array: T[]) => unknown, thisArg?: any): boolean;
-    some(predicate: (value: T, index: number, array: T[]) => unknown, thisArg?: any): boolean;
-    forEach(callbackfn: (value: T, index: number, array: T[]) => void, thisArg?: any): void;
-    map<U>(callbackfn: (value: T, index: number, array: T[]) => U, thisArg?: any): U[];
-    filter(predicate: (value: T, index: number, array: T[]) => unknown, thisArg?: any): T[];
-    reduce(callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: T[]) => T, initialValue: T): T;
-    reduceRight(callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: T[]) => T, initialValue: T): T;
-    entries(): IterableIterator<[number, T]>;
-    keys(): IterableIterator<number>;
-    values(): IterableIterator<T>;
-    private get mutable();
-}

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

@@ -1,42 +0,0 @@
-import { Sealant } from '../util/Sealant';
-import { ReactiveObject } from './Hooks';
-export class ReactiveArray extends ReactiveObject {
-    constructor() {
-        super(...arguments);
-        this.a = new Array();
-    }
-    get length() { return this.a.length; }
-    set length(n) { this.a.length = n; }
-    get(n) { return this.a[n]; }
-    set(n, item) { this.mutable[n] = item; }
-    toString() { return this.a.toString(); }
-    toLocaleString() { return this.a.toLocaleString(); }
-    pop() { return this.mutable.pop(); }
-    push(...items) { return this.mutable.push(...items); }
-    concat(...items) { return this.a.concat(...items); }
-    join(separator) { return this.a.join(separator); }
-    reverse() { return this.mutable.reverse(); }
-    shift() { return this.mutable.shift(); }
-    slice(start, end) { return this.a.slice(start, end); }
-    sort(compareFn) { this.mutable.sort(compareFn); return this; }
-    splice(start, deleteCount, ...items) { return this.mutable.splice(start, deleteCount, ...items); }
-    unshift(...items) { return this.mutable.unshift(...items); }
-    indexOf(searchElement, fromIndex) { return this.a.indexOf(searchElement, fromIndex); }
-    lastIndexOf(searchElement, fromIndex) { return this.a.lastIndexOf(searchElement, fromIndex); }
-    every(predicate, thisArg) { return this.a.every(predicate, thisArg); }
-    some(predicate, thisArg) { return this.a.some(predicate, thisArg); }
-    forEach(callbackfn, thisArg) { return this.a.forEach(callbackfn, thisArg); }
-    map(callbackfn, thisArg) { return this.a.map(callbackfn, thisArg); }
-    filter(predicate, thisArg) { return this.a.filter(predicate, thisArg); }
-    reduce(callbackfn, initialValue) { return this.a.reduce(callbackfn, initialValue); }
-    reduceRight(callbackfn, initialValue) { return this.a.reduceRight(callbackfn, initialValue); }
-    entries() { return this.a.entries(); }
-    keys() { return this.a.keys(); }
-    values() { return this.a.values(); }
-    get mutable() {
-        const createCopy = this.a[Sealant.CreateCopy];
-        if (createCopy)
-            return this.a = createCopy.call(this.a);
-        return this.a;
-    }
-}

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

@@ -1,15 +0,0 @@
-import { ReactiveObject } from './Hooks';
-export declare class ReactiveMap<K, V> extends ReactiveObject {
-    private m;
-    clear(): void;
-    delete(key: K): boolean;
-    forEach(callbackfn: (value: V, key: K, map: Map<K, V>) => void, thisArg?: any): void;
-    get(key: K): V | undefined;
-    has(key: K): boolean;
-    set(key: K, value: V): this;
-    get size(): number;
-    entries(): IterableIterator<[K, V]>;
-    keys(): IterableIterator<K>;
-    values(): IterableIterator<V>;
-    private get mutable();
-}

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

@@ -1,24 +0,0 @@
-import { Sealant } from '../util/Sealant';
-import { ReactiveObject } from './Hooks';
-export class ReactiveMap extends ReactiveObject {
-    constructor() {
-        super(...arguments);
-        this.m = new Map();
-    }
-    clear() { this.mutable.clear(); }
-    delete(key) { return this.mutable.delete(key); }
-    forEach(callbackfn, thisArg) { this.m.forEach(callbackfn, thisArg); }
-    get(key) { return this.m.get(key); }
-    has(key) { return this.m.has(key); }
-    set(key, value) { this.mutable.set(key, value); return this; }
-    get size() { return this.m.size; }
-    entries() { return this.m.entries(); }
-    keys() { return this.m.keys(); }
-    values() { return this.m.values(); }
-    get mutable() {
-        const createCopy = this.m[Sealant.CreateCopy];
-        if (createCopy)
-            return this.m = createCopy.call(this.m);
-        return this.m;
-    }
-}