agentation-vue 0.2.2 → 0.2.4

package/dist/composables/useTextSelection.js

@@ -1,33 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.useTextSelection = useTextSelection;
-function useTextSelection(mode) {
-  function checkTextSelection(e) {
-    if (mode.value !== "inspect") return null;
-    if (e.shiftKey || e.altKey) return null;
-    const selection = window.getSelection();
-    const selectedText = selection?.toString().trim() ?? "";
-    if (selectedText.length >= 2 && selection?.rangeCount) {
-      const range = selection.getRangeAt(0);
-      const rect = range.getBoundingClientRect();
-      if (rect.width > 5) {
-        const anchorElement = range.commonAncestorContainer instanceof Element ? range.commonAncestorContainer : range.commonAncestorContainer.parentElement;
-        if (anchorElement) {
-          return {
-            selectedText,
-            range,
-            rect,
-            anchorElement
-          };
-        }
-      }
-    }
-    return null;
-  }
-  return {
-    checkTextSelection
-  };
-}

package/dist/composables/useToolbarAutoHide.js

@@ -1,270 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.useToolbarAutoHide = useToolbarAutoHide;
-var _vueDemi = require("vue-demi");
-const EDGE_OFFSET = 20;
-const DEFAULT_TOOLBAR_SIZE = 42;
-const ACTIVATION_EDGE_DEPTH = 16;
-const ACTIVATION_INLINE_PAD = 30;
-const ACTIVATION_CORNER_SIZE = 32;
-const KEEP_ALIVE_PADDING = 56;
-const HIDE_DELAY_MS = 140;
-const ENTER_LOCK_MS = 220;
-const CLICK_LOCK_MS = 320;
-function useToolbarAutoHide(options) {
-  const {
-    enabled,
-    expanded,
-    isDragging,
-    placement,
-    toolbarEl
-  } = options;
-  const isAutoHideRevealed = (0, _vueDemi.ref)(false);
-  const isAutoHideActive = (0, _vueDemi.computed)(() => enabled.value && !expanded.value && !isDragging.value);
-  let hideTimer = null;
-  let revealLockUntil = 0;
-  let listenersAttached = false;
-  function clearHideTimer() {
-    if (!hideTimer) {
-      return;
-    }
-    clearTimeout(hideTimer);
-    hideTimer = null;
-  }
-  function reveal() {
-    isAutoHideRevealed.value = true;
-    clearHideTimer();
-  }
-  function lockReveal(durationMs) {
-    revealLockUntil = Math.max(revealLockUntil, Date.now() + durationMs);
-    reveal();
-  }
-  function hideNow() {
-    clearHideTimer();
-    revealLockUntil = 0;
-    isAutoHideRevealed.value = false;
-  }
-  function scheduleHide() {
-    clearHideTimer();
-    hideTimer = setTimeout(() => {
-      if (Date.now() < revealLockUntil) {
-        scheduleHide();
-        return;
-      }
-      isAutoHideRevealed.value = false;
-      hideTimer = null;
-    }, HIDE_DELAY_MS);
-  }
-  function getToolbarSize() {
-    const el = toolbarEl.value;
-    return {
-      width: el?.offsetWidth ?? DEFAULT_TOOLBAR_SIZE,
-      height: el?.offsetHeight ?? DEFAULT_TOOLBAR_SIZE
-    };
-  }
-  function getCollapsedRect(anchor, size) {
-    const left = EDGE_OFFSET;
-    const top = EDGE_OFFSET;
-    const right = window.innerWidth - EDGE_OFFSET - size.width;
-    const bottom = window.innerHeight - EDGE_OFFSET - size.height;
-    const centerX = (window.innerWidth - size.width) / 2;
-    switch (anchor) {
-      case "top-left":
-        return {
-          left,
-          top,
-          right: left + size.width,
-          bottom: top + size.height
-        };
-      case "top-center":
-        return {
-          left: centerX,
-          top,
-          right: centerX + size.width,
-          bottom: top + size.height
-        };
-      case "top-right":
-        return {
-          left: right,
-          top,
-          right: right + size.width,
-          bottom: top + size.height
-        };
-      case "bottom-left":
-        return {
-          left,
-          top: bottom,
-          right: left + size.width,
-          bottom: bottom + size.height
-        };
-      case "bottom-center":
-        return {
-          left: centerX,
-          top: bottom,
-          right: centerX + size.width,
-          bottom: bottom + size.height
-        };
-      case "bottom-right":
-      default:
-        return {
-          left: right,
-          top: bottom,
-          right: right + size.width,
-          bottom: bottom + size.height
-        };
-    }
-  }
-  function getActivationRect(anchor, size) {
-    const W = window.innerWidth;
-    const H = window.innerHeight;
-    const centerX = W / 2;
-    switch (anchor) {
-      case "top-left":
-        return {
-          left: 0,
-          top: 0,
-          right: ACTIVATION_CORNER_SIZE,
-          bottom: ACTIVATION_CORNER_SIZE
-        };
-      case "top-center":
-        return {
-          left: centerX - size.width / 2 - ACTIVATION_INLINE_PAD,
-          top: 0,
-          right: centerX + size.width / 2 + ACTIVATION_INLINE_PAD,
-          bottom: ACTIVATION_EDGE_DEPTH
-        };
-      case "top-right":
-        return {
-          left: W - ACTIVATION_CORNER_SIZE,
-          top: 0,
-          right: W,
-          bottom: ACTIVATION_CORNER_SIZE
-        };
-      case "bottom-left":
-        return {
-          left: 0,
-          top: H - ACTIVATION_CORNER_SIZE,
-          right: ACTIVATION_CORNER_SIZE,
-          bottom: H
-        };
-      case "bottom-center":
-        return {
-          left: centerX - size.width / 2 - ACTIVATION_INLINE_PAD,
-          top: H - ACTIVATION_EDGE_DEPTH,
-          right: centerX + size.width / 2 + ACTIVATION_INLINE_PAD,
-          bottom: H
-        };
-      case "bottom-right":
-      default:
-        return {
-          left: W - ACTIVATION_CORNER_SIZE,
-          top: H - ACTIVATION_CORNER_SIZE,
-          right: W,
-          bottom: H
-        };
-    }
-  }
-  function inflateRect(rect, padding) {
-    return {
-      left: rect.left - padding,
-      top: rect.top - padding,
-      right: rect.right + padding,
-      bottom: rect.bottom + padding
-    };
-  }
-  function isInside(point, rect) {
-    return point.x >= rect.left && point.x <= rect.right && point.y >= rect.top && point.y <= rect.bottom;
-  }
-  function isInActivationZone(point, anchor, size) {
-    return isInside(point, getActivationRect(anchor, size));
-  }
-  function onGlobalPointerMove(e) {
-    if (!isAutoHideActive.value) {
-      return;
-    }
-    const size = getToolbarSize();
-    const point = {
-      x: e.clientX,
-      y: e.clientY
-    };
-    const keepAliveRect = inflateRect(getCollapsedRect(placement.value, size), KEEP_ALIVE_PADDING);
-    if (isInActivationZone(point, placement.value, size) || isAutoHideRevealed.value && isInside(point, keepAliveRect)) {
-      reveal();
-      return;
-    }
-    scheduleHide();
-  }
-  function onWindowBlur() {
-    if (isAutoHideActive.value) {
-      hideNow();
-    }
-  }
-  function addGlobalListeners() {
-    if (listenersAttached || typeof window === "undefined") {
-      return;
-    }
-    listenersAttached = true;
-    window.addEventListener("pointermove", onGlobalPointerMove, true);
-    window.addEventListener("blur", onWindowBlur);
-  }
-  function removeGlobalListeners() {
-    if (!listenersAttached || typeof window === "undefined") {
-      return;
-    }
-    listenersAttached = false;
-    window.removeEventListener("pointermove", onGlobalPointerMove, true);
-    window.removeEventListener("blur", onWindowBlur);
-  }
-  function onToolbarPointerEnter() {
-    if (!isAutoHideActive.value) {
-      return;
-    }
-    lockReveal(ENTER_LOCK_MS);
-  }
-  function onToolbarPointerLeave() {}
-  function onToolbarPointerDown() {
-    if (!isAutoHideActive.value) {
-      return;
-    }
-    lockReveal(CLICK_LOCK_MS);
-  }
-  function onToolbarFocusIn() {
-    if (!isAutoHideActive.value) {
-      return;
-    }
-    lockReveal(CLICK_LOCK_MS);
-  }
-  function onToolbarFocusOut() {
-    if (!isAutoHideActive.value) {
-      return;
-    }
-    scheduleHide();
-  }
-  (0, _vueDemi.watch)(isAutoHideActive, active => {
-    if (!active) {
-      removeGlobalListeners();
-      hideNow();
-      return;
-    }
-    addGlobalListeners();
-    isAutoHideRevealed.value = false;
-  }, {
-    immediate: true
-  });
-  (0, _vueDemi.onBeforeUnmount)(() => {
-    removeGlobalListeners();
-    clearHideTimer();
-  });
-  return {
-    isAutoHideActive,
-    isAutoHideRevealed,
-    onToolbarPointerEnter,
-    onToolbarPointerLeave,
-    onToolbarPointerDown,
-    onToolbarFocusIn,
-    onToolbarFocusOut
-  };
-}

package/dist/composables/useToolbarDragSnap.js

@@ -1,296 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.useToolbarDragSnap = useToolbarDragSnap;
-var _vueDemi = require("vue-demi");
-var _math = require("../utils/math");
-const TOOLBAR_SIZE = 42;
-const EDGE_OFFSET = 20;
-const LONG_PRESS_MS = 350;
-const HALF_TOOLBAR_SIZE = TOOLBAR_SIZE / 2;
-const TOOLBAR_ANCHORS = ["top-left", "top-center", "top-right", "bottom-left", "bottom-center", "bottom-right"];
-function isToolbarAnchor(value) {
-  return typeof value === "string" && TOOLBAR_ANCHORS.includes(value);
-}
-function useToolbarDragSnap(options) {
-  const {
-    expanded,
-    initialPlacement,
-    onDragStart,
-    onDragEnd
-  } = options;
-  const placement = (0, _vueDemi.ref)(isToolbarAnchor(initialPlacement) ? initialPlacement : "bottom-right");
-  const isDragging = (0, _vueDemi.ref)(false);
-  const dragPosition = (0, _vueDemi.ref)(null);
-  const suppressNextClick = (0, _vueDemi.ref)(false);
-  const activePointerId = (0, _vueDemi.ref)(null);
-  const toolbarEl = (0, _vueDemi.ref)(null);
-  const dragOffset = (0, _vueDemi.ref)({
-    x: HALF_TOOLBAR_SIZE,
-    y: HALF_TOOLBAR_SIZE
-  });
-  const dragSize = (0, _vueDemi.ref)({
-    width: TOOLBAR_SIZE,
-    height: TOOLBAR_SIZE
-  });
-  const dragSource = (0, _vueDemi.ref)(null);
-  const dragRotation = (0, _vueDemi.ref)(0);
-  let longPressTimer = null;
-  const snapAnchors = TOOLBAR_ANCHORS;
-  const isExpandedDrag = (0, _vueDemi.computed)(() => isDragging.value && dragSource.value === "handle");
-  const toolbarStyle = (0, _vueDemi.computed)(() => {
-    if (!isDragging.value || !dragPosition.value) {
-      return void 0;
-    }
-    return {
-      left: `${dragPosition.value.x}px`,
-      top: `${dragPosition.value.y}px`,
-      transform: `rotate(${dragRotation.value}deg)`
-    };
-  });
-  const activeSnapAnchor = (0, _vueDemi.computed)(() => {
-    const current = dragPosition.value;
-    if (!current) {
-      return null;
-    }
-    return findClosestAnchor(current.x + dragSize.value.width / 2, current.y + dragSize.value.height / 2);
-  });
-  function getAnchorRects(size) {
-    const top = EDGE_OFFSET;
-    const bottom = window.innerHeight - EDGE_OFFSET - size.height;
-    const left = EDGE_OFFSET;
-    const right = window.innerWidth - EDGE_OFFSET - size.width;
-    const centerX = (window.innerWidth - size.width) / 2;
-    return {
-      "top-left": {
-        x: left,
-        y: top,
-        width: size.width,
-        height: size.height
-      },
-      "top-center": {
-        x: centerX,
-        y: top,
-        width: size.width,
-        height: size.height
-      },
-      "top-right": {
-        x: right,
-        y: top,
-        width: size.width,
-        height: size.height
-      },
-      "bottom-left": {
-        x: left,
-        y: bottom,
-        width: size.width,
-        height: size.height
-      },
-      "bottom-center": {
-        x: centerX,
-        y: bottom,
-        width: size.width,
-        height: size.height
-      },
-      "bottom-right": {
-        x: right,
-        y: bottom,
-        width: size.width,
-        height: size.height
-      }
-    };
-  }
-  function getSnapPoints(size) {
-    const rects = getAnchorRects(size);
-    const result = {};
-    for (const anchor of snapAnchors) {
-      const r = rects[anchor];
-      result[anchor] = {
-        x: r.x + r.width / 2,
-        y: r.y + r.height / 2
-      };
-    }
-    return result;
-  }
-  function findClosestAnchor(x, y) {
-    const points = getSnapPoints(dragSize.value);
-    let closest = "bottom-right";
-    let bestDistance = Number.POSITIVE_INFINITY;
-    for (const [anchor, point] of Object.entries(points)) {
-      const dx = point.x - x;
-      const dy = point.y - y;
-      const distance = dx * dx + dy * dy;
-      if (distance < bestDistance) {
-        bestDistance = distance;
-        closest = anchor;
-      }
-    }
-    return closest;
-  }
-  function captureDragMetrics(clientX, clientY) {
-    const rect = toolbarEl.value?.getBoundingClientRect();
-    if (!rect) {
-      return;
-    }
-    dragOffset.value = {
-      x: clientX - rect.left,
-      y: clientY - rect.top
-    };
-    dragSize.value = {
-      width: rect.width,
-      height: rect.height
-    };
-  }
-  function updateDragPosition(clientX, clientY) {
-    const {
-      width,
-      height
-    } = dragSize.value;
-    dragPosition.value = {
-      x: (0, _math.clamp)(clientX - dragOffset.value.x, 0, window.innerWidth - width),
-      y: (0, _math.clamp)(clientY - dragOffset.value.y, 0, window.innerHeight - height)
-    };
-  }
-  function clearLongPressTimer() {
-    if (longPressTimer) {
-      clearTimeout(longPressTimer);
-      longPressTimer = null;
-    }
-  }
-  function finishDrag(clientX, clientY) {
-    updateDragPosition(clientX, clientY);
-    const current = dragPosition.value;
-    if (current) {
-      placement.value = findClosestAnchor(current.x + dragSize.value.width / 2, current.y + dragSize.value.height / 2);
-    }
-    isDragging.value = false;
-    dragPosition.value = null;
-    onDragEnd?.();
-  }
-  function getSnapStyle(anchor) {
-    const rect = getAnchorRects(dragSize.value)[anchor];
-    if (isExpandedDrag.value) {
-      return {
-        left: `${rect.x}px`,
-        top: `${rect.y}px`,
-        width: `${rect.width}px`,
-        height: `${rect.height}px`
-      };
-    }
-    return {
-      left: `${rect.x + rect.width / 2}px`,
-      top: `${rect.y + rect.height / 2}px`
-    };
-  }
-  function startDragPointer(e, source, options2) {
-    if (e.button !== 0) {
-      return;
-    }
-    activePointerId.value = e.pointerId;
-    dragSource.value = source;
-    captureDragMetrics(e.clientX, e.clientY);
-    const target = e.currentTarget;
-    target?.setPointerCapture?.(e.pointerId);
-    clearLongPressTimer();
-    dragRotation.value = (2 + Math.random() * 3) * (Math.random() < 0.5 ? -1 : 1);
-    if (options2.immediate) {
-      dragRotation.value = (Math.random() * 4 + 1) * (Math.random() < 0.5 ? -1 : 1);
-      isDragging.value = true;
-      onDragStart?.();
-      updateDragPosition(e.clientX, e.clientY);
-      return;
-    }
-    longPressTimer = setTimeout(() => {
-      if (activePointerId.value !== e.pointerId || expanded.value) {
-        return;
-      }
-      dragRotation.value = (Math.random() * 4 + 1) * (Math.random() < 0.5 ? -1 : 1);
-      isDragging.value = true;
-      onDragStart?.();
-      updateDragPosition(e.clientX, e.clientY);
-    }, LONG_PRESS_MS);
-  }
-  function onTogglePointerDown(e) {
-    if (expanded.value) {
-      return;
-    }
-    startDragPointer(e, "toggle", {
-      immediate: false
-    });
-  }
-  function onHandlePointerDown(e) {
-    if (!expanded.value) {
-      return;
-    }
-    startDragPointer(e, "handle", {
-      immediate: true
-    });
-  }
-  function onPointerMove(e) {
-    if (!isDragging.value || activePointerId.value !== e.pointerId) {
-      return;
-    }
-    updateDragPosition(e.clientX, e.clientY);
-  }
-  function onPointerUp(e) {
-    if (activePointerId.value !== e.pointerId) {
-      return;
-    }
-    clearLongPressTimer();
-    if (isDragging.value) {
-      finishDrag(e.clientX, e.clientY);
-      if (dragSource.value === "toggle") {
-        suppressNextClick.value = true;
-      }
-    }
-    activePointerId.value = null;
-    dragSource.value = null;
-    const target = e.currentTarget;
-    target?.releasePointerCapture?.(e.pointerId);
-  }
-  function onPointerCancel() {
-    if (isDragging.value) {
-      onDragEnd?.();
-    }
-    clearLongPressTimer();
-    isDragging.value = false;
-    dragPosition.value = null;
-    activePointerId.value = null;
-    dragSource.value = null;
-  }
-  function consumeToggleClickSuppression() {
-    if (!suppressNextClick.value) {
-      return false;
-    }
-    suppressNextClick.value = false;
-    return true;
-  }
-  function cleanup() {
-    clearLongPressTimer();
-    if (isDragging.value) {
-      isDragging.value = false;
-      onDragEnd?.();
-    }
-    activePointerId.value = null;
-    dragSource.value = null;
-  }
-  return {
-    placement,
-    isDragging,
-    toolbarStyle,
-    toolbarEl,
-    snapAnchors,
-    activeSnapAnchor,
-    isExpandedDrag,
-    getSnapStyle,
-    onTogglePointerDown,
-    onHandlePointerDown,
-    onPointerMove,
-    onPointerUp,
-    onPointerCancel,
-    consumeToggleClickSuppression,
-    cleanup
-  };
-}

package/dist/constants.js

@@ -1,8 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.VA_DATA_ATTR_SELECTOR = exports.VA_DATA_ATTR = void 0;
-const VA_DATA_ATTR = exports.VA_DATA_ATTR = "data-agentation-vue";
-const VA_DATA_ATTR_SELECTOR = exports.VA_DATA_ATTR_SELECTOR = "[data-agentation-vue]";