velo-plot 1.12.0 → 1.15.0

package/dist/plugins/anomaly-detection.d.ts

@@ -0,0 +1 @@
+export * from './anomaly-detection/index'

package/dist/plugins/anomaly-detection.js

@@ -0,0 +1,221 @@
+function p(l, e, i = 3) {
+  const o = e.length;
+  if (o < 3) return [];
+  const n = [], c = Math.min(20, Math.floor(o / 10));
+  for (let t = 0; t < o; t++) {
+    const d = Math.max(0, t - c), u = Math.min(o, t + c + 1);
+    let a = 0, s = 0;
+    for (let h = d; h < u; h++)
+      h !== t && (a += e[h], s++);
+    const f = a / s;
+    let m = 0;
+    for (let h = d; h < u; h++)
+      h !== t && (m += Math.pow(e[h] - f, 2));
+    const g = Math.sqrt(m / s);
+    if (g === 0) continue;
+    const r = Math.abs((e[t] - f) / g);
+    r > i && n.push({
+      index: t,
+      x: l[t],
+      y: e[t],
+      score: r,
+      method: "zscore"
+    });
+  }
+  return n;
+}
+function z(l, e, i = 3.5) {
+  const o = e.length;
+  if (o < 3) return [];
+  const n = [], c = Math.min(20, Math.floor(o / 10));
+  for (let t = 0; t < o; t++) {
+    const d = Math.max(0, t - c), u = Math.min(o, t + c + 1), a = [];
+    for (let r = d; r < u; r++)
+      r !== t && a.push(e[r]);
+    a.sort((r, h) => r - h);
+    const s = a[Math.floor(a.length / 2)], f = a.map((r) => Math.abs(r - s));
+    f.sort((r, h) => r - h);
+    const m = f[Math.floor(f.length / 2)];
+    if (m === 0) continue;
+    const g = Math.abs(0.6745 * (e[t] - s) / m);
+    g > i && n.push({
+      index: t,
+      x: l[t],
+      y: e[t],
+      score: g,
+      method: "mad"
+    });
+  }
+  return n;
+}
+function A(l, e, i = 1.5) {
+  const o = e.length;
+  if (o < 4) return [];
+  const n = [], c = Math.min(20, Math.floor(o / 10));
+  for (let t = 0; t < o; t++) {
+    const d = Math.max(0, t - c), u = Math.min(o, t + c + 1), a = [];
+    for (let M = d; M < u; M++)
+      M !== t && a.push(e[M]);
+    a.sort((M, x) => M - x);
+    const s = Math.floor(a.length * 0.25), f = Math.floor(a.length * 0.75), m = a[s], g = a[f], r = g - m;
+    if (r === 0) continue;
+    const h = m - i * r, S = g + i * r;
+    if (e[t] < h || e[t] > S) {
+      const M = e[t] < h ? (h - e[t]) / r : (e[t] - S) / r;
+      n.push({
+        index: t,
+        x: l[t],
+        y: e[t],
+        score: M,
+        method: "iqr"
+      });
+    }
+  }
+  return n;
+}
+function q(l, e, i = 0.05, o = 10) {
+  const n = e.length;
+  if (n < 10) return [];
+  const c = new Float32Array(n);
+  for (let s = 0; s < n; s++) {
+    let f = 0;
+    for (let r = 0; r < o; r++)
+      f += w(e, s, 0, 8);
+    const m = f / o, g = 2 * (Math.log(n - 1) + 0.5772156649) - 2 * (n - 1) / n;
+    c[s] = Math.pow(2, -m / g);
+  }
+  const t = Array.from(c).sort((s, f) => f - s), d = Math.floor(n * i), u = t[d], a = [];
+  for (let s = 0; s < n; s++)
+    c[s] >= u && a.push({
+      index: s,
+      x: l[s],
+      y: e[s],
+      score: c[s],
+      method: "isolation-forest"
+    });
+  return a;
+}
+function w(l, e, i, o) {
+  if (i >= o) return i;
+  const n = Math.min(...Array.from(l)), c = Math.max(...Array.from(l)), t = n + Math.random() * (c - n);
+  return l[e] < t, w(l, e, i + 1, o);
+}
+function D(l, e, i, o) {
+  switch (i) {
+    case "zscore":
+      return p(l, e, o);
+    case "mad":
+      return z(l, e, o);
+    case "iqr":
+      return A(l, e, o);
+    case "isolation-forest":
+      return q(l, e, o);
+    default:
+      return p(l, e, o);
+  }
+}
+const j = {
+  method: "zscore",
+  sensitivity: 3,
+  realtime: !1,
+  highlight: !0,
+  highlightColor: "#ff0000",
+  highlightSize: 8,
+  minWindowSize: 30,
+  rollingWindow: !1,
+  windowSize: 100,
+  seriesIds: []
+}, R = {
+  id: "anomaly-detection",
+  name: "Anomaly Detection",
+  version: "1.0.0",
+  description: "Real-time anomaly detection with multiple algorithms",
+  author: "Sci Plot",
+  category: "analysis"
+};
+function b(l = {}) {
+  const e = { ...j, ...l };
+  let i = null;
+  const o = /* @__PURE__ */ new Map();
+  return {
+    manifest: R,
+    onInit(n) {
+      i = n;
+    },
+    onDestroy() {
+      o.clear(), i = null;
+    },
+    api: {
+      /**
+       * Run anomaly detection on a specific series
+       */
+      detect(n) {
+        if (!i) return null;
+        const c = i.data.getSeries(n);
+        if (!c) return null;
+        const t = c.getData();
+        if (!t || t.x.length < e.minWindowSize) return null;
+        let d = t.x, u = t.y;
+        if (e.rollingWindow && t.x.length > e.windowSize) {
+          const f = t.x.length - e.windowSize;
+          d = t.x.slice(f), u = t.y.slice(f);
+        }
+        const a = D(d, u, e.method, e.sensitivity), s = {
+          seriesId: n,
+          anomalies: a,
+          totalPoints: u.length,
+          method: e.method,
+          threshold: e.sensitivity,
+          timestamp: Date.now()
+        };
+        return o.set(n, s), i.events.emit("anomaly:detected", s), s;
+      },
+      /**
+       * Run detection on all series
+       */
+      detectAll() {
+        if (!i) return /* @__PURE__ */ new Map();
+        const n = /* @__PURE__ */ new Map();
+        return i.data.getAllSeries().forEach((t, d) => {
+          const u = this.detect(String(d));
+          u && n.set(String(d), u);
+        }), n;
+      },
+      /**
+       * Get detection results for a specific series
+       */
+      getResults(n) {
+        return o.get(n);
+      },
+      /**
+       * Get all detection results
+       */
+      getAllResults() {
+        return new Map(o);
+      },
+      /**
+       * Clear all detection results
+       */
+      clear() {
+        o.clear();
+      },
+      /**
+       * Update configuration
+       */
+      setConfig(n) {
+        Object.assign(e, n);
+      },
+      /**
+       * Get current configuration
+       */
+      getConfig() {
+        return { ...e };
+      }
+    }
+  };
+}
+export {
+  b as PluginAnomalyDetection,
+  R as manifestAnomalyDetection
+};
+//# sourceMappingURL=anomaly-detection.js.map

package/dist/plugins/anomaly-detection.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"anomaly-detection.js","sources":["../../src/plugins/anomaly-detection/algorithms.ts","../../src/plugins/anomaly-detection/index.ts"],"sourcesContent":["/**\n * Anomaly Detection Algorithms\n * Each method has distinct characteristics for different use cases\n */\n\nimport type { AnomalyPoint, AnomalyMethod } from './types';\n\n/**\n * Z-Score method: Standard statistical approach\n * - Uses MEAN and STANDARD DEVIATION (parametric)\n * - Assumes normal distribution\n * - Sensitive to extreme outliers\n * - Best for: Clean, normally distributed data\n */\nexport function detectZScore(\n  x: Float32Array | Float64Array,\n  y: Float32Array | Float64Array,\n  threshold: number = 3\n): AnomalyPoint[] {\n  const n = y.length;\n  if (n < 3) return [];\n  \n  const anomalies: AnomalyPoint[] = [];\n  const windowSize = Math.min(20, Math.floor(n / 10));\n  \n  for (let i = 0; i < n; i++) {\n    const start = Math.max(0, i - windowSize);\n    const end = Math.min(n, i + windowSize + 1);\n    \n    // Calculate local MEAN (parametric - sensitive to outliers)\n    let localSum = 0;\n    let count = 0;\n    for (let j = start; j < end; j++) {\n      if (j !== i) {\n        localSum += y[j];\n        count++;\n      }\n    }\n    const localMean = localSum / count;\n    \n    // Calculate local STANDARD DEVIATION (parametric)\n    let localSumSq = 0;\n    for (let j = start; j < end; j++) {\n      if (j !== i) {\n        localSumSq += Math.pow(y[j] - localMean, 2);\n      }\n    }\n    const localStdDev = Math.sqrt(localSumSq / count);\n    \n    if (localStdDev === 0) continue;\n    \n    // Z-score: measures how many standard deviations away from mean\n    const zScore = Math.abs((y[i] - localMean) / localStdDev);\n    \n    if (zScore > threshold) {\n      anomalies.push({\n        index: i,\n        x: x[i],\n        y: y[i],\n        score: zScore,\n        method: 'zscore'\n      });\n    }\n  }\n  \n  return anomalies;\n}\n\n/**\n * MAD (Median Absolute Deviation) method: Robust statistical approach\n * - Uses MEDIAN instead of mean (non-parametric)\n * - Robust to outliers in the window\n * - Doesn't assume normal distribution\n * - Best for: Data with existing outliers, skewed distributions\n */\nexport function detectMAD(\n  x: Float32Array | Float64Array,\n  y: Float32Array | Float64Array,\n  threshold: number = 3.5\n): AnomalyPoint[] {\n  const n = y.length;\n  if (n < 3) return [];\n  \n  const anomalies: AnomalyPoint[] = [];\n  const windowSize = Math.min(20, Math.floor(n / 10));\n  \n  for (let i = 0; i < n; i++) {\n    const start = Math.max(0, i - windowSize);\n    const end = Math.min(n, i + windowSize + 1);\n    \n    // Get local window values\n    const localValues: number[] = [];\n    for (let j = start; j < end; j++) {\n      if (j !== i) {\n        localValues.push(y[j]);\n      }\n    }\n    \n    // Calculate MEDIAN (robust to outliers)\n    localValues.sort((a, b) => a - b);\n    const localMedian = localValues[Math.floor(localValues.length / 2)];\n    \n    // Calculate MAD (Median Absolute Deviation - robust measure of spread)\n    const deviations = localValues.map(v => Math.abs(v - localMedian));\n    deviations.sort((a, b) => a - b);\n    const mad = deviations[Math.floor(deviations.length / 2)];\n    \n    if (mad === 0) continue;\n    \n    // Modified Z-score using MAD (more robust than standard Z-score)\n    // 0.6745 is the consistency constant for normal distribution\n    const modifiedZScore = Math.abs((0.6745 * (y[i] - localMedian)) / mad);\n    \n    if (modifiedZScore > threshold) {\n      anomalies.push({\n        index: i,\n        x: x[i],\n        y: y[i],\n        score: modifiedZScore,\n        method: 'mad'\n      });\n    }\n  }\n  \n  return anomalies;\n}\n\n/**\n * IQR (Interquartile Range) method: Quartile-based approach\n * - Uses PERCENTILES (25th and 75th)\n * - Classic box-plot outlier detection\n * - Non-parametric, distribution-free\n * - Best for: General purpose, well-understood method\n */\nexport function detectIQR(\n  x: Float32Array | Float64Array,\n  y: Float32Array | Float64Array,\n  multiplier: number = 1.5\n): AnomalyPoint[] {\n  const n = y.length;\n  if (n < 4) return [];\n  \n  const anomalies: AnomalyPoint[] = [];\n  const windowSize = Math.min(20, Math.floor(n / 10));\n  \n  for (let i = 0; i < n; i++) {\n    const start = Math.max(0, i - windowSize);\n    const end = Math.min(n, i + windowSize + 1);\n    \n    // Get local window values\n    const localValues: number[] = [];\n    for (let j = start; j < end; j++) {\n      if (j !== i) {\n        localValues.push(y[j]);\n      }\n    }\n    \n    // Calculate QUARTILES (percentile-based)\n    localValues.sort((a, b) => a - b);\n    const q1Index = Math.floor(localValues.length * 0.25);\n    const q3Index = Math.floor(localValues.length * 0.75);\n    const q1 = localValues[q1Index];\n    const q3 = localValues[q3Index];\n    const iqr = q3 - q1;\n    \n    if (iqr === 0) continue;\n    \n    // IQR method: points outside [Q1 - k*IQR, Q3 + k*IQR] are outliers\n    // k=1.5 for outliers, k=3.0 for extreme outliers\n    const lowerBound = q1 - multiplier * iqr;\n    const upperBound = q3 + multiplier * iqr;\n    \n    if (y[i] < lowerBound || y[i] > upperBound) {\n      const score = y[i] < lowerBound \n        ? (lowerBound - y[i]) / iqr\n        : (y[i] - upperBound) / iqr;\n      \n      anomalies.push({\n        index: i,\n        x: x[i],\n        y: y[i],\n        score,\n        method: 'iqr'\n      });\n    }\n  }\n  \n  return anomalies;\n}\n\n/**\n * Simplified Isolation Forest: Detects anomalies using random partitioning\n * - Machine learning approach\n * - Isolates anomalies through random splits\n * - Works well with high-dimensional data\n * - Best for: Complex patterns, unknown distributions\n */\nexport function detectIsolationForest(\n  x: Float32Array | Float64Array,\n  y: Float32Array | Float64Array,\n  contamination: number = 0.05,\n  numTrees: number = 10\n): AnomalyPoint[] {\n  const n = y.length;\n  if (n < 10) return [];\n  \n  // Calculate anomaly scores for each point\n  const scores = new Float32Array(n);\n  \n  for (let i = 0; i < n; i++) {\n    let totalDepth = 0;\n    \n    // Build multiple trees\n    for (let t = 0; t < numTrees; t++) {\n      totalDepth += isolationDepth(y, i, 0, 8); // Max depth 8\n    }\n    \n    // Average depth (normalized)\n    const avgDepth = totalDepth / numTrees;\n    const c = 2 * (Math.log(n - 1) + 0.5772156649) - (2 * (n - 1) / n);\n    scores[i] = Math.pow(2, -avgDepth / c);\n  }\n  \n  // Sort scores to find threshold\n  const sortedScores = Array.from(scores).sort((a, b) => b - a);\n  const thresholdIndex = Math.floor(n * contamination);\n  const threshold = sortedScores[thresholdIndex];\n  \n  // Find anomalies\n  const anomalies: AnomalyPoint[] = [];\n  for (let i = 0; i < n; i++) {\n    if (scores[i] >= threshold) {\n      anomalies.push({\n        index: i,\n        x: x[i],\n        y: y[i],\n        score: scores[i],\n        method: 'isolation-forest'\n      });\n    }\n  }\n  \n  return anomalies;\n}\n\n/**\n * Helper: Calculate isolation depth for a point\n */\nfunction isolationDepth(\n  data: Float32Array | Float64Array,\n  pointIndex: number,\n  currentDepth: number,\n  maxDepth: number\n): number {\n  if (currentDepth >= maxDepth) return currentDepth;\n  \n  // Random split\n  const min = Math.min(...Array.from(data));\n  const max = Math.max(...Array.from(data));\n  const splitValue = min + Math.random() * (max - min);\n  \n  // Check which side the point falls on\n  if (data[pointIndex] < splitValue) {\n    return isolationDepth(data, pointIndex, currentDepth + 1, maxDepth);\n  } else {\n    return isolationDepth(data, pointIndex, currentDepth + 1, maxDepth);\n  }\n}\n\n/**\n * Main detection function - routes to appropriate algorithm\n */\nexport function detectAnomalies(\n  x: Float32Array | Float64Array,\n  y: Float32Array | Float64Array,\n  method: AnomalyMethod,\n  sensitivity: number\n): AnomalyPoint[] {\n  switch (method) {\n    case 'zscore':\n      return detectZScore(x, y, sensitivity);\n    case 'mad':\n      return detectMAD(x, y, sensitivity);\n    case 'iqr':\n      return detectIQR(x, y, sensitivity);\n    case 'isolation-forest':\n      return detectIsolationForest(x, y, sensitivity);\n    default:\n      return detectZScore(x, y, sensitivity);\n  }\n}\n","/**\n * Anomaly Detection Plugin\n * \n * Detects anomalies in chart data using statistical methods.\n * This is a simplified version that provides the core API.\n * \n * @module plugins/anomaly-detection\n */\n\nimport type { ChartPlugin, PluginContext } from '../types';\nimport type { \n  PluginAnomalyDetectionConfig, \n  AnomalyDetectionResult\n} from './types';\nimport { detectAnomalies } from './algorithms';\n\nexport type { \n  PluginAnomalyDetectionConfig,\n  AnomalyDetectionResult,\n  AnomalyPoint,\n  AnomalyMethod\n} from './types';\n\nconst DEFAULT_CONFIG: Required<PluginAnomalyDetectionConfig> = {\n  method: 'zscore',\n  sensitivity: 3,\n  realtime: false,\n  highlight: true,\n  highlightColor: '#ff0000',\n  highlightSize: 8,\n  minWindowSize: 30,\n  rollingWindow: false,\n  windowSize: 100,\n  seriesIds: []\n};\n\nexport const manifestAnomalyDetection = {\n  id: 'anomaly-detection',\n  name: 'Anomaly Detection',\n  version: '1.0.0' as `${number}.${number}.${number}`,\n  description: 'Real-time anomaly detection with multiple algorithms',\n  author: 'Sci Plot',\n  category: 'analysis' as const\n};\n\n/**\n * Anomaly Detection Plugin Factory\n */\nexport function PluginAnomalyDetection(\n  userConfig: PluginAnomalyDetectionConfig = {}\n): ChartPlugin<PluginAnomalyDetectionConfig> {\n  const config = { ...DEFAULT_CONFIG, ...userConfig };\n  let ctx: PluginContext | null = null;\n  const detectionResults = new Map<string, AnomalyDetectionResult>();\n  \n  return {\n    manifest: manifestAnomalyDetection,\n    \n    onInit(pluginCtx: PluginContext) {\n      ctx = pluginCtx;\n    },\n    \n    onDestroy() {\n      detectionResults.clear();\n      ctx = null;\n    },\n    \n    api: {\n      /**\n       * Run anomaly detection on a specific series\n       */\n      detect(seriesId: string): AnomalyDetectionResult | null {\n        if (!ctx) return null;\n        \n        const series = ctx.data.getSeries(seriesId);\n        if (!series) return null;\n        \n        const data = series.getData();\n        if (!data || data.x.length < config.minWindowSize) return null;\n        \n        // Use rolling window if enabled\n        let x = data.x;\n        let y = data.y;\n        \n        if (config.rollingWindow && data.x.length > config.windowSize) {\n          const start = data.x.length - config.windowSize;\n          x = data.x.slice(start);\n          y = data.y.slice(start);\n        }\n        \n        // Run detection\n        const anomalies = detectAnomalies(x, y, config.method, config.sensitivity);\n        \n        // Store results\n        const result: AnomalyDetectionResult = {\n          seriesId,\n          anomalies,\n          totalPoints: y.length,\n          method: config.method,\n          threshold: config.sensitivity,\n          timestamp: Date.now()\n        };\n        \n        detectionResults.set(seriesId, result);\n        \n        // Emit event\n        ctx.events.emit('anomaly:detected', result);\n        \n        return result;\n      },\n      \n      /**\n       * Run detection on all series\n       */\n      detectAll(): Map<string, AnomalyDetectionResult> {\n        if (!ctx) return new Map();\n        \n        const results = new Map<string, AnomalyDetectionResult>();\n        const allSeries = ctx.data.getAllSeries();\n        \n        allSeries.forEach((_series, seriesId) => {\n          const result = (this as any).detect(String(seriesId));\n          if (result) {\n            results.set(String(seriesId), result);\n          }\n        });\n        \n        return results;\n      },\n      \n      /**\n       * Get detection results for a specific series\n       */\n      getResults(seriesId: string): AnomalyDetectionResult | undefined {\n        return detectionResults.get(seriesId);\n      },\n      \n      /**\n       * Get all detection results\n       */\n      getAllResults(): Map<string, AnomalyDetectionResult> {\n        return new Map(detectionResults);\n      },\n      \n      /**\n       * Clear all detection results\n       */\n      clear(): void {\n        detectionResults.clear();\n      },\n      \n      /**\n       * Update configuration\n       */\n      setConfig(newConfig: Partial<PluginAnomalyDetectionConfig>): void {\n        Object.assign(config, newConfig);\n      },\n      \n      /**\n       * Get current configuration\n       */\n      getConfig(): PluginAnomalyDetectionConfig {\n        return { ...config };\n      }\n    }\n  };\n}\n"],"names":["detectZScore","x","y","threshold","n","anomalies","windowSize","i","start","end","localSum","count","j","localMean","localSumSq","localStdDev","zScore","detectMAD","localValues","a","b","localMedian","deviations","v","mad","modifiedZScore","detectIQR","multiplier","q1Index","q3Index","q1","q3","iqr","lowerBound","upperBound","score","detectIsolationForest","contamination","numTrees","scores","totalDepth","t","isolationDepth","avgDepth","c","sortedScores","thresholdIndex","data","pointIndex","currentDepth","maxDepth","min","max","splitValue","detectAnomalies","method","sensitivity","DEFAULT_CONFIG","manifestAnomalyDetection","PluginAnomalyDetection","userConfig","config","ctx","detectionResults","pluginCtx","seriesId","series","result","results","_series","newConfig"],"mappings":"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"}

package/dist/plugins/broken-axis.d.ts

@@ -0,0 +1,3 @@
+export * from './broken-axis/index'
+import SciPlot from './broken-axis/index'
+export default SciPlot

package/dist/plugins/broken-axis.js

@@ -0,0 +1,262 @@
+var v = Object.defineProperty;
+var z = (d, e, o) => e in d ? v(d, e, { enumerable: !0, configurable: !0, writable: !0, value: o }) : d[e] = o;
+var R = (d, e, o) => z(d, typeof e != "symbol" ? e + "" : e, o);
+class w {
+  constructor(e, o) {
+    R(this, "domain", [0, 1]);
+    R(this, "range", [0, 100]);
+    R(this, "type", "linear");
+    // Compatible with linear for renderer selection
+    R(this, "underlying");
+    R(this, "sortedBreaks", []);
+    R(this, "visibleRanges", []);
+    R(this, "availableVisualRatio", 1);
+    this.breaks = o, this.underlying = e, this.domain = [...e.domain], this.range = [...e.range], this.refresh();
+  }
+  setDomain(e, o) {
+    this.domain = [e, o], this.underlying.setDomain(e, o), this.refresh();
+  }
+  setRange(e, o) {
+    this.range = [e, o], this.underlying.setRange(e, o), this.refresh();
+  }
+  updateBreaks(e) {
+    this.breaks = e, this.refresh();
+  }
+  refresh() {
+    const [e, o] = this.domain;
+    this.sortedBreaks = this.breaks.filter((r) => r.start < o && r.end > e).map((r) => ({
+      ...r,
+      start: Math.max(e, r.start),
+      end: Math.min(o, r.end),
+      visualRatio: r.visualRatio ?? 0.02
+    })).sort((r, f) => r.start - f.start);
+    const n = [];
+    let i = e;
+    for (const r of this.sortedBreaks)
+      r.start > i && n.push({ start: i, end: r.start }), i = r.end;
+    i < o && n.push({ start: i, end: o });
+    const h = n.reduce((r, f) => r + (f.end - f.start), 0) || 1e-10, c = this.sortedBreaks.reduce((r, f) => r + (f.visualRatio || 0.02), 0);
+    this.availableVisualRatio = Math.max(0.1, 1 - c);
+    let p = 0;
+    this.visibleRanges = n.map((r) => {
+      const f = r.end - r.start, S = f / h * this.availableVisualRatio, t = {
+        start: r.start,
+        end: r.end,
+        pixelOffset: p,
+        pixelScale: S / f
+      }, s = this.sortedBreaks.find((a) => Math.abs(a.start - r.end) < 1e-10);
+      return p += S + ((s == null ? void 0 : s.visualRatio) ?? 0), t;
+    });
+  }
+  transform(e) {
+    const [o, n] = this.domain, [i, h] = this.range, c = h < i;
+    let p = 0;
+    if (e <= o) p = 0;
+    else if (e >= n) p = 1;
+    else {
+      let r = !1;
+      for (const f of this.visibleRanges)
+        if (e >= f.start && e <= f.end) {
+          p = f.pixelOffset + (e - f.start) * f.pixelScale, r = !0;
+          break;
+        }
+      if (!r) {
+        for (const f of this.sortedBreaks)
+          if (e >= f.start && e <= f.end) {
+            const S = this.visibleRanges.find((s) => Math.abs(s.end - f.start) < 1e-10);
+            p = (S ? S.pixelOffset + (S.end - S.start) * S.pixelScale : 0) + (e - f.start) / (f.end - f.start) * (f.visualRatio ?? 0.02), r = !0;
+            break;
+          }
+      }
+      r || (p = 0);
+    }
+    return c ? i - p * (i - h) : i + p * (h - i);
+  }
+  /** Map data value to 0-1 ratio space (handles breaks) */
+  mapToRatio(e) {
+    const [o, n] = this.domain;
+    if (e <= o) return 0;
+    if (e >= n) return 1;
+    for (const i of this.visibleRanges)
+      if (e >= i.start && e <= i.end)
+        return i.pixelOffset + (e - i.start) * i.pixelScale;
+    for (const i of this.sortedBreaks)
+      if (e >= i.start && e <= i.end) {
+        const h = this.visibleRanges.find((p) => Math.abs(p.end - i.start) < 1e-10);
+        return (h ? h.pixelOffset + (h.end - h.start) * h.pixelScale : 0) + (e - i.start) / (i.end - i.start) * (i.visualRatio ?? 0.02);
+      }
+    return 0;
+  }
+  invert(e) {
+    const [o, n] = this.range, i = (e - o) / (n - o), h = Math.max(0, Math.min(1, i));
+    for (const c of this.visibleRanges) {
+      const p = c.pixelOffset + (c.end - c.start) * c.pixelScale;
+      if (h >= c.pixelOffset && h <= p)
+        return c.start + (h - c.pixelOffset) / c.pixelScale;
+    }
+    for (let c = 0; c < this.sortedBreaks.length; c++) {
+      const p = this.sortedBreaks[c], r = this.visibleRanges.find((S) => Math.abs(S.end - p.start) < 1e-10), f = r ? r.pixelOffset + (r.end - r.start) * r.pixelScale : 0;
+      if (h >= f && h <= f + (p.visualRatio ?? 0.02))
+        return p.start;
+    }
+    return this.domain[0];
+  }
+  ticks(e = 10) {
+    const o = [];
+    for (const n of this.visibleRanges) {
+      const i = (n.end - n.start) / (this.domain[1] - this.domain[0]), h = Math.max(2, Math.round(e * i / this.availableVisualRatio)), c = this.generateSegmentTicks(n.start, n.end, h);
+      o.push(...c);
+    }
+    return Array.from(new Set(o)).sort((n, i) => n - i);
+  }
+  generateSegmentTicks(e, o, n) {
+    const i = o - e;
+    if (i <= 0 || !isFinite(i)) return [];
+    const h = i / n, c = Math.pow(10, Math.floor(Math.log10(h))), p = h / c;
+    let r;
+    p < 1.5 ? r = 1 : p < 3 ? r = 2 : p < 7 ? r = 5 : r = 10, r *= c;
+    const f = Math.ceil(e / r) * r, S = [];
+    let t = f;
+    for (; t <= o + r * 0.1; )
+      S.push(Math.round(t * 1e12) / 1e12), t += r;
+    return S;
+  }
+}
+const T = {
+  name: "velo-plot-broken-axis",
+  version: "1.0.1",
+  description: "Support for gaps/breaks in axes with visual indicators",
+  provides: ["broken-axis", "coordinate-transform"],
+  tags: ["axis", "layout", "visualization"]
+};
+function _(d = { axes: {} }) {
+  d.enabled === void 0 && (d.enabled = !0);
+  let e = null, o = null, n = null;
+  const i = /* @__PURE__ */ new Map();
+  function h() {
+    if (!e || !d.enabled) return;
+    const t = d.axes.default || d.axes.xAxis;
+    t && n && (n.updateBreaks(t.breaks), c());
+  }
+  function c() {
+    if (!e || !n || !d.enabled) return;
+    const t = e.chart, [s, a] = n.domain, l = a - s;
+    for (const [m, u] of i.entries()) {
+      const g = new Float32Array(u.x.length);
+      for (let b = 0; b < u.x.length; b++)
+        g[b] = s + n.mapToRatio(u.x[b]) * l;
+      t._originalUpdateSeries && t._originalUpdateSeries(m, { x: g, y: u.y });
+    }
+  }
+  function p(t) {
+    const { render: s } = t, { ctx2d: a, plotArea: l } = s;
+    if (!(!a || !n))
+      for (const [m, u] of Object.entries(d.axes)) {
+        const g = m === "default" || m === "xAxis" ? "horizontal" : "vertical";
+        g === "horizontal" && u.breaks.forEach((b) => {
+          const x = n.transform(b.start), k = n.transform(b.end), y = (x + k) / 2;
+          a.save(), a.lineWidth = 1, a.strokeStyle = u.symbolColor || "#ff00ff", g === "horizontal" && (r(a, y, l.y, u.defaultSymbol || "diagonal", "top"), r(a, y, l.y + l.height, u.defaultSymbol || "diagonal", "bottom")), a.restore();
+        });
+      }
+  }
+  function r(t, s, a, l, m) {
+    t.beginPath(), l === "diagonal" ? (t.moveTo(s - 6, a + 6 / 2), t.lineTo(s + 6, a - 6 / 2), t.moveTo(s - 6 + 3, a + 6 / 2), t.lineTo(s + 6 + 3, a - 6 / 2)) : l === "zigzag" ? (t.moveTo(s - 6, a), t.lineTo(s - 6 / 2, a - 6 / 2), t.lineTo(s + 6 / 2, a + 6 / 2), t.lineTo(s + 6, a)) : m === "top" || m === "bottom" ? (t.moveTo(s - 6, a - 2), t.lineTo(s + 6, a + 2), t.moveTo(s - 6, a - 6), t.lineTo(s + 6, a - 2)) : (t.moveTo(s - 2, a - 6), t.lineTo(s + 2, a + 6)), t.stroke();
+  }
+  const S = {
+    addBreak(t, s) {
+      d.axes[t] || (d.axes[t] = { breaks: [] }), d.axes[t].breaks.push(s), h(), e == null || e.requestRender();
+    },
+    clearBreaks(t) {
+      d.axes[t] && (d.axes[t].breaks = []), h(), e == null || e.requestRender();
+    },
+    setEnabled(t) {
+      var a;
+      const s = d.enabled;
+      if (d.enabled = t, e && s !== t) {
+        const l = e.chart;
+        if (t)
+          o = l.xScale, n = new w(o, ((a = d.axes.default || d.axes.xAxis) == null ? void 0 : a.breaks) || []), l.setXScale(n), c();
+        else if (o) {
+          l.setXScale(o), n = null;
+          for (const [m, u] of i.entries())
+            l._originalUpdateSeries(m, u);
+        }
+      }
+      e == null || e.requestRender();
+    },
+    getBreaks(t) {
+      var s;
+      return ((s = d.axes[t]) == null ? void 0 : s.breaks) || [];
+    },
+    updateConfig(t) {
+      Object.assign(d, t), h(), e == null || e.requestRender();
+    }
+  };
+  return {
+    manifest: T,
+    onInit(t) {
+      e = t;
+      const s = e.chart;
+      if (s.brokenAxis = S, s._originalUpdateSeries = s.updateSeries.bind(s), s._originalAddSeries = s.addSeries.bind(s), s._originalAppendData = s.appendData.bind(s), s.updateSeries = (a, l) => {
+        if (l.x && l.y && i.set(a, {
+          x: l.x instanceof Float32Array ? l.x : new Float32Array(l.x),
+          y: l.y instanceof Float32Array ? l.y : new Float32Array(l.y)
+        }), d.enabled && n && l.x) {
+          const m = l.x, u = new Float32Array(m.length), [g, b] = n.domain, x = b - g;
+          for (let k = 0; k < m.length; k++)
+            u[k] = g + n.mapToRatio(m[k]) * x;
+          s._originalUpdateSeries(a, { ...l, x: u });
+        } else
+          s._originalUpdateSeries(a, l);
+      }, s.addSeries = (a) => {
+        var l, m, u;
+        if (a.id && ((l = a.data) != null && l.x) && ((m = a.data) != null && m.y) && i.set(a.id, {
+          x: a.data.x instanceof Float32Array ? a.data.x : new Float32Array(a.data.x),
+          y: a.data.y instanceof Float32Array ? a.data.y : new Float32Array(a.data.y)
+        }), d.enabled && n && ((u = a.data) != null && u.x)) {
+          const g = a.data.x, b = new Float32Array(g.length), [x, k] = n.domain, y = k - x;
+          for (let A = 0; A < g.length; A++)
+            b[A] = x + n.mapToRatio(g[A]) * y;
+          s._originalAddSeries({ ...a, data: { ...a.data, x: b } });
+        } else
+          s._originalAddSeries(a);
+      }, s.appendData = (a, l, m) => {
+        const u = i.get(a);
+        if (u) {
+          const g = l instanceof Float32Array ? l : [l], b = m instanceof Float32Array ? m : [m], x = new Float32Array(u.x.length + g.length), k = new Float32Array(u.y.length + b.length);
+          x.set(u.x), x.set(g, u.x.length), k.set(u.y), k.set(b, u.y.length), i.set(a, { x, y: k });
+        }
+        if (d.enabled && n) {
+          const g = l instanceof Array ? new Float32Array(l) : typeof l == "number" ? new Float32Array([l]) : l, b = new Float32Array(g.length), [x, k] = n.domain, y = k - x;
+          for (let A = 0; A < g.length; A++)
+            b[A] = x + n.mapToRatio(g[A]) * y;
+          s._originalAppendData(a, b, m);
+        } else
+          s._originalAppendData(a, l, m);
+      }, d.enabled) {
+        o = s.xScale;
+        const a = d.axes.default || d.axes.xAxis;
+        n = new w(o, (a == null ? void 0 : a.breaks) || []), s.setXScale(n);
+      }
+    },
+    onDestroy() {
+      if (e) {
+        const t = e.chart;
+        delete t.brokenAxis, o && t.setXScale(o), t.updateSeries = t._originalUpdateSeries, t.addSeries = t._originalAddSeries, t.appendData = t._originalAppendData, delete t._originalUpdateSeries, delete t._originalAddSeries, delete t._originalAppendData;
+      }
+      e = null, i.clear();
+    },
+    onRenderOverlay(t) {
+      d.enabled && p(t);
+    },
+    onViewChange() {
+      d.enabled && n && c();
+    },
+    api: S
+  };
+}
+export {
+  _ as PluginBrokenAxis,
+  _ as default
+};
+//# sourceMappingURL=broken-axis.js.map

package/dist/plugins/broken-axis.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"broken-axis.js","sources":["../../src/plugins/broken-axis/BrokenAxisScale.ts","../../src/plugins/broken-axis/index.ts"],"sourcesContent":["import type { Scale } from \"../../scales\";\nimport type { AxisBreak } from \"./types\";\n\nexport class BrokenAxisScale implements Scale {\n  public domain: [number, number] = [0, 1];\n  public range: [number, number] = [0, 100];\n  public readonly type = \"linear\"; // Compatible with linear for renderer selection\n\n  private underlying: Scale;\n  private sortedBreaks: AxisBreak[] = [];\n  private visibleRanges: { start: number; end: number; pixelOffset: number; pixelScale: number }[] = [];\n  private availableVisualRatio: number = 1.0;\n\n  constructor(originalScale: Scale, private breaks: AxisBreak[]) {\n    this.underlying = originalScale;\n    this.domain = [...originalScale.domain];\n    this.range = [...originalScale.range];\n    this.refresh();\n  }\n\n  setDomain(min: number, max: number): void {\n    this.domain = [min, max];\n    this.underlying.setDomain(min, max);\n    this.refresh();\n  }\n\n  setRange(min: number, max: number): void {\n    this.range = [min, max];\n    this.underlying.setRange(min, max);\n    this.refresh();\n  }\n\n  updateBreaks(breaks: AxisBreak[]) {\n    this.breaks = breaks;\n    this.refresh();\n  }\n\n  private refresh() {\n    const [min, max] = this.domain;\n    \n    // 1. Sort and filter breaks within [min, max]\n    this.sortedBreaks = this.breaks\n      .filter(b => b.start < max && b.end > min)\n      .map(b => ({\n        ...b,\n        start: Math.max(min, b.start),\n        end: Math.min(max, b.end),\n        visualRatio: b.visualRatio ?? 0.02\n      }))\n      .sort((a, b) => a.start - b.start);\n\n    // 2. Identify visible data segments\n    const segments: { start: number; end: number }[] = [];\n    let current = min;\n\n    for (const b of this.sortedBreaks) {\n      if (b.start > current) {\n        segments.push({ start: current, end: b.start });\n      }\n      current = b.end;\n    }\n    if (current < max) {\n      segments.push({ start: current, end: max });\n    }\n\n    // 3. Calculate total data span of visible segments\n    const totalVisibleDataWidth = segments.reduce((sum, s) => sum + (s.end - s.start), 0) || 1e-10;\n    const totalBreakVisualRatio = this.sortedBreaks.reduce((sum, b) => sum + (b.visualRatio || 0.02), 0);\n    this.availableVisualRatio = Math.max(0.1, 1.0 - totalBreakVisualRatio);\n\n    // 4. Calculate mapping for each segment (in 0-1 ratio space)\n    let currentRatioOffset = 0;\n    this.visibleRanges = segments.map(s => {\n      const dataWidth = s.end - s.start;\n      const visualWidth = (dataWidth / totalVisibleDataWidth) * this.availableVisualRatio;\n      const range = {\n        start: s.start,\n        end: s.end,\n        pixelOffset: currentRatioOffset,\n        pixelScale: visualWidth / dataWidth\n      };\n      \n      // Find following break if any to advance offset\n      const nextBreak = this.sortedBreaks.find(b => Math.abs(b.start - s.end) < 1e-10);\n      currentRatioOffset += visualWidth + (nextBreak?.visualRatio ?? 0);\n      \n      return range;\n    });\n  }\n\n  transform(value: number): number {\n    const [min, max] = this.domain;\n    const [r0, r1] = this.range;\n    const isReverse = r1 < r0;\n    \n    let ratio = 0;\n    if (value <= min) ratio = 0;\n    else if (value >= max) ratio = 1;\n    else {\n        let found = false;\n        // Check visible segments\n        for (const range of this.visibleRanges) {\n          if (value >= range.start && value <= range.end) {\n            ratio = range.pixelOffset + (value - range.start) * range.pixelScale;\n            found = true;\n            break;\n          }\n        }\n        \n        // If in break\n        if (!found) {\n            for (const b of this.sortedBreaks) {\n              if (value >= b.start && value <= b.end) {\n                const prevRange = this.visibleRanges.find(r => Math.abs(r.end - b.start) < 1e-10);\n                const offset = prevRange ? prevRange.pixelOffset + (prevRange.end - prevRange.start) * prevRange.pixelScale : 0;\n                ratio = offset + (value - b.start) / (b.end - b.start) * (b.visualRatio ?? 0.02);\n                found = true;\n                break;\n              }\n            }\n        }\n        \n        if (!found) ratio = 0;\n    }\n\n    // Map ratio to pixels\n    return isReverse ? r0 - ratio * (r0 - r1) : r0 + ratio * (r1 - r0);\n  }\n\n  /** Map data value to 0-1 ratio space (handles breaks) */\n  mapToRatio(value: number): number {\n    const [min, max] = this.domain;\n    if (value <= min) return 0;\n    if (value >= max) return 1;\n\n    for (const range of this.visibleRanges) {\n      if (value >= range.start && value <= range.end) {\n        return range.pixelOffset + (value - range.start) * range.pixelScale;\n      }\n    }\n\n    for (const b of this.sortedBreaks) {\n      if (value >= b.start && value <= b.end) {\n        const prevRange = this.visibleRanges.find(r => Math.abs(r.end - b.start) < 1e-10);\n        const offset = prevRange ? prevRange.pixelOffset + (prevRange.end - prevRange.start) * prevRange.pixelScale : 0;\n        return offset + (value - b.start) / (b.end - b.start) * (b.visualRatio ?? 0.02);\n      }\n    }\n\n    return 0;\n  }\n\n  invert(pixel: number): number {\n    const [r0, r1] = this.range;\n    const ratio = (pixel - r0) / (r1 - r0);\n    \n    const r = Math.max(0, Math.min(1, ratio));\n\n    for (const range of this.visibleRanges) {\n      const visualEnd = range.pixelOffset + (range.end - range.start) * range.pixelScale;\n      if (r >= range.pixelOffset && r <= visualEnd) {\n        return range.start + (r - range.pixelOffset) / range.pixelScale;\n      }\n    }\n\n    // In break, return nearest segment boundary\n    for (let i = 0; i < this.sortedBreaks.length; i++) {\n        const b = this.sortedBreaks[i];\n        const prevRange = this.visibleRanges.find(range => Math.abs(range.end - b.start) < 1e-10);\n        const offset = prevRange ? prevRange.pixelOffset + (prevRange.end - prevRange.start) * prevRange.pixelScale : 0;\n        if (r >= offset && r <= offset + (b.visualRatio ?? 0.02)) {\n            return b.start;\n        }\n    }\n\n    return this.domain[0];\n  }\n\n  ticks(count: number = 10): number[] {\n    // Generate ticks for each visible segment based on their visual weight\n    const allTicks: number[] = [];\n    \n    for (const range of this.visibleRanges) {\n        const visualWeight = (range.end - range.start) / (this.domain[1] - this.domain[0]);\n        const segmentCount = Math.max(2, Math.round(count * visualWeight / this.availableVisualRatio));\n        \n        // Use underlying logic for \"nice\" steps but restricted to this range\n        const segmentTicks = this.generateSegmentTicks(range.start, range.end, segmentCount);\n        allTicks.push(...segmentTicks);\n    }\n\n    // Remove duplicates and sort\n    return Array.from(new Set(allTicks)).sort((a, b) => a - b);\n  }\n\n  private generateSegmentTicks(min: number, max: number, count: number): number[] {\n      const range = max - min;\n      if (range <= 0 || !isFinite(range)) return [];\n      \n      // Re-use niceStep logic\n      const rawStep = range / count;\n      const magnitude = Math.pow(10, Math.floor(Math.log10(rawStep)));\n      const normalized = rawStep / magnitude;\n      let step: number;\n      if (normalized < 1.5) step = 1; else if (normalized < 3) step = 2; else if (normalized < 7) step = 5; else step = 10;\n      step *= magnitude;\n\n      const start = Math.ceil(min / step) * step;\n      const ticks: number[] = [];\n      let t = start;\n      while (t <= max + step * 0.1) {\n          ticks.push(Math.round(t * 1e12) / 1e12);\n          t += step;\n      }\n      return ticks;\n  }\n}\n","/**\n * @fileoverview Broken Axis plugin for displaying discontinuous data ranges.\n * @module plugins/broken-axis\n */\n\nimport type {\n  PluginBrokenAxisConfig,\n  BrokenAxisAPI,\n  AxisBreak,\n} from './types';\nimport type {\n  ChartPlugin,\n  PluginContext,\n  PluginManifest,\n} from '../types';\nimport { BrokenAxisScale } from './BrokenAxisScale';\n\nconst manifest: PluginManifest = {\n  name: 'velo-plot-broken-axis',\n  version: '1.0.1',\n  description: 'Support for gaps/breaks in axes with visual indicators',\n  provides: ['broken-axis', 'coordinate-transform'],\n  tags: ['axis', 'layout', 'visualization'],\n};\n\nexport function PluginBrokenAxis(\n  config: PluginBrokenAxisConfig = { axes: {} }\n): ChartPlugin<PluginBrokenAxisConfig> {\n  // Default enabled to true if not specified\n  if (config.enabled === undefined) config.enabled = true;\n  \n  let ctx: PluginContext | null = null;\n  let originalXScale: any = null;\n  let brokenXScale: BrokenAxisScale | null = null;\n  \n  // Storage for raw data of series to allow re-transformation on zoom\n  const rawDataStore = new Map<string, { x: Float32Array; y: Float32Array }>();\n\n  function updateScales() {\n    if (!ctx || !config.enabled) return;\n    \n    const options = config.axes.default || config.axes.xAxis;\n    if (options && brokenXScale) {\n        brokenXScale.updateBreaks(options.breaks);\n        // On break change, we must re-transform everything\n        applyTransformations();\n    }\n  }\n\n  function applyTransformations() {\n      if (!ctx || !brokenXScale || !config.enabled) return;\n      const chart = ctx.chart as any;\n      const [min, max] = brokenXScale.domain;\n      const range = max - min;\n\n      for (const [id, raw] of rawDataStore.entries()) {\n          const transformedX = new Float32Array(raw.x.length);\n          for (let i = 0; i < raw.x.length; i++) {\n              transformedX[i] = min + brokenXScale.mapToRatio(raw.x[i]) * range;\n          }\n          // Call the TRUE underlying updateSeries to avoid hijacking loop\n          if (chart._originalUpdateSeries) {\n              chart._originalUpdateSeries(id, { x: transformedX, y: raw.y });\n          }\n      }\n  }\n\n  function drawBreakSymbols(pCtx: PluginContext) {\n    const { render } = pCtx;\n    const { ctx2d, plotArea } = render;\n    if (!ctx2d || !brokenXScale) return;\n\n    for (const [axisId, options] of Object.entries(config.axes)) {\n        const orientation = (axisId === 'default' || axisId === 'xAxis') ? 'horizontal' : 'vertical';\n        if (orientation !== 'horizontal') continue;\n\n        options.breaks.forEach(b => {\n             const pxStart = brokenXScale!.transform(b.start);\n             const pxEnd = brokenXScale!.transform(b.end);\n             const midPx = (pxStart + pxEnd) / 2;\n\n             ctx2d.save();\n             ctx2d.lineWidth = 1;\n             ctx2d.strokeStyle = options.symbolColor || '#ff00ff';\n\n             if (orientation === 'horizontal') {\n                drawSymbol(ctx2d, midPx, plotArea.y, options.defaultSymbol || 'diagonal', 'top');\n                drawSymbol(ctx2d, midPx, plotArea.y + plotArea.height, options.defaultSymbol || 'diagonal', 'bottom');\n             }\n             ctx2d.restore();\n        });\n    }\n  }\n\n  function drawSymbol(ctx: CanvasRenderingContext2D, x: number, y: number, type: string, edge: string) {\n      const size = 6;\n      ctx.beginPath();\n      if (type === 'diagonal') {\n          ctx.moveTo(x - size, y + size/2);\n          ctx.lineTo(x + size, y - size/2);\n          ctx.moveTo(x - size + 3, y + size/2);\n          ctx.lineTo(x + size + 3, y - size/2);\n      } else if (type === 'zigzag') {\n          ctx.moveTo(x - size, y);\n          ctx.lineTo(x - size/2, y - size/2);\n          ctx.lineTo(x + size/2, y + size/2);\n          ctx.lineTo(x + size, y);\n      } else {\n          if (edge === 'top' || edge === 'bottom') {\n              ctx.moveTo(x - size, y - 2); ctx.lineTo(x + size, y + 2);\n              ctx.moveTo(x - size, y - 6); ctx.lineTo(x + size, y - 2);\n          } else {\n              ctx.moveTo(x - 2, y - size); ctx.lineTo(x + 2, y + size);\n          }\n      }\n      ctx.stroke();\n  }\n\n  const api: BrokenAxisAPI = {\n      addBreak(axisId, b) {\n          if (!config.axes[axisId]) config.axes[axisId] = { breaks: [] };\n          config.axes[axisId].breaks.push(b);\n          updateScales();\n          ctx?.requestRender();\n      },\n      clearBreaks(axisId) {\n          if (config.axes[axisId]) config.axes[axisId].breaks = [];\n          updateScales();\n          ctx?.requestRender();\n      },\n      setEnabled(enabled: boolean) {\n          const wasEnabled = config.enabled;\n          config.enabled = enabled;\n          \n          if (ctx && wasEnabled !== enabled) {\n              const chart = ctx.chart;\n              if (enabled) {\n                  originalXScale = (chart as any).xScale;\n                  brokenXScale = new BrokenAxisScale(originalXScale, (config.axes.default || config.axes.xAxis)?.breaks || []);\n                  chart.setXScale(brokenXScale);\n                  applyTransformations();\n              } else {\n                  if (originalXScale) {\n                      chart.setXScale(originalXScale);\n                      brokenXScale = null;\n                      // Restore original data to series\n                      for (const [id, raw] of rawDataStore.entries()) {\n                          (chart as any)._originalUpdateSeries(id, raw);\n                      }\n                  }\n              }\n          }\n          ctx?.requestRender();\n      },\n      getBreaks(axisId: string): AxisBreak[] {\n          return config.axes[axisId]?.breaks || [];\n      },\n      updateConfig(newConfig: Partial<PluginBrokenAxisConfig>) {\n          Object.assign(config, newConfig);\n          updateScales();\n          ctx?.requestRender();\n      }\n  };\n\n  const pluginApi: BrokenAxisAPI & Record<string, unknown> = api as any;\n\n  return {\n    manifest,\n    onInit(pCtx) {\n      ctx = pCtx;\n      const chart = ctx.chart as any;\n      chart.brokenAxis = pluginApi;\n\n      // Hijack and Save original methods\n      chart._originalUpdateSeries = chart.updateSeries.bind(chart);\n      chart._originalAddSeries = chart.addSeries.bind(chart);\n      chart._originalAppendData = chart.appendData.bind(chart);\n\n      chart.updateSeries = (id: string, data: any) => {\n          if (data.x && data.y) {\n              rawDataStore.set(id, { \n                  x: data.x instanceof Float32Array ? data.x : new Float32Array(data.x), \n                  y: data.y instanceof Float32Array ? data.y : new Float32Array(data.y) \n              });\n          }\n          \n          if (config.enabled && brokenXScale && data.x) {\n              const x = data.x;\n              const transformedX = new Float32Array(x.length);\n              const [min, max] = brokenXScale.domain;\n              const range = max - min;\n              for (let i = 0; i < x.length; i++) {\n                  transformedX[i] = min + brokenXScale.mapToRatio(x[i]) * range;\n              }\n              chart._originalUpdateSeries(id, { ...data, x: transformedX });\n          } else {\n              chart._originalUpdateSeries(id, data);\n          }\n      };\n\n      chart.addSeries = (options: any) => {\n          if (options.id && options.data?.x && options.data?.y) {\n               rawDataStore.set(options.id, { \n                   x: options.data.x instanceof Float32Array ? options.data.x : new Float32Array(options.data.x), \n                   y: options.data.y instanceof Float32Array ? options.data.y : new Float32Array(options.data.y) \n               });\n          }\n          \n          if (config.enabled && brokenXScale && options.data?.x) {\n              const x = options.data.x;\n              const transformedX = new Float32Array(x.length);\n              const [min, max] = brokenXScale.domain;\n              const range = max - min;\n              for (let i = 0; i < x.length; i++) {\n                  transformedX[i] = min + brokenXScale.mapToRatio(x[i]) * range;\n              }\n              chart._originalAddSeries({ ...options, data: { ...options.data, x: transformedX } });\n          } else {\n              chart._originalAddSeries(options);\n          }\n      };\n\n      chart.appendData = (id: string, x: any, y: any) => {\n          const raw = rawDataStore.get(id);\n          if (raw) {\n              const newX = x instanceof Float32Array ? x : [x];\n              const newY = y instanceof Float32Array ? y : [y];\n              const combinedX = new Float32Array(raw.x.length + newX.length);\n              const combinedY = new Float32Array(raw.y.length + newY.length);\n              combinedX.set(raw.x);\n              combinedX.set(newX, raw.x.length);\n              combinedY.set(raw.y);\n              combinedY.set(newY, raw.y.length);\n              rawDataStore.set(id, { x: combinedX, y: combinedY });\n          }\n\n          if (config.enabled && brokenXScale) {\n              const xArr = x instanceof Array ? new Float32Array(x) : (typeof x === 'number' ? new Float32Array([x]) : x);\n              const transformedX = new Float32Array(xArr.length);\n              const [min, max] = brokenXScale.domain;\n              const range = max - min;\n              for (let i = 0; i < xArr.length; i++) {\n                  transformedX[i] = min + brokenXScale.mapToRatio(xArr[i]) * range;\n              }\n              chart._originalAppendData(id, transformedX, y);\n          } else {\n              chart._originalAppendData(id, x, y);\n          }\n      };\n\n      if (config.enabled) {\n          originalXScale = chart.xScale; \n          const options = config.axes.default || config.axes.xAxis;\n          brokenXScale = new BrokenAxisScale(originalXScale, options?.breaks || []);\n          chart.setXScale(brokenXScale);\n      }\n    },\n    onDestroy() {\n        if (ctx) {\n            const chart = (ctx.chart as any);\n            delete chart.brokenAxis;\n            if (originalXScale) {\n                chart.setXScale(originalXScale);\n            }\n            // CLEANUP hijacked methods\n            chart.updateSeries = chart._originalUpdateSeries;\n            chart.addSeries = chart._originalAddSeries;\n            chart.appendData = chart._originalAppendData;\n            delete chart._originalUpdateSeries;\n            delete chart._originalAddSeries;\n            delete chart._originalAppendData;\n        }\n        ctx = null;\n        rawDataStore.clear();\n    },\n    onRenderOverlay(pCtx) {\n        if (config.enabled) drawBreakSymbols(pCtx);\n    },\n    onViewChange() {\n        if (config.enabled && brokenXScale) {\n            applyTransformations();\n        }\n    },\n    api: pluginApi\n  };\n}\n\nexport default PluginBrokenAxis;\n\nexport type {\n  PluginBrokenAxisConfig,\n  BrokenAxisAPI,\n  AxisBreak,\n  BrokenAxisOptions,\n} from './types';\n"],"names":["BrokenAxisScale","originalScale","breaks","__publicField","min","max","b","a","segments","current","totalVisibleDataWidth","sum","s","totalBreakVisualRatio","currentRatioOffset","dataWidth","visualWidth","range","nextBreak","value","r0","r1","isReverse","ratio","found","prevRange","r","pixel","visualEnd","i","offset","count","allTicks","visualWeight","segmentCount","segmentTicks","rawStep","magnitude","normalized","step","start","ticks","manifest","PluginBrokenAxis","config","ctx","originalXScale","brokenXScale","rawDataStore","updateScales","options","applyTransformations","chart","id","raw","transformedX","drawBreakSymbols","pCtx","render","ctx2d","plotArea","axisId","orientation","pxStart","pxEnd","midPx","drawSymbol","x","y","type","edge","pluginApi","enabled","_a","wasEnabled","newConfig","data","_b","_c","newX","newY","combinedX","combinedY","xArr"],"mappings":"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"}

package/dist/plugins/caching.d.ts

@@ -0,0 +1,3 @@
+export * from './caching/index'
+import SciPlot from './caching/index'
+export default SciPlot