ata-validator 1.59.0 → 1.61.0

package/lib/aot-impl.js

@@ -367,7 +367,7 @@ function defaultsDecl(validator) {
   if (defaults.buildDefaultsApplier(schema) === null) return '';
   const embedded = require('./schema-strip').stripAnnotationsKeepingDefaults(schema);
   const text = JSON.stringify(JSON.stringify(embedded)).replace(/</g, '\\u003c');
-  return `const _ataDefaults = (function () {\nconst MAX_DEPTH = ${defaults.MAX_DEPTH};\n${require(AOT_ORDER_MODULE).take('defaults.js', defaults.EMBED)}\nreturn buildDefaultsApplier;\n})();\n` +
+  return `const _ataDefaults = (function () {\nconst MAX_DEPTH = ${defaults.MAX_DEPTH};\n${loadAotOrder().take('defaults.js', defaults.EMBED)}\nreturn buildDefaultsApplier;\n})();\n` +
     `let _ataFill;\nfunction applyDefaults(d) { (_ataFill || (_ataFill = _ataDefaults(JSON.parse(${text}))))(d); }\n`;
 }
 
@@ -379,20 +379,20 @@ function defaultsDecl(validator) {
 // the runtime accepts. Where the generated pass declines and the runtime
 // would change the data with its closure pass, there is nothing to carry it
 // in, and the bundle refuses. `useDefaults` alone runs applyDefaults.
-// Returns { decl, call }.
-function bundlePreprocess(validator, opts, fillDecl, label) {
+// Returns { decl, call }, the call naming the data parameter `arg`.
+function bundlePreprocess(validator, opts, fillDecl, label, arg = 'd') {
   const coerceTypes = opts && opts.coerceTypes ? opts.coerceTypes : false;
   const removeAdditional = opts && opts.removeAdditional ? opts.removeAdditional : false;
   const useDefaults = !!(opts && opts.useDefaults === true);
-  if (!coerceTypes && !removeAdditional) return { decl: '', call: useDefaults && fillDecl ? 'applyDefaults(d);' : '' };
+  if (!coerceTypes && !removeAdditional) return { decl: '', call: useDefaults && fillDecl ? `applyDefaults(${arg});` : '' };
   const internals = require('./validator-core')._internals;
   const schema = internals.resolveSchemaForPreprocess(validator._schemaObj, validator._schemaMap);
   let src = null;
   try { src = require('./codegen-engine').preprocessSource(schema, { coerceTypes, removeAdditional, useDefaults }); } catch { src = null; }
-  if (src !== null) return { decl: `function _ataPre(d) {\n${src}\n}\n`, call: '_ataPre(d);' };
+  if (src !== null) return { decl: `function _ataPre(d) {\n${src}\n}\n`, call: `_ataPre(${arg});` };
   const changes = (coerceTypes && internals.buildCoercer(schema) !== null) || (removeAdditional && internals.buildRemover(schema) !== null);
   if (changes) throw new Error(`${label}: ${coerceTypes ? 'coerceTypes' : 'removeAdditional'} cannot be compiled into a standalone module for this schema; validate with the runtime Validator`);
-  return { decl: '', call: useDefaults && fillDecl ? 'applyDefaults(d);' : '' };
+  return { decl: '', call: useDefaults && fillDecl ? `applyDefaults(${arg});` : '' };
 }
 
 function toStandaloneModule(validator, opts) {
@@ -408,6 +408,12 @@ function toStandaloneModule(validator, opts) {
   const source = !!(opts && opts.source);
   const sourceMap = opts && opts.sourceMap ? opts.sourceMap : null;
   const schemaFile = opts && opts.schemaFile ? opts.schemaFile : null;
+  // The validator's own coerceTypes and removeAdditional run before every
+  // check, as they do in the validator; a module used to leave them out and
+  // reject what the validator accepts. Defaults are not filled here: a module
+  // exports applyDefaults for that, and validate() leaves the data as it is.
+  const vopts = validator._options || {};
+  const pre = bundlePreprocess(validator, { coerceTypes: vopts.coerceTypes, removeAdditional: vopts.removeAdditional }, '', 'toStandaloneModule', 'data');
   const src = jsFn._source;
 
   let errCore = '';
@@ -452,7 +458,7 @@ function toStandaloneModule(validator, opts) {
     // sorts by each error site's ordinal, the collector writes it (`_o`).
     const schemaForErrors = typeof validator._schemaObj === 'object' ? validator._schemaObj : {};
     ordered = !!(opts && opts.order === true);
-    const noOrdinal = !ordered || !require(AOT_ORDER_MODULE).wantsOrdinals(schemaForErrors);
+    const noOrdinal = !ordered || !loadAotOrder().wantsOrdinals(schemaForErrors);
     jsErrFn = compileToJSCodegenWithErrors(
       schemaForErrors,
       null,
@@ -594,7 +600,7 @@ function toStandaloneModule(validator, opts) {
     compactCore = `let _ataErrs = null;\nfunction _ataErrors(d) { if (_ataErrs === null) _ataErrs = _ataCreateErrors(JSON.parse(${text})${rtOpts ? ', { ' + rtOpts + ' }' : ''}); return _ataErrs(d); }\n`;
   }
   const orderDecl = errCore && ordered && errorRuntime === null && onePass === null
-    ? require(AOT_ORDER_MODULE).orderDecl(validator._schemaObj)
+    ? loadAotOrder().orderDecl(validator._schemaObj)
     : '';
   // Asked for and not given: stub errors, the one-pass function, or no error
   // code generated. The caller is told rather than handed the collector's
@@ -636,7 +642,7 @@ function toStandaloneModule(validator, opts) {
   // reading patterns. A second declaration of that name shadowed it and the
   // prelude called this one instead, reaching _fn before its initialiser ran.
   const parseCore = cloneExpr
-    ? `function _ataParse(data) {\n  if (!_fn(data)) { const e = new Error('validation failed'); e.name = 'AtaValidationError'; throw e; }\n  return ${cloneExpr};\n}\n`
+    ? `function _ataParse(data) {\n  ${pre.call}if (!_fn(data)) { const e = new Error('validation failed'); e.name = 'AtaValidationError'; throw e; }\n  return ${cloneExpr};\n}\n`
     : '';
 
   // validateJSON(): parse the text, validate, and on failure attach a
@@ -725,25 +731,20 @@ const ABORT = Object.freeze({
 ${closureDecls}${sharedBlock}${preambleDecls}${formatDecls}const _fn = function(d) {
   ${src}
 };
-${errCore}${orderDecl}${compactCore}function isValid(data) { return _fn(data); }
-function validate(data) { ${validBody}; }
+${errCore}${orderDecl}${compactCore}${pre.decl}function isValid(data) { ${pre.call}return _fn(data); }
+function validate(data) { ${pre.call}${validBody}; }
 ${parseCore}${positionsCore}${fillDecl}${hashDecl}${exports}`;
 }
 
-// Why a validator cannot be written as a compact module, or null when it can.
-// The error runtime walks the embedded schema with the interpreted engine and
-// knows nothing the schema does not say, so anything the validator adds from
-// outside the schema keeps the module self-contained.
-// The error runtime's generator reads the library's own files with fs, and
-// runs in Node only (ata build, errorRuntimeSource). It is required through a
-// name rather than a literal so that a bundler following this module, in a
-// build of the package for a runtime without fs, does not try to bring fs
-// along: 1.49.0 bundled for such runtimes, and the generator must not break
-// that.
-const ERROR_RUNTIME_MODULE = './error-runtime';
-// Reads the library's files too, at build time (see lib/aot-order.js).
-const AOT_ORDER_MODULE = './aot-order';
-function loadErrorRuntime() { return require(ERROR_RUNTIME_MODULE); }
+// The error runtime and the order helpers are required by their literal
+// names: an executable compiled ahead of time (Bun) loads a module from a
+// computed path by throwing, and warns about every such require at build
+// time. Both modules read the library's own files with fs at build time;
+// a bundle for a runtime without fs is kept away from lib/aot-order.js by
+// the package's `browser` field, and lib/error-runtime.js loads fs only in
+// the functions that read files.
+function loadErrorRuntime() { return require('./error-runtime'); }
+function loadAotOrder() { return require('./aot-order'); }
 
 // The schema hash a module stamps, once per validator: a plugin writes both
 // modules of a schema (self-contained and compact) from one validator, and
@@ -967,7 +968,7 @@ function bundleStandalone(Validator, schemas, opts) {
     v._ensureCompiled();
     const jsFn = v._jsFn;
     if (!jsFn || !jsFn._hybridSource) return null;
-    const noOrdinal = !ordered || !require(AOT_ORDER_MODULE).wantsOrdinals(v._schemaObj);
+    const noOrdinal = !ordered || !loadAotOrder().wantsOrdinals(v._schemaObj);
     // The schema the validator compiled, not the one the caller passed. They
     // differ whenever anything prepared the schema: draft-07 normalization,
     // `format` removed under assertFormat: false, keywords outside the
@@ -1034,7 +1035,7 @@ function bundleStandalone(Validator, schemas, opts) {
     // In order: the collector's errors sorted as the runtime sorts them.
     const hasErr = !!(jsErrFn && jsErrFn._errSource);
     const errDecl = ordered && hasErr
-      ? `${require(AOT_ORDER_MODULE).orderDecl(v._schemaObj)}var E=function(d){var r=(function(d){var _all=true;${errBody}})(d);return r&&r.errors?{valid:false,errors:_ataOrder(r.errors)}:r};`
+      ? `${loadAotOrder().orderDecl(v._schemaObj)}var E=function(d){var r=(function(d){var _all=true;${errBody}})(d);return r&&r.errors?{valid:false,errors:_ataOrder(r.errors)}:r};`
       : `var E=function(d){var _all=true;${errBody}};`;
     if (opts && opts.verbose) {
       // Embed the schema and a small resolver so errors carry parentSchema.