ata-validator 1.60.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`;
 }
 
@@ -458,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,
@@ -600,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
@@ -736,20 +736,15 @@ 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
@@ -973,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
@@ -1040,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.