ata-validator 1.46.1 → 1.48.0

package/lib/native-load.js

@@ -1,4 +1,5 @@
 'use strict';
+const { env } = require('./env');
 
 // Locate the optional native engine. Resolution order:
 //   1. ATA_NO_NATIVE set        -> null (explicit pure-JS mode)
@@ -36,6 +37,12 @@ function detectMusl() {
   }
 }
 
+// The require of the platform package is of a computed name on purpose. A
+// literal require of each of the seven packages was tried: at most one of
+// them is installed on any machine, and a bundler that bundles the Node
+// entry (esbuild, bun, webpack) fails to resolve the other six and stops.
+// A supply-chain scanner reports a computed require as dynamic loading;
+// this is what it loads, and nothing else is ever required by name here.
 let warned = false;
 function checkVersion(binding, source) {
   if (!binding) return null;
@@ -58,7 +65,7 @@ function checkVersion(binding, source) {
 }
 
 module.exports = function loadNative() {
-  if (process.env.ATA_NO_NATIVE) return null;
+  if (env('ATA_NO_NATIVE')) return null;
 
   const isMusl = process.platform === 'linux' ? detectMusl() : false;
   const candidates = [];
@@ -80,6 +87,8 @@ module.exports = function loadNative() {
 
   // Contributors running from a source checkout.
   try {
+    // Not a literal path for the same reason: the file is absent from the
+    // published package and a bundler must not try to resolve it.
     const path = require('path');
     const binding = checkVersion(
       require(path.join(__dirname, '..', 'build', 'Release', 'ata.node')),

package/lib/rejections.js

@@ -84,17 +84,16 @@ class RichRejection {
 // 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();
-  }
+  // The position map, resolved on the first read of an error's frame (see
+  // defineLazyFrames in lib/enrich-error.js): a walk of the document that a
+  // caller reading messages and paths never needs.
+  const lazyPositions = enrich && raw.length && rawInput != null ? lazyPositionsFor(self, rawInput, raw) : null;
   // One options object for the whole list, not one per error.
   const opts = enrich && raw.length
     ? {
         data,
-        positions,
+        positions: null,
+        lazyPositions,
         schemaPositions: self._schemaPositions,
         schemaFile: self._source ? self._source.path : undefined,
       }
@@ -180,13 +179,16 @@ Object.defineProperty(LazyJsonRejection.prototype, 'errors', {
     // on raw errors; taking it as the signal left those errors without
     // `received` or a suggestion on the text path while validate() had both.
     if (!raw[0] || !('received' in raw[0])) {
-      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 = needsOrdering(raw) ? sortErrorsBySchemaOrder(self._schemaObj, raw) : raw;
+      // The position map waits for the first read of a frame (lib/enrich-error
+      // defineLazyFrames); until then reading the list costs the enrichment alone.
+      const lazyPositions = lazyPositionsFor(self, jsonStr, ordered);
       const enrichOpts = {
         data: parsedData,
-        positions,
+        positions: null,
+        lazyPositions,
         schemaPositions: self._schemaPositions,
         schemaFile: self._source ? self._source.path : undefined,
       };
@@ -195,11 +197,11 @@ Object.defineProperty(LazyJsonRejection.prototype, 'errors', {
       attachDiagnosticSource(enriched, {
         data: parsedData,
         text: jsonStr,
-        positions,
+        // Read by the diagnostic renderer only, which resolves the same map.
+        get positions () { return lazyPositions(); },
         schema: self._schemaObj,
         mutatesInput: self._mutatesInput === true,
       });
-      if (positions) self._posCache.reset();
       this._cached = enriched;
       return enriched;
     }
@@ -232,6 +234,20 @@ Object.defineProperty(LazyJsonRejection.prototype, 'errors', {
   },
 });
 
+// The targeted position map for a list, built on the first call and shared
+// by every error's frame accessor (lib/enrich-error defineLazyFrames).
+function lazyPositionsFor (self, text, errors) {
+  let done = false;
+  let positions = null;
+  return () => {
+    if (done) return positions;
+    done = true;
+    positions = self._pos().targeted(text, wantedPointersFor(errors));
+    if (positions) self._posCache.reset();
+    return positions;
+  };
+}
+
 // The pointers a set of errors will ask the position map about. lib/enrich-error
 // looks up the error's own path, and for an additional or unevaluated property
 // the child pointer named in `params`, unescaped, which is the form it asks for.

package/lib/scan-compiler.js

@@ -1,4 +1,5 @@
 'use strict';
+const { compileFunction } = require('./compile-fn');
 
 // A schema-directed scanner: it answers the verdict from the JSON text without
 // building the document. `JSON.parse` is three quarters of the cost of a real
@@ -436,7 +437,7 @@ function finish(built, opts) {
   let fn;
   try {
     // eslint-disable-next-line no-new-func
-    fn = new Function('_h', '_r', ctx.subSource.join('\n') + '\nreturn function scan(s){\n' + body + '\n}')(ctx.helpers, require('./scan-runtime'));
+    fn = compileFunction('_h', '_r', ctx.subSource.join('\n') + '\nreturn function scan(s){\n' + body + '\n}')(ctx.helpers, require('./scan-runtime'));
   } catch {
     return null; // a runtime without code generation has no scanner, by design
   }
@@ -891,7 +892,7 @@ function emitArray(schema, ctx, out, depth) {
 // Every `return 0` inside the member becomes that record, which is also how
 // the rule reaches nested objects: an inner object's own verdict is a value
 // failure at the level above it.
-function emitMember(sub, ctx, out, depth, objId) {
+function emitMember(sub, ctx, out, depth, objId, kn) {
   let lines = [];
   emitValue(sub, ctx, lines, depth + 1);
   // A large member value becomes a function of its own, so no one function
@@ -920,9 +921,17 @@ function emitMember(sub, ctx, out, depth, objId) {
   out.push(label + ':{');
   out.push(body.split('return 0;').join('{_f' + objId + '=2;break ' + label + ';}'));
   out.push('}');
-  // Resync from where the value started: a scan that stopped partway through
-  // one cannot say where it ends, and the skipper can.
-  out.push('if(_f' + objId + '===2){_f' + objId + '=1;i=_r.skipValue(s,_vs' + label + ');if(i<0)return 0;c=s.charCodeAt(i);}');
+  // A failed member is the verdict unless this object repeats the key later,
+  // since the parser keeps the last value. Whether it can is answered by two
+  // native searches over the rest of the text, for the key as written and
+  // for any backslash, which is the only way to spell that key differently:
+  // when neither is there the scan ends here, and a 69 KB body with a bad
+  // first item is refused in the time of an indexOf rather than a full pass.
+  // Otherwise resync from where the value started, since a scan that stopped
+  // partway through one cannot say where it ends and the skipper can, and
+  // go on, so a repeat still bails to the parser.
+  out.push('if(_f' + objId + '===2){if(s.indexOf(s.slice(_p' + kn + '-1,_e' + kn + '+1),i)<0&&s.indexOf("\\\\",i)<0)return 0;');
+  out.push('_f' + objId + '=1;i=_r.skipValue(s,_vs' + label + ');if(i<0)return 0;c=s.charCodeAt(i);}');
 }
 
 function emitObject(schema, ctx, out, depth) {
@@ -1110,7 +1119,7 @@ function emitObject(schema, ctx, out, depth) {
       const cond = gi === bounds.length - 1 ? '' : 'if(_kid' + kn + '<' + g.end + ')';
       out.push((gi === 0 ? '' : 'else ') + cond + '{');
       if (g.sub === undefined) out.push(addH);
-      else emitMember(g.sub, ctx, out, depth, n);
+      else emitMember(g.sub, ctx, out, depth, n, kn);
       out.push('}');
       prev = g.end;
     });
@@ -1159,7 +1168,7 @@ function emitObject(schema, ctx, out, depth) {
       out.push('_s' + n + '_' + slot.w + '|=' + slot.b + ';');
       const sub = props && Object.prototype.hasOwnProperty.call(props, name) ? props[name] : undefined;
       if (sub === undefined) out.push(additional.join('\n'));
-      else emitMember(sub, ctx, out, depth, n);
+      else emitMember(sub, ctx, out, depth, n, kn);
       out.push('}');
     }
     out.push('else{' + additional.join('\n') + '}');

package/lib/validator-core.js

@@ -10,6 +10,8 @@ function getNative() {
   if (_nativeMod === undefined) _nativeMod = require("./native-load")();
   return _nativeMod;
 }
+const { env } = require('./env');
+const { compileFunction } = require('./compile-fn');
 const { normalizeKeywords, schemaUsesKeywords } = require('./keywords');
 // The code generator (lib/js-compiler and what builds on it: the scanner, the
 // parse() copy, the ahead-of-time emitters) is registered by the entry that
@@ -207,7 +209,7 @@ function codegenAvailable() {
   if (_codegen === null) return false;
   if (_codegenAvailable === null) {
     try {
-      _codegenAvailable = new Function('return 1')() === 1;
+      _codegenAvailable = compileFunction('return 1')() === 1;
     } catch {
       _codegenAvailable = false;
     }
@@ -880,7 +882,7 @@ class Validator {
     // Check cache first -- reuse compiled functions for same schema
     const sm = this._schemaMap.size > 0 ? this._schemaMap : null;
     const mapKey = compileCacheKey(this._schemaStr, this._schemaMap);
-    var _forceNapi = this._interpretOnly || (typeof process !== 'undefined' && process.env && process.env.ATA_FORCE_NAPI);
+    var _forceNapi = this._interpretOnly || env('ATA_FORCE_NAPI');
     // Custom formats are JS functions: bypass the compile cache since they can
     // differ between validators that share the same schema string. An
     // interpreter-only validator never touches it either way: a function a
@@ -1584,7 +1586,7 @@ class Validator {
       return;
     }
     this._ensureVocabularies();
-    if (this._interpretOnly || _codegen === null || (typeof process !== 'undefined' && process.env && process.env.ATA_FORCE_NAPI)) return;
+    if (this._interpretOnly || _codegen === null || env('ATA_FORCE_NAPI')) return;
     _codegen.compileVerdict.call(this);
   }
 
@@ -1800,8 +1802,12 @@ Validator.loadBundle = function (mods, schemas, opts) {
 // simdjson when the addon is there, JSON.parse otherwise; the addon loads on
 // the first call rather than when the package is required.
 function parseJSON(input) {
+  // The addon has not carried parseJSON since the per-platform packages
+  // (1.1.0); the call threw a TypeError whenever the engine was loaded and
+  // returned JSON.parse's answer otherwise. A Buffer is decoded first.
   const native = getNative();
-  return native ? native.parseJSON(input) : JSON.parse(input);
+  if (native && typeof native.parseJSON === 'function') return native.parseJSON(input);
+  return JSON.parse(typeof input === 'string' ? input : String(input));
 }
 
 // Ultra-fast compile: returns validate function directly, no Validator wrapper

package/lib/version.js

@@ -7,4 +7,4 @@
 //
 // Kept in lockstep with package.json by `tests/test_version_sync.js`.
 
-module.exports = '1.46.1';
+module.exports = '1.48.0';

package/lite.d.ts

@@ -0,0 +1,12 @@
+// ata-validator/lite: the same Validator and one-shot functions as
+// ata-validator, on the interpreted engine and without the code generator.
+// Validator#parse and the static bundle methods throw a TypeError here.
+export {
+  Validator,
+  validate,
+  validateAsync,
+  parseAsync,
+  defineSchema,
+  version,
+} from './index.js';
+export type * from './index.js';

package/lite.js

@@ -0,0 +1,20 @@
+'use strict';
+
+// ata-validator/lite: the Validator without the code generator. Every schema
+// runs on the interpreted engine, which passes the same official test suite as
+// the compiled path and never calls `new Function`, so it also runs under a
+// strict Content-Security-Policy. The results are the ones `ata-validator`
+// gives: the same verdicts, the same errors. What it leaves out is what needs
+// the code generator (parse(), the ahead-of-time bundle methods) and the tools
+// no Validator calls (TypeScript generation, the renderers). Made for pages
+// where the size of what ships matters more than nanoseconds per call.
+const core = require('./lib/validator-core.js');
+
+module.exports = {
+  Validator: core.Validator,
+  validate: core.validate,
+  validateAsync: core.validateAsync,
+  parseAsync: core.parseAsync,
+  defineSchema: core.defineSchema,
+  version: core.version,
+};

package/lite.mjs

@@ -0,0 +1,3 @@
+import mod from './lite.js';
+export const { Validator, validate, validateAsync, parseAsync, defineSchema, version } = mod;
+export default mod;

package/package.json

@@ -1,7 +1,8 @@
 {
   "name": "ata-validator",
-  "version": "1.46.1",
+  "version": "1.48.0",
   "description": "JSON Schema validator that compiles to plain JavaScript, still runs where code generation is blocked, and can be compiled away at build time. Passes the full official test suite.",
+  "type": "commonjs",
   "main": "index.js",
   "module": "index.mjs",
   "types": "index.d.ts",
@@ -48,6 +49,11 @@
       "import": "./compiled-verdict.mjs",
       "require": "./compiled-verdict.js"
     },
+    "./lite": {
+      "types": "./lite.d.ts",
+      "import": "./lite.mjs",
+      "require": "./lite.js"
+    },
     "./package.json": "./package.json"
   },
   "sideEffects": false,
@@ -138,18 +144,21 @@
     "compiled-verdict.js",
     "compiled-verdict.mjs",
     "compiled-verdict.d.ts",
+    "lite.js",
+    "lite.mjs",
+    "lite.d.ts",
     "bin/",
     "README.md",
     "LICENSE"
   ],
   "optionalDependencies": {
-    "@ata-validator/native-darwin-arm64": "1.46.1",
-    "@ata-validator/native-darwin-x64": "1.46.1",
-    "@ata-validator/native-linux-arm64-gnu": "1.46.1",
-    "@ata-validator/native-linux-arm64-musl": "1.46.1",
-    "@ata-validator/native-linux-x64-gnu": "1.46.1",
-    "@ata-validator/native-linux-x64-musl": "1.46.1",
-    "@ata-validator/native-win32-x64": "1.46.1"
+    "@ata-validator/native-darwin-arm64": "1.48.0",
+    "@ata-validator/native-darwin-x64": "1.48.0",
+    "@ata-validator/native-linux-arm64-gnu": "1.48.0",
+    "@ata-validator/native-linux-arm64-musl": "1.48.0",
+    "@ata-validator/native-linux-x64-gnu": "1.48.0",
+    "@ata-validator/native-linux-x64-musl": "1.48.0",
+    "@ata-validator/native-win32-x64": "1.48.0"
   },
   "peerDependencies": {
     "yaml": "^2.0.0"