z-schema 7.0.9 → 7.1.0

package/README.md

@@ -142,6 +142,7 @@ ZSchema.setSchemaReader(function (uri) {
 - [Turn on z-schema strict mode](#strictmode)
 - [Set validator to collect as many errors as possible](#breakonfirsterror)
 - [Report paths in errors as arrays so they can be processed easier](#reportpathasarray)
+- [Unicode Property Escapes Support](#unicode-property-escapes-support)
 
 ### Validate against subschema
 
@@ -254,6 +255,21 @@ validator.validate(data, schema);
 // data.hello === "world"
 ```
 
+### Unicode Property Escapes Support
+
+Fully supports [Unicode property escapes](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_expressions/Unicode_property_escapes) in JSON Schema `pattern` values (e.g., `/\p{L}/u`). This allows you to write patterns that match Unicode character properties, such as letters, numbers, or scripts, provided your JavaScript environment supports them (Node.js ≥ 10, all modern browsers).
+
+**Example:**
+
+```json
+{
+  "type": "string",
+  "pattern": "^\\p{L}+$" // matches only Unicode letters
+}
+```
+
+z-schema will automatically use the `u` (Unicode) flag for all patterns containing Unicode property escapes, both in Node.js and browser environments. If your environment does not support Unicode property escapes, such patterns will be reported as invalid.
+
 ## Options
 
 ### asyncTimeout

package/cjs/index.js

@@ -8570,6 +8570,46 @@ const deepClone = (src) => {
     return cloneDeepInner(src);
 };
 
+// Shared regex compilation helper for JSON Schema patterns
+// Returns { ok: true, value: RegExp } or { ok: false, error: { pattern, message } }
+function compileSchemaRegex(pattern) {
+    // Detect Unicode property escapes
+    const unicodeEscape = /\\[pP]{/;
+    const needsUnicode = unicodeEscape.test(pattern);
+    // Try compiling without 'u' flag if not needed
+    if (needsUnicode) {
+        // Try compiling with 'u' flag only
+        try {
+            const re = new RegExp(pattern, 'u');
+            return { ok: true, value: re };
+        }
+        catch (e) {
+            return {
+                ok: false,
+                error: {
+                    pattern,
+                    message: e && e.message ? e.message : 'Invalid regular expression',
+                },
+            };
+        }
+    }
+    else {
+        try {
+            const re = new RegExp(pattern);
+            return { ok: true, value: re };
+        }
+        catch (e) {
+            return {
+                ok: false,
+                error: {
+                    pattern,
+                    message: e && e.message ? e.message : 'Invalid regular expression',
+                },
+            };
+        }
+    }
+}
+
 const shouldSkipValidate = function (options, errors) {
     return (options &&
         Array.isArray(options.includeErrors) &&
@@ -8675,7 +8715,13 @@ const JsonValidators = {
         if (typeof json !== 'string') {
             return;
         }
-        if (RegExp(schema.pattern).test(json) === false) {
+        const result = compileSchemaRegex(schema.pattern);
+        if (!result.ok) {
+            // Should not happen: schema should have been validated already
+            report.addError('PATTERN', [schema.pattern, json, result.error.message], undefined, schema);
+            return;
+        }
+        if (!result.value.test(json)) {
             report.addError('PATTERN', [schema.pattern, json], undefined, schema);
         }
     },
@@ -11501,11 +11547,11 @@ const SchemaValidators = {
             report.addError('KEYWORD_TYPE_EXPECTED', ['pattern', 'string']);
         }
         else {
-            try {
-                RegExp(schema.pattern);
-            }
-            catch (_e) {
-                report.addError('KEYWORD_PATTERN', ['pattern', schema.pattern]);
+            // Use shared regex compilation helper
+            // Import at top of file
+            const result = compileSchemaRegex(schema.pattern);
+            if (!result.ok) {
+                report.addError('KEYWORD_PATTERN', ['pattern', schema.pattern, result.error.message]);
             }
         }
     },
@@ -11661,15 +11707,14 @@ const SchemaValidators = {
             report.addError('KEYWORD_TYPE_EXPECTED', ['patternProperties', 'object']);
             return;
         }
+        // Use shared regex compilation helper
         const keys = Object.keys(schema.patternProperties);
         let idx = keys.length;
         while (idx--) {
             const key = keys[idx], val = schema.patternProperties[key];
-            try {
-                RegExp(key);
-            }
-            catch (_e) {
-                report.addError('KEYWORD_PATTERN', ['patternProperties', key]);
+            const result = compileSchemaRegex(key);
+            if (!result.ok) {
+                report.addError('KEYWORD_PATTERN', ['patternProperties', key, result.error.message]);
             }
             report.path.push('patternProperties');
             report.path.push(key);

package/dist/json-validation.js

@@ -4,6 +4,7 @@ import { ucs2decode } from './utils/unicode.js';
 import { difference, isUniqueArray } from './utils/array.js';
 import { areEqual } from './utils/json.js';
 import { shallowClone } from './utils/clone.js';
+import { compileSchemaRegex } from './utils/schema-regex.js';
 import { getFormatValidators } from './format-validators.js';
 const shouldSkipValidate = function (options, errors) {
     return (options &&
@@ -110,7 +111,13 @@ export const JsonValidators = {
         if (typeof json !== 'string') {
             return;
         }
-        if (RegExp(schema.pattern).test(json) === false) {
+        const result = compileSchemaRegex(schema.pattern);
+        if (!result.ok) {
+            // Should not happen: schema should have been validated already
+            report.addError('PATTERN', [schema.pattern, json, result.error.message], undefined, schema);
+            return;
+        }
+        if (!result.value.test(json)) {
             report.addError('PATTERN', [schema.pattern, json], undefined, schema);
         }
     },

package/dist/schema-validator.js

@@ -4,6 +4,7 @@ import { isObject, whatIs } from './utils/what-is.js';
 import { shallowClone } from './utils/clone.js';
 import { isUniqueArray } from './utils/array.js';
 import { isFormatSupported } from './format-validators.js';
+import { compileSchemaRegex } from './utils/schema-regex.js';
 const SchemaValidators = {
     $ref: function (report, schema) {
         // http://tools.ietf.org/html/draft-ietf-appsawg-json-pointer-07
@@ -81,11 +82,11 @@ const SchemaValidators = {
             report.addError('KEYWORD_TYPE_EXPECTED', ['pattern', 'string']);
         }
         else {
-            try {
-                RegExp(schema.pattern);
-            }
-            catch (_e) {
-                report.addError('KEYWORD_PATTERN', ['pattern', schema.pattern]);
+            // Use shared regex compilation helper
+            // Import at top of file
+            const result = compileSchemaRegex(schema.pattern);
+            if (!result.ok) {
+                report.addError('KEYWORD_PATTERN', ['pattern', schema.pattern, result.error.message]);
             }
         }
     },
@@ -241,15 +242,14 @@ const SchemaValidators = {
             report.addError('KEYWORD_TYPE_EXPECTED', ['patternProperties', 'object']);
             return;
         }
+        // Use shared regex compilation helper
         const keys = Object.keys(schema.patternProperties);
         let idx = keys.length;
         while (idx--) {
             const key = keys[idx], val = schema.patternProperties[key];
-            try {
-                RegExp(key);
-            }
-            catch (_e) {
-                report.addError('KEYWORD_PATTERN', ['patternProperties', key]);
+            const result = compileSchemaRegex(key);
+            if (!result.ok) {
+                report.addError('KEYWORD_PATTERN', ['patternProperties', key, result.error.message]);
             }
             report.path.push('patternProperties');
             report.path.push(key);

package/dist/types/utils/schema-regex.d.ts

@@ -0,0 +1,10 @@
+export declare function compileSchemaRegex(pattern: string): {
+    ok: true;
+    value: RegExp;
+} | {
+    ok: false;
+    error: {
+        pattern: string;
+        message: string;
+    };
+};

package/dist/utils/schema-regex.js

@@ -0,0 +1,39 @@
+// Shared regex compilation helper for JSON Schema patterns
+// Returns { ok: true, value: RegExp } or { ok: false, error: { pattern, message } }
+export function compileSchemaRegex(pattern) {
+    // Detect Unicode property escapes
+    const unicodeEscape = /\\[pP]{/;
+    const needsUnicode = unicodeEscape.test(pattern);
+    // Try compiling without 'u' flag if not needed
+    if (needsUnicode) {
+        // Try compiling with 'u' flag only
+        try {
+            const re = new RegExp(pattern, 'u');
+            return { ok: true, value: re };
+        }
+        catch (e) {
+            return {
+                ok: false,
+                error: {
+                    pattern,
+                    message: e && e.message ? e.message : 'Invalid regular expression',
+                },
+            };
+        }
+    }
+    else {
+        try {
+            const re = new RegExp(pattern);
+            return { ok: true, value: re };
+        }
+        catch (e) {
+            return {
+                ok: false,
+                error: {
+                    pattern,
+                    message: e && e.message ? e.message : 'Invalid regular expression',
+                },
+            };
+        }
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "z-schema",
-  "version": "7.0.9",
+  "version": "7.1.0",
   "engines": {
     "node": ">=22.0.0"
   },
@@ -67,7 +67,7 @@
     "test": "vitest run",
     "test:quick": "npm run build && npm run test:node",
     "test:browsers": "vitest run --project browsers --silent=true",
-    "test:node": "vitest run --project node --silent=true",
+    "test:node": "vitest run --project node --silent=false",
     "test:sample": "npx vitest run --silent=false --hideSkippedTests --project node -t \"invalid definition\"",
     "release:commit": "node -e \"const v=process.argv[1]; if(!v) throw new Error('Usage: npm run release:empty-commit -- <version>'); require('child_process').execSync(`git commit --allow-empty -m \\\"chore: release ${v}\\\" -m \\\"Release-As: ${v}\\\"`, {stdio:'inherit'});\" --"
   },

package/src/json-validation.ts

@@ -5,6 +5,7 @@ import { difference, isUniqueArray } from './utils/array.js';
 import { areEqual } from './utils/json.js';
 import { shallowClone } from './utils/clone.js';
 import { JsonSchema, JsonSchemaInternal } from './json-schema.js';
+import { compileSchemaRegex } from './utils/schema-regex.js';
 import type { ValidateOptions, ZSchema } from './z-schema.js';
 import { getFormatValidators } from './format-validators.js';
 
@@ -117,7 +118,13 @@ export const JsonValidators: Record<keyof JsonSchema, JsonValidatorFn> = {
     if (typeof json !== 'string') {
       return;
     }
-    if (RegExp(schema.pattern!).test(json) === false) {
+    const result = compileSchemaRegex(schema.pattern!);
+    if (!result.ok) {
+      // Should not happen: schema should have been validated already
+      report.addError('PATTERN', [schema.pattern!, json, result.error.message], undefined, schema);
+      return;
+    }
+    if (!result.value.test(json)) {
       report.addError('PATTERN', [schema.pattern!, json], undefined, schema);
     }
   },

package/src/schema-validator.ts

@@ -6,6 +6,7 @@ import { shallowClone } from './utils/clone.js';
 import { JsonSchema, JsonSchemaInternal } from './json-schema.js';
 import { isUniqueArray } from './utils/array.js';
 import { isFormatSupported } from './format-validators.js';
+import { compileSchemaRegex } from './utils/schema-regex.js';
 
 const SchemaValidators = {
   $ref: function (this: SchemaValidator, report: Report, schema: JsonSchemaInternal) {
@@ -78,10 +79,11 @@ const SchemaValidators = {
     if (typeof schema.pattern !== 'string') {
       report.addError('KEYWORD_TYPE_EXPECTED', ['pattern', 'string']);
     } else {
-      try {
-        RegExp(schema.pattern);
-      } catch (_e) {
-        report.addError('KEYWORD_PATTERN', ['pattern', schema.pattern]);
+      // Use shared regex compilation helper
+      // Import at top of file
+      const result = compileSchemaRegex(schema.pattern);
+      if (!result.ok) {
+        report.addError('KEYWORD_PATTERN', ['pattern', schema.pattern, result.error.message]);
       }
     }
   },
@@ -231,15 +233,15 @@ const SchemaValidators = {
       return;
     }
 
+    // Use shared regex compilation helper
     const keys = Object.keys(schema.patternProperties!);
     let idx = keys.length;
     while (idx--) {
       const key = keys[idx],
         val = schema.patternProperties![key];
-      try {
-        RegExp(key);
-      } catch (_e) {
-        report.addError('KEYWORD_PATTERN', ['patternProperties', key]);
+      const result = compileSchemaRegex(key);
+      if (!result.ok) {
+        report.addError('KEYWORD_PATTERN', ['patternProperties', key, result.error.message]);
       }
       report.path.push('patternProperties');
       report.path.push(key);

package/src/utils/schema-regex.ts

@@ -0,0 +1,39 @@
+// Shared regex compilation helper for JSON Schema patterns
+// Returns { ok: true, value: RegExp } or { ok: false, error: { pattern, message } }
+
+export function compileSchemaRegex(
+  pattern: string
+): { ok: true; value: RegExp } | { ok: false; error: { pattern: string; message: string } } {
+  // Detect Unicode property escapes
+  const unicodeEscape = /\\[pP]{/;
+  const needsUnicode = unicodeEscape.test(pattern);
+  // Try compiling without 'u' flag if not needed
+  if (needsUnicode) {
+    // Try compiling with 'u' flag only
+    try {
+      const re = new RegExp(pattern, 'u');
+      return { ok: true, value: re };
+    } catch (e: any) {
+      return {
+        ok: false,
+        error: {
+          pattern,
+          message: e && e.message ? e.message : 'Invalid regular expression',
+        },
+      };
+    }
+  } else {
+    try {
+      const re = new RegExp(pattern);
+      return { ok: true, value: re };
+    } catch (e: any) {
+      return {
+        ok: false,
+        error: {
+          pattern,
+          message: e && e.message ? e.message : 'Invalid regular expression',
+        },
+      };
+    }
+  }
+}

package/umd/ZSchema.js

@@ -8574,6 +8574,46 @@
         return cloneDeepInner(src);
     };
 
+    // Shared regex compilation helper for JSON Schema patterns
+    // Returns { ok: true, value: RegExp } or { ok: false, error: { pattern, message } }
+    function compileSchemaRegex(pattern) {
+        // Detect Unicode property escapes
+        const unicodeEscape = /\\[pP]{/;
+        const needsUnicode = unicodeEscape.test(pattern);
+        // Try compiling without 'u' flag if not needed
+        if (needsUnicode) {
+            // Try compiling with 'u' flag only
+            try {
+                const re = new RegExp(pattern, 'u');
+                return { ok: true, value: re };
+            }
+            catch (e) {
+                return {
+                    ok: false,
+                    error: {
+                        pattern,
+                        message: e && e.message ? e.message : 'Invalid regular expression',
+                    },
+                };
+            }
+        }
+        else {
+            try {
+                const re = new RegExp(pattern);
+                return { ok: true, value: re };
+            }
+            catch (e) {
+                return {
+                    ok: false,
+                    error: {
+                        pattern,
+                        message: e && e.message ? e.message : 'Invalid regular expression',
+                    },
+                };
+            }
+        }
+    }
+
     const shouldSkipValidate = function (options, errors) {
         return (options &&
             Array.isArray(options.includeErrors) &&
@@ -8679,7 +8719,13 @@
             if (typeof json !== 'string') {
                 return;
             }
-            if (RegExp(schema.pattern).test(json) === false) {
+            const result = compileSchemaRegex(schema.pattern);
+            if (!result.ok) {
+                // Should not happen: schema should have been validated already
+                report.addError('PATTERN', [schema.pattern, json, result.error.message], undefined, schema);
+                return;
+            }
+            if (!result.value.test(json)) {
                 report.addError('PATTERN', [schema.pattern, json], undefined, schema);
             }
         },
@@ -11505,11 +11551,11 @@
                 report.addError('KEYWORD_TYPE_EXPECTED', ['pattern', 'string']);
             }
             else {
-                try {
-                    RegExp(schema.pattern);
-                }
-                catch (_e) {
-                    report.addError('KEYWORD_PATTERN', ['pattern', schema.pattern]);
+                // Use shared regex compilation helper
+                // Import at top of file
+                const result = compileSchemaRegex(schema.pattern);
+                if (!result.ok) {
+                    report.addError('KEYWORD_PATTERN', ['pattern', schema.pattern, result.error.message]);
                 }
             }
         },
@@ -11665,15 +11711,14 @@
                 report.addError('KEYWORD_TYPE_EXPECTED', ['patternProperties', 'object']);
                 return;
             }
+            // Use shared regex compilation helper
             const keys = Object.keys(schema.patternProperties);
             let idx = keys.length;
             while (idx--) {
                 const key = keys[idx], val = schema.patternProperties[key];
-                try {
-                    RegExp(key);
-                }
-                catch (_e) {
-                    report.addError('KEYWORD_PATTERN', ['patternProperties', key]);
+                const result = compileSchemaRegex(key);
+                if (!result.ok) {
+                    report.addError('KEYWORD_PATTERN', ['patternProperties', key, result.error.message]);
                 }
                 report.path.push('patternProperties');
                 report.path.push(key);