@tldraw/validate 5.1.1 → 5.2.0-canary.05c017c18b15

package/dist-esm/lib/validation.mjs

@@ -40,7 +40,7 @@ class ValidationError extends Error {
   constructor(rawMessage, path = []) {
     const formattedPath = formatPath(path);
     const indentedMessage = rawMessage.split("\n").map((line, i) => i === 0 ? line : `  ${line}`).join("\n");
-    super(path ? `At ${formattedPath}: ${indentedMessage}` : indentedMessage);
+    super(formattedPath ? `At ${formattedPath}: ${indentedMessage}` : indentedMessage);
     this.rawMessage = rawMessage;
     this.path = path;
   }
@@ -48,15 +48,11 @@ class ValidationError extends Error {
   path;
   name = "ValidationError";
 }
-function prefixError(path, fn) {
-  try {
-    return fn();
-  } catch (err) {
-    if (err instanceof ValidationError) {
-      throw new ValidationError(err.rawMessage, [path, ...err.path]);
-    }
-    throw new ValidationError(err.toString(), [path]);
+function rethrowPrefixed(path, err) {
+  if (err instanceof ValidationError) {
+    throw new ValidationError(err.rawMessage, [path, ...err.path]);
   }
+  throw new ValidationError(err.toString(), [path]);
 }
 function typeToString(value) {
   if (value === null) return "null";
@@ -285,7 +281,11 @@ class Validator {
   check(nameOrCheckFn, checkFn) {
     if (typeof nameOrCheckFn === "string") {
       return this.refine((value) => {
-        prefixError(`(check ${nameOrCheckFn})`, () => checkFn(value));
+        try {
+          checkFn(value);
+        } catch (err) {
+          rethrowPrefixed(`(check ${nameOrCheckFn})`, err);
+        }
         return value;
       });
     } else {
@@ -307,17 +307,10 @@ 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]);
-            }
+          try {
+            itemValidator.validate(arr[i]);
+          } catch (err) {
+            rethrowPrefixed(i, err);
           }
         }
         return arr;
@@ -333,46 +326,26 @@ 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]);
-              }
+            try {
+              itemValidator.validate(item);
+            } catch (err) {
+              rethrowPrefixed(i, err);
             }
             continue;
           }
           if (Object.is(knownGoodValue[i], item)) {
             continue;
           }
-          if (IS_DEV) {
-            const checkedItem = prefixError(
-              i,
-              () => itemValidator.validateUsingKnownGoodVersion(knownGoodValue[i], item)
+          try {
+            const checkedItem = 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]);
-            }
+          } catch (err) {
+            rethrowPrefixed(i, err);
           }
         }
         return isDifferent ? newValue : knownGoodValue;
@@ -428,33 +401,28 @@ class ObjectValidator extends Validator {
    * shouldAllowUnknownProperties - Whether to allow properties not defined in config
    */
   constructor(config, shouldAllowUnknownProperties = false) {
+    const configKeys = [];
+    const configValidators = [];
+    for (const [key, validator] of Object.entries(config)) {
+      configKeys.push(key);
+      configValidators.push(validator);
+    }
     super(
       (object2) => {
         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 (let i = 0; i < configKeys.length; i++) {
+          const key = configKeys[i];
+          try {
+            configValidators[i].validate(getOwnProperty(object2, key));
+          } catch (err) {
+            rethrowPrefixed(key, err);
           }
         }
         if (!shouldAllowUnknownProperties) {
-          for (const key of Object.keys(object2)) {
+          for (const key in object2) {
+            if (!hasOwnProperty(object2, key)) continue;
             if (!hasOwnProperty(config, key)) {
               throw new ValidationError(`Unexpected property`, [key]);
             }
@@ -470,52 +438,45 @@ class ObjectValidator extends Validator {
           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 (let i = 0; i < configKeys.length; i++) {
+          const key = configKeys[i];
           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);
-              }
-            });
+          try {
+            const validator = configValidators[i];
+            const checked = validator.validateUsingKnownGoodVersion ? validator.validateUsingKnownGoodVersion(prev, next) : validator.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]);
-            }
+          } catch (err) {
+            rethrowPrefixed(key, err);
           }
         }
         if (!shouldAllowUnknownProperties) {
-          for (const key of Object.keys(newValue)) {
+          for (const key in newValue) {
+            if (!hasOwnProperty(newValue, key)) continue;
             if (!hasOwnProperty(config, key)) {
               throw new ValidationError(`Unexpected property`, [key]);
             }
           }
+        } else if (!isDifferent) {
+          for (const key of Object.keys(newValue)) {
+            if (!hasOwnProperty(config, key) && !Object.is(getOwnProperty(knownGoodValue, key), getOwnProperty(newValue, key))) {
+              isDifferent = true;
+              break;
+            }
+          }
         }
-        for (const key of Object.keys(knownGoodValue)) {
-          if (!hasOwnProperty(newValue, key)) {
-            isDifferent = true;
-            break;
+        if (!isDifferent) {
+          for (const key in knownGoodValue) {
+            if (!hasOwnProperty(knownGoodValue, key)) continue;
+            if (!hasOwnProperty(newValue, key)) {
+              isDifferent = true;
+              break;
+            }
           }
         }
         return isDifferent ? newValue : knownGoodValue;
@@ -571,29 +532,35 @@ class UnionValidator extends Validator {
     super(
       (input) => {
         this.expectObject(input);
-        const { matchingSchema, variant } = this.getMatchingSchemaAndVariant(input);
+        const matchingSchema = this.getMatchingSchema(input);
         if (matchingSchema === void 0) {
-          return this.unknownValueValidation(input, variant);
+          return this.unknownValueValidation(input, this.getVariant(input));
+        }
+        try {
+          return matchingSchema.validate(input);
+        } catch (err) {
+          rethrowPrefixed(`(${key} = ${this.getVariant(input)})`, err);
         }
-        return prefixError(`(${key} = ${variant})`, () => matchingSchema.validate(input));
       },
       (prevValue, newValue) => {
         this.expectObject(newValue);
         this.expectObject(prevValue);
-        const { matchingSchema, variant } = this.getMatchingSchemaAndVariant(newValue);
+        const matchingSchema = this.getMatchingSchema(newValue);
         if (matchingSchema === void 0) {
-          return this.unknownValueValidation(newValue, variant);
-        }
-        if (getOwnProperty(prevValue, key) !== getOwnProperty(newValue, key)) {
-          return prefixError(`(${key} = ${variant})`, () => matchingSchema.validate(newValue));
+          return this.unknownValueValidation(newValue, this.getVariant(newValue));
         }
-        return prefixError(`(${key} = ${variant})`, () => {
+        try {
+          if (getOwnProperty(prevValue, key) !== getOwnProperty(newValue, key)) {
+            return matchingSchema.validate(newValue);
+          }
           if (matchingSchema.validateUsingKnownGoodVersion) {
             return matchingSchema.validateUsingKnownGoodVersion(prevValue, newValue);
           } else {
             return matchingSchema.validate(newValue);
           }
-        });
+        } catch (err) {
+          rethrowPrefixed(`(${key} = ${this.getVariant(newValue)})`, err);
+        }
       }
     );
     this.key = key;
@@ -610,7 +577,13 @@ class UnionValidator extends Validator {
       throw new ValidationError(`Expected an object, got ${typeToString(value)}`, []);
     }
   }
-  getMatchingSchemaAndVariant(object2) {
+  getVariant(object2) {
+    return getOwnProperty(object2, this.key);
+  }
+  // Returns the matching schema for the object's variant, or undefined if the variant is
+  // unknown. The variant itself is only needed on cold paths (unknown variants and errors),
+  // so this avoids allocating a `{ matchingSchema, variant }` result per validation.
+  getMatchingSchema(object2) {
     const variant = getOwnProperty(object2, this.key);
     if (!this.useNumberKeys && typeof variant !== "string") {
       throw new ValidationError(
@@ -624,8 +597,7 @@ class UnionValidator extends Validator {
         );
       }
     }
-    const matchingSchema = hasOwnProperty(this.config, variant) ? this.config[variant] : void 0;
-    return { matchingSchema, variant };
+    return hasOwnProperty(this.config, variant) ? this.config[variant] : void 0;
   }
   /**
    * Returns a new UnionValidator that can handle unknown variants using the provided function.
@@ -660,21 +632,11 @@ class DictValidator extends Validator {
         }
         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]);
-            }
+          try {
+            keyValidator.validate(key);
+            valueValidator.validate(object2[key]);
+          } catch (err) {
+            rethrowPrefixed(key, err);
           }
         }
         return object2;
@@ -692,21 +654,11 @@ class DictValidator extends Validator {
           const next = newObj[key];
           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]);
-              }
+            try {
+              keyValidator.validate(key);
+              valueValidator.validate(next);
+            } catch (err) {
+              rethrowPrefixed(key, err);
             }
             continue;
           }
@@ -714,29 +666,13 @@ class DictValidator extends Validator {
           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);
-              }
-            });
+          try {
+            const checked = valueValidator.validateUsingKnownGoodVersion ? valueValidator.validateUsingKnownGoodVersion(prev, next) : 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]);
-            }
+          } catch (err) {
+            rethrowPrefixed(key, err);
           }
         }
         if (!isDifferent) {
@@ -926,10 +862,17 @@ function isValidJson(value) {
     return true;
   }
   if (Array.isArray(value)) {
-    return value.every(isValidJson);
+    for (let i = 0; i < value.length; i++) {
+      if (!isValidJson(value[i])) return false;
+    }
+    return true;
   }
   if (isPlainObject(value)) {
-    return Object.values(value).every(isValidJson);
+    for (const key in value) {
+      if (!hasOwnProperty(value, key)) continue;
+      if (!isValidJson(value[key])) return false;
+    }
+    return true;
   }
   return false;
 }
@@ -962,7 +905,8 @@ const jsonValue = new Validator(
       return isDifferent ? newValue : knownGoodValue;
     } else if (isPlainObject(knownGoodValue) && isPlainObject(newValue)) {
       let isDifferent = false;
-      for (const key of Object.keys(newValue)) {
+      for (const key in newValue) {
+        if (!hasOwnProperty(newValue, key)) continue;
         if (!hasOwnProperty(knownGoodValue, key)) {
           isDifferent = true;
           jsonValue.validate(newValue[key]);
@@ -978,10 +922,13 @@ const jsonValue = new Validator(
           isDifferent = true;
         }
       }
-      for (const key of Object.keys(knownGoodValue)) {
-        if (!hasOwnProperty(newValue, key)) {
-          isDifferent = true;
-          break;
+      if (!isDifferent) {
+        for (const key in knownGoodValue) {
+          if (!hasOwnProperty(knownGoodValue, key)) continue;
+          if (!hasOwnProperty(newValue, key)) {
+            isDifferent = true;
+            break;
+          }
         }
       }
       return isDifferent ? newValue : knownGoodValue;
@@ -1025,16 +972,22 @@ function numberUnion(key, config) {
 function model(name, validator) {
   return new Validator(
     (value) => {
-      return prefixError(name, () => validator.validate(value));
+      try {
+        return validator.validate(value);
+      } catch (err) {
+        rethrowPrefixed(name, err);
+      }
     },
     (prevValue, newValue) => {
-      return prefixError(name, () => {
+      try {
         if (validator.validateUsingKnownGoodVersion) {
           return validator.validateUsingKnownGoodVersion(prevValue, newValue);
         } else {
           return validator.validate(newValue);
         }
-      });
+      } catch (err) {
+        rethrowPrefixed(name, err);
+      }
     }
   );
 }