reactronic 0.22.400 → 0.22.410

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

@@ -1,6 +1,7 @@
 import { LoggingOptions } from './Logging';
 import { SeparationMode } from './impl/Data';
-export { LoggingOptions, ProfilingOptions, LoggingLevel } from './Logging';
+export { LoggingLevel } from './Logging';
+export type { LoggingOptions, ProfilingOptions } from './Logging';
 import { Journal } from './impl/Journal';
 import { Monitor } from './impl/Monitor';
 export interface SnapshotOptions {

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

@@ -1,12 +1,15 @@
 export { all, pause } from './util/Utils';
-export { Collection, Item, CollectionReader } from './util/Collection';
+export { Collection } from './util/Collection';
+export type { Item, CollectionReader } from './util/Collection';
 export { SealedArray } from './util/SealedArray';
 export { SealedMap } from './util/SealedMap';
 export { SealedSet } from './util/SealedSet';
-export { MemberOptions, SnapshotOptions, Kind, Reentrance, LoggingOptions, ProfilingOptions, LoggingLevel } from './Options';
-export { Worker } from './Worker';
+export { Kind, Reentrance, LoggingLevel } from './Options';
+export type { MemberOptions, SnapshotOptions, LoggingOptions, ProfilingOptions } from './Options';
+export type { Worker } from './Worker';
 export { Controller } from './Controller';
-export { Ref, ToggleRef, BoolOnly, GivenTypeOnly } from './Ref';
+export { Ref, ToggleRef } from './Ref';
+export type { BoolOnly, GivenTypeOnly } from './Ref';
 export { TransactionalObject, ObservableObject } from './impl/Mvcc';
 export { TransactionalArray, ObservableArray } from './impl/MvccArray';
 export { TransactionalMap, ObservableMap } from './impl/MvccMap';

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

@@ -1,6 +1,6 @@
 import { MvccObject } from './Mvcc';
 export declare class MvccArray<T> extends MvccObject {
-    private all;
+    private impl;
     constructor(isObservable: boolean, array: Array<T>);
     get length(): number;
     set length(n: number);

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

@@ -3,47 +3,47 @@ import { MvccObject } from './Mvcc';
 export class MvccArray extends MvccObject {
     constructor(isObservable, array) {
         super(isObservable);
-        this.all = array;
+        this.impl = array;
     }
-    get length() { return this.all.length; }
+    get length() { return this.impl.length; }
     set length(n) { this.mutable.length = n; }
-    getItem(n) { return this.all[n]; }
+    getItem(n) { return this.impl[n]; }
     setItem(n, item) { this.mutable[n] = item; }
-    toString() { return this.all.toString(); }
-    toLocaleString() { return this.all.toLocaleString(); }
+    toString() { return this.impl.toString(); }
+    toLocaleString() { return this.impl.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); }
+    concat(...items) { return this.impl.concat(...items); }
+    join(separator) { return this.impl.join(separator); }
     reverse() { return this.mutable.reverse(); }
     shift() { return this.mutable.shift(); }
-    slice(start, end) { return this.all.slice(start, end); }
+    slice(start, end) { return this.impl.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); }
+    includes(searchElement, fromIndex) { return this.impl.includes(searchElement, fromIndex); }
+    indexOf(searchElement, fromIndex) { return this.impl.indexOf(searchElement, fromIndex); }
+    lastIndexOf(searchElement, fromIndex) { return this.impl.lastIndexOf(searchElement, fromIndex); }
+    every(predicate, thisArg) { return this.impl.every(predicate, thisArg); }
+    some(predicate, thisArg) { return this.impl.some(predicate, thisArg); }
+    forEach(callbackfn, thisArg) { return this.impl.forEach(callbackfn, thisArg); }
+    map(callbackfn, thisArg) { return this.impl.map(callbackfn, thisArg); }
+    filter(predicate, thisArg) { return this.impl.filter(predicate, thisArg); }
+    reduce(callbackfn, initialValue) { return initialValue !== undefined ? this.impl.reduce(callbackfn, initialValue) : this.impl.reduce(callbackfn); }
+    reduceRight(callbackfn, initialValue) { return initialValue !== undefined ? this.impl.reduceRight(callbackfn, initialValue) : this.impl.reduceRight(callbackfn); }
+    find(predicate, thisArg) { return this.impl.find(predicate, thisArg); }
+    findIndex(predicate, thisArg) { return this.impl.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(); }
+    [Symbol.iterator]() { return this.impl[Symbol.iterator](); }
+    entries() { return this.impl.entries(); }
+    keys() { return this.impl.keys(); }
+    values() { return this.impl.values(); }
     get mutable() {
-        const createCopy = this.all[Sealant.CreateCopy];
+        const createCopy = this.impl[Sealant.CreateCopy];
         if (createCopy)
-            return this.all = createCopy.call(this.all);
-        return this.all;
+            return this.impl = createCopy.call(this.impl);
+        return this.impl;
     }
 }
 export class TransactionalArray extends MvccArray {

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

@@ -1,7 +1,7 @@
 import { Collection, Item, CollectionReader } from '../util/Collection';
 import { ObservableObject } from './Mvcc';
 export declare abstract class ObservableCollection<T> extends ObservableObject implements CollectionReader<T> {
-    protected abstract a: Collection<T>;
+    protected abstract impl: Collection<T>;
     get strict(): boolean;
     get count(): number;
     get addedCount(): number;

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

@@ -1,23 +1,23 @@
 import { ObservableObject } from './Mvcc';
 export class ObservableCollection extends ObservableObject {
-    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); }
+    get strict() { return this.impl.strict; }
+    get count() { return this.impl.count; }
+    get addedCount() { return this.impl.addedCount; }
+    get removedCount() { return this.impl.removedCount; }
+    get isMergeInProgress() { return this.impl.isMergeInProgress; }
+    lookup(key) { return this.impl.lookup(key); }
+    claim(key) { return this.impl.claim(key); }
+    add(self) { return this.impl.add(self); }
+    remove(item) { return this.impl.remove(item); }
+    move(item, after) { this.impl.move(item, after); }
+    beginMerge() { this.impl.beginMerge(); }
+    endMerge(error) { this.impl.endMerge(error); }
+    resetAddedAndRemovedLists() { this.impl.resetAddedAndRemovedLists(); }
+    items() { return this.impl.items(); }
+    addedItems(reset) { return this.impl.addedItems(reset); }
+    removedItems(reset) { return this.impl.removedItems(reset); }
+    isAdded(item) { return this.impl.isAdded(item); }
+    isMoved(item) { return this.impl.isMoved(item); }
+    isRemoved(item) { return this.impl.isRemoved(item); }
+    isCurrent(item) { return this.impl.isCurrent(item); }
 }

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

@@ -1,6 +1,6 @@
 import { MvccObject } from './Mvcc';
 export declare class MvccMap<K, V> extends MvccObject {
-    private all;
+    private impl;
     constructor(isObservable: boolean, map: Map<K, V>);
     clear(): void;
     delete(key: K): boolean;

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

@@ -3,29 +3,29 @@ import { MvccObject } from './Mvcc';
 export class MvccMap extends MvccObject {
     constructor(isObservable, map) {
         super(isObservable);
-        this.all = map;
+        this.impl = 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); }
+    forEach(callbackfn, thisArg) { this.impl.forEach(callbackfn, thisArg); }
+    get(key) { return this.impl.get(key); }
+    has(key) { return this.impl.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 size() { return this.impl.size; }
+    entries() { return this.impl.entries(); }
+    keys() { return this.impl.keys(); }
+    values() { return this.impl.values(); }
+    [Symbol.toStringTag]() { return this.impl[Symbol.toStringTag]; }
     get mutable() {
-        const createCopy = this.all[Sealant.CreateCopy];
+        const createCopy = this.impl[Sealant.CreateCopy];
         if (createCopy)
-            return this.all = createCopy.call(this.all);
-        return this.all;
+            return this.impl = createCopy.call(this.impl);
+        return this.impl;
     }
 }
 export class TransactionalMap extends MvccMap {
     constructor(args) {
-        super(true, args !== undefined ? new Map(args) : new Map());
+        super(false, args !== undefined ? new Map(args) : new Map());
     }
 }
 export class ObservableMap extends MvccMap {

package/package.json

@@ -1,7 +1,8 @@
 {
   "name": "reactronic",
-  "version": "0.22.400",
+  "version": "0.22.410",
   "description": "Reactronic - Transactional Reactive State Management",
+  "icon": "reactronic.png",
   "type": "module",
   "main": "build/dist/source/api.js",
   "types": "build/dist/source/api.d.ts",