st-comp 0.0.164 → 0.0.166

package/packages/KlinePlus/utils.js

@@ -0,0 +1,705 @@
+import dayjs from "dayjs";
+import { stMath } from "st-func";
+
+const { round } = stMath;
+
+// 获取K线展示根数上限配置
+export const loadKlineConfig = {
+  // 单屏展示条目上限
+  minValueSpan: 5,
+  maxValueSpan: 2000,
+  // 加载更多: 触发阈值
+  loadCheckCount: 500,
+  // 加载更多: 载入条目
+  loadAddCount: 2000,
+};
+
+// 获取副图配置
+const getSubBarStyle = (data, index) => {
+  const itemData = data[index];
+  const preItemData = index === 0 ? data[index] : data[index - 1];
+  if (itemData[0] === itemData[1]) {
+    return itemData[0] >= preItemData[1]
+      ? {
+          color: "transparent",
+          borderColor: "#FF0000",
+        }
+      : {
+          color: "#00FFFF",
+        };
+  } else {
+    return itemData[1] > itemData[0]
+      ? {
+          color: "transparent",
+          borderColor: "#FF0000",
+        }
+      : {
+          color: "#00FFFF",
+        };
+  }
+};
+export const getSubOptions = (klineData, startValue, endValue) => {
+  const series = klineData.subIndicator.map((item) => {
+    if (item.series === "bar") {
+      return {
+        name: "subMain",
+        xAxisIndex: 0,
+        yAxisIndex: 1,
+        type: "bar",
+        silent: true,
+        symbol: "none",
+        data: item.data.map((val, index) => {
+          if (item.seriesColor === "kline") {
+            return {
+              value: val,
+              itemStyle: getSubBarStyle(klineData.data, index),
+            };
+          } else if (item.seriesColor === "value") {
+            return {
+              value: val,
+              itemStyle: {
+                color: val >= 0 ? "#FF0000" : "#00FFFF",
+              },
+            };
+          } else {
+            return {
+              value: val,
+              itemStyle: {
+                color: item.seriesColor,
+              },
+            };
+          }
+        }),
+      };
+    } else if (item.series === "line") {
+      return {
+        xAxisIndex: 0,
+        yAxisIndex: item.yAxis === "right" ? 2 : 1,
+        name: item.key,
+        type: "line",
+        silent: true,
+        symbol: "none",
+        data: item.data,
+        lineStyle: {
+          width: 1,
+        },
+        itemStyle: {
+          color: item.color,
+        },
+      };
+    }
+  });
+  return {
+    animation: false,
+    grid: {
+      top: "10px",
+      left: "60px",
+      right: "20px",
+      bottom: "10px",
+    },
+    dataZoom: [
+      {
+        type: "inside",
+        startValue,
+        endValue,
+        maxValueSpan: loadKlineConfig.maxValueSpan,
+      },
+    ],
+    tooltip: {
+      show: false,
+    },
+    axisPointer: {
+      show: true,
+      triggerTooltip: false,
+      label: {
+        rich: {},
+        formatter: (data) => {
+          const { axisDimension, value } = data;
+          if (axisDimension === "x") {
+            return null;
+          } else if (data.axisIndex === 1) {
+            return String(round(value));
+          }
+        },
+      },
+    },
+    xAxis: {
+      type: "category",
+      data: klineData.time,
+      axisLine: {
+        show: true,
+      },
+      splitLine: {
+        show: false,
+      },
+      axisLabel: {
+        show: false,
+      },
+    },
+    yAxis: [
+      {
+        position: "right",
+      },
+      {
+        position: "left",
+        min: klineData.subIndicator[0]?.leftYAxisRange === "cover" ? (value) => value.min : null,
+        max: klineData.subIndicator[0]?.leftYAxisRange === "cover" ? (value) => value.max : null,
+        splitNumber: 1,
+        axisLine: {
+          show: true,
+        },
+        splitLine: {
+          show: true,
+          lineStyle: {
+            type: "dotted",
+            color: "#333",
+          },
+        },
+      },
+      {
+        position: "right",
+        min: klineData.subIndicator[0]?.rightYAxisRange === "cover" ? (value) => value.min : null,
+        max: klineData.subIndicator[0]?.rightYAxisRange === "cover" ? (value) => value.max : null,
+        splitNumber: 1,
+        axisLine: {
+          show: false,
+        },
+        splitLine: {
+          show: false,
+        },
+        axisLabel: {
+          show: false,
+        },
+      },
+    ],
+    series,
+  };
+};
+
+/**
+ * @description: 二分查找法
+ * @param {Array}: 值数组
+ * @param {any}: 值
+ * @param {string}: 查找模式
+ *   - "strict": 精确查找（默认）
+ *   - "gte": 查找第一个大于等于目标值的元素
+ * @returns {Number}: 索引 (-1表示未找到)
+ */
+export const binarySearch = (arr, target, type = "strict") => {
+  let left = 0;
+  let right = arr.length - 1;
+  let result = -1; // 仅用于 gte 模式
+
+  while (left <= right) {
+    let mid = Math.floor((left + right) / 2);
+    if (type === "strict") {
+      // 精确查找模式
+      if (arr[mid] === target) {
+        return mid;
+      } else if (arr[mid] < target) {
+        // 左半区
+        left = mid + 1;
+      } else {
+        // 右半区
+        right = mid - 1;
+      }
+    }
+    // 大于等于模式
+    else if (type === "gte") {
+      if (arr[mid] >= target) {
+        result = mid; // 记录可能的结果
+        right = mid - 1; // 继续向左尝试找到更小的匹配
+      } else {
+        left = mid + 1;
+      }
+    }
+  }
+
+  return type === "strict" ? -1 : result;
+};
+
+// K线数据合并
+export const mergeklineData = (leftData, rightData) => {
+  return {
+    data: [...leftData.data, ...rightData.data.slice(1)],
+    mainIndicator: leftData.mainIndicator.map((item, index) => ({
+      ...item,
+      data: [...item.data, ...rightData.mainIndicator[index].data.slice(1)],
+    })),
+    subIndicator: leftData.subIndicator.map((item, index) => ({
+      ...item,
+      data: [...item.data, ...rightData.subIndicator[index].data.slice(1)],
+    })),
+    time: [...leftData.time, ...rightData.time.slice(1)],
+  };
+};
+
+// 将时间标准化为K线时间(精准计算)
+export const normalizeToKlineTime = (klineTimeArray, time, cycle) => {
+  // 5, 6, 7, 8特殊处理
+  switch (cycle) {
+    /**
+     * @description: 60min
+     * 按照最新的20根K线时分秒做匹配
+     * 不进行步阶计算的原因是无法确认首根K线的时间, 例如真实时间 09:35:00, 该品种首根可能是 10:00:00 也可能是 10:30:00
+     */
+    case "5": {
+      let HmsArray = [
+        ...new Set(
+          klineTimeArray.slice(-20).map((item) => {
+            const date = new Date(item);
+            const hour = String(date.getHours()).padStart(2, "0");
+            const minute = String(date.getMinutes()).padStart(2, "0");
+            const second = String(date.getSeconds()).padStart(2, "0");
+            return `${hour}:${minute}:${second}`;
+          })
+        ),
+      ];
+      if (HmsArray.includes("00:00:00")) {
+        HmsArray.splice(HmsArray.indexOf("00:00:00"), 1);
+        HmsArray.push("24:00:00");
+      }
+      HmsArray = HmsArray.sort((a, b) => new Date(`2000-01-30 ${a}`).getTime() - new Date(`2000-01-30 ${b}`).getTime());
+
+      const date = new Date(time);
+      const year = date.getFullYear();
+      const month = String(date.getMonth() + 1).padStart(2, "0");
+      const day = String(date.getDate()).padStart(2, "0");
+      const hour = String(date.getHours()).padStart(2, "0");
+      const minute = String(date.getMinutes()).padStart(2, "0");
+      const second = String(date.getSeconds()).padStart(2, "0");
+
+      // 该类为数据中台补全的数据, 不管它
+      if (`${hour}:${minute}:${second}` === "00:00:00") {
+        return `${year}-${month}-${day} 01:00:00`;
+      }
+      // 进行处理
+      else {
+        let Hms = null;
+        for (let index = 0; index < HmsArray.length; index++) {
+          const item = HmsArray[index].split(":");
+          if (Number(`${item[0]}${item[1]}${item[2]}`) >= Number(`${hour}${minute}${second}`)) {
+            Hms = HmsArray[index];
+            break;
+          }
+        }
+        if (Hms === "24:00:00") {
+          const date = new Date(time);
+          date.setDate(date.getDate() + 1);
+          const year = date.getFullYear();
+          const month = String(date.getMonth() + 1).padStart(2, "0");
+          const day = String(date.getDate()).padStart(2, "0");
+          return `${year}-${month}-${day} 00:00:00`;
+        }
+        return `${year}-${month}-${day} ${Hms}`;
+      }
+    }
+    /**
+     * @description: 1d
+     * 因为考虑到期货的操作, 并且日线不像周月线那样直接统一成周五,或月末, 如果直接+1天会面临可能存在的非交易日的情况
+     * 所以针对 [21:00:00 ~ 04:00:00)的数据, 都要进行匹配的算法, 即去klineTimeArray找到当前time的下一个日期
+     */
+    case "6": {
+      const date = new Date(time);
+      const hours = date.getHours();
+      // 常规处理的 [04:00:00 ~ 21:00:00) => 直接格式化
+      if (hours >= 4 && hours < 21) {
+        const year = date.getFullYear();
+        const month = String(date.getMonth() + 1).padStart(2, "0");
+        const day = String(date.getDate()).padStart(2, "0");
+        return `${year}-${month}-${day} 09:00:00`;
+      }
+      // 特殊处理的 [21:00:00 ~ 04:00:00) => 匹配算法
+      else {
+        const currentDate = new Date(time);
+        // 如果是21:00:00之后, 需要将日期+1天
+        if (currentDate.getHours() >= 21) {
+          currentDate.setDate(currentDate.getDate() + 1);
+        }
+        const year = currentDate.getFullYear();
+        const month = String(currentDate.getMonth() + 1).padStart(2, "0");
+        const day = String(currentDate.getDate()).padStart(2, "0");
+        const currentDateStr = `${year}-${month}-${day} 09:00:00`;
+
+        // 在klineTimeArray中找到当前日期或之后的第一个交易日 (二分优化)
+        const idx = binarySearch(klineTimeArray, currentDateStr, "gte");
+        return idx === -1 ? currentDateStr : klineTimeArray[idx];
+      }
+    }
+    /**
+     * @description: 1w
+     * 周五 || 下周五
+     */
+    case "7": {
+      const date = new Date(time);
+      const startOfWeek = new Date(date);
+      startOfWeek.setDate(date.getDate() - date.getDay());
+      startOfWeek.setHours(0, 0, 0, 0);
+      const nowWeek5 = new Date(startOfWeek);
+      nowWeek5.setDate(startOfWeek.getDate() + 5);
+      nowWeek5.setHours(23, 59, 59, 0);
+      const nextWeek5 = new Date(startOfWeek);
+      nextWeek5.setDate(startOfWeek.getDate() + 12);
+      nextWeek5.setHours(9, 0, 0, 0);
+      const result = date <= nowWeek5 ? nowWeek5 : nextWeek5;
+      const year = result.getFullYear();
+      const month = String(result.getMonth() + 1).padStart(2, "0");
+      const day = String(result.getDate()).padStart(2, "0");
+      return `${year}-${month}-${day} 09:00:00`;
+    }
+    /**
+     * @description: 1mon
+     * 本月最后一天
+     */
+    case "8": {
+      const date = new Date(time);
+      const nextMonth = new Date(date.getFullYear(), date.getMonth() + 1, 1);
+      const endOfMonth = new Date(nextMonth);
+      endOfMonth.setDate(nextMonth.getDate() - 1);
+      endOfMonth.setHours(9, 0, 0, 0);
+      const year = endOfMonth.getFullYear();
+      const month = String(endOfMonth.getMonth() + 1).padStart(2, "0");
+      const day = String(endOfMonth.getDate()).padStart(2, "0");
+      return `${year}-${month}-${day} 09:00:00`;
+    }
+  }
+  // 1, 2, 3, 4步阶计算
+  const date = new Date(time);
+  const year = date.getFullYear();
+  const month = date.getMonth(); // 0-based
+  const day = date.getDate();
+  const hour = date.getHours();
+  const minute = date.getMinutes();
+  const second = date.getSeconds();
+  const computeSmallCycle = (periodMinutes) => {
+    let targetMinute = null;
+    // 计算是否需要进位
+    const currentPeriod = Math.floor(minute / periodMinutes);
+    if (minute % periodMinutes === 0 && second === 0) {
+      // 正好在周期边界上且秒为0，不调整
+      targetMinute = minute;
+    } else {
+      // 计算下一个周期点
+      targetMinute = (currentPeriod + 1) * periodMinutes;
+    }
+
+    // 处理小时, 分钟的进位
+    const minuteCarry = Math.floor(targetMinute / 60);
+    const adjustedHour = hour + minuteCarry;
+    const adjustedMinute = targetMinute % 60;
+
+    // 创建新日期（自动处理日/月/年进位）
+    const resultDate = new Date(year, month, day, adjustedHour, adjustedMinute, 0);
+
+    // 格式化输出
+    const formatPart = (num) => String(num).padStart(2, "0");
+    const formattedYear = resultDate.getFullYear();
+    const formattedMonth = formatPart(resultDate.getMonth() + 1);
+    const formattedDay = formatPart(resultDate.getDate());
+    const formattedHour = formatPart(resultDate.getHours());
+    const formattedMinute = formatPart(resultDate.getMinutes());
+
+    return `${formattedYear}-${formattedMonth}-${formattedDay} ${formattedHour}:${formattedMinute}:00`;
+  };
+  switch (cycle) {
+    case "1":
+      return computeSmallCycle(1); // 1m周期
+    case "2":
+      return computeSmallCycle(5); // 5m周期
+    case "3":
+      return computeSmallCycle(15); // 15m周期
+    case "4":
+      return computeSmallCycle(30); // 30m周期
+    default:
+      throw new Error(`Unsupported cycle: ${time} ${cycle}`);
+  }
+};
+
+// 将时间标准化为K线时间范围(匹配算法)
+export const normalizeToKlineTimeByMatch = (klineTimeArray, timeRange, cycle) => {
+  let klineStart = null;
+  let klineEnd = null;
+  const [start, end] = timeRange;
+  switch (cycle) {
+    // 日线
+    case "6": {
+      klineStart = klineTimeArray.find((t) => new Date(dayjs(t).format("YYYY-MM-DD 23:59:59")).getTime() >= new Date(start).getTime());
+      klineEnd = klineTimeArray.findLast((t) => new Date(dayjs(t).format("YYYY-MM-DD 00:00:00")).getTime() <= new Date(end).getTime());
+      break;
+    }
+    // 周线
+    case "7": {
+      const format5 = dayjs(end).endOf("week").add(1, "day").format("YYYY-MM-DD 23:59:59");
+      klineStart = klineTimeArray.find((t) => dayjs(t).endOf("week").add(1, "day").format("YYYY-MM-DD") === dayjs(start).endOf("week").add(1, "day").format("YYYY-MM-DD"));
+      klineEnd = klineTimeArray.findLast((t) => new Date(t).getTime() <= new Date(format5).getTime());
+      break;
+    }
+    // 月线 (仅判断是否同属本月即可)
+    case "8": {
+      klineStart = klineTimeArray.find((t) => dayjs(t).format("YYYY-MM") === dayjs(start).format("YYYY-MM"));
+      klineEnd = klineTimeArray.findLast((t) => dayjs(t).format("YYYY-MM") === dayjs(end).format("YYYY-MM"));
+      break;
+    }
+    // 常规匹配
+    default: {
+      klineStart = klineTimeArray.find((t) => new Date(t).getTime() >= new Date(start).getTime());
+      klineEnd = klineTimeArray.findLast((t) => new Date(t).getTime() <= new Date(end).getTime());
+    }
+  }
+  return [klineStart, klineEnd]
+};
+
+// 统一处理markPoint标记点的偏移量
+export const handleMarkPointOffset = (markPointData) => {
+  const data = [];
+  markPointData.reduce((result, item) => {
+    // 1. 找到当前标记的位置
+    const key = `${item.coord[0]}+${item.label.position}`;
+    const baseOffset = item.label.position === "top" ? -16 : 16;
+    // 2. 找到先前处于相同位置 [key] 标记的数量
+    const sameNum = result.get(key);
+    if (sameNum) {
+      result.set(key, sameNum + 1);
+      item.symbolOffset[1] = baseOffset * (sameNum + 1);
+    } else {
+      result.set(key, 1);
+      item.symbolOffset[1] = item.label.position === "top" ? -7 : 7;
+    }
+    data.push(item);
+    return result;
+  }, new Map());
+  return data;
+};
+
+// 生成图表配置所需数据: 成交点位, 成交点位连线
+export const handleMarkPointTradeLog = (tradeLog, cycle, sellBuy, klineTimeArray, klineDataArray) => {
+  // 获取交易类型
+  const handleTradeType = (data, type) => {
+    const { direction = "", tradeAction = "", tradeType = "" } = data;
+    const key = tradeType ?? direction + tradeAction;
+    switch (type) {
+      // 买卖
+      case 0: {
+        const keyMap = new Map([
+          ["开多", "买"],
+          ["平多", "卖"],
+          ["开空", "卖"],
+          ["平空", "买"],
+        ]);
+        return keyMap.get(key);
+      }
+      // 开平
+      case 1: {
+        return tradeType ?? direction + tradeAction;
+      }
+    }
+  };
+  // 交易点: 买卖配置数据
+  const handleSellBuyConfig = (data, baseLineData, klineTimeAry, klineDataAry) => {
+    return data.reduce((result, next) => {
+      const tradeType = handleTradeType(next, 0);
+      // 找寻同一根K线上是否有其它点位类型
+      const timeTradeList = data.filter((item) => item.klineTime === next.klineTime);
+      const timeTradeTypes = [...new Set(timeTradeList.map((item) => handleTradeType(item, 0)))];
+      let symbol = null;
+      if (timeTradeTypes.length > 1) {
+        symbol = "image://" + new URL("./images/t.svg", import.meta.url).href;
+      } else {
+        symbol = "image://" + new URL(`./images/${tradeType === "买" ? "buy" : "sell"}.svg`, import.meta.url).href;
+      }
+      // 获取对应K线索引, 图标Y值永远为: 高, 连线起始Y值为: 低, 末端Y值为: 高
+      const klineIndex = binarySearch(klineTimeAry, next.klineTime);
+      const yAxisValue = klineDataAry[klineIndex]?.[3];
+      baseLineData.forEach((item) => {
+        const rangeIndex = tradeType === "买" ? 0 : 1;
+        if (item.range[rangeIndex] === next.klineTime) {
+          item.rangeValue[rangeIndex] = klineDataAry[klineIndex]?.[tradeType === "买" ? 2 : 3];
+        }
+      });
+      result.push({
+        symbol,
+        symbolSize: 25,
+        symbolRotate: 0,
+        symbolOffset: [0, 0],
+        label: {
+          show: false,
+          position: "top",
+        },
+        coord: [next.klineTime, yAxisValue],
+        silent: true,
+        animation: false,
+        customData: {
+          tradeType,
+          amount: next.amount, // 手数
+          part: next.part, // 份数
+          profitAndLoss: next.profitAndLoss, // 盈亏
+          openPriceAll: next.openPriceAll, // 开仓价
+          closePriceAll: next.closePriceAll, // 收仓价
+        },
+      });
+      return result;
+    }, []);
+  };
+  // 交易点: 开平配置数据
+  const handleOpenCloseConfig = (data, baseLineData, klineTimeAry, klineDataAry) => {
+    return data.reduce((result, next, index) => {
+      // 1.交易类型
+      const tradeType = handleTradeType(next, 1);
+      // 2.图标位置 [开在K线上方,平在K线下方]
+      const position = ["开多", "开空"].includes(tradeType) ? "top" : "bottom";
+      // 3.获取对应Y轴值
+      const klineIndex = binarySearch(klineTimeAry, next.klineTime);
+      const yAxisValue = position === "top" ? klineDataAry[klineIndex]?.[3] : klineDataAry[klineIndex]?.[2];
+      // 4.将Y轴值存到连线的数据中, 提供给连线配置使用
+      baseLineData.forEach((item) => {
+        const rangeTime = position === "top" ? item.range[0] : item.range[1];
+        if (rangeTime === next.klineTime) item.rangeValue[position === "top" ? 0 : 1] = yAxisValue;
+      });
+      result.push({
+        symbol: "triangle",
+        symbolSize: [10, 12],
+        symbolRotate: position === "top" ? 180 : 0,
+        symbolOffset: [0, 0],
+        label: {
+          show: true,
+          position,
+          color: "#fff",
+          formatter: `${tradeType} ${position === "top" ? "+" : "-"} ${next.amount}手 ${next.part ? `(${next.part}份)` : ""}`,
+        },
+        itemStyle: { color: position === "top" ? "#FF0000" : "#389e0d" },
+        coord: [next.klineTime, yAxisValue],
+        silent: true,
+        animation: false,
+        customData: {
+          tradeType,
+          amount: next.amount, // 手数
+          part: next.part, // 份数
+          profitAndLoss: next.profitAndLoss, // 盈亏
+          openPriceAll: next.openPriceAll, // 开仓价
+          closePriceAll: next.closePriceAll, // 收仓价
+        },
+      });
+      return result;
+    }, []);
+  };
+  // 交易点: 生成基础点位, 连线数据
+  const handleTradePointLineData = (tradeLog, cycle, klineTimeArray) => {
+    /**
+     * @description: 点位, 连线
+     * 1.生成点位, 连线基础数据
+     * 2.点位处理: 合并同一根K线上的数据, 整体按照时间排序
+     * 3.连线处理: 过滤相同范围的连线
+     */
+    const { basePointData, baseLineData } = tradeLog.reduce(
+      (result, item) => {
+        // 开仓点位的数据
+        const startPoint = {
+          pointTime: item.openTime, // 交易点位的真实时间
+          klineTime: normalizeToKlineTime(klineTimeArray, item.openTime, cycle), // 交易点位的K线时间
+
+          tradeAction: "开", // 交易行为
+          tradeDirection: item.tradeDirection ? "空" : "多", // 交易方向 1:空, 0:多
+          tradeType: `开${item.tradeDirection ? "空" : "多"}`,
+
+          part: null, // 份数,
+          amount: item.tradeVolume, // 手数
+          profitAndLoss: item.profitAndLoss, // 盈亏
+          openPriceAll: item.openPrice * item.tradeVolume, // 开仓价格
+          closePriceAll: item.closePrice * item.tradeVolume, // 平仓价格
+        };
+        // 平仓点位的数据
+        const endPoint = {
+          pointTime: item.closeTime, // 交易点位的真实时间
+          klineTime: normalizeToKlineTime(klineTimeArray, item.closeTime, cycle), // 交易点位的K线时间
+
+          tradeAction: "平", // 交易行为
+          tradeDirection: item.tradeDirection ? "空" : "多", // 交易方向 1:空, 0:多
+          tradeType: `平${item.tradeDirection ? "空" : "多"}`,
+
+          part: null, // 份数,
+          amount: item.tradeVolume, // 手数
+          profitAndLoss: item.profitAndLoss, // 盈亏
+          openPriceAll: item.openPrice * item.tradeVolume, // 开仓价格
+          closePriceAll: item.closePrice * item.tradeVolume, // 平仓价格
+        };
+        result.basePointData.push(startPoint, endPoint);
+        result.baseLineData.push({
+          range: [startPoint.klineTime, endPoint.klineTime],
+          rangeValue: [null, null],
+          color: endPoint.profitAndLoss > 0 ? "#FF0000" : "#389e0d",
+        });
+        return result;
+      },
+      {
+        basePointData: [], // 点位数据
+        baseLineData: [], // 连线数据
+      }
+    );
+    const basePointDataMergeMap = basePointData.reduce((result, item) => {
+      const newItem = JSON.parse(JSON.stringify(item));
+      const key = newItem.klineTime + newItem.tradeType;
+      // 判断这个节点是否已存在数据
+      if (result.has(key)) {
+        // 已存在,说明节点重复,进行数据合并
+        const oldItem = result.get(key);
+        newItem.amount += oldItem.amount;
+        newItem.part += oldItem.part;
+        newItem.profitAndLoss += oldItem.profitAndLoss;
+        newItem.openPriceAll += oldItem.openPriceAll;
+        newItem.closePriceAll += oldItem.closePriceAll;
+      }
+      result.set(key, newItem);
+      return result;
+    }, new Map([]));
+    const pointData = [...basePointDataMergeMap.values()].sort((a, b) => new Date(a.klineTime) - new Date(b.klineTime));
+    const lineData = baseLineData.filter(({ range }) => range[0] !== range[1]);
+    return { pointData, lineData };
+  };
+  const { pointData, lineData } = handleTradePointLineData(tradeLog, cycle, klineTimeArray);
+  const handler = sellBuy === 0 ? handleSellBuyConfig : handleOpenCloseConfig;
+  return {
+    tradePointData: handler(pointData, lineData, klineTimeArray, klineDataArray),
+    tradeLineData: lineData.map(({ range, rangeValue, color }) => {
+      return [
+        {
+          symbol: "none",
+          coord: [range[0], rangeValue[0]],
+          lineStyle: { color, width: 2, type: "solid" },
+          silent: true,
+          animation: false,
+        },
+        {
+          symbol: "none",
+          coord: [range[1], rangeValue[1]],
+          silent: true,
+          animation: false,
+        },
+      ];
+    }),
+  };
+};
+
+// 生成图表配置所需数据: 净值曲线
+export const handleNetPositionLine = (netPositionData, cycle) => {
+  let netPositionLineData = [];
+  // 分钟线: 时间格式化
+  if (Number(cycle) <= 5) {
+    netPositionLineData = netPositionData.map(({ tradeDate, netPositionValue }) => {
+      return [dayjs(tradeDate).format("YYYY-MM-DD HH:mm:ss"), netPositionValue];
+    });
+  }
+  // 日线: 取每天最后一条净值数据, 且时分秒转换成固定09:00:00
+  else if (Number(cycle) === 6) {
+    const netPositionMap = netPositionData.reduce((result, item) => {
+      const { tradeDate, netPositionValue } = item;
+      result.set(dayjs(tradeDate).format("YYYY-MM-DD 09:00:00"), netPositionValue);
+      return result;
+    }, new Map());
+    netPositionLineData = Array.from(netPositionMap, ([key, value]) => [key, value]);
+  }
+  // 其它: 不展示
+  else {
+    netPositionLineData = [];
+  }
+  return { netPositionLineData };
+};