ata-validator 0.12.5 → 0.12.6

package/index.d.ts

@@ -140,8 +140,12 @@ export class Validator {
    */
   static bundleStandalone(schemas: object[], options?: BundleStandaloneOptions): string;
 
-  /** Bundle multiple schemas with deduplicated shared templates. Smaller output than bundle(). */
-  static bundleCompact(schemas: object[], options?: ValidatorOptions): string;
+  /**
+   * Bundle multiple schemas with deduplicated shared templates. Smaller output
+   * than bundle(). Accepts the same options as bundleStandalone, including
+   * `format: 'esm' | 'cjs'` and cross-schema `$ref` resolution.
+   */
+  static bundleCompact(schemas: object[], options?: BundleStandaloneOptions): string;
 
   /** Load a bundle created by Validator.bundle(). Returns array of Validator instances. */
   static loadBundle(mods: object[], schemas: object[], options?: ValidatorOptions): Validator[];

package/index.js

@@ -1187,10 +1187,12 @@ Validator.bundle = function (schemas, opts) {
 
 // Zero-dependency self-contained bundle — no require('ata-validator') needed at runtime.
 // opts.format: 'cjs' (default) or 'esm'.
+// opts.formats: { name: fn } — embedded in the output via Function#toString.
 Validator.bundleStandalone = function (schemas, opts) {
-  // Cross-schema $ref resolution: every Validator in the bundle needs to know
-  // about the others so $ref to a sibling $id can resolve at compile time.
-  const bundleOpts = { ...(opts || {}), schemas };
+  // Cross-schema $ref resolution: only meaningful when at least one schema has
+  // an $id. Skip the schemas-as-map plumbing when none of them do.
+  const haveIds = schemas.some((s) => s && typeof s === 'object' && s.$id);
+  const bundleOpts = haveIds ? { ...(opts || {}), schemas } : (opts || {});
   const format = (opts && opts.format) || 'cjs';
   const R = "Object.freeze({valid:true,errors:Object.freeze([])})";
   const fns = schemas.map((schema) => {
@@ -1201,12 +1203,25 @@ Validator.bundleStandalone = function (schemas, opts) {
     const jsErrFn = compileToJSCodegenWithErrors(
       typeof schema === "string" ? JSON.parse(schema) : schema,
       v._schemaMap,
+      v._userFormats,
     );
     const errBody =
       jsErrFn && jsErrFn._errSource
         ? jsErrFn._errSource
         : "return{valid:false,errors:[{code:'error',path:'',message:'validation failed'}]}";
-    return `(function(R){var E=function(d){var _all=true;${errBody}};return function(d){${jsFn._hybridSource}}})(R)`;
+    // Serialize custom format closures so the bundle has no runtime dep on ata.
+    let preamble = '';
+    if (jsFn._formatClosures) {
+      preamble = jsFn._formatClosures
+        .map(({ name, fn }) => `var ${name}=${fn.toString()};`)
+        .join('\n');
+    }
+    if (opts && opts.verbose) {
+      // Embed the schema and a small resolver so errors carry parentSchema.
+      const schemaLit = JSON.stringify(typeof schema === 'string' ? JSON.parse(schema) : schema);
+      return `(function(R){${preamble}var _S=${schemaLit};function _PS(p){if(!p||p[0]!=='#')return undefined;var s=p.slice(1);if(!s)return _S;var ps=s.split('/').filter(Boolean).map(function(x){return x.replace(/~1/g,'/').replace(/~0/g,'~')});var t=_S;for(var i=0;i<ps.length-1;i++){if(t==null||typeof t!=='object')return undefined;t=t[ps[i]]}return t}var E=function(d){var _all=true;${errBody}};var _v=function(d){${jsFn._hybridSource}};return function(d){var r=_v(d);if(r&&r.valid===false&&r.errors){var es=[];for(var i=0;i<r.errors.length;i++){var e=r.errors[i];es.push(Object.assign({},e,{parentSchema:_PS(e.schemaPath)}))}return{valid:false,errors:es}}return r}})(R)`;
+    }
+    return `(function(R){${preamble}var E=function(d){var _all=true;${errBody}};return function(d){${jsFn._hybridSource}}})(R)`;
   });
   const arr = `[${fns.join(",")}]`;
   if (format === 'esm') {
@@ -1217,15 +1232,20 @@ Validator.bundleStandalone = function (schemas, opts) {
 
 // Compact bundle: deduplicated code. Shared template functions + per-schema params.
 // Much smaller file → faster V8 parse → faster startup.
+// opts.format: 'cjs' (default) or 'esm'.
 Validator.bundleCompact = function (schemas, opts) {
+  const haveIds = schemas.some((s) => s && typeof s === 'object' && s.$id);
+  const bundleOpts = haveIds ? { ...(opts || {}), schemas } : (opts || {});
+  const format = (opts && opts.format) || 'cjs';
   // Analyze schemas and group by structure
   const entries = schemas.map((schema) => {
-    const v = new Validator(schema, opts);
+    const v = new Validator(schema, bundleOpts);
     v._ensureCompiled();
     const jsFn = v._jsFn;
     if (!jsFn || !jsFn._hybridSource) return null;
     const jsErrFn = compileToJSCodegenWithErrors(
       typeof schema === "string" ? JSON.parse(schema) : schema,
+      v._schemaMap,
     );
     return {
       hybrid: jsFn._hybridSource,
@@ -1260,31 +1280,38 @@ Validator.bundleCompact = function (schemas, opts) {
   });
 
   // Generate compact bundle
-  let out = "'use strict';\n";
-  out += "var R=Object.freeze({valid:true,errors:Object.freeze([])});\n";
+  const isEsm = format === 'esm';
+  let out = isEsm
+    ? "// Auto-generated by ata-validator — do not edit\n"
+    : "'use strict';\n";
+  const declKW = isEsm ? "const" : "var";
+  out += `${declKW} R=Object.freeze({valid:true,errors:Object.freeze([])});\n`;
 
   // Shared hybrid factories
-  out += "var H=[\n";
+  out += `${declKW} H=[\n`;
   out += bodies
     .map((b) => `function(R,E){return function(d){${b}}}`)
     .join(",\n");
   out += "\n];\n";
 
   // Shared error functions
-  out += "var EF=[\n";
+  out += `${declKW} EF=[\n`;
   out += errBodies.map((b) => `function(d){var _all=true;${b}}`).join(",\n");
   out += "\n];\n";
 
   // Build validators from shared templates
-  out += "module.exports=[";
-  out += indices
+  const arrBody = indices
     .map(([hi, ei]) => {
       if (hi < 0) return "null";
       if (ei >= 0) return `H[${hi}](R,EF[${ei}])`;
       return `H[${hi}](R,function(){return{valid:false,errors:[]}})`;
     })
     .join(",");
-  out += "];\n";
+  if (isEsm) {
+    out += `const validators=[${arrBody}];\nexport default validators;\nexport { validators };\n`;
+  } else {
+    out += `module.exports=[${arrBody}];\n`;
+  }
 
   return out;
 };

package/lib/js-compiler.js

@@ -946,6 +946,17 @@ function compileToJSCodegen(schema, schemaMap, userFormats) {
     boolFn._source = helperStr + body
     boolFn._preambleSource = preambleStr
     boolFn._hybridSource = helperStr + hybridBody
+    // Custom-format closure entries that the bundle output needs to recreate.
+    // Stored as { name, fn } so consumers can serialize via Function#toString.
+    if (ctx.userFormats) {
+      const fmtEntries = []
+      for (let i = 0; i < closureNames.length; i++) {
+        if (closureNames[i].startsWith('_uf_')) {
+          fmtEntries.push({ name: closureNames[i], fn: closureValues[i] })
+        }
+      }
+      if (fmtEntries.length) boolFn._formatClosures = fmtEntries
+    }
 
     return boolFn
   } catch {
@@ -2448,7 +2459,7 @@ function genCharCodeSwitch(keys, v) {
 // --- Error-collecting codegen: same checks, but pushes errors instead of returning false ---
 // Returns a function: (data, allErrors) => { valid, errors }
 // Valid path is still fast — only error path does extra work.
-function compileToJSCodegenWithErrors(schema, schemaMap) {
+function compileToJSCodegenWithErrors(schema, schemaMap, userFormats) {
   // Bail on unevaluated keywords — error codegen doesn't support them yet
   if (typeof schema === 'object' && schema !== null) {
     const s = JSON.stringify(schema)
@@ -2509,7 +2520,7 @@ function compileToJSCodegenWithErrors(schema, schemaMap) {
     }
   }
 
-  const ctx = { varCounter: 0, helperCode: [], rootDefs: eRootDefs, refStack: new Set(), schemaMap: schemaMap || null, anchors: eAnchors, rootSchema: schema }
+  const ctx = { varCounter: 0, helperCode: [], rootDefs: eRootDefs, refStack: new Set(), schemaMap: schemaMap || null, anchors: eAnchors, rootSchema: schema, userFormats: userFormats || null }
   ctx.helperCode.push('const _cpLen=s=>{let n=0;for(const _ of s)n++;return n}')
   const lines = []
   genCodeE(schema, 'd', '', lines, ctx, '#')
@@ -2733,15 +2744,23 @@ function genCodeE(schema, v, pathExpr, lines, ctx, schemaPrefix) {
   }
   if (schema.format) {
     const fc = FORMAT_CODEGEN[schema.format]
+    const failPush = `_e.push({keyword:'format',instancePath:${pathExpr||'""'},schemaPath:'${schemaPrefix}/format',params:{format:'${esc(schema.format)}'},message:'must match format "${esc(schema.format)}"'});if(!_all)return{valid:false,errors:_e}`
     // Format errors use the boolean codegen — just wrap with error push
     if (fc) {
       const ri = ctx.varCounter++
       const boolLines = []
       boolLines.push(fc(v, isStr))
       // Replace `return false` with error push in the format check
-      const fmtCode = boolLines.join(';').replace(/return false/g,
-        `{_e.push({keyword:'format',instancePath:${pathExpr||'""'},schemaPath:'${schemaPrefix}/format',params:{format:'${esc(schema.format)}'},message:'must match format "${esc(schema.format)}"'});if(!_all)return{valid:false,errors:_e}}`)
+      const fmtCode = boolLines.join(';').replace(/return false/g, `{${failPush}}`)
       lines.push(fmtCode)
+    } else if (ctx.userFormats && typeof ctx.userFormats[schema.format] === 'function') {
+      // User-supplied format checker on the error path. Same closure plumbing
+      // as the boolean codegen — but error codegen has no closure factory, so
+      // bundle output serializes the function via Function#toString separately.
+      const safeName = schema.format.replace(/[^a-zA-Z0-9_]/g, '_')
+      const closureName = `_uf_${safeName}`
+      const guard = isStr ? '' : `typeof ${v}==='string'&&`
+      lines.push(`if(${guard}!${closureName}(${v})){${failPush}}`)
     }
   }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ata-validator",
-  "version": "0.12.5",
+  "version": "0.12.6",
   "description": "Ultra-fast JSON Schema validator. 5x faster validation, 159,000x faster compilation. Works without native addon. Cross-schema $ref, Draft 2020-12 + Draft 7, V8-optimized JS codegen, simdjson, RE2, multi-core. Standard Schema V1 compatible.",
   "main": "index.js",
   "module": "index.mjs",