@tldraw/validate 4.2.2 → 4.2.3

package/dist-esm/lib/validation.mjs

@@ -5,7 +5,6 @@ import {
   hasOwnProperty,
   validateIndexKey
 } from "@tldraw/utils";
-const IS_DEV = process.env.NODE_ENV !== "production";
 function formatPath(path) {
   if (!path.length) {
     return null;
@@ -82,12 +81,10 @@ class Validator {
    *
    * validationFn - Function that validates and returns a value of type T
    * validateUsingKnownGoodVersionFn - Optional performance-optimized validation function
-   * skipSameValueCheck - Internal flag to skip dev check for validators that transform values
    */
-  constructor(validationFn, validateUsingKnownGoodVersionFn, skipSameValueCheck = false) {
+  constructor(validationFn, validateUsingKnownGoodVersionFn) {
     this.validationFn = validationFn;
     this.validateUsingKnownGoodVersionFn = validateUsingKnownGoodVersionFn;
-    this.skipSameValueCheck = skipSameValueCheck;
   }
   /**
    * Validates an unknown value and returns it with the correct type. The returned value is
@@ -111,7 +108,7 @@ class Validator {
    */
   validate(value) {
     const validated = this.validationFn(value);
-    if (IS_DEV && !this.skipSameValueCheck && !Object.is(value, validated)) {
+    if (process.env.NODE_ENV !== "production" && !Object.is(value, validated)) {
       throw new ValidationError("Validator functions must return the same value they were passed");
     }
     return validated;
@@ -272,9 +269,7 @@ class Validator {
           return knownGoodValue;
         }
         return otherValidationFn(validated);
-      },
-      true
-      // skipSameValueCheck: refine is designed to transform values
+      }
     );
   }
   check(nameOrCheckFn, checkFn) {
@@ -302,25 +297,11 @@ class ArrayOfValidator extends Validator {
       (value) => {
         const arr = array.validate(value);
         for (let i = 0; i < arr.length; i++) {
-          if (IS_DEV) {
-            prefixError(i, () => itemValidator.validate(arr[i]));
-          } else {
-            try {
-              itemValidator.validate(arr[i]);
-            } catch (err) {
-              if (err instanceof ValidationError) {
-                throw new ValidationError(err.rawMessage, [i, ...err.path]);
-              }
-              throw new ValidationError(err.toString(), [i]);
-            }
-          }
+          prefixError(i, () => itemValidator.validate(arr[i]));
         }
         return arr;
       },
       (knownGoodValue, newValue) => {
-        if (Object.is(knownGoodValue, newValue)) {
-          return knownGoodValue;
-        }
         if (!itemValidator.validateUsingKnownGoodVersion) return this.validate(newValue);
         const arr = array.validate(newValue);
         let isDifferent = knownGoodValue.length !== arr.length;
@@ -328,46 +309,18 @@ class ArrayOfValidator extends Validator {
           const item = arr[i];
           if (i >= knownGoodValue.length) {
             isDifferent = true;
-            if (IS_DEV) {
-              prefixError(i, () => itemValidator.validate(item));
-            } else {
-              try {
-                itemValidator.validate(item);
-              } catch (err) {
-                if (err instanceof ValidationError) {
-                  throw new ValidationError(err.rawMessage, [i, ...err.path]);
-                }
-                throw new ValidationError(err.toString(), [i]);
-              }
-            }
+            prefixError(i, () => itemValidator.validate(item));
             continue;
           }
           if (Object.is(knownGoodValue[i], item)) {
             continue;
           }
-          if (IS_DEV) {
-            const checkedItem = prefixError(
-              i,
-              () => itemValidator.validateUsingKnownGoodVersion(knownGoodValue[i], item)
-            );
-            if (!Object.is(checkedItem, knownGoodValue[i])) {
-              isDifferent = true;
-            }
-          } else {
-            try {
-              const checkedItem = itemValidator.validateUsingKnownGoodVersion(
-                knownGoodValue[i],
-                item
-              );
-              if (!Object.is(checkedItem, knownGoodValue[i])) {
-                isDifferent = true;
-              }
-            } catch (err) {
-              if (err instanceof ValidationError) {
-                throw new ValidationError(err.rawMessage, [i, ...err.path]);
-              }
-              throw new ValidationError(err.toString(), [i]);
-            }
+          const checkedItem = prefixError(
+            i,
+            () => itemValidator.validateUsingKnownGoodVersion(knownGoodValue[i], item)
+          );
+          if (!Object.is(checkedItem, knownGoodValue[i])) {
+            isDifferent = true;
           }
         }
         return isDifferent ? newValue : knownGoodValue;
@@ -427,25 +380,11 @@ class ObjectValidator extends Validator {
         if (typeof object2 !== "object" || object2 === null) {
           throw new ValidationError(`Expected object, got ${typeToString(object2)}`);
         }
-        for (const key in config) {
-          if (!hasOwnProperty(config, key)) continue;
-          const validator = config[key];
-          if (IS_DEV) {
-            prefixError(key, () => {
-              ;
-              validator.validate(getOwnProperty(object2, key));
-            });
-          } else {
-            try {
-              ;
-              validator.validate(getOwnProperty(object2, key));
-            } catch (err) {
-              if (err instanceof ValidationError) {
-                throw new ValidationError(err.rawMessage, [key, ...err.path]);
-              }
-              throw new ValidationError(err.toString(), [key]);
-            }
-          }
+        for (const [key, validator] of Object.entries(config)) {
+          prefixError(key, () => {
+            ;
+            validator.validate(getOwnProperty(object2, key));
+          });
         }
         if (!shouldAllowUnknownProperties) {
           for (const key of Object.keys(object2)) {
@@ -457,46 +396,26 @@ class ObjectValidator extends Validator {
         return object2;
       },
       (knownGoodValue, newValue) => {
-        if (Object.is(knownGoodValue, newValue)) {
-          return knownGoodValue;
-        }
         if (typeof newValue !== "object" || newValue === null) {
           throw new ValidationError(`Expected object, got ${typeToString(newValue)}`);
         }
         let isDifferent = false;
-        for (const key in config) {
-          if (!hasOwnProperty(config, key)) continue;
-          const validator = config[key];
+        for (const [key, validator] of Object.entries(config)) {
           const prev = getOwnProperty(knownGoodValue, key);
           const next = getOwnProperty(newValue, key);
           if (Object.is(prev, next)) {
             continue;
           }
-          if (IS_DEV) {
-            const checked = prefixError(key, () => {
-              const validatable = validator;
-              if (validatable.validateUsingKnownGoodVersion) {
-                return validatable.validateUsingKnownGoodVersion(prev, next);
-              } else {
-                return validatable.validate(next);
-              }
-            });
-            if (!Object.is(checked, prev)) {
-              isDifferent = true;
-            }
-          } else {
-            try {
-              const validatable = validator;
-              const checked = validatable.validateUsingKnownGoodVersion ? validatable.validateUsingKnownGoodVersion(prev, next) : validatable.validate(next);
-              if (!Object.is(checked, prev)) {
-                isDifferent = true;
-              }
-            } catch (err) {
-              if (err instanceof ValidationError) {
-                throw new ValidationError(err.rawMessage, [key, ...err.path]);
-              }
-              throw new ValidationError(err.toString(), [key]);
+          const checked = prefixError(key, () => {
+            const validatable = validator;
+            if (validatable.validateUsingKnownGoodVersion) {
+              return validatable.validateUsingKnownGoodVersion(prev, next);
+            } else {
+              return validatable.validate(next);
             }
+          });
+          if (!Object.is(checked, prev)) {
+            isDifferent = true;
           }
         }
         if (!shouldAllowUnknownProperties) {
@@ -604,13 +523,8 @@ class UnionValidator extends Validator {
       throw new ValidationError(
         `Expected a string for key "${this.key}", got ${typeToString(variant)}`
       );
-    } else if (this.useNumberKeys) {
-      const numVariant = Number(variant);
-      if (numVariant - numVariant !== 0) {
-        throw new ValidationError(
-          `Expected a number for key "${this.key}", got "${variant}"`
-        );
-      }
+    } else if (this.useNumberKeys && !Number.isFinite(Number(variant))) {
+      throw new ValidationError(`Expected a number for key "${this.key}", got "${variant}"`);
     }
     const matchingSchema = hasOwnProperty(this.config, variant) ? this.config[variant] : void 0;
     return { matchingSchema, variant };
@@ -646,24 +560,11 @@ class DictValidator extends Validator {
         if (typeof object2 !== "object" || object2 === null) {
           throw new ValidationError(`Expected object, got ${typeToString(object2)}`);
         }
-        for (const key in object2) {
-          if (!hasOwnProperty(object2, key)) continue;
-          if (IS_DEV) {
-            prefixError(key, () => {
-              keyValidator.validate(key);
-              valueValidator.validate(object2[key]);
-            });
-          } else {
-            try {
-              keyValidator.validate(key);
-              valueValidator.validate(object2[key]);
-            } catch (err) {
-              if (err instanceof ValidationError) {
-                throw new ValidationError(err.rawMessage, [key, ...err.path]);
-              }
-              throw new ValidationError(err.toString(), [key]);
-            }
-          }
+        for (const [key, value] of Object.entries(object2)) {
+          prefixError(key, () => {
+            keyValidator.validate(key);
+            valueValidator.validate(value);
+          });
         }
         return object2;
       },
@@ -671,71 +572,36 @@ class DictValidator extends Validator {
         if (typeof newValue !== "object" || newValue === null) {
           throw new ValidationError(`Expected object, got ${typeToString(newValue)}`);
         }
-        const newObj = newValue;
         let isDifferent = false;
-        let newKeyCount = 0;
-        for (const key in newObj) {
-          if (!hasOwnProperty(newObj, key)) continue;
-          newKeyCount++;
-          const next = newObj[key];
+        for (const [key, value] of Object.entries(newValue)) {
           if (!hasOwnProperty(knownGoodValue, key)) {
             isDifferent = true;
-            if (IS_DEV) {
-              prefixError(key, () => {
-                keyValidator.validate(key);
-                valueValidator.validate(next);
-              });
-            } else {
-              try {
-                keyValidator.validate(key);
-                valueValidator.validate(next);
-              } catch (err) {
-                if (err instanceof ValidationError) {
-                  throw new ValidationError(err.rawMessage, [key, ...err.path]);
-                }
-                throw new ValidationError(err.toString(), [key]);
-              }
-            }
+            prefixError(key, () => {
+              keyValidator.validate(key);
+              valueValidator.validate(value);
+            });
             continue;
           }
-          const prev = knownGoodValue[key];
+          const prev = getOwnProperty(knownGoodValue, key);
+          const next = value;
           if (Object.is(prev, next)) {
             continue;
           }
-          if (IS_DEV) {
-            const checked = prefixError(key, () => {
-              if (valueValidator.validateUsingKnownGoodVersion) {
-                return valueValidator.validateUsingKnownGoodVersion(prev, next);
-              } else {
-                return valueValidator.validate(next);
-              }
-            });
-            if (!Object.is(checked, prev)) {
-              isDifferent = true;
-            }
-          } else {
-            try {
-              const checked = valueValidator.validateUsingKnownGoodVersion ? valueValidator.validateUsingKnownGoodVersion(prev, next) : valueValidator.validate(next);
-              if (!Object.is(checked, prev)) {
-                isDifferent = true;
-              }
-            } catch (err) {
-              if (err instanceof ValidationError) {
-                throw new ValidationError(err.rawMessage, [key, ...err.path]);
-              }
-              throw new ValidationError(err.toString(), [key]);
+          const checked = prefixError(key, () => {
+            if (valueValidator.validateUsingKnownGoodVersion) {
+              return valueValidator.validateUsingKnownGoodVersion(prev, next);
+            } else {
+              return valueValidator.validate(next);
             }
+          });
+          if (!Object.is(checked, prev)) {
+            isDifferent = true;
           }
         }
-        if (!isDifferent) {
-          let oldKeyCount = 0;
-          for (const key in knownGoodValue) {
-            if (hasOwnProperty(knownGoodValue, key)) {
-              oldKeyCount++;
-            }
-          }
-          if (oldKeyCount !== newKeyCount) {
+        for (const key of Object.keys(knownGoodValue)) {
+          if (!hasOwnProperty(newValue, key)) {
             isDifferent = true;
+            break;
           }
         }
         return isDifferent ? newValue : knownGoodValue;
@@ -756,125 +622,28 @@ function typeofValidator(type) {
 const unknown = new Validator((value) => value);
 const any = new Validator((value) => value);
 const string = typeofValidator("string");
-const number = new Validator((value) => {
-  if (Number.isFinite(value)) {
-    return value;
-  }
-  if (typeof value !== "number") {
-    throw new ValidationError(`Expected number, got ${typeToString(value)}`);
-  }
-  if (value !== value) {
+const number = typeofValidator("number").check((number2) => {
+  if (Number.isNaN(number2)) {
     throw new ValidationError("Expected a number, got NaN");
   }
-  throw new ValidationError(`Expected a finite number, got ${value}`);
-});
-const positiveNumber = new Validator((value) => {
-  if (Number.isFinite(value) && value >= 0) {
-    return value;
-  }
-  if (typeof value !== "number") {
-    throw new ValidationError(`Expected number, got ${typeToString(value)}`);
-  }
-  if (value !== value) {
-    throw new ValidationError("Expected a number, got NaN");
+  if (!Number.isFinite(number2)) {
+    throw new ValidationError(`Expected a finite number, got ${number2}`);
   }
-  if (value < 0) {
-    throw new ValidationError(`Expected a positive number, got ${value}`);
-  }
-  throw new ValidationError(`Expected a finite number, got ${value}`);
 });
-const nonZeroNumber = new Validator((value) => {
-  if (Number.isFinite(value) && value > 0) {
-    return value;
-  }
-  if (typeof value !== "number") {
-    throw new ValidationError(`Expected number, got ${typeToString(value)}`);
-  }
-  if (value !== value) {
-    throw new ValidationError("Expected a number, got NaN");
-  }
-  if (value <= 0) {
-    throw new ValidationError(`Expected a non-zero positive number, got ${value}`);
-  }
-  throw new ValidationError(`Expected a finite number, got ${value}`);
-});
-const nonZeroFiniteNumber = new Validator((value) => {
-  if (Number.isFinite(value) && value !== 0) {
-    return value;
-  }
-  if (typeof value !== "number") {
-    throw new ValidationError(`Expected number, got ${typeToString(value)}`);
-  }
-  if (value !== value) {
-    throw new ValidationError("Expected a number, got NaN");
-  }
-  if (value === 0) {
-    throw new ValidationError(`Expected a non-zero number, got 0`);
-  }
-  throw new ValidationError(`Expected a finite number, got ${value}`);
+const positiveNumber = number.check((value) => {
+  if (value < 0) throw new ValidationError(`Expected a positive number, got ${value}`);
 });
-const unitInterval = new Validator((value) => {
-  if (Number.isFinite(value) && value >= 0 && value <= 1) {
-    return value;
-  }
-  if (typeof value !== "number") {
-    throw new ValidationError(`Expected number, got ${typeToString(value)}`);
-  }
-  if (value !== value) {
-    throw new ValidationError("Expected a number, got NaN");
-  }
-  throw new ValidationError(`Expected a number between 0 and 1, got ${value}`);
+const nonZeroNumber = number.check((value) => {
+  if (value <= 0) throw new ValidationError(`Expected a non-zero positive number, got ${value}`);
 });
-const integer = new Validator((value) => {
-  if (Number.isInteger(value)) {
-    return value;
-  }
-  if (typeof value !== "number") {
-    throw new ValidationError(`Expected number, got ${typeToString(value)}`);
-  }
-  if (value !== value) {
-    throw new ValidationError("Expected a number, got NaN");
-  }
-  if (value - value !== 0) {
-    throw new ValidationError(`Expected a finite number, got ${value}`);
-  }
-  throw new ValidationError(`Expected an integer, got ${value}`);
+const integer = number.check((value) => {
+  if (!Number.isInteger(value)) throw new ValidationError(`Expected an integer, got ${value}`);
 });
-const positiveInteger = new Validator((value) => {
-  if (Number.isInteger(value) && value >= 0) {
-    return value;
-  }
-  if (typeof value !== "number") {
-    throw new ValidationError(`Expected number, got ${typeToString(value)}`);
-  }
-  if (value !== value) {
-    throw new ValidationError("Expected a number, got NaN");
-  }
-  if (value - value !== 0) {
-    throw new ValidationError(`Expected a finite number, got ${value}`);
-  }
-  if (value < 0) {
-    throw new ValidationError(`Expected a positive integer, got ${value}`);
-  }
-  throw new ValidationError(`Expected an integer, got ${value}`);
+const positiveInteger = integer.check((value) => {
+  if (value < 0) throw new ValidationError(`Expected a positive integer, got ${value}`);
 });
-const nonZeroInteger = new Validator((value) => {
-  if (Number.isInteger(value) && value > 0) {
-    return value;
-  }
-  if (typeof value !== "number") {
-    throw new ValidationError(`Expected number, got ${typeToString(value)}`);
-  }
-  if (value !== value) {
-    throw new ValidationError("Expected a number, got NaN");
-  }
-  if (value - value !== 0) {
-    throw new ValidationError(`Expected a finite number, got ${value}`);
-  }
-  if (value <= 0) {
-    throw new ValidationError(`Expected a non-zero positive integer, got ${value}`);
-  }
-  throw new ValidationError(`Expected an integer, got ${value}`);
+const nonZeroInteger = integer.check((value) => {
+  if (value <= 0) throw new ValidationError(`Expected a non-zero positive integer, got ${value}`);
 });
 const boolean = typeofValidator("boolean");
 const bigint = typeofValidator("bigint");
@@ -1040,14 +809,13 @@ function optional(validator) {
       return validator.validate(value);
     },
     (knownGoodValue, newValue) => {
+      if (knownGoodValue === void 0 && newValue === void 0) return void 0;
       if (newValue === void 0) return void 0;
       if (validator.validateUsingKnownGoodVersion && knownGoodValue !== void 0) {
         return validator.validateUsingKnownGoodVersion(knownGoodValue, newValue);
       }
       return validator.validate(newValue);
-    },
-    // Propagate skipSameValueCheck from inner validator to allow refine wrappers
-    validator instanceof Validator && validator.skipSameValueCheck
+    }
   );
 }
 function nullable(validator) {
@@ -1062,9 +830,7 @@ function nullable(validator) {
         return validator.validateUsingKnownGoodVersion(knownGoodValue, newValue);
       }
       return validator.validate(newValue);
-    },
-    // Propagate skipSameValueCheck from inner validator to allow refine wrappers
-    validator instanceof Validator && validator.skipSameValueCheck
+    }
   );
 }
 function literalEnum(...values) {
@@ -1152,7 +918,6 @@ export {
   literal,
   literalEnum,
   model,
-  nonZeroFiniteNumber,
   nonZeroInteger,
   nonZeroNumber,
   nullable,
@@ -1167,7 +932,6 @@ export {
   srcUrl,
   string,
   union,
-  unitInterval,
   unknown,
   unknownObject
 };