@jspsych/plugin-tobii-calibration 0.1.1

package/dist/index.js

@@ -0,0 +1,837 @@
+import { ParameterType } from 'jspsych';
+
+var version = "0.1.1";
+
+class CalibrationDisplay {
+  constructor(displayElement, params) {
+    this.displayElement = displayElement;
+    this.params = params;
+    this.currentPoint = null;
+    this.progressElement = null;
+    this.currentX = 0.5;
+    this.currentY = 0.5;
+    this.container = this.createContainer();
+    this.displayElement.appendChild(this.container);
+    if (params.show_progress) {
+      this.progressElement = this.createProgressIndicator();
+      this.displayElement.appendChild(this.progressElement);
+    }
+  }
+  /**
+   * Create container element
+   */
+  createContainer() {
+    const container = document.createElement("div");
+    container.className = "tobii-calibration-container";
+    return container;
+  }
+  /**
+   * Create progress indicator
+   */
+  createProgressIndicator() {
+    const progress = document.createElement("div");
+    progress.className = "tobii-calibration-progress";
+    progress.setAttribute("role", "status");
+    progress.setAttribute("aria-live", "polite");
+    return progress;
+  }
+  /**
+   * Show instructions
+   */
+  async showInstructions() {
+    const wrapper = document.createElement("div");
+    wrapper.className = "tobii-calibration-instructions";
+    wrapper.setAttribute("role", "dialog");
+    wrapper.setAttribute("aria-label", "Eye tracker calibration instructions");
+    const content = document.createElement("div");
+    content.className = "instructions-content";
+    const heading = document.createElement("h2");
+    heading.textContent = "Eye Tracker Calibration";
+    content.appendChild(heading);
+    const paragraph = document.createElement("p");
+    paragraph.innerHTML = this.params.instructions || "Look at each point and follow the instructions.";
+    content.appendChild(paragraph);
+    if (this.params.calibration_mode === "click") {
+      const button = document.createElement("button");
+      button.className = "calibration-start-btn";
+      button.textContent = this.params.button_text || "Start Calibration";
+      content.appendChild(button);
+    } else {
+      const autoMsg = document.createElement("p");
+      autoMsg.textContent = "Starting in a moment...";
+      content.appendChild(autoMsg);
+    }
+    wrapper.appendChild(content);
+    this.container.appendChild(wrapper);
+    if (this.params.calibration_mode === "click") {
+      return new Promise((resolve) => {
+        const button = wrapper.querySelector("button");
+        button?.addEventListener("click", () => {
+          wrapper.remove();
+          resolve();
+        });
+      });
+    } else {
+      await this.delay(this.params.instruction_display_duration || 3e3);
+      wrapper.remove();
+    }
+  }
+  /**
+   * Initialize the traveling point at screen center
+   */
+  async initializePoint() {
+    if (this.currentPoint)
+      return;
+    this.currentPoint = document.createElement("div");
+    this.currentPoint.className = "tobii-calibration-point";
+    this.currentPoint.setAttribute("role", "img");
+    this.currentPoint.setAttribute("aria-label", "Calibration target point");
+    const x = 0.5 * window.innerWidth;
+    const y = 0.5 * window.innerHeight;
+    this.currentX = 0.5;
+    this.currentY = 0.5;
+    Object.assign(this.currentPoint.style, {
+      left: `${x}px`,
+      top: `${y}px`,
+      width: `${this.params.point_size || 20}px`,
+      height: `${this.params.point_size || 20}px`,
+      backgroundColor: this.params.point_color || "#ff0000",
+      transition: "none"
+    });
+    this.container.appendChild(this.currentPoint);
+    await this.delay(this.params.zoom_duration || 300);
+  }
+  /**
+   * Travel to the next point location with smooth animation
+   */
+  async travelToPoint(point, index, total) {
+    if (!this.currentPoint) {
+      await this.initializePoint();
+    }
+    if (this.progressElement) {
+      this.progressElement.textContent = `Point ${index + 1} of ${total}`;
+    }
+    this.currentPoint.setAttribute("aria-label", `Calibration target point ${index + 1} of ${total}`);
+    const dx = point.x - this.currentX;
+    const dy = point.y - this.currentY;
+    const distance = Math.sqrt(dx * dx + dy * dy);
+    const travelDuration = Math.max(150, Math.min(400, 150 + distance * 200));
+    const x = point.x * window.innerWidth;
+    const y = point.y * window.innerHeight;
+    this.currentPoint.style.transition = `left ${travelDuration}ms ease-in-out, top ${travelDuration}ms ease-in-out`;
+    this.currentPoint.classList.remove("animation-explosion", "animation-shrink", "animation-pulse", "animation-zoom-out", "animation-zoom-in");
+    this.currentPoint.style.left = `${x}px`;
+    this.currentPoint.style.top = `${y}px`;
+    this.currentX = point.x;
+    this.currentY = point.y;
+    await this.delay(travelDuration);
+  }
+  /**
+   * Play zoom out animation (point grows larger)
+   */
+  async playZoomOut() {
+    if (!this.currentPoint)
+      return;
+    this.currentPoint.style.transition = "none";
+    this.currentPoint.classList.remove("animation-shrink", "animation-pulse", "animation-explosion", "animation-zoom-in");
+    this.currentPoint.classList.add("animation-zoom-out");
+    await this.delay(this.params.zoom_duration || 300);
+  }
+  /**
+   * Play zoom in animation (point shrinks to fixation size)
+   */
+  async playZoomIn() {
+    if (!this.currentPoint)
+      return;
+    this.currentPoint.classList.remove("animation-zoom-out");
+    this.currentPoint.classList.add("animation-zoom-in");
+    await this.delay(this.params.zoom_duration || 300);
+  }
+  /**
+   * Play explosion animation on the current point
+   */
+  async playExplosion(success) {
+    if (!this.currentPoint)
+      return;
+    this.currentPoint.classList.remove("animation-pulse", "animation-shrink");
+    this.currentPoint.classList.add("animation-explosion");
+    if (success) {
+      this.currentPoint.style.backgroundColor = "#4ade80";
+    } else {
+      this.currentPoint.style.backgroundColor = "#f87171";
+    }
+    await this.delay(this.params.explosion_duration || 400);
+  }
+  /**
+   * Hide current calibration point (removes element)
+   */
+  async hidePoint() {
+    if (this.currentPoint) {
+      this.currentPoint.remove();
+      this.currentPoint = null;
+    }
+    await this.delay(200);
+  }
+  /**
+   * Reset point state after explosion (keeps element for continued travel)
+   */
+  async resetPointAfterExplosion() {
+    if (!this.currentPoint)
+      return;
+    this.currentPoint.classList.remove("animation-explosion");
+    this.currentPoint.style.transform = "translate(-50%, -50%) scale(1)";
+    this.currentPoint.style.opacity = "1";
+    this.currentPoint.style.backgroundColor = this.params.point_color || "#ff0000";
+    await this.delay(50);
+  }
+  /**
+   * Wait for user click (in click mode)
+   */
+  waitForClick() {
+    return new Promise((resolve) => {
+      const handleClick = () => {
+        document.removeEventListener("click", handleClick);
+        resolve();
+      };
+      document.addEventListener("click", handleClick);
+    });
+  }
+  /**
+   * Show calibration result
+   * @param success Whether calibration succeeded
+   * @param canRetry Whether a retry button should be shown on failure
+   * @returns 'retry' if user chose to retry, 'continue' otherwise
+   */
+  async showResult(success, canRetry = false) {
+    const result = document.createElement("div");
+    result.className = "tobii-calibration-result";
+    result.setAttribute("role", "alert");
+    result.setAttribute("aria-live", "assertive");
+    if (success) {
+      result.innerHTML = `
+        <div class="tobii-calibration-result-content success">
+          <h2>Calibration Successful!</h2>
+          <p>Continuing automatically...</p>
+        </div>
+      `;
+      this.container.appendChild(result);
+      await this.delay(this.params.success_display_duration || 2e3);
+      result.remove();
+      return "continue";
+    }
+    const buttonsHTML = canRetry ? `<button class="calibration-retry-btn">Retry</button>
+         <button class="calibration-continue-btn" style="margin-left: 10px;">Continue</button>` : `<button class="calibration-continue-btn">Continue</button>`;
+    result.innerHTML = `
+      <div class="tobii-calibration-result-content error">
+        <h2>Calibration Failed</h2>
+        <p>Please try again or continue.</p>
+        ${buttonsHTML}
+      </div>
+    `;
+    this.container.appendChild(result);
+    return new Promise((resolve) => {
+      const retryBtn = result.querySelector(".calibration-retry-btn");
+      const continueBtn = result.querySelector(".calibration-continue-btn");
+      retryBtn?.addEventListener("click", () => {
+        result.remove();
+        resolve("retry");
+      });
+      continueBtn?.addEventListener("click", () => {
+        result.remove();
+        resolve("continue");
+      });
+    });
+  }
+  /**
+   * Reset display state for a retry attempt
+   */
+  resetForRetry() {
+    this.container.innerHTML = "";
+    this.currentPoint = null;
+    this.currentX = 0.5;
+    this.currentY = 0.5;
+  }
+  /**
+   * Clear display
+   */
+  clear() {
+    this.container.innerHTML = "";
+    if (this.progressElement) {
+      this.progressElement.textContent = "";
+    }
+  }
+  /**
+   * Delay helper
+   */
+  delay(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+}
+
+const info = {
+  name: "tobii-calibration",
+  version,
+  parameters: {
+    /** Number of calibration points (5 or 9) */
+    calibration_points: {
+      type: ParameterType.INT,
+      default: 9
+    },
+    /** Calibration mode: click or view */
+    calibration_mode: {
+      type: ParameterType.STRING,
+      default: "view"
+    },
+    /** Size of calibration points in pixels */
+    point_size: {
+      type: ParameterType.INT,
+      default: 20
+    },
+    /** Color of calibration points */
+    point_color: {
+      type: ParameterType.STRING,
+      default: "#ff0000"
+    },
+    /** Duration to show each point before data collection (ms) - allows user to fixate */
+    point_duration: {
+      type: ParameterType.INT,
+      default: 500
+    },
+    /** Show progress indicator */
+    show_progress: {
+      type: ParameterType.BOOL,
+      default: true
+    },
+    /** Custom calibration points */
+    custom_points: {
+      type: ParameterType.COMPLEX,
+      default: null
+    },
+    /** Instructions text */
+    instructions: {
+      type: ParameterType.STRING,
+      default: "Look at each point as it appears on the screen. Keep your gaze fixed on each point until it disappears."
+    },
+    /** Button text for click mode */
+    button_text: {
+      type: ParameterType.STRING,
+      default: "Start Calibration"
+    },
+    /** Background color of the calibration container */
+    background_color: {
+      type: ParameterType.STRING,
+      default: "#808080"
+    },
+    /** Primary button color */
+    button_color: {
+      type: ParameterType.STRING,
+      default: "#007bff"
+    },
+    /** Primary button hover color */
+    button_hover_color: {
+      type: ParameterType.STRING,
+      default: "#0056b3"
+    },
+    /** Retry button color */
+    retry_button_color: {
+      type: ParameterType.STRING,
+      default: "#dc3545"
+    },
+    /** Retry button hover color */
+    retry_button_hover_color: {
+      type: ParameterType.STRING,
+      default: "#c82333"
+    },
+    /** Success message color */
+    success_color: {
+      type: ParameterType.STRING,
+      default: "#28a745"
+    },
+    /** Error message color */
+    error_color: {
+      type: ParameterType.STRING,
+      default: "#dc3545"
+    },
+    /** Maximum number of retry attempts allowed on calibration failure */
+    max_retries: {
+      type: ParameterType.INT,
+      default: 1
+    },
+    /** Duration of zoom in/out animations in ms */
+    zoom_duration: {
+      type: ParameterType.INT,
+      default: 300
+    },
+    /** Duration of explosion animation in ms */
+    explosion_duration: {
+      type: ParameterType.INT,
+      default: 400
+    },
+    /** Duration to show success result before auto-advancing in ms */
+    success_display_duration: {
+      type: ParameterType.INT,
+      default: 2e3
+    },
+    /** Duration to show instructions before auto-advancing in view mode in ms */
+    instruction_display_duration: {
+      type: ParameterType.INT,
+      default: 3e3
+    }
+  },
+  data: {
+    /** Calibration success status */
+    calibration_success: {
+      type: ParameterType.BOOL
+    },
+    /** Number of calibration points used */
+    num_points: {
+      type: ParameterType.INT
+    },
+    /** Calibration mode used */
+    mode: {
+      type: ParameterType.STRING
+    },
+    /** Full calibration result data */
+    calibration_data: {
+      type: ParameterType.COMPLEX
+    },
+    /** Number of calibration attempts made */
+    num_attempts: {
+      type: ParameterType.INT
+    }
+  }
+};
+class TobiiCalibrationPlugin {
+  constructor(jsPsych) {
+    this.jsPsych = jsPsych;
+  }
+  static {
+    this.info = info;
+  }
+  static removeStyles() {
+    const el = document.getElementById("tobii-calibration-styles");
+    if (el) {
+      el.remove();
+    }
+  }
+  injectStyles(trial) {
+    TobiiCalibrationPlugin.removeStyles();
+    const css = `
+      .tobii-calibration-container {
+        position: fixed;
+        top: 0;
+        left: 0;
+        width: 100%;
+        height: 100%;
+        background-color: ${trial.background_color};
+        font-family: 'Open Sans', -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, Oxygen, Ubuntu, sans-serif;
+        z-index: 9999;
+      }
+
+      .tobii-calibration-instructions {
+        position: absolute;
+        top: 50%;
+        left: 50%;
+        transform: translate(-50%, -50%);
+        background-color: white;
+        padding: 40px;
+        border-radius: 10px;
+        box-shadow: 0 4px 6px rgba(0, 0, 0, 0.1);
+        text-align: center;
+        max-width: 600px;
+      }
+
+      .tobii-calibration-instructions h2 {
+        margin-top: 0;
+        margin-bottom: 20px;
+        font-size: 24px;
+        color: #333;
+      }
+
+      .tobii-calibration-instructions p {
+        margin-bottom: 20px;
+        font-size: 16px;
+        line-height: 1.5;
+        color: #666;
+      }
+
+      .calibration-start-btn,
+      .calibration-continue-btn,
+      .calibration-retry-btn {
+        background-color: ${trial.button_color};
+        color: white;
+        border: none;
+        padding: 12px 30px;
+        font-size: 16px;
+        border-radius: 5px;
+        cursor: pointer;
+        transition: background-color 0.3s;
+      }
+
+      .calibration-start-btn:hover,
+      .calibration-continue-btn:hover {
+        background-color: ${trial.button_hover_color};
+      }
+
+      .calibration-retry-btn {
+        background-color: ${trial.retry_button_color};
+      }
+
+      .calibration-retry-btn:hover {
+        background-color: ${trial.retry_button_hover_color};
+      }
+
+      .tobii-calibration-point {
+        position: absolute;
+        border-radius: 50%;
+        transform: translate(-50%, -50%);
+        cursor: pointer;
+        box-shadow: 0 0 10px rgba(0, 0, 0, 0.3);
+      }
+
+      .tobii-calibration-point.animation-pulse {
+        animation: tobii-calibration-pulse 1s infinite;
+      }
+
+      @keyframes tobii-calibration-pulse {
+        0%, 100% {
+          transform: translate(-50%, -50%) scale(1);
+          opacity: 1;
+        }
+        50% {
+          transform: translate(-50%, -50%) scale(1.2);
+          opacity: 0.8;
+        }
+      }
+
+      .tobii-calibration-point.animation-shrink {
+        animation: tobii-calibration-shrink 1s ease-out;
+      }
+
+      @keyframes tobii-calibration-shrink {
+        0% {
+          transform: translate(-50%, -50%) scale(3);
+          opacity: 0.5;
+        }
+        100% {
+          transform: translate(-50%, -50%) scale(1);
+          opacity: 1;
+        }
+      }
+
+      .tobii-calibration-point.animation-explosion {
+        animation: tobii-calibration-explosion ${trial.explosion_duration / 1e3}s ease-out forwards;
+      }
+
+      @keyframes tobii-calibration-explosion {
+        0% {
+          transform: translate(-50%, -50%) scale(1);
+          opacity: 1;
+        }
+        50% {
+          transform: translate(-50%, -50%) scale(2);
+          opacity: 0.8;
+        }
+        100% {
+          transform: translate(-50%, -50%) scale(0);
+          opacity: 0;
+        }
+      }
+
+      .tobii-calibration-point.animation-zoom-out {
+        animation: tobii-calibration-zoom-out ${trial.zoom_duration / 1e3}s ease-out forwards;
+      }
+
+      @keyframes tobii-calibration-zoom-out {
+        0% {
+          transform: translate(-50%, -50%) scale(1);
+        }
+        100% {
+          transform: translate(-50%, -50%) scale(2.5);
+        }
+      }
+
+      .tobii-calibration-point.animation-zoom-in {
+        animation: tobii-calibration-zoom-in ${trial.zoom_duration / 1e3}s ease-out forwards;
+      }
+
+      @keyframes tobii-calibration-zoom-in {
+        0% {
+          transform: translate(-50%, -50%) scale(2.5);
+        }
+        100% {
+          transform: translate(-50%, -50%) scale(1);
+        }
+      }
+
+      .tobii-calibration-progress {
+        position: fixed;
+        top: 20px;
+        left: 50%;
+        transform: translateX(-50%);
+        background-color: rgba(0, 0, 0, 0.7);
+        color: white;
+        padding: 10px 20px;
+        border-radius: 5px;
+        font-size: 14px;
+        z-index: 10000;
+      }
+
+      .tobii-calibration-result {
+        position: absolute;
+        top: 50%;
+        left: 50%;
+        transform: translate(-50%, -50%);
+        background-color: white;
+        padding: 40px;
+        border-radius: 10px;
+        box-shadow: 0 4px 6px rgba(0, 0, 0, 0.1);
+        text-align: center;
+      }
+
+      .tobii-calibration-result-content h2 {
+        margin-top: 0;
+        margin-bottom: 20px;
+        font-size: 24px;
+      }
+
+      .tobii-calibration-result-content.success h2 {
+        color: ${trial.success_color};
+      }
+
+      .tobii-calibration-result-content.error h2 {
+        color: ${trial.error_color};
+      }
+
+      .tobii-calibration-result-content p {
+        margin-bottom: 20px;
+        font-size: 16px;
+        color: #666;
+      }
+    `;
+    const styleElement = document.createElement("style");
+    styleElement.id = "tobii-calibration-styles";
+    styleElement.textContent = css;
+    document.head.appendChild(styleElement);
+  }
+  async trial(display_element, trial) {
+    this.injectStyles(trial);
+    const tobiiExt = this.jsPsych.extensions.tobii;
+    if (!tobiiExt) {
+      throw new Error("Tobii extension not initialized");
+    }
+    if (!tobiiExt.isConnected()) {
+      throw new Error("Not connected to Tobii server");
+    }
+    const calibrationDisplay = new CalibrationDisplay(
+      display_element,
+      trial
+    );
+    await calibrationDisplay.showInstructions();
+    let points;
+    if (trial.custom_points) {
+      points = this.validateCustomPoints(trial.custom_points);
+    } else {
+      points = this.getCalibrationPoints(trial.calibration_points);
+    }
+    const maxAttempts = 1 + trial.max_retries;
+    let attempt = 0;
+    let calibrationResult = { success: false };
+    try {
+      while (attempt < maxAttempts) {
+        attempt++;
+        const retriesRemaining = maxAttempts - attempt;
+        await tobiiExt.startCalibration();
+        await calibrationDisplay.initializePoint();
+        for (let i = 0; i < points.length; i++) {
+          const point = points[i];
+          await calibrationDisplay.travelToPoint(point, i, points.length);
+          await calibrationDisplay.playZoomOut();
+          await calibrationDisplay.playZoomIn();
+          if (trial.calibration_mode === "click") {
+            await calibrationDisplay.waitForClick();
+          } else {
+            await this.delay(trial.point_duration);
+          }
+          const result = await tobiiExt.collectCalibrationPoint(point.x, point.y);
+          await calibrationDisplay.playExplosion(result.success);
+          if (i < points.length - 1) {
+            await calibrationDisplay.resetPointAfterExplosion();
+          }
+        }
+        await calibrationDisplay.hidePoint();
+        calibrationResult = await tobiiExt.computeCalibration();
+        const userChoice = await calibrationDisplay.showResult(
+          calibrationResult.success,
+          retriesRemaining > 0
+        );
+        if (userChoice === "continue") {
+          break;
+        }
+        calibrationDisplay.resetForRetry();
+      }
+    } finally {
+      calibrationDisplay.clear();
+      display_element.innerHTML = "";
+      TobiiCalibrationPlugin.removeStyles();
+    }
+    const trial_data = {
+      calibration_success: calibrationResult.success,
+      num_points: points.length,
+      mode: trial.calibration_mode,
+      calibration_data: calibrationResult,
+      num_attempts: attempt
+    };
+    this.jsPsych.finishTrial(trial_data);
+  }
+  /**
+   * Validate custom calibration points
+   */
+  validateCustomPoints(points) {
+    if (!Array.isArray(points) || points.length === 0) {
+      throw new Error("custom_points must be a non-empty array");
+    }
+    const validated = [];
+    for (let i = 0; i < points.length; i++) {
+      const point = points[i];
+      if (typeof point !== "object" || point === null) {
+        throw new Error(`Invalid calibration point at index ${i}: must have numeric x and y`);
+      }
+      const p = point;
+      if (typeof p.x !== "number" || typeof p.y !== "number") {
+        throw new Error(`Invalid calibration point at index ${i}: must have numeric x and y`);
+      }
+      if (p.x < 0 || p.x > 1 || p.y < 0 || p.y > 1) {
+        throw new Error(
+          `Calibration point at index ${i} out of range: x and y must be between 0 and 1`
+        );
+      }
+      validated.push({ x: p.x, y: p.y });
+    }
+    return validated;
+  }
+  /**
+   * Get standard calibration points for the given grid size
+   */
+  getCalibrationPoints(count) {
+    switch (count) {
+      case 5:
+        return [
+          { x: 0.1, y: 0.1 },
+          { x: 0.9, y: 0.1 },
+          { x: 0.5, y: 0.5 },
+          { x: 0.1, y: 0.9 },
+          { x: 0.9, y: 0.9 }
+        ];
+      case 9:
+        return [
+          { x: 0.1, y: 0.1 },
+          { x: 0.5, y: 0.1 },
+          { x: 0.9, y: 0.1 },
+          { x: 0.1, y: 0.5 },
+          { x: 0.5, y: 0.5 },
+          { x: 0.9, y: 0.5 },
+          { x: 0.1, y: 0.9 },
+          { x: 0.5, y: 0.9 },
+          { x: 0.9, y: 0.9 }
+        ];
+      case 13:
+        return [
+          { x: 0.1, y: 0.1 },
+          { x: 0.5, y: 0.1 },
+          { x: 0.9, y: 0.1 },
+          { x: 0.3, y: 0.3 },
+          { x: 0.7, y: 0.3 },
+          { x: 0.1, y: 0.5 },
+          { x: 0.5, y: 0.5 },
+          { x: 0.9, y: 0.5 },
+          { x: 0.3, y: 0.7 },
+          { x: 0.7, y: 0.7 },
+          { x: 0.1, y: 0.9 },
+          { x: 0.5, y: 0.9 },
+          { x: 0.9, y: 0.9 }
+        ];
+      case 15:
+        return [
+          { x: 0.1, y: 0.1 },
+          { x: 0.5, y: 0.1 },
+          { x: 0.9, y: 0.1 },
+          { x: 0.1, y: 0.3 },
+          { x: 0.5, y: 0.3 },
+          { x: 0.9, y: 0.3 },
+          { x: 0.1, y: 0.5 },
+          { x: 0.5, y: 0.5 },
+          { x: 0.9, y: 0.5 },
+          { x: 0.1, y: 0.7 },
+          { x: 0.5, y: 0.7 },
+          { x: 0.9, y: 0.7 },
+          { x: 0.1, y: 0.9 },
+          { x: 0.5, y: 0.9 },
+          { x: 0.9, y: 0.9 }
+        ];
+      case 19:
+        return [
+          { x: 0.1, y: 0.1 },
+          { x: 0.5, y: 0.1 },
+          { x: 0.9, y: 0.1 },
+          { x: 0.1, y: 0.3 },
+          { x: 0.3, y: 0.3 },
+          { x: 0.5, y: 0.3 },
+          { x: 0.7, y: 0.3 },
+          { x: 0.9, y: 0.3 },
+          { x: 0.1, y: 0.5 },
+          { x: 0.5, y: 0.5 },
+          { x: 0.9, y: 0.5 },
+          { x: 0.1, y: 0.7 },
+          { x: 0.3, y: 0.7 },
+          { x: 0.5, y: 0.7 },
+          { x: 0.7, y: 0.7 },
+          { x: 0.9, y: 0.7 },
+          { x: 0.1, y: 0.9 },
+          { x: 0.5, y: 0.9 },
+          { x: 0.9, y: 0.9 }
+        ];
+      case 25:
+        return [
+          { x: 0.1, y: 0.1 },
+          { x: 0.3, y: 0.1 },
+          { x: 0.5, y: 0.1 },
+          { x: 0.7, y: 0.1 },
+          { x: 0.9, y: 0.1 },
+          { x: 0.1, y: 0.3 },
+          { x: 0.3, y: 0.3 },
+          { x: 0.5, y: 0.3 },
+          { x: 0.7, y: 0.3 },
+          { x: 0.9, y: 0.3 },
+          { x: 0.1, y: 0.5 },
+          { x: 0.3, y: 0.5 },
+          { x: 0.5, y: 0.5 },
+          { x: 0.7, y: 0.5 },
+          { x: 0.9, y: 0.5 },
+          { x: 0.1, y: 0.7 },
+          { x: 0.3, y: 0.7 },
+          { x: 0.5, y: 0.7 },
+          { x: 0.7, y: 0.7 },
+          { x: 0.9, y: 0.7 },
+          { x: 0.1, y: 0.9 },
+          { x: 0.3, y: 0.9 },
+          { x: 0.5, y: 0.9 },
+          { x: 0.7, y: 0.9 },
+          { x: 0.9, y: 0.9 }
+        ];
+      default:
+        throw new Error(
+          `Unsupported calibration_points value: ${count}. Use 5, 9, 13, 15, 19, or 25, or provide custom_points.`
+        );
+    }
+  }
+  /**
+   * Delay helper
+   */
+  delay(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+}
+
+export { TobiiCalibrationPlugin as default };
+//# sourceMappingURL=index.js.map