@srsergio/taptapp-ar 1.0.8 → 1.0.9

package/dist/compiler/offline-compiler.d.ts

@@ -3,7 +3,7 @@
  */
 export class OfflineCompiler {
     data: any;
-    workerPool: import("./utils/worker-pool.js").WorkerPool | null;
+    workerPool: WorkerPool | null;
     _initNodeWorkers(): Promise<void>;
     /**
      * Compila una lista de imágenes objetivo
@@ -15,27 +15,11 @@ export class OfflineCompiler {
     /**
      * Compila datos de matching usando DetectorLite (JS puro)
      */
-    _compileMatch(targetImages: any, progressCallback: any): Promise<{
-        maximaPoints: any[];
-        minimaPoints: any[];
-        maximaPointsCluster: {
-            rootNode: {
-                centerPointIndex: any;
-            };
-        };
-        minimaPointsCluster: {
-            rootNode: {
-                centerPointIndex: any;
-            };
-        };
-        width: any;
-        height: any;
-        scale: any;
-    }[][]>;
+    _compileMatch(targetImages: any, progressCallback: any): Promise<any[]>;
     /**
      * Compila datos de tracking usando extractTrackingFeatures (JS puro)
      */
-    _compileTrack(targetImages: any, progressCallback: any): Promise<Object[][]>;
+    _compileTrack(targetImages: any, progressCallback: any): Promise<any[]>;
     /**
      * Método público para compilar tracking (compatibilidad con API anterior)
      * @param {Object} options - Opciones de compilación
@@ -56,23 +40,7 @@ export class OfflineCompiler {
         progressCallback: any;
         targetImages: any;
         basePercent?: number | undefined;
-    }): Promise<{
-        maximaPoints: any[];
-        minimaPoints: any[];
-        maximaPointsCluster: {
-            rootNode: {
-                centerPointIndex: any;
-            };
-        };
-        minimaPointsCluster: {
-            rootNode: {
-                centerPointIndex: any;
-            };
-        };
-        width: any;
-        height: any;
-        scale: any;
-    }[][]>;
+    }): Promise<any[]>;
     /**
      * Exporta datos compilados en formato binario columnar optimizado
      */
@@ -173,3 +141,4 @@ export class OfflineCompiler {
      */
     destroy(): Promise<void>;
 }
+import { WorkerPool } from "./utils/worker-pool.js";

package/dist/compiler/offline-compiler.js

@@ -19,6 +19,7 @@ import { extractTrackingFeatures } from "./tracker/extract-utils.js";
 import { DetectorLite } from "./detector/detector-lite.js";
 import { build as hierarchicalClusteringBuild } from "./matching/hierarchical-clustering.js";
 import * as msgpack from "@msgpack/msgpack";
+import { WorkerPool } from "./utils/worker-pool.js";
 // Detect environment
 const isNode = typeof process !== "undefined" &&
     process.versions != null &&
@@ -41,21 +42,27 @@ export class OfflineCompiler {
     }
     async _initNodeWorkers() {
         try {
-            const [os, path, url, workerModule] = await Promise.all([
-                import("os"),
-                import("path"),
-                import("url"),
-                import("./utils/worker-pool.js")
+            // Use variables to prevent bundlers from trying to bundle these
+            const pathModule = "path";
+            const urlModule = "url";
+            const osModule = "os";
+            const workerThreadsModule = "node:worker_threads";
+            const [path, url, os, { Worker }] = await Promise.all([
+                import(pathModule),
+                import(urlModule),
+                import(osModule),
+                import(workerThreadsModule)
             ]);
             const __filename = url.fileURLToPath(import.meta.url);
             const __dirname = path.dirname(__filename);
             const workerPath = path.join(__dirname, "node-worker.js");
+            // Limit workers to avoid freezing system
             const numWorkers = Math.min(os.cpus().length, 4);
-            this.workerPool = new workerModule.WorkerPool(workerPath, numWorkers);
+            this.workerPool = new WorkerPool(workerPath, numWorkers, Worker);
             console.log(`🚀 OfflineCompiler: Node.js mode with ${numWorkers} workers`);
         }
         catch (e) {
-            console.log("⚡ OfflineCompiler: Running without workers");
+            console.log("⚡ OfflineCompiler: Running without workers (initialization failed)", e);
         }
     }
     /**
@@ -120,9 +127,48 @@ export class OfflineCompiler {
     async _compileMatch(targetImages, progressCallback) {
         const percentPerImage = 100 / targetImages.length;
         let currentPercent = 0;
+        // Use workers if available
+        if (this.workerPool) {
+            const promises = targetImages.map((targetImage, index) => {
+                return this.workerPool.runTask({
+                    type: 'match',
+                    targetImage,
+                    percentPerImage,
+                    basePercent: index * percentPerImage,
+                    onProgress: (percent) => {
+                        // Basic aggregation: this assumes naive progress updates.
+                        // Ideally we should track exact progress per image.
+                        // For now, simpler to just let the main thread loop handle overall progress callback?
+                        // No, workers are async. We need to aggregate.
+                        // Actually, the main loop below is serial.
+                        // If we use workers, we run them in parallel.
+                    }
+                });
+            });
+            // Progress handling for parallel workers is tricky without a shared state manager.
+            // Simplified approach: each worker reports its absolute progress contribution?
+            // No, worker reports 'percent' which is base + local.
+            // We can use a shared loadedPercent variable.
+            let totalPercent = 0;
+            const progressMap = new Float32Array(targetImages.length);
+            const wrappedPromises = targetImages.map((targetImage, index) => {
+                return this.workerPool.runTask({
+                    type: 'match',
+                    targetImage,
+                    percentPerImage, // Not really needed for logic but worker expects it
+                    basePercent: 0, // Worker will report 0-percentPerImage roughly
+                    onProgress: (p) => {
+                        // This 'p' from worker is "base + local". If we passed base=0, it's just local (0 to percentPerImage)
+                        progressMap[index] = p;
+                        const sum = progressMap.reduce((a, b) => a + b, 0);
+                        progressCallback(sum);
+                    }
+                });
+            });
+            return Promise.all(wrappedPromises);
+        }
+        // Serial Fallback
         const results = [];
-        // Procesar secuencialmente para evitar overhead de workers
-        // (los workers son útiles para muchas imágenes, pero añaden latencia)
         for (let i = 0; i < targetImages.length; i++) {
             const targetImage = targetImages[i];
             const imageList = buildImageList(targetImage);
@@ -157,6 +203,24 @@ export class OfflineCompiler {
     async _compileTrack(targetImages, progressCallback) {
         const percentPerImage = 100 / targetImages.length;
         let currentPercent = 0;
+        if (this.workerPool) {
+            const progressMap = new Float32Array(targetImages.length);
+            const wrappedPromises = targetImages.map((targetImage, index) => {
+                return this.workerPool.runTask({
+                    type: 'compile',
+                    targetImage,
+                    percentPerImage,
+                    basePercent: 0,
+                    onProgress: (p) => {
+                        progressMap[index] = p;
+                        const sum = progressMap.reduce((a, b) => a + b, 0);
+                        progressCallback(sum);
+                    }
+                });
+            });
+            return Promise.all(wrappedPromises);
+        }
+        // Serial Fallback
         const results = [];
         for (let i = 0; i < targetImages.length; i++) {
             const targetImage = targetImages[i];
@@ -231,7 +295,8 @@ export class OfflineCompiler {
         return msgpack.encode({
             v: CURRENT_VERSION,
             dataList,
-        });
+            // eslint-disable-next-line
+        }); // eslint-disable-line
     }
     _packKeyframe(kf) {
         return {

package/dist/compiler/utils/worker-pool.d.ts

@@ -1,7 +1,8 @@
 export class WorkerPool {
-    constructor(workerPath: any, poolSize?: any);
+    constructor(workerPath: any, poolSize: any, WorkerClass: any);
     workerPath: any;
     poolSize: any;
+    WorkerClass: any;
     workers: any[];
     queue: any[];
     activeWorkers: number;

package/dist/compiler/utils/worker-pool.js

@@ -1,9 +1,8 @@
-import { Worker } from 'node:worker_threads';
-import os from 'node:os';
 export class WorkerPool {
-    constructor(workerPath, poolSize = os.cpus().length) {
+    constructor(workerPath, poolSize, WorkerClass) {
         this.workerPath = workerPath;
         this.poolSize = poolSize;
+        this.WorkerClass = WorkerClass;
         this.workers = [];
         this.queue = [];
         this.activeWorkers = 0;
@@ -24,7 +23,7 @@ export class WorkerPool {
     }
     _createWorker() {
         this.activeWorkers++;
-        const worker = new Worker(this.workerPath);
+        const worker = new this.WorkerClass(this.workerPath);
         return worker;
     }
     _executeTask(worker, task) {
@@ -62,10 +61,7 @@ export class WorkerPool {
                 serializableData[key] = value;
             }
         }
-        worker.postMessage({
-            type: 'compile',
-            ...serializableData
-        });
+        worker.postMessage(serializableData);
     }
     _finishTask(worker, callback, result) {
         if (this.queue.length > 0) {

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@srsergio/taptapp-ar",
-    "version": "1.0.8",
+    "version": "1.0.9",
     "description": "AR Compiler for Node.js and Browser",
     "repository": {
         "type": "git",

package/src/compiler/offline-compiler.js

@@ -20,6 +20,7 @@ import { extractTrackingFeatures } from "./tracker/extract-utils.js";
 import { DetectorLite } from "./detector/detector-lite.js";
 import { build as hierarchicalClusteringBuild } from "./matching/hierarchical-clustering.js";
 import * as msgpack from "@msgpack/msgpack";
+import { WorkerPool } from "./utils/worker-pool.js";
 
 // Detect environment
 const isNode = typeof process !== "undefined" &&
@@ -46,22 +47,30 @@ export class OfflineCompiler {
 
   async _initNodeWorkers() {
     try {
-      const [os, path, url, workerModule] = await Promise.all([
-        import("os"),
-        import("path"),
-        import("url"),
-        import("./utils/worker-pool.js")
+      // Use variables to prevent bundlers from trying to bundle these
+      const pathModule = "path";
+      const urlModule = "url";
+      const osModule = "os";
+      const workerThreadsModule = "node:worker_threads";
+
+      const [path, url, os, { Worker }] = await Promise.all([
+        import(pathModule),
+        import(urlModule),
+        import(osModule),
+        import(workerThreadsModule)
       ]);
 
       const __filename = url.fileURLToPath(import.meta.url);
       const __dirname = path.dirname(__filename);
       const workerPath = path.join(__dirname, "node-worker.js");
 
+      // Limit workers to avoid freezing system
       const numWorkers = Math.min(os.cpus().length, 4);
-      this.workerPool = new workerModule.WorkerPool(workerPath, numWorkers);
+
+      this.workerPool = new WorkerPool(workerPath, numWorkers, Worker);
       console.log(`🚀 OfflineCompiler: Node.js mode with ${numWorkers} workers`);
     } catch (e) {
-      console.log("⚡ OfflineCompiler: Running without workers");
+      console.log("⚡ OfflineCompiler: Running without workers (initialization failed)", e);
     }
   }
 
@@ -142,10 +151,53 @@ export class OfflineCompiler {
     const percentPerImage = 100 / targetImages.length;
     let currentPercent = 0;
 
-    const results = [];
+    // Use workers if available
+    if (this.workerPool) {
+      const promises = targetImages.map((targetImage, index) => {
+        return this.workerPool.runTask({
+          type: 'match',
+          targetImage,
+          percentPerImage,
+          basePercent: index * percentPerImage,
+          onProgress: (percent) => {
+            // Basic aggregation: this assumes naive progress updates.
+            // Ideally we should track exact progress per image.
+            // For now, simpler to just let the main thread loop handle overall progress callback?
+            // No, workers are async. We need to aggregate.
+            // Actually, the main loop below is serial.
+            // If we use workers, we run them in parallel.
+          }
+        });
+      });
+
+      // Progress handling for parallel workers is tricky without a shared state manager.
+      // Simplified approach: each worker reports its absolute progress contribution?
+      // No, worker reports 'percent' which is base + local.
+      // We can use a shared loadedPercent variable.
+
+      let totalPercent = 0;
+      const progressMap = new Float32Array(targetImages.length);
+
+      const wrappedPromises = targetImages.map((targetImage, index) => {
+        return this.workerPool.runTask({
+          type: 'match',
+          targetImage,
+          percentPerImage, // Not really needed for logic but worker expects it
+          basePercent: 0, // Worker will report 0-percentPerImage roughly
+          onProgress: (p) => {
+            // This 'p' from worker is "base + local". If we passed base=0, it's just local (0 to percentPerImage)
+            progressMap[index] = p;
+            const sum = progressMap.reduce((a, b) => a + b, 0);
+            progressCallback(sum);
+          }
+        });
+      });
+
+      return Promise.all(wrappedPromises);
+    }
 
-    // Procesar secuencialmente para evitar overhead de workers
-    // (los workers son útiles para muchas imágenes, pero añaden latencia)
+    // Serial Fallback
+    const results = [];
     for (let i = 0; i < targetImages.length; i++) {
       const targetImage = targetImages[i];
       const imageList = buildImageList(targetImage);
@@ -189,8 +241,26 @@ export class OfflineCompiler {
     const percentPerImage = 100 / targetImages.length;
     let currentPercent = 0;
 
-    const results = [];
+    if (this.workerPool) {
+      const progressMap = new Float32Array(targetImages.length);
+      const wrappedPromises = targetImages.map((targetImage, index) => {
+        return this.workerPool.runTask({
+          type: 'compile',
+          targetImage,
+          percentPerImage,
+          basePercent: 0,
+          onProgress: (p) => {
+            progressMap[index] = p;
+            const sum = progressMap.reduce((a, b) => a + b, 0);
+            progressCallback(sum);
+          }
+        });
+      });
+      return Promise.all(wrappedPromises);
+    }
 
+    // Serial Fallback
+    const results = [];
     for (let i = 0; i < targetImages.length; i++) {
       const targetImage = targetImages[i];
       const imageList = buildTrackingImageList(targetImage);
@@ -274,7 +344,8 @@ export class OfflineCompiler {
     return msgpack.encode({
       v: CURRENT_VERSION,
       dataList,
-    });
+      // eslint-disable-next-line
+    }); // eslint-disable-line
   }
 
   _packKeyframe(kf) {

package/src/compiler/utils/worker-pool.js

@@ -1,10 +1,9 @@
-import { Worker } from 'node:worker_threads';
-import os from 'node:os';
 
 export class WorkerPool {
-    constructor(workerPath, poolSize = os.cpus().length) {
+    constructor(workerPath, poolSize, WorkerClass) {
         this.workerPath = workerPath;
         this.poolSize = poolSize;
+        this.WorkerClass = WorkerClass;
         this.workers = [];
         this.queue = [];
         this.activeWorkers = 0;
@@ -25,7 +24,7 @@ export class WorkerPool {
 
     _createWorker() {
         this.activeWorkers++;
-        const worker = new Worker(this.workerPath);
+        const worker = new this.WorkerClass(this.workerPath);
         return worker;
     }
 
@@ -66,10 +65,7 @@ export class WorkerPool {
             }
         }
 
-        worker.postMessage({
-            type: 'compile',
-            ...serializableData
-        });
+        worker.postMessage(serializableData);
     }
 
     _finishTask(worker, callback, result) {