ata-validator 1.22.1 → 1.24.0

package/lib/aot-impl.js

@@ -269,6 +269,16 @@ function toStandaloneModule(validator, opts) {
     const errSrc = jsErrFn && jsErrFn._errSource ? jsErrFn._errSource : '';
     if (errSrc) {
       errCore = `const errFn = function(d, _all) {\n  ${errSrc}\n};\n`;
+    } else if (opts && typeof opts.onWarning === 'function') {
+      // The caller asked for error detail and is not getting it: the error
+      // generator declined this schema (unevaluated* and a few other shapes),
+      // and a standalone module has no interpreted engine to fall back to the
+      // way the runtime validator does. The module still ships, with the
+      // verdict exact, but every failure reports the single ATA9000 stub.
+      // Silence here cost a user a debugging session; hence the channel.
+      opts.onWarning(
+        'error detail could not be generated for this schema; the module reports failures as the single ATA9000 abort-early error. The verdict is unaffected. For detailed errors, validate failing documents with the runtime Validator.'
+      );
     }
   }
 
@@ -379,9 +389,12 @@ function toStandaloneModule(validator, opts) {
     ? `export { ${names}${parseAlias} };\nexport default { ${names}${parseProp} };\n`
     : `module.exports = { ${names}${parseProp} };\nmodule.exports.default = module.exports;\n`;
 
+  const degradedNote = (!abortEarly && !errCore)
+    ? '// NOTE: error detail was requested but could not be generated for this\n// schema; failures report the single ATA9000 abort-early error. The verdict\n// is exact. Validate failing documents with the runtime Validator for detail.\n'
+    : '';
   return `// Auto-generated by ata-validator — do not edit.
 // Schema is embedded; runtime has zero dependency on ata-validator.
-'use strict';
+${degradedNote}'use strict';
 ${_CP_LEN_SOURCE}
 ${safeRePrelude(jsFn, jsErrFn)}${schemaSourceConst}const VALID = Object.freeze({ valid: true, errors: Object.freeze([]) });
 const ABORT = Object.freeze({

package/lib/compat-errors.js

@@ -49,7 +49,14 @@ function pointerOf(schemaPath) {
 }
 
 function segments(pointer) {
-  return pointer === '' ? [] : pointer.split('/').slice(1);
+  // split-then-slice built two arrays per call, and this is called for every
+  // error's pointer and every pointer walk. Dropping everything before the
+  // first '/' first builds one. Same answer for every input shape, including
+  // a pointer with no slash at all, which the old form turned into [].
+  if (pointer === '') return [];
+  const i = pointer.indexOf('/');
+  if (i < 0) return [];
+  return pointer.slice(i + 1).split('/');
 }
 
 // Walks a pointer's segments and reports, per position, whether that segment
@@ -67,24 +74,41 @@ function classify(segs) {
   return kinds;
 }
 
-function compareReferenceOrder(a, b) {
-  const pa = segments(pointerOf(a.schemaPath || ''));
-  const pb = segments(pointerOf(b.schemaPath || ''));
-  const ka = classify(pa);
-  const n = Math.min(pa.length, pb.length);
-  for (let i = 0; i < n; i++) {
-    if (pa[i] === pb[i]) continue;
-    if (ka[i] !== 'kw') return 0;
-    const ra = REFERENCE_RANK.get(pa[i]);
-    const rb = REFERENCE_RANK.get(pb[i]);
-    if (ra === undefined || rb === undefined) return 0;
-    return ra - rb;
-  }
-  return 0;
+// One derived key per error: its pointer relative to the hash, the split
+// segments, and each segment's kind. Everything below used to re-derive these
+// wherever it needed them, which for one shaped rejection meant splitting the
+// same pointer three times per error.
+function keyFor(e) {
+  const rel = pointerOf(e && e.schemaPath ? e.schemaPath : '#');
+  const segs = segments(rel);
+  return { rel, segs, kinds: classify(segs) };
+}
+
+function sortByKeys(errors, keys) {
+  if (errors.length < 2) return errors.slice();
+  const keyed = errors.map((e) => ({ e, k: keys.get(e) }));
+  keyed.sort((A, B) => {
+    const pa = A.k.segs, pb = B.k.segs, ka = A.k.kinds;
+    const n = Math.min(pa.length, pb.length);
+    for (let i = 0; i < n; i++) {
+      if (pa[i] === pb[i]) continue;
+      if (ka[i] !== 'kw') return 0;
+      const ra = REFERENCE_RANK.get(pa[i]);
+      const rb = REFERENCE_RANK.get(pb[i]);
+      if (ra === undefined || rb === undefined) return 0;
+      return ra - rb;
+    }
+    return 0;
+  });
+  for (let i = 0; i < keyed.length; i++) keyed[i] = keyed[i].e;
+  return keyed;
 }
 
 function sortLikeReference(errors) {
-  return errors.length < 2 ? errors : errors.slice().sort(compareReferenceOrder);
+  if (errors.length < 2) return errors;
+  const keys = new Map();
+  for (const e of errors) keys.set(e, keyFor(e));
+  return sortByKeys(errors, keys);
 }
 
 function walkPointer(node, pointer) {
@@ -151,14 +175,16 @@ function createShaper({ Validator, rootId, rootDoc, schemas, options, allErrors,
   // `basePointer` is where `errors` were produced relative to the root
   // document; a branch validator reports paths relative to its branch.
   function shape(errors, data, basePointer) {
-    const sorted = sortLikeReference(errors);
+    const keys = new Map();
+    for (const e of errors) keys.set(e, keyFor(e));
+    const sorted = sortByKeys(errors, keys);
     const out = [];
     const consumed = new Set();
     let thenGroup = null; // { prefix, which } for the pending `if` wrapper
 
     const flushIf = (e) => {
       if (thenGroup === null) return;
-      const segs = segments(pointerOf(e ? e.schemaPath : ''));
+      const segs = e ? keys.get(e).segs : [];
       const still = e && segs.length > thenGroup.depth && segs[thenGroup.depth] === thenGroup.which &&
         segs.slice(0, thenGroup.depth).join('/') === thenGroup.prefixSegs;
       if (still) return;
@@ -170,10 +196,11 @@ function createShaper({ Validator, rootId, rootDoc, schemas, options, allErrors,
     for (let idx = 0; idx < sorted.length; idx++) {
       const e = sorted[idx];
       if (consumed.has(e)) continue;
-      const rel = pointerOf(e.schemaPath || '#');
+      const K = keys.get(e);
+      const rel = K.rel;
       const abs = basePointer + rel;
-      const segs = segments(rel);
-      const kinds = classify(segs);
+      const segs = K.segs;
+      const kinds = K.kinds;
       const schemaPrefix = (e.schemaPath || '#').slice(0, (e.schemaPath || '#').indexOf('#') + 1);
 
       if (allErrors) flushIf(e);
@@ -234,7 +261,7 @@ function createShaper({ Validator, rootId, rootDoc, schemas, options, allErrors,
           // instance is replaced by the regenerated sequence.
           for (let j = idx; j < sorted.length; j++) {
             const o = sorted[j];
-            if ((o.instancePath || '') === (e.instancePath || '') && pointerOf(o.schemaPath || '#').startsWith(pnPointer + '/')) consumed.add(o);
+            if ((o.instancePath || '') === (e.instancePath || '') && keys.get(o).rel.startsWith(pnPointer + '/')) consumed.add(o);
           }
           const pnSchemaPath = schemaPrefix + pnPointer;
           for (const name of Object.keys(object)) {

package/lib/js-compiler.js

@@ -2612,8 +2612,14 @@ function genCode(schema, v, lines, ctx, knownType) {
           }
           // else: already emitted early (before properties)
         } else if (propCount > 0) {
-          // TRICK 3: charCodeAt switch tree
-          inner = genCharCodeSwitch(knownKeys, v)
+          // TRICK 3: charCodeAt switch tree. Above the lookup threshold it is
+          // the additionalProperties quadratic wearing a disguise: keys that
+          // share a first character, ENV_0 through ENV_999 say, all land in
+          // one case whose body is a chain of every name, per key of the
+          // document. The hoisted name lookup is the same cure it was there.
+          inner = propCount >= AP_LOOKUP_MIN
+            ? apMembershipCheck(ctx, knownKeys, v)
+            : genCharCodeSwitch(knownKeys, v)
                     _deferOrInline(ctx, lines, v, isObj ? inner : `if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})){${inner}}`)
         } else {
           inner = `for(var _k in ${v})return false`
@@ -2627,8 +2633,13 @@ function genCode(schema, v, lines, ctx, knownType) {
         genCode(schema.unevaluatedProperties, `${v}[${ukVar}]`, subLines, ctx)
         if (subLines.length > 0) {
           const check = subLines.join(';')
-          const keyChecks = knownKeys.map(k => `${ukVar}===${JSON.stringify(k)}`).join('||')
-          const skipKnown = knownKeys.length > 0 ? `if(${keyChecks})continue;` : ''
+          let skipKnown = ''
+          if (knownKeys.length >= AP_LOOKUP_MIN) {
+            const id = emitNameLookup(ctx, knownKeys)
+            skipKnown = id !== null ? `if(${id}[${ukVar}]!==undefined)continue;` : `if(${knownKeys.map(k => `${ukVar}===${JSON.stringify(k)}`).join('||')})continue;`
+          } else if (knownKeys.length > 0) {
+            skipKnown = `if(${knownKeys.map(k => `${ukVar}===${JSON.stringify(k)}`).join('||')})continue;`
+          }
           const inner = `for(var ${ukVar} in ${v}){${skipKnown}${check}}`
                     _deferOrInline(ctx, lines, v, isObj ? inner : `if(typeof ${v}==='object'&&${v}!==null&&!Array.isArray(${v})){${inner}}`)
         }