@tldraw/validate 5.2.0-canary.4a316fdfb2bb → 5.2.0-canary.4e00299c3e28

package/README.md

@@ -30,9 +30,17 @@ const queryValidator = T.object({
 queryValidator.validate(request.query)
 ```
 
+## Documentation
+
+Documentation for the most recent release can be found on [tldraw.dev/docs](https://tldraw.dev/docs), including [reference docs](https://tldraw.dev/reference/editor/Editor). Our release notes can be found [here](https://tldraw.dev/releases).
+
+For more agent-friendly docs, see our [LLMs.txt](https://tldraw.dev/llms.txt).
+
+A `DOCS.md` file is included alongside this README in the published package, with detailed API documentation and usage examples.
+
 ## Contribution
 
-Please see our [contributing guide](https://github.com/tldraw/tldraw/blob/main/CONTRIBUTING.md). Found a bug? Please [submit an issue](https://github.com/tldraw/tldraw/issues/new).
+Found a bug? Please [submit an issue](https://github.com/tldraw/tldraw/issues/new).
 
 ## License
 

package/dist-cjs/index.d.ts

@@ -712,7 +712,8 @@ export declare class UnionValidator<Key extends string, Config extends UnionVali
      */
     constructor(key: Key, config: Config, unknownValueValidation: (value: object, variant: string) => UnknownValue, useNumberKeys: boolean);
     private expectObject;
-    private getMatchingSchemaAndVariant;
+    private getVariant;
+    private getMatchingSchema;
     /**
      * Returns a new UnionValidator that can handle unknown variants using the provided function.
      *
@@ -781,14 +782,14 @@ declare const unitInterval: Validator<number>;
 declare const unknown: Validator<unknown>;
 
 /**
- * Validator that ensures a value is an object (non-null, non-array). Does not validate
- * the properties of the object.
+ * Validator that ensures a value is a non-null object. Does not validate the properties of
+ * the object. Note that arrays also pass this check.
  *
  * @example
  * ```ts
  * const obj = T.unknownObject.validate({ any: "properties" }) // Returns Record<string, unknown>
  * T.unknownObject.validate(null) // Throws ValidationError: "Expected object, got null"
- * T.unknownObject.validate([1, 2, 3]) // Throws ValidationError: "Expected object, got an array"
+ * T.unknownObject.validate([1, 2, 3]) // Returns the array (arrays pass the object check)
  * ```
  * @public
  */

package/dist-cjs/index.js

@@ -41,7 +41,7 @@ var T = __toESM(require("./lib/validation"), 1);
 var import_validation = require("./lib/validation");
 (0, import_utils.registerTldrawLibraryVersion)(
   "@tldraw/validate",
-  "5.2.0-canary.4a316fdfb2bb",
+  "5.2.0-canary.4e00299c3e28",
   "cjs"
 );
 //# sourceMappingURL=index.js.map

package/dist-cjs/lib/validation.js

@@ -95,7 +95,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;
   }
@@ -103,15 +103,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";
@@ -340,7 +336,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 {
@@ -362,17 +362,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;
@@ -388,46 +381,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;
@@ -483,33 +456,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 (!(0, import_utils.hasOwnProperty)(config, key)) continue;
-          const validator = config[key];
-          if (IS_DEV) {
-            prefixError(key, () => {
-              ;
-              validator.validate((0, import_utils.getOwnProperty)(object2, key));
-            });
-          } else {
-            try {
-              ;
-              validator.validate((0, import_utils.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((0, import_utils.getOwnProperty)(object2, key));
+          } catch (err) {
+            rethrowPrefixed(key, err);
           }
         }
         if (!shouldAllowUnknownProperties) {
-          for (const key of Object.keys(object2)) {
+          for (const key in object2) {
+            if (!(0, import_utils.hasOwnProperty)(object2, key)) continue;
             if (!(0, import_utils.hasOwnProperty)(config, key)) {
               throw new ValidationError(`Unexpected property`, [key]);
             }
@@ -525,52 +493,45 @@ class ObjectValidator extends Validator {
           throw new ValidationError(`Expected object, got ${typeToString(newValue)}`);
         }
         let isDifferent = false;
-        for (const key in config) {
-          if (!(0, import_utils.hasOwnProperty)(config, key)) continue;
-          const validator = config[key];
+        for (let i = 0; i < configKeys.length; i++) {
+          const key = configKeys[i];
           const prev = (0, import_utils.getOwnProperty)(knownGoodValue, key);
           const next = (0, import_utils.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 (!(0, import_utils.hasOwnProperty)(newValue, key)) continue;
             if (!(0, import_utils.hasOwnProperty)(config, key)) {
               throw new ValidationError(`Unexpected property`, [key]);
             }
           }
+        } else if (!isDifferent) {
+          for (const key of Object.keys(newValue)) {
+            if (!(0, import_utils.hasOwnProperty)(config, key) && !Object.is((0, import_utils.getOwnProperty)(knownGoodValue, key), (0, import_utils.getOwnProperty)(newValue, key))) {
+              isDifferent = true;
+              break;
+            }
+          }
         }
-        for (const key of Object.keys(knownGoodValue)) {
-          if (!(0, import_utils.hasOwnProperty)(newValue, key)) {
-            isDifferent = true;
-            break;
+        if (!isDifferent) {
+          for (const key in knownGoodValue) {
+            if (!(0, import_utils.hasOwnProperty)(knownGoodValue, key)) continue;
+            if (!(0, import_utils.hasOwnProperty)(newValue, key)) {
+              isDifferent = true;
+              break;
+            }
           }
         }
         return isDifferent ? newValue : knownGoodValue;
@@ -626,29 +587,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 ((0, import_utils.getOwnProperty)(prevValue, key) !== (0, import_utils.getOwnProperty)(newValue, key)) {
-          return prefixError(`(${key} = ${variant})`, () => matchingSchema.validate(newValue));
+          return this.unknownValueValidation(newValue, this.getVariant(newValue));
         }
-        return prefixError(`(${key} = ${variant})`, () => {
+        try {
+          if ((0, import_utils.getOwnProperty)(prevValue, key) !== (0, import_utils.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;
@@ -665,7 +632,13 @@ class UnionValidator extends Validator {
       throw new ValidationError(`Expected an object, got ${typeToString(value)}`, []);
     }
   }
-  getMatchingSchemaAndVariant(object2) {
+  getVariant(object2) {
+    return (0, import_utils.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 = (0, import_utils.getOwnProperty)(object2, this.key);
     if (!this.useNumberKeys && typeof variant !== "string") {
       throw new ValidationError(
@@ -679,8 +652,7 @@ class UnionValidator extends Validator {
         );
       }
     }
-    const matchingSchema = (0, import_utils.hasOwnProperty)(this.config, variant) ? this.config[variant] : void 0;
-    return { matchingSchema, variant };
+    return (0, import_utils.hasOwnProperty)(this.config, variant) ? this.config[variant] : void 0;
   }
   /**
    * Returns a new UnionValidator that can handle unknown variants using the provided function.
@@ -715,21 +687,11 @@ class DictValidator extends Validator {
         }
         for (const key in object2) {
           if (!(0, import_utils.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;
@@ -747,21 +709,11 @@ class DictValidator extends Validator {
           const next = newObj[key];
           if (!(0, import_utils.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;
           }
@@ -769,29 +721,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) {
@@ -981,10 +917,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 (!(0, import_utils.hasOwnProperty)(value, key)) continue;
+      if (!isValidJson(value[key])) return false;
+    }
+    return true;
   }
   return false;
 }
@@ -1017,7 +960,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 (!(0, import_utils.hasOwnProperty)(newValue, key)) continue;
         if (!(0, import_utils.hasOwnProperty)(knownGoodValue, key)) {
           isDifferent = true;
           jsonValue.validate(newValue[key]);
@@ -1033,10 +977,13 @@ const jsonValue = new Validator(
           isDifferent = true;
         }
       }
-      for (const key of Object.keys(knownGoodValue)) {
-        if (!(0, import_utils.hasOwnProperty)(newValue, key)) {
-          isDifferent = true;
-          break;
+      if (!isDifferent) {
+        for (const key in knownGoodValue) {
+          if (!(0, import_utils.hasOwnProperty)(knownGoodValue, key)) continue;
+          if (!(0, import_utils.hasOwnProperty)(newValue, key)) {
+            isDifferent = true;
+            break;
+          }
         }
       }
       return isDifferent ? newValue : knownGoodValue;
@@ -1080,16 +1027,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);
+      }
     }
   );
 }