reactronic 0.22.302 → 0.22.306

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

@@ -1,60 +0,0 @@
-import { Kind, SnapshotOptions } from '../Options';
-import { AbstractSnapshot, DataRevision, MemberName, DataHolder, Subscription, Subscriber } from './Data';
-export declare const MAX_TIMESTAMP: number;
-export declare const UNDEFINED_TIMESTAMP: number;
-export declare class Snapshot implements AbstractSnapshot {
-    static idGen: number;
-    private static stampGen;
-    private static pending;
-    private static oldest;
-    static garbageCollectionSummaryInterval: number;
-    static lastGarbageCollectionSummaryTimestamp: number;
-    static totalHolderCount: number;
-    static totalRevisionCount: number;
-    readonly id: number;
-    readonly options: SnapshotOptions;
-    get hint(): string;
-    get timestamp(): number;
-    private stamp;
-    private bumper;
-    changeset: Map<DataHolder, DataRevision>;
-    reactions: Subscriber[];
-    sealed: boolean;
-    constructor(options: SnapshotOptions | null);
-    static current: () => Snapshot;
-    static edit: () => Snapshot;
-    static markUsed: (subscription: Subscription, r: DataRevision, m: MemberName, h: DataHolder, kind: Kind, weak: boolean) => void;
-    static markEdited: (oldValue: any, newValue: any, edited: boolean, r: DataRevision, m: MemberName, h: DataHolder) => void;
-    static isConflicting: (oldValue: any, newValue: any) => boolean;
-    static propagateAllChangesThroughSubscriptions: (snapshot: Snapshot) => void;
-    static revokeAllSubscriptions: (snapshot: Snapshot) => void;
-    static enqueueReactionsToRun: (reactions: Array<Subscriber>) => void;
-    seekRevision(h: DataHolder, m: MemberName): DataRevision;
-    getCurrentRevision(h: DataHolder, m: MemberName): DataRevision;
-    getEditableRevision(h: DataHolder, m: MemberName, value: any, token?: any): DataRevision;
-    static takeSnapshot<T>(obj: T): T;
-    static dispose(obj: any): void;
-    static doDispose(ctx: Snapshot, h: DataHolder): DataRevision;
-    private isNewRevisionRequired;
-    acquire(outer: Snapshot): void;
-    bumpBy(timestamp: number): void;
-    rebase(): DataRevision[] | undefined;
-    private merge;
-    applyOrDiscard(error?: any): Array<Subscriber>;
-    static sealObjectRevision(h: DataHolder, r: DataRevision): void;
-    static sealSubscription(subscription: Subscription | symbol, m: MemberName, typeName: string): void;
-    static freezeObjectRevision(r: DataRevision): DataRevision;
-    triggerGarbageCollection(): void;
-    private unlinkHistory;
-    static _init(): void;
-}
-export declare class Dump {
-    static valueHint: (value: any, m?: PropertyKey | undefined) => string;
-    static obj(h: DataHolder | undefined, m?: MemberName | undefined, stamp?: number, snapshotId?: number, originSnapshotId?: number, value?: any): string;
-    static rev2(h: DataHolder, s: AbstractSnapshot, m?: MemberName, o?: Subscription): string;
-    static rev(r: DataRevision, m?: MemberName): string;
-    static conflicts(conflicts: DataRevision[]): string;
-    static conflictingMemberHint(m: MemberName, ours: DataRevision, theirs: DataRevision): string;
-}
-export declare const ROOT_REV: DataRevision;
-export declare const DefaultSnapshotOptions: SnapshotOptions;

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

@@ -1,353 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DefaultSnapshotOptions = exports.ROOT_REV = exports.Dump = exports.Snapshot = exports.UNDEFINED_TIMESTAMP = exports.MAX_TIMESTAMP = void 0;
-const Utils_1 = require("../util/Utils");
-const Dbg_1 = require("../util/Dbg");
-const Sealant_1 = require("../util/Sealant");
-const SealedArray_1 = require("../util/SealedArray");
-const SealedMap_1 = require("../util/SealedMap");
-const SealedSet_1 = require("../util/SealedSet");
-const Data_1 = require("./Data");
-exports.MAX_TIMESTAMP = Number.MAX_SAFE_INTEGER;
-exports.UNDEFINED_TIMESTAMP = exports.MAX_TIMESTAMP - 1;
-Object.defineProperty(Data_1.DataHolder.prototype, '#this', {
-    configurable: false, enumerable: false,
-    get() {
-        const result = {};
-        const data = Snapshot.current().getCurrentRevision(this, '#this').data;
-        for (const m in data) {
-            const v = data[m];
-            if (v instanceof Data_1.Subscription)
-                result[m] = v.content;
-            else if (v === Data_1.Meta.Nonreactive)
-                result[m] = this.data[m];
-            else
-                result[m] = v;
-        }
-        return result;
-    },
-});
-const EMPTY_ARRAY = Object.freeze([]);
-const EMPTY_MAP = Utils_1.Utils.freezeMap(new Map());
-class Snapshot {
-    constructor(options) {
-        this.id = ++Snapshot.idGen;
-        this.options = options !== null && options !== void 0 ? options : exports.DefaultSnapshotOptions;
-        this.stamp = exports.UNDEFINED_TIMESTAMP;
-        this.bumper = 100;
-        this.changeset = new Map();
-        this.reactions = [];
-        this.sealed = false;
-    }
-    get hint() { var _a; return (_a = this.options.hint) !== null && _a !== void 0 ? _a : 'noname'; }
-    get timestamp() { return this.stamp; }
-    seekRevision(h, m) {
-        let r = h.editing;
-        if (r && r.snapshot !== this) {
-            r = this.changeset.get(h);
-            if (r)
-                h.editing = r;
-        }
-        if (!r) {
-            r = h.head;
-            while (r !== exports.ROOT_REV && r.snapshot.timestamp > this.timestamp)
-                r = r.former.revision;
-        }
-        return r;
-    }
-    getCurrentRevision(h, m) {
-        const r = this.seekRevision(h, m);
-        if (r === exports.ROOT_REV)
-            throw (0, Dbg_1.misuse)(`object ${Dump.obj(h)} doesn't exist in snapshot v${this.stamp} (${this.hint})`);
-        return r;
-    }
-    getEditableRevision(h, m, value, token) {
-        let r = this.seekRevision(h, m);
-        const existing = r.data[m];
-        if (existing !== Data_1.Meta.Nonreactive) {
-            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.DataRevision(this, r, data);
-                this.changeset.set(h, r);
-                h.editing = r;
-                h.editors++;
-                if (Dbg_1.Log.isOn && Dbg_1.Log.opt.write)
-                    Dbg_1.Log.write('║', '  ⎘', `${Dump.obj(h)} is cloned`);
-            }
-        }
-        else
-            r = exports.ROOT_REV;
-        return r;
-    }
-    static takeSnapshot(obj) {
-        return obj[Data_1.Meta.Holder]['#this'];
-    }
-    static dispose(obj) {
-        const ctx = Snapshot.edit();
-        const h = Data_1.Meta.get(obj, Data_1.Meta.Holder);
-        if (h !== undefined)
-            Snapshot.doDispose(ctx, h);
-    }
-    static doDispose(ctx, h) {
-        const r = ctx.getEditableRevision(h, Data_1.Meta.Disposed, Data_1.Meta.Disposed);
-        if (r !== exports.ROOT_REV) {
-            r.data[Data_1.Meta.Disposed] = Data_1.Meta.Disposed;
-            Snapshot.markEdited(Data_1.Meta.Disposed, Data_1.Meta.Disposed, true, r, Data_1.Meta.Disposed, h);
-        }
-        return r;
-    }
-    isNewRevisionRequired(h, r, m, existing, value, token) {
-        if (this.sealed && r.snapshot !== exports.ROOT_REV.snapshot)
-            throw (0, Dbg_1.misuse)(`reactive 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.former.revision !== exports.ROOT_REV) {
-                if (this.options.token !== undefined && token !== this.options.token)
-                    throw (0, Dbg_1.misuse)(`${this.hint} should not have side effects (trying to change ${Dump.rev(r, m)})`);
-            }
-            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) {
-            const ahead = this.options.token === undefined || outer.stamp === exports.UNDEFINED_TIMESTAMP;
-            this.stamp = ahead ? Snapshot.stampGen : outer.stamp;
-            Snapshot.pending.push(this);
-            if (Snapshot.oldest === undefined)
-                Snapshot.oldest = this;
-            if (Dbg_1.Log.isOn && Dbg_1.Log.opt.transaction)
-                Dbg_1.Log.write('╔══', `v${this.stamp}`, `${this.hint}`);
-        }
-    }
-    bumpBy(timestamp) {
-        if (timestamp > this.bumper)
-            this.bumper = timestamp;
-    }
-    rebase() {
-        let conflicts = undefined;
-        if (this.changeset.size > 0) {
-            this.changeset.forEach((r, h) => {
-                if (r.former.revision !== h.head) {
-                    const merged = this.merge(h, r);
-                    if (r.conflicts.size > 0) {
-                        if (!conflicts)
-                            conflicts = [];
-                        conflicts.push(r);
-                    }
-                    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) {
-                if (this.bumper > 100) {
-                    this.bumper = this.stamp;
-                    this.stamp = ++Snapshot.stampGen;
-                }
-                else
-                    this.stamp = this.bumper + 1;
-            }
-            else {
-                this.stamp = this.bumper;
-            }
-        }
-        return conflicts;
-    }
-    merge(h, ours) {
-        let counter = 0;
-        const head = h.head;
-        const headDisposed = head.changes.has(Data_1.Meta.Disposed);
-        const merged = Object.assign({}, head.data);
-        ours.changes.forEach((o, m) => {
-            counter++;
-            merged[m] = ours.data[m];
-            if (headDisposed || m === Data_1.Meta.Disposed) {
-                if (headDisposed !== (m === Data_1.Meta.Disposed)) {
-                    if (headDisposed || this.options.standalone !== 'disposal') {
-                        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);
-                    }
-                }
-            }
-            else {
-                const conflict = Snapshot.isConflicting(head.data[m], ours.former.revision.data[m]);
-                if (conflict)
-                    ours.conflicts.set(m, head);
-                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);
-        ours.former.revision = head;
-        return counter;
-    }
-    applyOrDiscard(error) {
-        this.sealed = true;
-        this.changeset.forEach((r, h) => {
-            Snapshot.sealObjectRevision(h, r);
-            h.editors--;
-            if (h.editors === 0)
-                h.editing = undefined;
-            if (!error) {
-                h.head = r;
-                if (Snapshot.garbageCollectionSummaryInterval < Number.MAX_SAFE_INTEGER) {
-                    Snapshot.totalRevisionCount++;
-                    if (r.former.revision === exports.ROOT_REV)
-                        Snapshot.totalHolderCount++;
-                }
-            }
-        });
-        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.Log.write('║', '√', `${Dump.rev2(h, r.snapshot)} (${s}) is ${r.former.revision === exports.ROOT_REV ? 'constructed' : `applied on top of ${Dump.rev2(h, r.former.revision.snapshot)}`}`);
-                });
-            }
-            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);
-        return this.reactions;
-    }
-    static sealObjectRevision(h, r) {
-        if (!r.changes.has(Data_1.Meta.Disposed))
-            r.changes.forEach((o, m) => Snapshot.sealSubscription(r.data[m], m, h.proxy.constructor.name));
-        else
-            for (const m in r.former.revision.data)
-                r.data[m] = Data_1.Meta.Disposed;
-        if (Dbg_1.Log.isOn)
-            Snapshot.freezeObjectRevision(r);
-    }
-    static sealSubscription(subscription, m, typeName) {
-        if (subscription instanceof Data_1.Subscription) {
-            const value = subscription.content;
-            if (value !== undefined && value !== null) {
-                const sealedType = Object.getPrototypeOf(value)[Sealant_1.Sealant.SealedType];
-                if (sealedType)
-                    subscription.content = Sealant_1.Sealant.seal(value, sealedType, typeName, m);
-            }
-        }
-    }
-    static freezeObjectRevision(r) {
-        Object.freeze(r.data);
-        Utils_1.Utils.freezeSet(r.changes);
-        Utils_1.Utils.freezeMap(r.conflicts);
-        return r;
-    }
-    triggerGarbageCollection() {
-        if (this.stamp !== 0) {
-            if (this === Snapshot.oldest) {
-                const p = Snapshot.pending;
-                p.sort((a, b) => a.stamp - b.stamp);
-                let i = 0;
-                while (i < p.length && p[i].sealed) {
-                    p[i].unlinkHistory();
-                    i++;
-                }
-                Snapshot.pending = p.slice(i);
-                Snapshot.oldest = Snapshot.pending[0];
-                const now = Date.now();
-                if (now - Snapshot.lastGarbageCollectionSummaryTimestamp > Snapshot.garbageCollectionSummaryInterval) {
-                    Dbg_1.Log.write('', '[G]', `Total object/revision count: ${Snapshot.totalHolderCount}/${Snapshot.totalRevisionCount}`);
-                    Snapshot.lastGarbageCollectionSummaryTimestamp = now;
-                }
-            }
-        }
-    }
-    unlinkHistory() {
-        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.Log.isOn && Dbg_1.Log.opt.gc && r.former.revision !== exports.ROOT_REV)
-                Dbg_1.Log.write(' ', '  ', `${Dump.rev2(h, r.former.revision.snapshot)} is ready for GC because overwritten by ${Dump.rev2(h, r.snapshot)}`);
-            if (Snapshot.garbageCollectionSummaryInterval < Number.MAX_SAFE_INTEGER) {
-                if (r.former.revision !== exports.ROOT_REV)
-                    Snapshot.totalRevisionCount--;
-                if (r.changes.has(Data_1.Meta.Disposed))
-                    Snapshot.totalHolderCount--;
-            }
-            r.former.revision = exports.ROOT_REV;
-        });
-        this.changeset = EMPTY_MAP;
-        this.reactions = EMPTY_ARRAY;
-        if (Dbg_1.Log.isOn)
-            Object.freeze(this);
-    }
-    static _init() {
-        const boot = exports.ROOT_REV.snapshot;
-        boot.acquire(boot);
-        boot.applyOrDiscard();
-        boot.triggerGarbageCollection();
-        Snapshot.freezeObjectRevision(exports.ROOT_REV);
-        Snapshot.idGen = 100;
-        Snapshot.stampGen = 101;
-        Snapshot.oldest = undefined;
-        SealedArray_1.SealedArray.prototype;
-        SealedMap_1.SealedMap.prototype;
-        SealedSet_1.SealedSet.prototype;
-    }
-}
-exports.Snapshot = Snapshot;
-Snapshot.idGen = -1;
-Snapshot.stampGen = 1;
-Snapshot.pending = [];
-Snapshot.oldest = undefined;
-Snapshot.garbageCollectionSummaryInterval = Number.MAX_SAFE_INTEGER;
-Snapshot.lastGarbageCollectionSummaryTimestamp = Date.now();
-Snapshot.totalHolderCount = 0;
-Snapshot.totalRevisionCount = 0;
-Snapshot.current = Utils_1.UNDEF;
-Snapshot.edit = Utils_1.UNDEF;
-Snapshot.markUsed = Utils_1.UNDEF;
-Snapshot.markEdited = Utils_1.UNDEF;
-Snapshot.isConflicting = Utils_1.UNDEF;
-Snapshot.propagateAllChangesThroughSubscriptions = (snapshot) => { };
-Snapshot.revokeAllSubscriptions = (snapshot) => { };
-Snapshot.enqueueReactionsToRun = (reactions) => { };
-class Dump {
-    static obj(h, m, stamp, snapshotId, originSnapshotId, value) {
-        const member = m !== undefined ? `.${m.toString()}` : '';
-        return h === undefined
-            ? `boot${member}`
-            : stamp === undefined
-                ? `${h.hint}${member}${value !== undefined ? `[=${Dump.valueHint(value)}]` : ''} #${h.id}`
-                : `${h.hint}${member}${value !== undefined ? `[=${Dump.valueHint(value)}]` : ''} #${h.id}t${snapshotId}v${stamp}${originSnapshotId !== undefined && originSnapshotId !== 0 ? `t${originSnapshotId}` : ''}`;
-    }
-    static rev2(h, s, m, o) {
-        var _a;
-        return Dump.obj(h, m, s.timestamp, s.id, o === null || o === void 0 ? void 0 : o.originSnapshotId, (_a = o === null || o === void 0 ? void 0 : o.content) !== null && _a !== void 0 ? _a : Data_1.Meta.Undefined);
-    }
-    static rev(r, m) {
-        const h = Data_1.Meta.get(r.data, Data_1.Meta.Holder);
-        const value = m !== undefined ? r.data[m] : undefined;
-        return Dump.obj(h, m, r.snapshot.timestamp, r.snapshot.id, value === null || value === void 0 ? void 0 : value.originSnapshotId);
-    }
-    static conflicts(conflicts) {
-        return conflicts.map(ours => {
-            const items = [];
-            ours.conflicts.forEach((theirs, m) => {
-                items.push(Dump.conflictingMemberHint(m, ours, theirs));
-            });
-            return items.join(', ');
-        }).join(', ');
-    }
-    static conflictingMemberHint(m, ours, theirs) {
-        return `${theirs.snapshot.hint} (${Dump.rev(theirs, m)})`;
-    }
-}
-exports.Dump = Dump;
-Dump.valueHint = (value, m) => '???';
-exports.ROOT_REV = new Data_1.DataRevision(new Snapshot({ hint: '<root>' }), undefined, {});
-exports.DefaultSnapshotOptions = Object.freeze({
-    hint: 'noname',
-    standalone: false,
-    journal: undefined,
-    logging: undefined,
-    token: undefined,
-});

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

@@ -1,30 +0,0 @@
-import { F } from '../util/Utils';
-import { Worker } from '../Worker';
-import { SnapshotOptions } from '../Options';
-import { Snapshot } from './Snapshot';
-export declare abstract class Transaction implements Worker {
-    static get current(): Transaction;
-    abstract readonly id: number;
-    abstract readonly hint: string;
-    abstract readonly options: SnapshotOptions;
-    abstract readonly timestamp: number;
-    abstract readonly error: Error | undefined;
-    abstract readonly snapshot: Snapshot;
-    abstract readonly margin: number;
-    abstract run<T>(func: F<T>, ...args: any[]): T;
-    abstract inspect<T>(func: F<T>, ...args: any[]): T;
-    abstract apply(): void;
-    abstract seal(): this;
-    abstract wrap<T>(func: F<T>, secondary: boolean): F<T>;
-    abstract cancel(error: Error, retryAfterOrIgnore?: Worker | null): this;
-    abstract readonly isCanceled: boolean;
-    abstract readonly isFinished: boolean;
-    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 isFrameOver(everyN?: number, timeLimit?: number): boolean;
-    static requestNextFrame(sleepTime?: number): Promise<void>;
-    static get isCanceled(): boolean;
-}