hyperprop-charting-library 0.1.135 → 0.1.136

package/dist/index.js

@@ -4788,6 +4788,216 @@ function createChart(element, options = {}) {
             drawDrawingLabel(drawing.label, (leftX + rightX) / 2, topY - 4, drawing.color);
           }
         }
+      } else if (drawing.type === "ellipse") {
+        const p0 = drawing.points[0];
+        const p1 = drawing.points[1];
+        if (p0 && p1) {
+          const px0 = xFromDrawingPoint(p0);
+          const px1 = xFromDrawingPoint(p1);
+          const y0 = yFromPrice(p0.price);
+          const y1 = yFromPrice(p1.price);
+          const cx = (px0 + px1) / 2;
+          const cy = (y0 + y1) / 2;
+          const rx = Math.max(1, Math.abs(px1 - px0) / 2);
+          const ry = Math.max(1, Math.abs(y1 - y0) / 2);
+          ctx.save();
+          ctx.globalAlpha = draft ? 0.6 : 1;
+          ctx.beginPath();
+          ctx.ellipse(cx, cy, rx, ry, 0, 0, Math.PI * 2);
+          ctx.fillStyle = hexToRgba(drawing.color, 0.14);
+          ctx.fill();
+          ctx.lineWidth = Math.max(1, drawing.width);
+          ctx.strokeStyle = drawing.color;
+          applyDashPattern(drawing.style, dashPatterns.dotted, dashPatterns.dashed);
+          ctx.stroke();
+          ctx.restore();
+          handleAt(px0, y0, drawing.color);
+          handleAt(px1, y1, drawing.color);
+          handleAt(px0, y1, drawing.color);
+          handleAt(px1, y0, drawing.color);
+          if (drawing.label) {
+            drawDrawingLabel(drawing.label, cx, cy - ry - 4, drawing.color);
+          }
+        }
+      } else if (drawing.type === "parallel-channel") {
+        const p0 = drawing.points[0];
+        const p1 = drawing.points[1];
+        const p2 = drawing.points[2];
+        if (p0 && p1) {
+          const x0 = xFromDrawingPoint(p0);
+          const y0 = yFromPrice(p0.price);
+          const x1 = xFromDrawingPoint(p1);
+          const y1 = yFromPrice(p1.price);
+          ctx.beginPath();
+          ctx.moveTo(x0, y0);
+          ctx.lineTo(x1, y1);
+          ctx.stroke();
+          handleAt(x0, y0, drawing.color);
+          handleAt(x1, y1, drawing.color);
+          if (p2) {
+            const indexSpan = p1.index - p0.index;
+            const slope = indexSpan !== 0 ? (p1.price - p0.price) / indexSpan : 0;
+            const basePriceAtP2 = p0.price + slope * (p2.index - p0.index);
+            const offset = p2.price - basePriceAtP2;
+            const q0x = x0;
+            const q0y = yFromPrice(p0.price + offset);
+            const q1x = x1;
+            const q1y = yFromPrice(p1.price + offset);
+            ctx.save();
+            ctx.globalAlpha = draft ? 0.5 : 1;
+            ctx.fillStyle = hexToRgba(drawing.color, 0.08);
+            ctx.beginPath();
+            ctx.moveTo(x0, y0);
+            ctx.lineTo(x1, y1);
+            ctx.lineTo(q1x, q1y);
+            ctx.lineTo(q0x, q0y);
+            ctx.closePath();
+            ctx.fill();
+            ctx.restore();
+            ctx.beginPath();
+            ctx.moveTo(q0x, q0y);
+            ctx.lineTo(q1x, q1y);
+            ctx.stroke();
+            ctx.save();
+            ctx.setLineDash([4, 4]);
+            ctx.globalAlpha = draft ? 0.5 : 0.7;
+            ctx.beginPath();
+            ctx.moveTo(x0, (y0 + q0y) / 2);
+            ctx.lineTo(x1, (y1 + q1y) / 2);
+            ctx.stroke();
+            ctx.restore();
+            handleAt(xFromDrawingPoint(p2), yFromPrice(p2.price), drawing.color);
+          }
+          if (drawing.label) {
+            drawDrawingLabel(drawing.label, (x0 + x1) / 2, Math.min(y0, y1) - 4, drawing.color);
+          }
+        }
+      } else if (drawing.type === "arrow") {
+        const first = drawing.points[0];
+        const second = drawing.points[1];
+        if (first && second) {
+          const x0 = xFromDrawingPoint(first);
+          const y0 = yFromPrice(first.price);
+          const x1 = xFromDrawingPoint(second);
+          const y1 = yFromPrice(second.price);
+          const angle = Math.atan2(y1 - y0, x1 - x0);
+          const head = 5 + Math.max(1, drawing.width) * 3;
+          const shaftX = x1 - Math.cos(angle) * head * 0.6;
+          const shaftY = y1 - Math.sin(angle) * head * 0.6;
+          ctx.beginPath();
+          ctx.moveTo(x0, y0);
+          ctx.lineTo(shaftX, shaftY);
+          ctx.stroke();
+          ctx.save();
+          ctx.setLineDash([]);
+          ctx.fillStyle = drawing.color;
+          ctx.beginPath();
+          ctx.moveTo(x1, y1);
+          ctx.lineTo(x1 - Math.cos(angle - Math.PI / 7) * head, y1 - Math.sin(angle - Math.PI / 7) * head);
+          ctx.lineTo(x1 - Math.cos(angle + Math.PI / 7) * head, y1 - Math.sin(angle + Math.PI / 7) * head);
+          ctx.closePath();
+          ctx.fill();
+          ctx.restore();
+          handleAt(x0, y0, drawing.color);
+          handleAt(x1, y1, drawing.color);
+          if (drawing.label) {
+            const midX = (x0 + x1) / 2;
+            const midY = (y0 + y1) / 2;
+            drawDrawingLabel(drawing.label, midX, midY, drawing.color);
+          }
+        }
+      } else if (drawing.type === "brush") {
+        const pts = drawing.points;
+        if (pts.length >= 2) {
+          ctx.save();
+          ctx.lineJoin = "round";
+          ctx.lineCap = "round";
+          ctx.beginPath();
+          const startX = xFromDrawingPoint(pts[0]);
+          const startY = yFromPrice(pts[0].price);
+          ctx.moveTo(startX, startY);
+          if (pts.length === 2) {
+            ctx.lineTo(xFromDrawingPoint(pts[1]), yFromPrice(pts[1].price));
+          } else {
+            for (let i = 1; i < pts.length - 1; i += 1) {
+              const cxp = xFromDrawingPoint(pts[i]);
+              const cyp = yFromPrice(pts[i].price);
+              const nx = xFromDrawingPoint(pts[i + 1]);
+              const ny = yFromPrice(pts[i + 1].price);
+              ctx.quadraticCurveTo(cxp, cyp, (cxp + nx) / 2, (cyp + ny) / 2);
+            }
+            const last = pts[pts.length - 1];
+            ctx.lineTo(xFromDrawingPoint(last), yFromPrice(last.price));
+          }
+          ctx.stroke();
+          ctx.restore();
+          if (isSelected) {
+            handleAt(startX, startY, drawing.color);
+            const last = pts[pts.length - 1];
+            handleAt(xFromDrawingPoint(last), yFromPrice(last.price), drawing.color);
+          }
+        }
+      } else if (drawing.type === "callout") {
+        const anchor = drawing.points[0];
+        const boxPoint = drawing.points[1];
+        if (anchor && boxPoint) {
+          const ax = xFromDrawingPoint(anchor);
+          const ay = yFromPrice(anchor.price);
+          const bx = xFromDrawingPoint(boxPoint);
+          const by = yFromPrice(boxPoint.price);
+          const fontSize = Math.max(6, drawing.fontSize);
+          const prevFont = ctx.font;
+          ctx.font = `500 ${fontSize}px ${mergedOptions.fontFamily}`;
+          const rawLabel = drawing.label ?? "";
+          const isPlaceholder = rawLabel.trim().length === 0;
+          const lines = (isPlaceholder ? "Text" : rawLabel).split("\n");
+          const textW = Math.max(1, ...lines.map((line) => measureTextWidth(line)));
+          const padX = 10;
+          const padY = 7;
+          const lineH = Math.round(fontSize * 1.35);
+          const blockW = textW + padX * 2;
+          const blockH = lines.length * lineH + padY * 2;
+          const edgeX = Math.max(bx, Math.min(bx + blockW, ax));
+          const edgeY = Math.max(by, Math.min(by + blockH, ay));
+          const insideBox = ax >= bx && ax <= bx + blockW && ay >= by && ay <= by + blockH;
+          if (!insideBox) {
+            ctx.save();
+            ctx.setLineDash([]);
+            ctx.lineWidth = Math.max(1, drawing.width);
+            ctx.beginPath();
+            ctx.moveTo(edgeX, edgeY);
+            ctx.lineTo(ax, ay);
+            ctx.stroke();
+            const angle = Math.atan2(ay - edgeY, ax - edgeX);
+            const head = 7;
+            ctx.fillStyle = drawing.color;
+            ctx.beginPath();
+            ctx.moveTo(ax, ay);
+            ctx.lineTo(ax - Math.cos(angle - Math.PI / 7) * head, ay - Math.sin(angle - Math.PI / 7) * head);
+            ctx.lineTo(ax - Math.cos(angle + Math.PI / 7) * head, ay - Math.sin(angle + Math.PI / 7) * head);
+            ctx.closePath();
+            ctx.fill();
+            ctx.restore();
+          }
+          ctx.save();
+          ctx.setLineDash([]);
+          ctx.fillStyle = hexToRgba(drawing.color, 0.16);
+          fillRoundedRect(bx, by, blockW, blockH, 6);
+          ctx.strokeStyle = drawing.color;
+          ctx.lineWidth = Math.max(1, drawing.width);
+          strokeRoundedRect(bx, by, blockW, blockH, 6);
+          ctx.fillStyle = drawing.color;
+          ctx.globalAlpha = (draft ? 0.72 : 1) * (isPlaceholder ? 0.55 : 1);
+          ctx.textAlign = "left";
+          ctx.textBaseline = "middle";
+          lines.forEach((line, lineIndex) => {
+            ctx.fillText(line, bx + padX, by + padY + lineIndex * lineH + lineH / 2);
+          });
+          ctx.restore();
+          ctx.font = prevFont;
+          handleAt(ax, ay, drawing.color);
+          handleAt(bx, by, drawing.color);
+        }
       } else if (drawing.type === "price-range") {
         const p0 = drawing.points[0];
         const p1 = drawing.points[1];
@@ -6842,6 +7052,126 @@ function createChart(element, options = {}) {
         if (x >= Math.min(px0, px1) && x <= Math.max(px0, px1) && y >= Math.min(y0, y1) && y <= Math.max(y0, y1)) {
           return { drawing, target: "line" };
         }
+      } else if (drawing.type === "ellipse") {
+        const p0 = drawing.points[0];
+        const p1 = drawing.points[1];
+        if (!p0 || !p1) continue;
+        const px0 = canvasXFromDrawingPoint(p0);
+        const px1 = canvasXFromDrawingPoint(p1);
+        const y0 = canvasYFromDrawingPrice(p0.price);
+        const y1 = canvasYFromDrawingPrice(p1.price);
+        if (Math.hypot(x - px0, y - y0) <= 9) return { drawing, target: "handle", pointIndex: 0 };
+        if (Math.hypot(x - px1, y - y1) <= 9) return { drawing, target: "handle", pointIndex: 1 };
+        if (Math.hypot(x - px0, y - y1) <= 9) return { drawing, target: "handle", pointIndex: 2 };
+        if (Math.hypot(x - px1, y - y0) <= 9) return { drawing, target: "handle", pointIndex: 3 };
+        const cx = (px0 + px1) / 2;
+        const cy = (y0 + y1) / 2;
+        const rx = Math.max(1, Math.abs(px1 - px0) / 2);
+        const ry = Math.max(1, Math.abs(y1 - y0) / 2);
+        const norm = ((x - cx) / rx) ** 2 + ((y - cy) / ry) ** 2;
+        if (norm <= 1) {
+          return { drawing, target: "line" };
+        }
+      } else if (drawing.type === "parallel-channel") {
+        const p0 = drawing.points[0];
+        const p1 = drawing.points[1];
+        const p2 = drawing.points[2];
+        if (!p0 || !p1) continue;
+        const x0 = canvasXFromDrawingPoint(p0);
+        const y0 = canvasYFromDrawingPrice(p0.price);
+        const x1 = canvasXFromDrawingPoint(p1);
+        const y1 = canvasYFromDrawingPrice(p1.price);
+        if (Math.hypot(x - x0, y - y0) <= 8) return { drawing, target: "handle", pointIndex: 0 };
+        if (Math.hypot(x - x1, y - y1) <= 8) return { drawing, target: "handle", pointIndex: 1 };
+        if (p2) {
+          const x2 = canvasXFromDrawingPoint(p2);
+          const y2 = canvasYFromDrawingPrice(p2.price);
+          if (Math.hypot(x - x2, y - y2) <= 8) return { drawing, target: "handle", pointIndex: 2 };
+          const indexSpan = p1.index - p0.index;
+          const slope = indexSpan !== 0 ? (p1.price - p0.price) / indexSpan : 0;
+          const offset = p2.price - (p0.price + slope * (p2.index - p0.index));
+          const q0y = canvasYFromDrawingPrice(p0.price + offset);
+          const q1y = canvasYFromDrawingPrice(p1.price + offset);
+          if (distanceToSegment(x, y, x0, y0, x1, y1) <= 6 || distanceToSegment(x, y, x0, q0y, x1, q1y) <= 6) {
+            return { drawing, target: "line" };
+          }
+          const minX = Math.min(x0, x1);
+          const maxX = Math.max(x0, x1);
+          if (x >= minX && x <= maxX && maxX > minX) {
+            const t = (x - x0) / (x1 - x0);
+            const baseY = y0 + t * (y1 - y0);
+            const parY = q0y + t * (q1y - q0y);
+            if (y >= Math.min(baseY, parY) && y <= Math.max(baseY, parY)) {
+              return { drawing, target: "line" };
+            }
+          }
+        } else if (distanceToSegment(x, y, x0, y0, x1, y1) <= 6) {
+          return { drawing, target: "line" };
+        }
+      } else if (drawing.type === "arrow") {
+        const first = drawing.points[0];
+        const second = drawing.points[1];
+        if (!first || !second) continue;
+        const x1 = canvasXFromDrawingPoint(first);
+        const y1 = canvasYFromDrawingPrice(first.price);
+        const x2 = canvasXFromDrawingPoint(second);
+        const y2 = canvasYFromDrawingPrice(second.price);
+        if (Math.hypot(x - x1, y - y1) <= 8) {
+          return { drawing, target: "handle", pointIndex: 0 };
+        }
+        if (Math.hypot(x - x2, y - y2) <= 8) {
+          return { drawing, target: "handle", pointIndex: 1 };
+        }
+        if (distanceToSegment(x, y, x1, y1, x2, y2) <= 6) {
+          return { drawing, target: "line" };
+        }
+      } else if (drawing.type === "brush") {
+        const pts = drawing.points;
+        if (pts.length < 2) continue;
+        let hitBody = false;
+        let prevX = canvasXFromDrawingPoint(pts[0]);
+        let prevY = canvasYFromDrawingPrice(pts[0].price);
+        for (let i = 1; i < pts.length; i += 1) {
+          const nextX = canvasXFromDrawingPoint(pts[i]);
+          const nextY = canvasYFromDrawingPrice(pts[i].price);
+          if (distanceToSegment(x, y, prevX, prevY, nextX, nextY) <= 7) {
+            hitBody = true;
+            break;
+          }
+          prevX = nextX;
+          prevY = nextY;
+        }
+        if (hitBody) {
+          return { drawing, target: "line" };
+        }
+      } else if (drawing.type === "callout") {
+        const anchor = drawing.points[0];
+        const boxPoint = drawing.points[1];
+        if (!anchor || !boxPoint) continue;
+        const ax = canvasXFromDrawingPoint(anchor);
+        const ay = canvasYFromDrawingPrice(anchor.price);
+        const bx = canvasXFromDrawingPoint(boxPoint);
+        const by = canvasYFromDrawingPrice(boxPoint.price);
+        if (Math.hypot(x - ax, y - ay) <= 9) return { drawing, target: "handle", pointIndex: 0 };
+        if (Math.hypot(x - bx, y - by) <= 9) return { drawing, target: "handle", pointIndex: 1 };
+        const fontSize = Math.max(6, drawing.fontSize);
+        const prevFont = ctx.font;
+        ctx.font = `500 ${fontSize}px ${mergedOptions.fontFamily}`;
+        const rawLabel = drawing.label ?? "";
+        const lines = (rawLabel.trim().length === 0 ? "Text" : rawLabel).split("\n");
+        const textW = Math.max(1, ...lines.map((line) => measureTextWidth(line)));
+        ctx.font = prevFont;
+        const padX = 10;
+        const padY = 7;
+        const lineH = Math.round(fontSize * 1.35);
+        const blockW = textW + padX * 2;
+        const blockH = lines.length * lineH + padY * 2;
+        if (x >= bx && x <= bx + blockW && y >= by && y <= by + blockH) {
+          return { drawing, target: "line" };
+        }
+        if (distanceToSegment(x, y, bx + blockW / 2, by + blockH / 2, ax, ay) <= 5) {
+          return { drawing, target: "line" };
+        }
       } else if (drawing.type === "price-range") {
         const p0 = drawing.points[0];
         const p1 = drawing.points[1];
@@ -7070,6 +7400,128 @@ function createChart(element, options = {}) {
       scheduleDraw();
       return true;
     }
+    if (activeDrawingTool === "arrow") {
+      if (draftDrawing?.type === "arrow") {
+        const anchor = draftDrawing.points[0];
+        const endPoint = shiftKeyActive ? constrainAngleFromAnchor(anchor, x, y) ?? point : point;
+        const completed = normalizeDrawingState({
+          ...serializeDrawing(draftDrawing),
+          points: [anchor, endPoint]
+        });
+        drawings.push(completed);
+        draftDrawing = null;
+        activeDrawingTool = null;
+        emitDrawingsChange();
+        scheduleDraw();
+        return true;
+      }
+      const defaults = getDrawingToolDefaults("arrow");
+      draftDrawing = normalizeDrawingState({
+        type: "arrow",
+        points: [point, point],
+        color: defaults.color ?? "#2563eb",
+        style: defaults.style ?? "solid",
+        width: defaults.width ?? 2
+      });
+      scheduleDraw();
+      return true;
+    }
+    if (activeDrawingTool === "parallel-channel") {
+      if (draftDrawing?.type === "parallel-channel") {
+        if (draftDrawing.points.length < 3) {
+          draftDrawing = normalizeDrawingState({
+            ...serializeDrawing(draftDrawing),
+            points: [...draftDrawing.points.slice(0, -1), point, point]
+          });
+          scheduleDraw();
+          return true;
+        }
+        const completed = normalizeDrawingState({
+          ...serializeDrawing(draftDrawing),
+          points: [draftDrawing.points[0], draftDrawing.points[1], point]
+        });
+        drawings.push(completed);
+        draftDrawing = null;
+        activeDrawingTool = null;
+        emitDrawingsChange();
+        scheduleDraw();
+        return true;
+      }
+      const defaults = getDrawingToolDefaults("parallel-channel");
+      draftDrawing = normalizeDrawingState({
+        type: "parallel-channel",
+        points: [point, point],
+        color: defaults.color ?? "#2563eb",
+        style: defaults.style ?? "solid",
+        width: defaults.width ?? 2
+      });
+      scheduleDraw();
+      return true;
+    }
+    if (activeDrawingTool === "ellipse") {
+      if (draftDrawing?.type === "ellipse") {
+        const completed = normalizeDrawingState({
+          ...serializeDrawing(draftDrawing),
+          points: [draftDrawing.points[0], point]
+        });
+        drawings.push(completed);
+        draftDrawing = null;
+        activeDrawingTool = null;
+        emitDrawingsChange();
+        scheduleDraw();
+        return true;
+      }
+      const defaults = getDrawingToolDefaults("ellipse");
+      draftDrawing = normalizeDrawingState({
+        type: "ellipse",
+        points: [point, point],
+        color: defaults.color ?? "#2962ff",
+        style: defaults.style ?? "solid",
+        width: defaults.width ?? 1
+      });
+      scheduleDraw();
+      return true;
+    }
+    if (activeDrawingTool === "callout") {
+      if (draftDrawing?.type === "callout") {
+        const completed = normalizeDrawingState({
+          ...serializeDrawing(draftDrawing),
+          points: [draftDrawing.points[0], point]
+        });
+        drawings.push(completed);
+        draftDrawing = null;
+        activeDrawingTool = null;
+        selectedDrawingId = completed.id;
+        emitDrawingsChange();
+        scheduleDraw();
+        drawingEditTextHandler?.({ drawing: serializeDrawing(completed), target: "line", x, y });
+        return true;
+      }
+      const defaults = getDrawingToolDefaults("callout");
+      draftDrawing = normalizeDrawingState({
+        type: "callout",
+        points: [point, point],
+        color: defaults.color ?? "#2962ff",
+        style: defaults.style ?? "solid",
+        width: defaults.width ?? 1,
+        ...defaults.fontSize === void 0 ? {} : { fontSize: defaults.fontSize },
+        label: ""
+      });
+      scheduleDraw();
+      return true;
+    }
+    if (activeDrawingTool === "brush") {
+      const defaults = getDrawingToolDefaults("brush");
+      draftDrawing = normalizeDrawingState({
+        type: "brush",
+        points: [point],
+        color: defaults.color ?? "#f59e0b",
+        style: defaults.style ?? "solid",
+        width: defaults.width ?? 2
+      });
+      scheduleDraw();
+      return true;
+    }
     if (activeDrawingTool === "fib-retracement") {
       if (draftDrawing?.type === "fib-retracement") {
         const completed = normalizeDrawingState({
@@ -7273,7 +7725,7 @@ function createChart(element, options = {}) {
         }
         return { ...drawing, points: pts };
       }
-      if (drawingDragState.target === "handle" && drawing.type === "rectangle") {
+      if (drawingDragState.target === "handle" && (drawing.type === "rectangle" || drawing.type === "ellipse")) {
         const pts = drawing.points.map((point) => ({ ...point }));
         const p0 = pts[0];
         const p1 = pts[1];
@@ -7292,7 +7744,7 @@ function createChart(element, options = {}) {
         }
         return { ...drawing, points: pts };
       }
-      if (drawingDragState.target === "handle" && shiftKeyActive && (drawing.type === "trendline" || drawing.type === "ray")) {
+      if (drawingDragState.target === "handle" && shiftKeyActive && (drawing.type === "trendline" || drawing.type === "ray" || drawing.type === "arrow")) {
         const pointIndex = drawingDragState.pointIndex ?? 0;
         const anchor = drawing.points[pointIndex === 0 ? 1 : 0];
         const constrained = anchor ? constrainAngleFromAnchor(anchor, x, y) : null;
@@ -7542,6 +7994,10 @@ function createChart(element, options = {}) {
     if (region === "plot" && handleDrawingToolPointerDown(point.x, point.y)) {
       setCrosshairPoint(null);
       canvas.style.cursor = "crosshair";
+      if (activeDrawingTool === "brush" && draftDrawing?.type === "brush") {
+        activePointerId = event.pointerId;
+        capturePointer(event.pointerId);
+      }
       return;
     }
     isDragging = true;
@@ -7626,9 +8082,30 @@ function createChart(element, options = {}) {
       setCrosshairPoint(null);
       return;
     }
-    if (draftDrawing && (activeDrawingTool === "trendline" || activeDrawingTool === "ray" || activeDrawingTool === "rectangle" || activeDrawingTool === "fib-retracement" || activeDrawingTool === "fib-extension")) {
+    if (draftDrawing?.type === "brush" && activeDrawingTool === "brush") {
+      if (activePointerId !== null && event.pointerId !== activePointerId) {
+        return;
+      }
+      const nextPoint = drawingPointFromCanvas(point.x, point.y);
+      if (nextPoint) {
+        const last = draftDrawing.points[draftDrawing.points.length - 1];
+        const lastX = last ? canvasXFromDrawingPoint(last) : Number.NEGATIVE_INFINITY;
+        const lastY = last ? canvasYFromDrawingPrice(last.price) : Number.NEGATIVE_INFINITY;
+        if (Math.hypot(point.x - lastX, point.y - lastY) >= 3) {
+          draftDrawing = {
+            ...draftDrawing,
+            points: [...draftDrawing.points, nextPoint]
+          };
+        }
+        canvas.style.cursor = "crosshair";
+        setCrosshairPoint(null);
+        scheduleDraw();
+      }
+      return;
+    }
+    if (draftDrawing && (activeDrawingTool === "trendline" || activeDrawingTool === "ray" || activeDrawingTool === "arrow" || activeDrawingTool === "rectangle" || activeDrawingTool === "ellipse" || activeDrawingTool === "callout" || activeDrawingTool === "parallel-channel" || activeDrawingTool === "fib-retracement" || activeDrawingTool === "fib-extension")) {
       let nextPoint = drawingPointFromCanvas(point.x, point.y);
-      if (nextPoint && shiftKeyActive && (draftDrawing.type === "trendline" || draftDrawing.type === "ray") && draftDrawing.points[0]) {
+      if (nextPoint && shiftKeyActive && (draftDrawing.type === "trendline" || draftDrawing.type === "ray" || draftDrawing.type === "arrow") && draftDrawing.points[0]) {
         nextPoint = constrainAngleFromAnchor(draftDrawing.points[0], point.x, point.y) ?? nextPoint;
       }
       if (nextPoint) {
@@ -7865,6 +8342,25 @@ function createChart(element, options = {}) {
       scheduleDraw();
       return;
     }
+    if (draftDrawing?.type === "brush" && activeDrawingTool === "brush") {
+      if (draftDrawing.points.length >= 2) {
+        const completed = normalizeDrawingState(serializeDrawing(draftDrawing));
+        drawings.push(completed);
+        draftDrawing = null;
+        activeDrawingTool = null;
+        canvas.style.cursor = "default";
+        emitDrawingsChange();
+      } else {
+        draftDrawing = null;
+        canvas.style.cursor = "crosshair";
+      }
+      isDragging = false;
+      dragMode = null;
+      activePointerId = null;
+      pointerDownInfo = null;
+      scheduleDraw();
+      return;
+    }
     if (orderDragState) {
       const moved = orderDragState.lastPrice !== orderDragState.startPrice;
       const finalLine = orderLines.find((line) => line.id === orderDragState?.orderId);
@@ -8008,7 +8504,7 @@ function createChart(element, options = {}) {
           x: point.x,
           y: point.y
         };
-        if (drawingHit.drawing.type === "text" || drawingHit.drawing.type === "note") {
+        if (drawingHit.drawing.type === "text" || drawingHit.drawing.type === "note" || drawingHit.drawing.type === "callout") {
           drawingEditTextHandler?.(payload);
         } else {
           drawingDoubleClickHandler?.(payload);
@@ -8455,6 +8951,51 @@ function createChart(element, options = {}) {
   const onDrawingHover = (handler) => {
     drawingHoverHandler = handler;
   };
+  const saveState = () => {
+    const drawingDefaults = {};
+    for (const [tool, defaults] of drawingToolDefaults) {
+      drawingDefaults[tool] = { ...defaults };
+    }
+    return {
+      version: 1,
+      chartType: getChartType(),
+      viewport: getViewport(),
+      drawings: getDrawings(),
+      indicators: getIndicators(),
+      magnetMode: getMagnetMode(),
+      drawingDefaults
+    };
+  };
+  const loadState = (state) => {
+    if (!state || typeof state !== "object") {
+      return;
+    }
+    if (typeof state.chartType === "string") {
+      setChartType(state.chartType);
+    }
+    if (Array.isArray(state.indicators)) {
+      setIndicators(state.indicators);
+    }
+    if (Array.isArray(state.drawings)) {
+      setDrawings(state.drawings);
+    }
+    if (state.magnetMode === "none" || state.magnetMode === "weak" || state.magnetMode === "strong") {
+      setMagnetMode(state.magnetMode);
+    }
+    if (state.drawingDefaults && typeof state.drawingDefaults === "object") {
+      for (const [tool, defaults] of Object.entries(state.drawingDefaults)) {
+        if (defaults && typeof defaults === "object") {
+          setDrawingDefaults(tool, defaults);
+        }
+      }
+    }
+    if (state.viewport && typeof state.viewport === "object") {
+      setViewport(state.viewport);
+    }
+  };
+  const takeScreenshot = (options2 = {}) => {
+    return canvas.toDataURL(options2.type ?? "image/png", options2.quality);
+  };
   const destroy = () => {
     cancelKineticPan();
     if (smoothingRafId !== null) {
@@ -8550,6 +9091,9 @@ function createChart(element, options = {}) {
     updateIndicator,
     removeIndicator,
     setIndicators,
+    saveState,
+    loadState,
+    takeScreenshot,
     resize,
     destroy
   };