@jbrowse/mobx-state-tree 6.1.0 → 6.2.0

package/dist/index.d.ts

@@ -604,7 +604,7 @@ declare class ObjectNode<C, S, T> extends BaseNode<C, S, T> {
     applySnapshot(snapshot: C): void;
     private _autoUnbox;
     _isRunningAction: boolean;
-    private _hasSnapshotReaction;
+    private _snapshotReactionDisposer?;
     private _observableInstanceState;
     private _childNodes;
     private _initialSnapshot;
@@ -663,6 +663,7 @@ declare class ObjectNode<C, S, T> extends BaseNode<C, S, T> {
     addMiddleWare(handler: IMiddlewareHandler, includeHooks?: boolean): IDisposer;
     applyPatchLocally(subpath: string, patch: IJsonPatch): void;
     private _addSnapshotReaction;
+    private _removeSnapshotReaction;
     private _internalEvents?;
     private _internalEventsHasSubscribers;
     private _internalEventsRegister;
@@ -913,14 +914,36 @@ type SnapshotOrInstance<T> = SnapshotIn<T> | Instance<T>;
  * @hidden
  */
 declare abstract class BaseType<C, S, T, N extends BaseNode<any, any, any> = BaseNode<C, S, T>> implements IType<C, S, T> {
-    [$type]: undefined;
+    readonly [$type]: undefined;
     readonly C: C;
     readonly S: S;
     readonly T: T;
     readonly N: N;
-    readonly isType = true;
-    readonly name: string;
-    constructor(name: string);
+    readonly isType: true;
+    private _name?;
+    /**
+     * Builds the name of a type that does not get one handed to it. Composite
+     * types (`union`, `array`, `map`, `reference`, ...) override this to fold
+     * their members' names; see {@link name}. It runs after construction, so
+     * unlike a `super(...)` argument it can read the subclass's own fields.
+     */
+    protected computeName(): string;
+    /**
+     * Friendly type name.
+     *
+     * A composite type folds its members' names, which for a union is a map +
+     * join over every member — and the result is read only by error messages and
+     * `describe()`. So those types leave it unset and it is built on first read
+     * and cached: a union that never fails a typecheck never builds one, and
+     * jbrowse builds a union per config slot, tens of thousands per session load.
+     *
+     * Deliberately not a lambda passed to the constructor: that allocated a
+     * closure per type (the very cost being avoided) and made two separately
+     * built but equivalent types compare unequal, since the closures differ.
+     */
+    get name(): string;
+    set name(value: string);
+    constructor(name?: string);
     create(snapshot?: C, environment?: any): any;
     getSnapshot(_node: N, _applyPostProcess?: boolean): S;
     abstract reconcile(current: N, newValue: C | T, parent: AnyObjectNode, subpath: string): N;