ata-validator 0.12.4 → 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

@@ -496,6 +496,50 @@ function collectDefs(schema) {
   return defs
 }
 
+// Walk a JSON-pointer fragment ("/foo/bar/0") into a schema object.
+// Returns the target node, or null if any segment is missing.
+function walkJsonPointer(root, fragment) {
+  if (!fragment || fragment === '/' || fragment === '#') return root
+  const path = fragment.startsWith('#') ? fragment.slice(1) : fragment
+  if (!path.startsWith('/')) return null
+  const parts = path.split('/').slice(1).map(s => s.replace(/~1/g, '/').replace(/~0/g, '~'))
+  let target = root
+  for (const p of parts) {
+    if (target == null || typeof target !== 'object') return null
+    target = target[p]
+  }
+  return target == null ? null : target
+}
+
+// Resolve a cross-schema $ref of the form "<id>#/<json-pointer>" (or just "<id>").
+// Returns { schema, fullId } where fullId is the resolved $id of the host schema.
+function resolveCrossSchemaRef(ref, schemaMap) {
+  if (!schemaMap) return null
+  const hashIdx = ref.indexOf('#')
+  const baseId = hashIdx >= 0 ? ref.slice(0, hashIdx) : ref
+  const fragment = hashIdx >= 0 ? ref.slice(hashIdx) : ''
+  if (!baseId) return null
+
+  let baseSchema = null
+  let fullId = null
+  if (schemaMap.has(baseId)) {
+    baseSchema = schemaMap.get(baseId)
+    fullId = baseId
+  } else if (!ref.includes('://')) {
+    for (const [id] of schemaMap) {
+      if (id.endsWith('/' + baseId)) {
+        baseSchema = schemaMap.get(id)
+        fullId = id
+        break
+      }
+    }
+  }
+  if (!baseSchema) return null
+  const target = fragment ? walkJsonPointer(baseSchema, fragment) : baseSchema
+  if (target == null) return null
+  return { schema: target, fullId }
+}
+
 function resolveRef(ref, defs, schemaMap) {
   // Self-reference: "#" — treat as permissive to avoid infinite recursion
   if (ref === '#') return () => true
@@ -520,7 +564,15 @@ function resolveRef(ref, defs, schemaMap) {
     const fn = compileToJS(resolved, null, schemaMap)
     return fn || (() => true)
   }
-  // 3. Cross-schema ref (relative URI resolution)
+  // 3. Cross-schema ref with JSON pointer fragment ("<id>#/<path>")
+  if (schemaMap && ref.includes('#')) {
+    const r = resolveCrossSchemaRef(ref, schemaMap)
+    if (r) {
+      const fn = compileToJS(r.schema, null, schemaMap)
+      return fn || (() => true)
+    }
+  }
+  // 4. Cross-schema ref (relative URI resolution, no fragment)
   if (schemaMap && !ref.includes('://') && !ref.startsWith('#')) {
     for (const [id] of schemaMap) {
       if (id.endsWith('/' + ref)) {
@@ -652,6 +704,11 @@ function codegenSafe(schema, schemaMap) {
         if (id.endsWith('/' + schema.$ref)) { isResolvable = true; resolvedTarget = schemaMap.get(id); break }
       }
     }
+    // Cross-schema ref with JSON pointer fragment: "<id>#/<path>"
+    if (!isLocal && !isResolvable && schemaMap && schema.$ref.includes('#') && !schema.$ref.startsWith('#')) {
+      const r = resolveCrossSchemaRef(schema.$ref, schemaMap)
+      if (r) { isResolvable = true; resolvedTarget = r.schema }
+    }
     // Anchor-style ref: #name (not #/path, not bare #) — resolvable at compile time via anchors map
     const isAnchorRef = !isLocal && !isResolvable && schema.$ref.length > 1 && schema.$ref.startsWith('#') && !schema.$ref.startsWith('#/')
     if (!isLocal && !isResolvable && !isAnchorRef) return false
@@ -889,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 {
@@ -1093,13 +1161,17 @@ function genCode(schema, v, lines, ctx, knownType) {
         }
       }
     } else if (schema.$ref !== '#' && ctx.schemaMap) {
-      // 2. Cross-schema ref (exact match or relative URI)
+      // 2. Cross-schema ref (exact match, relative URI, or JSON pointer fragment)
       let resolved = ctx.schemaMap.get(schema.$ref)
       if (!resolved && !schema.$ref.includes('://') && !schema.$ref.startsWith('#')) {
         for (const [id, s] of ctx.schemaMap) {
           if (id.endsWith('/' + schema.$ref)) { resolved = s; break }
         }
       }
+      if (!resolved && schema.$ref.includes('#') && !schema.$ref.startsWith('#')) {
+        const r = resolveCrossSchemaRef(schema.$ref, ctx.schemaMap)
+        if (r) resolved = r.schema
+      }
       if (resolved) {
         if (ctx.refStack.has(schema.$ref)) { if (!hasSiblings) return }
         else {
@@ -2387,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)
@@ -2448,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, '#')
@@ -2516,6 +2588,17 @@ function genCodeE(schema, v, pathExpr, lines, ctx, schemaPrefix) {
       ctx.refStack.delete(schema.$ref)
       return
     }
+    // Cross-schema ref with JSON pointer fragment ("<id>#/<path>")
+    if (ctx.schemaMap && schema.$ref.includes('#') && !schema.$ref.startsWith('#')) {
+      const r = resolveCrossSchemaRef(schema.$ref, ctx.schemaMap)
+      if (r) {
+        if (ctx.refStack.has(schema.$ref)) return
+        ctx.refStack.add(schema.$ref)
+        genCodeE(r.schema, v, pathExpr, lines, ctx, schemaPrefix)
+        ctx.refStack.delete(schema.$ref)
+        return
+      }
+    }
   }
 
   // $dynamicRef — resolve via anchors map
@@ -2661,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}}`)
     }
   }
 
@@ -3022,6 +3113,17 @@ function genCodeC(schema, v, pathExpr, lines, ctx, schemaPrefix) {
       ctx.refStack.delete(schema.$ref)
       return
     }
+    // Cross-schema ref with JSON pointer fragment ("<id>#/<path>")
+    if (ctx.schemaMap && schema.$ref.includes('#') && !schema.$ref.startsWith('#')) {
+      const r = resolveCrossSchemaRef(schema.$ref, ctx.schemaMap)
+      if (r) {
+        if (ctx.refStack.has(schema.$ref)) return
+        ctx.refStack.add(schema.$ref)
+        genCodeC(r.schema, v, pathExpr, lines, ctx, schemaPrefix)
+        ctx.refStack.delete(schema.$ref)
+        return
+      }
+    }
   }
 
   // $dynamicRef — resolve via anchors map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ata-validator",
-  "version": "0.12.4",
+  "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",