velo-plot 1.12.0 → 1.19.0

package/dist/plugins/pattern-recognition.js

@@ -0,0 +1,690 @@
+function C(s) {
+  const e = [], n = [];
+  for (let t = 1; t < s.length - 1; t++) {
+    const o = s[t - 1], i = s[t], g = s[t + 1];
+    i.y > o.y && i.y > g.y ? e.push({ ...i, type: "peak" }) : i.y < o.y && i.y < g.y && n.push({ ...i, type: "valley" });
+  }
+  return { peaks: e, valleys: n };
+}
+function I(s, e) {
+  return (e.y - s.y) / (e.x - s.x);
+}
+function T(s) {
+  const e = s.map((g) => g.y), n = s.map((g) => g.x), t = Math.max(...e) - Math.min(...e), o = Math.max(...n) - Math.min(...n), i = I(s[0], s[s.length - 1]);
+  return {
+    height: t,
+    width: o,
+    slope: i,
+    volumeProfile: {
+      increasing: 0.4,
+      // Mock values
+      decreasing: 0.3,
+      neutral: 0.3
+    },
+    breakoutTarget: Math.max(...e) + t * 0.8,
+    stopLoss: Math.min(...e) - t * 0.2
+  };
+}
+function D(s) {
+  if (s.length < 5)
+    return { valid: !1, confidence: 0, segments: [], keyPoints: [], errors: ["Insufficient points for head-shoulders pattern"] };
+  const { peaks: e, valleys: n } = C(s);
+  if (e.length < 3 || n.length < 2)
+    return { valid: !1, confidence: 0, segments: [], keyPoints: [], errors: ["Insufficient peaks/valleys"] };
+  const t = e[0], o = e[1], i = e[2], g = n[0], u = n[1], p = o.y > t.y && o.y > i.y, y = Math.abs(t.y - i.y) / t.y < 0.1, k = g.y < t.y && u.y < i.y;
+  if (!p || !y || !k)
+    return {
+      valid: !1,
+      confidence: 0,
+      segments: [],
+      keyPoints: [],
+      errors: ["Invalid head-shoulders structure"]
+    };
+  const x = [
+    { start: t, end: g, type: "resistance", strength: 0.8 },
+    { start: g, end: o, type: "support", strength: 0.7 },
+    { start: o, end: u, type: "resistance", strength: 0.8 },
+    { start: u, end: i, type: "support", strength: 0.7 }
+  ], b = [t, g, o, u, i], M = T(s), a = 1 - Math.abs(t.y - i.y) / o.y, l = 1 - Math.abs(g.y - u.y) / o.y;
+  return {
+    valid: !0,
+    confidence: (a + l) / 2,
+    segments: x,
+    keyPoints: b,
+    measurements: M
+  };
+}
+function q(s) {
+  if (s.length < 4)
+    return { valid: !1, confidence: 0, segments: [], keyPoints: [], errors: ["Insufficient points for double top"] };
+  const { peaks: e, valleys: n } = C(s);
+  if (e.length < 2 || n.length < 1)
+    return { valid: !1, confidence: 0, segments: [], keyPoints: [], errors: ["Insufficient peaks/valleys"] };
+  const t = e[0], o = e[1], i = n[0], g = Math.abs(t.y - o.y) / t.y < 0.05, u = i.y < t.y && i.y < o.y, p = (t.y - i.y) / t.y > 0.1;
+  if (!g || !u || !p)
+    return { valid: !1, confidence: 0, segments: [], keyPoints: [], errors: ["Invalid double top structure"] };
+  const y = [
+    { start: t, end: i, type: "resistance", strength: 0.9 },
+    { start: i, end: o, type: "support", strength: 0.8 },
+    { start: t, end: o, type: "resistance", strength: 0.9 }
+  ], k = [t, i, o], x = T(s), b = 1 - Math.abs(t.y - o.y) / t.y, M = (t.y - i.y) / t.y;
+  return {
+    valid: !0,
+    confidence: (b + Math.min(M * 2, 1)) / 2,
+    segments: y,
+    keyPoints: k,
+    measurements: x
+  };
+}
+function E(s) {
+  if (s.length < 4)
+    return { valid: !1, confidence: 0, segments: [], keyPoints: [], errors: ["Insufficient points for double bottom"] };
+  const { peaks: e, valleys: n } = C(s);
+  if (n.length < 2 || e.length < 1)
+    return { valid: !1, confidence: 0, segments: [], keyPoints: [], errors: ["Insufficient peaks/valleys"] };
+  const t = n[0], o = n[1], i = e[0], g = Math.abs(t.y - o.y) / t.y < 0.05, u = i.y > t.y && i.y > o.y, p = (i.y - t.y) / t.y > 0.1;
+  if (!g || !u || !p)
+    return { valid: !1, confidence: 0, segments: [], keyPoints: [], errors: ["Invalid double bottom structure"] };
+  const y = [
+    { start: t, end: i, type: "support", strength: 0.9 },
+    { start: i, end: o, type: "resistance", strength: 0.8 },
+    { start: t, end: o, type: "support", strength: 0.9 }
+  ], k = [t, i, o], x = T(s), b = 1 - Math.abs(t.y - o.y) / t.y, M = (i.y - t.y) / t.y;
+  return {
+    valid: !0,
+    confidence: (b + Math.min(M * 2, 1)) / 2,
+    segments: y,
+    keyPoints: k,
+    measurements: x
+  };
+}
+function _(s) {
+  if (s.length < 4)
+    return { valid: !1, confidence: 0, segments: [], keyPoints: [], errors: ["Insufficient points for ascending triangle"] };
+  const e = s.map((a) => a.y), n = Math.max(...e), t = s.filter((a) => Math.abs(a.y - n) / n < 0.02);
+  if (t.length < 2)
+    return { valid: !1, confidence: 0, segments: [], keyPoints: [], errors: ["Insufficient resistance points"] };
+  const o = s.filter((a, l) => l === 0 || a.y < s[l - 1].y);
+  if (o.length < 2)
+    return { valid: !1, confidence: 0, segments: [], keyPoints: [], errors: ["Insufficient low points"] };
+  const i = o[0], g = o[o.length - 1], u = I(i, g);
+  if (u <= 0)
+    return { valid: !1, confidence: 0, segments: [], keyPoints: [], errors: ["Support not ascending"] };
+  const p = [
+    { start: t[0], end: t[t.length - 1], type: "resistance", strength: 0.8 },
+    { start: i, end: g, type: "support", strength: 0.7 }
+  ], y = [...t.slice(0, 2), i, g], k = T(s), x = 1 - Math.abs(t[0].y - t[t.length - 1].y) / n, b = Math.min(u / 0.01, 1);
+  return {
+    valid: !0,
+    confidence: (x + b) / 2,
+    segments: p,
+    keyPoints: y,
+    measurements: k
+  };
+}
+const B = {
+  "head-shoulders": {
+    id: "head-shoulders",
+    type: "head-shoulders",
+    name: "Head and Shoulders",
+    description: "Bearish reversal pattern with three peaks",
+    minPoints: 5,
+    maxPoints: 7,
+    validator: D
+  },
+  "inverse-head-shoulders": {
+    id: "inverse-head-shoulders",
+    type: "inverse-head-shoulders",
+    name: "Inverse Head and Shoulders",
+    description: "Bullish reversal pattern with three valleys",
+    minPoints: 5,
+    maxPoints: 7,
+    validator: (s) => {
+      const e = s.map((t) => ({ ...t, y: -t.y }));
+      return D(e);
+    }
+  },
+  "double-top": {
+    id: "double-top",
+    type: "double-top",
+    name: "Double Top",
+    description: "Bearish reversal pattern with two equal peaks",
+    minPoints: 4,
+    maxPoints: 6,
+    validator: q
+  },
+  "double-bottom": {
+    id: "double-bottom",
+    type: "double-bottom",
+    name: "Double Bottom",
+    description: "Bullish reversal pattern with two equal valleys",
+    minPoints: 4,
+    maxPoints: 6,
+    validator: E
+  },
+  "triple-top": {
+    id: "triple-top",
+    type: "triple-top",
+    name: "Triple Top",
+    description: "Bearish reversal pattern with three equal peaks",
+    minPoints: 5,
+    maxPoints: 7,
+    validator: (s) => {
+      if (s.length < 5)
+        return { valid: !1, confidence: 0, segments: [], keyPoints: [], errors: ["Insufficient points"] };
+      const { peaks: e } = C(s);
+      if (e.length < 3)
+        return { valid: !1, confidence: 0, segments: [], keyPoints: [], errors: ["Need at least 3 peaks"] };
+      const n = e[0].y, t = e[1].y, o = e[2].y, i = 0.05;
+      if (!(Math.abs(n - t) / n < i && Math.abs(t - o) / t < i))
+        return { valid: !1, confidence: 0, segments: [], keyPoints: [], errors: ["Peaks not equal"] };
+      const u = [
+        { start: e[0], end: e[1], type: "resistance", strength: 0.8 },
+        { start: e[1], end: e[2], type: "resistance", strength: 0.8 }
+      ], p = [e[0], e[1], e[2]], y = T(s);
+      return {
+        valid: !0,
+        confidence: 0.8,
+        segments: u,
+        keyPoints: p,
+        measurements: y
+      };
+    }
+  },
+  "triple-bottom": {
+    id: "triple-bottom",
+    type: "triple-bottom",
+    name: "Triple Bottom",
+    description: "Bullish reversal pattern with three equal valleys",
+    minPoints: 5,
+    maxPoints: 7,
+    validator: (s) => {
+      const e = s.map((n) => ({ ...n, y: -n.y }));
+      return B["triple-top"].validator(e);
+    }
+  },
+  "ascending-triangle": {
+    id: "ascending-triangle",
+    type: "ascending-triangle",
+    name: "Ascending Triangle",
+    description: "Continuation pattern with horizontal resistance and ascending support",
+    minPoints: 4,
+    maxPoints: 8,
+    validator: _
+  },
+  "descending-triangle": {
+    id: "descending-triangle",
+    type: "descending-triangle",
+    name: "Descending Triangle",
+    description: "Continuation pattern with horizontal support and descending resistance",
+    minPoints: 4,
+    maxPoints: 8,
+    validator: (s) => {
+      const e = s.map((t) => ({ ...t, y: -t.y }));
+      return _(e);
+    }
+  },
+  "symmetrical-triangle": {
+    id: "symmetrical-triangle",
+    type: "symmetrical-triangle",
+    name: "Symmetrical Triangle",
+    description: "Continuation pattern with converging support and resistance",
+    minPoints: 4,
+    maxPoints: 8,
+    validator: (s) => {
+      if (s.length < 4)
+        return { valid: !1, confidence: 0, segments: [], keyPoints: [], errors: ["Insufficient points"] };
+      const e = s.slice(0, Math.floor(s.length / 2)), n = s.slice(Math.floor(s.length / 2)), t = I(e[0], e[e.length - 1]), o = I(n[0], n[n.length - 1]);
+      if (!(t > 0 && o < 0 || t < 0 && o > 0))
+        return { valid: !1, confidence: 0, segments: [], keyPoints: [], errors: ["Lines not converging"] };
+      const g = [
+        { start: e[0], end: e[e.length - 1], type: "trendline", strength: 0.7 },
+        { start: n[0], end: n[n.length - 1], type: "trendline", strength: 0.7 }
+      ], u = [e[0], e[e.length - 1], n[0], n[n.length - 1]], p = T(s);
+      return {
+        valid: !0,
+        confidence: 0.7,
+        segments: g,
+        keyPoints: u,
+        measurements: p
+      };
+    }
+  },
+  "rising-wedge": {
+    id: "rising-wedge",
+    type: "rising-wedge",
+    name: "Rising Wedge",
+    description: "Bearish reversal pattern with two converging upward lines",
+    minPoints: 4,
+    maxPoints: 8,
+    validator: (s) => {
+      if (s.length < 4)
+        return { valid: !1, confidence: 0, segments: [], keyPoints: [], errors: ["Insufficient points"] };
+      const { peaks: e, valleys: n } = C(s);
+      if (e.length < 2 || n.length < 2)
+        return { valid: !1, confidence: 0, segments: [], keyPoints: [], errors: ["Insufficient peaks/valleys"] };
+      const t = I(e[0], e[e.length - 1]), o = I(n[0], n[n.length - 1]);
+      if (!(t > 0 && o > 0 && o > t))
+        return { valid: !1, confidence: 0, segments: [], keyPoints: [], errors: ["Not a rising wedge pattern"] };
+      const g = [
+        { start: e[0], end: e[e.length - 1], type: "resistance", strength: 0.8 },
+        { start: n[0], end: n[n.length - 1], type: "support", strength: 0.8 }
+      ], u = [e[0], e[e.length - 1], n[0], n[n.length - 1]], p = T(s);
+      return {
+        valid: !0,
+        confidence: 0.75,
+        segments: g,
+        keyPoints: u,
+        measurements: p
+      };
+    }
+  },
+  "falling-wedge": {
+    id: "falling-wedge",
+    type: "falling-wedge",
+    name: "Falling Wedge",
+    description: "Bullish reversal pattern with two converging downward lines",
+    minPoints: 4,
+    maxPoints: 8,
+    validator: (s) => {
+      const e = s.map((t) => ({ ...t, y: -t.y }));
+      return B["rising-wedge"].validator(e);
+    }
+  },
+  rectangle: {
+    id: "rectangle",
+    type: "rectangle",
+    name: "Rectangle",
+    description: "Continuation pattern with horizontal support and resistance",
+    minPoints: 4,
+    maxPoints: 10,
+    validator: (s) => {
+      if (s.length < 4)
+        return { valid: !1, confidence: 0, segments: [], keyPoints: [], errors: ["Insufficient points"] };
+      const e = s.map((y) => y.y), n = Math.max(...e), t = Math.min(...e), o = s.filter((y) => Math.abs(y.y - n) / n < 0.05), i = s.filter((y) => Math.abs(y.y - t) / t < 0.05);
+      if (o.length < 2 || i.length < 2)
+        return { valid: !1, confidence: 0, segments: [], keyPoints: [], errors: ["Insufficient horizontal lines"] };
+      const g = [
+        { start: o[0], end: o[o.length - 1], type: "resistance", strength: 0.9 },
+        { start: i[0], end: i[i.length - 1], type: "support", strength: 0.9 }
+      ], u = [o[0], o[o.length - 1], i[0], i[i.length - 1]], p = T(s);
+      return {
+        valid: !0,
+        confidence: 0.8,
+        segments: g,
+        keyPoints: u,
+        measurements: p
+      };
+    }
+  },
+  flag: {
+    id: "flag",
+    type: "flag",
+    name: "Flag",
+    description: "Short-term continuation pattern after strong move",
+    minPoints: 3,
+    maxPoints: 6,
+    validator: (s) => {
+      if (s.length < 3)
+        return { valid: !1, confidence: 0, segments: [], keyPoints: [], errors: ["Insufficient points"] };
+      const e = I(s[0], s[s.length - 1]);
+      if (!(Math.abs(e) < 0.01))
+        return { valid: !1, confidence: 0, segments: [], keyPoints: [], errors: ["Not horizontal enough"] };
+      const t = [
+        { start: s[0], end: s[s.length - 1], type: "trendline", strength: 0.6 }
+      ], o = [s[0], s[s.length - 1]], i = T(s);
+      return {
+        valid: !0,
+        confidence: 0.6,
+        segments: t,
+        keyPoints: o,
+        measurements: i
+      };
+    }
+  },
+  pennant: {
+    id: "pennant",
+    type: "pennant",
+    name: "Pennant",
+    description: "Short-term continuation pattern with converging lines",
+    minPoints: 3,
+    maxPoints: 5,
+    validator: (s) => B["symmetrical-triangle"].validator(s)
+  },
+  custom: {
+    id: "custom",
+    type: "custom",
+    name: "Custom Pattern",
+    description: "User-defined pattern",
+    minPoints: 3,
+    validator: (s) => ({ valid: !1, confidence: 0, segments: [], keyPoints: [], errors: ["Custom pattern not implemented"] })
+  }
+}, L = {
+  name: "pattern-recognition",
+  version: "1.0.0",
+  description: "Technical pattern recognition for financial and scientific data",
+  author: "Sci Plot Team",
+  provides: ["patterns", "technical-analysis", "chart-patterns"]
+}, V = {
+  defaultParameters: {
+    minConfidence: 0.7,
+    maxPatterns: 10,
+    patternTypes: ["head-shoulders", "double-top", "double-bottom", "ascending-triangle", "descending-triangle"],
+    sensitivity: 0.5,
+    minPatternSize: 5,
+    maxPatternSize: 50,
+    overlapTolerance: 0.3,
+    enableVolumeConfirmation: !1,
+    enableTrendConfirmation: !0
+  },
+  customPatterns: [],
+  enableRealtime: !1,
+  debounceTime: 500,
+  maxStoredPatterns: 100,
+  visualization: {
+    showPatterns: !0,
+    showLabels: !0,
+    showTargets: !0,
+    colorScheme: {
+      "head-shoulders": "#ff6b6b",
+      "inverse-head-shoulders": "#4ecdc4",
+      "double-top": "#ff9f43",
+      "double-bottom": "#00d2d3",
+      "triple-top": "#ff6b6b",
+      "triple-bottom": "#4ecdc4",
+      "ascending-triangle": "#45b7d1",
+      "descending-triangle": "#f39c12",
+      "symmetrical-triangle": "#9b59b6",
+      "rising-wedge": "#e74c3c",
+      "falling-wedge": "#27ae60",
+      rectangle: "#34495e",
+      flag: "#f1c40f",
+      pennant: "#e67e22",
+      custom: "#95a5a6"
+    },
+    opacity: 0.7,
+    lineWidth: 2
+  },
+  notifications: {
+    enableAlerts: !1,
+    minAlertConfidence: 0.8,
+    alertTypes: ["head-shoulders", "double-top", "double-bottom"]
+  }
+};
+function F(s = {}) {
+  const e = { ...V, ...s };
+  let n = null;
+  const t = /* @__PURE__ */ new Map(), o = new Map(Object.entries(B)), i = /* @__PURE__ */ new Set(), g = /* @__PURE__ */ new Map();
+  async function u(a, l, d) {
+    const r = { ...e.defaultParameters, ...d }, f = performance.now(), c = [], m = {}, h = p(l, r.sensitivity);
+    for (const v of r.patternTypes) {
+      const w = o.get(v);
+      if (w) {
+        for (let z = r.minPatternSize; z <= Math.min(h.length, r.maxPatternSize); z++) {
+          const $ = h.slice(Math.max(0, z - r.maxPatternSize), z);
+          if ($.length < w.minPoints || w.maxPoints && $.length > w.maxPoints) continue;
+          const R = w.validator($);
+          if (R.valid && R.confidence >= r.minConfidence) {
+            const A = {
+              pattern: w,
+              confidence: R.confidence,
+              location: {
+                startIndex: Math.max(0, z - r.maxPatternSize),
+                endIndex: z,
+                startPoint: $[0],
+                endPoint: $[$.length - 1]
+              },
+              validation: R,
+              timestamp: Date.now(),
+              seriesId: a
+            };
+            if (!y(A, c, r.overlapTolerance) && (c.push(A), m[v] = (m[v] || 0) + 1, c.length >= r.maxPatterns))
+              break;
+          }
+        }
+        if (c.length >= r.maxPatterns)
+          break;
+      }
+    }
+    c.sort((v, w) => w.confidence - v.confidence), t.set(a, c);
+    const P = performance.now() - f;
+    for (const v of c)
+      v.confidence >= e.notifications.minAlertConfidence && e.notifications.alertTypes.includes(v.pattern.type) && (n == null || n.events.emit("pattern:detected", {
+        match: v,
+        seriesId: a,
+        timestamp: Date.now()
+      }));
+    const S = {
+      matches: c,
+      summary: {
+        totalPatterns: c.length,
+        patternsByType: m,
+        averageConfidence: c.length > 0 ? c.reduce((v, w) => v + w.confidence, 0) / c.length : 0,
+        detectionTime: P
+      },
+      processedPoints: h.length,
+      parameters: r
+    };
+    return n == null || n.log.info(`Pattern detection completed for ${a}: ${c.length} patterns found`), S;
+  }
+  function p(a, l) {
+    return a.filter((d, r) => {
+      if (r === 0 || r === a.length - 1) return !0;
+      const f = a[r - 1];
+      return Math.abs(d.y - f.y) / f.y >= l * 0.01;
+    });
+  }
+  function y(a, l, d) {
+    for (const r of l) {
+      const f = Math.max(a.location.startIndex, r.location.startIndex), m = Math.min(a.location.endIndex, r.location.endIndex) - f, h = a.location.endIndex - a.location.startIndex, P = r.location.endIndex - r.location.startIndex;
+      if (m / Math.min(h, P) > d)
+        return !0;
+    }
+    return !1;
+  }
+  function k(a) {
+    const l = {
+      id: a.id,
+      type: "custom",
+      name: a.name,
+      minPoints: a.pointSequence.length,
+      maxPoints: a.pointSequence.length,
+      validator: (d) => x(d, a)
+    };
+    o.set("custom", l), n == null || n.log.info(`Custom pattern registered: ${a.id}`);
+  }
+  function x(a, l) {
+    if (a.length < l.pointSequence.length)
+      return { valid: !1, confidence: 0, segments: [], keyPoints: [], errors: ["Insufficient points"] };
+    let d = 1;
+    const r = [];
+    for (let f = 0; f < l.pointSequence.length; f++) {
+      const c = l.pointSequence[f], m = a[f];
+      if (c.constraints) {
+        const h = c.constraints;
+        if (h.higherThanPrevious && f > 0 && m.y <= a[f - 1].y && (d *= 0.8, r.push(`Point ${f} not higher than previous`)), h.lowerThanPrevious && f > 0 && m.y >= a[f - 1].y && (d *= 0.8, r.push(`Point ${f} not lower than previous`)), h.withinRange) {
+          const [P, S] = h.withinRange;
+          (m.y < P || m.y > S) && (d *= 0.7, r.push(`Point ${f} not within range [${P}, ${S}]`));
+        }
+      }
+    }
+    return {
+      valid: d >= 0.5,
+      confidence: d,
+      segments: [],
+      keyPoints: a,
+      errors: r.length > 0 ? r : void 0
+    };
+  }
+  const b = {
+    detectPatterns: u,
+    registerCustomPattern: k,
+    getRegisteredPatterns() {
+      return Array.from(o.values());
+    },
+    getPatternMatches(a) {
+      return t.get(a) || [];
+    },
+    clearPatternMatches(a) {
+      t.delete(a), n == null || n.log.info(`Pattern matches cleared for series: ${a}`);
+    },
+    enableRealtimeDetection(a, l) {
+      i.add(a);
+      const d = n == null ? void 0 : n.chart;
+      if (d) {
+        const r = d.getSeries(a);
+        if (r) {
+          const f = r.getData();
+          if (f && f.x.length > 0) {
+            const c = Array.from(f.x).map((m, h) => ({
+              x: m,
+              y: f.y[h]
+            }));
+            u(a, c, l);
+          }
+        }
+      }
+      n == null || n.log.info(`Real-time pattern detection enabled for series: ${a}`);
+    },
+    disableRealtimeDetection(a) {
+      i.delete(a);
+      const l = g.get(a);
+      l && (clearTimeout(l), g.delete(a)), n == null || n.log.info(`Real-time pattern detection disabled for series: ${a}`);
+    },
+    getStatistics(a) {
+      if (a) {
+        const l = t.get(a) || [], d = {};
+        for (const r of l)
+          d[r.pattern.type] = (d[r.pattern.type] || 0) + 1;
+        return {
+          totalDetections: l.length,
+          patternsByType: d,
+          averageConfidence: l.length > 0 ? l.reduce((r, f) => r + f.confidence, 0) / l.length : 0,
+          detectionRate: l.length / 100
+        };
+      } else {
+        let l = 0;
+        const d = {}, r = [];
+        for (const f of t.values()) {
+          l += f.length, r.push(...f.map((c) => c.confidence));
+          for (const c of f)
+            d[c.pattern.type] = (d[c.pattern.type] || 0) + 1;
+        }
+        return {
+          totalDetections: l,
+          patternsByType: d,
+          averageConfidence: r.length > 0 ? r.reduce((f, c) => f + c, 0) / r.length : 0,
+          detectionRate: l / 100
+        };
+      }
+    },
+    updateConfig: (a) => {
+      Object.assign(e, a);
+    },
+    getConfig: () => ({ ...e }),
+    visualizePatterns(a, l) {
+      const d = n == null ? void 0 : n.chart;
+      if (!d) return;
+      const r = t.get(a) || [], f = l ? r.filter((c) => l.includes(c.pattern.type)) : r;
+      b.hidePatterns(a);
+      for (const c of f) {
+        const m = e.visualization.colorScheme[c.pattern.type] || "#666666";
+        for (const h of c.validation.segments) {
+          const P = `${a}_pattern_${c.pattern.id}_${c.location.startIndex}`;
+          d.addSeries({
+            id: P,
+            type: "line",
+            data: {
+              x: new Float32Array([h.start.x, h.end.x]),
+              y: new Float32Array([h.start.y, h.end.y])
+            },
+            style: {
+              color: m,
+              width: e.visualization.lineWidth,
+              opacity: e.visualization.opacity,
+              lineDash: [5, 5]
+            }
+          });
+        }
+        if (e.visualization.showLabels) {
+          const h = `${a}_label_${c.pattern.id}_${c.location.startIndex}`, P = (c.location.startPoint.x + c.location.endPoint.x) / 2, S = (c.location.startPoint.y + c.location.endPoint.y) / 2;
+          d.addAnnotation({
+            id: h,
+            type: "text",
+            text: c.pattern.name,
+            x: P,
+            y: S,
+            style: {
+              color: m,
+              fontSize: 12,
+              backgroundColor: "rgba(255, 255, 255, 0.8)"
+            }
+          });
+        }
+      }
+    },
+    hidePatterns(a) {
+      const l = n == null ? void 0 : n.chart;
+      if (!l) return;
+      const d = t.get(a) || [];
+      for (const r of d) {
+        for (let c = 0; c < r.validation.segments.length; c++) {
+          const m = `${a}_pattern_${r.pattern.id}_${r.location.startIndex}`;
+          l.getSeries(m) && l.removeSeries(m);
+        }
+        const f = `${a}_label_${r.pattern.id}_${r.location.startIndex}`;
+        l.getAnnotation(f) && l.removeAnnotation(f);
+      }
+    }
+  };
+  function M(a, l) {
+    if (!e.enableRealtime) return;
+    const { seriesId: d } = l;
+    if (i.has(d)) {
+      const r = g.get(d);
+      r && clearTimeout(r);
+      const f = setTimeout(() => {
+        const c = a.chart;
+        if (c) {
+          const m = c.getSeries(d);
+          if (m) {
+            const h = m.getData();
+            if (h && h.x.length > 0) {
+              const P = Array.from(h.x).map((S, v) => ({
+                x: S,
+                y: h.y[v]
+              }));
+              u(d, P), e.visualization.showPatterns && b.visualizePatterns(d);
+            }
+          }
+        }
+      }, e.debounceTime);
+      g.set(d, f);
+    }
+  }
+  return {
+    manifest: L,
+    onInit(a) {
+      if (n = a, e.customPatterns)
+        for (const l of e.customPatterns)
+          k(l);
+      n.log.info(`Pattern Recognition plugin initialized with ${o.size} patterns`);
+    },
+    onConfigChange(a, l) {
+    },
+    onBeforeRender(a, l) {
+    },
+    onDataUpdate: M,
+    onDestroy(a) {
+      for (const l of g.values())
+        clearTimeout(l);
+      g.clear(), t.clear(), i.clear(), o.clear();
+    },
+    api: b
+  };
+}
+export {
+  F as PluginPatternRecognition,
+  F as default
+};
+//# sourceMappingURL=pattern-recognition.js.map