@yh-ui/flow 0.1.21

package/dist/utils/custom-types.d.ts

@@ -0,0 +1,78 @@
+import type { Component } from 'vue';
+import type { EdgeType, Edge } from '../types/edge';
+import type { NodeType, Node, NodeData, NodeHandleBounds } from '../types/node';
+export interface CustomEdge {
+    type: EdgeType;
+    component: Component;
+    label?: string;
+}
+export declare function registerCustomEdge(edge: CustomEdge): void;
+export declare function getCustomEdge(type: EdgeType): CustomEdge | undefined;
+export declare function getAllCustomEdges(): CustomEdge[];
+export declare function hasCustomEdge(type: EdgeType): boolean;
+export interface CustomNodeTemplate {
+    type: NodeType;
+    component: Component;
+    defaultData?: Partial<NodeData>;
+    defaultWidth?: number;
+    defaultHeight?: number;
+    handles?: NodeHandleBounds;
+    description?: string;
+}
+export declare function registerCustomNodeTemplate(template: CustomNodeTemplate): void;
+export declare function getCustomNodeTemplate(type: NodeType): CustomNodeTemplate | undefined;
+export declare function getAllCustomNodeTemplates(): CustomNodeTemplate[];
+export declare function hasCustomNodeTemplate(type: NodeType): boolean;
+export declare function createNodeFromTemplate(type: NodeType, id: string, position: {
+    x: number;
+    y: number;
+}, overrides?: Partial<Node>): Node | null;
+export interface CustomNode {
+    type: NodeType;
+    component: Component;
+    defaultData?: Record<string, unknown>;
+}
+export declare function registerCustomNode(node: CustomNode): void;
+export declare function getCustomNode(type: NodeType): CustomNode | undefined;
+export declare function getAllCustomNodes(): CustomNode[];
+export declare function hasCustomNode(type: NodeType): boolean;
+export interface NestedNodeConfig {
+    parentId: string;
+    children: string[];
+    extent?: 'parent' | 'container';
+}
+export declare function isNestedNode(node: Node): boolean;
+export declare function getNodeChildren(node: Node, allNodes: Node[]): Node[];
+export declare function getNodeParent(node: Node, allNodes: Node[]): Node | undefined;
+export interface EdgeTemplate {
+    type: EdgeType;
+    component?: Component;
+    defaultData?: Record<string, unknown>;
+    animated?: boolean;
+    style?: Record<string, string | number>;
+    label?: string;
+}
+export declare function registerEdgeTemplate(template: EdgeTemplate): void;
+export declare function getEdgeTemplate(type: EdgeType): EdgeTemplate | undefined;
+export declare function getAllEdgeTemplates(): EdgeTemplate[];
+export interface FlowExportData {
+    nodes: Node[];
+    edges: Edge[];
+    viewport?: {
+        x: number;
+        y: number;
+        zoom: number;
+    };
+    customTemplates?: {
+        nodes: CustomNodeTemplate[];
+        edges: EdgeTemplate[];
+    };
+    version?: string;
+}
+export declare function exportFlowData(nodes: Node[], edges: Edge[], viewport?: {
+    x: number;
+    y: number;
+    zoom: number;
+}): string;
+export declare function importFlowData(json: string): FlowExportData | null;
+export declare function clearCustomTypes(): void;

package/dist/utils/custom-types.mjs

@@ -0,0 +1,108 @@
+const customEdges = /* @__PURE__ */ new Map();
+export function registerCustomEdge(edge) {
+  customEdges.set(edge.type, edge);
+}
+export function getCustomEdge(type) {
+  return customEdges.get(type);
+}
+export function getAllCustomEdges() {
+  return Array.from(customEdges.values());
+}
+export function hasCustomEdge(type) {
+  return customEdges.has(type);
+}
+const customNodeTemplates = /* @__PURE__ */ new Map();
+export function registerCustomNodeTemplate(template) {
+  customNodeTemplates.set(template.type, template);
+}
+export function getCustomNodeTemplate(type) {
+  return customNodeTemplates.get(type);
+}
+export function getAllCustomNodeTemplates() {
+  return Array.from(customNodeTemplates.values());
+}
+export function hasCustomNodeTemplate(type) {
+  return customNodeTemplates.has(type);
+}
+export function createNodeFromTemplate(type, id, position, overrides) {
+  const template = getCustomNodeTemplate(type);
+  if (!template) return null;
+  return {
+    id,
+    type,
+    position,
+    data: { ...template.defaultData, ...overrides?.data },
+    width: overrides?.width ?? template.defaultWidth ?? 180,
+    height: overrides?.height ?? template.defaultHeight ?? 60,
+    selected: false,
+    dragging: false,
+    ...overrides
+  };
+}
+const customNodes = /* @__PURE__ */ new Map();
+export function registerCustomNode(node) {
+  if (!customNodeTemplates.has(node.type)) {
+    customNodeTemplates.set(node.type, {
+      type: node.type,
+      component: node.component,
+      defaultData: node.defaultData
+    });
+  }
+  customNodes.set(node.type, node);
+}
+export function getCustomNode(type) {
+  return customNodes.get(type);
+}
+export function getAllCustomNodes() {
+  return Array.from(customNodes.values());
+}
+export function hasCustomNode(type) {
+  return customNodes.has(type);
+}
+export function isNestedNode(node) {
+  return !!node.parentId;
+}
+export function getNodeChildren(node, allNodes) {
+  if (!node.id) return [];
+  return allNodes.filter((n) => n.parentId === node.id);
+}
+export function getNodeParent(node, allNodes) {
+  if (!node.parentId) return void 0;
+  return allNodes.find((n) => n.id === node.parentId);
+}
+const edgeTemplates = /* @__PURE__ */ new Map();
+export function registerEdgeTemplate(template) {
+  edgeTemplates.set(template.type, template);
+}
+export function getEdgeTemplate(type) {
+  return edgeTemplates.get(type);
+}
+export function getAllEdgeTemplates() {
+  return Array.from(edgeTemplates.values());
+}
+export function exportFlowData(nodes, edges, viewport) {
+  const data = {
+    nodes,
+    edges,
+    viewport,
+    version: "1.0.0"
+  };
+  return JSON.stringify(data, null, 2);
+}
+export function importFlowData(json) {
+  try {
+    const data = JSON.parse(json);
+    if (!data.nodes || !Array.isArray(data.nodes)) {
+      return null;
+    }
+    return data;
+  } catch {
+    return null;
+  }
+}
+export function clearCustomTypes() {
+  customEdges.clear();
+  customNodes.clear();
+  customNodeTemplates.clear();
+  edgeTemplates.clear();
+}

package/dist/utils/edge.cjs

@@ -0,0 +1,235 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getBezierPath = getBezierPath;
+exports.getEdgeCenter = getEdgeCenter;
+exports.getEdgePath = getEdgePath;
+exports.getEdgePosition = getEdgePosition;
+exports.getHandlePosition = getHandlePosition;
+exports.getSmoothStepPath = getSmoothStepPath;
+exports.getStepPath = getStepPath;
+exports.getStraightPath = getStraightPath;
+exports.shortenEndpoint = shortenEndpoint;
+function getDir(pos) {
+  switch (pos) {
+    case "top":
+      return {
+        x: 0,
+        y: -1
+      };
+    case "bottom":
+      return {
+        x: 0,
+        y: 1
+      };
+    case "right":
+      return {
+        x: 1,
+        y: 0
+      };
+    case "left":
+      return {
+        x: -1,
+        y: 0
+      };
+  }
+}
+function getHandlePosition(node, handlePosition = "right", _handleId) {
+  const x = node.position.x;
+  const y = node.position.y;
+  let width = node.width;
+  let height = node.height;
+  if (width === void 0 && node.style?.width) {
+    const val = parseInt(String(node.style.width));
+    if (!isNaN(val)) width = val;
+  }
+  if (height === void 0 && node.style?.height) {
+    const val = parseInt(String(node.style.height));
+    if (!isNaN(val)) height = val;
+  }
+  width = width || 150;
+  height = height || 40;
+  switch (handlePosition) {
+    case "top":
+      return {
+        x: x + width / 2,
+        y
+      };
+    case "bottom":
+      return {
+        x: x + width / 2,
+        y: y + height
+      };
+    case "left":
+      return {
+        x,
+        y: y + height / 2
+      };
+    case "right":
+      return {
+        x: x + width,
+        y: y + height / 2
+      };
+    default:
+      return {
+        x: x + width / 2,
+        y: y + height / 2
+      };
+  }
+}
+function getEdgePosition(sourceX, sourceY, targetX, targetY, _sourcePosition, _targetPosition) {
+  return {
+    sx: sourceX,
+    sy: sourceY,
+    tx: targetX,
+    ty: targetY
+  };
+}
+function getBezierPath(params) {
+  const {
+    sourceX,
+    sourceY,
+    targetX,
+    targetY,
+    sourcePosition,
+    targetPosition,
+    curvature = 0.25
+  } = params;
+  const srcDir = getDir(sourcePosition);
+  const tgtDir = getDir(targetPosition);
+  const dx = Math.abs(targetX - sourceX);
+  const dy = Math.abs(targetY - sourceY);
+  const dist = Math.sqrt(dx * dx + dy * dy);
+  const offset = Math.min(Math.max(dist * curvature, 20), dist / 2);
+  const c1x = sourceX + srcDir.x * offset;
+  const c1y = sourceY + srcDir.y * offset;
+  const c2x = targetX + tgtDir.x * offset;
+  const c2y = targetY + tgtDir.y * offset;
+  return `M${sourceX},${sourceY} C${c1x},${c1y} ${c2x},${c2y} ${targetX},${targetY}`;
+}
+function getStraightPath(params) {
+  const {
+    sourceX,
+    sourceY,
+    targetX,
+    targetY
+  } = params;
+  return `M${sourceX},${sourceY} L${targetX},${targetY}`;
+}
+function getStepPath(params) {
+  const {
+    sourceX,
+    sourceY,
+    targetX,
+    targetY,
+    sourcePosition,
+    targetPosition
+  } = params;
+  const srcIsHoriz = sourcePosition === "left" || sourcePosition === "right";
+  const tgtIsHoriz = targetPosition === "left" || targetPosition === "right";
+  if (srcIsHoriz && !tgtIsHoriz) {
+    const midX = (sourceX + targetX) / 2;
+    return `M${sourceX},${sourceY} L${midX},${sourceY} L${midX},${targetY} L${targetX},${targetY}`;
+  } else if (!srcIsHoriz && tgtIsHoriz) {
+    const midY = (sourceY + targetY) / 2;
+    return `M${sourceX},${sourceY} L${sourceX},${midY} L${targetX},${midY} L${targetX},${targetY}`;
+  } else if (srcIsHoriz && tgtIsHoriz) {
+    const midX = (sourceX + targetX) / 2;
+    return `M${sourceX},${sourceY} L${midX},${sourceY} L${midX},${targetY} L${targetX},${targetY}`;
+  } else {
+    const midY = (sourceY + targetY) / 2;
+    return `M${sourceX},${sourceY} L${sourceX},${midY} L${targetX},${midY} L${targetX},${targetY}`;
+  }
+}
+function getSmoothStepPath(params) {
+  const {
+    sourceX,
+    sourceY,
+    targetX,
+    targetY,
+    sourcePosition,
+    targetPosition
+  } = params;
+  const srcDir = getDir(sourcePosition);
+  const tgtDir = getDir(targetPosition);
+  const dx = Math.abs(targetX - sourceX);
+  const dy = Math.abs(targetY - sourceY);
+  const r = Math.min(10, Math.min(dx, dy) / 2);
+  const srcIsHoriz = sourcePosition === "left" || sourcePosition === "right";
+  if (srcIsHoriz) {
+    const midX = (sourceX + targetX) / 2;
+    const sign1X = srcDir.x;
+    const sign2Y = tgtDir.y || (targetY > sourceY ? 1 : -1);
+    return [`M${sourceX},${sourceY}`, `L${midX - sign1X * r},${sourceY}`, `Q${midX},${sourceY} ${midX},${sourceY + sign2Y * r}`, `L${midX},${targetY - sign2Y * r}`, `Q${midX},${targetY} ${midX + sign1X * r},${targetY}`, `L${targetX},${targetY}`].join(" ");
+  } else {
+    const midY = (sourceY + targetY) / 2;
+    const sign1Y = srcDir.y;
+    const sign2X = tgtDir.x || (targetX > sourceX ? 1 : -1);
+    return [`M${sourceX},${sourceY}`, `L${sourceX},${midY - sign1Y * r}`, `Q${sourceX},${midY} ${sourceX + sign2X * r},${midY}`, `L${targetX - sign2X * r},${midY}`, `Q${targetX},${midY} ${targetX},${midY + sign1Y * r}`, `L${targetX},${targetY}`].join(" ");
+  }
+}
+function getEdgePath(type, params) {
+  switch (type) {
+    case "bezier":
+    case "default":
+      return getBezierPath(params);
+    case "straight":
+      return getStraightPath(params);
+    case "step":
+      return getStepPath(params);
+    case "smoothstep":
+      return getSmoothStepPath(params);
+    default:
+      return getBezierPath(params);
+  }
+}
+function getEdgeCenter(params) {
+  const {
+    sourceX,
+    sourceY,
+    targetX,
+    targetY,
+    type = "bezier"
+  } = params;
+  if (type === "bezier" || type === "default") {
+    const curvature = params.curvature ?? 0.25;
+    const srcDir = getDir(params.sourcePosition);
+    const tgtDir = getDir(params.targetPosition);
+    const dx = Math.abs(targetX - sourceX);
+    const dy = Math.abs(targetY - sourceY);
+    const dist = Math.sqrt(dx * dx + dy * dy);
+    const offset = Math.min(Math.max(dist * curvature, 20), dist / 2);
+    const c1x = sourceX + srcDir.x * offset;
+    const c1y = sourceY + srcDir.y * offset;
+    const c2x = targetX + tgtDir.x * offset;
+    const c2y = targetY + tgtDir.y * offset;
+    return {
+      x: 0.125 * sourceX + 0.375 * c1x + 0.375 * c2x + 0.125 * targetX,
+      y: 0.125 * sourceY + 0.375 * c1y + 0.375 * c2y + 0.125 * targetY,
+      ox: (targetX - sourceX) / 2,
+      oy: (targetY - sourceY) / 2
+    };
+  }
+  return {
+    x: (sourceX + targetX) / 2,
+    y: (sourceY + targetY) / 2,
+    ox: (targetX - sourceX) / 2,
+    oy: (targetY - sourceY) / 2
+  };
+}
+function shortenEndpoint(x, y, fromX, fromY, offset) {
+  const dx = x - fromX;
+  const dy = y - fromY;
+  const dist = Math.sqrt(dx * dx + dy * dy);
+  if (dist < offset * 2) return {
+    x,
+    y
+  };
+  const factor = offset / dist;
+  return {
+    x: x - dx * factor,
+    y: y - dy * factor
+  };
+}

package/dist/utils/edge.d.ts

@@ -0,0 +1,79 @@
+import type { Position, EdgeType, NodeStyle } from '../types';
+export interface EdgePathParams {
+    sourceX: number;
+    sourceY: number;
+    targetX: number;
+    targetY: number;
+    sourcePosition: Position;
+    targetPosition: Position;
+    /** 控制曲率，0~1，默认 0.25 */
+    curvature?: number;
+}
+/**
+ * 获取连接点的位置坐标
+ */
+export declare function getHandlePosition(node: {
+    position: {
+        x: number;
+        y: number;
+    };
+    width?: number;
+    height?: number;
+    style?: NodeStyle;
+}, handlePosition?: Position, _handleId?: string | null): {
+    x: number;
+    y: number;
+};
+/**
+ * 获取从源位置到目标位置的偏移量（向后兼容）
+ */
+export declare function getEdgePosition(sourceX: number, sourceY: number, targetX: number, targetY: number, _sourcePosition: Position, _targetPosition: Position): {
+    sx: number;
+    sy: number;
+    tx: number;
+    ty: number;
+};
+/**
+ * 生成高质量贝塞尔曲线路径（参考 vue-flow 实现）
+ * 控制点偏移量基于两节点的距离动态计算，保证平滑
+ */
+export declare function getBezierPath(params: EdgePathParams): string;
+/**
+ * 生成直线路径
+ */
+export declare function getStraightPath(params: EdgePathParams): string;
+/**
+ * 生成阶梯线路径（水平/垂直直角转弯）
+ */
+export declare function getStepPath(params: EdgePathParams): string;
+/**
+ * 生成平滑阶梯线路径（带圆角转折的 step）
+ */
+export declare function getSmoothStepPath(params: EdgePathParams): string;
+/**
+ * 根据类型获取连线路径
+ */
+export declare function getEdgePath(type: EdgeType | 'default', params: EdgePathParams): string;
+/**
+ * 计算连线的中心点（用于标签放置）
+ */
+export declare function getEdgeCenter(params: EdgePathParams & {
+    type?: string;
+}): {
+    x: number;
+    y: number;
+    ox: number;
+    oy: number;
+};
+/**
+ * 计算给定方向需要缩短路径的终点（使箭头尖端落在 handle 边缘）
+ * @param x 终点 x
+ * @param y 终点 y
+ * @param fromX 起点 x（用于计算方向）
+ * @param fromY 起点 y
+ * @param offset 回退距离（px）
+ */
+export declare function shortenEndpoint(x: number, y: number, fromX: number, fromY: number, offset: number): {
+    x: number;
+    y: number;
+};

package/dist/utils/edge.mjs

@@ -0,0 +1,172 @@
+function getDir(pos) {
+  switch (pos) {
+    case "top":
+      return { x: 0, y: -1 };
+    case "bottom":
+      return { x: 0, y: 1 };
+    case "right":
+      return { x: 1, y: 0 };
+    case "left":
+      return { x: -1, y: 0 };
+  }
+}
+export function getHandlePosition(node, handlePosition = "right", _handleId) {
+  const x = node.position.x;
+  const y = node.position.y;
+  let width = node.width;
+  let height = node.height;
+  if (width === void 0 && node.style?.width) {
+    const val = parseInt(String(node.style.width));
+    if (!isNaN(val)) width = val;
+  }
+  if (height === void 0 && node.style?.height) {
+    const val = parseInt(String(node.style.height));
+    if (!isNaN(val)) height = val;
+  }
+  width = width || 150;
+  height = height || 40;
+  switch (handlePosition) {
+    case "top":
+      return { x: x + width / 2, y };
+    case "bottom":
+      return { x: x + width / 2, y: y + height };
+    case "left":
+      return { x, y: y + height / 2 };
+    case "right":
+      return { x: x + width, y: y + height / 2 };
+    default:
+      return { x: x + width / 2, y: y + height / 2 };
+  }
+}
+export function getEdgePosition(sourceX, sourceY, targetX, targetY, _sourcePosition, _targetPosition) {
+  return { sx: sourceX, sy: sourceY, tx: targetX, ty: targetY };
+}
+export function getBezierPath(params) {
+  const {
+    sourceX,
+    sourceY,
+    targetX,
+    targetY,
+    sourcePosition,
+    targetPosition,
+    curvature = 0.25
+  } = params;
+  const srcDir = getDir(sourcePosition);
+  const tgtDir = getDir(targetPosition);
+  const dx = Math.abs(targetX - sourceX);
+  const dy = Math.abs(targetY - sourceY);
+  const dist = Math.sqrt(dx * dx + dy * dy);
+  const offset = Math.min(Math.max(dist * curvature, 20), dist / 2);
+  const c1x = sourceX + srcDir.x * offset;
+  const c1y = sourceY + srcDir.y * offset;
+  const c2x = targetX + tgtDir.x * offset;
+  const c2y = targetY + tgtDir.y * offset;
+  return `M${sourceX},${sourceY} C${c1x},${c1y} ${c2x},${c2y} ${targetX},${targetY}`;
+}
+export function getStraightPath(params) {
+  const { sourceX, sourceY, targetX, targetY } = params;
+  return `M${sourceX},${sourceY} L${targetX},${targetY}`;
+}
+export function getStepPath(params) {
+  const { sourceX, sourceY, targetX, targetY, sourcePosition, targetPosition } = params;
+  const srcIsHoriz = sourcePosition === "left" || sourcePosition === "right";
+  const tgtIsHoriz = targetPosition === "left" || targetPosition === "right";
+  if (srcIsHoriz && !tgtIsHoriz) {
+    const midX = (sourceX + targetX) / 2;
+    return `M${sourceX},${sourceY} L${midX},${sourceY} L${midX},${targetY} L${targetX},${targetY}`;
+  } else if (!srcIsHoriz && tgtIsHoriz) {
+    const midY = (sourceY + targetY) / 2;
+    return `M${sourceX},${sourceY} L${sourceX},${midY} L${targetX},${midY} L${targetX},${targetY}`;
+  } else if (srcIsHoriz && tgtIsHoriz) {
+    const midX = (sourceX + targetX) / 2;
+    return `M${sourceX},${sourceY} L${midX},${sourceY} L${midX},${targetY} L${targetX},${targetY}`;
+  } else {
+    const midY = (sourceY + targetY) / 2;
+    return `M${sourceX},${sourceY} L${sourceX},${midY} L${targetX},${midY} L${targetX},${targetY}`;
+  }
+}
+export function getSmoothStepPath(params) {
+  const { sourceX, sourceY, targetX, targetY, sourcePosition, targetPosition } = params;
+  const srcDir = getDir(sourcePosition);
+  const tgtDir = getDir(targetPosition);
+  const dx = Math.abs(targetX - sourceX);
+  const dy = Math.abs(targetY - sourceY);
+  const r = Math.min(10, Math.min(dx, dy) / 2);
+  const srcIsHoriz = sourcePosition === "left" || sourcePosition === "right";
+  if (srcIsHoriz) {
+    const midX = (sourceX + targetX) / 2;
+    const sign1X = srcDir.x;
+    const sign2Y = tgtDir.y || (targetY > sourceY ? 1 : -1);
+    return [
+      `M${sourceX},${sourceY}`,
+      `L${midX - sign1X * r},${sourceY}`,
+      `Q${midX},${sourceY} ${midX},${sourceY + sign2Y * r}`,
+      `L${midX},${targetY - sign2Y * r}`,
+      `Q${midX},${targetY} ${midX + sign1X * r},${targetY}`,
+      `L${targetX},${targetY}`
+    ].join(" ");
+  } else {
+    const midY = (sourceY + targetY) / 2;
+    const sign1Y = srcDir.y;
+    const sign2X = tgtDir.x || (targetX > sourceX ? 1 : -1);
+    return [
+      `M${sourceX},${sourceY}`,
+      `L${sourceX},${midY - sign1Y * r}`,
+      `Q${sourceX},${midY} ${sourceX + sign2X * r},${midY}`,
+      `L${targetX - sign2X * r},${midY}`,
+      `Q${targetX},${midY} ${targetX},${midY + sign1Y * r}`,
+      `L${targetX},${targetY}`
+    ].join(" ");
+  }
+}
+export function getEdgePath(type, params) {
+  switch (type) {
+    case "bezier":
+    case "default":
+      return getBezierPath(params);
+    case "straight":
+      return getStraightPath(params);
+    case "step":
+      return getStepPath(params);
+    case "smoothstep":
+      return getSmoothStepPath(params);
+    default:
+      return getBezierPath(params);
+  }
+}
+export function getEdgeCenter(params) {
+  const { sourceX, sourceY, targetX, targetY, type = "bezier" } = params;
+  if (type === "bezier" || type === "default") {
+    const curvature = params.curvature ?? 0.25;
+    const srcDir = getDir(params.sourcePosition);
+    const tgtDir = getDir(params.targetPosition);
+    const dx = Math.abs(targetX - sourceX);
+    const dy = Math.abs(targetY - sourceY);
+    const dist = Math.sqrt(dx * dx + dy * dy);
+    const offset = Math.min(Math.max(dist * curvature, 20), dist / 2);
+    const c1x = sourceX + srcDir.x * offset;
+    const c1y = sourceY + srcDir.y * offset;
+    const c2x = targetX + tgtDir.x * offset;
+    const c2y = targetY + tgtDir.y * offset;
+    return {
+      x: 0.125 * sourceX + 0.375 * c1x + 0.375 * c2x + 0.125 * targetX,
+      y: 0.125 * sourceY + 0.375 * c1y + 0.375 * c2y + 0.125 * targetY,
+      ox: (targetX - sourceX) / 2,
+      oy: (targetY - sourceY) / 2
+    };
+  }
+  return {
+    x: (sourceX + targetX) / 2,
+    y: (sourceY + targetY) / 2,
+    ox: (targetX - sourceX) / 2,
+    oy: (targetY - sourceY) / 2
+  };
+}
+export function shortenEndpoint(x, y, fromX, fromY, offset) {
+  const dx = x - fromX;
+  const dy = y - fromY;
+  const dist = Math.sqrt(dx * dx + dy * dy);
+  if (dist < offset * 2) return { x, y };
+  const factor = offset / dist;
+  return { x: x - dx * factor, y: y - dy * factor };
+}