kd-lane-chart-v3 0.1.19 → 0.1.20

package/dist/esm/index.js

@@ -1,7 +1,7 @@
 var __defProp = Object.defineProperty;
 var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
 var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
-import { ref, onMounted, onBeforeUnmount, resolveDirective, openBlock, createElementBlock, withDirectives, Fragment, renderList, normalizeClass, withModifiers, createElementVNode, toRaw, reactive, computed, inject, watch, resolveComponent, createVNode, withCtx, unref, createBlock, createTextVNode, toDisplayString, createCommentVNode, vShow, provide, mergeProps, normalizeStyle, isRef, isReadonly, getCurrentInstance, nextTick, renderSlot, markRaw, useAttrs, onActivated, onUnmounted, shallowRef, createSlots } from "vue";
+import { ref, onMounted, onBeforeUnmount, openBlock, createElementBlock, withDirectives, Fragment, renderList, normalizeClass, withModifiers, createElementVNode, toRaw, reactive, computed, inject, watch, resolveComponent, createVNode, withCtx, unref, createBlock, createTextVNode, toDisplayString, createCommentVNode, vShow, provide, resolveDirective, mergeProps, normalizeStyle, isRef, isReadonly, getCurrentInstance, nextTick, renderSlot, markRaw, useAttrs, shallowRef, onActivated, onUnmounted, createSlots } from "vue";
 import { cloneDeep, debounce } from "lodash-es";
 import { VueDraggable } from "vue-draggable-plus";
 import { Star, Search } from "@element-plus/icons-vue";
@@ -297,6 +297,19 @@ const _sfc_main$e = /* @__PURE__ */ Object.assign({
   },
   emits: ["menu-closed", "option-clicked"],
   setup(__props, { expose: __expose, emit: __emit }) {
+    const vClickOutside = {
+      mounted(el, binding) {
+        el.__kdClickOutside = (event) => {
+          if (el === event.target || el.contains(event.target)) return;
+          if (typeof binding.value === "function") binding.value(event);
+        };
+        document.addEventListener("pointerdown", el.__kdClickOutside, true);
+      },
+      unmounted(el) {
+        document.removeEventListener("pointerdown", el.__kdClickOutside, true);
+        delete el.__kdClickOutside;
+      }
+    };
     const props = __props;
     const emit = __emit;
     const refUl = ref(null);
@@ -376,7 +389,6 @@ const _sfc_main$e = /* @__PURE__ */ Object.assign({
       hideContextMenu
     });
     return (_ctx, _cache) => {
-      const _directive_click_outside = resolveDirective("click-outside");
       return openBlock(), createElementBlock("div", null, [
         withDirectives((openBlock(), createElementBlock("ul", {
           ref_key: "refUl",
@@ -395,13 +407,13 @@ const _sfc_main$e = /* @__PURE__ */ Object.assign({
             ], 10, _hoisted_1$d);
           }), 128))
         ])), [
-          [_directive_click_outside, onClickOutside]
+          [vClickOutside, onClickOutside]
         ])
       ]);
     };
   }
 });
-const VueSimpleContextMenu = /* @__PURE__ */ _export_sfc(_sfc_main$e, [["__scopeId", "data-v-1d3cb41b"]]);
+const VueSimpleContextMenu = /* @__PURE__ */ _export_sfc(_sfc_main$e, [["__scopeId", "data-v-b8d2d221"]]);
 class CustomStrategy {
   constructor(strategy) {
     this.strategy = strategy;
@@ -8678,7 +8690,7 @@ const _sfc_main$6 = /* @__PURE__ */ Object.assign({
     };
   }
 });
-const KdLaneContainerComponent = /* @__PURE__ */ _export_sfc(_sfc_main$6, [["__scopeId", "data-v-8592a21f"]]);
+const KdLaneContainerComponent = /* @__PURE__ */ _export_sfc(_sfc_main$6, [["__scopeId", "data-v-a170491c"]]);
 /*! Element Plus v2.14.3 */
 var en_default = {
   name: "en",
@@ -11805,7 +11817,7 @@ const _sfc_main$3 = /* @__PURE__ */ Object.assign({
     const lastArea = ref(0);
     const graphic = echarts.graphic;
     const _skipWatcher = ref(false);
-    const chart = ref(null);
+    const chart = shallowRef(null);
     const manualOptions = ref(void 0);
     let unwatchOptionsFn = null;
     let resizeHandlerFn = null;
@@ -12023,7 +12035,7 @@ const _sfc_main$3 = /* @__PURE__ */ Object.assign({
         );
         addListener(el, resizeHandlerFn);
       }
-      chart.value = nextChart;
+      chart.value = markRaw(nextChart);
       emit("chart-inited", nextChart);
     }
     function initOptionsWatcher() {
@@ -12170,7 +12182,7 @@ const _sfc_main$3 = /* @__PURE__ */ Object.assign({
         enumerable: true,
         get: () => chart.value,
         set: (val) => {
-          chart.value = val;
+          chart.value = val && typeof val === "object" ? markRaw(val) : val;
         }
       },
       width: {
@@ -12196,7 +12208,7 @@ const _sfc_main$3 = /* @__PURE__ */ Object.assign({
     };
   }
 });
-const resizeEcharts = /* @__PURE__ */ _export_sfc(_sfc_main$3, [["__scopeId", "data-v-c291a28b"]]);
+const resizeEcharts = /* @__PURE__ */ _export_sfc(_sfc_main$3, [["__scopeId", "data-v-985d070b"]]);
 const DRAW_POINT_MIN = 400;
 const DRAW_POINT_MAX = 1200;
 function getSeriesDrawThreshold(laneHeightPx) {
@@ -12300,6 +12312,34 @@ function averageBuckets(data, threshold) {
   }
   return out.length ? out : data;
 }
+function clampSeriesXToAxis(data, min, max, positiveOnly = false) {
+  if (!data || !data.length) return data || [];
+  const lo = Number(min);
+  const hi = Number(max);
+  if (!Number.isFinite(lo) || !Number.isFinite(hi) || !(hi > lo)) return data;
+  let changed = false;
+  const out = new Array(data.length);
+  for (let i = 0; i < data.length; i++) {
+    const pt = data[i];
+    const x = pointX(pt);
+    if (isMissingCurveValue(x)) {
+      out[i] = pt;
+      continue;
+    }
+    const n = Number(x);
+    if (!Number.isFinite(n) || positiveOnly && !(n > 0)) {
+      out[i] = pt;
+      continue;
+    }
+    if (n < lo || n > hi) {
+      changed = true;
+      out[i] = clonePointWithXY(pt, n < lo ? lo : hi, pointYRaw(pt));
+    } else {
+      out[i] = pt;
+    }
+  }
+  return changed ? out : data;
+}
 function downsampleSeriesForDraw(data, threshold, mode = "average") {
   if (!data || !data.length) return data || [];
   if (data.length <= threshold) return data;
@@ -12318,7 +12358,7 @@ function downsampleSeriesForDraw(data, threshold, mode = "average") {
   }
   if (cur.length) segments.push(cur);
   if (segments.length === 1 && segments[0].length === data.length) {
-    return sample(data, threshold);
+    return pinSegmentEnds(sample(data, threshold), data);
   }
   if (!segments.length) return data;
   const totalValid = segments.reduce((n, s) => n + s.length, 0);
@@ -12327,13 +12367,70 @@ function downsampleSeriesForDraw(data, threshold, mode = "average") {
     const seg = segments[s];
     const share = Math.max(2, Math.round(seg.length / totalValid * threshold));
     const sampled = seg.length <= share ? seg : sample(seg, Math.min(share, seg.length));
+    const pinned = pinSegmentEnds(sampled, seg);
     if (out.length) {
-      out.push([null, pointYRaw(sampled[0])]);
+      out.push([null, pointYRaw(pinned[0])]);
     }
-    for (let i = 0; i < sampled.length; i++) out.push(sampled[i]);
+    for (let i = 0; i < pinned.length; i++) out.push(pinned[i]);
   }
   return out;
 }
+function pinSegmentEnds(sampled, seg) {
+  if (!seg || seg.length < 2) return sampled && sampled.length ? sampled : seg || [];
+  const first = seg[0];
+  const last = seg[seg.length - 1];
+  if (!sampled || !sampled.length) return [first, last];
+  const out = sampled.slice();
+  out[0] = first;
+  if (out.length === 1) out.push(last);
+  else out[out.length - 1] = last;
+  return out;
+}
+function finiteDrawPoint(pt) {
+  if (!Array.isArray(pt) || isMissingCurveValue(pt[0])) return null;
+  const x = Number(pt[0]);
+  const y = Number(pt[1]);
+  if (!Number.isFinite(x) || !Number.isFinite(y)) return null;
+  return { x, y, pt };
+}
+function bridgeCurveEnds(actual, recommend, maxGap = 80) {
+  if (!actual || !recommend || !actual.length || !recommend.length) {
+    return { actual, recommend };
+  }
+  let lastA = null;
+  let lastAIndex = -1;
+  for (let i = actual.length - 1; i >= 0; i--) {
+    const p = finiteDrawPoint(actual[i]);
+    if (p) {
+      lastA = p;
+      lastAIndex = i;
+      break;
+    }
+  }
+  let firstR = null;
+  let firstRIndex = -1;
+  for (let i = 0; i < recommend.length; i++) {
+    const p = finiteDrawPoint(recommend[i]);
+    if (p) {
+      firstR = p;
+      firstRIndex = i;
+      break;
+    }
+  }
+  if (!lastA || !firstR) return { actual, recommend };
+  const gap = firstR.y - lastA.y;
+  const abs = Math.abs(gap);
+  if (!(abs > 0.05) || abs > maxGap) return { actual, recommend };
+  const nextActual = actual.slice();
+  const nextRecommend = recommend.slice();
+  const extA = lastA.pt.slice();
+  extA[1] = firstR.y;
+  nextActual.splice(lastAIndex + 1, 0, extA);
+  const extR = firstR.pt.slice();
+  extR[1] = lastA.y;
+  nextRecommend.splice(firstRIndex, 0, extR);
+  return { actual: nextActual, recommend: nextRecommend };
+}
 function findNearestRow(rows, key, axisValue) {
   if (!rows || !rows.length) return null;
   const target = Number(axisValue);
@@ -15404,8 +15501,30 @@ const _sfc_main$2 = /* @__PURE__ */ Object.assign({
       const plotted = proxy.plotSeries(data, isLogScale);
       return downsampleSeriesForDraw(plotted, proxy.getSeriesDrawThreshold());
     }
-    function toDrawSeriesData(lane, rawPoints) {
-      return proxy.plotSeriesForDraw(rawPoints, isLaneLogScale(lane));
+    function toDrawSeriesData(lane, rawPoints, lineInfo) {
+      const isLog = isLaneLogScale(lane);
+      const range = proxy.curveDrawClampRange(lane, lineInfo, isLog);
+      const bounded = clampSeriesXToAxis(rawPoints, range.min, range.max, isLog);
+      return proxy.plotSeriesForDraw(bounded, isLog);
+    }
+    function curveDrawClampRange(lane, lineInfo, isLog) {
+      if (isLog) {
+        const plot = resolveLaneLogPlotRange(lane, proxy.getLineRangeStore());
+        return { min: plot.min, max: plot.max };
+      }
+      return {
+        min: lineInfo ? Number(lineInfo.min) : NaN,
+        max: lineInfo ? Number(lineInfo.max) : NaN
+      };
+    }
+    function findLineInfoByParam(lane, paramId) {
+      const lines = lane && lane.lines || [];
+      for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        if (!line) continue;
+        if (line.paramId == paramId || line.recommendParamId == paramId) return line;
+      }
+      return null;
     }
     function getAxisDataKey() {
       return proxy.currentToolBarConfig.axisTypeList && proxy.currentToolBarConfig.axisTypeList[proxy.formCache.axisType] || (proxy.formCache.axisType === "time" ? "time" : "depth");
@@ -15458,6 +15577,157 @@ const _sfc_main$2 = /* @__PURE__ */ Object.assign({
       }
       return groups;
     }
+    function bridgePatchedCurveEnds(series) {
+      const slots = /* @__PURE__ */ new Map();
+      for (let i = 0; i < series.length; i++) {
+        const item = series[i];
+        const meta = item && item.__bridge;
+        if (!meta) continue;
+        const key = `${meta.gi}:${meta.lineId}`;
+        const slot = slots.get(key) || {};
+        if (meta.isRecommend) slot.recommend = item;
+        else slot.actual = item;
+        slots.set(key, slot);
+      }
+      for (const slot of slots.values()) {
+        if (!slot.actual || !slot.recommend) continue;
+        if (!Array.isArray(slot.actual.data) || !Array.isArray(slot.recommend.data)) continue;
+        const joined = bridgeCurveEnds(slot.actual.data, slot.recommend.data);
+        slot.actual.data = joined.actual;
+        slot.recommend.data = joined.recommend;
+      }
+      for (let i = 0; i < series.length; i++) {
+        if (series[i] && series[i].__bridge) delete series[i].__bridge;
+      }
+    }
+    function latestPointColor(ctx, lineInfo) {
+      const gradient = ctx.linearGradientLineColor && ctx.linearGradientLineColor[ctx.nowTheme] && ctx.linearGradientLineColor[ctx.nowTheme][lineInfo.paramId];
+      if (lineInfo.isGradient && gradient) return gradient;
+      const theme = lineInfo.themeConfig && lineInfo.themeConfig[ctx.nowTheme];
+      if (theme && theme.lineColor) return theme.lineColor;
+      return lineInfo.lineColor;
+    }
+    function resolveLatestPoint(ctx, lineInfo, axisMin, axisMax, axisKey) {
+      if (!lineInfo || !lineInfo.latestDataTips || !lineInfo.paramId) return null;
+      const book = ctx.latestLineDataByParamCode || {};
+      const point = book[lineInfo.paramId];
+      if (!point) return null;
+      const y = Number(point[axisKey]);
+      const lo = Number(axisMin);
+      const hi = Number(axisMax);
+      if (!Number.isFinite(y) || !Number.isFinite(lo) || !Number.isFinite(hi)) return null;
+      if (y < lo || y > hi) return null;
+      return point;
+    }
+    function clampLatestTipX(ctx, raw, lane, lineInfo, isLog) {
+      const x = ctx.plotX(raw, isLog);
+      if (x == null || !Number.isFinite(Number(x))) return null;
+      let n = Number(x);
+      const range = ctx.curveDrawClampRange(lane, lineInfo, isLog);
+      const lo = Number(range && range.min);
+      const hi = Number(range && range.max);
+      if (Number.isFinite(lo) && Number.isFinite(hi) && hi > lo) {
+        if (n < lo) n = lo;
+        if (n > hi) n = hi;
+      }
+      return n;
+    }
+    function buildLatestPointSeries(ctx, lineInfo, lane, point, axisKey, isLog, xAxisIndex, yAxisIndex) {
+      const x = clampLatestTipX(ctx, point[lineInfo.paramId], lane, lineInfo, isLog);
+      if (x == null) return null;
+      return {
+        type: "effectScatter",
+        name: lineInfo.paramId + "-最新点",
+        tipParamId: lineInfo.paramId,
+        xAxisIndex,
+        yAxisIndex,
+        data: [[x, point[axisKey]]],
+        symbol: "circle",
+        symbolSize: getAdaptedFontSize(12),
+        itemStyle: {
+          color: latestPointColor(ctx, lineInfo),
+          opacity: 1
+        },
+        tooltip: { show: false },
+        showEffectOn: "render",
+        rippleEffect: {
+          brushType: "stroke",
+          scale: 3,
+          period: 2
+        },
+        z: (Number(lineInfo.lineSort) || 0) + 1,
+        // 贴在道边缘的点（值为 0，或实测超出道宽）不能被裁掉
+        clip: false,
+        silent: true
+      };
+    }
+    function seriesAxisByParam(ctx, seriesList, paramId) {
+      for (let i = 0; i < seriesList.length; i++) {
+        const opt = seriesList[i] && seriesList[i].option || {};
+        const pid = ctx.unwrapEchartsValue(opt.paramId);
+        if (pid == null || pid === "" || String(pid) !== String(paramId)) continue;
+        let x = opt.xAxisIndex;
+        if (Array.isArray(x)) x = x[0];
+        const xn = Number(x);
+        return {
+          xAxisIndex: Number.isFinite(xn) ? xn : 0,
+          yAxisIndex: ctx.seriesYAxisIndex(opt)
+        };
+      }
+      return null;
+    }
+    function appendMissingWindowGraphics(ctx, lane, groups, seriesList, series, axisKey, paramCodeMap, isLog, seenRange, seenTip) {
+      const lines = lane && lane.lines || [];
+      for (let i = 0; i < lines.length; i++) {
+        const lineInfo = lines[i];
+        if (!lineInfo || lineInfo.paramId == null || lineInfo.paramId === "") continue;
+        const key = String(lineInfo.paramId);
+        const axes = seriesAxisByParam(ctx, seriesList, lineInfo.paramId);
+        if (!axes) continue;
+        const gi = ctx.clampGridIndex(groups.length, axes.yAxisIndex);
+        const group2 = groups[gi];
+        const rows = group2 && group2.rows;
+        if (!rows || !rows.length) continue;
+        if (!seenRange.has(key) && (lineInfo.upperParamId || lineInfo.lowerParamId)) {
+          const built = ctx.addRangeAreaToSeries(
+            {
+              z: Number(lineInfo.lineSort) || 0,
+              xAxisIndex: axes.xAxisIndex,
+              yAxisIndex: axes.yAxisIndex
+            },
+            lineInfo,
+            rows,
+            axisKey,
+            paramCodeMap,
+            lineInfo.min,
+            lineInfo.max,
+            isLog
+          );
+          if (built && built.data && built.data.length) {
+            series.push(built);
+            seenRange.add(key);
+          }
+        }
+        if (!seenTip.has(key)) {
+          const point = resolveLatestPoint(ctx, lineInfo, group2.min, group2.max, axisKey);
+          if (!point) continue;
+          const tip = buildLatestPointSeries(
+            ctx,
+            lineInfo,
+            lane,
+            point,
+            axisKey,
+            isLog,
+            axes.xAxisIndex,
+            axes.yAxisIndex
+          );
+          if (tip) {
+            series.push(tip);
+            seenTip.add(key);
+          }
+        }
+      }
+    }
     function patchVisibleSeries() {
       const rows = proxy.getVisibleData();
       if (!rows.length) return;
@@ -15496,7 +15766,15 @@ const _sfc_main$2 = /* @__PURE__ */ Object.assign({
           return;
         }
         const isLog = isLaneLogScale(lane);
-        const yAxis = groups.map((g) => ({ min: g.min, max: g.max }));
+        const yAxis = groups.map((g) => {
+          const axis = { min: g.min, max: g.max };
+          if (proxy.formCache.axisType === "depth") {
+            applyDepthYAxisInterval(axis, g.min, g.max);
+          }
+          return axis;
+        });
+        const seenRange = /* @__PURE__ */ new Set();
+        const seenTip = /* @__PURE__ */ new Set();
         const series = seriesList.map((sm) => {
           const opt = sm && sm.option || {};
           const gi = proxy.clampGridIndex(groups.length, proxy.seriesYAxisIndex(opt));
@@ -15512,33 +15790,110 @@ const _sfc_main$2 = /* @__PURE__ */ Object.assign({
             };
           }
           const type = sm.subType || proxy.unwrapEchartsValue(opt.type);
+          if (type === "custom" && typeof name === "string" && name.endsWith("-范围区域")) {
+            const paramId2 = name.slice(0, -"-范围区域".length);
+            seenRange.add(String(paramId2));
+            const lineInfo2 = proxy.findLineInfoByParam(lane, paramId2);
+            const rows2 = group2 && group2.rows;
+            if (!lineInfo2 || !rows2 || !rows2.length) return { data: [] };
+            const built = proxy.addRangeAreaToSeries(
+              { z: Number(lineInfo2.lineSort) || 0 },
+              lineInfo2,
+              rows2,
+              axisKey,
+              paramCodeMap,
+              lineInfo2.min,
+              lineInfo2.max,
+              isLog
+            );
+            return {
+              data: built && built.data || [],
+              encode: { x: 1, y: 0 }
+            };
+          }
+          if (type === "effectScatter") {
+            let tipParam = proxy.unwrapEchartsValue(opt.tipParamId);
+            if ((tipParam == null || tipParam === "") && typeof name === "string" && name.endsWith("-最新点")) {
+              tipParam = name.slice(0, -"-最新点".length);
+            }
+            if (tipParam == null || tipParam === "") return { data: [] };
+            seenTip.add(String(tipParam));
+            const lineInfo2 = proxy.findLineInfoByParam(lane, tipParam);
+            const point = lineInfo2 ? resolveLatestPoint(proxy, lineInfo2, group2.min, group2.max, axisKey) : null;
+            if (!point) return { data: [] };
+            const x = clampLatestTipX(proxy, point[lineInfo2.paramId], lane, lineInfo2, isLog);
+            if (x == null) return { data: [] };
+            return { data: [[x, point[axisKey]]] };
+          }
           if (name === "log-grid" || name === "trend" || type !== "line") return {};
-          const paramId = proxy.unwrapEchartsValue(opt.paramId);
-          if (paramId == null) return {};
-          const cacheKey = `${gi}:${paramId}:${isLog ? 1 : 0}`;
+          let paramId = proxy.unwrapEchartsValue(opt.drawParamId);
+          if (paramId == null || paramId === "") {
+            paramId = proxy.unwrapEchartsValue(opt.paramId);
+          }
+          if (paramId == null || paramId === "") {
+            const fromLane = proxy.unwrapEchartsValue(opt.laneId);
+            if (fromLane != null && proxy.findLineInfoByParam(lane, fromLane)) {
+              paramId = fromLane;
+            }
+          }
+          if (paramId == null || paramId === "") return {};
+          const lineInfo = proxy.findLineInfoByParam(lane, paramId);
+          if (!lineInfo) return {};
+          const isRecommend = lineInfo.recommendParamId == paramId && lineInfo.paramId != paramId;
+          if (isRecommend) {
+            if (!(lineInfo.recommendIsUsed === "1" || lineInfo.recommendIsUsed == 1)) {
+              return { data: [] };
+            }
+          } else if (lineInfo.isUsed !== "1") {
+            return { data: [] };
+          }
+          const cacheKey = `${gi}:${paramId}:${isLog ? 1 : 0}:${lane.laneId}`;
           let data = groupSeriesCache.get(cacheKey);
           if (!data) {
-            const raw = proxy.generateSeriesDataCached(
+            let raw = proxy.generateSeriesDataCached(
               group2.rows,
               { paramId },
               axisKey,
               paramCodeMap
             );
+            const range = proxy.curveDrawClampRange(lane, lineInfo, isLog);
+            raw = clampSeriesXToAxis(raw, range.min, range.max, isLog);
             data = downsampleSeriesForDraw(
               proxy.plotSeries(raw, isLog),
               threshold
             );
             groupSeriesCache.set(cacheKey, data);
           }
-          return { data };
+          return {
+            data,
+            __bridge: {
+              gi,
+              lineId: lineInfo.lineId,
+              isRecommend
+            }
+          };
         });
-        const patch = { yAxis, series };
-        if (groups.length > 1) {
-          patch.grid = groups.map((g) => ({
+        appendMissingWindowGraphics(
+          proxy,
+          lane,
+          groups,
+          seriesList,
+          series,
+          axisKey,
+          paramCodeMap,
+          isLog,
+          seenRange,
+          seenTip
+        );
+        bridgePatchedCurveEnds(series);
+        const patch = {
+          yAxis,
+          series,
+          grid: groups.map((g) => ({
             top: g.top,
             height: g.height
-          }));
-        }
+          }))
+        };
         try {
           chart.setOption(patch, { lazyUpdate: true, silent: true });
         } catch (e) {
@@ -16473,7 +16828,7 @@ const _sfc_main$2 = /* @__PURE__ */ Object.assign({
                 let tipAnchorMin = 0;
                 let tipAnchorMax = 1;
                 lane.lines.forEach((lineInfo, index2) => {
-                  var _a, _b, _c, _d;
+                  var _a, _b;
                   if (!seriesDataCache2[lineInfo.lineId]) {
                     seriesDataCache2[lineInfo.lineId] = {
                       full: proxy.generateSeriesDataCached(
@@ -16484,7 +16839,8 @@ const _sfc_main$2 = /* @__PURE__ */ Object.assign({
                       )
                     };
                   }
-                  const groupSeriesData = plotGroups.length === 1 ? seriesDataCache2[lineInfo.lineId].full : proxy.generateSeriesDataCached(
+                  const cachedFull = seriesDataCache2[lineInfo.lineId].full;
+                  const groupSeriesData = plotGroups.length === 1 && group2.length === realTimeData2.length ? cachedFull : proxy.generateSeriesDataCached(
                     group2,
                     lineInfo,
                     axisKey,
@@ -16531,7 +16887,7 @@ const _sfc_main$2 = /* @__PURE__ */ Object.assign({
                       axisTick: { show: false }
                     }
                   );
-                  const seriesSource = lineInfo.isUsed === "1" ? proxy.toDrawSeriesData(lane, groupSeriesData) : [];
+                  const seriesSource = lineInfo.isUsed === "1" ? proxy.toDrawSeriesData(lane, groupSeriesData, lineInfo) : [];
                   const baseSeries = {
                     laneId: lineInfo.paramId,
                     paramId: lineInfo.paramId,
@@ -16546,7 +16902,9 @@ const _sfc_main$2 = /* @__PURE__ */ Object.assign({
                     symbolSize: getAdaptedFontSize(lineInfo.symbolSize || 6),
                     lineStyle: {
                       width: getAdaptedFontSize(+lineInfo.lineSize || 1.5),
-                      type: lineInfo.lineType
+                      type: lineInfo.lineType,
+                      cap: "round",
+                      join: "round"
                     },
                     clip: true,
                     connectNulls: false,
@@ -16582,14 +16940,35 @@ const _sfc_main$2 = /* @__PURE__ */ Object.assign({
                   const rangeAreaSeries = proxy.addRangeAreaToSeries(
                     baseSeries,
                     lineInfo,
-                    realTimeData2,
+                    group2,
                     axisKey,
                     paramCodeMap,
                     min,
                     max,
                     isLogScale
                   );
-                  proxy.pushGeoLineSeries(option, baseSeries, seriesSource);
+                  let recommendDraw = null;
+                  if (lineInfo.recommendParamId) {
+                    const recommendLineInfo = {
+                      ...lineInfo,
+                      paramId: lineInfo.recommendParamId
+                    };
+                    const recommendGroupSeriesData = proxy.generateSeriesDataCached(
+                      group2,
+                      recommendLineInfo,
+                      axisKey,
+                      paramCodeMap
+                    );
+                    recommendDraw = lineInfo.recommendIsUsed === "1" || lineInfo.recommendIsUsed == 1 ? proxy.toDrawSeriesData(
+                      lane,
+                      recommendGroupSeriesData,
+                      lineInfo
+                    ) : [];
+                    const joined = bridgeCurveEnds(baseSeries.data, recommendDraw);
+                    baseSeries.data = joined.actual;
+                    recommendDraw = joined.recommend;
+                  }
+                  proxy.pushGeoLineSeries(option, baseSeries, baseSeries.data);
                   if (rangeAreaSeries) {
                     option.series.push(rangeAreaSeries);
                   }
@@ -16621,20 +17000,11 @@ const _sfc_main$2 = /* @__PURE__ */ Object.assign({
                     }
                   }
                   if (lineInfo.recommendParamId) {
-                    const recommendLineInfo = {
-                      ...lineInfo,
-                      paramId: lineInfo.recommendParamId,
-                      lineType: "dashed"
-                    };
-                    const recommendGroupSeriesData = proxy.generateSeriesDataCached(
-                      group2,
-                      recommendLineInfo,
-                      axisKey,
-                      paramCodeMap
-                    );
-                    const recommendSource = lineInfo.recommendIsUsed === "1" || lineInfo.recommendIsUsed == 1 ? proxy.toDrawSeriesData(lane, recommendGroupSeriesData) : [];
+                    const recommendSource = recommendDraw || [];
                     const recommendSeries = {
                       laneId: lineInfo.recommendParamId,
+                      // 不写 paramId，避免点选被当成实测曲线。滚轮缩放靠它重画推荐值。
+                      drawParamId: lineInfo.recommendParamId,
                       data: recommendSource,
                       type: "line",
                       xAxisIndex,
@@ -16644,7 +17014,9 @@ const _sfc_main$2 = /* @__PURE__ */ Object.assign({
                       color: lineInfo.themeConfig ? lineInfo.themeConfig[proxy.nowTheme].lineColor : lineInfo.lineColor,
                       lineStyle: {
                         width: getAdaptedFontSize(+lineInfo.lineSize || 1.5),
-                        type: "dashed"
+                        type: "dashed",
+                        cap: "round",
+                        join: "round"
                       },
                       clip: true,
                       connectNulls: false,
@@ -16652,49 +17024,25 @@ const _sfc_main$2 = /* @__PURE__ */ Object.assign({
                     };
                     proxy.pushGeoLineSeries(option, recommendSeries, recommendSource);
                   }
-                  const effectScatterPoint = proxy.latestLineDataByParamCode[lineInfo.paramId];
-                  if (effectScatterPoint && lineInfo.latestDataTips) {
-                    let findIndex = -1;
-                    if (axisKey === "depth") {
-                      findIndex = group2.findIndex(
-                        (item) => item.timestamp === effectScatterPoint.timestamp && item[axisKey] === effectScatterPoint[axisKey]
-                      );
-                    } else {
-                      findIndex = group2.findIndex(
-                        (item) => item[axisKey] === effectScatterPoint[axisKey]
-                      );
-                    }
-                    const pointAxisValue = effectScatterPoint[axisKey];
-                    if (pointAxisValue >= groupMin && pointAxisValue <= groupMax && findIndex !== -1) {
-                      option.series.push({
-                        type: "effectScatter",
-                        xAxisIndex,
-                        yAxisIndex: gridIndex,
-                        data: [
-                          [
-                            proxy.plotX(
-                              effectScatterPoint[lineInfo.paramId],
-                              isLogScale
-                            ),
-                            effectScatterPoint[axisKey]
-                          ]
-                        ],
-                        symbol: "circle",
-                        symbolSize: getAdaptedFontSize(12),
-                        itemStyle: {
-                          color: lineInfo.themeConfig ? lineInfo.isGradient && ((_d = (_c = proxy.linearGradientLineColor) == null ? void 0 : _c[proxy.nowTheme]) == null ? void 0 : _d[lineInfo.paramId]) ? proxy.linearGradientLineColor[proxy.nowTheme][lineInfo.paramId] : lineInfo.themeConfig[proxy.nowTheme].lineColor : lineInfo.lineColor,
-                          opacity: 1
-                        },
-                        tooltip: { show: false },
-                        showEffectOn: "render",
-                        rippleEffect: {
-                          brushType: "stroke",
-                          scale: 3,
-                          period: 2
-                        },
-                        z: lineInfo.lineSort + 1
-                      });
-                    }
+                  const latestPoint = resolveLatestPoint(
+                    proxy,
+                    lineInfo,
+                    groupMin,
+                    groupMax,
+                    axisKey
+                  );
+                  if (latestPoint) {
+                    const tipSeries = buildLatestPointSeries(
+                      proxy,
+                      lineInfo,
+                      lane,
+                      latestPoint,
+                      axisKey,
+                      isLogScale,
+                      xAxisIndex,
+                      gridIndex
+                    );
+                    if (tipSeries) option.series.push(tipSeries);
                   }
                 });
                 if (!isDepthLane && !isTimeLane && lane.lines.length > 0) {
@@ -18321,13 +18669,18 @@ const _sfc_main$2 = /* @__PURE__ */ Object.assign({
           continue;
         if (!Number.isFinite(upperPoint1[1]) || !Number.isFinite(upperPoint2[1]) || !Number.isFinite(lowerPoint1[1]) || !Number.isFinite(lowerPoint2[1]))
           continue;
+        const upperA = proxy.clampRangeBandX(upperPoint1[0], min, max, isLogScale);
+        const lowerA = proxy.clampRangeBandX(lowerPoint1[0], min, max, isLogScale);
+        const upperB = proxy.clampRangeBandX(upperPoint2[0], min, max, isLogScale);
+        const lowerB = proxy.clampRangeBandX(lowerPoint2[0], min, max, isLogScale);
+        if (upperA == null || lowerA == null || upperB == null || lowerB == null) continue;
         customData.push([
-          proxy.plotX(upperPoint1[0], isLogScale),
-          proxy.plotX(lowerPoint1[0], isLogScale),
           upperPoint1[1],
-          proxy.plotX(upperPoint2[0], isLogScale),
-          proxy.plotX(lowerPoint2[0], isLogScale),
-          upperPoint2[1]
+          upperA,
+          lowerA,
+          upperPoint2[1],
+          upperB,
+          lowerB
         ]);
       }
       if (customData.length === 0) return null;
@@ -18342,13 +18695,16 @@ const _sfc_main$2 = /* @__PURE__ */ Object.assign({
         yAxisIndex: baseSeries.yAxisIndex,
         clip: true,
         z: baseSeries.z - 1,
+        encode: { x: 1, y: 0 },
+        progressive: 0,
+        animation: false,
         renderItem: (params2, api) => {
-          const upperX1 = api.value(0);
-          const lowerX1 = api.value(1);
-          const depth1 = api.value(2);
-          const upperX2 = api.value(3);
-          const lowerX2 = api.value(4);
-          const depth2 = api.value(5);
+          const depth1 = api.value(0);
+          const upperX1 = api.value(1);
+          const lowerX1 = api.value(2);
+          const depth2 = api.value(3);
+          const upperX2 = api.value(4);
+          const lowerX2 = api.value(5);
           const topLeft = api.coord([upperX1, depth1]);
           const topRight = api.coord([upperX2, depth2]);
           const bottomRight = api.coord([lowerX2, depth2]);
@@ -18558,7 +18914,7 @@ const _sfc_main$2 = /* @__PURE__ */ Object.assign({
                     lineInfo,
                     axisKey
                   );
-                  const finalSeriesData = lineInfo.isUsed === "1" ? proxy.toDrawSeriesData(lane, seriesData) : [];
+                  const finalSeriesData = lineInfo.isUsed === "1" ? proxy.toDrawSeriesData(lane, seriesData, lineInfo) : [];
                   needUpdate.series = true;
                   newSeriesData.push({
                     index: seriesIndex,
@@ -18965,7 +19321,7 @@ const _sfc_main$2 = /* @__PURE__ */ Object.assign({
     proxy.scheduleConnectAllCharts = debounce(() => {
       proxy.connectAllCharts();
     }, 50);
-    trendLineManager.value = new TrendLineManager(proxy);
+    trendLineManager.value = markRaw(new TrendLineManager(proxy));
     proxy.paramRangeOverrides = /* @__PURE__ */ Object.create(null);
     onMounted(() => {
       proxy.showDateTime = Object.prototype.hasOwnProperty.call(
@@ -19237,6 +19593,8 @@ const _sfc_main$2 = /* @__PURE__ */ Object.assign({
       getSeriesDrawThreshold: getSeriesDrawThreshold$1,
       plotSeriesForDraw,
       toDrawSeriesData,
+      curveDrawClampRange,
+      findLineInfoByParam,
       getAxisDataKey,
       findRowByAxisValue,
       formatAxisPointerYLabel,
@@ -19766,6 +20124,8 @@ const _sfc_main$2 = /* @__PURE__ */ Object.assign({
       getSeriesDrawThreshold: getSeriesDrawThreshold$1,
       plotSeriesForDraw,
       toDrawSeriesData,
+      curveDrawClampRange,
+      findLineInfoByParam,
       getAxisDataKey,
       findRowByAxisValue,
       formatAxisPointerYLabel,
@@ -20090,7 +20450,7 @@ const _sfc_main$2 = /* @__PURE__ */ Object.assign({
     };
   }
 });
-const LineChartContainer = /* @__PURE__ */ _export_sfc(_sfc_main$2, [["__scopeId", "data-v-996922ca"]]);
+const LineChartContainer = /* @__PURE__ */ _export_sfc(_sfc_main$2, [["__scopeId", "data-v-010ab113"]]);
 const _hoisted_1$1 = ["title"];
 const _hoisted_2$1 = ["title"];
 const _sfc_main$1 = /* @__PURE__ */ Object.assign({
@@ -21825,7 +22185,7 @@ const _sfc_main = /* @__PURE__ */ Object.assign({ name: "frameLayout", component
     };
   }
 });
-const FrameLayoutComponent = /* @__PURE__ */ _export_sfc(_sfc_main, [["__scopeId", "data-v-2cf67725"]]);
+const FrameLayoutComponent = /* @__PURE__ */ _export_sfc(_sfc_main, [["__scopeId", "data-v-a17d7f29"]]);
 function installComponents(app) {
   installKdI18n(app);
   app.component(KdLaneContainerComponent.name, KdLaneContainerComponent);