@srsergio/taptapp-ar 1.0.78 → 1.0.79

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

@@ -5,26 +5,110 @@
  * que NO depende de TensorFlow, eliminando todos los problemas de
  * inicialización, bloqueos y compatibilidad.
  */
-import { WorkerPool } from "./utils/worker-pool.js";
 export declare class OfflineCompiler {
     data: any;
-    workerPool: WorkerPool | null;
     constructor();
-    _initNodeWorkers(): Promise<void>;
     compileImageTargets(images: any[], progressCallback: (p: number) => void): Promise<any>;
-    _compileTarget(targetImages: any[], progressCallback: (p: number) => void): Promise<any[]>;
-    _compileMatch(targetImages: any[], progressCallback: (p: number) => void): Promise<any[]>;
-    _compileTrack(targetImages: any[], progressCallback: (p: number) => void): Promise<any[]>;
+    _compileTarget(targetImages: any[], progressCallback: (p: number) => void): Promise<{
+        matchingData: {
+            maximaPoints: any[];
+            minimaPoints: any[];
+            maximaPointsCluster: {
+                rootNode: {
+                    leaf: boolean;
+                    pointIndexes: never[];
+                    centerPointIndex: null;
+                };
+            } | {
+                rootNode: {
+                    centerPointIndex: any;
+                };
+            };
+            minimaPointsCluster: {
+                rootNode: {
+                    leaf: boolean;
+                    pointIndexes: never[];
+                    centerPointIndex: null;
+                };
+            } | {
+                rootNode: {
+                    centerPointIndex: any;
+                };
+            };
+            width: any;
+            height: any;
+            scale: any;
+        }[];
+        trackingData: Object[];
+    }[]>;
+    _compileMatch(targetImages: any[], progressCallback: (p: number) => void): Promise<{
+        maximaPoints: any[];
+        minimaPoints: any[];
+        maximaPointsCluster: {
+            rootNode: {
+                leaf: boolean;
+                pointIndexes: never[];
+                centerPointIndex: null;
+            };
+        } | {
+            rootNode: {
+                centerPointIndex: any;
+            };
+        };
+        minimaPointsCluster: {
+            rootNode: {
+                leaf: boolean;
+                pointIndexes: never[];
+                centerPointIndex: null;
+            };
+        } | {
+            rootNode: {
+                centerPointIndex: any;
+            };
+        };
+        width: any;
+        height: any;
+        scale: any;
+    }[][]>;
+    _compileTrack(targetImages: any[], progressCallback: (p: number) => void): Promise<Object[][]>;
     compileTrack({ progressCallback, targetImages, basePercent }: {
         progressCallback: (p: number) => void;
         targetImages: any[];
         basePercent?: number;
-    }): Promise<any[]>;
+    }): Promise<Object[][]>;
     compileMatch({ progressCallback, targetImages, basePercent }: {
         progressCallback: (p: number) => void;
         targetImages: any[];
         basePercent?: number;
-    }): Promise<any[]>;
+    }): Promise<{
+        maximaPoints: any[];
+        minimaPoints: any[];
+        maximaPointsCluster: {
+            rootNode: {
+                leaf: boolean;
+                pointIndexes: never[];
+                centerPointIndex: null;
+            };
+        } | {
+            rootNode: {
+                centerPointIndex: any;
+            };
+        };
+        minimaPointsCluster: {
+            rootNode: {
+                leaf: boolean;
+                pointIndexes: never[];
+                centerPointIndex: null;
+            };
+        } | {
+            rootNode: {
+                centerPointIndex: any;
+            };
+        };
+        width: any;
+        height: any;
+        scale: any;
+    }[][]>;
     exportData(): Uint8Array<ArrayBuffer>;
     _getMorton(x: number, y: number): number;
     _columnarize(points: any[], tree: any, width: number, height: number): {

package/dist/compiler/offline-compiler.js

@@ -10,7 +10,6 @@ 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 &&
@@ -18,35 +17,8 @@ const isNode = typeof process !== "undefined" &&
 const CURRENT_VERSION = 7; // Protocol v7: Moonshot - 4-bit Packed Tracking Data
 export class OfflineCompiler {
     data = null;
-    workerPool = null;
     constructor() {
-        // Workers only in Node.js
-        if (!isNode) {
-            console.log("🌐 OfflineCompiler: Browser mode (no workers)");
-        }
-    }
-    async _initNodeWorkers() {
-        try {
-            const pathModule = "path";
-            const urlModule = "url";
-            const osModule = "os";
-            const workerThreadsModule = "node:worker_threads";
-            const [path, url, os, { Worker }] = await Promise.all([
-                import(/* @vite-ignore */ pathModule),
-                import(/* @vite-ignore */ urlModule),
-                import(/* @vite-ignore */ osModule),
-                import(/* @vite-ignore */ 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 WorkerPool(workerPath, numWorkers, Worker);
-        }
-        catch (e) {
-            console.log("⚡ OfflineCompiler: Running without workers (initialization failed)", e);
-        }
+        console.log("⚡ OfflineCompiler: Main thread mode (no workers)");
     }
     async compileImageTargets(images, progressCallback) {
         console.time("⏱️ Compilación total");
@@ -86,24 +58,7 @@ export class OfflineCompiler {
         return this.data;
     }
     async _compileTarget(targetImages, progressCallback) {
-        if (isNode)
-            await this._initNodeWorkers();
-        if (this.workerPool) {
-            const progressMap = new Float32Array(targetImages.length);
-            const wrappedPromises = targetImages.map((targetImage, index) => {
-                return this.workerPool.runTask({
-                    type: 'compile-all', // 🚀 MOONSHOT: Combined task
-                    targetImage,
-                    onProgress: (p) => {
-                        progressMap[index] = p;
-                        const sum = progressMap.reduce((a, b) => a + b, 0);
-                        progressCallback(sum / targetImages.length);
-                    }
-                });
-            });
-            return Promise.all(wrappedPromises);
-        }
-        // Fallback or non-worker implementation: run match and track sequentially
+        // Run match and track sequentially to match browser behavior exactly
         const matchingResults = await this._compileMatch(targetImages, (p) => progressCallback(p * 0.5));
         const trackingResults = await this._compileTrack(targetImages, (p) => progressCallback(50 + p * 0.5));
         return targetImages.map((_, i) => ({
@@ -114,25 +69,6 @@ export class OfflineCompiler {
     async _compileMatch(targetImages, progressCallback) {
         const percentPerImage = 100 / targetImages.length;
         let currentPercent = 0;
-        if (isNode)
-            await this._initNodeWorkers();
-        if (this.workerPool) {
-            const progressMap = new Float32Array(targetImages.length);
-            const wrappedPromises = targetImages.map((targetImage, index) => {
-                return this.workerPool.runTask({
-                    type: 'match',
-                    targetImage,
-                    percentPerImage,
-                    basePercent: 0,
-                    onProgress: (p) => {
-                        progressMap[index] = p;
-                        const sum = progressMap.reduce((a, b) => a + b, 0);
-                        progressCallback(sum);
-                    }
-                });
-            });
-            return Promise.all(wrappedPromises);
-        }
         const results = [];
         for (let i = 0; i < targetImages.length; i++) {
             const targetImage = targetImages[i];
@@ -165,23 +101,6 @@ 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);
-        }
         const results = [];
         for (let i = 0; i < targetImages.length; i++) {
             const targetImage = targetImages[i];
@@ -407,9 +326,7 @@ export class OfflineCompiler {
         };
     }
     async destroy() {
-        if (this.workerPool) {
-            await this.workerPool.destroy();
-        }
+        // No workers to destroy
     }
     _pack4Bit(data) {
         const length = data.length;

package/dist/react/TaptappAR.js

@@ -92,6 +92,9 @@ export const TaptappAR = ({ config, className = "", showScanningOverlay = true,
                     display: block;
                     width: 100%;
                     height: auto;
+                    opacity: 0;
+                    pointer-events: none;
+                    transition: opacity 0.3s ease;
                 }
             ` })] }));
 };

package/dist/react/use-ar.js

@@ -38,6 +38,7 @@ export const useAR = (config) => {
                     targetSrc: config.targetTaarSrc,
                     overlay: overlayRef.current,
                     scale: config.scale,
+                    debug: false,
                     onFound: async ({ targetIndex }) => {
                         console.log(`🎯 Target ${targetIndex} detected!`);
                         if (!isMounted)

package/package.json

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

package/src/compiler/offline-compiler.ts

@@ -11,7 +11,6 @@ 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" &&
@@ -22,40 +21,9 @@ const CURRENT_VERSION = 7; // Protocol v7: Moonshot - 4-bit Packed Tracking Data
 
 export class OfflineCompiler {
     data: any = null;
-    workerPool: WorkerPool | null = null;
 
     constructor() {
-        // Workers only in Node.js
-        if (!isNode) {
-            console.log("🌐 OfflineCompiler: Browser mode (no workers)");
-        }
-    }
-
-    async _initNodeWorkers() {
-        try {
-            const pathModule = "path";
-            const urlModule = "url";
-            const osModule = "os";
-            const workerThreadsModule = "node:worker_threads";
-
-            const [path, url, os, { Worker }] = await Promise.all([
-                import(/* @vite-ignore */ pathModule),
-                import(/* @vite-ignore */ urlModule),
-                import(/* @vite-ignore */ osModule),
-                import(/* @vite-ignore */ 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 WorkerPool(workerPath, numWorkers, Worker);
-        } catch (e) {
-            console.log("⚡ OfflineCompiler: Running without workers (initialization failed)", e);
-        }
+        console.log("⚡ OfflineCompiler: Main thread mode (no workers)");
     }
 
     async compileImageTargets(images: any[], progressCallback: (p: number) => void) {
@@ -108,25 +76,7 @@ export class OfflineCompiler {
     }
 
     async _compileTarget(targetImages: any[], progressCallback: (p: number) => void) {
-        if (isNode) await this._initNodeWorkers();
-
-        if (this.workerPool) {
-            const progressMap = new Float32Array(targetImages.length);
-            const wrappedPromises = targetImages.map((targetImage: any, index: number) => {
-                return this.workerPool!.runTask({
-                    type: 'compile-all', // 🚀 MOONSHOT: Combined task
-                    targetImage,
-                    onProgress: (p: number) => {
-                        progressMap[index] = p;
-                        const sum = progressMap.reduce((a, b) => a + b, 0);
-                        progressCallback(sum / targetImages.length);
-                    }
-                });
-            });
-            return Promise.all(wrappedPromises);
-        }
-
-        // Fallback or non-worker implementation: run match and track sequentially
+        // Run match and track sequentially to match browser behavior exactly
         const matchingResults = await this._compileMatch(targetImages, (p) => progressCallback(p * 0.5));
         const trackingResults = await this._compileTrack(targetImages, (p) => progressCallback(50 + p * 0.5));
 
@@ -140,27 +90,6 @@ export class OfflineCompiler {
         const percentPerImage = 100 / targetImages.length;
         let currentPercent = 0;
 
-        if (isNode) await this._initNodeWorkers();
-        if (this.workerPool) {
-            const progressMap = new Float32Array(targetImages.length);
-
-            const wrappedPromises = targetImages.map((targetImage: any, index: number) => {
-                return this.workerPool!.runTask({
-                    type: 'match',
-                    targetImage,
-                    percentPerImage,
-                    basePercent: 0,
-                    onProgress: (p: number) => {
-                        progressMap[index] = p;
-                        const sum = progressMap.reduce((a, b) => a + b, 0);
-                        progressCallback(sum);
-                    }
-                });
-            });
-
-            return Promise.all(wrappedPromises);
-        }
-
         const results = [];
         for (let i = 0; i < targetImages.length; i++) {
             const targetImage = targetImages[i];
@@ -201,24 +130,6 @@ export class OfflineCompiler {
         const percentPerImage = 100 / targetImages.length;
         let currentPercent = 0;
 
-        if (this.workerPool) {
-            const progressMap = new Float32Array(targetImages.length);
-            const wrappedPromises = targetImages.map((targetImage: any, index: number) => {
-                return this.workerPool!.runTask({
-                    type: 'compile',
-                    targetImage,
-                    percentPerImage,
-                    basePercent: 0,
-                    onProgress: (p: number) => {
-                        progressMap[index] = p;
-                        const sum = progressMap.reduce((a, b) => a + b, 0);
-                        progressCallback(sum);
-                    }
-                });
-            });
-            return Promise.all(wrappedPromises);
-        }
-
         const results = [];
         for (let i = 0; i < targetImages.length; i++) {
             const targetImage = targetImages[i];
@@ -480,9 +391,7 @@ export class OfflineCompiler {
     }
 
     async destroy() {
-        if (this.workerPool) {
-            await this.workerPool.destroy();
-        }
+        // No workers to destroy
     }
 
 

package/src/react/TaptappAR.tsx

@@ -169,6 +169,9 @@ export const TaptappAR: React.FC<TaptappARProps> = ({
                     display: block;
                     width: 100%;
                     height: auto;
+                    opacity: 0;
+                    pointer-events: none;
+                    transition: opacity 0.3s ease;
                 }
             `}</style>
         </div>

package/src/react/use-ar.ts

@@ -52,6 +52,7 @@ export const useAR = (config: ARConfig): UseARReturn => {
                     targetSrc: config.targetTaarSrc,
                     overlay: overlayRef.current!,
                     scale: config.scale,
+                    debug: false,
                     onFound: async ({ targetIndex }) => {
                         console.log(`🎯 Target ${targetIndex} detected!`);
                         if (!isMounted) return;