reactronic 0.22.109 → 0.22.202

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

@@ -65,16 +65,15 @@ class Snapshot {
         let r = this.seekRevision(h, m);
         const existing = r.data[m];
         if (existing !== Data_1.Meta.Unobservable) {
-            this.checkIfEditable(h, r, m, existing, value, token);
-            if (r.snapshot !== this) {
+            if (this.isNewRevisionRequired(h, r, m, existing, value, token)) {
                 const data = Object.assign({}, m === Data_1.Meta.Holder ? value : r.data);
                 Reflect.set(data, Data_1.Meta.Holder, h);
                 r = new Data_1.ObjectRevision(this, r, data);
                 this.changeset.set(h, r);
                 h.editing = r;
                 h.editors++;
-                if (Dbg_1.Dbg.isOn && Dbg_1.Dbg.trace.write)
-                    Dbg_1.Dbg.log('║', '  ⎘', `${Dump.obj(h)} is cloned`);
+                if (Dbg_1.Log.isOn && Dbg_1.Log.opt.write)
+                    Dbg_1.Log.write('║', '  ⎘', `${Dump.obj(h)} is cloned`);
             }
         }
         else
@@ -98,8 +97,8 @@ class Snapshot {
         }
         return r;
     }
-    checkIfEditable(h, r, m, existing, value, token) {
-        if (this.sealed)
+    isNewRevisionRequired(h, r, m, existing, value, token) {
+        if (this.sealed && r.snapshot !== exports.ROOT_REV.snapshot)
             throw (0, Dbg_1.misuse)(`observable property ${Dump.obj(h, m)} can only be modified inside transaction`);
         if (m !== Data_1.Meta.Holder && value !== Data_1.Meta.Holder) {
             if (r.snapshot !== this || r.prev.revision !== exports.ROOT_REV) {
@@ -109,6 +108,7 @@ class Snapshot {
             if (r === exports.ROOT_REV)
                 throw (0, Dbg_1.misuse)(`member ${Dump.rev(r, m)} doesn't exist in snapshot v${this.stamp} (${this.hint})`);
         }
+        return r.snapshot !== this && !this.sealed;
     }
     acquire(outer) {
         if (!this.sealed && this.stamp === exports.UNDEFINED_TIMESTAMP) {
@@ -117,8 +117,8 @@ class Snapshot {
             Snapshot.pending.push(this);
             if (Snapshot.oldest === undefined)
                 Snapshot.oldest = this;
-            if (Dbg_1.Dbg.isOn && Dbg_1.Dbg.trace.transaction)
-                Dbg_1.Dbg.log('╔══', `v${this.stamp}`, `${this.hint}`);
+            if (Dbg_1.Log.isOn && Dbg_1.Log.opt.transaction)
+                Dbg_1.Log.write('╔══', `v${this.stamp}`, `${this.hint}`);
         }
     }
     bumpBy(timestamp) {
@@ -136,8 +136,8 @@ class Snapshot {
                             conflicts = [];
                         conflicts.push(r);
                     }
-                    if (Dbg_1.Dbg.isOn && Dbg_1.Dbg.trace.transaction)
-                        Dbg_1.Dbg.log('╠╝', '', `${Dump.rev2(h, r.snapshot)} is merged with ${Dump.rev2(h, h.head.snapshot)} among ${merged} properties with ${r.conflicts.size} conflicts.`);
+                    if (Dbg_1.Log.isOn && Dbg_1.Log.opt.transaction)
+                        Dbg_1.Log.write('╠╝', '', `${Dump.rev2(h, r.snapshot)} is merged with ${Dump.rev2(h, h.head.snapshot)} among ${merged} properties with ${r.conflicts.size} conflicts.`);
                 }
             });
             if (this.options.token === undefined) {
@@ -165,8 +165,8 @@ class Snapshot {
             if (headDisposed || m === Data_1.Meta.Disposed) {
                 if (headDisposed !== (m === Data_1.Meta.Disposed)) {
                     if (headDisposed || this.options.standalone !== 'disposal') {
-                        if (Dbg_1.Dbg.isOn && Dbg_1.Dbg.trace.change)
-                            Dbg_1.Dbg.log('║╠', '', `${Dump.rev2(h, ours.snapshot, m)} <> ${Dump.rev2(h, head.snapshot, m)}`, 0, ' *** CONFLICT ***');
+                        if (Dbg_1.Log.isOn && Dbg_1.Log.opt.change)
+                            Dbg_1.Log.write('║╠', '', `${Dump.rev2(h, ours.snapshot, m)} <> ${Dump.rev2(h, head.snapshot, m)}`, 0, ' *** CONFLICT ***');
                         ours.conflicts.set(m, head);
                     }
                 }
@@ -175,8 +175,8 @@ class Snapshot {
                 const conflict = Snapshot.isConflicting(head.data[m], ours.prev.revision.data[m]);
                 if (conflict)
                     ours.conflicts.set(m, head);
-                if (Dbg_1.Dbg.isOn && Dbg_1.Dbg.trace.change)
-                    Dbg_1.Dbg.log('║╠', '', `${Dump.rev2(h, ours.snapshot, m)} ${conflict ? '<>' : '=='} ${Dump.rev2(h, head.snapshot, m)}`, 0, conflict ? ' *** CONFLICT ***' : undefined);
+                if (Dbg_1.Log.isOn && Dbg_1.Log.opt.change)
+                    Dbg_1.Log.write('║╠', '', `${Dump.rev2(h, ours.snapshot, m)} ${conflict ? '<>' : '=='} ${Dump.rev2(h, head.snapshot, m)}`, 0, conflict ? ' *** CONFLICT ***' : undefined);
             }
         });
         Utils_1.Utils.copyAllMembers(merged, ours.data);
@@ -199,17 +199,17 @@ class Snapshot {
                 }
             }
         });
-        if (Dbg_1.Dbg.isOn) {
-            if (Dbg_1.Dbg.trace.change && !error) {
+        if (Dbg_1.Log.isOn) {
+            if (Dbg_1.Log.opt.change && !error) {
                 this.changeset.forEach((r, h) => {
                     const members = [];
                     r.changes.forEach((o, m) => members.push(m.toString()));
                     const s = members.join(', ');
-                    Dbg_1.Dbg.log('║', '√', `${Dump.rev2(h, r.snapshot)} (${s}) is ${r.prev.revision === exports.ROOT_REV ? 'constructed' : `applied on top of ${Dump.rev2(h, r.prev.revision.snapshot)}`}`);
+                    Dbg_1.Log.write('║', '√', `${Dump.rev2(h, r.snapshot)} (${s}) is ${r.prev.revision === exports.ROOT_REV ? 'constructed' : `applied on top of ${Dump.rev2(h, r.prev.revision.snapshot)}`}`);
                 });
             }
-            if (Dbg_1.Dbg.trace.transaction)
-                Dbg_1.Dbg.log(this.stamp < exports.UNDEFINED_TIMESTAMP ? '╚══' : '═══', `v${this.stamp}`, `${this.hint} - ${error ? 'CANCEL' : 'APPLY'}(${this.changeset.size})${error ? ` - ${error}` : ''}`);
+            if (Dbg_1.Log.opt.transaction)
+                Dbg_1.Log.write(this.stamp < exports.UNDEFINED_TIMESTAMP ? '╚══' : '═══', `v${this.stamp}`, `${this.hint} - ${error ? 'CANCEL' : 'APPLY'}(${this.changeset.size})${error ? ` - ${error}` : ''}`);
         }
         if (!error)
             Snapshot.propagateAllChangesThroughSubscriptions(this);
@@ -221,7 +221,7 @@ class Snapshot {
         else
             for (const m in r.prev.revision.data)
                 r.data[m] = Data_1.Meta.Disposed;
-        if (Dbg_1.Dbg.isOn)
+        if (Dbg_1.Log.isOn)
             Snapshot.freezeObjectRevision(r);
     }
     static sealObservable(observable, m, typeName) {
@@ -254,18 +254,18 @@ class Snapshot {
                 Snapshot.oldest = Snapshot.pending[0];
                 const now = Date.now();
                 if (now - Snapshot.lastGarbageCollectionSummaryTimestamp > Snapshot.garbageCollectionSummaryInterval) {
-                    Dbg_1.Dbg.log('', '[G]', `Total object/revision count: ${Snapshot.totalObjectHolderCount}/${Snapshot.totalObjectRevisionCount}`);
+                    Dbg_1.Log.write('', '[G]', `Total object/revision count: ${Snapshot.totalObjectHolderCount}/${Snapshot.totalObjectRevisionCount}`);
                     Snapshot.lastGarbageCollectionSummaryTimestamp = now;
                 }
             }
         }
     }
     unlinkHistory() {
-        if (Dbg_1.Dbg.isOn && Dbg_1.Dbg.trace.gc)
-            Dbg_1.Dbg.log('', '[G]', `Dismiss history below v${this.stamp}t${this.id} (${this.hint})`);
+        if (Dbg_1.Log.isOn && Dbg_1.Log.opt.gc)
+            Dbg_1.Log.write('', '[G]', `Dismiss history below v${this.stamp}t${this.id} (${this.hint})`);
         this.changeset.forEach((r, h) => {
-            if (Dbg_1.Dbg.isOn && Dbg_1.Dbg.trace.gc && r.prev.revision !== exports.ROOT_REV)
-                Dbg_1.Dbg.log(' ', '  ', `${Dump.rev2(h, r.prev.revision.snapshot)} is ready for GC because overwritten by ${Dump.rev2(h, r.snapshot)}`);
+            if (Dbg_1.Log.isOn && Dbg_1.Log.opt.gc && r.prev.revision !== exports.ROOT_REV)
+                Dbg_1.Log.write(' ', '  ', `${Dump.rev2(h, r.prev.revision.snapshot)} is ready for GC because overwritten by ${Dump.rev2(h, r.snapshot)}`);
             if (Snapshot.garbageCollectionSummaryInterval < Number.MAX_SAFE_INTEGER) {
                 if (r.prev.revision !== exports.ROOT_REV)
                     Snapshot.totalObjectRevisionCount--;
@@ -276,14 +276,14 @@ class Snapshot {
         });
         this.changeset = EMPTY_MAP;
         this.reactions = EMPTY_ARRAY;
-        if (Dbg_1.Dbg.isOn)
+        if (Dbg_1.Log.isOn)
             Object.freeze(this);
     }
     static _init() {
-        const root = exports.ROOT_REV.snapshot;
-        root.acquire(root);
-        root.applyOrDiscard();
-        root.triggerGarbageCollection();
+        const boot = exports.ROOT_REV.snapshot;
+        boot.acquire(boot);
+        boot.applyOrDiscard();
+        boot.triggerGarbageCollection();
         Snapshot.freezeObjectRevision(exports.ROOT_REV);
         Snapshot.idGen = 100;
         Snapshot.stampGen = 101;
@@ -314,7 +314,7 @@ class Dump {
     static obj(h, m, stamp, snapshotId, originSnapshotId, typeless) {
         const member = m !== undefined ? `.${m.toString()}` : '';
         return h === undefined
-            ? `root${member}`
+            ? `boot${member}`
             : stamp === undefined ? `${h.hint}${member} #${h.id}` : `${h.hint}${member} #${h.id}t${snapshotId}v${stamp}${originSnapshotId !== undefined && originSnapshotId !== 0 ? `t${originSnapshotId}` : ''}`;
     }
     static rev2(h, s, m, value) {
@@ -339,11 +339,11 @@ class Dump {
     }
 }
 exports.Dump = Dump;
-exports.ROOT_REV = new Data_1.ObjectRevision(new Snapshot({ hint: 'root-rev' }), undefined, {});
+exports.ROOT_REV = new Data_1.ObjectRevision(new Snapshot({ hint: '<root>' }), undefined, {});
 exports.DefaultSnapshotOptions = Object.freeze({
     hint: 'noname',
     standalone: false,
     journal: undefined,
-    trace: undefined,
+    logging: undefined,
     token: undefined,
 });

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

@@ -54,8 +54,8 @@ class TransactionImpl extends Transaction {
         const restore = TransactionImpl.inspection;
         try {
             TransactionImpl.inspection = true;
-            if (Dbg_1.Dbg.isOn && Dbg_1.Dbg.trace.transaction)
-                Dbg_1.Dbg.log(' ', ' ', `T${this.id}[${this.hint}] is being inspected by T${TransactionImpl.curr.id}[${TransactionImpl.curr.hint}]`);
+            if (Dbg_1.Log.isOn && Dbg_1.Log.opt.transaction)
+                Dbg_1.Log.write(' ', ' ', `T${this.id}[${this.hint}] is being inspected by T${TransactionImpl.curr.id}[${TransactionImpl.curr.hint}]`);
             return this.runImpl(undefined, func, ...args);
         }
         finally {
@@ -119,7 +119,7 @@ class TransactionImpl extends Transaction {
         const t = TransactionImpl.acquire(options);
         const root = t !== TransactionImpl.curr;
         t.guard();
-        let result = t.runImpl(options === null || options === void 0 ? void 0 : options.trace, func, ...args);
+        let result = t.runImpl(options === null || options === void 0 ? void 0 : options.logging, func, ...args);
         if (root) {
             if (result instanceof Promise) {
                 result = TransactionImpl.off(() => {
@@ -181,7 +181,7 @@ class TransactionImpl extends Transaction {
                         const options = {
                             hint: `${this.hint} - restart after T${this.after.id}`,
                             standalone: this.options.standalone === 'isolated' ? 'isolated' : true,
-                            trace: this.snapshot.options.trace,
+                            logging: this.snapshot.options.logging,
                             token: this.snapshot.options.token,
                         };
                         return TransactionImpl.run(options, func, ...args);
@@ -201,7 +201,7 @@ class TransactionImpl extends Transaction {
             return result;
         });
     }
-    runImpl(trace, func, ...args) {
+    runImpl(logging, func, ...args) {
         let result;
         const outer = TransactionImpl.curr;
         try {
@@ -241,10 +241,10 @@ class TransactionImpl extends Transaction {
         if (!t.canceled && error) {
             t.canceled = error;
             t.after = after;
-            if (Dbg_1.Dbg.isOn && Dbg_1.Dbg.trace.transaction) {
-                Dbg_1.Dbg.log('║', ' [!]', `${error.message}`, undefined, ' *** CANCEL ***');
+            if (Dbg_1.Log.isOn && Dbg_1.Log.opt.transaction) {
+                Dbg_1.Log.write('║', ' [!]', `${error.message}`, undefined, ' *** CANCEL ***');
                 if (after && after !== TransactionImpl.none)
-                    Dbg_1.Dbg.log('║', ' [!]', `T${t.id}[${t.hint}] will be restarted${t !== after ? ` after T${after.id}[${after.hint}]` : ''}`);
+                    Dbg_1.Log.write('║', ' [!]', `T${t.id}[${t.hint}] will be restarted${t !== after ? ` after T${after.id}[${after.hint}]` : ''}`);
             }
             Snapshot_1.Snapshot.revokeAllSubscriptions(t.snapshot);
         }
@@ -261,8 +261,8 @@ class TransactionImpl extends Transaction {
     applyOrDiscard() {
         let reactions;
         try {
-            if (Dbg_1.Dbg.isOn && Dbg_1.Dbg.trace.change)
-                Dbg_1.Dbg.log('╠═', '', '', undefined, 'changes');
+            if (Dbg_1.Log.isOn && Dbg_1.Log.opt.change)
+                Dbg_1.Log.write('╠═', '', '', undefined, 'changes');
             reactions = this.snapshot.applyOrDiscard(this.canceled);
             this.snapshot.triggerGarbageCollection();
             if (this.promise) {
@@ -271,7 +271,7 @@ class TransactionImpl extends Transaction {
                 else
                     this.resolve();
             }
-            if (Dbg_1.Dbg.isOn)
+            if (Dbg_1.Log.isOn)
                 Object.freeze(this);
         }
         catch (e) {
@@ -305,7 +305,7 @@ class TransactionImpl extends Transaction {
         Snapshot_1.Snapshot._init();
     }
 }
-TransactionImpl.none = new TransactionImpl({ hint: '<none>' });
+TransactionImpl.none = new TransactionImpl({ hint: 'Transaction.off' });
 TransactionImpl.curr = TransactionImpl.none;
 TransactionImpl.inspection = false;
 TransactionImpl.frameStartTime = 0;

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

@@ -1,15 +1,15 @@
-import { TraceOptions } from '../Trace';
+import { LoggingOptions } from '../Logging';
 export declare function error(message: string, dump: Error | undefined): Error;
 export declare function misuse(message: string, dump?: any): Error;
 export declare function fatal(error: Error): Error;
-export declare class Dbg {
-    static DefaultLevel: TraceOptions;
+export declare class Log {
+    static DefaultLevel: LoggingOptions;
     static isOn: boolean;
-    static global: TraceOptions;
-    static get trace(): TraceOptions;
-    static getMergedTraceOptions: (local: Partial<TraceOptions> | undefined) => TraceOptions;
-    static setTraceMode(enabled: boolean, options?: TraceOptions): void;
-    static log(bar: string, tran: string, message: string, ms?: number, highlight?: string | undefined, dump?: any): void;
-    static logAs(options: Partial<TraceOptions> | undefined, bar: string, tran: string, message: string, ms?: number, highlight?: string | undefined, dump?: any): void;
-    static merge(t: Partial<TraceOptions> | undefined, color: number | undefined, prefix: string | undefined, existing: TraceOptions): TraceOptions;
+    static global: LoggingOptions;
+    static get opt(): LoggingOptions;
+    static getMergedLoggingOptions: (local: Partial<LoggingOptions> | undefined) => LoggingOptions;
+    static setMode(isOn: boolean, options?: LoggingOptions): void;
+    static write(bar: string, tran: string, message: string, ms?: number, highlight?: string | undefined, dump?: any): void;
+    static writeAs(options: Partial<LoggingOptions> | undefined, bar: string, tran: string, message: string, ms?: number, highlight?: string | undefined, dump?: any): void;
+    static merge(t: Partial<LoggingOptions> | undefined, color: number | undefined, prefix: string | undefined, existing: LoggingOptions): LoggingOptions;
 }

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

@@ -1,46 +1,46 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Dbg = exports.fatal = exports.misuse = exports.error = void 0;
+exports.Log = exports.fatal = exports.misuse = exports.error = void 0;
 function error(message, dump) {
-    if (Dbg.isOn && Dbg.trace.error)
-        Dbg.log('█', ' ███', message, undefined, ' *** ERROR ***', dump);
+    if (Log.isOn && Log.opt.error)
+        Log.write('█', ' ███', message, undefined, ' *** ERROR ***', dump);
     return new Error(message);
 }
 exports.error = error;
 function misuse(message, dump) {
     const error = new Error(message);
-    Dbg.log(' ', ' ███', message, undefined, ' *** ERROR / MISUSE ***', dump !== null && dump !== void 0 ? dump : error);
+    Log.write(' ', ' ███', message, undefined, ' *** ERROR / MISUSE ***', dump !== null && dump !== void 0 ? dump : error);
     return error;
 }
 exports.misuse = misuse;
 function fatal(error) {
-    Dbg.log(' ', ' ███', error.message, undefined, ' *** FATAL ***', error);
+    Log.write(' ', ' ███', error.message, undefined, ' *** FATAL ***', error);
     return error;
 }
 exports.fatal = fatal;
-class Dbg {
-    static get trace() { return this.getMergedTraceOptions(undefined); }
-    static setTraceMode(enabled, options) {
-        Dbg.isOn = enabled;
-        Dbg.global = options || Dbg.DefaultLevel;
-        if (enabled) {
-            const t = Dbg.global;
-            const o = Object.keys(Dbg.global).filter(x => t[x] === true).join(', ');
-            Dbg.log('', '', `Reactronic trace is enabled: ${o}`);
-            Dbg.log('', '', 'Method-level trace can be configured with @options({ trace: ... }) decorator');
+class Log {
+    static get opt() { return this.getMergedLoggingOptions(undefined); }
+    static setMode(isOn, options) {
+        Log.global = options || Log.DefaultLevel;
+        if (isOn) {
+            const t = Log.global;
+            const o = Object.keys(Log.global).filter(x => t[x] === true).join(', ');
+            Log.write('', '', `Reactronic logging is turned on: ${o}`);
+            Log.write('', '', 'Member-level logging can be configured with @options({ logging: ... }) decorator');
         }
-        else
-            Dbg.log('', '', 'Reactronic trace is disabled');
+        else if (Log.isOn)
+            Log.write('', '', 'Reactronic logging is turned off');
+        Log.isOn = isOn;
     }
-    static log(bar, tran, message, ms = 0, highlight = undefined, dump) {
-        Dbg.logAs(undefined, bar, tran, message, ms, highlight, dump);
+    static write(bar, tran, message, ms = 0, highlight = undefined, dump) {
+        Log.writeAs(undefined, bar, tran, message, ms, highlight, dump);
     }
-    static logAs(options, bar, tran, message, ms = 0, highlight = undefined, dump) {
-        const t = Dbg.getMergedTraceOptions(options);
+    static writeAs(options, bar, tran, message, ms = 0, highlight = undefined, dump) {
+        const t = Log.getMergedLoggingOptions(options);
         const margin1 = '  '.repeat(t.margin1 >= 0 ? t.margin1 : 0);
         const margin2 = '  '.repeat(t.margin2);
-        const silent = (options && options.silent !== undefined) ? options.silent : t.silent;
-        if (!silent) {
+        const enabled = (options && options.enabled !== undefined) ? options.enabled : t.enabled;
+        if (enabled) {
             console.log('\x1b[37m%s\x1b[0m \x1b[' + t.color + 'm%s %s%s\x1b[0m \x1b[' + t.color + 'm%s%s\x1b[0m \x1b[' + t.color + 'm%s\x1b[0m%s', '', t.prefix, t.transaction ? margin1 : '', t.transaction ? bar : bar.replace(/./g, ' '), margin2, tran, message, (highlight !== undefined ? `${highlight}` : '') + (ms > 2 ? `    [ ${ms}ms ]` : ''));
             if (dump)
                 console.log(dump);
@@ -48,7 +48,7 @@ class Dbg {
     }
     static merge(t, color, prefix, existing) {
         const result = !t ? Object.assign({}, existing) : {
-            silent: t.silent !== undefined ? t.silent : existing.silent,
+            enabled: t.enabled !== undefined ? t.enabled : existing.enabled,
             transaction: t.transaction !== undefined ? t.transaction : existing.transaction,
             operation: t.operation !== undefined ? t.operation : existing.operation,
             step: t.step !== undefined ? t.step : existing.step,
@@ -72,9 +72,9 @@ class Dbg {
         return result;
     }
 }
-exports.Dbg = Dbg;
-Dbg.DefaultLevel = {
-    silent: false,
+exports.Log = Log;
+Log.DefaultLevel = {
+    enabled: true,
     error: false,
     warning: false,
     transaction: false,
@@ -91,6 +91,6 @@ Dbg.DefaultLevel = {
     margin1: 0,
     margin2: 0,
 };
-Dbg.isOn = false;
-Dbg.global = Dbg.DefaultLevel;
-Dbg.getMergedTraceOptions = (local) => Dbg.global;
+Log.isOn = false;
+Log.global = Log.DefaultLevel;
+Log.getMergedLoggingOptions = (local) => Log.global;

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

@@ -8,8 +8,8 @@ class Sealant {
         const createCopy = result[Sealant.CreateCopy];
         if (createCopy)
             result = createCopy.call(result);
-        if (Dbg_1.Dbg.isOn && Dbg_1.Dbg.trace.write)
-            Dbg_1.Dbg.log('║', ' ', `${typeName}.${member.toString()} - collection is sealed`);
+        if (Dbg_1.Log.isOn && Dbg_1.Log.opt.write)
+            Dbg_1.Log.write('║', ' ', `${typeName}.${member.toString()} - collection is sealed`);
         Object.setPrototypeOf(result, sealedType);
         Object.freeze(result);
         return result;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "reactronic",
-  "version": "0.22.109",
+  "version": "0.22.202",
   "description": "Reactronic - Transactional Reactive State Management",
   "main": "build/dist/source/api.js",
   "types": "build/dist/source/api.d.ts",