@jbrowse/mobx-state-tree 6.1.0 → 6.3.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;
@@ -1777,10 +1800,16 @@ declare const DatePrimitive: IType<number | Date, number, Date>;
 /**
  * Returns if a given value represents a primitive type.
  *
+ * Returns a plain `boolean`, not a `type is IT` predicate: with the parameter
+ * typed as `IT`, narrowing to `IT` was a no-op in the positive branch while
+ * collapsing the negative one to `never`, so `if (!isX(t)) { t.name }` failed
+ * to compile. Guards with a distinct narrowing target (`isArrayType`,
+ * `isMapType`, `isModelType`) keep their predicate.
+ *
  * @param type
  * @returns
  */
-declare function isPrimitiveType<IT extends ISimpleType<string> | ISimpleType<number> | ISimpleType<boolean> | typeof DatePrimitive>(type: IT): type is IT;
+declare function isPrimitiveType<IT extends ISimpleType<string> | ISimpleType<number> | ISimpleType<boolean> | typeof DatePrimitive>(type: IT): boolean;
 
 /**
  * `types.literal` - The literal type will return a type that will match only the exact given type.
@@ -1802,20 +1831,32 @@ declare function literal<S extends Primitives>(value: S): ISimpleType<S>;
 /**
  * Returns if a given value represents a literal type.
  *
+ * Returns a plain `boolean`, not a `type is IT` predicate: with the parameter
+ * typed as `IT`, narrowing to `IT` was a no-op in the positive branch while
+ * collapsing the negative one to `never`, so `if (!isX(t)) { t.name }` failed
+ * to compile. Guards with a distinct narrowing target (`isArrayType`,
+ * `isMapType`, `isModelType`) keep their predicate.
+ *
  * @param type
  * @returns
  */
-declare function isLiteralType<IT extends ISimpleType<any>>(type: IT): type is IT;
+declare function isLiteralType<IT extends ISimpleType<any>>(type: IT): boolean;
 
 declare function refinement<IT extends IAnyType>(name: string, type: IT, predicate: (snapshot: IT["CreationType"]) => boolean, message?: string | ((v: IT["CreationType"]) => string)): IT;
 declare function refinement<IT extends IAnyType>(type: IT, predicate: (snapshot: IT["CreationType"]) => boolean, message?: string | ((v: IT["CreationType"]) => string)): IT;
 /**
  * Returns if a given value is a refinement type.
  *
+ * Returns a plain `boolean`, not a `type is IT` predicate: with the parameter
+ * typed as `IT`, narrowing to `IT` was a no-op in the positive branch while
+ * collapsing the negative one to `never`, so `if (!isX(t)) { t.name }` failed
+ * to compile. Guards with a distinct narrowing target (`isArrayType`,
+ * `isMapType`, `isModelType`) keep their predicate.
+ *
  * @param type
  * @returns
  */
-declare function isRefinementType<IT extends IAnyType>(type: IT): type is IT;
+declare function isRefinementType<IT extends IAnyType>(type: IT): boolean;
 
 /** @hidden */
 type UnionStringArray<T extends readonly string[]> = T[number];
@@ -1872,10 +1913,16 @@ declare function union(dispatchOrType: UnionOptions | IAnyType, ...otherTypes: I
 /**
  * Returns if a given value represents a union type.
  *
+ * Returns a plain `boolean`, not a `type is IT` predicate: with the parameter
+ * typed as `IT`, narrowing to `IT` was a no-op in the positive branch while
+ * collapsing the negative one to `never`, so `if (!isX(t)) { t.name }` failed
+ * to compile. Guards with a distinct narrowing target (`isArrayType`,
+ * `isMapType`, `isModelType`) keep their predicate.
+ *
  * @param type
  * @returns
  */
-declare function isUnionType<IT extends IAnyType>(type: IT): type is IT;
+declare function isUnionType<IT extends IAnyType>(type: IT): boolean;
 /**
  * Returns the member types of a union.
  *
@@ -1905,11 +1952,17 @@ declare function optional<IT extends IAnyType, OptionalVals extends ValidOptiona
 /**
  * Returns if a value represents an optional type.
  *
+ * Returns a plain `boolean`, not a `type is IT` predicate: with the parameter
+ * typed as `IT`, narrowing to `IT` was a no-op in the positive branch while
+ * collapsing the negative one to `never`, so `if (!isX(t)) { t.name }` failed
+ * to compile. Guards with a distinct narrowing target (`isArrayType`,
+ * `isMapType`, `isModelType`) keep their predicate.
+ *
  * @template IT
  * @param type
  * @returns
  */
-declare function isOptionalType<IT extends IAnyType>(type: IT): type is IT;
+declare function isOptionalType<IT extends IAnyType>(type: IT): boolean;
 /**
  * `types.stripDefault` - Like `types.optional`, but the property is omitted from
  * a parent model's snapshot entirely when its value equals the default (instead
@@ -1953,10 +2006,16 @@ declare function late<T extends IAnyType>(name: string, type: () => T): T;
 /**
  * Returns if a given value represents a late type.
  *
+ * Returns a plain `boolean`, not a `type is IT` predicate: with the parameter
+ * typed as `IT`, narrowing to `IT` was a no-op in the positive branch while
+ * collapsing the negative one to `never`, so `if (!isX(t)) { t.name }` failed
+ * to compile. Guards with a distinct narrowing target (`isArrayType`,
+ * `isMapType`, `isModelType`) keep their predicate.
+ *
  * @param type
  * @returns
  */
-declare function isLateType<IT extends IAnyType>(type: IT): type is IT;
+declare function isLateType<IT extends IAnyType>(type: IT): boolean;
 
 interface LazyOptions<T extends IType<any, any, any>, U> {
     loadType: () => Promise<T>;
@@ -1970,10 +2029,16 @@ declare function frozen<T = any>(): IType<T, T, T>;
 /**
  * Returns if a given value represents a frozen type.
  *
+ * Returns a plain `boolean`, not a `type is IT` predicate: with the parameter
+ * typed as `IT`, narrowing to `IT` was a no-op in the positive branch while
+ * collapsing the negative one to `never`, so `if (!isX(t)) { t.name }` failed
+ * to compile. Guards with a distinct narrowing target (`isArrayType`,
+ * `isMapType`, `isModelType`) keep their predicate.
+ *
  * @param type
  * @returns
  */
-declare function isFrozenType<IT extends IType<T | any, T, T>, T = any>(type: IT): type is IT;
+declare function isFrozenType<IT extends IType<T | any, T, T>, T = any>(type: IT): boolean;
 
 type OnReferenceInvalidatedEvent<STN extends IAnyStateTreeNode> = {
     parent: IAnyStateTreeNode;
@@ -2005,10 +2070,16 @@ declare function reference<IT extends IAnyComplexType>(subType: IT, options?: Re
 /**
  * Returns if a given value represents a reference type.
  *
+ * Returns a plain `boolean`, not a `type is IT` predicate: with the parameter
+ * typed as `IT`, narrowing to `IT` was a no-op in the positive branch while
+ * collapsing the negative one to `never`, so `if (!isX(t)) { t.name }` failed
+ * to compile. Guards with a distinct narrowing target (`isArrayType`,
+ * `isMapType`, `isModelType`) keep their predicate.
+ *
  * @param type
  * @returns
  */
-declare function isReferenceType<IT extends IReferenceType<any>>(type: IT): type is IT;
+declare function isReferenceType<IT extends IReferenceType<any>>(type: IT): boolean;
 declare function safeReference<IT extends IAnyComplexType>(subType: IT, options: (ReferenceOptionsGetSet<IT> | object) & {
     acceptsUndefined: false;
     onInvalidated?: OnReferenceInvalidated<ReferenceT<IT>>;
@@ -2053,10 +2124,16 @@ declare const identifierNumber: ISimpleType<number>;
 /**
  * Returns if a given value represents an identifier type.
  *
+ * Returns a plain `boolean`, not a `type is IT` predicate: with the parameter
+ * typed as `IT`, narrowing to `IT` was a no-op in the positive branch while
+ * collapsing the negative one to `never`, so `if (!isX(t)) { t.name }` failed
+ * to compile. Guards with a distinct narrowing target (`isArrayType`,
+ * `isMapType`, `isModelType`) keep their predicate.
+ *
  * @param type
  * @returns
  */
-declare function isIdentifierType<IT extends typeof identifier | typeof identifierNumber>(type: IT): type is IT;
+declare function isIdentifierType<IT extends typeof identifier | typeof identifierNumber>(type: IT): boolean;
 /**
  * Valid types for identifiers.
  */