ata-validator 1.7.0 → 1.7.2

package/lib/js-compiler.js

@@ -1,5 +1,77 @@
 'use strict'
 
+// uniqueItems helpers for the boolean generator, hoisted once per compiled
+// function (and carried into standalone output through the preamble).
+// _deq is JSON equality: numbers by value, objects by own keys regardless of
+// order, arrays positionally. _uq answers whether every item is distinct.
+// Structural JSON equality, hoisted once per compiled function. `const` and
+// `enum` compare instances by value: two objects with the same members are
+// equal whatever order their keys were written in. Comparing serialized
+// forms answers a different question and costs a string per call.
+const DEQ_HELPER = "function _deq(a,b){if(a===b)return true;if(a===null||b===null||typeof a!=='object'||typeof b!=='object')return false;var aa=Array.isArray(a);if(aa!==Array.isArray(b))return false;var i;if(aa){if(a.length!==b.length)return false;for(i=0;i<a.length;i++)if(!_deq(a[i],b[i]))return false;return true}var ka=Object.keys(a);if(ka.length!==Object.keys(b).length)return false;for(i=0;i<ka.length;i++){var k=ka[i];if(!Object.prototype.hasOwnProperty.call(b,k)||!_deq(a[k],b[k]))return false}return true}"
+
+// uniqueItems helpers for the boolean generator. `_uq` answers whether every
+// item is distinct: short arrays compare pairwise and allocate nothing,
+// longer ones use a Set of primitives and fall back to sorted-key canonical
+// strings only once an object actually appears.
+const UQ_HELPERS = "function _cn(x){if(x===null||typeof x!=='object')return typeof x+':'+x;if(Array.isArray(x))return'['+x.map(_cn).join(',')+']';return'{'+Object.keys(x).sort().map(function(k){return JSON.stringify(k)+':'+_cn(x[k])}).join(',')+'}'}" +
+  "function _uq(a){var n=a.length,i,k;if(n<2)return true;if(n<=12){for(i=1;i<n;i++)for(k=0;k<i;k++)if(_deq(a[i],a[k]))return false;return true}var s=new Set();for(i=0;i<n;i++){var x=a[i];if(x!==null&&typeof x==='object')break;if(s.has(x))return false;s.add(x)}if(i===n)return true;s=new Set();for(i=0;i<n;i++){var c=_cn(a[i]);if(s.has(c))return false;s.add(c)}return true}"
+
+// Where a generator hoists a declaration so it runs once per compiled
+// function rather than once per call. The boolean generator has a preamble
+// for exactly this; the error and combined generators emit `helperCode` into
+// their function source. The boolean generator's `helperCode` is only
+// scanned for regex entries and must not be used here.
+function hoistOnce(ctx, key, code) {
+  if (ctx[key]) return
+  ctx[key] = true
+  if (ctx.preamble) ctx.preamble.push(code)
+  else if (ctx.helperCode) ctx.helperCode.push(code)
+}
+
+function emitDeq(ctx) {
+  hoistOnce(ctx, '_deqHoisted', DEQ_HELPER)
+  return '_deq'
+}
+
+// `_uq` compares items with `_deq`, so it can never be hoisted alone.
+function emitUq(ctx) {
+  emitDeq(ctx)
+  hoistOnce(ctx, '_uqHoisted', UQ_HELPERS)
+  return '_uq'
+}
+
+// The compared value, parsed once at compile time. `JSON.parse` rather than a
+// JS object literal so a `__proto__` member stays an ordinary property.
+function emitConstant(ctx, value) {
+  if (!ctx._constPool) ctx._constPool = new Map()
+  const json = JSON.stringify(value)
+  let name = ctx._constPool.get(json)
+  if (name === undefined) {
+    name = '_kv' + ctx._constPool.size
+    ctx._constPool.set(json, name)
+    const decl = `const ${name}=JSON.parse(${JSON.stringify(json)})`
+    if (ctx.preamble) ctx.preamble.push(decl)
+    else if (ctx.helperCode) ctx.helperCode.push(decl)
+  }
+  return name
+}
+
+// One `enum` test: primitives compare with `===`, which needs no call, and
+// object members go through structural equality.
+function enumCondition(ctx, vals, v) {
+  const parts = []
+  const prims = vals.filter((x) => x === null || typeof x !== 'object')
+  const objs = vals.filter((x) => x !== null && typeof x === 'object')
+  if (prims.length) parts.push(prims.map((x) => `${v}===${JSON.stringify(x)}`).join('||'))
+  if (objs.length) {
+    const deq = emitDeq(ctx)
+    parts.push(objs.map((o) => `${deq}(${v},${emitConstant(ctx, o)})`).join('||'))
+  }
+  return parts.filter(Boolean).join('||') || 'false'
+}
+
+
 const { codeFor } = require('./error-codes')
 const { compileSafe, patternIsSafe } = require('./safe-regex')
 
@@ -53,7 +125,8 @@ function buildErrorLiteral (opts) {
 function _cpLen(s) {
   const len = s.length;
   for (let i = 0; i < len; i++) {
-    if (s.charCodeAt(i) >= 0xD800 && s.charCodeAt(i) <= 0xDBFF) {
+    // Wraparound test: one compare classifies a high surrogate.
+    if (((s.charCodeAt(i) - 0xD800) >>> 0) < 0x400) {
       // Found a high surrogate — count code points the slow way
       let n = 0; for (const _ of s) n++; return n;
     }
@@ -354,7 +427,7 @@ function compileToJS(schema, defs, schemaMap) {
   }
   if (schema.maxLength !== undefined) {
     const max = schema.maxLength
-    checks.push((d) => typeof d !== 'string' || d.length <= max || _cpLen(d) <= max)
+    checks.push((d) => typeof d !== 'string' || d.length <= max || (d.length <= 2 * max + 1 && _cpLen(d) <= max))
   }
   if (schema.pattern) {
     try {
@@ -1706,13 +1779,7 @@ function genCode(schema, v, lines, ctx, knownType) {
 
   // enum
   if (schema.enum) {
-    const vals = schema.enum
-    const primitives = vals.filter(v => v === null || typeof v !== 'object')
-    const objects = vals.filter(v => v !== null && typeof v === 'object')
-    const primChecks = primitives.map(p => `${v}===${JSON.stringify(p)}`).join('||')
-    const objChecks = objects.map(o => `JSON.stringify(${v})===${JSON.stringify(JSON.stringify(o))}`).join('||')
-    const allChecks = [primChecks, objChecks].filter(Boolean).join('||')
-    lines.push(`if(!(${allChecks || 'false'}))return false`)
+    lines.push(`if(!(${enumCondition(ctx, schema.enum, v)}))return false`)
   }
 
   // const
@@ -1721,12 +1788,9 @@ function genCode(schema, v, lines, ctx, knownType) {
     if (cv === null || typeof cv !== 'object') {
       lines.push(`if(${v}!==${JSON.stringify(cv)})return false`)
     } else {
-      // Key-order independent comparison, defined inline so every emitter
-      // (runtime, hybrid, standalone) carries it.
-      const ci = ctx.varCounter++
-      const canonFn = `_cnB${ci}`
-      const expected = _canonical(cv)
-      lines.push(`{const ${canonFn}=function(x){if(x===null||typeof x!=='object')return JSON.stringify(x);if(Array.isArray(x))return'['+x.map(${canonFn}).join(',')+']';return'{'+Object.keys(x).sort().map(function(k){return JSON.stringify(k)+':'+${canonFn}(x[k])}).join(',')+'}'};if(${canonFn}(${v})!==${JSON.stringify(expected)})return false}`)
+      // Structural comparison against a value parsed once, so the hot path
+      // neither builds a closure nor serializes the instance.
+      lines.push(`if(!${emitDeq(ctx)}(${v},${emitConstant(ctx, cv)}))return false`)
     }
   }
 
@@ -1881,11 +1945,22 @@ function genCode(schema, v, lines, ctx, knownType) {
     const maxItems = schema.maxItems
     // Small primitive arrays (maxItems <= 16): nested loop is 6x faster than Set
     // No allocation, no hash computation — just direct === comparison
-    const inner = isPrimItems && maxItems && maxItems <= 16
-      ? `for(let _i=1;_i<${v}.length;_i++){for(let _k=0;_k<_i;_k++){if(${v}[_i]===${v}[_k])return false}}`
-      : isPrimItems
-        ? `const _s${si}=new Set();for(let _i=0;_i<${v}.length;_i++){if(_s${si}.has(${v}[_i]))return false;_s${si}.add(${v}[_i])}`
-        : `const _cn${si}=function(x){if(x===null||typeof x!=='object')return typeof x+':'+x;if(Array.isArray(x))return'['+x.map(_cn${si}).join(',')+']';return'{'+Object.keys(x).sort().map(function(k){return JSON.stringify(k)+':'+_cn${si}(x[k])}).join(',')+'}'};const _s${si}=new Set();for(let _i=0;_i<${v}.length;_i++){const _k=_cn${si}(${v}[_i]);if(_s${si}.has(_k))return false;_s${si}.add(_k)}`
+    let inner
+    if (isPrimItems && maxItems && maxItems <= 16) {
+      inner = `for(let _i=1;_i<${v}.length;_i++){for(let _k=0;_k<_i;_k++){if(${v}[_i]===${v}[_k])return false}}`
+    } else if (isPrimItems) {
+      inner = `const _s${si}=new Set();for(let _i=0;_i<${v}.length;_i++){if(_s${si}.has(${v}[_i]))return false;_s${si}.add(${v}[_i])}`
+    } else if (ctx.preamble) {
+      // Unknown item types: one hoisted helper per compiled function. Short
+      // arrays compare pairwise with a structural equality that ignores key
+      // order and allocates nothing; longer ones fall back to a Set of
+      // primitives, or to sorted-key canonical strings once an object shows
+      // up. The previous form built the canonical closure and a Set on
+      // every call, even for [1, 2, 3].
+      inner = `if(!${emitUq(ctx)}(${v}))return false`
+    } else {
+      inner = `const _cn${si}=function(x){if(x===null||typeof x!=='object')return typeof x+':'+x;if(Array.isArray(x))return'['+x.map(_cn${si}).join(',')+']';return'{'+Object.keys(x).sort().map(function(k){return JSON.stringify(k)+':'+_cn${si}(x[k])}).join(',')+'}'};const _s${si}=new Set();for(let _i=0;_i<${v}.length;_i++){const _k=_cn${si}(${v}[_i]);if(_s${si}.has(_k))return false;_s${si}.add(_k)}`
+    }
     lines.push(isArr ? `{${inner}}` : `if(Array.isArray(${v})){${inner}}`)
   }
 
@@ -3187,13 +3262,7 @@ function genCodeE(schema, v, pathExpr, lines, ctx, schemaPrefix) {
 
   // enum
   if (schema.enum) {
-    const vals = schema.enum
-    const primitives = vals.filter(v => v === null || typeof v !== 'object')
-    const objects = vals.filter(v => v !== null && typeof v === 'object')
-    const primChecks = primitives.map(p => `${v}===${JSON.stringify(p)}`).join('||')
-    const objChecks = objects.map(o => `JSON.stringify(${v})===${JSON.stringify(JSON.stringify(o))}`).join('||')
-    const allChecks = [primChecks, objChecks].filter(Boolean).join('||')
-    lines.push(`if(!(${allChecks || 'false'})){${fail('enum', 'enum', `{allowedValues:${JSON.stringify(schema.enum)}}`, "'must be equal to one of the allowed values'")}}`)
+    lines.push(`if(!(${enumCondition(ctx, schema.enum, v)})){${fail('enum', 'enum', `{allowedValues:${JSON.stringify(schema.enum)}}`, "'must be equal to one of the allowed values'")}}`)
   }
 
   // const — use canonical (sorted-key) comparison for objects
@@ -3202,12 +3271,7 @@ function genCodeE(schema, v, pathExpr, lines, ctx, schemaPrefix) {
     if (cv === null || typeof cv !== 'object') {
       lines.push(`if(${v}!==${JSON.stringify(cv)}){${fail('const', 'const', `{allowedValue:${JSON.stringify(schema.const)}}`, "'must be equal to constant'")}}`)
     } else {
-      // Pre-compute canonical form of const value
-      const ci = ctx.varCounter++
-      const canonFn = `_cnE${ci}`
-      ctx.helperCode.push(`const ${canonFn}=function(x){if(x===null||typeof x!=='object')return JSON.stringify(x);if(Array.isArray(x))return'['+x.map(${canonFn}).join(',')+']';return'{'+Object.keys(x).sort().map(function(k){return JSON.stringify(k)+':'+${canonFn}(x[k])}).join(',')+'}'};`)
-      const expected = canonFn + '(JSON.parse(' + JSON.stringify(JSON.stringify(cv)) + '))'
-      lines.push(`if(${canonFn}(${v})!==${expected}){${fail('const', 'const', `{allowedValue:JSON.parse(${JSON.stringify(JSON.stringify(schema.const))})}`, "'must be equal to constant'")}}`)
+      lines.push(`if(!${emitDeq(ctx)}(${v},${emitConstant(ctx, cv)})){${fail('const', 'const', `{allowedValue:JSON.parse(${JSON.stringify(JSON.stringify(schema.const))})}`, "'must be equal to constant'")}}`)
     }
   }
 
@@ -3797,13 +3861,7 @@ function genCodeC(schema, v, pathExpr, lines, ctx, schemaPrefix) {
 
   // enum
   if (schema.enum) {
-    const vals = schema.enum
-    const primitives = vals.filter(v => v === null || typeof v !== 'object')
-    const objects = vals.filter(v => v !== null && typeof v === 'object')
-    const primChecks = primitives.map(p => `${v}===${JSON.stringify(p)}`).join('||')
-    const objChecks = objects.map(o => `JSON.stringify(${v})===${JSON.stringify(JSON.stringify(o))}`).join('||')
-    const allChecks = [primChecks, objChecks].filter(Boolean).join('||')
-    lines.push(`if(!(${allChecks || 'false'})){${fail('enum', 'enum', `{allowedValues:${JSON.stringify(schema.enum)}}`, "'must be equal to one of the allowed values'")}}`)
+    lines.push(`if(!(${enumCondition(ctx, schema.enum, v)})){${fail('enum', 'enum', `{allowedValues:${JSON.stringify(schema.enum)}}`, "'must be equal to one of the allowed values'")}}`)
   }
 
   // const
@@ -3812,10 +3870,7 @@ function genCodeC(schema, v, pathExpr, lines, ctx, schemaPrefix) {
     if (cv === null || typeof cv !== 'object') {
       lines.push(`if(${v}!==${JSON.stringify(cv)}){${fail('const', 'const', `{allowedValue:${JSON.stringify(schema.const)}}`, "'must be equal to constant'")}}`)
     } else {
-      const ci = ctx.varCounter++
-      const canonFn = `_cn${ci}`
-      ctx.helperCode.push(`const ${canonFn}=function(x){if(x===null||typeof x!=='object')return JSON.stringify(x);if(Array.isArray(x))return'['+x.map(${canonFn}).join(',')+']';return'{'+Object.keys(x).sort().map(function(k){return JSON.stringify(k)+':'+${canonFn}(x[k])}).join(',')+'}'};`)
-      lines.push(`if(${canonFn}(${v})!==${canonFn}(JSON.parse(${JSON.stringify(JSON.stringify(cv))}))){${fail('const', 'const', `{allowedValue:JSON.parse(${JSON.stringify(JSON.stringify(schema.const))})}`, "'must be equal to constant'")}}`)
+      lines.push(`if(!${emitDeq(ctx)}(${v},${emitConstant(ctx, cv)})){${fail('const', 'const', `{allowedValue:JSON.parse(${JSON.stringify(JSON.stringify(schema.const))})}`, "'must be equal to constant'")}}`)
     }
   }