react-klinecharts-ui 0.1.0

package/dist/chunk-SLTXNLKN.cjs

@@ -0,0 +1,932 @@
+'use strict';
+
+var reactKlinecharts = require('react-klinecharts');
+
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/overlays/index.ts
+var overlays_exports = {};
+__export(overlays_exports, {
+  abcd: () => abcd_default,
+  anyWaves: () => anyWaves_default,
+  arrow: () => arrow_default,
+  circle: () => circle_default,
+  eightWaves: () => eightWaves_default,
+  fibonacciCircle: () => fibonacciCircle_default,
+  fibonacciExtension: () => fibonacciExtension_default,
+  fibonacciSegment: () => fibonacciSegment_default,
+  fibonacciSpeedResistanceFan: () => fibonacciSpeedResistanceFan_default,
+  fibonacciSpiral: () => fibonacciSpiral_default,
+  fiveWaves: () => fiveWaves_default,
+  gannBox: () => gannBox_default,
+  parallelogram: () => parallelogram_default,
+  rect: () => rect_default,
+  threeWaves: () => threeWaves_default,
+  triangle: () => triangle_default,
+  xabcd: () => xabcd_default
+});
+function getRotateCoordinate(coordinate, targetCoordinate, angle) {
+  const x = (coordinate.x - targetCoordinate.x) * Math.cos(angle) - (coordinate.y - targetCoordinate.y) * Math.sin(angle) + targetCoordinate.x;
+  const y = (coordinate.x - targetCoordinate.x) * Math.sin(angle) + (coordinate.y - targetCoordinate.y) * Math.cos(angle) + targetCoordinate.y;
+  return { x, y };
+}
+function getRayLine(coordinates, bounding) {
+  if (coordinates.length > 1) {
+    let coordinate;
+    if (coordinates[0].x === coordinates[1].x && coordinates[0].y !== coordinates[1].y) {
+      if (coordinates[0].y < coordinates[1].y) {
+        coordinate = { x: coordinates[0].x, y: bounding.height };
+      } else {
+        coordinate = { x: coordinates[0].x, y: 0 };
+      }
+    } else if (coordinates[0].x > coordinates[1].x) {
+      coordinate = {
+        x: 0,
+        y: reactKlinecharts.utils.getLinearYFromCoordinates(coordinates[0], coordinates[1], {
+          x: 0,
+          y: coordinates[0].y
+        })
+      };
+    } else {
+      coordinate = {
+        x: bounding.width,
+        y: reactKlinecharts.utils.getLinearYFromCoordinates(coordinates[0], coordinates[1], {
+          x: bounding.width,
+          y: coordinates[0].y
+        })
+      };
+    }
+    return { coordinates: [coordinates[0], coordinate] };
+  }
+  return [];
+}
+function getDistance(coordinate1, coordinate2) {
+  const xDis = Math.abs(coordinate1.x - coordinate2.x);
+  const yDis = Math.abs(coordinate1.y - coordinate2.y);
+  return Math.sqrt(xDis * xDis + yDis * yDis);
+}
+
+// src/overlays/arrow.ts
+var arrow = {
+  name: "arrow",
+  totalStep: 3,
+  needDefaultPointFigure: true,
+  needDefaultXAxisFigure: true,
+  needDefaultYAxisFigure: true,
+  createPointFigures: ({ coordinates }) => {
+    if (coordinates.length > 1) {
+      const flag = coordinates[1].x > coordinates[0].x ? 0 : 1;
+      const kb = reactKlinecharts.utils.getLinearSlopeIntercept(coordinates[0], coordinates[1]);
+      let offsetAngle;
+      if (kb) {
+        offsetAngle = Math.atan(kb[0]) + Math.PI * flag;
+      } else {
+        if (coordinates[1].y > coordinates[0].y) {
+          offsetAngle = Math.PI / 2;
+        } else {
+          offsetAngle = Math.PI / 2 * 3;
+        }
+      }
+      const rotateCoordinate1 = getRotateCoordinate(
+        { x: coordinates[1].x - 8, y: coordinates[1].y + 4 },
+        coordinates[1],
+        offsetAngle
+      );
+      const rotateCoordinate2 = getRotateCoordinate(
+        { x: coordinates[1].x - 8, y: coordinates[1].y - 4 },
+        coordinates[1],
+        offsetAngle
+      );
+      return [
+        { type: "line", attrs: { coordinates } },
+        {
+          type: "line",
+          ignoreEvent: true,
+          attrs: {
+            coordinates: [rotateCoordinate1, coordinates[1], rotateCoordinate2]
+          }
+        }
+      ];
+    }
+    return [];
+  }
+};
+var arrow_default = arrow;
+
+// src/overlays/circle.ts
+var circle = {
+  name: "circle",
+  totalStep: 3,
+  needDefaultPointFigure: true,
+  needDefaultXAxisFigure: true,
+  needDefaultYAxisFigure: true,
+  styles: { circle: { color: "rgba(22, 119, 255, 0.15)" } },
+  createPointFigures: ({ coordinates }) => {
+    if (coordinates.length > 1) {
+      const radius = getDistance(coordinates[0], coordinates[1]);
+      return {
+        type: "circle",
+        attrs: { ...coordinates[0], r: radius },
+        styles: { style: "stroke_fill" }
+      };
+    }
+    return [];
+  }
+};
+var circle_default = circle;
+
+// src/overlays/rect.ts
+var rect = {
+  name: "rect",
+  totalStep: 3,
+  needDefaultPointFigure: true,
+  needDefaultXAxisFigure: true,
+  needDefaultYAxisFigure: true,
+  styles: { polygon: { color: "rgba(22, 119, 255, 0.15)" } },
+  createPointFigures: ({ coordinates }) => {
+    if (coordinates.length > 1) {
+      return [
+        {
+          type: "polygon",
+          attrs: {
+            coordinates: [
+              coordinates[0],
+              { x: coordinates[1].x, y: coordinates[0].y },
+              coordinates[1],
+              { x: coordinates[0].x, y: coordinates[1].y }
+            ]
+          },
+          styles: { style: "stroke_fill" }
+        }
+      ];
+    }
+    return [];
+  }
+};
+var rect_default = rect;
+
+// src/overlays/triangle.ts
+var triangle = {
+  name: "triangle",
+  totalStep: 4,
+  needDefaultPointFigure: true,
+  needDefaultXAxisFigure: true,
+  needDefaultYAxisFigure: true,
+  styles: { polygon: { color: "rgba(22, 119, 255, 0.15)" } },
+  createPointFigures: ({ coordinates }) => {
+    return [
+      {
+        type: "polygon",
+        attrs: { coordinates },
+        styles: { style: "stroke_fill" }
+      }
+    ];
+  }
+};
+var triangle_default = triangle;
+
+// src/overlays/parallelogram.ts
+var parallelogram = {
+  name: "parallelogram",
+  totalStep: 4,
+  needDefaultPointFigure: true,
+  needDefaultXAxisFigure: true,
+  needDefaultYAxisFigure: true,
+  styles: { polygon: { color: "rgba(22, 119, 255, 0.15)" } },
+  createPointFigures: ({ coordinates }) => {
+    if (coordinates.length === 2) {
+      return [{ type: "line", ignoreEvent: true, attrs: { coordinates } }];
+    }
+    if (coordinates.length === 3) {
+      const coordinate = {
+        x: coordinates[0].x + (coordinates[2].x - coordinates[1].x),
+        y: coordinates[2].y - coordinates[1].y + coordinates[0].y
+      };
+      return [
+        {
+          type: "polygon",
+          attrs: {
+            coordinates: [
+              coordinates[0],
+              coordinates[1],
+              coordinates[2],
+              coordinate
+            ]
+          },
+          styles: { style: "stroke_fill" }
+        }
+      ];
+    }
+    return [];
+  },
+  performEventPressedMove: ({ points, performPointIndex, performPoint }) => {
+    if (performPointIndex < 2) {
+      if (points[0]) points[0].price = performPoint.price;
+      if (points[1]) points[1].price = performPoint.price;
+    }
+  },
+  performEventMoveForDrawing: ({ currentStep, points, performPoint }) => {
+    if (currentStep === 2) {
+      if (points[0]) points[0].price = performPoint.price;
+    }
+  }
+};
+var parallelogram_default = parallelogram;
+
+// src/overlays/fibonacciCircle.ts
+var fibonacciCircle = {
+  name: "fibonacciCircle",
+  totalStep: 3,
+  needDefaultPointFigure: true,
+  needDefaultXAxisFigure: true,
+  needDefaultYAxisFigure: true,
+  createPointFigures: ({ coordinates }) => {
+    if (coordinates.length > 1) {
+      const xDis = Math.abs(coordinates[0].x - coordinates[1].x);
+      const yDis = Math.abs(coordinates[0].y - coordinates[1].y);
+      const radius = Math.sqrt(xDis * xDis + yDis * yDis);
+      const percents = [0.236, 0.382, 0.5, 0.618, 0.786, 1];
+      const circles = [];
+      const texts = [];
+      percents.forEach((percent) => {
+        const r = radius * percent;
+        circles.push({ ...coordinates[0], r });
+        texts.push({
+          x: coordinates[0].x,
+          y: coordinates[0].y + r + 6,
+          text: `${(percent * 100).toFixed(1)}%`
+        });
+      });
+      return [
+        { type: "circle", attrs: circles, styles: { style: "stroke" } },
+        { type: "text", ignoreEvent: true, attrs: texts }
+      ];
+    }
+    return [];
+  }
+};
+var fibonacciCircle_default = fibonacciCircle;
+
+// src/overlays/fibonacciSegment.ts
+var fibonacciSegment = {
+  name: "fibonacciSegment",
+  totalStep: 3,
+  needDefaultPointFigure: true,
+  needDefaultXAxisFigure: true,
+  needDefaultYAxisFigure: true,
+  createPointFigures: ({ coordinates, overlay, chart }) => {
+    const precision = chart.getSymbol()?.pricePrecision ?? 2;
+    const lines = [];
+    const texts = [];
+    if (coordinates.length > 1) {
+      const textX = coordinates[1].x > coordinates[0].x ? coordinates[0].x : coordinates[1].x;
+      const percents = [1, 0.786, 0.618, 0.5, 0.382, 0.236, 0];
+      const yDif = coordinates[0].y - coordinates[1].y;
+      const points = overlay.points;
+      const valueDif = points[0].value - points[1].value;
+      percents.forEach((percent) => {
+        const y = coordinates[1].y + yDif * percent;
+        const price = (points[1].value + valueDif * percent).toFixed(precision);
+        lines.push({
+          coordinates: [
+            { x: coordinates[0].x, y },
+            { x: coordinates[1].x, y }
+          ]
+        });
+        texts.push({
+          x: textX,
+          y,
+          text: `${price} (${(percent * 100).toFixed(1)}%)`,
+          baseline: "bottom"
+        });
+      });
+    }
+    return [
+      { type: "line", attrs: lines },
+      { type: "text", ignoreEvent: true, attrs: texts }
+    ];
+  }
+};
+var fibonacciSegment_default = fibonacciSegment;
+var fibonacciSpiral = {
+  name: "fibonacciSpiral",
+  totalStep: 3,
+  needDefaultPointFigure: true,
+  needDefaultXAxisFigure: true,
+  needDefaultYAxisFigure: true,
+  createPointFigures: ({ coordinates, bounding }) => {
+    if (coordinates.length > 1) {
+      const startRadius = getDistance(coordinates[0], coordinates[1]) / Math.sqrt(24);
+      const flag = coordinates[1].x > coordinates[0].x ? 0 : 1;
+      const kb = reactKlinecharts.utils.getLinearSlopeIntercept(coordinates[0], coordinates[1]);
+      let offsetAngle;
+      if (kb) {
+        offsetAngle = Math.atan(kb[0]) + Math.PI * flag;
+      } else {
+        if (coordinates[1].y > coordinates[0].y) {
+          offsetAngle = Math.PI / 2;
+        } else {
+          offsetAngle = Math.PI / 2 * 3;
+        }
+      }
+      const rotateCoordinate1 = getRotateCoordinate(
+        { x: coordinates[0].x - startRadius, y: coordinates[0].y },
+        coordinates[0],
+        offsetAngle
+      );
+      const rotateCoordinate2 = getRotateCoordinate(
+        {
+          x: coordinates[0].x - startRadius,
+          y: coordinates[0].y - startRadius
+        },
+        coordinates[0],
+        offsetAngle
+      );
+      const arcs = [
+        {
+          ...rotateCoordinate1,
+          r: startRadius,
+          startAngle: offsetAngle,
+          endAngle: offsetAngle + Math.PI / 2
+        },
+        {
+          ...rotateCoordinate2,
+          r: startRadius * 2,
+          startAngle: offsetAngle + Math.PI / 2,
+          endAngle: offsetAngle + Math.PI
+        }
+      ];
+      let x = coordinates[0].x - startRadius;
+      let y = coordinates[0].y - startRadius;
+      for (let i = 2; i < 9; i++) {
+        const r = arcs[i - 2].r + arcs[i - 1].r;
+        let startAngle = 0;
+        switch (i % 4) {
+          case 0:
+            startAngle = offsetAngle;
+            x -= arcs[i - 2].r;
+            break;
+          case 1:
+            startAngle = offsetAngle + Math.PI / 2;
+            y -= arcs[i - 2].r;
+            break;
+          case 2:
+            startAngle = offsetAngle + Math.PI;
+            x += arcs[i - 2].r;
+            break;
+          case 3:
+            startAngle = offsetAngle + Math.PI / 2 * 3;
+            y += arcs[i - 2].r;
+            break;
+        }
+        const endAngle = startAngle + Math.PI / 2;
+        const rotateCoordinate = getRotateCoordinate(
+          { x, y },
+          coordinates[0],
+          offsetAngle
+        );
+        arcs.push({ ...rotateCoordinate, r, startAngle, endAngle });
+      }
+      return [
+        { type: "arc", attrs: arcs },
+        { type: "line", attrs: getRayLine(coordinates, bounding) }
+      ];
+    }
+    return [];
+  }
+};
+var fibonacciSpiral_default = fibonacciSpiral;
+
+// src/overlays/fibonacciSpeedResistanceFan.ts
+var fibonacciSpeedResistanceFan = {
+  name: "fibonacciSpeedResistanceFan",
+  totalStep: 3,
+  needDefaultPointFigure: true,
+  needDefaultXAxisFigure: true,
+  needDefaultYAxisFigure: true,
+  createPointFigures: ({ coordinates, bounding }) => {
+    const lines1 = [];
+    let lines2 = [];
+    const texts = [];
+    if (coordinates.length > 1) {
+      const xOffset = coordinates[1].x > coordinates[0].x ? -38 : 4;
+      const yOffset = coordinates[1].y > coordinates[0].y ? -2 : 20;
+      const xDistance = coordinates[1].x - coordinates[0].x;
+      const yDistance = coordinates[1].y - coordinates[0].y;
+      const percents = [1, 0.75, 0.618, 0.5, 0.382, 0.25, 0];
+      percents.forEach((percent) => {
+        const x = coordinates[1].x - xDistance * percent;
+        const y = coordinates[1].y - yDistance * percent;
+        lines1.push({
+          coordinates: [
+            { x, y: coordinates[0].y },
+            { x, y: coordinates[1].y }
+          ]
+        });
+        lines1.push({
+          coordinates: [
+            { x: coordinates[0].x, y },
+            { x: coordinates[1].x, y }
+          ]
+        });
+        lines2 = lines2.concat(
+          getRayLine(
+            [coordinates[0], { x, y: coordinates[1].y }],
+            bounding
+          )
+        );
+        lines2 = lines2.concat(
+          getRayLine(
+            [coordinates[0], { x: coordinates[1].x, y }],
+            bounding
+          )
+        );
+        texts.unshift({
+          x: coordinates[0].x + xOffset,
+          y: y + 10,
+          text: `${percent.toFixed(3)}`
+        });
+        texts.unshift({
+          x: x - 18,
+          y: coordinates[0].y + yOffset,
+          text: `${percent.toFixed(3)}`
+        });
+      });
+    }
+    return [
+      { type: "line", attrs: lines1 },
+      { type: "line", attrs: lines2 },
+      { type: "text", ignoreEvent: true, attrs: texts }
+    ];
+  }
+};
+var fibonacciSpeedResistanceFan_default = fibonacciSpeedResistanceFan;
+
+// src/overlays/fibonacciExtension.ts
+var fibonacciExtension = {
+  name: "fibonacciExtension",
+  totalStep: 4,
+  needDefaultPointFigure: true,
+  needDefaultXAxisFigure: true,
+  needDefaultYAxisFigure: true,
+  createPointFigures: ({ coordinates, overlay, chart }) => {
+    const precision = chart.getSymbol()?.pricePrecision ?? 2;
+    const fbLines = [];
+    const texts = [];
+    if (coordinates.length > 2) {
+      const points = overlay.points;
+      const valueDif = points[1].value - points[0].value;
+      const yDif = coordinates[1].y - coordinates[0].y;
+      const percents = [0, 0.236, 0.382, 0.5, 0.618, 0.786, 1];
+      const textX = coordinates[2].x > coordinates[1].x ? coordinates[1].x : coordinates[2].x;
+      percents.forEach((percent) => {
+        const y = coordinates[2].y + yDif * percent;
+        const price = (points[2].value + valueDif * percent).toFixed(precision);
+        fbLines.push({
+          coordinates: [
+            { x: coordinates[1].x, y },
+            { x: coordinates[2].x, y }
+          ]
+        });
+        texts.push({
+          x: textX,
+          y,
+          text: `${price} (${(percent * 100).toFixed(1)}%)`,
+          baseline: "bottom"
+        });
+      });
+    }
+    return [
+      {
+        type: "line",
+        attrs: { coordinates },
+        styles: { style: "dashed" }
+      },
+      { type: "line", attrs: fbLines },
+      { type: "text", ignoreEvent: true, attrs: texts }
+    ];
+  }
+};
+var fibonacciExtension_default = fibonacciExtension;
+
+// src/overlays/gannBox.ts
+var gannBox = {
+  name: "gannBox",
+  totalStep: 3,
+  needDefaultPointFigure: true,
+  needDefaultXAxisFigure: true,
+  needDefaultYAxisFigure: true,
+  styles: { polygon: { color: "rgba(22, 119, 255, 0.15)" } },
+  createPointFigures: ({ coordinates }) => {
+    if (coordinates.length > 1) {
+      const quarterYDis = (coordinates[1].y - coordinates[0].y) / 4;
+      const xDis = coordinates[1].x - coordinates[0].x;
+      const dashedLines = [
+        {
+          coordinates: [
+            coordinates[0],
+            { x: coordinates[1].x, y: coordinates[1].y - quarterYDis }
+          ]
+        },
+        {
+          coordinates: [
+            coordinates[0],
+            { x: coordinates[1].x, y: coordinates[1].y - quarterYDis * 2 }
+          ]
+        },
+        {
+          coordinates: [
+            { x: coordinates[0].x, y: coordinates[1].y },
+            { x: coordinates[1].x, y: coordinates[0].y + quarterYDis }
+          ]
+        },
+        {
+          coordinates: [
+            { x: coordinates[0].x, y: coordinates[1].y },
+            { x: coordinates[1].x, y: coordinates[0].y + quarterYDis * 2 }
+          ]
+        },
+        {
+          coordinates: [
+            { ...coordinates[0] },
+            { x: coordinates[0].x + xDis * 0.236, y: coordinates[1].y }
+          ]
+        },
+        {
+          coordinates: [
+            { ...coordinates[0] },
+            { x: coordinates[0].x + xDis * 0.5, y: coordinates[1].y }
+          ]
+        },
+        {
+          coordinates: [
+            { x: coordinates[0].x, y: coordinates[1].y },
+            { x: coordinates[0].x + xDis * 0.236, y: coordinates[0].y }
+          ]
+        },
+        {
+          coordinates: [
+            { x: coordinates[0].x, y: coordinates[1].y },
+            { x: coordinates[0].x + xDis * 0.5, y: coordinates[0].y }
+          ]
+        }
+      ];
+      const solidLines = [
+        { coordinates: [coordinates[0], coordinates[1]] },
+        {
+          coordinates: [
+            { x: coordinates[0].x, y: coordinates[1].y },
+            { x: coordinates[1].x, y: coordinates[0].y }
+          ]
+        }
+      ];
+      return [
+        {
+          type: "line",
+          attrs: [
+            {
+              coordinates: [
+                coordinates[0],
+                { x: coordinates[1].x, y: coordinates[0].y }
+              ]
+            },
+            {
+              coordinates: [
+                { x: coordinates[1].x, y: coordinates[0].y },
+                coordinates[1]
+              ]
+            },
+            {
+              coordinates: [
+                coordinates[1],
+                { x: coordinates[0].x, y: coordinates[1].y }
+              ]
+            },
+            {
+              coordinates: [
+                { x: coordinates[0].x, y: coordinates[1].y },
+                coordinates[0]
+              ]
+            }
+          ]
+        },
+        {
+          type: "polygon",
+          ignoreEvent: true,
+          attrs: {
+            coordinates: [
+              coordinates[0],
+              { x: coordinates[1].x, y: coordinates[0].y },
+              coordinates[1],
+              { x: coordinates[0].x, y: coordinates[1].y }
+            ]
+          },
+          styles: { style: "fill" }
+        },
+        { type: "line", attrs: dashedLines, styles: { style: "dashed" } },
+        { type: "line", attrs: solidLines }
+      ];
+    }
+    return [];
+  }
+};
+var gannBox_default = gannBox;
+
+// src/overlays/threeWaves.ts
+var threeWaves = {
+  name: "threeWaves",
+  totalStep: 5,
+  needDefaultPointFigure: true,
+  needDefaultXAxisFigure: true,
+  needDefaultYAxisFigure: true,
+  createPointFigures: ({ coordinates }) => {
+    const texts = coordinates.map((coordinate, i) => ({
+      ...coordinate,
+      text: `(${i})`,
+      baseline: "bottom"
+    }));
+    return [
+      { type: "line", attrs: { coordinates } },
+      { type: "text", ignoreEvent: true, attrs: texts }
+    ];
+  }
+};
+var threeWaves_default = threeWaves;
+
+// src/overlays/fiveWaves.ts
+var fiveWaves = {
+  name: "fiveWaves",
+  totalStep: 7,
+  needDefaultPointFigure: true,
+  needDefaultXAxisFigure: true,
+  needDefaultYAxisFigure: true,
+  createPointFigures: ({ coordinates }) => {
+    const texts = coordinates.map((coordinate, i) => ({
+      ...coordinate,
+      text: `(${i})`,
+      baseline: "bottom"
+    }));
+    return [
+      { type: "line", attrs: { coordinates } },
+      { type: "text", ignoreEvent: true, attrs: texts }
+    ];
+  }
+};
+var fiveWaves_default = fiveWaves;
+
+// src/overlays/eightWaves.ts
+var eightWaves = {
+  name: "eightWaves",
+  totalStep: 10,
+  needDefaultPointFigure: true,
+  needDefaultXAxisFigure: true,
+  needDefaultYAxisFigure: true,
+  createPointFigures: ({ coordinates }) => {
+    const texts = coordinates.map((coordinate, i) => ({
+      ...coordinate,
+      text: `(${i})`,
+      baseline: "bottom"
+    }));
+    return [
+      { type: "line", attrs: { coordinates } },
+      { type: "text", ignoreEvent: true, attrs: texts }
+    ];
+  }
+};
+var eightWaves_default = eightWaves;
+
+// src/overlays/anyWaves.ts
+var anyWaves = {
+  name: "anyWaves",
+  totalStep: Number.MAX_SAFE_INTEGER,
+  needDefaultPointFigure: true,
+  needDefaultXAxisFigure: true,
+  needDefaultYAxisFigure: true,
+  createPointFigures: ({ coordinates }) => {
+    const texts = coordinates.map((coordinate, i) => ({
+      ...coordinate,
+      text: `(${i})`,
+      baseline: "bottom"
+    }));
+    return [
+      { type: "line", attrs: { coordinates } },
+      { type: "text", ignoreEvent: true, attrs: texts }
+    ];
+  }
+};
+var anyWaves_default = anyWaves;
+
+// src/overlays/abcd.ts
+var abcd = {
+  name: "abcd",
+  totalStep: 5,
+  needDefaultPointFigure: true,
+  needDefaultXAxisFigure: true,
+  needDefaultYAxisFigure: true,
+  createPointFigures: ({ coordinates }) => {
+    let acLineCoordinates = [];
+    let bdLineCoordinates = [];
+    const tags = ["A", "B", "C", "D"];
+    const texts = coordinates.map((coordinate, i) => ({
+      ...coordinate,
+      baseline: "bottom",
+      text: `(${tags[i]})`
+    }));
+    if (coordinates.length > 2) {
+      acLineCoordinates = [coordinates[0], coordinates[2]];
+      if (coordinates.length > 3) {
+        bdLineCoordinates = [coordinates[1], coordinates[3]];
+      }
+    }
+    return [
+      { type: "line", attrs: { coordinates } },
+      {
+        type: "line",
+        attrs: [
+          { coordinates: acLineCoordinates },
+          { coordinates: bdLineCoordinates }
+        ],
+        styles: { style: "dashed" }
+      },
+      { type: "text", ignoreEvent: true, attrs: texts }
+    ];
+  }
+};
+var abcd_default = abcd;
+
+// src/overlays/xabcd.ts
+var xabcd = {
+  name: "xabcd",
+  totalStep: 6,
+  needDefaultPointFigure: true,
+  needDefaultXAxisFigure: true,
+  needDefaultYAxisFigure: true,
+  styles: { polygon: { color: "rgba(22, 119, 255, 0.15)" } },
+  createPointFigures: ({ coordinates }) => {
+    const dashedLines = [];
+    const polygons = [];
+    const tags = ["X", "A", "B", "C", "D"];
+    const texts = coordinates.map((coordinate, i) => ({
+      ...coordinate,
+      baseline: "bottom",
+      text: `(${tags[i]})`
+    }));
+    if (coordinates.length > 2) {
+      dashedLines.push({ coordinates: [coordinates[0], coordinates[2]] });
+      polygons.push({
+        coordinates: [coordinates[0], coordinates[1], coordinates[2]]
+      });
+      if (coordinates.length > 3) {
+        dashedLines.push({ coordinates: [coordinates[1], coordinates[3]] });
+        if (coordinates.length > 4) {
+          dashedLines.push({ coordinates: [coordinates[2], coordinates[4]] });
+          polygons.push({
+            coordinates: [coordinates[2], coordinates[3], coordinates[4]]
+          });
+        }
+      }
+    }
+    return [
+      { type: "line", attrs: { coordinates } },
+      { type: "line", attrs: dashedLines, styles: { style: "dashed" } },
+      { type: "polygon", ignoreEvent: true, attrs: polygons },
+      { type: "text", ignoreEvent: true, attrs: texts }
+    ];
+  }
+};
+var xabcd_default = xabcd;
+
+// src/extensions/overlays/orderLine.ts
+var DEFAULT_FONT_FAMILY = "Helvetica Neue, Arial, sans-serif";
+var orderLine = {
+  name: "orderLine",
+  totalStep: 2,
+  needDefaultPointFigure: false,
+  needDefaultXAxisFigure: false,
+  needDefaultYAxisFigure: false,
+  createYAxisFigures: ({ chart, overlay, coordinates }) => {
+    if (coordinates.length < 1) return [];
+    const y = coordinates[0].y;
+    const price = overlay.points[0]?.value;
+    if (price == null) return [];
+    const d = overlay.extendData ?? {};
+    const color = d.color ?? "rgba(255, 165, 0, 0.85)";
+    const m = d.mark;
+    const precision = chart.getSymbol()?.pricePrecision ?? 2;
+    return [
+      {
+        type: "text",
+        attrs: {
+          x: 0,
+          y,
+          text: price.toFixed(precision),
+          align: "left",
+          baseline: "middle"
+        },
+        styles: {
+          color: m?.color ?? "#ffffff",
+          size: m?.font?.size ?? 11,
+          family: m?.font?.family ?? DEFAULT_FONT_FAMILY,
+          weight: m?.font?.weight ?? "bold",
+          paddingLeft: m?.padding?.x ?? 4,
+          paddingRight: m?.padding?.x ?? 4,
+          paddingTop: m?.padding?.y ?? 4,
+          paddingBottom: m?.padding?.y ?? 4,
+          backgroundColor: m?.bg ?? color,
+          borderRadius: m?.borderRadius ?? 2
+        }
+      }
+    ];
+  },
+  createPointFigures: ({ coordinates, bounding, overlay }) => {
+    if (coordinates.length < 1) return [];
+    const y = coordinates[0].y;
+    const d = overlay.extendData ?? {};
+    const color = d.color ?? "rgba(255, 165, 0, 0.85)";
+    const ln = d.line;
+    const figures = [
+      {
+        type: "line",
+        attrs: {
+          coordinates: [
+            { x: 0, y },
+            { x: bounding.width, y }
+          ]
+        },
+        styles: {
+          style: ln?.style ?? "dashed",
+          color,
+          size: ln?.width ?? 1,
+          dashedValue: ln?.dashedValue ?? [4, 2]
+        }
+      }
+    ];
+    if (d.text) {
+      const lb = d.label;
+      figures.push({
+        type: "text",
+        ignoreEvent: true,
+        attrs: {
+          x: lb?.offset?.x ?? 8,
+          y: y - (lb?.offset?.y ?? 3),
+          text: d.text,
+          align: "left",
+          baseline: "bottom"
+        },
+        styles: {
+          color: lb?.color ?? color,
+          size: lb?.font?.size ?? 11,
+          family: lb?.font?.family ?? DEFAULT_FONT_FAMILY,
+          weight: lb?.font?.weight ?? "normal",
+          paddingLeft: lb?.padding?.x ?? 0,
+          paddingRight: lb?.padding?.x ?? 0,
+          paddingTop: lb?.padding?.y ?? 0,
+          paddingBottom: lb?.padding?.y ?? 0,
+          backgroundColor: lb?.bg ?? "transparent",
+          borderRadius: lb?.borderRadius ?? 0
+        }
+      });
+    }
+    return figures;
+  },
+  performEventPressedMove: ({ points, performPoint }) => {
+    points[0].value = performPoint.value;
+  }
+};
+var orderLine_default = orderLine;
+
+// src/extensions/index.ts
+var overlays = Object.values(overlays_exports);
+var registered = false;
+function registerExtensions() {
+  if (registered) return;
+  overlays.forEach((overlay) => reactKlinecharts.registerOverlay(overlay));
+  registered = true;
+}
+
+exports.abcd_default = abcd_default;
+exports.anyWaves_default = anyWaves_default;
+exports.arrow_default = arrow_default;
+exports.circle_default = circle_default;
+exports.eightWaves_default = eightWaves_default;
+exports.fibonacciCircle_default = fibonacciCircle_default;
+exports.fibonacciExtension_default = fibonacciExtension_default;
+exports.fibonacciSegment_default = fibonacciSegment_default;
+exports.fibonacciSpeedResistanceFan_default = fibonacciSpeedResistanceFan_default;
+exports.fibonacciSpiral_default = fibonacciSpiral_default;
+exports.fiveWaves_default = fiveWaves_default;
+exports.gannBox_default = gannBox_default;
+exports.orderLine_default = orderLine_default;
+exports.overlays = overlays;
+exports.parallelogram_default = parallelogram_default;
+exports.rect_default = rect_default;
+exports.registerExtensions = registerExtensions;
+exports.threeWaves_default = threeWaves_default;
+exports.triangle_default = triangle_default;
+exports.xabcd_default = xabcd_default;
+//# sourceMappingURL=chunk-SLTXNLKN.cjs.map
+//# sourceMappingURL=chunk-SLTXNLKN.cjs.map