Apply code formatting with yarn format:fix

Co-authored-by: streamich <9773803+streamich@users.noreply.github.com>

Author: Copilot

src/schema/schema.ts

@@ -119,7 +119,7 @@ export interface StringSchema extends TType<string>, WithValidator {
   /**
    * String format specification. When set, the string value will be validated
    * according to the specified format for maximum performance.
-   * 
+   *
    * - "ascii" - Only ASCII characters (0-127) are allowed
    * - "utf8" - Valid UTF-8 encoded strings are allowed
    */
@@ -129,7 +129,7 @@ export interface StringSchema extends TType<string>, WithValidator {
    * When set to true, means that the string can contain only ASCII characters.
    * This enables a range of optimizations, such as using a faster JSON
    * serialization, faster binary serialization.
-   * 
+   *
    * @deprecated Use `format: 'ascii'` instead.
    */
   ascii?: boolean;

src/type/classes/StringType.ts

@@ -91,7 +91,7 @@ export class StringType extends AbstractType<schema.StringSchema> {
         ctx.js(/* js */ `if(${r}.length > ${max}) return ${err};`);
       }
     }
-    
+
     if (format) {
       const formatErr = ctx.err(ValidationError.STR, path);
       if (format === 'ascii') {
@@ -106,7 +106,7 @@ export class StringType extends AbstractType<schema.StringSchema> {
       const validateFn = ctx.codegen.linkDependency(isAscii);
       ctx.js(/* js */ `if(!${validateFn}(${r})) return ${asciiErr};`);
     }
-    
+
     ctx.emitCustomValidators(this, path, r);
   }
 

src/type/classes/__tests__/StringType.format.spec.ts

@@ -25,7 +25,7 @@ describe('StringType format validation', () => {
     test('works with min/max length', () => {
       const type = t.String({format: 'ascii', min: 2, max: 5});
       const validator = type.validator('boolean');
-      
+
       expect(validator('ab')).toBe(false); // Valid ASCII, correct length
       expect(validator('abcde')).toBe(false); // Valid ASCII, correct length
       expect(validator('a')).toBe(true); // Too short
@@ -51,9 +51,9 @@ describe('StringType format validation', () => {
     test('rejects strings with unpaired surrogates', () => {
       const validator = utf8Type.validator('boolean');
       // Create strings with unpaired surrogates
-      const highSurrogate = String.fromCharCode(0xD800); // High surrogate without low
-      const lowSurrogate = String.fromCharCode(0xDC00); // Low surrogate without high
-      
+      const highSurrogate = String.fromCharCode(0xd800); // High surrogate without low
+      const lowSurrogate = String.fromCharCode(0xdc00); // Low surrogate without high
+
       expect(validator(highSurrogate)).toBe(true); // Unpaired high surrogate
       expect(validator(lowSurrogate)).toBe(true); // Orphaned low surrogate
       expect(validator('hello' + highSurrogate)).toBe(true); // High surrogate at end
@@ -72,15 +72,15 @@ describe('StringType format validation', () => {
     test('ascii: true behaves like format: "ascii"', () => {
       const asciiType = t.String({ascii: true});
       const validator = asciiType.validator('boolean');
-      
+
       expect(validator('hello')).toBe(false); // Valid ASCII
       expect(validator('héllo')).toBe(true); // Non-ASCII
     });
 
     test('format takes precedence over ascii boolean', () => {
       const type = t.String({format: 'utf8', ascii: true});
       const validator = type.validator('boolean');
-      
+
       // Should behave as UTF-8 validation, allowing non-ASCII
       expect(validator('héllo')).toBe(false); // Should pass UTF-8 validation
     });
@@ -119,4 +119,4 @@ describe('StringType format validation', () => {
       expect(jsonSchema.pattern).toBe('^[\\x00-\\x7F]*$');
     });
   });
-});
+});

src/util/__tests__/stringFormats.spec.ts

@@ -42,42 +42,42 @@ describe('String format validation utilities', () => {
     });
 
     test('returns false for unpaired high surrogates', () => {
-      const highSurrogate = String.fromCharCode(0xD800);
+      const highSurrogate = String.fromCharCode(0xd800);
       expect(isUtf8(highSurrogate)).toBe(false);
       expect(isUtf8('hello' + highSurrogate)).toBe(false);
       expect(isUtf8(highSurrogate + 'world')).toBe(false);
     });
 
     test('returns false for orphaned low surrogates', () => {
-      const lowSurrogate = String.fromCharCode(0xDC00);
+      const lowSurrogate = String.fromCharCode(0xdc00);
       expect(isUtf8(lowSurrogate)).toBe(false);
       expect(isUtf8('hello' + lowSurrogate)).toBe(false);
       expect(isUtf8(lowSurrogate + 'world')).toBe(false);
     });
 
     test('returns false for high surrogate not followed by low surrogate', () => {
-      const highSurrogate = String.fromCharCode(0xD800);
-      const notLowSurrogate = String.fromCharCode(0xE000); // Outside surrogate range
+      const highSurrogate = String.fromCharCode(0xd800);
+      const notLowSurrogate = String.fromCharCode(0xe000); // Outside surrogate range
       expect(isUtf8(highSurrogate + notLowSurrogate)).toBe(false);
       expect(isUtf8(highSurrogate + 'a')).toBe(false);
     });
 
     test('returns true for valid surrogate pairs', () => {
       // Create a valid surrogate pair manually
-      const highSurrogate = String.fromCharCode(0xD800);
-      const lowSurrogate = String.fromCharCode(0xDC00);
+      const highSurrogate = String.fromCharCode(0xd800);
+      const lowSurrogate = String.fromCharCode(0xdc00);
       expect(isUtf8(highSurrogate + lowSurrogate)).toBe(true);
-      
+
       // Test with real emoji
       expect(isUtf8('👨‍💻')).toBe(true); // Complex emoji with ZWJ
       expect(isUtf8('🏳️‍🌈')).toBe(true); // Rainbow flag emoji
     });
 
     test('handles sequences correctly', () => {
-      const highSurrogate = String.fromCharCode(0xD800);
-      const lowSurrogate = String.fromCharCode(0xDC00);
+      const highSurrogate = String.fromCharCode(0xd800);
+      const lowSurrogate = String.fromCharCode(0xdc00);
       const validPair = highSurrogate + lowSurrogate;
-      
+
       expect(isUtf8(validPair + validPair)).toBe(true); // Two valid pairs
       expect(isUtf8(validPair + highSurrogate)).toBe(false); // Valid pair + unpaired high
       expect(isUtf8('hello' + validPair + 'world')).toBe(true); // Valid pair in middle
@@ -93,11 +93,11 @@ describe('String format validation utilities', () => {
     test('delegates to isUtf8 for utf8 format', () => {
       expect(validateStringFormat('hello', 'utf8')).toBe(true);
       expect(validateStringFormat('héllo', 'utf8')).toBe(true);
-      expect(validateStringFormat(String.fromCharCode(0xD800), 'utf8')).toBe(false);
+      expect(validateStringFormat(String.fromCharCode(0xd800), 'utf8')).toBe(false);
     });
 
     test('returns true for invalid format (defensive)', () => {
       expect(validateStringFormat('hello', 'invalid' as any)).toBe(true);
     });
   });
-});
+});

src/util/stringFormats.ts

@@ -21,7 +21,7 @@ export const isAscii = (str: string): boolean => {
  * Validates if a string represents valid UTF-8 when encoded.
  * JavaScript strings are UTF-16, but we need to validate they don't contain
  * invalid Unicode sequences that would produce invalid UTF-8.
- * 
+ *
  * This checks for:
  * - Unpaired surrogates (invalid UTF-16 sequences)
  * - Characters that would produce invalid UTF-8
@@ -30,19 +30,19 @@ export const isUtf8 = (str: string): boolean => {
   const length = str.length;
   for (let i = 0; i < length; i++) {
     const code = str.charCodeAt(i);
-    
+
     // Check for high surrogate
-    if (code >= 0xD800 && code <= 0xDBFF) {
+    if (code >= 0xd800 && code <= 0xdbff) {
       // High surrogate must be followed by low surrogate
       if (i + 1 >= length) {
         return false; // Unpaired high surrogate at end
       }
       const nextCode = str.charCodeAt(i + 1);
-      if (nextCode < 0xDC00 || nextCode > 0xDFFF) {
+      if (nextCode < 0xdc00 || nextCode > 0xdfff) {
         return false; // High surrogate not followed by low surrogate
       }
       i++; // Skip the low surrogate
-    } else if (code >= 0xDC00 && code <= 0xDFFF) {
+    } else if (code >= 0xdc00 && code <= 0xdfff) {
       // Low surrogate without preceding high surrogate
       return false;
     }
@@ -63,4 +63,4 @@ export const validateStringFormat = (str: string, format: 'ascii' | 'utf8'): boo
     default:
       return true;
   }
-};
+};