reactronic 0.22.313 → 0.22.316

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.handler, 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

@@ -0,0 +1,63 @@
+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, resolution?: {
+        isDuplicate: boolean;
+    }): 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,283 @@
+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, resolution) {
+        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) {
+                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}`);
+        }
+        else if (resolution)
+            resolution.isDuplicate = false;
+        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.313",
+  "version": "0.22.316",
   "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": {