chartai 0.0.11 → 1.0.0

package/dist/chunk-g6m56ptf.js

@@ -0,0 +1,609 @@
+import {
+  M
+} from "./chunk-93yrr7er.js";
+import {
+  __require
+} from "./chunk-m17t3vjq.js";
+
+// src/chart-library.ts
+class Chart {
+  id;
+  _mgr;
+  constructor(id, mgr) {
+    this.id = id;
+    this._mgr = mgr;
+  }
+  get _c() {
+    return this._mgr["charts"].get(this.id);
+  }
+  setData(series) {
+    this._mgr.updateSeries(this.id, series);
+  }
+  configure(patch) {
+    const c = this._c;
+    if (!c)
+      return;
+    Object.assign(c.config, patch);
+    const uniformNames = new Set((c.renderer.uniforms ?? []).map((u) => u.name));
+    const workerValues = {};
+    for (const key of Object.keys(patch)) {
+      const val = patch[key];
+      if (typeof val === "number" && uniformNames.has(key)) {
+        workerValues[key] = val;
+      }
+    }
+    if (Object.keys(workerValues).length > 0) {
+      Object.assign(c.customUniforms, workerValues);
+      this._mgr["worker"]?.postMessage({
+        type: M.SET_UNIFORMS,
+        id: this.id,
+        values: workerValues
+      });
+    }
+    if ("bgColor" in patch && patch.bgColor !== undefined) {
+      const [r, g, b] = patch.bgColor;
+      const wrap = c.el.querySelector("div");
+      if (wrap)
+        wrap.style.background = `rgb(${Math.round(r * 255)},${Math.round(g * 255)},${Math.round(b * 255)})`;
+      this._mgr["worker"]?.postMessage({
+        type: M.SET_STYLE,
+        id: this.id,
+        bgColor: patch.bgColor
+      });
+    }
+    this._mgr.requestRender(this.id);
+    this._mgr.drawChart(c);
+  }
+  addPlugin(plugin) {
+    const c = this._c;
+    if (!c || c.plugins.some((p) => p.name === plugin.name))
+      return;
+    const wrap = c.el.querySelector("div");
+    plugin.install?.(c, wrap);
+    c.plugins.push(plugin);
+    this._mgr.drawChart(c);
+  }
+  removePlugin(name) {
+    const c = this._c;
+    if (!c)
+      return;
+    const idx = c.plugins.findIndex((p) => p.name === name);
+    if (idx >= 0) {
+      c.plugins[idx].uninstall?.(c);
+      c.plugins.splice(idx, 1);
+      this._mgr.drawChart(c);
+    }
+  }
+  hasPlugin(name) {
+    return this._c?.plugins.some((p) => p.name === name) ?? false;
+  }
+  resetView() {
+    this._mgr.resetView(this.id);
+  }
+  destroy() {
+    this._mgr.destroy(this.id);
+  }
+}
+var _colorEl = null;
+function parseColor(c) {
+  if (typeof c !== "string")
+    return c;
+  if (!_colorEl) {
+    _colorEl = document.createElement("i");
+    _colorEl.style.cssText = "display:none";
+    document.body.appendChild(_colorEl);
+  }
+  _colorEl.style.color = c;
+  const m = getComputedStyle(_colorEl).color.match(/\d+/g);
+  return { r: +m[0] / 255, g: +m[1] / 255, b: +m[2] / 255 };
+}
+function resizeCanvas(canvas, cssW, cssH) {
+  const dpr = devicePixelRatio || 1;
+  canvas.width = Math.round(cssW * dpr);
+  canvas.height = Math.round(cssH * dpr);
+  if (canvas instanceof HTMLCanvasElement) {
+    canvas.style.width = `${cssW}px`;
+    canvas.style.height = `${cssH}px`;
+  }
+}
+
+class _ChartManager {
+  static instance = null;
+  worker = null;
+  charts = new Map;
+  renderers = new Map;
+  uiPlugins = [];
+  pendingRenderers = [];
+  chartIdCounter = 0;
+  _isDark = false;
+  _syncViews = false;
+  statsCallbacks = [];
+  currentStats = {
+    fps: 0,
+    renderMs: 0,
+    total: 0,
+    active: 0
+  };
+  visibilityObserver;
+  resizeObserver;
+  constructor() {
+    this._isDark = document.documentElement.classList.contains("dark");
+    this.visibilityObserver = new IntersectionObserver((entries) => {
+      for (const e of entries) {
+        const id = e.target.dataset.chartId;
+        if (!id)
+          continue;
+        const chart = this.charts.get(id);
+        if (!chart)
+          continue;
+        chart.visible = e.isIntersecting;
+        this.worker?.postMessage({
+          type: M.SET_VISIBILITY,
+          id,
+          visible: e.isIntersecting
+        });
+        if (e.isIntersecting)
+          this.drawChart(chart);
+      }
+    }, { threshold: 0.01 });
+    this.resizeObserver = new ResizeObserver((entries) => {
+      for (const e of entries) {
+        const id = e.target.dataset.chartId;
+        if (!id)
+          continue;
+        const chart = this.charts.get(id);
+        if (!chart)
+          continue;
+        const { width, height } = e.contentRect;
+        if (width <= 0 || height <= 0)
+          continue;
+        chart.width = width;
+        chart.height = height;
+        const dpr = devicePixelRatio || 1;
+        resizeCanvas(chart.backCanvas, width, height);
+        resizeCanvas(chart.frontCanvas, width, height);
+        const { bufferSizes, perSeriesPassMeta } = this.computeRendererMeta(chart.renderer, chart);
+        this.worker?.postMessage({
+          type: M.RESIZE,
+          id,
+          width: Math.round(width * dpr),
+          height: Math.round(height * dpr),
+          bufferSizes,
+          perSeriesPassMeta
+        });
+        this.drawChart(chart);
+      }
+    });
+  }
+  static getInstance() {
+    if (!_ChartManager.instance)
+      _ChartManager.instance = new _ChartManager;
+    return _ChartManager.instance;
+  }
+  get isDark() {
+    return this._isDark;
+  }
+  get syncViews() {
+    return this._syncViews;
+  }
+  use(plugin) {
+    if ("passes" in plugin) {
+      const r = plugin;
+      this.renderers.set(r.name, r);
+      if (this.worker)
+        this.sendRendererRegistration(r);
+      else
+        this.pendingRenderers.push(r);
+    } else {
+      const p = plugin;
+      if (!this.uiPlugins.some((x) => x.name === p.name))
+        this.uiPlugins.push(p);
+    }
+  }
+  async init() {
+    if (this.worker)
+      return true;
+    return new Promise((resolve) => {
+      import("./worker-inline.js").then(({ WORKER_CODE }) => {
+        const blob = new Blob([WORKER_CODE], {
+          type: "application/javascript"
+        });
+        this.worker = new Worker(URL.createObjectURL(blob), {
+          type: "module"
+        });
+        this.setupWorkerHandlers(resolve);
+      }).catch(() => {
+        this.worker = new Worker(new URL("./gpu-worker.js", import.meta.url), { type: "module" });
+        this.setupWorkerHandlers(resolve);
+      });
+    });
+  }
+  setupWorkerHandlers(resolve) {
+    if (!this.worker)
+      return;
+    this.worker.onmessage = (e) => {
+      const { type, ...data } = e.data;
+      switch (type) {
+        case M.GPU_READY:
+          for (const r of this.pendingRenderers)
+            this.sendRendererRegistration(r);
+          this.pendingRenderers = [];
+          resolve(true);
+          break;
+        case M.ERROR:
+          console.error("chartai:", data.code);
+          resolve(false);
+          break;
+        case M.STATS:
+          this.currentStats = {
+            fps: data.fps,
+            renderMs: data.renderMs,
+            total: data.totalCharts,
+            active: data.activeCharts
+          };
+          for (const cb of this.statsCallbacks)
+            cb(this.currentStats);
+          break;
+      }
+    };
+    this.worker.onerror = (e) => {
+      console.error("chartai:", e);
+      resolve(false);
+    };
+    this.worker.postMessage({ type: M.INIT, isDark: this._isDark });
+  }
+  sendRendererRegistration(renderer) {
+    const bufferDefs = (renderer.buffers ?? []).map((buf) => ({
+      name: buf.name,
+      usages: buf.usages,
+      perSeries: renderer.passes.some((p) => p.perSeries !== false && p.bindings.some((b) => b.source === buf.name))
+    }));
+    this.worker?.postMessage({
+      type: M.REGISTER_RENDERER,
+      name: renderer.name,
+      shaders: renderer.shaders,
+      passes: renderer.passes.map((p) => ({
+        type: p.type,
+        shader: p.shader,
+        bindings: p.bindings,
+        perSeries: p.perSeries !== false,
+        topology: p.topology,
+        loadOp: p.loadOp,
+        blend: p.blend
+      })),
+      bufferDefs,
+      uniformDefs: renderer.uniforms ?? []
+    });
+  }
+  computeRendererMeta(renderer, chart) {
+    const bufferSizes = {};
+    const perSeriesPassMeta = [];
+    const series = chart.series.length > 0 ? chart.series : [
+      {
+        rawX: [],
+        rawY: [],
+        extra: {},
+        label: "",
+        color: { r: 0, g: 0, b: 0 }
+      }
+    ];
+    const dpr = devicePixelRatio || 1;
+    const physW = Math.round(chart.width * dpr);
+    const physH = Math.round(chart.height * dpr);
+    for (const s of series) {
+      const ctx = {
+        width: physW,
+        height: physH,
+        samples: s.rawX.length,
+        seriesCount: series.length,
+        bounds: chart.bounds,
+        view: chart.view
+      };
+      for (const buf of renderer.buffers ?? []) {
+        const size = buf.bytes(ctx);
+        bufferSizes[buf.name] = Math.max(bufferSizes[buf.name] ?? 0, size);
+      }
+      perSeriesPassMeta.push(renderer.passes.map((p) => ({
+        dispatch: p.dispatch?.(ctx),
+        draw: p.draw?.(ctx)
+      })));
+    }
+    return { bufferSizes, perSeriesPassMeta };
+  }
+  create(config) {
+    if (!this.worker)
+      throw new Error("Call init() before create().");
+    const renderer = this.renderers.get(config.type);
+    if (!renderer)
+      throw new Error(`No renderer "${config.type}". Call manager.use() with a matching RendererPlugin first.`);
+    const id = `chart-${++this.chartIdCounter}`;
+    const el = document.createElement("div");
+    el.dataset.chartId = id;
+    el.style.cssText = "width:100%;height:100%;position:relative;";
+    const wrap = document.createElement("div");
+    wrap.dataset.chartId = id;
+    wrap.style.cssText = "width:100%;height:100%;position:relative;";
+    const mkCanvas = (z, events) => {
+      const c = document.createElement("canvas");
+      c.style.cssText = `position:absolute;inset:0;width:100%;height:100%;pointer-events:${events};z-index:${z};`;
+      return c;
+    };
+    const backCanvas = mkCanvas(0, "none");
+    const gpuCanvas = mkCanvas(1, "auto");
+    const frontCanvas = mkCanvas(2, "none");
+    wrap.append(backCanvas, gpuCanvas, frontCanvas);
+    el.appendChild(wrap);
+    config.container.appendChild(el);
+    let offscreen;
+    try {
+      offscreen = gpuCanvas.transferControlToOffscreen();
+    } catch (e) {
+      throw new Error(`Failed to acquire OffscreenCanvas: ${e}`);
+    }
+    const rect = wrap.getBoundingClientRect();
+    const cssW = rect.width || 400;
+    const cssH = rect.height || 200;
+    resizeCanvas(offscreen, cssW, cssH);
+    resizeCanvas(backCanvas, cssW, cssH);
+    resizeCanvas(frontCanvas, cssW, cssH);
+    if (config.bgColor) {
+      const [r, g, b] = config.bgColor;
+      wrap.style.background = `rgb(${Math.round(r * 255)},${Math.round(g * 255)},${Math.round(b * 255)})`;
+    }
+    const customUniforms = {};
+    for (const u of renderer.uniforms ?? []) {
+      const v = config[u.name];
+      customUniforms[u.name] = typeof v === "number" ? v : u.default;
+    }
+    const chart = {
+      id,
+      config,
+      el,
+      backCanvas,
+      frontCanvas,
+      width: cssW,
+      height: cssH,
+      series: [],
+      bounds: { minX: 0, maxX: 1, minY: 0, maxY: 1 },
+      view: { panX: 0, panY: 0, zoomX: 1, zoomY: 1 },
+      visible: true,
+      dragging: false,
+      plugins: [...this.uiPlugins],
+      renderer,
+      customUniforms
+    };
+    this.charts.set(id, chart);
+    const dpr = devicePixelRatio || 1;
+    const { bufferSizes, perSeriesPassMeta } = this.computeRendererMeta(renderer, chart);
+    this.worker.postMessage({
+      type: M.REGISTER_CHART,
+      id,
+      canvas: offscreen,
+      rendererName: config.type,
+      bgColor: config.bgColor ?? null,
+      bufferSizes,
+      perSeriesPassMeta,
+      customUniformValues: customUniforms,
+      width: Math.round(cssW * dpr),
+      height: Math.round(cssH * dpr)
+    }, [offscreen]);
+    this.visibilityObserver.observe(el);
+    this.resizeObserver.observe(wrap);
+    for (const plugin of chart.plugins)
+      plugin.install?.(chart, wrap);
+    renderer.install?.(chart, wrap);
+    this.updateSeries(id, config.series);
+    return new Chart(id, this);
+  }
+  destroy(id) {
+    const chart = this.charts.get(id);
+    if (!chart)
+      return;
+    chart.renderer.uninstall?.(chart);
+    for (const p of chart.plugins)
+      p.uninstall?.(chart);
+    this.visibilityObserver.unobserve(chart.el);
+    const wrap = chart.el.querySelector("div");
+    if (wrap)
+      this.resizeObserver.unobserve(wrap);
+    chart.el.remove();
+    this.worker?.postMessage({ type: M.UNREGISTER_CHART, id });
+    this.charts.delete(id);
+  }
+  updateSeries(id, series) {
+    const chart = this.charts.get(id);
+    if (!chart || !this.worker || series.length === 0)
+      return;
+    chart.series = series.map((s) => {
+      const n = s.x.length;
+      const color = parseColor(s.color);
+      if (n === 0)
+        return { label: s.label, color, rawX: [], rawY: [], extra: {} };
+      const idx = Array.from({ length: n }, (_, i) => i).sort((a, b) => s.x[a] - s.x[b]);
+      const extra = {};
+      for (const key in s) {
+        if (key !== "label" && key !== "color" && key !== "x" && key !== "y" && Array.isArray(s[key])) {
+          extra[key] = idx.map((i) => s[key][i]);
+        }
+      }
+      return {
+        label: s.label,
+        color,
+        rawX: idx.map((i) => s.x[i]),
+        rawY: idx.map((i) => s.y[i]),
+        extra
+      };
+    });
+    const customBounds = chart.renderer.computeBounds?.(chart.series);
+    let { minX, maxX, minY, maxY } = customBounds ?? (() => {
+      let minX2 = Infinity, maxX2 = -Infinity, minY2 = Infinity, maxY2 = -Infinity;
+      for (const s of chart.series) {
+        for (let i = 0;i < s.rawX.length; i++) {
+          if (s.rawX[i] < minX2)
+            minX2 = s.rawX[i];
+          if (s.rawX[i] > maxX2)
+            maxX2 = s.rawX[i];
+          if (s.rawY[i] < minY2)
+            minY2 = s.rawY[i];
+          if (s.rawY[i] > maxY2)
+            maxY2 = s.rawY[i];
+        }
+      }
+      const px = (maxX2 - minX2) * 0.05 || 1;
+      const py = (maxY2 - minY2) * 0.1 || 1;
+      return {
+        minX: minX2 - px,
+        maxX: maxX2 + px,
+        minY: minY2 - py,
+        maxY: maxY2 + py
+      };
+    })();
+    const db = chart.config.defaultBounds;
+    if (db) {
+      if (db.minX !== undefined)
+        minX = db.minX;
+      if (db.maxX !== undefined)
+        maxX = db.maxX;
+      if (db.minY !== undefined)
+        minY = db.minY;
+      if (db.maxY !== undefined)
+        maxY = db.maxY;
+    }
+    chart.bounds = { minX, maxX, minY, maxY };
+    const { bufferSizes, perSeriesPassMeta } = this.computeRendererMeta(chart.renderer, chart);
+    const seriesData = chart.series.map((s) => {
+      const extra = {};
+      for (const key in s.extra)
+        extra[key] = new Float32Array(s.extra[key]);
+      return {
+        label: s.label,
+        colorR: s.color.r,
+        colorG: s.color.g,
+        colorB: s.color.b,
+        dataX: new Float32Array(s.rawX),
+        dataY: new Float32Array(s.rawY),
+        extra
+      };
+    });
+    const transferables = seriesData.flatMap((s) => [
+      s.dataX.buffer,
+      s.dataY.buffer,
+      ...Object.values(s.extra).map((a) => a.buffer)
+    ]);
+    this.worker.postMessage({
+      type: M.UPDATE_SERIES,
+      id,
+      series: seriesData,
+      bounds: chart.bounds,
+      bufferSizes,
+      perSeriesPassMeta
+    }, transferables);
+    this.sendViewTransform(chart);
+    this.drawChart(chart);
+  }
+  setSyncViews(sync) {
+    this._syncViews = sync;
+  }
+  setTheme(dark) {
+    this._isDark = dark;
+    this.worker?.postMessage({ type: M.THEME, isDark: dark });
+    for (const chart of this.charts.values())
+      this.drawChart(chart);
+  }
+  onStats(callback) {
+    this.statsCallbacks.push(callback);
+    return () => {
+      const idx = this.statsCallbacks.indexOf(callback);
+      if (idx >= 0)
+        this.statsCallbacks.splice(idx, 1);
+    };
+  }
+  getStats() {
+    return { ...this.currentStats };
+  }
+  resetView(id) {
+    const chart = this.charts.get(id);
+    if (!chart)
+      return;
+    for (const p of chart.plugins)
+      p.resetView?.(chart);
+    const { panX: spx, panY: spy, zoomX: szx, zoomY: szy } = chart.view;
+    const t0 = performance.now();
+    const animate = () => {
+      const t = Math.min(1, (performance.now() - t0) / 300);
+      const e = 1 - Math.pow(1 - t, 3);
+      chart.view.panX = spx * (1 - e);
+      chart.view.panY = spy * (1 - e);
+      chart.view.zoomX = szx + (1 - szx) * e;
+      chart.view.zoomY = szy + (1 - szy) * e;
+      this.sendViewTransform(chart);
+      this.drawChart(chart);
+      if (this._syncViews)
+        this.syncAllViews(chart);
+      if (t < 1)
+        requestAnimationFrame(animate);
+    };
+    requestAnimationFrame(animate);
+  }
+  requestRender(id) {
+    const chart = this.charts.get(id);
+    if (chart)
+      this.sendViewTransform(chart);
+  }
+  sendViewTransform(chart) {
+    this.worker?.postMessage({
+      type: M.VIEW_TRANSFORM,
+      id: chart.id,
+      panX: chart.view.panX,
+      panY: chart.view.panY,
+      zoomX: chart.view.zoomX,
+      zoomY: chart.view.zoomY
+    });
+  }
+  syncAllViews(source) {
+    const transforms = [];
+    for (const chart of this.charts.values()) {
+      if (chart.id !== source.id) {
+        chart.view = { ...source.view };
+        transforms.push({ id: chart.id });
+        this.drawChart(chart);
+      }
+    }
+    if (transforms.length > 0) {
+      this.worker?.postMessage({
+        type: M.BATCH_VIEW_TRANSFORM,
+        panX: source.view.panX,
+        panY: source.view.panY,
+        zoomX: source.view.zoomX,
+        zoomY: source.view.zoomY,
+        transforms
+      });
+    }
+  }
+  drawChart(chart) {
+    if (!chart.visible)
+      return;
+    const dpr = devicePixelRatio || 1;
+    const backCtx = chart.backCanvas.getContext("2d");
+    if (backCtx) {
+      backCtx.clearRect(0, 0, chart.backCanvas.width, chart.backCanvas.height);
+      backCtx.save();
+      backCtx.scale(dpr, dpr);
+      for (const p of chart.plugins)
+        p.beforeDraw?.(backCtx, chart);
+      backCtx.restore();
+    }
+    const ctx = chart.frontCanvas.getContext("2d");
+    if (ctx) {
+      ctx.clearRect(0, 0, chart.frontCanvas.width, chart.frontCanvas.height);
+      ctx.save();
+      ctx.scale(dpr, dpr);
+      for (const p of chart.plugins)
+        p.afterDraw?.(ctx, chart);
+      ctx.restore();
+    }
+  }
+}
+var ChartManager = _ChartManager.getInstance();
+
+export { Chart, ChartManager };

package/dist/chunk-m17t3vjq.js

@@ -0,0 +1,9 @@
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined")
+    return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+export { __require };

package/dist/chunk-me3qaz3m.min.js

@@ -0,0 +1,2 @@
+var d=((a)=>typeof require<"u"?require:typeof Proxy<"u"?new Proxy(a,{get:(b,c)=>(typeof require<"u"?require:b)[c]}):a)(function(a){if(typeof require<"u")return require.apply(this,arguments);throw Error('Dynamic require of "'+a+'" is not supported')});
+export{d as o};

package/dist/chunk-qr6mweck.min.js

@@ -0,0 +1,2 @@
+import{j as T}from"./chunk-e7d3zgw5.js";import{l as p}from"./chunk-94kc81rr.js";var D='-apple-system, BlinkMacSystemFont, "Segoe UI", system-ui, sans-serif',F=12,c=(t,m,s)=>{let o=m-t;if(o<=0)return[t];let e=o/s,n=10**Math.floor(Math.log10(e)),a=e/n,r=n*(a<=1.5?1:a<=3?2:a<=7?5:10),l=[];for(let g=Math.ceil(t/r)*r;g<=m;g+=r)l.push(g);return l},M=(t)=>{let{width:m,height:s}=t,o=T,{bounds:e,view:n}=t,a=e.maxX-e.minX,r=e.maxY-e.minY,l=a/n.zoomX,g=r/n.zoomY,u=e.minX+n.panX*a,i=e.minY+n.panY*r,h=t.config.bgColor??(p.isDark?[0.11,0.11,0.12]:[0.98,0.98,0.98]);return{w:m,h:s,m:o,rx:l,ry:g,mx:u,my:i,bg:`${Math.round(h[0]*255)},${Math.round(h[1]*255)},${Math.round(h[2]*255)}`,font:t.config.fontFamily??D,text:t.config.textColor??(p.isDark?"#c0c0c0":"#333333"),grid:t.config.gridColor??(p.isDark?"rgba(255,255,255,0.06)":"rgba(0,0,0,0.06)")}},A={name:"labels",beforeDraw(t,m){let{w:s,h:o,m:e,rx:n,ry:a,mx:r,my:l,grid:g}=M(m);t.strokeStyle=g,t.lineWidth=1,t.beginPath(),c(l,l+a,7).forEach((u)=>{let i=o*(1-(u-l)/a);if(i>5&&i<o-e.bottom-5)t.moveTo(e.left,i),t.lineTo(s,i)}),c(r,r+n,8).forEach((u)=>{let i=s*((u-r)/n);if(i>e.left&&i<s)t.moveTo(i,0),t.lineTo(i,o-e.bottom)}),t.stroke()},afterDraw(t,m){let{w:s,h:o,m:e,rx:n,ry:a,mx:r,my:l,bg:g,font:u,text:i}=M(m),{formatX:h=String,formatY:E=String,labelSize:k=F}=m.config,d=(b,f,C,y,S)=>{let L=b==="left"?t.createLinearGradient(f,0,f+y,0):t.createLinearGradient(0,C,0,C+S),w=b==="left"?[1,0.7,0.2,0.05,0]:[0,0.05,0.2,0.7,1];[0,0.35,0.55,0.7,1].forEach((X,Y)=>L.addColorStop(X,`rgba(${g},${w[Y]})`)),t.fillStyle=L,t.fillRect(f,C,y,S)};d("left",0,0,e.left+20,o),d("bottom",0,o-e.bottom-20,s,e.bottom+20),t.font=`${k}px ${u}`,t.fillStyle=i,t.textAlign="right",t.textBaseline="middle",c(l,l+a,7).forEach((b)=>{let f=o*(1-(b-l)/a);if(f>5&&f<o-e.bottom-5)t.fillText(E(b),e.left-5,f)}),t.textAlign="right",t.textBaseline="top",c(r,r+n,8).forEach((b)=>{let f=s*((b-r)/n);if(f<e.left-10||f>s+30)return;t.save(),t.translate(f,o-e.bottom+5),t.rotate(-Math.PI/14),t.fillText(h(b),0,0),t.restore()})}};
+export{D as g,F as h,A as i};

package/dist/chunk-yabjrff2.js

@@ -0,0 +1,11 @@
+import {
+  BINARY_SEARCH,
+  COMPUTE_WG,
+  UNIFORM_STRUCT
+} from "./chunk-0jepamv9.js";
+
+// src/shaders/line.ts
+var LINE_COMPUTE_SHADER = `${UNIFORM_STRUCT}struct LineUniforms{maxSamplesPerPixel: u32,_p1: u32,_p2: u32,_p3: u32};struct LineData{screenX: f32,minScreenY: f32,maxScreenY: f32,valid: f32,};@group(0)@binding(0)var<uniform> u: Uniforms;@group(0)@binding(1)var<storage,read> dataX: array<f32>;@group(0)@binding(2)var<storage,read> dataY: array<f32>;@group(0)@binding(3)var<storage,read_write> lineData: array<LineData>;@group(0)@binding(4)var<storage,read> allSeries: array<SeriesInfo>;@group(0)@binding(5)var<uniform> lu: LineUniforms;${BINARY_SEARCH}@compute @workgroup_size(${COMPUTE_WG})fn main(@builtin(global_invocation_id)id: vec3u){let outputIdx = id.x;let maxCols = u32(u.width);let count = u.pointCount;if(outputIdx >= maxCols || count == 0u){if(outputIdx < maxCols){lineData[outputIdx] = LineData(-1.0,-1.0,-1.0,0.0);}return;}let viewRangeX = u.viewMaxX - u.viewMinX;let viewRangeY = u.viewMaxY - u.viewMinY;if(viewRangeX < 0.0001 || viewRangeY < 0.0001){lineData[outputIdx] = LineData(-1.0,-1.0,-1.0,0.0);return;}let relPx = f32(outputIdx);let pixelMinX = u.viewMinX +(relPx / u.width)* viewRangeX;let pixelMaxX = u.viewMinX +((relPx + 1.0)/ u.width)* viewRangeX;if(pixelMaxX < u.dataMinX || pixelMinX > u.dataMaxX){lineData[outputIdx] = LineData(-1.0,-1.0,-1.0,0.0);return;}let startIdx = lowerBound(pixelMinX,count);var endIdx = lowerBound(pixelMaxX,count);endIdx = min(endIdx,count);let centerX =(pixelMinX + pixelMaxX)* 0.5;if(startIdx >= endIdx){var bestIdx = startIdx;if(startIdx > 0u && startIdx < count){let distPrev = abs(dataX[startIdx - 1u] - centerX);let distCurr = abs(dataX[startIdx] - centerX);if(distPrev < distCurr){bestIdx = startIdx - 1u;}}else if(startIdx >= count && count > 0u){bestIdx = count - 1u;}if(bestIdx >= count){lineData[outputIdx] = LineData(-1.0,-1.0,-1.0,0.0);return;}let y = dataY[bestIdx];let normY =(y - u.viewMinY)/ viewRangeY;let screenY = 1.0 - normY;let normX =(dataX[bestIdx] - u.viewMinX)/ viewRangeX;let screenX = normX;lineData[outputIdx] = LineData(screenX,screenY,screenY,1.0);return;}var dataMinY = dataY[startIdx];var dataMaxY = dataY[startIdx];let rangeCount = endIdx - startIdx;let maxSamples = lu.maxSamplesPerPixel;if(maxSamples > 1u && rangeCount > maxSamples){let stride = f32(rangeCount - 1u)/ f32(maxSamples - 1u);for(var s = 0u;s < maxSamples;s++){let idx = startIdx + u32(f32(s)* stride);if(idx < endIdx){let y = dataY[idx];dataMinY = min(dataMinY,y);dataMaxY = max(dataMaxY,y);}}let lastY = dataY[endIdx - 1u];dataMinY = min(dataMinY,lastY);dataMaxY = max(dataMaxY,lastY);}else{for(var i = startIdx + 1u;i < endIdx;i++){let y = dataY[i];dataMinY = min(dataMinY,y);dataMaxY = max(dataMaxY,y);}}let normX =(centerX - u.viewMinX)/ viewRangeX;let screenX = normX;let normMaxY =(dataMaxY - u.viewMinY)/ viewRangeY;let normMinY =(dataMinY - u.viewMinY)/ viewRangeY;let minScreenY = 1.0 - normMaxY;let maxScreenY = 1.0 - normMinY;lineData[outputIdx] = LineData(screenX,minScreenY,maxScreenY,1.0);}`;
+var LINE_RENDER_SHADER = `${UNIFORM_STRUCT}struct LineData{screenX: f32,minScreenY: f32,maxScreenY: f32,valid: f32,};@group(0)@binding(0)var<uniform> u: Uniforms;@group(0)@binding(1)var<storage,read> lineData: array<LineData>;@group(0)@binding(2)var<storage,read> allSeries: array<SeriesInfo>;struct VertexOutput{@builtin(position)pos: vec4f,@location(0)alpha: f32,@location(1)@interpolate(flat)seriesIdx: u32,};@vertex fn vs(@builtin(vertex_index)vi: u32,@builtin(instance_index)series_idx: u32)-> VertexOutput{var out: VertexOutput;out.seriesIdx = series_idx;let maxCols = u32(u.width);let segIdx = vi / 2u;let endpoint = vi % 2u;if(segIdx < maxCols){let d = lineData[segIdx];let y = select(d.maxScreenY,d.minScreenY,endpoint == 0u);out.pos = vec4f(d.screenX * 2.0 - 1.0,1.0 - y * 2.0,0.0,d.valid);out.alpha = d.valid;}else{let connIdx = segIdx - maxCols;if(connIdx + 1u >= maxCols){out.pos = vec4f(0.0,0.0,0.0,0.0);out.alpha = 0.0;return out;}let d0 = lineData[connIdx];let d1 = lineData[connIdx + 1u];let segValid = min(d0.valid,d1.valid);if(endpoint == 0u){let midY =(d0.minScreenY + d0.maxScreenY)* 0.5;out.pos = vec4f(d0.screenX * 2.0 - 1.0,1.0 - midY * 2.0,0.0,segValid);}else{let midY =(d1.minScreenY + d1.maxScreenY)* 0.5;out.pos = vec4f(d1.screenX * 2.0 - 1.0,1.0 - midY * 2.0,0.0,segValid);}out.alpha = segValid;}return out;}@fragment fn fs(in: VertexOutput)-> @location(0)vec4f{if(in.alpha < 0.1){discard;}let series = allSeries[in.seriesIdx];return vec4f(series.color.rgb,1.0);}`;
+
+export { LINE_COMPUTE_SHADER, LINE_RENDER_SHADER };