@tldraw/validate 4.2.2 → 4.2.3

package/dist-cjs/index.d.ts

@@ -322,20 +322,6 @@ 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.
  *
@@ -627,8 +613,6 @@ declare namespace T {
         number,
         positiveNumber,
         nonZeroNumber,
-        nonZeroFiniteNumber,
-        unitInterval,
         integer,
         positiveInteger,
         nonZeroInteger,
@@ -751,22 +735,6 @@ 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.
@@ -886,17 +854,13 @@ 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>, 
-    /** @internal */
-    skipSameValueCheck?: boolean);
+    constructor(validationFn: ValidatorFn<T>, validateUsingKnownGoodVersionFn?: undefined | ValidatorUsingKnownGoodVersionFn<T>);
     /**
      * 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.2",
+  "4.2.3",
   "cjs"
 );
 //# sourceMappingURL=index.js.map

package/dist-cjs/lib/validation.js

@@ -39,7 +39,6 @@ __export(validation_exports, {
   literal: () => literal,
   literalEnum: () => literalEnum,
   model: () => model,
-  nonZeroFiniteNumber: () => nonZeroFiniteNumber,
   nonZeroInteger: () => nonZeroInteger,
   nonZeroNumber: () => nonZeroNumber,
   nullable: () => nullable,
@@ -54,13 +53,11 @@ __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;
@@ -137,12 +134,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
@@ -166,7 +161,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;
@@ -327,9 +322,7 @@ class Validator {
           return knownGoodValue;
         }
         return otherValidationFn(validated);
-      },
-      true
-      // skipSameValueCheck: refine is designed to transform values
+      }
     );
   }
   check(nameOrCheckFn, checkFn) {
@@ -357,25 +350,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;
@@ -383,46 +362,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;
@@ -482,25 +433,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 (!(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 (const [key, validator] of Object.entries(config)) {
+          prefixError(key, () => {
+            ;
+            validator.validate((0, import_utils.getOwnProperty)(object2, key));
+          });
         }
         if (!shouldAllowUnknownProperties) {
           for (const key of Object.keys(object2)) {
@@ -512,46 +449,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 (!(0, import_utils.hasOwnProperty)(config, key)) continue;
-          const validator = config[key];
+        for (const [key, validator] of Object.entries(config)) {
           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);
-              }
-            });
-            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) {
@@ -659,13 +576,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 = (0, import_utils.hasOwnProperty)(this.config, variant) ? this.config[variant] : void 0;
     return { matchingSchema, variant };
@@ -701,24 +613,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 (!(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]);
-            }
-          }
+        for (const [key, value] of Object.entries(object2)) {
+          prefixError(key, () => {
+            keyValidator.validate(key);
+            valueValidator.validate(value);
+          });
         }
         return object2;
       },
@@ -726,71 +625,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 (!(0, import_utils.hasOwnProperty)(newObj, key)) continue;
-          newKeyCount++;
-          const next = newObj[key];
+        for (const [key, value] of Object.entries(newValue)) {
           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]);
-              }
-            }
+            prefixError(key, () => {
+              keyValidator.validate(key);
+              valueValidator.validate(value);
+            });
             continue;
           }
-          const prev = knownGoodValue[key];
+          const prev = (0, import_utils.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 ((0, import_utils.hasOwnProperty)(knownGoodValue, key)) {
-              oldKeyCount++;
-            }
-          }
-          if (oldKeyCount !== newKeyCount) {
+        for (const key of Object.keys(knownGoodValue)) {
+          if (!(0, import_utils.hasOwnProperty)(newValue, key)) {
             isDifferent = true;
+            break;
           }
         }
         return isDifferent ? newValue : knownGoodValue;
@@ -811,125 +675,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");
@@ -1095,14 +862,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) {
@@ -1117,9 +883,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) {