reactronic 0.22.314 → 0.22.317

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.314",
+  "version": "0.22.317",
   "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;
-    }
-}