velo-plot 1.11.1

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

@@ -0,0 +1,6 @@
+/**
+ * @fileoverview Broken Axis plugin exports
+ * @module plugins/broken-axis
+ */
+export { PluginBrokenAxis, default } from './index';
+export type { PluginBrokenAxisConfig, BrokenAxisAPI, AxisBreak, BrokenAxisOptions, } from './types';

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

@@ -0,0 +1,6 @@
+import { PluginBrokenAxisConfig } from './types';
+import { ChartPlugin } from '../types';
+
+export declare function PluginBrokenAxis(config?: PluginBrokenAxisConfig): ChartPlugin<PluginBrokenAxisConfig>;
+export default PluginBrokenAxis;
+export type { PluginBrokenAxisConfig, BrokenAxisAPI, AxisBreak, BrokenAxisOptions, } from './types';

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

@@ -0,0 +1,50 @@
+/**
+ * @fileoverview Types for Broken Axis plugin
+ * @module plugins/broken-axis/types
+ */
+export type AxisBreakSymbol = "diagonal" | "zigzag" | "wave" | "simple";
+export interface AxisBreak {
+    /** Start value of the break in data units */
+    start: number;
+    /** End value of the break in data units */
+    end: number;
+    /**
+     * Ratio of the plot area this break should take (0-1).
+     * Usually small (e.g., 0.02 for 2% of the axis length).
+     * Default is 0.02.
+     */
+    visualRatio?: number;
+    /** Visual symbol to draw at the break */
+    symbol?: AxisBreakSymbol;
+}
+export interface BrokenAxisOptions {
+    /** Array of breaks defined for the axis */
+    breaks: AxisBreak[];
+    /** Default symbol for all breaks in this axis if not specified */
+    defaultSymbol?: AxisBreakSymbol;
+    /** Color of the break symbols (defaults to axis color) */
+    symbolColor?: string;
+    /** Size of the symbol in pixels (width/height depending on orientation) */
+    symbolSize?: number;
+}
+export interface PluginBrokenAxisConfig {
+    /** Enable broken axes (default: true) */
+    enabled?: boolean;
+    /**
+     * Mapping of axis ID to its broken axis configuration.
+     * Use 'default' for the main X axis.
+     */
+    axes: Record<string, BrokenAxisOptions>;
+}
+export interface BrokenAxisAPI {
+    /** Add a break to an axis */
+    addBreak(axisId: string, axisBreak: AxisBreak): void;
+    /** Remove all breaks from an axis */
+    clearBreaks(axisId: string): void;
+    /** Enable/disable the plugin */
+    setEnabled(enabled: boolean): void;
+    /** Get current breaks for an axis */
+    getBreaks(axisId: string): AxisBreak[];
+    /** Update configuration */
+    updateConfig(config: Partial<PluginBrokenAxisConfig>): void;
+}

package/dist/plugins/builtins/crosshair/CrosshairPlugin.d.ts

@@ -0,0 +1,40 @@
+import { CrosshairValueMode, CornerPosition } from '../../../core/layout';
+
+export interface CrosshairPluginConfig {
+    /** Show vertical line (default: true) */
+    showVertical?: boolean;
+    /** Show horizontal line (default: true) */
+    showHorizontal?: boolean;
+    /** Line color (default: from theme) */
+    color?: string;
+    /** Line style (default: 'dashed') */
+    lineStyle?: "solid" | "dashed" | "dotted";
+    /** Line width (default: 1) */
+    lineWidth?: number;
+    /**
+     * @deprecated Use valueDisplayMode instead
+     * Show axis labels (will be converted to valueDisplayMode)
+     */
+    showAxisLabels?: boolean;
+    /**
+     * Display mode for X,Y coordinate values (default: 'disabled')
+     * - 'disabled': Never show coordinate values
+     * - 'corner': Show values in a fixed corner position
+     * - 'floating': Show values next to the cursor (axis labels)
+     */
+    valueDisplayMode?: CrosshairValueMode;
+    /**
+     * Corner position when valueDisplayMode is 'corner' (default: 'top-left')
+     */
+    cornerPosition?: CornerPosition;
+    /** Snap to nearest data point (default: false) */
+    snapToData?: boolean;
+    /** Value format options */
+    valueFormat?: {
+        /** X value precision (default: 4) */
+        xPrecision?: number;
+        /** Y value precision (default: 4) */
+        yPrecision?: number;
+    };
+}
+export declare const CrosshairPlugin: import('../..').PluginFactory<CrosshairPluginConfig>;

package/dist/plugins/builtins/crosshair/index.d.ts

@@ -0,0 +1 @@
+export * from './CrosshairPlugin';

package/dist/plugins/builtins/data-logger/DataLoggerPlugin.d.ts

@@ -0,0 +1,11 @@
+export interface DataLoggerConfig {
+    /** Log data updates (default: true) */
+    logDataUpdates?: boolean;
+    /** Log view changes (default: true) */
+    logViewChanges?: boolean;
+    /** Log interactions (default: false) */
+    logInteractions?: boolean;
+    /** Maximum log entries to keep (default: 100) */
+    maxEntries?: number;
+}
+export declare const DataLoggerPlugin: import('../..').PluginFactory<DataLoggerConfig>;

package/dist/plugins/builtins/data-logger/index.d.ts

@@ -0,0 +1 @@
+export * from './DataLoggerPlugin';

package/dist/plugins/builtins/direction-indicator/DirectionIndicatorPlugin.d.ts

@@ -0,0 +1,17 @@
+export interface DirectionIndicatorConfig {
+    /** Series ID to track (if not specified, tracks the first series) */
+    seriesId?: string;
+    /** Number of recent points to analyze for direction (default: 20) */
+    sampleSize?: number;
+    /** Arrow color (default: from theme) */
+    color?: string;
+    /** Arrow size in pixels (default: 40) */
+    size?: number;
+    /** Minimum velocity to show arrow (default: 0.01) */
+    minVelocity?: number;
+    /** Number of points for smoothing the position/angle (default: 20) */
+    historySize?: number;
+    /** Hide arrow if no new points are received for this duration in ms (default: undefined/disabled) */
+    idleTimeout?: number;
+}
+export declare const DirectionIndicatorPlugin: import('../..').PluginFactory<DirectionIndicatorConfig>;

package/dist/plugins/builtins/direction-indicator/index.d.ts

@@ -0,0 +1,2 @@
+export { DirectionIndicatorPlugin } from './DirectionIndicatorPlugin';
+export type { DirectionIndicatorConfig } from './DirectionIndicatorPlugin';

package/dist/plugins/builtins/grid-highlight/GridHighlightPlugin.d.ts

@@ -0,0 +1,17 @@
+export interface GridHighlightConfig {
+    /** Highlight intervals on X axis */
+    xIntervals?: Array<{
+        start: number;
+        end: number;
+        color: string;
+    }>;
+    /** Highlight intervals on Y axis */
+    yIntervals?: Array<{
+        start: number;
+        end: number;
+        color: string;
+    }>;
+    /** Opacity for highlight regions (default: 0.1) */
+    opacity?: number;
+}
+export declare const GridHighlightPlugin: import('../..').PluginFactory<GridHighlightConfig>;

package/dist/plugins/builtins/grid-highlight/index.d.ts

@@ -0,0 +1 @@
+export * from './GridHighlightPlugin';

package/dist/plugins/builtins/index.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Sci Plot - Built-in Plugins
+ *
+ * Collection of official plugins that demonstrate the plugin system
+ * capabilities and provide common functionality.
+ *
+ * @module plugins/builtins
+ */
+export * from './crosshair';
+export * from './stats';
+export * from './watermark';
+export * from './grid-highlight';
+export * from './data-logger';
+export * from './direction-indicator';
+/**
+ * Plugin collection for easy registration
+ */
+export declare const BuiltinPlugins: {
+    Crosshair: import('..').PluginFactory<import('./crosshair').CrosshairPluginConfig>;
+    Statistics: import('..').PluginFactory<import('./stats').StatsPluginConfig>;
+    Watermark: import('..').PluginFactory<import('./watermark').WatermarkPluginConfig>;
+    GridHighlight: import('..').PluginFactory<import('./grid-highlight').GridHighlightConfig>;
+    DataLogger: import('..').PluginFactory<import('./data-logger').DataLoggerConfig>;
+    DirectionIndicator: import('..').PluginFactory<import('./direction-indicator').DirectionIndicatorConfig>;
+};

package/dist/plugins/builtins/stats/StatsPlugin.d.ts

@@ -0,0 +1,11 @@
+export interface StatsPluginConfig {
+    /** Position of the stats overlay */
+    position?: "top-left" | "top-right" | "bottom-left" | "bottom-right";
+    /** Which stats to show */
+    show?: Array<"count" | "mean" | "min" | "max" | "std" | "range">;
+    /** Series ID to compute stats for (default: all) */
+    seriesId?: string;
+    /** Update on every data change (default: true) */
+    autoUpdate?: boolean;
+}
+export declare const StatsPlugin: import('../..').PluginFactory<StatsPluginConfig>;

package/dist/plugins/builtins/stats/index.d.ts

@@ -0,0 +1 @@
+export * from './StatsPlugin';

package/dist/plugins/builtins/watermark/WatermarkPlugin.d.ts

@@ -0,0 +1,15 @@
+export interface WatermarkPluginConfig {
+    /** Watermark text */
+    text: string;
+    /** Font size (default: 48) */
+    fontSize?: number;
+    /** Font family (default: system-ui) */
+    fontFamily?: string;
+    /** Text color with opacity (default: rgba(128,128,128,0.15)) */
+    color?: string;
+    /** Position (default: center) */
+    position?: "center" | "bottom-right" | "bottom-left";
+    /** Rotation in degrees (default: -30 for center, 0 for corners) */
+    rotation?: number;
+}
+export declare const WatermarkPlugin: import('../..').PluginFactory<WatermarkPluginConfig>;

package/dist/plugins/builtins/watermark/index.d.ts

@@ -0,0 +1 @@
+export * from './WatermarkPlugin';

package/dist/plugins/caching/exports.d.ts

@@ -0,0 +1,6 @@
+/**
+ * @fileoverview Caching plugin exports
+ * @module plugins/caching
+ */
+export { PluginCaching, default } from './index';
+export type { PluginCachingConfig, CachingAPI, CacheEntry, CacheStats, CacheStrategy, CacheInvalidationEvent, } from './types';

package/dist/plugins/caching/index.d.ts

@@ -0,0 +1,6 @@
+import { PluginCachingConfig } from './types';
+import { ChartPlugin } from '../types';
+
+export declare function PluginCaching(userConfig?: Partial<PluginCachingConfig>): ChartPlugin<PluginCachingConfig>;
+export default PluginCaching;
+export type { PluginCachingConfig, CachingAPI, CacheEntry, CacheStats, CacheStrategy, CacheInvalidationEvent, } from './types';

package/dist/plugins/caching/types.d.ts

@@ -0,0 +1,120 @@
+/**
+ * @fileoverview Types for caching plugin
+ * @module plugins/caching/types
+ */
+/**
+ * Cache entry with metadata
+ */
+export interface CacheEntry<T = any> {
+    /** Cached value */
+    value: T;
+    /** Timestamp when cached */
+    timestamp: number;
+    /** Last access timestamp */
+    lastAccess: number;
+    /** Access count */
+    hits: number;
+    /** Approximate size in bytes */
+    size: number;
+    /** Optional TTL (time to live) in ms */
+    ttl?: number;
+    /** Optional tags for bulk invalidation */
+    tags?: string[];
+}
+/**
+ * Cache statistics
+ */
+export interface CacheStats {
+    /** Total cache hits */
+    hits: number;
+    /** Total cache misses */
+    misses: number;
+    /** Hit ratio (0-1) */
+    hitRatio: number;
+    /** Current cache size in bytes */
+    currentSize: number;
+    /** Maximum cache size in bytes */
+    maxSize: number;
+    /** Number of entries */
+    entryCount: number;
+    /** Number of evictions */
+    evictions: number;
+}
+/**
+ * Cache strategy
+ */
+export type CacheStrategy = 'lru' | 'lfu' | 'fifo';
+/**
+ * Cache invalidation event
+ */
+export interface CacheInvalidationEvent {
+    /** Keys invalidated */
+    keys: string[];
+    /** Reason for invalidation */
+    reason: 'manual' | 'ttl' | 'size' | 'tag';
+    /** Timestamp */
+    timestamp: number;
+}
+/**
+ * Plugin configuration
+ */
+export interface PluginCachingConfig {
+    /** Enable caching (default: true) */
+    enabled?: boolean;
+    /** Maximum cache size in bytes (default: 50MB) */
+    maxSize?: number;
+    /** Cache strategy (default: 'lru') */
+    strategy?: CacheStrategy;
+    /** Default TTL in milliseconds (default: undefined = no expiration) */
+    defaultTTL?: number;
+    /** Enable automatic invalidation on data changes (default: true) */
+    autoInvalidate?: boolean;
+    /** Cache specific data types */
+    cacheTypes?: {
+        /** Cache transformed data (default: true) */
+        transforms?: boolean;
+        /** Cache analysis results (default: true) */
+        analysis?: boolean;
+        /** Cache rendered frames (default: false) */
+        frames?: boolean;
+        /** Cache computed bounds (default: true) */
+        bounds?: boolean;
+    };
+    /** Callback when cache is invalidated */
+    onInvalidate?: (event: CacheInvalidationEvent) => void;
+    /** Enable debug logging (default: false) */
+    debug?: boolean;
+}
+/**
+ * Plugin API
+ */
+export interface CachingAPI {
+    /** Get value from cache */
+    get<T>(key: string): T | undefined;
+    /** Set value in cache */
+    set<T>(key: string, value: T, options?: {
+        ttl?: number;
+        tags?: string[];
+        size?: number;
+    }): void;
+    /** Check if key exists */
+    has(key: string): boolean;
+    /** Delete specific key */
+    delete(key: string): boolean;
+    /** Clear all cache */
+    clear(): void;
+    /** Invalidate by tags */
+    invalidateByTags(tags: string[]): number;
+    /** Get cache statistics */
+    getStats(): CacheStats;
+    /** Reset statistics */
+    resetStats(): void;
+    /** Get all keys */
+    keys(): string[];
+    /** Get cache size */
+    size(): number;
+    /** Prune expired entries */
+    prune(): number;
+    /** Update configuration */
+    updateConfig(config: Partial<PluginCachingConfig>): void;
+}

package/dist/plugins/clipboard/index.d.ts

@@ -0,0 +1,20 @@
+import { ChartPlugin } from '../types';
+/**
+ * SciPlot Engine - Clipboard Plugin
+ *
+ * Provides clipboard integration for copying chart data and images.
+ *
+ * @module plugins/clipboard
+ */
+export * from '../../core/clipboard';
+export interface PluginClipboardConfig {
+    /** Default format for copied data: 'csv' | 'json' | 'image' */
+    defaultFormat?: string;
+}
+/**
+ * SciPlot Clipboard Plugin
+ *
+ * Adds support for copying data and screenshots to the clipboard.
+ */
+export declare function PluginClipboard(_config?: PluginClipboardConfig): ChartPlugin<PluginClipboardConfig>;
+export default PluginClipboard;

package/dist/plugins/clipboard.d.ts

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

package/dist/plugins/clipboard.js

@@ -0,0 +1,270 @@
+var b = Object.defineProperty;
+var x = (o, t, e) => t in o ? b(o, t, { enumerable: !0, configurable: !0, writable: !0, value: e }) : o[t] = e;
+var h = (o, t, e) => x(o, typeof t != "symbol" ? t + "" : t, e);
+const g = {
+  tsv: { separator: "	", quote: !1, extension: "tsv" },
+  csv: { separator: ",", quote: !0, extension: "csv" },
+  json: { separator: "", quote: !1, extension: "json" },
+  markdown: { separator: " | ", quote: !1, extension: "md" }
+};
+class N {
+  constructor(t) {
+    h(this, "defaultOptions", {
+      format: "tsv",
+      includeHeaders: !0,
+      precision: 6,
+      scientific: !0,
+      scientificThreshold: 1e6,
+      lineSeparator: `
+`,
+      includeSeriesName: !1
+    });
+    t && (this.defaultOptions = { ...this.defaultOptions, ...t });
+  }
+  /**
+   * Copy data points to clipboard
+   */
+  async copyPoints(t, e) {
+    const i = { ...this.defaultOptions, ...e };
+    if (!t || t.length === 0)
+      return {
+        success: !1,
+        pointCount: 0,
+        seriesCount: 0,
+        error: "No data points to copy"
+      };
+    try {
+      const r = this.formatPoints(t, i);
+      await this.writeToClipboard(r);
+      const s = new Set(t.map((a) => a.seriesId).filter(Boolean));
+      return {
+        success: !0,
+        pointCount: t.length,
+        seriesCount: s.size || 1,
+        text: r
+      };
+    } catch (r) {
+      return {
+        success: !1,
+        pointCount: 0,
+        seriesCount: 0,
+        error: r instanceof Error ? r.message : "Failed to copy to clipboard"
+      };
+    }
+  }
+  /**
+   * Copy series data to clipboard
+   */
+  async copySeries(t, e) {
+    const i = [];
+    for (const s of t)
+      for (let a = 0; a < s.x.length; a++)
+        i.push({
+          x: s.x[a],
+          y: s.y[a],
+          seriesId: s.id,
+          seriesName: s.name || s.id,
+          index: a
+        });
+    const r = { ...e };
+    return t.length > 1 && r.includeSeriesName === void 0 && (r.includeSeriesName = !0), this.copyPoints(i, r);
+  }
+  /**
+   * Format data points to string
+   */
+  formatPoints(t, e) {
+    const i = e.format || "tsv";
+    return i === "json" ? this.formatAsJson(t, e) : i === "markdown" ? this.formatAsMarkdown(t, e) : this.formatAsDelimited(t, e);
+  }
+  /**
+   * Format as delimited text (TSV/CSV)
+   */
+  formatAsDelimited(t, e) {
+    var d, u, c;
+    const i = e.format || "tsv", r = g[i], s = e.separator || r.separator, a = e.lineSeparator || `
+`, l = [];
+    if (e.includeHeaders) {
+      const n = [];
+      e.includeSeriesName && n.push(((d = e.headers) == null ? void 0 : d.series) || "Series"), n.push(((u = e.headers) == null ? void 0 : u.x) || "X"), n.push(((c = e.headers) == null ? void 0 : c.y) || "Y"), l.push(n.join(s));
+    }
+    for (const n of t) {
+      const f = [];
+      if (e.includeSeriesName) {
+        const m = n.seriesName || n.seriesId || "";
+        f.push(r.quote ? `"${m}"` : m);
+      }
+      f.push(this.formatNumber(n.x, e)), f.push(this.formatNumber(n.y, e)), l.push(f.join(s));
+    }
+    return l.join(a);
+  }
+  /**
+   * Format as JSON
+   */
+  formatAsJson(t, e) {
+    const i = t.map((r) => {
+      const s = {
+        x: this.roundNumber(r.x, e.precision || 6),
+        y: this.roundNumber(r.y, e.precision || 6)
+      };
+      return e.includeSeriesName && r.seriesId && (s.series = r.seriesName || r.seriesId), s;
+    });
+    return JSON.stringify(i, null, 2);
+  }
+  /**
+   * Format as Markdown table
+   */
+  formatAsMarkdown(t, e) {
+    var l, d, u;
+    const i = [], r = " | ", s = [];
+    e.includeSeriesName && s.push(((l = e.headers) == null ? void 0 : l.series) || "Series"), s.push(((d = e.headers) == null ? void 0 : d.x) || "X"), s.push(((u = e.headers) == null ? void 0 : u.y) || "Y"), i.push("| " + s.join(r) + " |");
+    const a = s.map(() => "---");
+    i.push("| " + a.join(r) + " |");
+    for (const c of t) {
+      const n = [];
+      e.includeSeriesName && n.push(c.seriesName || c.seriesId || ""), n.push(this.formatNumber(c.x, e)), n.push(this.formatNumber(c.y, e)), i.push("| " + n.join(r) + " |");
+    }
+    return i.join(`
+`);
+  }
+  /**
+   * Format a number for output
+   */
+  formatNumber(t, e) {
+    const i = e.precision ?? 6, r = e.scientificThreshold ?? 1e6;
+    return isFinite(t) ? e.scientific && (Math.abs(t) >= r || Math.abs(t) < 1e-4 && t !== 0) ? t.toExponential(i) : this.roundNumber(t, i).toString() : t.toString();
+  }
+  /**
+   * Round a number to specified precision
+   */
+  roundNumber(t, e) {
+    const i = Math.pow(10, e);
+    return Math.round(t * i) / i;
+  }
+  /**
+   * Write text to system clipboard
+   */
+  async writeToClipboard(t) {
+    navigator.clipboard && navigator.clipboard.writeText ? await navigator.clipboard.writeText(t) : this.fallbackCopyToClipboard(t);
+  }
+  /**
+   * Fallback clipboard copy using hidden textarea
+   */
+  fallbackCopyToClipboard(t) {
+    const e = document.createElement("textarea");
+    e.value = t, e.style.position = "fixed", e.style.left = "-9999px", e.style.top = "-9999px", document.body.appendChild(e), e.focus(), e.select();
+    try {
+      document.execCommand("copy");
+    } finally {
+      document.body.removeChild(e);
+    }
+  }
+  /**
+   * Read from clipboard (for paste functionality)
+   */
+  async readFromClipboard() {
+    if (navigator.clipboard && navigator.clipboard.readText)
+      try {
+        return await navigator.clipboard.readText();
+      } catch {
+        return null;
+      }
+    return null;
+  }
+  /**
+   * Parse clipboard text to data points
+   */
+  parseClipboardData(t, e) {
+    const i = [], r = e || this.detectFormat(t);
+    if (r === "json")
+      return this.parseJson(t);
+    const s = t.trim().split(/\r?\n/), a = r === "csv" ? "," : r === "tsv" ? "	" : ",", d = s.length > 0 && /^[a-zA-Z]/.test(s[0].trim()) ? 1 : 0;
+    for (let u = d; u < s.length; u++) {
+      const c = s[u].split(a).map((n) => n.trim().replace(/^"|"$/g, ""));
+      if (c.length >= 2) {
+        const n = parseFloat(c[0]), f = parseFloat(c[1]);
+        !isNaN(n) && !isNaN(f) && i.push({ x: n, y: f, index: u - d });
+      }
+    }
+    return i;
+  }
+  /**
+   * Detect format from text content
+   */
+  detectFormat(t) {
+    const e = t.trim();
+    return e.startsWith("[") || e.startsWith("{") ? "json" : e.includes("	") ? "tsv" : e.includes(" | ") ? "markdown" : "csv";
+  }
+  /**
+   * Parse JSON data
+   */
+  parseJson(t) {
+    try {
+      const e = JSON.parse(t), i = [], r = Array.isArray(e) ? e : [e];
+      for (let s = 0; s < r.length; s++) {
+        const a = r[s];
+        typeof a.x == "number" && typeof a.y == "number" && i.push({
+          x: a.x,
+          y: a.y,
+          seriesId: a.series || a.seriesId,
+          seriesName: a.seriesName || a.series,
+          index: s
+        });
+      }
+      return i;
+    } catch {
+      return [];
+    }
+  }
+  /**
+   * Set default options
+   */
+  setDefaults(t) {
+    this.defaultOptions = { ...this.defaultOptions, ...t };
+  }
+  /**
+   * Get current default options
+   */
+  getDefaults() {
+    return { ...this.defaultOptions };
+  }
+}
+let p = null;
+function y() {
+  return p || (p = new N()), p;
+}
+async function w(o, t) {
+  return y().copyPoints(o, t);
+}
+function v(o, t) {
+  const e = y();
+  return e.formatPoints(o, { ...e.getDefaults(), ...t });
+}
+const C = {
+  name: "velo-plot-clipboard",
+  version: "1.0.0",
+  description: "Clipboard integration for velo-plot",
+  provides: ["interaction"],
+  tags: ["clipboard", "copy", "paste", "export"]
+};
+function j(o = {}) {
+  return {
+    manifest: C,
+    onInit(t) {
+    },
+    onDestroy(t) {
+    },
+    api: {
+      copyCurrentView() {
+      }
+    }
+  };
+}
+export {
+  N as ClipboardManager,
+  j as PluginClipboard,
+  w as copyToClipboard,
+  j as default,
+  v as formatData,
+  y as getClipboardManager
+};
+//# sourceMappingURL=clipboard.js.map