js.foresight 0.0.5

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Bart Spaans
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1 @@
+.

package/dist/ForesightManager/ForesightDebugger.d.ts

@@ -0,0 +1,38 @@
+import type { ForesightManager } from "./ForesightManager";
+import type { LinkElement, Point, Rect } from "../types/types";
+type LinkManagerData = {
+    callback: () => void;
+    expandedRect: Rect | null;
+    isHovering: boolean;
+    isTrajectoryHit: boolean;
+    trajectoryHitTime: number;
+};
+export declare class IntentDebugger {
+    private foresightManagerInstance;
+    private shadowHost;
+    private shadowRoot;
+    private debugContainer;
+    private debugLinkOverlays;
+    private debugPredictedMouseIndicator;
+    private debugTrajectoryLine;
+    private debugControlsContainer;
+    private debugStyleElement;
+    constructor(foresightManager: ForesightManager);
+    initialize(links: Map<LinkElement, LinkManagerData>, currentSettings: {
+        positionHistorySize: number;
+        trajectoryPredictionTime: number;
+        enableMouseTrajectory: boolean;
+    }, currentPoint: Point, predictedPoint: Point): void;
+    cleanup(): void;
+    createOrUpdateLinkOverlay(element: LinkElement, linkData: LinkManagerData): void;
+    removeLinkOverlay(element: LinkElement): void;
+    updateAllLinkVisuals(links: Map<LinkElement, LinkManagerData>): void;
+    updateTrajectoryVisuals(currentPoint: Point, predictedPoint: Point, enableMouseTrajectory: boolean): void;
+    private createDebugControls;
+    updateControlsState(settings: {
+        positionHistorySize: number;
+        trajectoryPredictionTime: number;
+        enableMouseTrajectory: boolean;
+    }): void;
+}
+export {};

package/dist/ForesightManager/ForesightDebugger.js

@@ -0,0 +1,243 @@
+"use strict";
+"use client";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IntentDebugger = void 0;
+class IntentDebugger {
+    foresightManagerInstance;
+    shadowHost = null;
+    shadowRoot = null;
+    debugContainer = null;
+    debugLinkOverlays = new Map();
+    debugPredictedMouseIndicator = null;
+    debugTrajectoryLine = null;
+    debugControlsContainer = null;
+    debugStyleElement = null;
+    constructor(foresightManager) {
+        this.foresightManagerInstance = foresightManager;
+    }
+    initialize(links, currentSettings, currentPoint, predictedPoint) {
+        if (typeof window === "undefined")
+            return;
+        this.cleanup();
+        this.shadowHost = document.createElement("div");
+        this.shadowHost.id = "intent-debugger-shadow-host";
+        // Host itself should not capture pointer events unless specifically designed to.
+        this.shadowHost.style.pointerEvents = "none";
+        document.body.appendChild(this.shadowHost);
+        this.shadowRoot = this.shadowHost.attachShadow({ mode: "open" });
+        this.debugStyleElement = document.createElement("style");
+        this.debugStyleElement.textContent = `
+      #intent-debug-container {
+        position: fixed; top: 0; left: 0; width: 100%; height: 100%;
+        pointer-events: none; z-index: 9999;
+      }
+      .intent-link-overlay {
+        position: absolute; border: 2px solid blue;
+        background-color: rgba(0, 0, 255, 0.1); box-sizing: border-box;
+        transition: opacity 0.2s ease, border-color 0.2s ease, background-color 0.2s ease, box-shadow 0.2s ease;
+      }
+      .intent-link-overlay.active {
+        border-color: red; background-color: rgba(255, 0, 0, 0.1);
+      }
+      .intent-link-overlay.trajectory-hit {
+        border-color: lime; background-color: rgba(0, 255, 0, 0.3);
+        box-shadow: 0 0 10px rgba(0, 255, 0, 0.8);
+      }
+      .intent-expanded-overlay {
+        position: absolute; border: 1px dashed rgba(0, 0, 255, 0.5);
+        background-color: rgba(0, 0, 255, 0.05); box-sizing: border-box;
+      }
+      .intent-mouse-predicted {
+        position: absolute; width: 20px; height: 20px; border-radius: 50%;
+        border: 2px solid orange; background-color: rgba(255, 165, 0, 0.3);
+        transform: translate(-50%, -50%); z-index: 10000;
+      }
+      .intent-trajectory-line {
+        position: absolute; height: 2px; background-color: rgba(255, 100, 0, 0.5);
+        transform-origin: left center; z-index: 9999;
+      }
+      #intent-debug-controls {
+        position: fixed; bottom: 10px; right: 10px;
+        background-color: rgba(0, 0, 0, 0.7); color: white; padding: 10px;
+        border-radius: 5px; font-family: monospace; font-size: 12px;
+        z-index: 10001; pointer-events: auto; /* Make controls interactive */
+      }
+      #intent-debug-controls h3 { margin: 0 0 5px 0; font-size: 14px; }
+      #intent-debug-controls label { display: block; margin: 5px 0; }
+      #intent-debug-controls input { margin-right: 5px; vertical-align: middle; }
+      #intent-debug-controls button {
+        margin: 5px 5px 0 0; padding: 3px 8px; background: #444;
+        border: 1px solid #666; color: white; border-radius: 3px; cursor: pointer;
+      }
+      #intent-debug-controls button:hover { background: #555; }
+    `;
+        this.shadowRoot.appendChild(this.debugStyleElement);
+        this.debugContainer = document.createElement("div");
+        this.debugContainer.id = "intent-debug-container";
+        this.shadowRoot.appendChild(this.debugContainer);
+        this.debugPredictedMouseIndicator = document.createElement("div");
+        this.debugPredictedMouseIndicator.className = "intent-mouse-predicted";
+        this.debugContainer.appendChild(this.debugPredictedMouseIndicator);
+        this.debugTrajectoryLine = document.createElement("div");
+        this.debugTrajectoryLine.className = "intent-trajectory-line";
+        this.debugContainer.appendChild(this.debugTrajectoryLine);
+        this.createDebugControls(currentSettings); // Appends to shadowRoot
+        links.forEach((data, element) => {
+            this.createOrUpdateLinkOverlay(element, data);
+        });
+        this.updateTrajectoryVisuals(currentPoint, predictedPoint, currentSettings.enableMouseTrajectory);
+    }
+    cleanup() {
+        this.shadowHost?.remove();
+        this.shadowHost = null;
+        this.shadowRoot = null;
+    }
+    createOrUpdateLinkOverlay(element, linkData) {
+        if (!this.debugContainer)
+            return;
+        let overlays = this.debugLinkOverlays.get(element);
+        if (!overlays) {
+            const linkOverlay = document.createElement("div");
+            linkOverlay.className = "intent-link-overlay";
+            this.debugContainer.appendChild(linkOverlay);
+            const expandedOverlay = document.createElement("div");
+            expandedOverlay.className = "intent-expanded-overlay";
+            this.debugContainer.appendChild(expandedOverlay);
+            overlays = { linkOverlay, expandedOverlay };
+            this.debugLinkOverlays.set(element, overlays);
+        }
+        const { linkOverlay, expandedOverlay } = overlays;
+        const rect = element.getBoundingClientRect();
+        // Corrected: Since debugContainer is position:fixed top:0 left:0,
+        // getBoundingClientRect() coords are already relative to it.
+        linkOverlay.style.left = `${rect.left}px`;
+        linkOverlay.style.top = `${rect.top}px`;
+        linkOverlay.style.width = `${rect.width}px`;
+        linkOverlay.style.height = `${rect.height}px`;
+        linkOverlay.classList.toggle("trajectory-hit", linkData.isTrajectoryHit);
+        linkOverlay.classList.toggle("active", linkData.isHovering);
+        if (linkData.expandedRect) {
+            // Corrected: Assuming expandedRect coords are viewport-relative.
+            expandedOverlay.style.left = `${linkData.expandedRect.left}px`;
+            expandedOverlay.style.top = `${linkData.expandedRect.top}px`;
+            expandedOverlay.style.width = `${linkData.expandedRect.right - linkData.expandedRect.left}px`;
+            expandedOverlay.style.height = `${linkData.expandedRect.bottom - linkData.expandedRect.top}px`;
+            expandedOverlay.style.display = "block";
+        }
+        else {
+            expandedOverlay.style.display = "none";
+        }
+    }
+    removeLinkOverlay(element) {
+        const overlays = this.debugLinkOverlays.get(element);
+        if (overlays) {
+            overlays.linkOverlay.remove();
+            overlays.expandedOverlay.remove();
+            this.debugLinkOverlays.delete(element);
+        }
+    }
+    updateAllLinkVisuals(links) {
+        if (!this.shadowRoot || !this.debugContainer)
+            return;
+        const currentElements = new Set(links.keys());
+        this.debugLinkOverlays.forEach((_, element) => {
+            if (!currentElements.has(element)) {
+                this.removeLinkOverlay(element);
+            }
+        });
+        links.forEach((data, element) => {
+            this.createOrUpdateLinkOverlay(element, data);
+        });
+    }
+    updateTrajectoryVisuals(currentPoint, predictedPoint, enableMouseTrajectory) {
+        if (!this.shadowRoot || !this.debugContainer)
+            return;
+        if (this.debugPredictedMouseIndicator) {
+            this.debugPredictedMouseIndicator.style.left = `${predictedPoint?.x || 0}px`;
+            this.debugPredictedMouseIndicator.style.top = `${predictedPoint?.y || 0}px`;
+            this.debugPredictedMouseIndicator.style.display =
+                enableMouseTrajectory && predictedPoint ? "block" : "none";
+        }
+        if (this.debugTrajectoryLine) {
+            if (enableMouseTrajectory && currentPoint && predictedPoint) {
+                const dx = predictedPoint.x - currentPoint.x;
+                const dy = predictedPoint.y - currentPoint.y;
+                const length = Math.sqrt(dx * dx + dy * dy);
+                const angle = (Math.atan2(dy, dx) * 180) / Math.PI;
+                this.debugTrajectoryLine.style.left = `${currentPoint.x}px`;
+                this.debugTrajectoryLine.style.top = `${currentPoint.y}px`;
+                this.debugTrajectoryLine.style.width = `${length}px`;
+                this.debugTrajectoryLine.style.transform = `translateY(-50%) rotate(${angle}deg)`;
+                this.debugTrajectoryLine.style.display = "block";
+            }
+            else {
+                this.debugTrajectoryLine.style.display = "none";
+            }
+        }
+    }
+    createDebugControls(initialSettings) {
+        if (!this.shadowRoot)
+            return;
+        this.debugControlsContainer = document.createElement("div");
+        this.debugControlsContainer.id = "intent-debug-controls";
+        this.shadowRoot.appendChild(this.debugControlsContainer);
+        this.debugControlsContainer.innerHTML = `
+      <h3>Trajectory Debug</h3>
+      <label>
+        <input type="checkbox" id="intent-trajectory-enabled" ${initialSettings.enableMouseTrajectory ? "checked" : ""}>
+        Enable Trajectory
+      </label>
+      <label>
+        History Size: <span id="intent-history-value">${initialSettings.positionHistorySize}</span>
+        <input type="range" id="intent-history-size" min="2" max="20" value="${initialSettings.positionHistorySize}">
+      </label>
+      <label>
+        Prediction Time: <span id="intent-prediction-value">${initialSettings.trajectoryPredictionTime}</span>ms
+        <input type="range" id="intent-prediction-time" min="10" max="500" value="${initialSettings.trajectoryPredictionTime}">
+      </label>
+     
+    `;
+        const enabledCheckbox = this.debugControlsContainer.querySelector("#intent-trajectory-enabled");
+        enabledCheckbox.addEventListener("change", () => {
+            this.foresightManagerInstance.setTrajectorySettings({
+                enabled: enabledCheckbox.checked,
+            });
+        });
+        const historySlider = this.debugControlsContainer.querySelector("#intent-history-size");
+        const historyValueSpan = this.debugControlsContainer.querySelector("#intent-history-value");
+        historySlider.addEventListener("input", () => {
+            const value = parseInt(historySlider.value);
+            historyValueSpan.textContent = value.toString();
+            this.foresightManagerInstance.setTrajectorySettings({ historySize: value });
+        });
+        const predictionSlider = this.debugControlsContainer.querySelector("#intent-prediction-time");
+        const predictionValueSpan = this.debugControlsContainer.querySelector("#intent-prediction-value");
+        predictionSlider.addEventListener("input", () => {
+            const value = parseInt(predictionSlider.value);
+            predictionValueSpan.textContent = value.toString();
+            this.foresightManagerInstance.setTrajectorySettings({
+                predictionTime: value,
+            });
+        });
+    }
+    updateControlsState(settings) {
+        if (!this.debugControlsContainer)
+            return;
+        const enabledCheckbox = this.debugControlsContainer.querySelector("#intent-trajectory-enabled");
+        if (enabledCheckbox)
+            enabledCheckbox.checked = settings.enableMouseTrajectory;
+        const historySlider = this.debugControlsContainer.querySelector("#intent-history-size");
+        const historyValueSpan = this.debugControlsContainer.querySelector("#intent-history-value");
+        if (historySlider && historyValueSpan) {
+            historySlider.value = settings.positionHistorySize.toString();
+            historyValueSpan.textContent = settings.positionHistorySize.toString();
+        }
+        const predictionSlider = this.debugControlsContainer.querySelector("#intent-prediction-time");
+        const predictionValueSpan = this.debugControlsContainer.querySelector("#intent-prediction-value");
+        if (predictionSlider && predictionValueSpan) {
+            predictionSlider.value = settings.trajectoryPredictionTime.toString();
+            predictionValueSpan.textContent = settings.trajectoryPredictionTime.toString();
+        }
+    }
+}
+exports.IntentDebugger = IntentDebugger;

package/dist/ForesightManager/ForesightManager.d.ts

@@ -0,0 +1,39 @@
+import type { IntentCallback, IntentManagerProps, LinkElement } from "../types/types";
+export declare class ForesightManager {
+    private static instance;
+    private links;
+    private isSetup;
+    private debugMode;
+    private debugger;
+    private positionHistorySize;
+    private trajectoryPredictionTime;
+    private positions;
+    private enableMouseTrajectory;
+    private currentPoint;
+    private predictedPoint;
+    private lastResizeScrollCallTimestamp;
+    private resizeScrollThrottleTimeoutId;
+    private readonly resizeScrollThrottleDelay;
+    private constructor();
+    static initialize(props?: Partial<IntentManagerProps>): ForesightManager;
+    static getInstance(): ForesightManager;
+    private checkTrajectoryHitExpiration;
+    register(element: LinkElement, callback: IntentCallback): () => void;
+    private unregister;
+    setTrajectorySettings(settings: {
+        historySize?: number;
+        predictionTime?: number;
+        enabled?: boolean;
+    }): void;
+    private turnOnDebugMode;
+    private getExpandedRect;
+    private updateExpandedRect;
+    private updateAllRects;
+    private predictMousePosition;
+    private pointIntersectsRect;
+    private isMouseInExpandedArea;
+    private handleMouseMove;
+    private handleResizeOrScroll;
+    private setupGlobalListeners;
+    private removeGlobalListeners;
+}

package/dist/ForesightManager/ForesightManager.js

@@ -0,0 +1,314 @@
+"use strict";
+"use client";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ForesightManager = void 0;
+const ForesightDebugger_1 = require("./ForesightDebugger");
+class ForesightManager {
+    static instance;
+    links = new Map();
+    isSetup = false;
+    debugMode = false;
+    debugger = null;
+    positionHistorySize = 6;
+    trajectoryPredictionTime = 50;
+    positions = [];
+    enableMouseTrajectory = true;
+    currentPoint = { x: 0, y: 0 };
+    predictedPoint = { x: 0, y: 0 };
+    lastResizeScrollCallTimestamp = 0;
+    resizeScrollThrottleTimeoutId = null;
+    resizeScrollThrottleDelay = 50;
+    constructor() {
+        setInterval(this.checkTrajectoryHitExpiration.bind(this), 100);
+    }
+    static initialize(props) {
+        if (!ForesightManager.instance) {
+            ForesightManager.instance = new ForesightManager();
+        }
+        if (props) {
+            ForesightManager.instance.setTrajectorySettings({
+                historySize: props.positionHistorySize,
+                predictionTime: props.trajectoryPredictionTime,
+                enabled: props.enableMouseTrajectory,
+            });
+        }
+        if (props?.debug) {
+            this.instance.turnOnDebugMode();
+        }
+        else {
+            if (this.instance.debugger) {
+                this.instance.debugMode = false;
+                this.instance.debugger.cleanup();
+                this.instance.debugger = null;
+            }
+        }
+        return ForesightManager.instance;
+    }
+    static getInstance() {
+        if (!ForesightManager.instance) {
+            return this.initialize();
+        }
+        return ForesightManager.instance;
+    }
+    checkTrajectoryHitExpiration() {
+        const now = performance.now();
+        let needsVisualUpdate = false;
+        const updatedLinkElements = [];
+        this.links.forEach((linkData, element) => {
+            if (linkData.isTrajectoryHit && now - linkData.trajectoryHitTime > 300) {
+                this.links.set(element, {
+                    ...linkData,
+                    isTrajectoryHit: false,
+                });
+                needsVisualUpdate = true;
+                updatedLinkElements.push(element);
+            }
+        });
+        if (needsVisualUpdate && this.debugMode && this.debugger) {
+            updatedLinkElements.forEach((element) => {
+                const data = this.links.get(element);
+                if (data && this.debugger) {
+                    console.log("asda");
+                    this.debugger.createOrUpdateLinkOverlay(element, data);
+                }
+            });
+        }
+    }
+    register(element, callback) {
+        const newLinkData = {
+            callback,
+            expandedRect: null,
+            isHovering: false,
+            isTrajectoryHit: false,
+            trajectoryHitTime: 0,
+        };
+        this.links.set(element, newLinkData);
+        this.updateExpandedRect(element); // This will also update debug visuals if active
+        this.setupGlobalListeners();
+        if (this.debugMode && this.debugger) {
+            const data = this.links.get(element);
+            if (data)
+                this.debugger.createOrUpdateLinkOverlay(element, data);
+        }
+        return () => this.unregister(element);
+    }
+    unregister(element) {
+        this.links.delete(element);
+        if (this.debugMode && this.debugger) {
+            this.debugger.removeLinkOverlay(element);
+        }
+        if (this.links.size === 0 && this.isSetup) {
+            this.removeGlobalListeners();
+        }
+    }
+    setTrajectorySettings(settings) {
+        let changed = false;
+        if (settings.historySize !== undefined && this.positionHistorySize !== settings.historySize) {
+            this.positionHistorySize = settings.historySize;
+            while (this.positions.length > this.positionHistorySize) {
+                this.positions.shift();
+            }
+            changed = true;
+        }
+        if (settings.predictionTime !== undefined &&
+            this.trajectoryPredictionTime !== settings.predictionTime) {
+            this.trajectoryPredictionTime = settings.predictionTime;
+            changed = true;
+        }
+        if (settings.enabled !== undefined && this.enableMouseTrajectory !== settings.enabled) {
+            this.enableMouseTrajectory = settings.enabled;
+            changed = true;
+        }
+        if (changed && this.debugMode && this.debugger) {
+            this.debugger.updateControlsState({
+                positionHistorySize: this.positionHistorySize,
+                trajectoryPredictionTime: this.trajectoryPredictionTime,
+                enableMouseTrajectory: this.enableMouseTrajectory,
+            });
+            this.debugger.updateTrajectoryVisuals(this.currentPoint, this.predictedPoint, this.enableMouseTrajectory);
+        }
+    }
+    turnOnDebugMode() {
+        this.debugMode = true;
+        if (!this.debugger) {
+            this.debugger = new ForesightDebugger_1.IntentDebugger(this);
+            this.debugger.initialize(this.links, {
+                positionHistorySize: this.positionHistorySize,
+                trajectoryPredictionTime: this.trajectoryPredictionTime,
+                enableMouseTrajectory: this.enableMouseTrajectory,
+            }, this.currentPoint, this.predictedPoint);
+        }
+    }
+    getExpandedRect(baseRect, hitSlop) {
+        return {
+            left: baseRect.left - hitSlop.left,
+            right: baseRect.right + hitSlop.right,
+            top: baseRect.top - hitSlop.top,
+            bottom: baseRect.bottom + hitSlop.bottom,
+        };
+    }
+    updateExpandedRect(element) {
+        const linkData = this.links.get(element);
+        if (!linkData)
+            return;
+        const expandedRect = this.getExpandedRect(element.getBoundingClientRect(), {
+            top: 100,
+            left: 100,
+            right: 100,
+            bottom: 100,
+        });
+        if (expandedRect != linkData.expandedRect) {
+            console.log("updating rect");
+            this.links.set(element, {
+                ...linkData,
+                expandedRect,
+            });
+        }
+        if (this.debugMode && this.debugger) {
+            const updatedData = this.links.get(element);
+            if (updatedData)
+                this.debugger.createOrUpdateLinkOverlay(element, updatedData);
+        }
+    }
+    updateAllRects() {
+        this.links.forEach((_, element) => {
+            this.updateExpandedRect(element);
+        });
+    }
+    predictMousePosition = (point) => {
+        const now = performance.now();
+        const currentPosition = { point, time: now };
+        const { x, y } = point;
+        this.positions.push(currentPosition);
+        if (this.positions.length > this.positionHistorySize) {
+            this.positions.shift();
+        }
+        if (this.positions.length < 2) {
+            return { x, y };
+        }
+        const first = this.positions[0];
+        const last = this.positions[this.positions.length - 1];
+        const dt = (last.time - first.time) / 1000;
+        if (dt === 0) {
+            return { x, y };
+        }
+        const dx = last.point.x - first.point.x;
+        const dy = last.point.y - first.point.y;
+        const vx = dx / dt;
+        const vy = dy / dt;
+        const trajectoryPredictionTimeInSeconds = this.trajectoryPredictionTime / 1000;
+        const predictedX = x + vx * trajectoryPredictionTimeInSeconds;
+        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;
+    };
+    isMouseInExpandedArea = (area, clientPoint, isAlreadyHovering) => {
+        const isInExpandedArea = clientPoint.x >= area.left &&
+            clientPoint.x <= area.right &&
+            clientPoint.y >= area.top &&
+            clientPoint.y <= area.bottom;
+        if (isInExpandedArea && !isAlreadyHovering) {
+            return { isHoveringInArea: true, shouldRunCallback: true };
+        }
+        return { isHoveringInArea: isInExpandedArea, shouldRunCallback: false };
+    };
+    handleMouseMove = (e) => {
+        this.currentPoint = { x: e.clientX, y: e.clientY };
+        this.predictedPoint = this.enableMouseTrajectory
+            ? this.predictMousePosition(this.currentPoint)
+            : this.currentPoint;
+        const linksToUpdateInDebugger = [];
+        this.links.forEach((linkData, element) => {
+            if (!linkData.expandedRect)
+                return;
+            const { isHoveringInArea, shouldRunCallback } = this.isMouseInExpandedArea(linkData.expandedRect, this.currentPoint, linkData.isHovering);
+            let linkStateChanged = false;
+            if (this.enableMouseTrajectory && !isHoveringInArea) {
+                if (this.pointIntersectsRect(this.predictedPoint.x, this.predictedPoint.y, linkData.expandedRect)) {
+                    if (!linkData.isTrajectoryHit) {
+                        linkData.callback();
+                        console.log("trajectory");
+                        this.links.set(element, {
+                            ...linkData,
+                            isTrajectoryHit: true,
+                            trajectoryHitTime: performance.now(),
+                            isHovering: isHoveringInArea,
+                        });
+                        linkStateChanged = true;
+                    }
+                }
+            }
+            if (linkData.isHovering !== isHoveringInArea) {
+                this.links.set(element, {
+                    ...linkData,
+                    isHovering: isHoveringInArea,
+                    isTrajectoryHit: this.links.get(element).isTrajectoryHit,
+                    trajectoryHitTime: this.links.get(element).trajectoryHitTime,
+                });
+                linkStateChanged = true;
+            }
+            if (linkStateChanged) {
+                linksToUpdateInDebugger.push(element);
+            }
+            if (shouldRunCallback) {
+                if (!linkData.isTrajectoryHit ||
+                    (linkData.isTrajectoryHit && !this.enableMouseTrajectory)) {
+                    linkData.callback();
+                    console.log("hover");
+                }
+            }
+        });
+        if (this.debugMode && this.debugger) {
+            linksToUpdateInDebugger.forEach((element) => {
+                const data = this.links.get(element);
+                if (data)
+                    this.debugger.createOrUpdateLinkOverlay(element, data);
+            });
+            this.debugger.updateTrajectoryVisuals(this.currentPoint, this.predictedPoint, this.enableMouseTrajectory);
+        }
+    };
+    // Throttled handler for resize and scroll events
+    handleResizeOrScroll = () => {
+        if (this.resizeScrollThrottleTimeoutId) {
+            clearTimeout(this.resizeScrollThrottleTimeoutId);
+        }
+        const now = performance.now();
+        const timeSinceLastCall = now - this.lastResizeScrollCallTimestamp;
+        if (timeSinceLastCall >= this.resizeScrollThrottleDelay) {
+            this.updateAllRects();
+            this.lastResizeScrollCallTimestamp = now;
+            this.resizeScrollThrottleTimeoutId = null;
+        }
+        else {
+            this.resizeScrollThrottleTimeoutId = setTimeout(() => {
+                this.updateAllRects();
+                this.lastResizeScrollCallTimestamp = performance.now();
+                this.resizeScrollThrottleTimeoutId = null;
+            }, this.resizeScrollThrottleDelay - timeSinceLastCall);
+        }
+    };
+    setupGlobalListeners() {
+        if (this.isSetup)
+            return;
+        document.addEventListener("mousemove", this.handleMouseMove);
+        // Use the throttled handler for resize and scroll
+        window.addEventListener("resize", this.handleResizeOrScroll);
+        window.addEventListener("scroll", this.handleResizeOrScroll);
+        this.isSetup = true;
+    }
+    removeGlobalListeners() {
+        document.removeEventListener("mousemove", this.handleMouseMove);
+        // Remove the throttled handler for resize and scroll
+        window.removeEventListener("resize", this.handleResizeOrScroll);
+        window.removeEventListener("scroll", this.handleResizeOrScroll);
+        // Clear any pending timeout for the throttled handler
+        if (this.resizeScrollThrottleTimeoutId) {
+            clearTimeout(this.resizeScrollThrottleTimeoutId);
+            this.resizeScrollThrottleTimeoutId = null;
+        }
+        this.isSetup = false;
+    }
+}
+exports.ForesightManager = ForesightManager;

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export { ForesightManager } from "./ForesightManager/ForesightManager";
+export * from "./types/types";

package/dist/index.js

@@ -0,0 +1,22 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ForesightManager = void 0;
+// Export the ForesightManager (currently called IntentManager)
+var ForesightManager_1 = require("./ForesightManager/ForesightManager");
+Object.defineProperty(exports, "ForesightManager", { enumerable: true, get: function () { return ForesightManager_1.ForesightManager; } });
+// Export any types you need
+__exportStar(require("./types/types"), exports);

package/dist/types/types.d.ts

@@ -0,0 +1,29 @@
+export type Rect = {
+    top: number;
+    left: number;
+    right: number;
+    bottom: number;
+};
+export type IntentCallback = () => void;
+export type LinkElement = HTMLAnchorElement;
+export type MousePosition = {
+    point: Point;
+    time: number;
+};
+export type Point = {
+    x: number;
+    y: number;
+};
+export type LinkData = {
+    callback: IntentCallback;
+    expandedRect: Rect | null;
+    isHovering: boolean;
+    isTrajectoryHit: boolean;
+    trajectoryHitTime: number;
+};
+export type IntentManagerProps = {
+    positionHistorySize: number;
+    trajectoryPredictionTime: number;
+    enableMouseTrajectory: boolean;
+    debug: boolean;
+};

package/dist/types/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "js.foresight",
+  "version": "0.0.5",
+  "description": "",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "clean": "rm -rf dist",
+    "build": "pnpm clean && tsc",
+    "prepublishOnly": "pnpm build",
+    "test": "cd ./test_project && pnpm dev"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "keywords": [],
+  "author": "Bart Spaans",
+  "license": "MIT",
+  "devDependencies": {
+    "@types/node": "^22.15.17",
+    "typescript": "^5.8.3"
+  }
+}