image-utils: rename base64 option to parseAs

Replace { base64: true } with { parseAs: 'base64' } on resize, compress,
and strip to match the parseAs convention used in language-common http.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: mtuchi

packages/image-utils/src/Adaptor.js

@@ -12,10 +12,8 @@ function resolveInput(raw) {
   return Buffer.isBuffer(raw) ? raw : decodeBase64Image(raw);
 }
 
-// util.encode from language-common is text/JSON-oriented (utf-8 encoding).
-// For binary image buffers we encode directly with buffer.toString('base64').
-function applyBase64Option(result, encode) {
-  if (!encode) return result;
+function applyParseAs(result, parseAs) {
+  if (parseAs !== 'base64') return result;
   const { buffer, ...rest } = result;
   return { ...rest, base64: buffer.toString('base64') };
 }
@@ -38,15 +36,25 @@ function applyBase64Option(result, encode) {
  * @param {object} [options={}]
  * @param {number} [options.width=1200] - Output width in pixels
  * @param {number} [options.height=1600] - Output height in pixels
- * @param {boolean} [options.base64=false] - When true, returns `{ base64, width, height }` instead of `{ buffer, width, height }`
+ * @param {'buffer'|'base64'} [options.parseAs='buffer'] - Return format: `'buffer'` (default) or `'base64'`
  * @state {ImageState}
  * @returns {Operation}
  */
 export function resize(base64ImgOrBuffer, options = {}) {
   return async state => {
-    const [resolvedImg, resolvedOptions] = expandReferences(state, base64ImgOrBuffer, options);
-    const result = await resizeImage(resolveInput(resolvedImg), resolvedOptions);
-    return composeNextState(state, applyBase64Option(result, resolvedOptions.base64));
+    const [resolvedImg, resolvedOptions] = expandReferences(
+      state,
+      base64ImgOrBuffer,
+      options,
+    );
+    const result = await resizeImage(
+      resolveInput(resolvedImg),
+      resolvedOptions,
+    );
+    return composeNextState(
+      state,
+      applyParseAs(result, resolvedOptions.parseAs),
+    );
   };
 }
 
@@ -62,15 +70,25 @@ export function resize(base64ImgOrBuffer, options = {}) {
  * @param {number} [options.maxBytes=716800] - Maximum output file size in bytes
  * @param {number} [options.minQuality=20] - JPEG quality floor (1–100); compression stops here even if maxBytes is not met
  * @param {string} [options.comment] - String to embed in the EXIF UserComment field
- * @param {boolean} [options.base64=false] - When true, returns `{ base64, size, quality }` instead of `{ buffer, size, quality }`
+ * @param {'buffer'|'base64'} [options.parseAs='buffer'] - Return format: `'buffer'` (default) or `'base64'`
  * @state {ImageState}
  * @returns {Operation}
  */
 export function compress(base64ImgOrBuffer, options = {}) {
   return async state => {
-    const [resolvedImg, resolvedOptions] = expandReferences(state, base64ImgOrBuffer, options);
-    const result = await compressImage(resolveInput(resolvedImg), resolvedOptions);
-    return composeNextState(state, applyBase64Option(result, resolvedOptions.base64));
+    const [resolvedImg, resolvedOptions] = expandReferences(
+      state,
+      base64ImgOrBuffer,
+      options,
+    );
+    const result = await compressImage(
+      resolveInput(resolvedImg),
+      resolvedOptions,
+    );
+    return composeNextState(
+      state,
+      applyParseAs(result, resolvedOptions.parseAs),
+    );
   };
 }
 
@@ -82,15 +100,22 @@ export function compress(base64ImgOrBuffer, options = {}) {
  * @function
  * @param {string|Buffer|Function} base64ImgOrBuffer - Base64 string, data URL, Buffer, or resolver fn
  * @param {object} [options={}]
- * @param {boolean} [options.base64=false] - When true, returns `{ base64 }` instead of `{ buffer }`
+ * @param {'buffer'|'base64'} [options.parseAs='buffer'] - Return format: `'buffer'` (default) or `'base64'`
  * @state {ImageState}
  * @returns {Operation}
  */
 export function strip(base64ImgOrBuffer, options = {}) {
   return async state => {
-    const [resolvedImg, resolvedOptions] = expandReferences(state, base64ImgOrBuffer, options);
+    const [resolvedImg, resolvedOptions] = expandReferences(
+      state,
+      base64ImgOrBuffer,
+      options,
+    );
     const result = await stripImage(resolveInput(resolvedImg));
-    return composeNextState(state, applyBase64Option(result, resolvedOptions.base64));
+    return composeNextState(
+      state,
+      applyParseAs(result, resolvedOptions.parseAs),
+    );
   };
 }
 

packages/image-utils/test/Adaptor.test.js

@@ -150,10 +150,10 @@ describe('resize', () => {
   });
 
   describe('base64 option', () => {
-    it('returns { base64, width, height } when base64: true', async () => {
+    it("returns { base64, width, height } when parseAs: 'base64'", async () => {
       const finalState = await resize(
         toBase64Str('portrait-small.jpg'),
-        { ...DEFAULT_RESIZE_OPTS, base64: true },
+        { ...DEFAULT_RESIZE_OPTS, parseAs: 'base64' },
       )(state);
 
       expect(finalState.data).to.have.keys(['base64', 'width', 'height']);
@@ -287,11 +287,11 @@ describe('compress', () => {
   });
 
   describe('base64 option', () => {
-    it('returns { base64, size, quality } when base64: true', async () => {
+    it("returns { base64, size, quality } when parseAs: 'base64'", async () => {
       const inputBuffer = await getResizedBuffer('portrait-small.jpg');
       const finalState = await compress(
         inputBuffer,
-        { ...DEFAULT_COMPRESS_OPTS, base64: true },
+        { ...DEFAULT_COMPRESS_OPTS, parseAs: 'base64' },
       )(state);
 
       expect(finalState.data).to.have.keys(['base64', 'size', 'quality']);
@@ -356,8 +356,8 @@ describe('strip', () => {
     expect(finalState.data.buffer).to.be.instanceOf(Buffer);
   });
 
-  it('returns { base64 } when base64: true', async () => {
-    const finalState = await strip(toBase64Str('portrait-small.jpg'), { base64: true })(state);
+  it("returns { base64 } when parseAs: 'base64'", async () => {
+    const finalState = await strip(toBase64Str('portrait-small.jpg'), { parseAs: 'base64' })(state);
 
     expect(finalState.data).to.have.keys(['base64']);
     expect(finalState.data.base64).to.be.a('string');
@@ -440,7 +440,7 @@ describe('buffer passing between steps', () => {
   it('base64 output from resize() can be fed directly into compress()', async () => {
     const resizeState = await resize(
       toBase64Str('portrait-large.jpg'),
-      { ...DEFAULT_RESIZE_OPTS, base64: true },
+      { ...DEFAULT_RESIZE_OPTS, parseAs: 'base64' },
     )(state);
     expect(resizeState.data.base64).to.be.a('string');