@ata-project/unplugin 0.2.0 → 0.3.0

package/README.md

@@ -183,9 +183,13 @@ A call is replaced only when all of this is true, and left to the runtime
 otherwise:
 
 - `Validator` is a named import from `ata-validator`;
-- the call has one argument, and it is an object literal, a top-level `const`
-  bound to one, the default import of a relative `.json` file, or
-  `defineSchema(...)` around one of those;
+- the schema argument is an object literal, a top-level `const` bound to one,
+  the default import of a relative `.json` file, or `defineSchema(...)` around
+  one of those;
+- there is no second argument, or it is `{ useDefaults: false }` (or
+  `{ useDefaults: true }`), written as a literal or a top-level `const`; that
+  one option needs ata-validator 1.37.0, and older versions keep such calls on
+  the runtime;
 - the result goes into a `const` that is not exported and is only used as
   `name.validate(...)`, `name.isValidObject(...)`, `name.validateJSON(...)` or
   `name.isValidJSON(...)`;
@@ -193,7 +197,7 @@ otherwise:
   `errorMessage`s and shapes its code generator cannot express, which the
   runtime answers with its interpreted engine.
 
-Anything with options (`new Validator(schema, { coerceTypes: true })`), a schema
+Any other option (`new Validator(schema, { coerceTypes: true })`), a schema
 built at run time, or an instance passed around stays as written.
 
 ## How it works

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ata-project/unplugin",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "Compile JSON, JS and TS schema files to ata-validator standalone modules at build time, in Vite, Webpack, Rollup, Rolldown, esbuild and Rspack.",
   "type": "module",
   "main": "./src/index.js",
@@ -78,7 +78,7 @@
   },
   "devDependencies": {
     "@rspack/core": "^1.7.0",
-    "ata-validator": "^1.36.0",
+    "ata-validator": "^1.37.0",
     "esbuild": "^0.28.0",
     "rolldown": "^1.2.8",
     "rollup": "^4.60.0",

package/src/compile-away.js

@@ -185,8 +185,24 @@ function inlineModule(src, index) {
   return `const __ataCompiled${index} = (() => {\n${body}\nreturn { validate, isValid };\n})();\n`
 }
 
+// The options of `new Validator(schema, options)` as a third argument for
+// fromCompiled(), or NOT_STATIC when the call has to stay on the runtime: options
+// that are not a literal the build can read, or that name anything this
+// ata-validator's wrapper does not reproduce. `useDefaults: true` is the default
+// and needs no argument.
+function compiledOptionsArg(node, ctx, supported) {
+  const opts = staticValue(node, ctx)
+  if (opts === NOT_STATIC || opts === null || typeof opts !== 'object' || Array.isArray(opts)) return NOT_STATIC
+  for (const [key, value] of Object.entries(opts)) {
+    if (!supported.includes(key)) return NOT_STATIC
+    if (key === 'useDefaults' && typeof value !== 'boolean') return NOT_STATIC
+  }
+  return opts.useDefaults === false ? '{"useDefaults":false}' : ''
+}
+
 export function compileAway(code, id, ata) {
   const { compiledModuleFor, compiledSchemaFor } = ata
+  const supportedOptions = Array.isArray(ata.compiledOptions) ? ata.compiledOptions : []
   if (!code.includes('ata-validator')) return null
   let ast
   try {
@@ -221,7 +237,13 @@ export function compileAway(code, id, ata) {
   for (const r of refs) {
     if (r.node.name !== validatorName) continue
     const expr = r.parent
-    if (!expr || expr.type !== 'NewExpression' || r.key !== 'callee' || expr.arguments.length !== 1) continue
+    if (!expr || expr.type !== 'NewExpression' || r.key !== 'callee') continue
+    if (expr.arguments.length !== 1 && expr.arguments.length !== 2) continue
+    let optionsArg = ''
+    if (expr.arguments.length === 2) {
+      optionsArg = compiledOptionsArg(expr.arguments[1], ctx, supportedOptions)
+      if (optionsArg === NOT_STATIC) continue
+    }
     if (!replaceableBinding(expr, ctx)) continue
     const schema = staticValue(expr.arguments[0], ctx)
     if (schema === NOT_STATIC || schema === null || typeof schema !== 'object' || Array.isArray(schema)) continue
@@ -230,7 +252,7 @@ export function compileAway(code, id, ata) {
     if (!src) continue
     const index = modules.length
     modules.push(inlineModule(src, index))
-    s.overwrite(expr.start, expr.end, `__ataFromCompiled(__ataCompiled${index}, ${JSON.stringify(compiledSchemaFor(schema))})`)
+    s.overwrite(expr.start, expr.end, `__ataFromCompiled(__ataCompiled${index}, ${JSON.stringify(compiledSchemaFor(schema))}${optionsArg ? ', ' + optionsArg : ''})`)
     done.add(expr)
   }
   if (done.size === 0) return null

package/src/core.js

@@ -69,6 +69,9 @@ async function loadAta() {
     toStandaloneModule: build.toStandaloneModule,
     compiledModuleFor: canCompileAway ? build.compiledModuleFor : null,
     compiledSchemaFor: canCompileAway ? build.compiledSchemaFor : null,
+    // The Validator options fromCompiled() reproduces, from ata-validator
+    // 1.37.0; before it, only calls without options are replaced.
+    compiledOptions: canCompileAway && Array.isArray(build.compiledOptions) ? build.compiledOptions : [],
   }
 }