@platformatic/itc 3.13.1 → 3.15.0

package/lib/index.js

@@ -97,43 +97,89 @@ export function sanitize (data, transferList) {
     return data
   }
 
-  let sanitized
-
   if (Buffer.isBuffer(data) || data instanceof Uint8Array) {
     // This will convert as Uint8Array
     return data
-  } else if (Array.isArray(data)) {
-    sanitized = []
+  }
+
+  if (Array.isArray(data)) {
+    let sanitized = null
+    let needsSanitization = false
 
-    for (const value of data) {
+    for (let i = 0; i < data.length; i++) {
+      const value = data[i]
       const valueType = typeof value
 
       /* c8 ignore next 3 */
       if (valueType === 'function' || valueType === 'symbol') {
+        if (!needsSanitization) {
+          sanitized = data.slice(0, i)
+          needsSanitization = true
+        }
         continue
       }
 
-      sanitized.push(value && typeof value === 'object' ? sanitize(value, transferList) : value)
+      let sanitizedValue = value
+      if (value && typeof value === 'object') {
+        sanitizedValue = sanitize(value, transferList)
+        if (sanitizedValue !== value && !needsSanitization) {
+          sanitized = data.slice(0, i)
+          needsSanitization = true
+        }
+      }
+
+      if (needsSanitization) {
+        sanitized.push(sanitizedValue)
+      }
     }
-  } else {
-    sanitized = {}
 
-    for (const [key, value] of Object.entries(data)) {
-      const valueType = typeof value
+    return needsSanitization ? sanitized : data
+  }
 
-      if (valueType === 'function' || valueType === 'symbol') {
-        continue
+  // Handle plain objects
+  let sanitized = null
+  let needsSanitization = false
+
+  for (const [key, value] of Object.entries(data)) {
+    const valueType = typeof value
+
+    if (valueType === 'function' || valueType === 'symbol') {
+      if (!needsSanitization) {
+        sanitized = {}
+        // Copy all previous properties
+        for (const [k] of Object.entries(data)) {
+          if (k === key) break
+          sanitized[k] = data[k]
+        }
+        needsSanitization = true
+      }
+      continue
+    }
+
+    let sanitizedValue = value
+    if (value && typeof value === 'object') {
+      sanitizedValue = sanitize(value, transferList)
+      if (sanitizedValue !== value && !needsSanitization) {
+        sanitized = {}
+        // Copy all previous properties
+        for (const [k] of Object.entries(data)) {
+          if (k === key) break
+          sanitized[k] = data[k]
+        }
+        needsSanitization = true
       }
+    }
 
-      sanitized[key] = value && typeof value === 'object' ? sanitize(value, transferList) : value
+    if (needsSanitization) {
+      sanitized[key] = sanitizedValue
     }
   }
 
-  return sanitized
+  return needsSanitization ? sanitized : data
 }
 
 export class ITC extends EventEmitter {
-  #requestEmitter
+  #waitingRequests
   #handlers
   #listening
   #handling
@@ -154,16 +200,13 @@ export class ITC extends EventEmitter {
     // Without it, it's impossible to know which "side" of the ITC is being used.
     this.name = name
     this.port = port
-    this.#requestEmitter = new EventEmitter()
+    this.#waitingRequests = new Map()
     this.#handlers = new Map()
     this.#listening = false
     this.#handling = false
     this.#closeAfterCurrentRequest = false
     this.#throwOnMissingHandler = throwOnMissingHandler ?? true
 
-    // Make sure the emitter handle a lot of listeners at once before raising a warning
-    this.#requestEmitter.setMaxListeners(1e3)
-
     /*
       There some contexts in which a message is sent and the event loop empties up while waiting for a response.
       For instance @platformatic/astro when doing build with custom commands.
@@ -197,19 +240,24 @@ export class ITC extends EventEmitter {
       throw new SendBeforeListen()
     }
 
+    let reqId
     try {
       this._enableKeepAlive()
 
       const request = generateRequest(name, message)
       this._send(request, options)
 
-      const responsePromise = once(this.#requestEmitter, request.reqId).then(([response]) => response)
+      const promiseWithResolvers = Promise.withResolvers()
+      reqId = request.reqId
+      this.#waitingRequests.set(request.reqId, promiseWithResolvers)
 
-      const { error, data } = await Unpromise.race([responsePromise, this.#closePromise])
+      const { error, data } = await Unpromise.race([promiseWithResolvers.promise, this.#closePromise])
 
       if (error !== null) throw error
       return data
     } finally {
+      // Clean up the waiting requests map even if an error occurred
+      this.#waitingRequests.delete(reqId)
       this._manageKeepAlive()
     }
   }
@@ -342,7 +390,12 @@ export class ITC extends EventEmitter {
   }
 
   _emitResponse (response) {
-    this.#requestEmitter.emit(response.reqId, response)
+    const pending = this.#waitingRequests.get(response.reqId)
+    if (!pending) {
+      return
+    }
+
+    pending.resolve(response)
   }
 
   _enableKeepAlive () {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@platformatic/itc",
-  "version": "3.13.1",
+  "version": "3.15.0",
   "description": "",
   "main": "lib/index.js",
   "type": "module",