watr 4.7.2 → 5.0.0

package/src/template.js

@@ -19,6 +19,24 @@ import { resultType } from './const.js'
 /** Private Use Area character as placeholder for interpolation */
 const PUA = '\uE000'
 
+/**
+ * Apply a backend transform (`polyfill`/`optimize`), or throw an actionable
+ * pointer when this entry doesn't bundle it. The default `watr` build wires a
+ * lean backend (parse + compile) and leaves the heavy transforms to their own
+ * entries, so `compile(src, { optimize })` here directs you to compose instead.
+ *
+ * @param {Function|undefined} fn - transform from the backend
+ * @param {string} name - 'polyfill' | 'optimize'
+ * @param {Array} ast
+ * @param {any} opt - the option value
+ * @returns {Array} transformed AST
+ */
+function applyTransform(fn, name, ast, opt) {
+  if (typeof fn !== 'function')
+    throw Error(`watr: '${name}' is not bundled in this entry \u2014 import it from 'watr/${name}' and compose: compile(${name}(src))`)
+  return fn(ast, opt)
+}
+
 /**
  * Infer type of an expression AST node.
  * Used for auto-import parameter type inference.
@@ -209,9 +227,9 @@ export function compile(backend, source, values) {
       }
     }
 
-    // Apply transforms
-    if (opts.polyfill) ast = polyfill(ast, opts.polyfill)
-    if (opts.optimize) ast = optimize(ast, opts.optimize)
+    // Apply transforms (heavy passes live in separate entries — see applyTransform)
+    if (opts.polyfill) ast = applyTransform(polyfill, 'polyfill', ast, opts.polyfill)
+    if (opts.optimize) ast = applyTransform(optimize, 'optimize', ast, opts.optimize)
 
     const binary = emit(ast)
     // Attach imports for watr() to use
@@ -222,8 +240,8 @@ export function compile(backend, source, values) {
   // String/AST source with options
   if (opts.polyfill || opts.optimize) {
     let ast = typeof source === 'string' ? parse(source) : source
-    if (opts.polyfill) ast = polyfill(ast, opts.polyfill)
-    if (opts.optimize) ast = optimize(ast, opts.optimize)
+    if (opts.polyfill) ast = applyTransform(polyfill, 'polyfill', ast, opts.polyfill)
+    if (opts.optimize) ast = applyTransform(optimize, 'optimize', ast, opts.optimize)
     return emit(ast)
   }
   return emit(source)

package/types/src/template.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"template.d.ts","sourceRoot":"","sources":["../../src/template.js"],"names":[],"mappings":"AA4HA;;;;;;;;;;GAUG;AACH,8CAPW,MAAM,WAAO,oBAAoB,UACjC,GAAG,EAAE,GAIH,UAAU,CAgGtB;AAED;;;;;;;GAOG;AACH,2CAJW,MAAM,WAAO,oBAAoB,UACjC,GAAG,EAAE,GACH,WAAW,CAAC,OAAO,CAO/B"}
+{"version":3,"file":"template.d.ts","sourceRoot":"","sources":["../../src/template.js"],"names":[],"mappings":"AA8IA;;;;;;;;;;GAUG;AACH,8CAPW,MAAM,WAAO,oBAAoB,UACjC,GAAG,EAAE,GAIH,UAAU,CAgGtB;AAED;;;;;;;GAOG;AACH,2CAJW,MAAM,WAAO,oBAAoB,UACjC,GAAG,EAAE,GACH,WAAW,CAAC,OAAO,CAO/B"}

package/types/watr.d.ts

@@ -17,18 +17,17 @@ export function watr(source: string | TemplateStringsArray, ...values: any[]): W
  *
  * @param {string|TemplateStringsArray} source - WAT source or template strings
  * @param {...any} values - Interpolation values (for template literal).
- *   Last value can be an options object: { polyfill, optimize }.
  * @returns {Uint8Array} WebAssembly binary
  *
  * @example
  * compile('(func (export "f") (result i32) (i32.const 42))')
  * compile`(func (export "f") (result f64) (f64.const ${Math.PI}))`
- * compile(src, { polyfill: true, optimize: true })
+ * // transforms ship as separate entries — compose them:
+ * // import optimize from 'watr/optimize'
+ * // compile(optimize(src))
  */
 export function compile(source: string | TemplateStringsArray, ...values: any[]): Uint8Array;
 import parse from './src/parse.js';
 import print from './src/print.js';
-import _polyfill from './src/polyfill.js';
-import _optimize from './src/optimize.js';
-export { parse, print, _polyfill as polyfill, _optimize as optimize };
+export { parse, print };
 //# sourceMappingURL=watr.d.ts.map

package/types/watr.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"watr.d.ts","sourceRoot":"","sources":["../watr.js"],"names":[],"mappings":";AAiCA;;;;;;;;;;;GAWG;AACH,6BATW,MAAM,GAAC,oBAAoB,aACxB,GAAG,EAAA,GACJ,WAAW,CAAC,OAAO,CAS/B;AA/BD;;;;;;;;;;;;GAYG;AACH,gCAVW,MAAM,GAAC,oBAAoB,aACxB,GAAG,EAAA,GAEJ,UAAU,CAStB;kBAxBiB,gBAAgB;kBAChB,gBAAgB;sBACZ,mBAAmB;sBACnB,mBAAmB"}
+{"version":3,"file":"watr.d.ts","sourceRoot":"","sources":["../watr.js"],"names":[],"mappings":";AAoCA;;;;;;;;;;;GAWG;AACH,6BATW,MAAM,GAAC,oBAAoB,aACxB,GAAG,EAAA,GACJ,WAAW,CAAC,OAAO,CAS/B;AAhCD;;;;;;;;;;;;;GAaG;AACH,gCAXW,MAAM,GAAC,oBAAoB,aACxB,GAAG,EAAA,GACJ,UAAU,CAWtB;kBA3BiB,gBAAgB;kBAChB,gBAAgB"}

package/watr.js

@@ -7,25 +7,28 @@
 import _compile from './src/compile.js'
 import parse from './src/parse.js'
 import print from './src/print.js'
-import _polyfill from './src/polyfill.js'
-import _optimize from './src/optimize.js'
 import { compile as _tcompile, watr as _twatr } from './src/template.js'
 
-/** JS-source backend primitives for the tagged-template layer. */
-const backend = { parse, compile: _compile, optimize: _optimize, polyfill: _polyfill }
+/** JS-source backend primitives for the tagged-template layer.
+ *  `polyfill` and `optimize` are intentionally NOT wired here — they're heavy
+ *  (the optimizer alone is ~5× the core encoder) and ship as separate entries,
+ *  `watr/polyfill` and `watr/optimize`, that you compose explicitly:
+ *  `compile(optimize(src))`. This keeps the default bundle minimal. */
+const backend = { parse, compile: _compile }
 
 /**
  * Compile WAT to binary. Supports both string and template literal.
  *
  * @param {string|TemplateStringsArray} source - WAT source or template strings
  * @param {...any} values - Interpolation values (for template literal).
- *   Last value can be an options object: { polyfill, optimize }.
  * @returns {Uint8Array} WebAssembly binary
  *
  * @example
  * compile('(func (export "f") (result i32) (i32.const 42))')
  * compile`(func (export "f") (result f64) (f64.const ${Math.PI}))`
- * compile(src, { polyfill: true, optimize: true })
+ * // transforms ship as separate entries — compose them:
+ * // import optimize from 'watr/optimize'
+ * // compile(optimize(src))
  */
 function compile(source, ...values) {
   return _tcompile(backend, source, values)
@@ -48,4 +51,4 @@ function watr(source, ...values) {
 }
 
 export default watr
-export { watr, compile, parse, print, _polyfill as polyfill, _optimize as optimize }
+export { watr, compile, parse, print }