prepare & finalize

examples/service-types.ts

···
+const counts: Record<string, number>= {}
+
+export function process({ op }: { op: any }) {
+
+    if (!op.operation?.services) {
+        return
+    }
+    for (const key of Object.keys(op.operation.services)) {
+        if (!counts[key]) {
+            counts[key] = 1
+        } else {
+            counts[key] += 1
+        }
+    }
+}
+
+export function prepare() {
+    return { counts }
+}
+
+export function finalize(results: any, { aggregate }: any) {
+    console.log(Object.fromEntries(Object.entries(aggregate(results.map((r: any) => r.data.counts))).sort((a, b) => a[1] < b[1] ? 1 : -1)))
+}

src/plcbundle.ts

···
     
     // Determine mode based on what function is exported
     let mode: 'detect' | 'process' = 'detect';
+    let mod: any;
     if (module) {
       try {
-        const mod = await import(module);
+        mod = await import(module);
         // If module has 'process' function, use process mode
         if (mod.process) {
           mode = 'process';
···
         onMatch
       );
     }
-    
+
     // Load module if provided but single-threaded
-    if (module && !callback) {
-      const resolvedPath = module;
-      const mod = await import(resolvedPath);
+    if (mod && !callback) {
       const userFn = mode === 'detect' ? (mod.detect || mod.default) : (mod.process || mod.default);
       
       callback = (op, position, bundleNum, line) => {
···
     
     // Cleanup
     workers.forEach(w => w.terminate());
+
+    if (modulePath) {
+      const mod = await import(modulePath);
+      if (mod.finalize) {
+        await mod.finalize(results, { aggregate: this.aggregate });
+      }
+    }
     
     // Aggregate results
     let totalOps = 0;
···
       matches: flush || mode === 'process' ? undefined : allMatches,
     };
   }
+
+  private aggregate(objects: Array<{ [key: string]: number }>): { [key: string]: number } {
+    const aggregatedDict: { [key: string]: number } = {};
+
+    for (const currentObj of objects) {
+      for (const key in currentObj) {
+        if (Object.prototype.hasOwnProperty.call(currentObj, key)) {
+          aggregatedDict[key] = (aggregatedDict[key] || 0) + currentObj[key];
+        }
+      }
+    }
+
+    return aggregatedDict;
+  }
+
 
   /**
    * Fast single-threaded processing (optimized)

src/worker.ts

···
       // Continue on error
     }
   }
+
+  let prepareResult: any;
+  if (typeof mod.prepare === 'function') {
+    try {
+      prepareResult = await mod.prepare();
+    } catch (error) {
+      // Silently ignore finalize errors
+    }
+  }
   
   // Send final result
   self.postMessage({
···
     totalOps,
     totalBytes,
     matches: flush ? [] : matches,
+    data: prepareResult || null
   } as WorkerResult);
 };