@tldraw/validate 4.2.1 → 4.2.2

package/dist-esm/lib/validation.mjs

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