Refactor and resolve linter violations

Author: mattt

index.test.ts

@@ -219,11 +219,12 @@ describe("Replicate client", () => {
     ])(
       "converts a $type input into a base64 encoded string",
       async ({ value: data, expected }) => {
-        let body: Record<string, any>;
+        let actual: Record<string, any> | undefined;
         nock(BASE_URL)
           .post("/predictions")
-          .reply(201, (_uri, _body: Record<string, any>) => {
-            return (body = _body);
+          .reply(201, (uri: string, body: Record<string, any>) => {
+            actual = body;
+            return body;
           });
 
         await client.predictions.create({
@@ -236,7 +237,7 @@ describe("Replicate client", () => {
           stream: true,
         });
 
-        expect(body!.input.data).toEqual(expected);
+        expect(actual?.input.data).toEqual(expected);
       }
     );
 

lib/util.js

@@ -72,52 +72,53 @@ const MAX_DATA_URI_SIZE = 10_000_000;
 
 /**
  * Walks the inputs and transforms any binary data found into a
- * base64 encoded data uri. It will throw if the size of inputs
- * exceeds a given threshould set by MAX_DATA_URI_SIZE.
+ * base64-encoded data URI.
+ *
+ * @param {object} inputs - The inputs to transform
+ * @returns {object} - The transformed inputs
+ * @throws {Error} If the size of inputs exceeds a given threshould set by MAX_DATA_URI_SIZE
  */
 async function transformFileInputs(inputs) {
   let totalBytes = 0;
   const result = await transform(inputs, async (value) => {
+    let buffer;
     let mime;
 
-    // Currently we use a NodeJS only API for base64 encoding, as
-    // we move to support the browser we could support either using
-    // btoa (which does string encoding), the FileReader API or
-    // a JavaScript implenentation like base64-js.
-    // See: https://developer.mozilla.org/en-US/docs/Glossary/Base64
-    // See: https://github.com/beatgammit/base64-js
     if (value instanceof Blob) {
+      // Currently we use a NodeJS only API for base64 encoding, as
+      // we move to support the browser we could support either using
+      // btoa (which does string encoding), the FileReader API or
+      // a JavaScript implenentation like base64-js.
+      // See: https://developer.mozilla.org/en-US/docs/Glossary/Base64
+      // See: https://github.com/beatgammit/base64-js
+      buffer = Buffer.from(await value.arrayBuffer());
       mime = value.type;
-      value = Buffer.from(await value.arrayBuffer());
-    }
-
-    if (!Buffer.isBuffer(value)) {
+    } else if (Buffer.isBuffer(value)) {
+      buffer = value;
+    } else {
       return value;
     }
 
-    totalBytes = 0 + value.byteLength;
+    totalBytes += buffer.byteLength;
     if (totalBytes > MAX_DATA_URI_SIZE) {
-      return null;
+      throw new Error(
+        `Combined filesize of prediction ${totalBytes} bytes exceeds 10mb limit for inline encoding, please provide URLs instead`
+      );
     }
 
-    const data = value.toString("base64");
+    const data = buffer.toString("base64");
     mime = mime ?? "application/octet-stream";
+
     return `data:${mime};base64,${data}`;
   });
 
-  if (totalBytes > MAX_DATA_URI_SIZE) {
-    throw new Error(
-      `Combined filesize of prediction ${totalBytes} bytes exceeds 10mb limit for inline encoding, please provide URLs instead`
-    );
-  }
-
   return result;
 }
 
 // Walk a JavaScript object and transform the leaf values.
 async function transform(value, mapper) {
   if (Array.isArray(value)) {
-    const copy = [];
+    let copy = [];
     for (const val of value) {
       copy = await transform(val, mapper);
     }
@@ -138,21 +139,21 @@ async function transform(value, mapper) {
 // Test for a plain JS object.
 // Source: lodash.isPlainObject
 function isPlainObject(value) {
-  const isObjectLike = typeof value == "object" && value !== null;
+  const isObjectLike = typeof value === "object" && value !== null;
   if (!isObjectLike || String(value) !== "[object Object]") {
     return false;
   }
-  var proto = Object.getPrototypeOf(value);
+  const proto = Object.getPrototypeOf(value);
   if (proto === null) {
     return true;
   }
-  var Ctor =
+  const Ctor =
     Object.prototype.hasOwnProperty.call(proto, "constructor") &&
     proto.constructor;
   return (
-    typeof Ctor == "function" &&
+    typeof Ctor === "function" &&
     Ctor instanceof Ctor &&
-    Function.prototype.toString.call(Ctor) ==
+    Function.prototype.toString.call(Ctor) ===
       Function.prototype.toString.call(Object)
   );
 }