ata-validator 1.38.0 → 1.39.2

package/lib/rejections.js

@@ -76,53 +76,57 @@ 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;
   }
 }
+// Orders a raw error list and gives it the shape the caller asked for: the
+// legacy key set, or enriched. Shared by both rejection classes below.
+function presentErrors(raw, data, rawInput, self, root, enrich) {
+  if (needsOrdering(raw)) raw = sortErrorsBySchemaOrder(root, raw);
+  // The position map, resolved now that an error is actually being read.
+  let positions = null;
+  if (enrich && raw.length && rawInput != null) {
+    positions = self._pos().targeted(rawInput, wantedPointersFor(raw));
+    if (positions) self._posCache.reset();
+  }
+  // One options object for the whole list, not one per error.
+  const opts = enrich && raw.length
+    ? {
+        data,
+        positions,
+        schemaPositions: self._schemaPositions,
+        schemaFile: self._source ? self._source.path : undefined,
+      }
+    : null;
+  const cached = opts
+    ? raw.map((e) => enrich(e, opts))
+    // The v0.14 shape is a fixed key set; the ordering key the
+    // generated code carries is dropped from it here.
+    : raw.map(stripOrdinal);
+  // Correlation is published, never applied. Both halves of a typo pair
+  // stay in the array; `related` only says they are one mistake, so a
+  // wrong pairing costs a sentence rather than a hidden violation.
+  if (enrich && cached.length > 1) attachRelated(cached);
+  // No diagnostic payload here. validate(data) is the library hot path,
+  // and attaching one cost about 100 ns per rejection for a consumer
+  // that never renders. The text path attaches it, and a renderer given
+  // `{ data }` builds frames for object input on request.
+  return cached;
+}
+
 Object.defineProperty(RichRejection.prototype, 'errors', {
   enumerable: true,
   configurable: true,
   get() {
     if (this._cached === null) {
-      const self = this._self;
-      const enrich = this._enrich;
-      let raw = this._result.errors || [];
-      if (raw.length > 1) 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) {
-        positions = self._pos().targeted(this._rawInput, wantedPointersFor(raw));
-        if (positions) self._posCache.reset();
-      }
-      // One options object for the whole list, not one per error.
-      const opts = enrich && raw.length
-        ? {
-            data: this._data,
-            positions,
-            schemaPositions: self._schemaPositions,
-            schemaFile: self._source ? self._source.path : undefined,
-          }
-        : null;
-      const cached = opts
-        ? raw.map((e) => enrich(e, opts))
-        // The v0.14 shape is a fixed key set; the ordering key the
-        // generated code carries is dropped from it here.
-        : raw.map(stripOrdinal);
-      // Correlation is published, never applied. Both halves of a typo pair
-      // stay in the array; `related` only says they are one mistake, so a
-      // wrong pairing costs a sentence rather than a hidden violation.
-      if (enrich && cached.length > 1) attachRelated(cached);
-      // No diagnostic payload here. validate(data) is the library hot path,
-      // and attaching one cost about 100 ns per rejection for a consumer
-      // that never renders. The text path attaches it, and a renderer given
-      // `{ data }` builds frames for object input on request.
-      this._cached = cached;
+      this._cached = presentErrors(this._result.errors || [], this._data, this._rawInput, this._self, this._root, this._enrich);
     }
     return this._cached;
   },
 });
 
+
 // The rejection validateJSON returns. Everything the text path adds over
 // validate(data), the value tree enrichment needs, the position map, the
 // diagnostic payload, happens on first access to `.errors`. Reading `.valid`
@@ -172,7 +176,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 +250,26 @@ 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;
+  // Generated code keeps errors at a fixed path as frozen literals shared by
+  // every call. The caller gets its own copy, as it always has, so an error it
+  // edits (a translated message) is its own and editing it does not throw.
+  if (e._o === undefined && e.docUrl === undefined && (e.code === undefined || COLLAPSE_CODES.has(e.code)) && !e.branchErrors) return Object.isFrozen(e) ? { ...e } : 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 +280,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;
@@ -326,4 +371,4 @@ function attachRelated (errors) {
   return errors;
 }
 
-module.exports = { LazyRejection, RichRejection, LazyJsonRejection, _enrichLazy, attachRelated, sortErrorsBySchemaOrder, stripOrdinal, wantedPointersFor };
+module.exports = { LazyRejection, RichRejection, presentErrors, needsOrdering, LazyJsonRejection, _enrichLazy, attachRelated, sortErrorsBySchemaOrder, stripOrdinal, wantedPointersFor };

package/lib/render-pretty.js

@@ -42,7 +42,11 @@ function caretSuffix (d, raw, useColor) {
 function renderOne (d, useColor, opts) {
   const lines = [];
   const width = terminalWidth();
-  const gutter = 3;
+  // The bar sits one column past the widest line number, so the source line,
+  // the blank rows and the caret row share it and a caret lands on the first
+  // character of the value, not one column to its left.
+  const bar = (line) => ' '.repeat(Math.max(3, String(line).length + 1)) + '|';
+  const src = (line, text) => String(line).padStart(Math.max(2, String(line).length)) + ' | ' + text;
 
   // Headline carries the code when there is one. A code-less error, which the
   // LazyRejection fallback can produce, must not render as "error[undefined]".
@@ -57,12 +61,12 @@ function renderOne (d, useColor, opts) {
   if (raw && raw.schemaSource) {
     const f = trimCwd(raw.schemaSource.file, opts.cwd);
     lines.push(`  --> ${color(useColor, ANSI.cyan, `${f}:${raw.schemaSource.line}:${raw.schemaSource.col}`)}`);
-    lines.push('   |');
-    const sln = String(raw.schemaSource.line).padStart(2, ' ');
-    lines.push(` ${sln} | ${truncateLine(raw.schemaSource.text, width - 8)}`);
+    const sl = raw.schemaSource.line;
+    lines.push(bar(sl));
+    lines.push(src(sl, truncateLine(raw.schemaSource.text, width - 8)));
     const inlineHint = raw.expected ? '  ' + color(useColor, ANSI.dim, `expected ${raw.expected}`) : '';
-    lines.push(caretLine(raw.schemaSource.col, 1, gutter) + inlineHint);
-    lines.push('   |');
+    lines.push(caretLine(raw.schemaSource.col, 1, bar(sl).length - 1) + inlineHint);
+    lines.push(bar(sl));
   }
 
   // Data location, always, even without a frame. This is the single most
@@ -70,11 +74,11 @@ function renderOne (d, useColor, opts) {
   if (d.frame) {
     const where = `input:${d.frame.line}:${d.frame.col}`;
     lines.push(`  --> ${color(useColor, ANSI.cyan, where)}  ${color(useColor, ANSI.dim, '(' + d.dotted + ')')}`);
-    lines.push('   |');
-    const ln = String(d.frame.line).padStart(2, ' ');
-    lines.push(` ${ln} | ${truncateLine(d.frame.text, width - 8)}`);
-    lines.push(caretLine(d.frame.col, d.frame.length, gutter) + caretSuffix(d, raw, useColor));
-    lines.push('   |');
+    const fl = d.frame.line;
+    lines.push(bar(fl));
+    lines.push(src(fl, truncateLine(d.frame.text, width - 8)));
+    lines.push(caretLine(d.frame.col, d.frame.length, bar(fl).length - 1) + caretSuffix(d, raw, useColor));
+    lines.push(bar(fl));
   } else {
     lines.push(`  --> ${color(useColor, ANSI.cyan, 'at ' + d.dotted)}`);
   }