ata-validator 1.37.1 → 1.39.1

package/lib/regex-linear.js

@@ -0,0 +1,65 @@
+'use strict'
+
+const { parse } = require('./safe-regex')
+
+// True when the platform RegExp, a backtracking engine, also runs `src` in
+// linear time, so it can take the pattern: every quantifier on one character,
+// class or `.`; at most one unbounded, and then anchored with `^`; few bounded
+// choices; only escapes both engines read alike; nothing outside the BMP, so
+// both see the same UTF-16 units. tests/test_regex_native_linear.js holds it.
+const NATIVE_ESCAPES = new Set(['d', 'D', 'w', 'W', 's', 'S', 'n', 'r', 't', 'f', 'v', '.', '\\', '/', '^', '$', '|', '?', '*', '+', '(', ')', '[', ']', '{', '}', '-', 'x', 'u'])
+function nativeIsLinear (src) {
+  if (typeof src !== 'string' || src.length > 512) return false
+  for (let i = 0; i < src.length; i++) {
+    const c = src.charCodeAt(i)
+    if (c >= 0xd800 && c <= 0xdfff) return false
+    if (src[i] === '\\') {
+      const e = src[i + 1]
+      if (!NATIVE_ESCAPES.has(e)) return false
+      if (e === 'x' && !/^[0-9a-fA-F]{2}$/.test(src.slice(i + 2, i + 4))) return false
+      if (e === 'u' && !/^[0-9a-fA-F]{4}$/.test(src.slice(i + 2, i + 6))) return false
+      i++
+    }
+  }
+  let ast
+  try { ast = parse(src) } catch { return false }
+  let unbounded = 0
+  let bounded = 0
+  let ok = true
+  const atom = (n) => n.t === 'char' || n.t === 'class' || n.t === 'any'
+  const walk = (n) => {
+    if (!ok) return
+    switch (n.t) {
+      case 'star': case 'plus':
+        if (!atom(n.child)) ok = false
+        unbounded++
+        break
+      case 'quest':
+        if (!atom(n.child)) ok = false
+        bounded += 1
+        break
+      case 'repeat':
+        if (!atom(n.child)) ok = false
+        if (n.max === Infinity) unbounded++
+        else bounded += n.max - n.min
+        break
+      case 'group': walk(n.child); break
+      case 'concat': n.parts.forEach(walk); break
+      case 'alt': n.opts.forEach(walk); break
+      default: break
+    }
+  }
+  walk(ast)
+  if (!ok || unbounded > 1 || bounded > 64) return false
+  if (unbounded === 1) {
+    // Anchored at the start on every top-level branch.
+    let top = ast
+    while (top.t === 'group') top = top.child
+    const branches = top.t === 'alt' ? top.opts : [top]
+    const first = (n) => { while (n && n.t === 'group') n = n.child; return n && n.t === 'concat' ? first(n.parts[0]) : n }
+    if (!branches.every((b) => { const f = first(b); return f && f.t === 'bol' })) return false
+  }
+  return true
+}
+
+module.exports = { nativeIsLinear }

package/lib/rejections.js

@@ -76,7 +76,7 @@ class RichRejection {
   }
   _ataRaw() {
     let raw = this._result.errors || [];
-    if (raw.length > 1) raw = sortErrorsBySchemaOrder(this._root, raw);
+    if (needsOrdering(raw)) raw = sortErrorsBySchemaOrder(this._root, raw);
     return raw;
   }
 }
@@ -88,7 +88,7 @@ Object.defineProperty(RichRejection.prototype, 'errors', {
       const self = this._self;
       const enrich = this._enrich;
       let raw = this._result.errors || [];
-      if (raw.length > 1) raw = sortErrorsBySchemaOrder(this._root, raw);
+      if (needsOrdering(raw)) raw = sortErrorsBySchemaOrder(this._root, raw);
       // The position map, resolved now that an error is actually being read.
       let positions = null;
       if (enrich && raw.length && this._rawInput != null) {
@@ -172,7 +172,7 @@ Object.defineProperty(LazyJsonRejection.prototype, 'errors', {
       const positions = self._pos().targeted(jsonStr, wantedPointersFor(raw));
       // Declaration order, as validate() applies it; the text path used to
       // enrich in emission order.
-      const ordered = raw.length > 1 ? sortErrorsBySchemaOrder(self._schemaObj, raw) : raw;
+      const ordered = needsOrdering(raw) ? sortErrorsBySchemaOrder(self._schemaObj, raw) : raw;
       const enrichOpts = {
         data: parsedData,
         positions,
@@ -246,11 +246,23 @@ function wantedPointersFor (errors) {
   return wanted;
 }
 
-// A raw error without the `_o` ordering key, for the legacy error shape.
+// A raw error in the legacy shape. The error generator writes `code` and
+// `docUrl` into its literals because a standalone module returns them as they
+// are; the runtime's legacy shape never had them, and the interpreter leaves
+// them out, so they are dropped here with the ordering key `_o`. A collapsed
+// oneOf/anyOf error keeps its code, which both engines give it, and its
+// branch errors get the same treatment, so the shape does not depend on
+// which engine answered.
+const COLLAPSE_CODES = new Set(['ATA4001', 'ATA4002', 'ATA4003']);
 function stripOrdinal(e) {
-  if (e === null || typeof e !== 'object' || e._o === undefined) return e;
+  if (e === null || typeof e !== 'object') return e;
+  if (e._o === undefined && e.docUrl === undefined && (e.code === undefined || COLLAPSE_CODES.has(e.code)) && !e.branchErrors) return e;
   const out = {};
-  for (const k in e) if (k !== '_o') out[k] = e[k];
+  for (const k in e) {
+    if (k === '_o' || k === 'docUrl') continue;
+    if (k === 'code' && !COLLAPSE_CODES.has(e.code)) continue;
+    out[k] = k === 'branchErrors' && Array.isArray(e[k]) ? e[k].map(stripOrdinal) : e[k];
+  }
   return out;
 }
 
@@ -261,7 +273,33 @@ function stripOrdinal(e) {
 // place in the target (rankFor), so they come out in the order they would
 // inline, whichever engine produced them. Most rejections come out already
 // ordered, and those return without sorting or allocating.
+// A list of one can still hold a collapsed error whose branch errors, at any
+// depth, need ordering.
+function needsOrdering(raw) {
+  if (raw.length > 1) return true;
+  const e = raw[0];
+  return raw.length === 1 && e !== null && typeof e === 'object' && Array.isArray(e.branchErrors) && needsOrdering(e.branchErrors);
+}
+
+// A collapsed oneOf/anyOf error carries the closest branch's errors, which
+// each engine produces in its own walk order. They go in schema order like the
+// list they sit in, so which engine answered cannot be read off them.
+function sortBranchErrors(rootSchema, errors) {
+  let out = null;
+  for (let i = 0; i < errors.length; i++) {
+    const e = errors[i];
+    const b = e !== null && typeof e === 'object' ? e.branchErrors : undefined;
+    if (!Array.isArray(b) || b.length === 0) continue;
+    const sb = sortErrorsBySchemaOrder(rootSchema, b);
+    if (sb === b) continue;
+    if (out === null) out = errors.slice();
+    out[i] = Object.assign({}, e, { branchErrors: sb });
+  }
+  return out === null ? errors : out;
+}
+
 function sortErrorsBySchemaOrder(rootSchema, errors) {
+  errors = sortBranchErrors(rootSchema, errors);
   const n = errors.length;
   const keys = new Array(n);
   let sorted = true;