@tldraw/validate 4.2.1 → 4.2.2

package/dist-cjs/index.d.ts

@@ -322,6 +322,20 @@ declare function model<T extends {
     readonly id: string;
 }>(name: string, validator: Validatable<T>): Validator<T>;
 
+/**
+ * Validator that ensures a value is a finite, non-zero number. Allows negative numbers.
+ * Useful for scale factors that can be negative (for flipping) but not zero.
+ *
+ * @example
+ * ```ts
+ * const scale = T.nonZeroFiniteNumber.validate(-1.5) // Returns -1.5 (valid, allows negative)
+ * T.nonZeroFiniteNumber.validate(0) // Throws ValidationError: "Expected a non-zero number, got 0"
+ * T.nonZeroFiniteNumber.validate(Infinity) // Throws ValidationError
+ * ```
+ * @public
+ */
+declare const nonZeroFiniteNumber: Validator<number>;
+
 /**
  * Validator that ensures a value is a positive integer (\> 0). Rejects zero and negative integers.
  *
@@ -613,6 +627,8 @@ declare namespace T {
         number,
         positiveNumber,
         nonZeroNumber,
+        nonZeroFiniteNumber,
+        unitInterval,
         integer,
         positiveInteger,
         nonZeroInteger,
@@ -735,6 +751,22 @@ export declare type UnionValidatorConfig<Key extends string, Config> = {
     };
 };
 
+/**
+ * Validator that ensures a value is a number in the unit interval [0, 1].
+ * Useful for opacity, percentages expressed as decimals, and other normalized values.
+ *
+ * @example
+ * ```ts
+ * const opacity = T.unitInterval.validate(0.5) // Returns 0.5
+ * T.unitInterval.validate(0) // Returns 0 (valid)
+ * T.unitInterval.validate(1) // Returns 1 (valid)
+ * T.unitInterval.validate(1.5) // Throws ValidationError
+ * T.unitInterval.validate(-0.1) // Throws ValidationError
+ * ```
+ * @public
+ */
+declare const unitInterval: Validator<number>;
+
 /**
  * Validator that accepts any value without type checking. Useful as a starting point for
  * building custom validations or when you need to accept truly unknown data.
@@ -854,13 +886,17 @@ declare class ValidationError extends Error {
 export declare class Validator<T> implements Validatable<T> {
     readonly validationFn: ValidatorFn<T>;
     readonly validateUsingKnownGoodVersionFn?: undefined | ValidatorUsingKnownGoodVersionFn<T>;
+    /* Excluded from this release type: skipSameValueCheck */
     /**
      * Creates a new Validator instance.
      *
      * 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: ValidatorFn<T>, validateUsingKnownGoodVersionFn?: undefined | ValidatorUsingKnownGoodVersionFn<T>);
+    constructor(validationFn: ValidatorFn<T>, validateUsingKnownGoodVersionFn?: undefined | ValidatorUsingKnownGoodVersionFn<T>, 
+    /** @internal */
+    skipSameValueCheck?: boolean);
     /**
      * Validates an unknown value and returns it with the correct type. The returned value is
      * guaranteed to be referentially equal to the passed value.

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",
-  "4.2.1",
+  "4.2.2",
   "cjs"
 );
 //# sourceMappingURL=index.js.map

package/dist-cjs/lib/validation.js

@@ -39,6 +39,7 @@ __export(validation_exports, {
   literal: () => literal,
   literalEnum: () => literalEnum,
   model: () => model,
+  nonZeroFiniteNumber: () => nonZeroFiniteNumber,
   nonZeroInteger: () => nonZeroInteger,
   nonZeroNumber: () => nonZeroNumber,
   nullable: () => nullable,
@@ -53,11 +54,13 @@ __export(validation_exports, {
   srcUrl: () => srcUrl,
   string: () => string,
   union: () => union,
+  unitInterval: () => unitInterval,
   unknown: () => unknown,
   unknownObject: () => unknownObject
 });
 module.exports = __toCommonJS(validation_exports);
 var import_utils = require("@tldraw/utils");
+const IS_DEV = process.env.NODE_ENV !== "production";
 function formatPath(path) {
   if (!path.length) {
     return null;
@@ -134,10 +137,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
@@ -161,7 +166,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;
@@ -322,7 +327,9 @@ class Validator {
           return knownGoodValue;
         }
         return otherValidationFn(validated);
-      }
+      },
+      true
+      // skipSameValueCheck: refine is designed to transform values
     );
   }
   check(nameOrCheckFn, checkFn) {
@@ -350,11 +357,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;
@@ -362,18 +383,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;
@@ -433,11 +482,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((0, import_utils.getOwnProperty)(object2, key));
-          });
+        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]);
+            }
+          }
         }
         if (!shouldAllowUnknownProperties) {
           for (const key of Object.keys(object2)) {
@@ -449,26 +512,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 (!(0, import_utils.hasOwnProperty)(config, key)) continue;
+          const validator = config[key];
           const prev = (0, import_utils.getOwnProperty)(knownGoodValue, key);
           const next = (0, import_utils.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) {
@@ -576,8 +659,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 = (0, import_utils.hasOwnProperty)(this.config, variant) ? this.config[variant] : void 0;
     return { matchingSchema, variant };
@@ -613,11 +701,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 (!(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]);
+            }
+          }
         }
         return object2;
       },
@@ -625,36 +726,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 (!(0, import_utils.hasOwnProperty)(newObj, key)) continue;
+          newKeyCount++;
+          const next = newObj[key];
           if (!(0, import_utils.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 = (0, import_utils.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 (!(0, import_utils.hasOwnProperty)(newValue, key)) {
+        if (!isDifferent) {
+          let oldKeyCount = 0;
+          for (const key in knownGoodValue) {
+            if ((0, import_utils.hasOwnProperty)(knownGoodValue, key)) {
+              oldKeyCount++;
+            }
+          }
+          if (oldKeyCount !== newKeyCount) {
             isDifferent = true;
-            break;
           }
         }
         return isDifferent ? newValue : knownGoodValue;
@@ -675,28 +811,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");
@@ -862,13 +1095,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) {
@@ -883,7 +1117,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) {