mobx-state-tree 7.0.2 → 7.1.0

package/dist/mobx-state-tree.module.js

@@ -791,7 +791,7 @@ function addDisposer(target, disposer) {
 }
 /**
  * Returns the environment of the current state tree, or throws. For more info on environments,
- * see [Dependency injection](https://github.com/mobxjs/mobx-state-tree#dependency-injection)
+ * see [Dependency injection](/concepts/dependency-injection)
  *
  * Please note that in child nodes access to the root is only possible
  * once the `afterAttach` hook has fired
@@ -2165,6 +2165,17 @@ var ObjectNode = /** @class */ (function (_super) {
             return this._internalEventsRegister(InternalEvents.Patch, handler);
         }
     });
+    Object.defineProperty(ObjectNode.prototype, "hasPatchSubscribers", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function () {
+            if (this._internalEventsHasSubscribers(InternalEvents.Patch)) {
+                return true;
+            }
+            return this.parent ? this.parent.hasPatchSubscribers() : false;
+        }
+    });
     Object.defineProperty(ObjectNode.prototype, "emitPatch", {
         enumerable: false,
         configurable: true,
@@ -2377,6 +2388,7 @@ var TypeFlags;
     TypeFlags[TypeFlags["Lazy"] = 1048576] = "Lazy";
     TypeFlags[TypeFlags["Finite"] = 2097152] = "Finite";
     TypeFlags[TypeFlags["Float"] = 4194304] = "Float";
+    TypeFlags[TypeFlags["BigInt"] = 8388608] = "BigInt";
 })(TypeFlags || (TypeFlags = {}));
 /**
  * @internal
@@ -2693,6 +2705,38 @@ var SimpleType = /** @class */ (function (_super) {
     });
     return SimpleType;
 }(BaseType));
+function canApplyDirectSnapshot(childType, childNode, newValue) {
+    var reconciliationType = childNode.getReconciliationType();
+    var expectedReconciliationType = resolveDirectApplyType(childType);
+    // Only types that reconcile as the same transparent-wrapper-adjusted type can safely reuse
+    // the existing child node. Wrappers with their own validation or snapshot semantics
+    // intentionally keep a distinct reconciliation type so they fall back to the validated path.
+    var hasMatchingReconciliationType = reconciliationType === expectedReconciliationType;
+    return (childNode instanceof ObjectNode &&
+        hasMatchingReconciliationType &&
+        reconciliationType instanceof ComplexType &&
+        isMutable(newValue) &&
+        !isStateTreeNode(newValue) &&
+        reconciliationType.isMatchingSnapshotId(childNode, newValue));
+}
+function resolveDirectApplyType(type) {
+    var subTypes = type.getSubTypes();
+    if (!subTypes ||
+        Array.isArray(subTypes) ||
+        subTypes === cannotDetermineSubtype ||
+        !canUnwrapDirectApplyType(type)) {
+        return type;
+    }
+    // Only unwrap wrappers that are transparent for direct apply. Wrappers with their own
+    // validation or snapshot processing must keep their wrapper identity here.
+    return resolveDirectApplyType(subTypes);
+}
+function canUnwrapDirectApplyType(type) {
+    var transparentWrapperFlags = TypeFlags.Optional | TypeFlags.Late;
+    var nonTransparentWrapperFlags = TypeFlags.Refinement | TypeFlags.SnapshotProcessor | TypeFlags.Union;
+    return ((type.flags & transparentWrapperFlags) > 0 &&
+        (type.flags & nonTransparentWrapperFlags) === 0);
+}
 /**
  * Returns if a given value represents a type.
  *
@@ -4042,6 +4086,7 @@ function isPrimitive(value, includeDate) {
         typeof value === "string" ||
         typeof value === "number" ||
         typeof value === "boolean" ||
+        typeof value === "bigint" ||
         (includeDate && value instanceof Date));
 }
 /**
@@ -4926,6 +4971,8 @@ function proxyNodeTypeMethods(nodeType, snapshotProcessorType) {
 /**
  * `types.snapshotProcessor` - Runs a pre/post snapshot processor before/after serializing a given type.
  *
+ * [See known issue with `applySnapshot` and `preProcessSnapshot`](https://github.com/mobxjs/mobx-state-tree/issues/1317)
+ *
  * Example:
  * ```ts
  * const Todo1 = types.model({ text: types.string })
@@ -5376,23 +5423,33 @@ var MapType = /** @class */ (function (_super) {
         configurable: true,
         writable: true,
         value: function (node, snapshot) {
-            typecheckInternal(this, snapshot);
+            if (!isPlainObject(snapshot)) {
+                typecheckInternal(this, snapshot);
+                return;
+            }
             var target = node.storedValue;
-            var currentKeys = {};
+            var childType = this.getChildType();
             Array.from(target.keys()).forEach(function (key) {
-                currentKeys[key] = false;
-            });
-            if (snapshot) {
-                // Don't use target.replace, as it will throw away all existing items first
-                for (var key in snapshot) {
-                    target.set(key, snapshot[key]);
-                    currentKeys["" + key] = true;
-                }
-            }
-            Object.keys(currentKeys).forEach(function (key) {
-                if (currentKeys[key] === false)
+                if (!Object.prototype.hasOwnProperty.call(snapshot, key)) {
                     target.delete(key);
+                    return;
+                }
+                var childNode = node.getChildNode(key);
+                var newValue = snapshot[key];
+                if (childNode.snapshot === newValue)
+                    return;
+                if (canApplyDirectSnapshot(childType, childNode, newValue)) {
+                    childNode.applySnapshot(newValue);
+                }
+                else {
+                    target.set(key, newValue);
+                }
             });
+            for (var key in snapshot) {
+                if (!Object.prototype.hasOwnProperty.call(snapshot, key) || target.has(key))
+                    continue;
+                target.set(key, snapshot[key]);
+            }
         }
     });
     Object.defineProperty(MapType.prototype, "getChildType", {
@@ -5718,9 +5775,52 @@ var ArrayType = /** @class */ (function (_super) {
         configurable: true,
         writable: true,
         value: function (node, snapshot) {
-            typecheckInternal(this, snapshot);
+            if (!isArray(snapshot)) {
+                typecheckInternal(this, snapshot);
+                return;
+            }
             var target = node.storedValue;
-            target.replace(snapshot);
+            var childNodes = node.getChildren();
+            var oldLength = childNodes.length;
+            var newLength = snapshot.length;
+            var childType = this.getChildType();
+            var minLength = Math.min(oldLength, newLength);
+            var firstChangedIndex = findFirstChangedIndex(childNodes, snapshot, minLength);
+            // If all array items are the same and the length did not change, there is nothing to do.
+            if (firstChangedIndex === oldLength && firstChangedIndex === newLength) {
+                return;
+            }
+            // Preserve the old "always replace" behavior for length changes and when patches are being
+            // observed, since those cases are more sensitive to patch shape (for example, splice
+            // would otherwise emit add/remove patch sequences) and benchmark variance.
+            if (oldLength !== newLength || node.hasPatchSubscribers()) {
+                target.replace(snapshot);
+                return;
+            }
+            // When every changed entry can reuse its existing child node, update them in place
+            // instead of going through array replacement/splice.
+            if (canApplyDirectSnapshotsInRange(childType, childNodes, snapshot, firstChangedIndex)) {
+                applyDirectSnapshotsInRange(childNodes, snapshot, firstChangedIndex);
+                return;
+            }
+            var oldEnd = oldLength - 1;
+            var newEnd = newLength - 1;
+            while (oldEnd >= firstChangedIndex &&
+                newEnd >= firstChangedIndex &&
+                childNodes[oldEnd].snapshot === snapshot[newEnd]) {
+                oldEnd--;
+                newEnd--;
+            }
+            // Trim the unchanged suffix too, so we only replace the minimal changed window.
+            var replacedCount = oldEnd >= firstChangedIndex ? oldEnd - firstChangedIndex + 1 : 0;
+            var replacementSnapshots = newEnd >= firstChangedIndex
+                ? snapshot.slice(firstChangedIndex, newEnd + 1)
+                : EMPTY_ARRAY;
+            if (replacedCount === 1 && replacementSnapshots.length === 1) {
+                target[firstChangedIndex] = replacementSnapshots[0];
+                return;
+            }
+            target.splice.apply(target, __spreadArray([firstChangedIndex, replacedCount], __read(replacementSnapshots), false));
         }
     });
     Object.defineProperty(ArrayType.prototype, "getChildType", {
@@ -5792,6 +5892,31 @@ function array(subtype) {
     assertIsType(subtype, 1);
     return new ArrayType("".concat(subtype.name, "[]"), subtype);
 }
+function findFirstChangedIndex(childNodes, snapshot, length) {
+    var index = 0;
+    while (index < length && childNodes[index].snapshot === snapshot[index]) {
+        index++;
+    }
+    return index;
+}
+function canApplyDirectSnapshotsInRange(childType, childNodes, snapshot, startIndex) {
+    for (var i = startIndex; i < childNodes.length; i++) {
+        if (childNodes[i].snapshot === snapshot[i])
+            continue;
+        if (!canApplyDirectSnapshot(childType, childNodes[i], snapshot[i])) {
+            return false;
+        }
+    }
+    return true;
+}
+function applyDirectSnapshotsInRange(childNodes, snapshot, startIndex) {
+    for (var i = startIndex; i < childNodes.length; i++) {
+        var childNode = childNodes[i];
+        if (childNode.snapshot === snapshot[i])
+            continue;
+        childNode.applySnapshot(snapshot[i]);
+    }
+}
 function reconcileArrayChildren(parent, childType, oldNodes, newValues, newPaths) {
     var nothingChanged = true;
     for (var i = 0;; i++) {
@@ -6437,10 +6562,25 @@ var ModelType = /** @class */ (function (_super) {
         configurable: true,
         writable: true,
         value: function (node, snapshot) {
-            typecheckInternal(this, snapshot);
             var preProcessedSnapshot = this.applySnapshotPreProcessor(snapshot);
-            this.forAllProps(function (name) {
-                node.storedValue[name] = preProcessedSnapshot[name];
+            var isPreProcessedSnapshotNonPlain = !isPlainObject(preProcessedSnapshot);
+            // Fast-path plain-object snapshots, but still validate when preprocessing is required
+            // or when preprocessing produces an invalid model snapshot.
+            if (!isPlainObject(snapshot) || isPreProcessedSnapshotNonPlain) {
+                typecheckInternal(this, snapshot);
+                if (isPreProcessedSnapshotNonPlain)
+                    return;
+            }
+            this.forAllProps(function (name, childType) {
+                var childNode = node.getChildNode(name);
+                var newValue = preProcessedSnapshot[name];
+                if (childNode.snapshot === newValue)
+                    return;
+                if (canApplyDirectSnapshot(childType, childNode, newValue)) {
+                    childNode.applySnapshot(newValue);
+                    return;
+                }
+                node.storedValue[name] = newValue;
             });
         }
     });
@@ -6731,6 +6871,37 @@ var float = new CoreType("float", TypeFlags.Float, function (v) { return isFloat
  */
 // tslint:disable-next-line:variable-name
 var finite = new CoreType("finite", TypeFlags.Finite, function (v) { return isFinite(v); });
+var _BigIntPrimitive = new CoreType("bigint", TypeFlags.BigInt, function (v) {
+    if (typeof v === "bigint") {
+        return true;
+    }
+    if (typeof v === "string" || typeof v === "number") {
+        try {
+            // BigInt primitive constructor verifies whether the value is a valid integer
+            BigInt(v);
+            return true;
+        }
+        catch (_a) { }
+    }
+    return false;
+}, function (v) { return (typeof v === "bigint" ? v : BigInt(v)); });
+_BigIntPrimitive.getSnapshot = function (node) {
+    return String(node.storedValue);
+};
+/**
+ * `types.bigint` - Creates a type that can only contain a bigint value.
+ * Snapshots serialize to string (JSON-safe) and deserialize from string, number or bigint.
+ *
+ * Example:
+ * ```ts
+ * const BigId = types.model({
+ *   id: types.identifier,
+ *   value: types.bigint
+ * })
+ * getSnapshot(store).value // "0" (string, JSON-safe)
+ * ```
+ */
+var bigint = _BigIntPrimitive;
 /**
  * `types.boolean` - Creates a type that can only contain a boolean value.
  * This type is used for boolean values by default
@@ -6782,6 +6953,8 @@ function getPrimitiveFactoryFromValue(value) {
             return number; // In the future, isInteger(value) ? integer : number would be interesting, but would be too breaking for now
         case "boolean":
             return boolean;
+        case "bigint":
+            return bigint;
         case "object":
             if (value instanceof Date)
                 return DatePrimitive;
@@ -6801,7 +6974,8 @@ function isPrimitiveType(type) {
                 TypeFlags.Number |
                 TypeFlags.Integer |
                 TypeFlags.Boolean |
-                TypeFlags.Date)) >
+                TypeFlags.Date |
+                TypeFlags.BigInt)) >
             0);
 }
 
@@ -8632,6 +8806,7 @@ var types = {
     integer: integer,
     float: float,
     finite: finite,
+    bigint: bigint,
     Date: DatePrimitive,
     map: map,
     array: array,

package/dist/mobx-state-tree.umd.js

@@ -795,7 +795,7 @@
     }
     /**
      * Returns the environment of the current state tree, or throws. For more info on environments,
-     * see [Dependency injection](https://github.com/mobxjs/mobx-state-tree#dependency-injection)
+     * see [Dependency injection](/concepts/dependency-injection)
      *
      * Please note that in child nodes access to the root is only possible
      * once the `afterAttach` hook has fired
@@ -2169,6 +2169,17 @@
                 return this._internalEventsRegister(InternalEvents.Patch, handler);
             }
         });
+        Object.defineProperty(ObjectNode.prototype, "hasPatchSubscribers", {
+            enumerable: false,
+            configurable: true,
+            writable: true,
+            value: function () {
+                if (this._internalEventsHasSubscribers(InternalEvents.Patch)) {
+                    return true;
+                }
+                return this.parent ? this.parent.hasPatchSubscribers() : false;
+            }
+        });
         Object.defineProperty(ObjectNode.prototype, "emitPatch", {
             enumerable: false,
             configurable: true,
@@ -2381,6 +2392,7 @@
         TypeFlags[TypeFlags["Lazy"] = 1048576] = "Lazy";
         TypeFlags[TypeFlags["Finite"] = 2097152] = "Finite";
         TypeFlags[TypeFlags["Float"] = 4194304] = "Float";
+        TypeFlags[TypeFlags["BigInt"] = 8388608] = "BigInt";
     })(TypeFlags || (TypeFlags = {}));
     /**
      * @internal
@@ -2697,6 +2709,38 @@
         });
         return SimpleType;
     }(BaseType));
+    function canApplyDirectSnapshot(childType, childNode, newValue) {
+        var reconciliationType = childNode.getReconciliationType();
+        var expectedReconciliationType = resolveDirectApplyType(childType);
+        // Only types that reconcile as the same transparent-wrapper-adjusted type can safely reuse
+        // the existing child node. Wrappers with their own validation or snapshot semantics
+        // intentionally keep a distinct reconciliation type so they fall back to the validated path.
+        var hasMatchingReconciliationType = reconciliationType === expectedReconciliationType;
+        return (childNode instanceof ObjectNode &&
+            hasMatchingReconciliationType &&
+            reconciliationType instanceof ComplexType &&
+            isMutable(newValue) &&
+            !isStateTreeNode(newValue) &&
+            reconciliationType.isMatchingSnapshotId(childNode, newValue));
+    }
+    function resolveDirectApplyType(type) {
+        var subTypes = type.getSubTypes();
+        if (!subTypes ||
+            Array.isArray(subTypes) ||
+            subTypes === cannotDetermineSubtype ||
+            !canUnwrapDirectApplyType(type)) {
+            return type;
+        }
+        // Only unwrap wrappers that are transparent for direct apply. Wrappers with their own
+        // validation or snapshot processing must keep their wrapper identity here.
+        return resolveDirectApplyType(subTypes);
+    }
+    function canUnwrapDirectApplyType(type) {
+        var transparentWrapperFlags = TypeFlags.Optional | TypeFlags.Late;
+        var nonTransparentWrapperFlags = TypeFlags.Refinement | TypeFlags.SnapshotProcessor | TypeFlags.Union;
+        return ((type.flags & transparentWrapperFlags) > 0 &&
+            (type.flags & nonTransparentWrapperFlags) === 0);
+    }
     /**
      * Returns if a given value represents a type.
      *
@@ -4046,6 +4090,7 @@
             typeof value === "string" ||
             typeof value === "number" ||
             typeof value === "boolean" ||
+            typeof value === "bigint" ||
             (includeDate && value instanceof Date));
     }
     /**
@@ -4908,6 +4953,8 @@
     /**
      * `types.snapshotProcessor` - Runs a pre/post snapshot processor before/after serializing a given type.
      *
+     * [See known issue with `applySnapshot` and `preProcessSnapshot`](https://github.com/mobxjs/mobx-state-tree/issues/1317)
+     *
      * Example:
      * ```ts
      * const Todo1 = types.model({ text: types.string })
@@ -5358,23 +5405,33 @@
             configurable: true,
             writable: true,
             value: function (node, snapshot) {
-                typecheckInternal(this, snapshot);
+                if (!isPlainObject(snapshot)) {
+                    typecheckInternal(this, snapshot);
+                    return;
+                }
                 var target = node.storedValue;
-                var currentKeys = {};
+                var childType = this.getChildType();
                 Array.from(target.keys()).forEach(function (key) {
-                    currentKeys[key] = false;
-                });
-                if (snapshot) {
-                    // Don't use target.replace, as it will throw away all existing items first
-                    for (var key in snapshot) {
-                        target.set(key, snapshot[key]);
-                        currentKeys["" + key] = true;
-                    }
-                }
-                Object.keys(currentKeys).forEach(function (key) {
-                    if (currentKeys[key] === false)
+                    if (!Object.prototype.hasOwnProperty.call(snapshot, key)) {
                         target.delete(key);
+                        return;
+                    }
+                    var childNode = node.getChildNode(key);
+                    var newValue = snapshot[key];
+                    if (childNode.snapshot === newValue)
+                        return;
+                    if (canApplyDirectSnapshot(childType, childNode, newValue)) {
+                        childNode.applySnapshot(newValue);
+                    }
+                    else {
+                        target.set(key, newValue);
+                    }
                 });
+                for (var key in snapshot) {
+                    if (!Object.prototype.hasOwnProperty.call(snapshot, key) || target.has(key))
+                        continue;
+                    target.set(key, snapshot[key]);
+                }
             }
         });
         Object.defineProperty(MapType.prototype, "getChildType", {
@@ -5700,9 +5757,52 @@
             configurable: true,
             writable: true,
             value: function (node, snapshot) {
-                typecheckInternal(this, snapshot);
+                if (!isArray(snapshot)) {
+                    typecheckInternal(this, snapshot);
+                    return;
+                }
                 var target = node.storedValue;
-                target.replace(snapshot);
+                var childNodes = node.getChildren();
+                var oldLength = childNodes.length;
+                var newLength = snapshot.length;
+                var childType = this.getChildType();
+                var minLength = Math.min(oldLength, newLength);
+                var firstChangedIndex = findFirstChangedIndex(childNodes, snapshot, minLength);
+                // If all array items are the same and the length did not change, there is nothing to do.
+                if (firstChangedIndex === oldLength && firstChangedIndex === newLength) {
+                    return;
+                }
+                // Preserve the old "always replace" behavior for length changes and when patches are being
+                // observed, since those cases are more sensitive to patch shape (for example, splice
+                // would otherwise emit add/remove patch sequences) and benchmark variance.
+                if (oldLength !== newLength || node.hasPatchSubscribers()) {
+                    target.replace(snapshot);
+                    return;
+                }
+                // When every changed entry can reuse its existing child node, update them in place
+                // instead of going through array replacement/splice.
+                if (canApplyDirectSnapshotsInRange(childType, childNodes, snapshot, firstChangedIndex)) {
+                    applyDirectSnapshotsInRange(childNodes, snapshot, firstChangedIndex);
+                    return;
+                }
+                var oldEnd = oldLength - 1;
+                var newEnd = newLength - 1;
+                while (oldEnd >= firstChangedIndex &&
+                    newEnd >= firstChangedIndex &&
+                    childNodes[oldEnd].snapshot === snapshot[newEnd]) {
+                    oldEnd--;
+                    newEnd--;
+                }
+                // Trim the unchanged suffix too, so we only replace the minimal changed window.
+                var replacedCount = oldEnd >= firstChangedIndex ? oldEnd - firstChangedIndex + 1 : 0;
+                var replacementSnapshots = newEnd >= firstChangedIndex
+                    ? snapshot.slice(firstChangedIndex, newEnd + 1)
+                    : EMPTY_ARRAY;
+                if (replacedCount === 1 && replacementSnapshots.length === 1) {
+                    target[firstChangedIndex] = replacementSnapshots[0];
+                    return;
+                }
+                target.splice.apply(target, __spreadArray([firstChangedIndex, replacedCount], __read(replacementSnapshots), false));
             }
         });
         Object.defineProperty(ArrayType.prototype, "getChildType", {
@@ -5774,6 +5874,31 @@
         assertIsType(subtype, 1);
         return new ArrayType("".concat(subtype.name, "[]"), subtype);
     }
+    function findFirstChangedIndex(childNodes, snapshot, length) {
+        var index = 0;
+        while (index < length && childNodes[index].snapshot === snapshot[index]) {
+            index++;
+        }
+        return index;
+    }
+    function canApplyDirectSnapshotsInRange(childType, childNodes, snapshot, startIndex) {
+        for (var i = startIndex; i < childNodes.length; i++) {
+            if (childNodes[i].snapshot === snapshot[i])
+                continue;
+            if (!canApplyDirectSnapshot(childType, childNodes[i], snapshot[i])) {
+                return false;
+            }
+        }
+        return true;
+    }
+    function applyDirectSnapshotsInRange(childNodes, snapshot, startIndex) {
+        for (var i = startIndex; i < childNodes.length; i++) {
+            var childNode = childNodes[i];
+            if (childNode.snapshot === snapshot[i])
+                continue;
+            childNode.applySnapshot(snapshot[i]);
+        }
+    }
     function reconcileArrayChildren(parent, childType, oldNodes, newValues, newPaths) {
         var nothingChanged = true;
         for (var i = 0;; i++) {
@@ -6419,10 +6544,25 @@
             configurable: true,
             writable: true,
             value: function (node, snapshot) {
-                typecheckInternal(this, snapshot);
                 var preProcessedSnapshot = this.applySnapshotPreProcessor(snapshot);
-                this.forAllProps(function (name) {
-                    node.storedValue[name] = preProcessedSnapshot[name];
+                var isPreProcessedSnapshotNonPlain = !isPlainObject(preProcessedSnapshot);
+                // Fast-path plain-object snapshots, but still validate when preprocessing is required
+                // or when preprocessing produces an invalid model snapshot.
+                if (!isPlainObject(snapshot) || isPreProcessedSnapshotNonPlain) {
+                    typecheckInternal(this, snapshot);
+                    if (isPreProcessedSnapshotNonPlain)
+                        return;
+                }
+                this.forAllProps(function (name, childType) {
+                    var childNode = node.getChildNode(name);
+                    var newValue = preProcessedSnapshot[name];
+                    if (childNode.snapshot === newValue)
+                        return;
+                    if (canApplyDirectSnapshot(childType, childNode, newValue)) {
+                        childNode.applySnapshot(newValue);
+                        return;
+                    }
+                    node.storedValue[name] = newValue;
                 });
             }
         });
@@ -6713,6 +6853,37 @@
      */
     // tslint:disable-next-line:variable-name
     var finite = new CoreType("finite", TypeFlags.Finite, function (v) { return isFinite(v); });
+    var _BigIntPrimitive = new CoreType("bigint", TypeFlags.BigInt, function (v) {
+        if (typeof v === "bigint") {
+            return true;
+        }
+        if (typeof v === "string" || typeof v === "number") {
+            try {
+                // BigInt primitive constructor verifies whether the value is a valid integer
+                BigInt(v);
+                return true;
+            }
+            catch (_a) { }
+        }
+        return false;
+    }, function (v) { return (typeof v === "bigint" ? v : BigInt(v)); });
+    _BigIntPrimitive.getSnapshot = function (node) {
+        return String(node.storedValue);
+    };
+    /**
+     * `types.bigint` - Creates a type that can only contain a bigint value.
+     * Snapshots serialize to string (JSON-safe) and deserialize from string, number or bigint.
+     *
+     * Example:
+     * ```ts
+     * const BigId = types.model({
+     *   id: types.identifier,
+     *   value: types.bigint
+     * })
+     * getSnapshot(store).value // "0" (string, JSON-safe)
+     * ```
+     */
+    var bigint = _BigIntPrimitive;
     /**
      * `types.boolean` - Creates a type that can only contain a boolean value.
      * This type is used for boolean values by default
@@ -6764,6 +6935,8 @@
                 return number; // In the future, isInteger(value) ? integer : number would be interesting, but would be too breaking for now
             case "boolean":
                 return boolean;
+            case "bigint":
+                return bigint;
             case "object":
                 if (value instanceof Date)
                     return DatePrimitive;
@@ -6783,7 +6956,8 @@
                     TypeFlags.Number |
                     TypeFlags.Integer |
                     TypeFlags.Boolean |
-                    TypeFlags.Date)) >
+                    TypeFlags.Date |
+                    TypeFlags.BigInt)) >
                 0);
     }
 
@@ -8614,6 +8788,7 @@
         integer: integer,
         float: float,
         finite: finite,
+        bigint: bigint,
         Date: DatePrimitive,
         map: map,
         array: array,