reactronic 0.22.312 → 0.22.315

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

@@ -1,4 +1,5 @@
 export { all, pause } from './util/Utils';
+export { Collection, Item, CollectionReader } from './util/Collection';
 export { SealedArray } from './util/SealedArray';
 export { SealedMap } from './util/SealedMap';
 export { SealedSet } from './util/SealedSet';
@@ -6,7 +7,9 @@ export { MemberOptions, SnapshotOptions, Kind, Reentrance, LoggingOptions, Profi
 export { Worker } from './Worker';
 export { Controller } from './Controller';
 export { Ref, ToggleRef, BoolOnly, GivenTypeOnly } from './Ref';
-export { ReactiveObject, ReactiveArray, ReactiveMap } from './impl/Hooks';
+export { ReactiveObject } from './impl/Hooks';
+export { ReactiveArray } from './impl/ReactiveArray';
+export { ReactiveMap } from './impl/ReactiveMap';
 export { Changeset } from './impl/Changeset';
 export { Transaction } from './impl/Transaction';
 export { Monitor } from './impl/Monitor';

package/build/dist/source/api.js

@@ -1,11 +1,14 @@
 export { all, pause } from './util/Utils';
+export { Collection } from './util/Collection';
 export { SealedArray } from './util/SealedArray';
 export { SealedMap } from './util/SealedMap';
 export { SealedSet } from './util/SealedSet';
 export { Kind, Reentrance, LoggingLevel } from './Options';
 export { Controller } from './Controller';
 export { Ref, ToggleRef } from './Ref';
-export { ReactiveObject, ReactiveArray, ReactiveMap } from './impl/Hooks';
+export { ReactiveObject } from './impl/Hooks';
+export { ReactiveArray } from './impl/ReactiveArray';
+export { ReactiveMap } from './impl/ReactiveMap';
 export { Changeset } from './impl/Changeset';
 export { Transaction } from './impl/Transaction';
 export { Monitor } from './impl/Monitor';

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

@@ -4,55 +4,12 @@ import { LoggingOptions, ProfilingOptions } from '../Logging';
 import { MemberName, ObjectHandle, StandaloneMode } from './Data';
 import { Journal } from './Journal';
 import { Monitor } from './Monitor';
-export declare abstract class ReactiveObject {
-    constructor();
+export declare abstract class HookedObject {
+    protected constructor(reactive: boolean);
     [Symbol.toStringTag](): string;
 }
-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();
-}
-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();
+export declare abstract class ReactiveObject extends HookedObject {
+    constructor();
 }
 export declare class OptionsImpl implements MemberOptions {
     readonly getter: Function;
@@ -76,7 +33,10 @@ export declare class Hooks implements ProxyHandler<ObjectHandle> {
     static mainThreadBlockingWarningThreshold: number;
     static asyncActionDurationWarningThreshold: number;
     static sensitivity: boolean;
-    static readonly handler: Hooks;
+    static readonly transactional: Hooks;
+    static readonly reactive: Hooks;
+    readonly isReactive: boolean;
+    constructor(isReactive: boolean);
     getPrototypeOf(h: ObjectHandle): object | null;
     get(h: ObjectHandle, m: MemberName, receiver: any): any;
     set(h: ObjectHandle, m: MemberName, value: any, receiver: any): boolean;
@@ -87,10 +47,11 @@ export declare class Hooks implements ProxyHandler<ObjectHandle> {
     static decorateOperation(implicit: boolean, decorator: Function, options: Partial<MemberOptions>, proto: any, member: MemberName, pd: PropertyDescriptor | undefined): any;
     static decorateOperationParametrized(decorator: Function, options: Partial<MemberOptions>): F<any>;
     static acquireHandle(obj: any): ObjectHandle;
-    static createHandleForReactiveObject(proto: any, data: any, blank: any, hint: string): ObjectHandle;
+    static createHandleForReactronicObject(proto: any, data: any, blank: any, hint: string, reactive: boolean): ObjectHandle;
     static setProfilingMode(isOn: boolean, options?: Partial<ProfilingOptions>): void;
     static sensitive<T>(sensitivity: boolean, func: F<T>, ...args: any[]): T;
     static setHint<T>(obj: T, hint: string | undefined): T;
+    static getHint<T>(obj: T): string;
     static createOperation: (h: ObjectHandle, m: MemberName, options: OptionsImpl) => F<any>;
     static rememberOperationOptions: (proto: any, m: MemberName, getter: Function | undefined, setter: Function | undefined, enumerable: boolean, configurable: boolean, options: Partial<MemberOptions>, implicit: boolean) => OptionsImpl;
 }

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

@@ -1,14 +1,13 @@
 import { UNDEF } from '../util/Utils';
-import { Sealant } from '../util/Sealant';
 import { Log, misuse } from '../util/Dbg';
 import { Kind, Reentrance } from '../Options';
 import { ObjectSnapshot, ObjectHandle, Subscription, Meta } from './Data';
 import { Changeset, Dump, EMPTY_SNAPSHOT } from './Changeset';
-export class ReactiveObject {
-    constructor() {
+export class HookedObject {
+    constructor(reactive) {
         const proto = new.target.prototype;
         const initial = Meta.getFrom(proto, Meta.Initial);
-        const h = Hooks.createHandleForReactiveObject(proto, this, initial, new.target.name);
+        const h = Hooks.createHandleForReactronicObject(proto, this, initial, new.target.name, reactive);
         return h.proxy;
     }
     [Symbol.toStringTag]() {
@@ -16,66 +15,9 @@ export class ReactiveObject {
         return Dump.obj(h);
     }
 }
-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;
-    }
-}
-export class ReactiveMap extends ReactiveObject {
+export class ReactiveObject extends HookedObject {
     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;
+        super(true);
     }
 }
 const DEFAULT_OPTIONS = Object.freeze({
@@ -113,6 +55,9 @@ function merge(def, existing, patch, implicit) {
     return patch !== undefined && (existing === def || !implicit) ? patch : existing;
 }
 export class Hooks {
+    constructor(isReactive) {
+        this.isReactive = isReactive;
+    }
     getPrototypeOf(h) {
         return Reflect.getPrototypeOf(h.data);
     }
@@ -123,7 +68,8 @@ export class Hooks {
             const os = cs.getObjectSnapshot(h, m);
             result = os.data[m];
             if (result instanceof Subscription && !result.isOperation) {
-                Changeset.markUsed(result, os, m, h, Kind.Plain, false);
+                if (this.isReactive)
+                    Changeset.markUsed(result, os, m, h, Kind.Plain, false);
                 result = result.content;
             }
             else
@@ -182,11 +128,11 @@ export class Hooks {
         if (reactive) {
             const get = function () {
                 const h = Hooks.acquireHandle(this);
-                return Hooks.handler.get(h, m, this);
+                return Hooks.reactive.get(h, m, this);
             };
             const set = function (value) {
                 const h = Hooks.acquireHandle(this);
-                return Hooks.handler.set(h, m, value, this);
+                return Hooks.reactive.set(h, m, value, this);
             };
             const enumerable = true;
             const configurable = false;
@@ -235,16 +181,17 @@ export class Hooks {
                 throw misuse('only objects can be reactive');
             const initial = Meta.getFrom(Object.getPrototypeOf(obj), Meta.Initial);
             const os = new ObjectSnapshot(EMPTY_SNAPSHOT.changeset, EMPTY_SNAPSHOT, Object.assign({}, initial));
-            h = new ObjectHandle(obj, obj, Hooks.handler, os, obj.constructor.name);
+            h = new ObjectHandle(obj, obj, Hooks.reactive, os, obj.constructor.name);
             Meta.set(os.data, Meta.Handle, h);
             Meta.set(obj, Meta.Handle, h);
             Meta.set(os.data, Meta.Revision, new Subscription(1));
         }
         return h;
     }
-    static createHandleForReactiveObject(proto, data, blank, hint) {
+    static createHandleForReactronicObject(proto, data, blank, hint, reactive) {
         const ctx = Changeset.edit();
-        const h = new ObjectHandle(data, undefined, Hooks.handler, EMPTY_SNAPSHOT, hint);
+        const hooks = reactive ? Hooks.reactive : Hooks.transactional;
+        const h = new ObjectHandle(data, undefined, hooks, EMPTY_SNAPSHOT, hint);
         ctx.getEditableObjectSnapshot(h, Meta.Handle, blank);
         if (!Hooks.reactionsAutoStartDisabled)
             for (const m in Meta.getFrom(proto, Meta.Reactions))
@@ -282,13 +229,18 @@ export class Hooks {
         }
         return obj;
     }
+    static getHint(obj) {
+        const h = Hooks.acquireHandle(obj);
+        return h.hint;
+    }
 }
 Hooks.reactionsAutoStartDisabled = false;
 Hooks.repetitiveUsageWarningThreshold = Number.MAX_SAFE_INTEGER;
 Hooks.mainThreadBlockingWarningThreshold = Number.MAX_SAFE_INTEGER;
 Hooks.asyncActionDurationWarningThreshold = Number.MAX_SAFE_INTEGER;
 Hooks.sensitivity = false;
-Hooks.handler = new Hooks();
+Hooks.transactional = new Hooks(false);
+Hooks.reactive = new Hooks(true);
 Hooks.createOperation = function (h, m, options) {
     throw misuse('createOperation should never be called');
 };

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

@@ -12,7 +12,7 @@ export declare class MonitorImpl extends Monitor {
     counter: number;
     workers: Set<Worker>;
     duration: number;
-    internals: {
+    readonly internals: {
         started: number;
         activationDelay: number;
         activationTimeout: undefined;

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

@@ -51,7 +51,8 @@ export class MonitorImpl extends Monitor {
         return m;
     }
     static activate(mon, delay) {
-        if (mon.internals.started === 0) {
+        const active = mon.counter > 0;
+        if (mon.internals.started === 0 && active) {
             mon.duration = 0;
             mon.internals.started = performance.now();
             MonitorImpl.tick(mon);
@@ -60,7 +61,7 @@ export class MonitorImpl extends Monitor {
             if (mon.internals.activationTimeout === undefined)
                 mon.internals.activationTimeout = setTimeout(() => Transaction.run({ hint: 'Monitor.activate', standalone: 'isolated' }, MonitorImpl.activate, mon, -1), delay);
         }
-        else if (mon.counter > 0)
+        else if (active)
             mon.isActive = true;
     }
     static deactivate(mon, delay) {
@@ -80,7 +81,7 @@ export class MonitorImpl extends Monitor {
     }
     static tick(mon) {
         if (mon.internals.started !== 0) {
-            Transaction.run(null, () => {
+            Transaction.run(MONITOR_TICK_OPTIONS, () => {
                 const resolution = mon.internals.durationResolution;
                 mon.duration = Math.round(resolution * (performance.now() - mon.internals.started)) / resolution;
             });
@@ -90,3 +91,6 @@ export class MonitorImpl extends Monitor {
         }
     }
 }
+const MONITOR_TICK_OPTIONS = Object.freeze({
+    hint: 'Monitor.tick',
+});

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

@@ -9,7 +9,7 @@ import { Hooks, OptionsImpl } from './Hooks';
 import { JournalImpl } from './Journal';
 const BOOT_ARGS = [];
 const BOOT_CAUSE = '<boot>';
-const EMPTY_HANDLE = new ObjectHandle(undefined, undefined, Hooks.handler, EMPTY_SNAPSHOT, '<empty>');
+const EMPTY_HANDLE = new ObjectHandle(undefined, undefined, Hooks.reactive, EMPTY_SNAPSHOT, '<empty>');
 export class OperationController extends Controller {
     constructor(h, m) {
         super();

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

@@ -0,0 +1,33 @@
+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

@@ -0,0 +1,42 @@
+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

@@ -0,0 +1,15 @@
+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

@@ -0,0 +1,24 @@
+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;
+    }
+}

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

@@ -0,0 +1,61 @@
+export declare type GetItemKey<T = unknown> = (item: T) => string | undefined;
+export interface CollectionReader<T> {
+    readonly strict: boolean;
+    readonly count: number;
+    readonly addedCount: number;
+    readonly removedCount: number;
+    readonly 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;
+}
+export interface Item<T> {
+    readonly self: T;
+    readonly prev?: Item<T>;
+    aux?: Item<T>;
+}
+export declare class Collection<T> implements CollectionReader<T> {
+    readonly strict: boolean;
+    readonly getKey: GetItemKey<T>;
+    private map;
+    private tag;
+    private current;
+    private added;
+    private removed;
+    private lastNotFoundKey;
+    private strictNextItem?;
+    constructor(strict: boolean, getKey: GetItemKey<T>);
+    get count(): number;
+    get addedCount(): number;
+    get removedCount(): number;
+    get isMergeInProgress(): boolean;
+    lookup(key: string | undefined): 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;
+    markAsMoved(item: Item<T>): void;
+    static createItem<T>(self: T): Item<T>;
+}

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

@@ -0,0 +1,275 @@
+export class Collection {
+    constructor(strict, getKey) {
+        this.strict = strict;
+        this.getKey = getKey;
+        this.map = new Map();
+        this.tag = ~0;
+        this.current = new ItemChain();
+        this.added = new ItemChain();
+        this.removed = new ItemChain();
+        this.lastNotFoundKey = undefined;
+        this.strictNextItem = undefined;
+    }
+    get count() {
+        return this.current.count;
+    }
+    get addedCount() {
+        return this.added.count;
+    }
+    get removedCount() {
+        return this.removed.count;
+    }
+    get isMergeInProgress() {
+        return this.tag > 0;
+    }
+    lookup(key) {
+        let result = undefined;
+        if (key !== undefined && key !== this.lastNotFoundKey) {
+            result = this.map.get(key);
+            if (result) {
+                if (this.getKey(result.self) !== key) {
+                    this.lastNotFoundKey = key;
+                    result = undefined;
+                }
+            }
+            else
+                this.lastNotFoundKey = key;
+        }
+        return result;
+    }
+    claim(key) {
+        const tag = this.tag;
+        if (tag < 0)
+            throw new Error('merge is not in progress');
+        let item = this.strictNextItem;
+        if (key !== (item ? this.getKey(item.self) : undefined))
+            item = this.lookup(key);
+        if (item) {
+            if (item.tag === tag)
+                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);
+        }
+        return item;
+    }
+    add(self) {
+        const key = this.getKey(self);
+        if (this.lookup(key) !== undefined)
+            throw new Error(`key is already in use: ${key}`);
+        let tag = this.tag;
+        if (tag < 0) {
+            tag = ~this.tag + 1;
+            this.tag = ~tag;
+        }
+        const item = new ItemImpl(self, tag);
+        this.map.set(key, item);
+        this.lastNotFoundKey = undefined;
+        this.strictNextItem = undefined;
+        this.current.include(item);
+        this.added.aux(item);
+        return item;
+    }
+    remove(item) {
+        const t = item;
+        if (!this.isRemoved(t)) {
+            this.current.exclude(t);
+            this.removed.include(t);
+            t.tag--;
+        }
+    }
+    move(item, after) {
+        throw new Error('not implemented');
+    }
+    beginMerge() {
+        if (this.isMergeInProgress)
+            throw new Error('merge is in progress already');
+        this.tag = ~this.tag + 1;
+        this.strictNextItem = this.current.first;
+        this.removed.grab(this.current, false);
+        this.added.reset();
+    }
+    endMerge(error) {
+        if (!this.isMergeInProgress)
+            throw new Error('merge is ended already');
+        this.tag = ~this.tag;
+        if (error === undefined) {
+            const currentCount = this.current.count;
+            if (currentCount > 0) {
+                const getKey = this.getKey;
+                if (currentCount > this.removed.count) {
+                    const map = this.map;
+                    for (const x of this.removed.items())
+                        map.delete(getKey(x.self));
+                }
+                else {
+                    const map = this.map = new Map();
+                    for (const x of this.current.items())
+                        map.set(getKey(x.self), x);
+                }
+            }
+            else
+                this.map = new Map();
+        }
+        else {
+            this.current.grab(this.removed, true);
+            const getKey = this.getKey;
+            for (const x of this.added.itemsViaAux()) {
+                this.map.delete(getKey(x.self));
+                this.current.exclude(x);
+            }
+            this.added.reset();
+        }
+    }
+    resetAddedAndRemovedLists() {
+        this.removed.reset();
+        this.added.reset();
+    }
+    *items() {
+        let x = this.current.first;
+        while (x !== undefined) {
+            const next = x.next;
+            yield x;
+            x = next;
+        }
+    }
+    *addedItems(reset) {
+        let x = this.added.first;
+        while (x !== undefined) {
+            const next = x.aux;
+            if (!this.isRemoved(x))
+                yield x;
+            x = next;
+        }
+        if (reset)
+            this.added.reset();
+    }
+    *removedItems(reset) {
+        let x = this.removed.first;
+        while (x !== undefined) {
+            const next = x.next;
+            yield x;
+            x = next;
+        }
+        if (reset)
+            this.removed.reset();
+    }
+    isAdded(item) {
+        const t = item;
+        let tag = this.tag;
+        if (tag < 0)
+            tag = ~tag;
+        return t.status === ~tag && t.tag > 0;
+    }
+    isMoved(item) {
+        const t = item;
+        let tag = this.tag;
+        if (tag < 0)
+            tag = ~tag;
+        return t.status === tag && t.tag > 0;
+    }
+    isRemoved(item) {
+        const t = item;
+        const tag = this.tag;
+        return tag > 0 ? t.tag < tag : t.tag < tag - 1;
+    }
+    isCurrent(item) {
+        const t = item;
+        return t.tag === this.tag;
+    }
+    markAsMoved(item) {
+        const t = item;
+        if (t.tag > 0)
+            t.status = t.tag;
+    }
+    static createItem(self) {
+        return new ItemImpl(self, 0);
+    }
+}
+class ItemImpl {
+    constructor(self, tag) {
+        this.self = self;
+        this.tag = tag;
+        this.status = ~tag;
+        this.next = undefined;
+        this.prev = undefined;
+        this.aux = undefined;
+    }
+}
+class ItemChain {
+    constructor() {
+        this.count = 0;
+        this.first = undefined;
+        this.last = undefined;
+    }
+    *items() {
+        let x = this.first;
+        while (x !== undefined) {
+            const next = x.next;
+            yield x;
+            x = next;
+        }
+    }
+    *itemsViaAux() {
+        let x = this.first;
+        while (x !== undefined) {
+            const next = x.aux;
+            yield x;
+            x = next;
+        }
+    }
+    reset() {
+        this.count = 0;
+        this.first = undefined;
+        this.last = undefined;
+    }
+    grab(from, join) {
+        const head = from.first;
+        if (join && head) {
+            const last = this.last;
+            head.prev = last;
+            if (last)
+                this.last = last.next = head;
+            else
+                this.first = this.last = head;
+            this.count += from.count;
+        }
+        else {
+            this.count = from.count;
+            this.first = head;
+            this.last = from.last;
+        }
+        from.reset();
+    }
+    include(item) {
+        const last = this.last;
+        item.prev = last;
+        item.next = undefined;
+        if (last)
+            this.last = last.next = item;
+        else
+            this.first = this.last = item;
+        this.count++;
+    }
+    exclude(item) {
+        if (item.prev !== undefined)
+            item.prev.next = item.next;
+        if (item.next !== undefined)
+            item.next.prev = item.prev;
+        if (item === this.first)
+            this.first = item.next;
+        this.count--;
+    }
+    aux(item) {
+        item.aux = undefined;
+        const last = this.last;
+        if (last)
+            this.last = last.aux = item;
+        else
+            this.first = this.last = item;
+        this.count++;
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "reactronic",
-  "version": "0.22.312",
+  "version": "0.22.315",
   "description": "Reactronic - Transactional Reactive State Management",
   "type": "module",
   "main": "build/dist/source/api.js",
@@ -30,15 +30,15 @@
   },
   "homepage": "https://github.com/nezaboodka/reactronic/blob/master/README.md#readme",
   "devDependencies": {
-    "@types/node": "18.0.0",
-    "@types/react": "18.0.14",
-    "@typescript-eslint/eslint-plugin": "5.29.0",
-    "@typescript-eslint/parser": "5.29.0",
-    "ava": "4.3.0",
+    "@types/node": "18.0.5",
+    "@types/react": "18.0.15",
+    "@typescript-eslint/eslint-plugin": "5.30.6",
+    "@typescript-eslint/parser": "5.30.6",
+    "ava": "4.3.1",
     "c8": "7.11.3",
-    "eslint": "8.18.0",
+    "eslint": "8.19.0",
     "react": "18.2.0",
-    "ts-node": "10.8.1",
+    "ts-node": "10.9.1",
     "typescript": "4.7.3"
   },
   "scripts": {