"use strict";
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __export = (target, all) => {
  for (var name in all)
    __defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
  if (from && typeof from === "object" || typeof from === "function") {
    for (let key of __getOwnPropNames(from))
      if (!__hasOwnProp.call(to, key) && key !== except)
        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
  }
  return to;
};
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
var PointingHandle_exports = {};
__export(PointingHandle_exports, {
  PointingHandle: () => PointingHandle
});
module.exports = __toCommonJS(PointingHandle_exports);
var import_editor = require("@tldraw/editor");
var import_arrowTargetState = require("../../../shapes/arrow/arrowTargetState");
var import_shared = require("../../../shapes/arrow/shared");
var import_noteHelpers = require("../../../shapes/note/noteHelpers");
var import_getDisplayValues = require("../../../shapes/shared/getDisplayValues");
var import_selectHelpers = require("../selectHelpers");
class PointingHandle extends import_editor.StateNode {
  static id = "pointing_handle";
  didCtrlOnEnter = false;
  info = {};
  onEnter(info) {
    this.info = info;
    this.didCtrlOnEnter = info.accelKey;
    const { shape } = info;
    if (this.editor.isShapeOfType(shape, "arrow")) {
      const initialBindings = (0, import_shared.getArrowBindings)(this.editor, shape);
      const currentBinding = initialBindings[info.handle.id];
      const oppositeBinding = initialBindings[info.handle.id === "start" ? "end" : "start"];
      const arrowTransform = this.editor.getShapePageTransform(shape.id);
      if (currentBinding) {
        (0, import_arrowTargetState.updateArrowTargetState)({
          editor: this.editor,
          pointInPageSpace: arrowTransform.applyToPoint(info.handle),
          arrow: shape,
          isPrecise: currentBinding.props.isPrecise,
          currentBinding,
          oppositeBinding
        });
      }
    }
    this.editor.setCursor({ type: "grabbing", rotation: 0 });
  }
  onExit() {
    this.editor.setHintingShapes([]);
    this.editor.setCursor({ type: "default", rotation: 0 });
  }
  onPointerUp() {
    const { shape, handle } = this.info;
    if (this.editor.isShapeOfType(shape, "note")) {
      const { editor } = this;
      const nextNote = getNoteForAdjacentPosition(editor, shape, handle, false);
      if (nextNote) {
        (0, import_selectHelpers.startEditingShapeWithRichText)(editor, nextNote, { selectAll: true });
        return;
      }
    }
    this.parent.transition("idle", this.info);
  }
  onDoubleClick(info) {
    if (this.editor.inputs.getShiftKey() || info.phase !== "down" || info.ctrlKey || info.shiftKey) {
      return;
    }
    this.parent.transition("idle");
    this.parent.getCurrent()?.handleEvent(info);
  }
  onPointerMove(info) {
    const { editor } = this;
    if (editor.inputs.getIsDragging()) {
      if (this.didCtrlOnEnter) {
        this.parent.transition("brushing", info);
      } else {
        this.startDraggingHandle();
      }
    }
  }
  onLongPress() {
    this.startDraggingHandle();
  }
  startDraggingHandle() {
    const { editor } = this;
    if (editor.getIsReadonly()) return;
    const { shape, handle } = this.info;
    if (editor.isShapeOfType(shape, "note")) {
      const noteUtil = editor.getShapeUtil(shape);
      const dv = (0, import_getDisplayValues.getDisplayValues)(noteUtil, shape);
      const nextNote = getNoteForAdjacentPosition(editor, shape, handle, true);
      if (nextNote) {
        const centeredOnPointer = editor.getPointInParentSpace(nextNote, editor.inputs.getOriginPagePoint()).sub(
          import_editor.Vec.Rot(
            new import_editor.Vec(dv.noteWidth / 2, dv.noteHeight / 2).mul(shape.props.scale),
            nextNote.rotation
          )
        );
        editor.updateShape({ ...nextNote, x: centeredOnPointer.x, y: centeredOnPointer.y });
        editor.setHoveredShape(nextNote.id).select(nextNote.id).setCurrentTool("select.translating", {
          ...this.info,
          target: "shape",
          shape: editor.getShape(nextNote),
          onInteractionEnd: "note",
          isCreating: true,
          onCreate: () => {
            (0, import_selectHelpers.startEditingShapeWithRichText)(editor, nextNote, { selectAll: true });
          }
        });
        return;
      }
    }
    this.parent.transition("dragging_handle", this.info);
  }
  onCancel() {
    this.cancel();
  }
  onComplete() {
    this.cancel();
  }
  onInterrupt() {
    this.cancel();
  }
  cancel() {
    this.parent.transition("idle");
  }
}
function getNoteForAdjacentPosition(editor, shape, handle, forceNew) {
  const noteUtil = editor.getShapeUtil(shape);
  const dv = (0, import_getDisplayValues.getDisplayValues)(noteUtil, shape);
  const pageTransform = editor.getShapePageTransform(shape.id);
  const pagePoint = pageTransform.point();
  const pageRotation = pageTransform.rotation();
  const positions = (0, import_noteHelpers.getNoteAdjacentPositions)(editor, {
    pagePoint,
    pageRotation,
    growY: shape.props.growY * shape.props.scale,
    extraHeight: 0,
    scale: shape.props.scale,
    noteWidth: dv.noteWidth,
    noteHeight: dv.noteHeight
  });
  const position = positions[handle.index];
  if (position) {
    return (0, import_noteHelpers.getNoteShapeForAdjacentPosition)(editor, {
      shape,
      center: position,
      pageRotation,
      noteWidth: dv.noteWidth,
      noteHeight: dv.noteHeight,
      forceNew
    });
  }
  return void 0;
}
//# sourceMappingURL=PointingHandle.js.map
