Address code review feedback: rename isValidUtf8 to isUtf8, optimize performance, link dependencies directly

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

Author: Copilot

src/type/classes/StringType.ts

@@ -21,7 +21,7 @@ import type {json_string} from '@jsonjoy.com/util/lib/json-brand';
 import type * as ts from '../../typescript/types';
 import type {TypeExportContext} from '../../system/TypeExportContext';
 import type * as jtd from '../../jtd/types';
-import {validateStringFormat} from '../../util/stringFormats';
+import {isAscii, isUtf8} from '../../util/stringFormats';
 
 export class StringType extends AbstractType<schema.StringSchema> {
   constructor(protected schema: schema.StringSchema) {
@@ -92,16 +92,19 @@ export class StringType extends AbstractType<schema.StringSchema> {
       }
     }
 
-    // Handle format validation
     if (format) {
       const formatErr = ctx.err(ValidationError.STR, path);
-      const validateFn = ctx.codegen.linkDependency(validateStringFormat);
-      ctx.js(/* js */ `if(!${validateFn}(${r}, "${format}")) return ${formatErr};`);
+      if (format === 'ascii') {
+        const validateFn = ctx.codegen.linkDependency(isAscii);
+        ctx.js(/* js */ `if(!${validateFn}(${r})) return ${formatErr};`);
+      } else if (format === 'utf8') {
+        const validateFn = ctx.codegen.linkDependency(isUtf8);
+        ctx.js(/* js */ `if(!${validateFn}(${r})) return ${formatErr};`);
+      }
     } else if (ascii) {
-      // Backward compatibility: use ASCII validation if ascii=true and no format specified
       const asciiErr = ctx.err(ValidationError.STR, path);
-      const validateFn = ctx.codegen.linkDependency(validateStringFormat);
-      ctx.js(/* js */ `if(!${validateFn}(${r}, "ascii")) return ${asciiErr};`);
+      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

@@ -31,6 +31,7 @@ describe('StringType format validation', () => {
       expect(validator('a')).toBe(true); // Too short
       expect(validator('abcdef')).toBe(true); // Too long
       expect(validator('ñ')).toBe(true); // Non-ASCII (but would also be too short)
+      expect(validator('ñoño')).toBe(true); // Good length, but not ASCII
     });
   });
 

src/util/__tests__/stringFormats.spec.ts

@@ -1,4 +1,4 @@
-import {isAscii, isValidUtf8, validateStringFormat} from '../stringFormats';
+import {isAscii, isUtf8, validateStringFormat} from '../stringFormats';
 
 describe('String format validation utilities', () => {
   describe('isAscii', () => {
@@ -30,57 +30,57 @@ describe('String format validation utilities', () => {
     });
   });
 
-  describe('isValidUtf8', () => {
+  describe('isUtf8', () => {
     test('returns true for valid UTF-8 strings', () => {
-      expect(isValidUtf8('')).toBe(true);
-      expect(isValidUtf8('hello')).toBe(true);
-      expect(isValidUtf8('héllo')).toBe(true);
-      expect(isValidUtf8('🚀')).toBe(true);
-      expect(isValidUtf8('中文')).toBe(true);
-      expect(isValidUtf8('русский')).toBe(true);
-      expect(isValidUtf8('👍💖🎉')).toBe(true); // Multiple emojis with surrogate pairs
+      expect(isUtf8('')).toBe(true);
+      expect(isUtf8('hello')).toBe(true);
+      expect(isUtf8('héllo')).toBe(true);
+      expect(isUtf8('🚀')).toBe(true);
+      expect(isUtf8('中文')).toBe(true);
+      expect(isUtf8('русский')).toBe(true);
+      expect(isUtf8('👍💖🎉')).toBe(true); // Multiple emojis with surrogate pairs
     });
 
     test('returns false for unpaired high surrogates', () => {
       const highSurrogate = String.fromCharCode(0xD800);
-      expect(isValidUtf8(highSurrogate)).toBe(false);
-      expect(isValidUtf8('hello' + highSurrogate)).toBe(false);
-      expect(isValidUtf8(highSurrogate + 'world')).toBe(false);
+      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);
-      expect(isValidUtf8(lowSurrogate)).toBe(false);
-      expect(isValidUtf8('hello' + lowSurrogate)).toBe(false);
-      expect(isValidUtf8(lowSurrogate + 'world')).toBe(false);
+      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
-      expect(isValidUtf8(highSurrogate + notLowSurrogate)).toBe(false);
-      expect(isValidUtf8(highSurrogate + 'a')).toBe(false);
+      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);
-      expect(isValidUtf8(highSurrogate + lowSurrogate)).toBe(true);
+      expect(isUtf8(highSurrogate + lowSurrogate)).toBe(true);
 
       // Test with real emoji
-      expect(isValidUtf8('👨‍💻')).toBe(true); // Complex emoji with ZWJ
-      expect(isValidUtf8('🏳️‍🌈')).toBe(true); // Rainbow flag 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 validPair = highSurrogate + lowSurrogate;
 
-      expect(isValidUtf8(validPair + validPair)).toBe(true); // Two valid pairs
-      expect(isValidUtf8(validPair + highSurrogate)).toBe(false); // Valid pair + unpaired high
-      expect(isValidUtf8('hello' + validPair + 'world')).toBe(true); // Valid pair in middle
+      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
     });
   });
 
@@ -90,7 +90,7 @@ describe('String format validation utilities', () => {
       expect(validateStringFormat('héllo', 'ascii')).toBe(false);
     });
 
-    test('delegates to isValidUtf8 for utf8 format', () => {
+    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);

src/util/stringFormats.ts

@@ -8,7 +8,8 @@
  * This is highly optimized for performance.
  */
 export const isAscii = (str: string): boolean => {
-  for (let i = 0; i < str.length; i++) {
+  const length = str.length;
+  for (let i = 0; i < length; i++) {
     if (str.charCodeAt(i) > 127) {
       return false;
     }
@@ -25,14 +26,15 @@ export const isAscii = (str: string): boolean => {
  * - Unpaired surrogates (invalid UTF-16 sequences)
  * - Characters that would produce invalid UTF-8
  */
-export const isValidUtf8 = (str: string): boolean => {
-  for (let i = 0; i < str.length; i++) {
+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) {
       // High surrogate must be followed by low surrogate
-      if (i + 1 >= str.length) {
+      if (i + 1 >= length) {
         return false; // Unpaired high surrogate at end
       }
       const nextCode = str.charCodeAt(i + 1);
@@ -57,7 +59,7 @@ export const validateStringFormat = (str: string, format: 'ascii' | 'utf8'): boo
     case 'ascii':
       return isAscii(str);
     case 'utf8':
-      return isValidUtf8(str);
+      return isUtf8(str);
     default:
       return true;
   }