js.foresight 0.0.8 → 0.0.9

package/dist/ForesightManager/ForesightDebugger.js

@@ -33,7 +33,7 @@ export class ForesightDebugger {
         transition: opacity 0.2s ease, border-color 0.2s ease, background-color 0.2s ease, box-shadow 0.2s ease;
       }
       .jsforesight-link-overlay.active {
-        border-color: red; background-color: rgba(255, 0, 0, 0.1);
+        border-color: orange; background-color: rgba(255, 0, 0, 0.1);
       }
       .jsforesight-link-overlay.trajectory-hit {
         border-color: lime; background-color: rgba(0, 255, 0, 0.3);

package/dist/ForesightManager/ForesightManager.d.ts

@@ -1,6 +1,6 @@
 import type { ForesightCallback, ForesightManagerProps, ForesightElement, Rect } from "../types/types";
 export declare class ForesightManager {
-    private static instance;
+    private static manager;
     private links;
     private isSetup;
     private debugMode;
@@ -13,7 +13,7 @@ export declare class ForesightManager {
     private resizeScrollThrottleTimeoutId;
     private constructor();
     static initialize(props?: Partial<ForesightManagerProps>): ForesightManager;
-    static getInstance(): ForesightManager;
+    static get instance(): ForesightManager;
     private checkTrajectoryHitExpiration;
     private normalizeHitSlop;
     register(element: ForesightElement, callback: ForesightCallback, hitSlop?: number | Rect): () => void;
@@ -24,7 +24,15 @@ export declare class ForesightManager {
     private updateExpandedRect;
     private updateAllRects;
     private predictMousePosition;
-    private pointIntersectsRect;
+    /**
+     * Checks if a line segment intersects with an axis-aligned rectangle.
+     * Uses the Liang-Barsky line clipping algorithm.
+     * @param p1 Start point of the line segment.
+     * @param p2 End point of the line segment.
+     * @param rect The rectangle to check against.
+     * @returns True if the line segment intersects the rectangle, false otherwise.
+     */
+    private lineSegmentIntersectsRect;
     private isMouseInExpandedArea;
     private handleMouseMove;
     private handleResizeOrScroll;

package/dist/ForesightManager/ForesightManager.js

@@ -1,7 +1,7 @@
 "use client";
 import { ForesightDebugger } from "./ForesightDebugger";
 export class ForesightManager {
-    static instance;
+    static manager;
     links = new Map();
     isSetup = false;
     debugMode = false; // Synced with globalSettings.debug
@@ -9,8 +9,8 @@ export class ForesightManager {
     globalSettings = {
         debug: false,
         enableMouseTrajectory: true,
-        positionHistorySize: 6,
-        trajectoryPredictionTime: 50,
+        positionHistorySize: 8,
+        trajectoryPredictionTime: 80,
         defaultHitSlop: { top: 0, left: 0, right: 0, bottom: 0 },
         resizeScrollThrottleDelay: 50,
     };
@@ -20,44 +20,40 @@ export class ForesightManager {
     lastResizeScrollCallTimestamp = 0;
     resizeScrollThrottleTimeoutId = null;
     constructor() {
-        // Ensure defaultHitSlop is normalized if it's a number initially
         this.globalSettings.defaultHitSlop = this.normalizeHitSlop(this.globalSettings.defaultHitSlop);
         setInterval(this.checkTrajectoryHitExpiration.bind(this), 100);
     }
     static initialize(props) {
-        if (!ForesightManager.instance) {
-            ForesightManager.instance = new ForesightManager();
-            // Apply initial props, which also handles initial debugger setup
+        if (!ForesightManager.manager) {
+            ForesightManager.manager = new ForesightManager();
             if (props) {
-                ForesightManager.instance.alterGlobalSettings(props);
+                ForesightManager.manager.alterGlobalSettings(props);
             }
             else {
-                // If no props, but default globalSettings.debug is true, ensure debugger is on
-                if (ForesightManager.instance.globalSettings.debug) {
-                    ForesightManager.instance.turnOnDebugMode();
+                if (ForesightManager.manager.globalSettings.debug) {
+                    ForesightManager.manager.turnOnDebugMode();
                 }
             }
         }
         else if (props) {
-            // Instance exists, apply new props (handles debugger lifecycle and UI updates)
-            ForesightManager.instance.alterGlobalSettings(props);
+            console.error("ForesightManager is already initialized. Use alterGlobalSettings to update settings. Make sure to not put the ForesightManager.initialize() in a place that rerenders often.");
+            ForesightManager.manager.alterGlobalSettings(props);
         }
-        // Ensure internal debugMode flag is synced
-        ForesightManager.instance.debugMode = ForesightManager.instance.globalSettings.debug;
-        return ForesightManager.instance;
+        ForesightManager.manager.debugMode = ForesightManager.manager.globalSettings.debug;
+        return ForesightManager.manager;
     }
-    static getInstance() {
-        if (!ForesightManager.instance) {
-            return this.initialize(); // Initialize with defaults
+    static get instance() {
+        if (!ForesightManager.manager) {
+            return this.initialize();
         }
-        return ForesightManager.instance;
+        return ForesightManager.manager;
     }
     checkTrajectoryHitExpiration() {
         const now = performance.now();
         let needsVisualUpdate = false;
         const updatedForesightElements = [];
         this.links.forEach((elementData, element) => {
-            if (elementData.isTrajectoryHit && now - elementData.trajectoryHitTime > 300) {
+            if (elementData.isTrajectoryHit && now - elementData.trajectoryHitTime > 100) {
                 this.links.set(element, {
                     ...elementData,
                     isTrajectoryHit: false,
@@ -89,7 +85,7 @@ export class ForesightManager {
     register(element, callback, hitSlop) {
         const normalizedHitSlop = hitSlop
             ? this.normalizeHitSlop(hitSlop)
-            : this.globalSettings.defaultHitSlop; // Already normalized in constructor/alterGlobalSettings
+            : this.globalSettings.defaultHitSlop; // Already normalized in constructor
         const originalRect = element.getBoundingClientRect();
         const newElementData = {
             callback,
@@ -145,7 +141,6 @@ export class ForesightManager {
             if (JSON.stringify(this.globalSettings.defaultHitSlop) !== JSON.stringify(newSlop)) {
                 this.globalSettings.defaultHitSlop = newSlop;
                 settingsActuallyChanged = true;
-                // Note: This won't update existing elements' hitSlop unless they are re-registered.
             }
         }
         if (props?.resizeScrollThrottleDelay !== undefined &&
@@ -172,14 +167,12 @@ export class ForesightManager {
         }
     }
     turnOnDebugMode() {
-        this.debugMode = true; // Ensure this is true when method is called
+        this.debugMode = true;
         if (!this.debugger) {
             this.debugger = new ForesightDebugger(this);
             this.debugger.initialize(this.links, this.globalSettings, this.currentPoint, this.predictedPoint);
         }
         else {
-            // If debugger exists, ensure its controls are up-to-date with current globalSettings
-            // This could happen if debug was false, then true again, or settings changed.
             this.debugger.updateControlsState(this.globalSettings);
             this.debugger.updateTrajectoryVisuals(this.currentPoint, this.predictedPoint, this.globalSettings.enableMouseTrajectory);
         }
@@ -243,9 +236,67 @@ export class ForesightManager {
         const predictedY = y + vy * trajectoryPredictionTimeInSeconds;
         return { x: predictedX, y: predictedY };
     };
-    pointIntersectsRect = (x, y, rect) => {
-        return x >= rect.left && x <= rect.right && y >= rect.top && y <= rect.bottom;
-    };
+    /**
+     * Checks if a line segment intersects with an axis-aligned rectangle.
+     * Uses the Liang-Barsky line clipping algorithm.
+     * @param p1 Start point of the line segment.
+     * @param p2 End point of the line segment.
+     * @param rect The rectangle to check against.
+     * @returns True if the line segment intersects the rectangle, false otherwise.
+     */
+    lineSegmentIntersectsRect(p1, p2, rect) {
+        let t0 = 0.0;
+        let t1 = 1.0;
+        const dx = p2.x - p1.x;
+        const dy = p2.y - p1.y;
+        // Helper function for Liang-Barsky algorithm
+        // p: parameter related to edge normal and line direction
+        // q: parameter related to distance from p1 to edge
+        const clipTest = (p, q) => {
+            if (p === 0) {
+                // Line is parallel to the clip edge
+                if (q < 0) {
+                    // Line is outside the clip edge (p1 is on the "wrong" side)
+                    return false;
+                }
+            }
+            else {
+                const r = q / p;
+                if (p < 0) {
+                    // Line proceeds from outside to inside (potential entry)
+                    if (r > t1)
+                        return false; // Enters after already exited
+                    if (r > t0)
+                        t0 = r; // Update latest entry time
+                }
+                else {
+                    // Line proceeds from inside to outside (potential exit) (p > 0)
+                    if (r < t0)
+                        return false; // Exits before already entered
+                    if (r < t1)
+                        t1 = r; // Update earliest exit time
+                }
+            }
+            return true;
+        };
+        // Left edge: rect.left
+        if (!clipTest(-dx, p1.x - rect.left))
+            return false;
+        // Right edge: rect.right
+        if (!clipTest(dx, rect.right - p1.x))
+            return false;
+        // Top edge: rect.top
+        if (!clipTest(-dy, p1.y - rect.top))
+            return false;
+        // Bottom edge: rect.bottom
+        if (!clipTest(dy, rect.bottom - p1.y))
+            return false;
+        // If t0 > t1, the segment is completely outside or misses the clip window.
+        // Also, the valid intersection must be within the segment [0,1].
+        // Since t0 and t1 are initialized to 0 and 1, and clamped,
+        // this also ensures the intersection lies on the segment.
+        return t0 <= t1;
+    }
     isMouseInExpandedArea = (area, clientPoint, isAlreadyHovering) => {
         const isInExpandedArea = clientPoint.x >= area.left &&
             clientPoint.x <= area.right &&
@@ -268,24 +319,29 @@ export class ForesightManager {
             const { isHoveringInArea, shouldRunCallback } = this.isMouseInExpandedArea(elementData.elementBounds.expandedRect, this.currentPoint, elementData.isHovering);
             let linkStateChanged = false;
             if (this.globalSettings.enableMouseTrajectory && !isHoveringInArea) {
-                if (this.pointIntersectsRect(this.predictedPoint.x, this.predictedPoint.y, elementData.elementBounds.expandedRect)) {
+                // Check if the trajectory line segment intersects the expanded rect
+                if (this.lineSegmentIntersectsRect(this.currentPoint, this.predictedPoint, elementData.elementBounds.expandedRect)) {
                     if (!elementData.isTrajectoryHit) {
                         elementData.callback();
                         this.links.set(element, {
                             ...elementData,
                             isTrajectoryHit: true,
                             trajectoryHitTime: performance.now(),
-                            isHovering: isHoveringInArea,
+                            isHovering: isHoveringInArea, // isHoveringInArea is false here
                         });
                         linkStateChanged = true;
                     }
                 }
+                // Note: No 'else' here to turn off isTrajectoryHit immediately.
+                // It's managed by checkTrajectoryHitExpiration or when actual hover occurs.
             }
             if (elementData.isHovering !== isHoveringInArea) {
                 this.links.set(element, {
                     ...elementData,
                     isHovering: isHoveringInArea,
-                    // Preserve trajectory hit state if it was already hit
+                    // Preserve trajectory hit state if it was already hit,
+                    // unless actual hover is now false and trajectory also doesn't hit
+                    // (though trajectory hit is primarily for non-hovering states)
                     isTrajectoryHit: this.links.get(element).isTrajectoryHit,
                     trajectoryHitTime: this.links.get(element).trajectoryHitTime,
                 });

package/dist/types/types.d.ts

@@ -68,13 +68,13 @@ export type ForesightManagerProps = {
     /**
      * Number of mouse positions to keep in history for trajectory calculation.
      * A higher number might lead to smoother but slightly delayed predictions.
-     * @default 6
+     * @default 8
      */
     positionHistorySize: number;
     /**
      * How far ahead (in milliseconds) to predict the mouse trajectory.
      * A larger value means the prediction extends further into the future. (meaning it will trigger callbacks sooner)
-     * @default 50
+     * @default 80
      */
     trajectoryPredictionTime: number;
     /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "js.foresight",
-  "version": "0.0.8",
+  "version": "0.0.9",
   "description": "",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",