chartai 0.1.0 → 1.1.0

package/dist/charts/experimental/ohlc.js

@@ -0,0 +1,132 @@
+import {
+  CANDLESTICK_COMPUTE_SHADER,
+  packRGB
+} from "../../chunk-t0kdz02m.js";
+import {
+  COMPUTE_WG,
+  UNIFORM_STRUCT
+} from "../../chunk-0jepamv9.js";
+import"../../chunk-5gtx3pza.js";
+
+// src/shaders/experimental/ohlc.ts
+var CANDLE_TYPES = `
+struct CandleUniforms {
+  maxSamples: f32,
+  upColor:    u32,
+  downColor:  u32,
+  binSize:    u32,
+  interval:   f32,
+  _p0: u32, _p1: u32, _p2: u32,
+};
+struct CandleData {
+  screenX:    f32,
+  barWidth:   f32,
+  low:        f32,
+  bodyBottom: f32,
+  bodyTop:    f32,
+  high:       f32,
+  isUp:       f32,
+};`;
+var EFFECTIVE_INTERVAL = `
+fn effectiveInterval() -> f32 {
+  if (cu.interval > 0.0) { return cu.interval; }
+  let raw = (u.viewMaxX - u.viewMinX) / u.width * f32(cu.binSize);
+  let steps = array<f32, 20>(
+    1.0, 2.0, 5.0, 10.0, 15.0, 30.0,
+    60.0, 120.0, 300.0, 600.0, 900.0, 1800.0,
+    3600.0, 7200.0, 14400.0, 43200.0,
+    86400.0, 259200.0, 604800.0, 2592000.0
+  );
+  for (var i = 0u; i < 20u; i++) {
+    if (steps[i] >= raw) { return steps[i]; }
+  }
+  return raw;
+}`;
+var OHLC_RENDER_SHADER = `${UNIFORM_STRUCT}${CANDLE_TYPES}@group(0)@binding(0)var<uniform> u: Uniforms;@group(0)@binding(1)var<storage,read> candleData: array<CandleData>;@group(0)@binding(2)var<uniform> cu: CandleUniforms;${EFFECTIVE_INTERVAL}struct VertexOutput{@builtin(position)pos: vec4f,@location(0)@interpolate(flat)isUp: f32,};@vertex fn vs(@builtin(vertex_index)vi: u32)-> VertexOutput{var out: VertexOutput;let viewRangeX = u.viewMaxX - u.viewMinX;let interval = effectiveInterval();let numBins = min(u32(ceil(viewRangeX / interval))+ 2u,u32(u.width));let colIdx = vi / 18u;let localVi = vi % 18u;let section = localVi / 6u;let vertexType = localVi % 6u;if(colIdx >= numBins){out.pos = vec4f(0.0,0.0,0.0,0.0);out.isUp = 0.0;return out;}let cd = candleData[colIdx];if(cd.barWidth <= 0.0){out.pos = vec4f(0.0,0.0,0.0,0.0);out.isUp = 0.0;return out;}out.isUp = cd.isUp;let viewRangeY = u.viewMaxY - u.viewMinY;let safeRangeY = select(viewRangeY,1.0,viewRangeY < 0.0001);let onePixelX = 1.0 / u.width;let onePixelY = 1.0 / u.height;let wickWidth = max(onePixelX,cd.barWidth * 0.07);let tickHalfH = max(onePixelY,wickWidth * u.width / u.height);let openPrice = select(cd.bodyTop,cd.bodyBottom,cd.isUp > 0.5);let closePrice = select(cd.bodyBottom,cd.bodyTop,cd.isUp > 0.5);var sLeft: f32;var sRight: f32;var sTop: f32;var sBottom: f32;if(section == 0u){let nb =(cd.low - u.viewMinY)/ safeRangeY;let nt =(cd.high - u.viewMinY)/ safeRangeY;sBottom = 1.0 - nb;sTop = 1.0 - nt;sLeft = cd.screenX - wickWidth;sRight = cd.screenX + wickWidth;}else if(section == 1u){let ny =(openPrice - u.viewMinY)/ safeRangeY;let sy = 1.0 - ny;sTop = sy - tickHalfH;sBottom = sy + tickHalfH;sLeft = cd.screenX - cd.barWidth * 0.45;sRight = cd.screenX;}else{let ny =(closePrice - u.viewMinY)/ safeRangeY;let sy = 1.0 - ny;sTop = sy - tickHalfH;sBottom = sy + tickHalfH;sLeft = cd.screenX;sRight = cd.screenX + cd.barWidth * 0.45;}var positions = array<vec2f,6>(vec2f(sLeft,sBottom),vec2f(sRight,sBottom),vec2f(sLeft,sTop),vec2f(sLeft,sTop),vec2f(sRight,sBottom),vec2f(sRight,sTop));let sp = positions[vertexType];out.pos = vec4f(sp.x * 2.0 - 1.0,1.0 - sp.y * 2.0,0.0,1.0);return out;}@fragment fn fs(in: VertexOutput)-> @location(0)vec4f{let upRgb = unpack4x8unorm(cu.upColor).rgb;let downRgb = unpack4x8unorm(cu.downColor).rgb;let color = select(downRgb,upRgb,in.isUp > 0.5);return vec4f(color,0.92);}`;
+
+// src/charts/experimental/ohlc.ts
+var BYTES_PER_CANDLE = 7 * 4;
+var OhlcChart = {
+  name: "ohlc",
+  shaders: {
+    compute: CANDLESTICK_COMPUTE_SHADER,
+    render: OHLC_RENDER_SHADER
+  },
+  uniforms: [
+    { name: "maxSamples", type: "f32", default: 1e4 },
+    { name: "upColor", type: "u32", default: packRGB(0.2, 0.7, 0.3) },
+    { name: "downColor", type: "u32", default: packRGB(0.9, 0.3, 0.3) },
+    { name: "binSize", type: "u32", default: 8 },
+    { name: "interval", type: "f32", default: 0 }
+  ],
+  buffers: [
+    {
+      name: "candleBuffer",
+      bytes: ({ width }) => Math.max(16, width * BYTES_PER_CANDLE),
+      usages: ["STORAGE"]
+    }
+  ],
+  passes: [
+    {
+      type: "compute",
+      shader: "compute",
+      perSeries: true,
+      dispatch: ({ width }) => ({ x: Math.ceil(Math.max(1, width) / COMPUTE_WG) }),
+      bindings: [
+        { binding: 0, source: "uniforms" },
+        { binding: 1, source: "x-data" },
+        { binding: 2, source: "y-data" },
+        { binding: 3, source: "candleBuffer", write: true },
+        { binding: 4, source: "series-info" },
+        { binding: 5, source: "series-index" },
+        { binding: 6, source: "custom-uniforms" },
+        { binding: 7, source: "open-data" },
+        { binding: 8, source: "high-data" },
+        { binding: 9, source: "low-data" }
+      ]
+    },
+    {
+      type: "render",
+      shader: "render",
+      topology: "triangle-list",
+      loadOp: "load",
+      blend: {
+        color: { srcFactor: "src-alpha", dstFactor: "one-minus-src-alpha" },
+        alpha: { srcFactor: "one", dstFactor: "one-minus-src-alpha" }
+      },
+      draw: ({ width }) => width * 18,
+      bindings: [
+        { binding: 0, source: "uniforms" },
+        { binding: 1, source: "candleBuffer" },
+        { binding: 2, source: "custom-uniforms" }
+      ]
+    }
+  ],
+  computeBounds(series) {
+    let minX = Infinity, maxX = -Infinity, minY = Infinity, maxY = -Infinity;
+    for (const s of series) {
+      for (const x of s.rawX) {
+        if (x < minX)
+          minX = x;
+        if (x > maxX)
+          maxX = x;
+      }
+      for (const y of s.extra.high ?? []) {
+        if (y > maxY)
+          maxY = y;
+      }
+      for (const y of s.extra.low ?? []) {
+        if (y < minY)
+          minY = y;
+      }
+    }
+    if (!isFinite(minX))
+      return { minX: 0, maxX: 1, minY: 0, maxY: 1 };
+    const px = (maxX - minX) * 0.05 || 1;
+    const py = (maxY - minY) * 0.1 || 1;
+    return { minX: minX - px, maxX: maxX + px, minY: minY - py, maxY: maxY + py };
+  }
+};
+export {
+  OhlcChart
+};

package/dist/charts/experimental/ohlc.min.js

@@ -0,0 +1,32 @@
+import{a as Q,b as Z}from"../../chunk-g2qmt43n.js";import{f as g,g as z}from"../../chunk-64q9a7nw.js";import"../../chunk-bbyt23tw.js";var V=`
+struct CandleUniforms {
+  maxSamples: f32,
+  upColor:    u32,
+  downColor:  u32,
+  binSize:    u32,
+  interval:   f32,
+  _p0: u32, _p1: u32, _p2: u32,
+};
+struct CandleData {
+  screenX:    f32,
+  barWidth:   f32,
+  low:        f32,
+  bodyBottom: f32,
+  bodyTop:    f32,
+  high:       f32,
+  isUp:       f32,
+};`,B=`
+fn effectiveInterval() -> f32 {
+  if (cu.interval > 0.0) { return cu.interval; }
+  let raw = (u.viewMaxX - u.viewMinX) / u.width * f32(cu.binSize);
+  let steps = array<f32, 20>(
+    1.0, 2.0, 5.0, 10.0, 15.0, 30.0,
+    60.0, 120.0, 300.0, 600.0, 900.0, 1800.0,
+    3600.0, 7200.0, 14400.0, 43200.0,
+    86400.0, 259200.0, 604800.0, 2592000.0
+  );
+  for (var i = 0u; i < 20u; i++) {
+    if (steps[i] >= raw) { return steps[i]; }
+  }
+  return raw;
+}`,W=`${z}${V}@group(0)@binding(0)var<uniform> u: Uniforms;@group(0)@binding(1)var<storage,read> candleData: array<CandleData>;@group(0)@binding(2)var<uniform> cu: CandleUniforms;${B}struct VertexOutput{@builtin(position)pos: vec4f,@location(0)@interpolate(flat)isUp: f32,};@vertex fn vs(@builtin(vertex_index)vi: u32)-> VertexOutput{var out: VertexOutput;let viewRangeX = u.viewMaxX - u.viewMinX;let interval = effectiveInterval();let numBins = min(u32(ceil(viewRangeX / interval))+ 2u,u32(u.width));let colIdx = vi / 18u;let localVi = vi % 18u;let section = localVi / 6u;let vertexType = localVi % 6u;if(colIdx >= numBins){out.pos = vec4f(0.0,0.0,0.0,0.0);out.isUp = 0.0;return out;}let cd = candleData[colIdx];if(cd.barWidth <= 0.0){out.pos = vec4f(0.0,0.0,0.0,0.0);out.isUp = 0.0;return out;}out.isUp = cd.isUp;let viewRangeY = u.viewMaxY - u.viewMinY;let safeRangeY = select(viewRangeY,1.0,viewRangeY < 0.0001);let onePixelX = 1.0 / u.width;let onePixelY = 1.0 / u.height;let wickWidth = max(onePixelX,cd.barWidth * 0.07);let tickHalfH = max(onePixelY,wickWidth * u.width / u.height);let openPrice = select(cd.bodyTop,cd.bodyBottom,cd.isUp > 0.5);let closePrice = select(cd.bodyBottom,cd.bodyTop,cd.isUp > 0.5);var sLeft: f32;var sRight: f32;var sTop: f32;var sBottom: f32;if(section == 0u){let nb =(cd.low - u.viewMinY)/ safeRangeY;let nt =(cd.high - u.viewMinY)/ safeRangeY;sBottom = 1.0 - nb;sTop = 1.0 - nt;sLeft = cd.screenX - wickWidth;sRight = cd.screenX + wickWidth;}else if(section == 1u){let ny =(openPrice - u.viewMinY)/ safeRangeY;let sy = 1.0 - ny;sTop = sy - tickHalfH;sBottom = sy + tickHalfH;sLeft = cd.screenX - cd.barWidth * 0.45;sRight = cd.screenX;}else{let ny =(closePrice - u.viewMinY)/ safeRangeY;let sy = 1.0 - ny;sTop = sy - tickHalfH;sBottom = sy + tickHalfH;sLeft = cd.screenX;sRight = cd.screenX + cd.barWidth * 0.45;}var positions = array<vec2f,6>(vec2f(sLeft,sBottom),vec2f(sRight,sBottom),vec2f(sLeft,sTop),vec2f(sLeft,sTop),vec2f(sRight,sBottom),vec2f(sRight,sTop));let sp = positions[vertexType];out.pos = vec4f(sp.x * 2.0 - 1.0,1.0 - sp.y * 2.0,0.0,1.0);return out;}@fragment fn fs(in: VertexOutput)-> @location(0)vec4f{let upRgb = unpack4x8unorm(cu.upColor).rgb;let downRgb = unpack4x8unorm(cu.downColor).rgb;let color = select(downRgb,upRgb,in.isUp > 0.5);return vec4f(color,0.92);}`;var F=28,k={name:"ohlc",shaders:{compute:Q,render:W},uniforms:[{name:"maxSamples",type:"f32",default:1e4},{name:"upColor",type:"u32",default:Z(0.2,0.7,0.3)},{name:"downColor",type:"u32",default:Z(0.9,0.3,0.3)},{name:"binSize",type:"u32",default:8},{name:"interval",type:"f32",default:0}],buffers:[{name:"candleBuffer",bytes:({width:j})=>Math.max(16,j*F),usages:["STORAGE"]}],passes:[{type:"compute",shader:"compute",perSeries:!0,dispatch:({width:j})=>({x:Math.ceil(Math.max(1,j)/g)}),bindings:[{binding:0,source:"uniforms"},{binding:1,source:"x-data"},{binding:2,source:"y-data"},{binding:3,source:"candleBuffer",write:!0},{binding:4,source:"series-info"},{binding:5,source:"series-index"},{binding:6,source:"custom-uniforms"},{binding:7,source:"open-data"},{binding:8,source:"high-data"},{binding:9,source:"low-data"}]},{type:"render",shader:"render",topology:"triangle-list",loadOp:"load",blend:{color:{srcFactor:"src-alpha",dstFactor:"one-minus-src-alpha"},alpha:{srcFactor:"one",dstFactor:"one-minus-src-alpha"}},draw:({width:j})=>j*18,bindings:[{binding:0,source:"uniforms"},{binding:1,source:"candleBuffer"},{binding:2,source:"custom-uniforms"}]}],computeBounds(j){let q=1/0,u=-1/0,v=1/0,J=-1/0;for(let K of j){for(let b of K.rawX){if(b<q)q=b;if(b>u)u=b}for(let b of K.extra.high??[])if(b>J)J=b;for(let b of K.extra.low??[])if(b<v)v=b}if(!isFinite(q))return{minX:0,maxX:1,minY:0,maxY:1};let $=(u-q)*0.05||1,f=(J-v)*0.1||1;return{minX:q-$,maxX:u+$,minY:v-f,maxY:J+f}}};export{k as OhlcChart};

package/dist/charts/experimental/step.js

@@ -0,0 +1,67 @@
+import {
+  LINE_COMPUTE_SHADER
+} from "../../chunk-yabjrff2.js";
+import {
+  COMPUTE_WG,
+  UNIFORM_STRUCT
+} from "../../chunk-0jepamv9.js";
+import"../../chunk-5gtx3pza.js";
+
+// src/shaders/experimental/step.ts
+var STEP_RENDER_SHADER = `${UNIFORM_STRUCT}struct LineData{screenX: f32,minScreenY: f32,maxScreenY: f32,valid: f32,};struct StepUniforms{maxSamplesPerPixel: u32,stepMode: u32,_p2: u32,_p3: u32,};@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>;@group(0)@binding(3)var<uniform> su: StepUniforms;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 spanVerts = maxCols * 2u;if(vi < spanVerts){let segIdx = vi / 2u;let endpoint = vi % 2u;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 connOffset = vi - spanVerts;let connIdx = connOffset / 4u;let localVert = connOffset % 4u;let segInConn = localVert / 2u;let endpoint = localVert % 2u;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);let midY0 =(d0.minScreenY + d0.maxScreenY)* 0.5;let midY1 =(d1.minScreenY + d1.maxScreenY)* 0.5;let midX =(d0.screenX + d1.screenX)* 0.5;var px: f32;var py: f32;if(su.stepMode == 0u){if(segInConn == 0u){px = select(d0.screenX,d1.screenX,endpoint == 1u);py = midY0;}else{px = d1.screenX;py = select(midY0,midY1,endpoint == 1u);}}else if(su.stepMode == 1u){if(segInConn == 0u){px = d0.screenX;py = select(midY0,midY1,endpoint == 1u);}else{px = select(d0.screenX,d1.screenX,endpoint == 1u);py = midY1;}}else{if(segInConn == 0u){px = select(d0.screenX,midX,endpoint == 1u);py = midY0;}else{px = midX;py = select(midY0,midY1,endpoint == 1u);}}out.pos = vec4f(px * 2.0 - 1.0,1.0 - py * 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);}`;
+
+// src/charts/experimental/step.ts
+var StepChart = {
+  name: "step",
+  shaders: {
+    compute: LINE_COMPUTE_SHADER,
+    render: STEP_RENDER_SHADER
+  },
+  uniforms: [
+    { name: "maxSamplesPerPixel", type: "u32", default: 1e4 },
+    { name: "stepMode", type: "u32", default: 0 }
+  ],
+  buffers: [
+    {
+      name: "lineBuffer",
+      bytes: ({ width }) => Math.max(16, width * 4 * 4),
+      usages: ["STORAGE"]
+    }
+  ],
+  passes: [
+    {
+      type: "compute",
+      shader: "compute",
+      perSeries: true,
+      dispatch: ({ width }) => ({ x: Math.ceil(Math.max(1, width) / COMPUTE_WG) }),
+      bindings: [
+        { binding: 0, source: "uniforms" },
+        { binding: 1, source: "x-data" },
+        { binding: 2, source: "y-data" },
+        { binding: 3, source: "lineBuffer", write: true },
+        { binding: 4, source: "series-info" },
+        { binding: 5, source: "custom-uniforms" }
+      ]
+    },
+    {
+      type: "render",
+      shader: "render",
+      topology: "line-list",
+      loadOp: "load",
+      blend: {
+        color: { srcFactor: "src-alpha", dstFactor: "one-minus-src-alpha" },
+        alpha: { srcFactor: "one", dstFactor: "one-minus-src-alpha" }
+      },
+      draw: ({ width }) => Math.max(0, width * 2 + (width - 1) * 4),
+      bindings: [
+        { binding: 0, source: "uniforms" },
+        { binding: 1, source: "lineBuffer" },
+        { binding: 2, source: "series-info" },
+        { binding: 3, source: "custom-uniforms" }
+      ]
+    }
+  ]
+};
+export {
+  StepChart
+};

package/dist/charts/experimental/step.min.js

@@ -0,0 +1 @@
+import{d as n}from"../../chunk-gm0d4cgx.js";import{f as r,g as t}from"../../chunk-64q9a7nw.js";import"../../chunk-bbyt23tw.js";var i=`${t}struct LineData{screenX: f32,minScreenY: f32,maxScreenY: f32,valid: f32,};struct StepUniforms{maxSamplesPerPixel: u32,stepMode: u32,_p2: u32,_p3: u32,};@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>;@group(0)@binding(3)var<uniform> su: StepUniforms;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 spanVerts = maxCols * 2u;if(vi < spanVerts){let segIdx = vi / 2u;let endpoint = vi % 2u;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 connOffset = vi - spanVerts;let connIdx = connOffset / 4u;let localVert = connOffset % 4u;let segInConn = localVert / 2u;let endpoint = localVert % 2u;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);let midY0 =(d0.minScreenY + d0.maxScreenY)* 0.5;let midY1 =(d1.minScreenY + d1.maxScreenY)* 0.5;let midX =(d0.screenX + d1.screenX)* 0.5;var px: f32;var py: f32;if(su.stepMode == 0u){if(segInConn == 0u){px = select(d0.screenX,d1.screenX,endpoint == 1u);py = midY0;}else{px = d1.screenX;py = select(midY0,midY1,endpoint == 1u);}}else if(su.stepMode == 1u){if(segInConn == 0u){px = d0.screenX;py = select(midY0,midY1,endpoint == 1u);}else{px = select(d0.screenX,d1.screenX,endpoint == 1u);py = midY1;}}else{if(segInConn == 0u){px = select(d0.screenX,midX,endpoint == 1u);py = midY0;}else{px = midX;py = select(midY0,midY1,endpoint == 1u);}}out.pos = vec4f(px * 2.0 - 1.0,1.0 - py * 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);}`;var u={name:"step",shaders:{compute:n,render:i},uniforms:[{name:"maxSamplesPerPixel",type:"u32",default:1e4},{name:"stepMode",type:"u32",default:0}],buffers:[{name:"lineBuffer",bytes:({width:e})=>Math.max(16,e*4*4),usages:["STORAGE"]}],passes:[{type:"compute",shader:"compute",perSeries:!0,dispatch:({width:e})=>({x:Math.ceil(Math.max(1,e)/r)}),bindings:[{binding:0,source:"uniforms"},{binding:1,source:"x-data"},{binding:2,source:"y-data"},{binding:3,source:"lineBuffer",write:!0},{binding:4,source:"series-info"},{binding:5,source:"custom-uniforms"}]},{type:"render",shader:"render",topology:"line-list",loadOp:"load",blend:{color:{srcFactor:"src-alpha",dstFactor:"one-minus-src-alpha"},alpha:{srcFactor:"one",dstFactor:"one-minus-src-alpha"}},draw:({width:e})=>Math.max(0,e*2+(e-1)*4),bindings:[{binding:0,source:"uniforms"},{binding:1,source:"lineBuffer"},{binding:2,source:"series-info"},{binding:3,source:"custom-uniforms"}]}]};export{u as StepChart};

package/dist/charts/experimental/waterfall.js

@@ -0,0 +1,121 @@
+import {
+  packRGB
+} from "../../chunk-t0kdz02m.js";
+import {
+  UNIFORM_STRUCT
+} from "../../chunk-0jepamv9.js";
+import"../../chunk-5gtx3pza.js";
+
+// src/shaders/experimental/waterfall.ts
+var WATERFALL_TYPES = `
+struct WaterfallUniforms {
+  upColor:    u32,
+  downColor:  u32,
+  totalColor: u32,
+  _pad:       u32,
+};`;
+var WATERFALL_RENDER_SHADER = `${UNIFORM_STRUCT}${WATERFALL_TYPES}@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<uniform> wu: WaterfallUniforms;@group(0)@binding(4)var<storage,read> dataH: array<f32>;@group(0)@binding(5)var<storage,read> dataT: array<f32>;@group(0)@binding(6)var<storage,read> dataBW: array<f32>;struct VertexOutput{@builtin(position)pos: vec4f,@location(0)@interpolate(flat)colorType: f32,};@vertex fn vs(@builtin(vertex_index)vi: u32)-> VertexOutput{var out: VertexOutput;let barIdx = vi / 6u;let vertexType = vi % 6u;let count = u.pointCount;if(barIdx >= count){out.pos = vec4f(0.0,0.0,0.0,1.0);out.colorType = 0.0;return out;}let x = dataX[barIdx];let barBottom = dataY[barIdx];let barHeight = max(dataH[barIdx],0.0);let barTop = barBottom + barHeight;let barWidth = dataBW[barIdx];let viewRangeX = u.viewMaxX - u.viewMinX;let viewRangeY = u.viewMaxY - u.viewMinY;let safeRangeX = select(viewRangeX,1.0,viewRangeX < 0.0001);let safeRangeY = select(viewRangeY,1.0,viewRangeY < 0.0001);let screenX =(x - u.viewMinX)/ safeRangeX;let halfW =(barWidth * 0.5)/ safeRangeX;let left = screenX - halfW;let right = screenX + halfW;let normBottom =(barBottom - u.viewMinY)/ safeRangeY;let normTop =(barTop - u.viewMinY)/ safeRangeY;let sBottom = max(1.0 - normBottom,1.0 - normTop);let sTop = min(1.0 - normBottom,1.0 - normTop);var positions = array<vec2f,6>(vec2f(left,sBottom),vec2f(right,sBottom),vec2f(left,sTop),vec2f(left,sTop),vec2f(right,sBottom),vec2f(right,sTop));let sp = positions[vertexType];out.pos = vec4f(sp.x * 2.0 - 1.0,1.0 - sp.y * 2.0,0.0,1.0);out.colorType = dataT[barIdx];return out;}@fragment fn fs(in: VertexOutput)-> @location(0)vec4f{let upRgb = unpack4x8unorm(wu.upColor).rgb;let downRgb = unpack4x8unorm(wu.downColor).rgb;let totalRgb = unpack4x8unorm(wu.totalColor).rgb;var color: vec3f;if(in.colorType < 0.5){color = upRgb;}else if(in.colorType < 1.5){color = downRgb;}else{color = totalRgb;}return vec4f(color,0.9);}`;
+
+// src/charts/experimental/waterfall.ts
+function prepareWaterfall(positions, deltas, totals) {
+  const n = deltas.length;
+  const y = new Array(n);
+  const h = new Array(n);
+  const t = new Array(n);
+  const bw = new Array(n);
+  let running = 0;
+  for (let i = 0;i < n; i++) {
+    const isTotal = (totals?.[i] ?? 0) > 0.5;
+    const delta = deltas[i];
+    if (isTotal) {
+      y[i] = Math.min(0, running);
+      h[i] = Math.abs(running);
+      t[i] = 2;
+    } else {
+      if (delta >= 0) {
+        y[i] = running;
+        h[i] = delta;
+        t[i] = 0;
+      } else {
+        y[i] = running + delta;
+        h[i] = Math.abs(delta);
+        t[i] = 1;
+      }
+      running += delta;
+    }
+  }
+  for (let i = 0;i < n; i++) {
+    let spacing;
+    if (n <= 1) {
+      spacing = 1;
+    } else if (i === 0) {
+      spacing = positions[1] - positions[0];
+    } else if (i === n - 1) {
+      spacing = positions[n - 1] - positions[n - 2];
+    } else {
+      spacing = Math.min(positions[i + 1] - positions[i], positions[i] - positions[i - 1]);
+    }
+    bw[i] = spacing * 0.8;
+  }
+  return { x: positions, y, h, t, bw };
+}
+var WaterfallChart = {
+  name: "waterfall",
+  shaders: { render: WATERFALL_RENDER_SHADER },
+  uniforms: [
+    { name: "upColor", type: "u32", default: packRGB(0.2, 0.7, 0.3) },
+    { name: "downColor", type: "u32", default: packRGB(0.9, 0.3, 0.3) },
+    { name: "totalColor", type: "u32", default: packRGB(0.5, 0.5, 0.6) }
+  ],
+  passes: [
+    {
+      type: "render",
+      shader: "render",
+      topology: "triangle-list",
+      loadOp: "load",
+      perSeries: true,
+      blend: {
+        color: { srcFactor: "src-alpha", dstFactor: "one-minus-src-alpha" },
+        alpha: { srcFactor: "one", dstFactor: "one-minus-src-alpha" }
+      },
+      draw: ({ samples }) => Math.max(0, samples * 6),
+      bindings: [
+        { binding: 0, source: "uniforms" },
+        { binding: 1, source: "x-data" },
+        { binding: 2, source: "y-data" },
+        { binding: 3, source: "custom-uniforms" },
+        { binding: 4, source: "h-data" },
+        { binding: 5, source: "t-data" },
+        { binding: 6, source: "bw-data" }
+      ]
+    }
+  ],
+  computeBounds(series) {
+    let minX = Infinity, maxX = -Infinity, minY = Infinity, maxY = -Infinity;
+    for (const s of series) {
+      for (let i = 0;i < s.rawX.length; i++) {
+        const x = s.rawX[i];
+        const barBottom = s.rawY[i];
+        const barHeight = s.extra["h"]?.[i] ?? 0;
+        const barTop = barBottom + barHeight;
+        if (x < minX)
+          minX = x;
+        if (x > maxX)
+          maxX = x;
+        if (barBottom < minY)
+          minY = barBottom;
+        if (barTop > maxY)
+          maxY = barTop;
+      }
+    }
+    if (!isFinite(minX))
+      return { minX: 0, maxX: 1, minY: 0, maxY: 1 };
+    const px = (maxX - minX) * 0.05 || 1;
+    const py = (maxY - minY) * 0.1 || 0.1;
+    return { minX: minX - px, maxX: maxX + px, minY: minY - py, maxY: maxY + py };
+  }
+};
+export {
+  prepareWaterfall,
+  WaterfallChart
+};

package/dist/charts/experimental/waterfall.min.js

@@ -0,0 +1,7 @@
+import{b as M}from"../../chunk-g2qmt43n.js";import{g as P}from"../../chunk-64q9a7nw.js";import"../../chunk-bbyt23tw.js";var D=`
+struct WaterfallUniforms {
+  upColor:    u32,
+  downColor:  u32,
+  totalColor: u32,
+  _pad:       u32,
+};`,f=`${P}${D}@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<uniform> wu: WaterfallUniforms;@group(0)@binding(4)var<storage,read> dataH: array<f32>;@group(0)@binding(5)var<storage,read> dataT: array<f32>;@group(0)@binding(6)var<storage,read> dataBW: array<f32>;struct VertexOutput{@builtin(position)pos: vec4f,@location(0)@interpolate(flat)colorType: f32,};@vertex fn vs(@builtin(vertex_index)vi: u32)-> VertexOutput{var out: VertexOutput;let barIdx = vi / 6u;let vertexType = vi % 6u;let count = u.pointCount;if(barIdx >= count){out.pos = vec4f(0.0,0.0,0.0,1.0);out.colorType = 0.0;return out;}let x = dataX[barIdx];let barBottom = dataY[barIdx];let barHeight = max(dataH[barIdx],0.0);let barTop = barBottom + barHeight;let barWidth = dataBW[barIdx];let viewRangeX = u.viewMaxX - u.viewMinX;let viewRangeY = u.viewMaxY - u.viewMinY;let safeRangeX = select(viewRangeX,1.0,viewRangeX < 0.0001);let safeRangeY = select(viewRangeY,1.0,viewRangeY < 0.0001);let screenX =(x - u.viewMinX)/ safeRangeX;let halfW =(barWidth * 0.5)/ safeRangeX;let left = screenX - halfW;let right = screenX + halfW;let normBottom =(barBottom - u.viewMinY)/ safeRangeY;let normTop =(barTop - u.viewMinY)/ safeRangeY;let sBottom = max(1.0 - normBottom,1.0 - normTop);let sTop = min(1.0 - normBottom,1.0 - normTop);var positions = array<vec2f,6>(vec2f(left,sBottom),vec2f(right,sBottom),vec2f(left,sTop),vec2f(left,sTop),vec2f(right,sBottom),vec2f(right,sTop));let sp = positions[vertexType];out.pos = vec4f(sp.x * 2.0 - 1.0,1.0 - sp.y * 2.0,0.0,1.0);out.colorType = dataT[barIdx];return out;}@fragment fn fs(in: VertexOutput)-> @location(0)vec4f{let upRgb = unpack4x8unorm(wu.upColor).rgb;let downRgb = unpack4x8unorm(wu.downColor).rgb;let totalRgb = unpack4x8unorm(wu.totalColor).rgb;var color: vec3f;if(in.colorType < 0.5){color = upRgb;}else if(in.colorType < 1.5){color = downRgb;}else{color = totalRgb;}return vec4f(color,0.9);}`;function F(v,Q,I){let q=Q.length,K=Array(q),V=Array(q),Z=Array(q),$=Array(q),z=0;for(let j=0;j<q;j++){let J=(I?.[j]??0)>0.5,C=Q[j];if(J)K[j]=Math.min(0,z),V[j]=Math.abs(z),Z[j]=2;else{if(C>=0)K[j]=z,V[j]=C,Z[j]=0;else K[j]=z+C,V[j]=Math.abs(C),Z[j]=1;z+=C}}for(let j=0;j<q;j++){let J;if(q<=1)J=1;else if(j===0)J=v[1]-v[0];else if(j===q-1)J=v[q-1]-v[q-2];else J=Math.min(v[j+1]-v[j],v[j]-v[j-1]);$[j]=J*0.8}return{x:v,y:K,h:V,t:Z,bw:$}}var G={name:"waterfall",shaders:{render:f},uniforms:[{name:"upColor",type:"u32",default:M(0.2,0.7,0.3)},{name:"downColor",type:"u32",default:M(0.9,0.3,0.3)},{name:"totalColor",type:"u32",default:M(0.5,0.5,0.6)}],passes:[{type:"render",shader:"render",topology:"triangle-list",loadOp:"load",perSeries:!0,blend:{color:{srcFactor:"src-alpha",dstFactor:"one-minus-src-alpha"},alpha:{srcFactor:"one",dstFactor:"one-minus-src-alpha"}},draw:({samples:v})=>Math.max(0,v*6),bindings:[{binding:0,source:"uniforms"},{binding:1,source:"x-data"},{binding:2,source:"y-data"},{binding:3,source:"custom-uniforms"},{binding:4,source:"h-data"},{binding:5,source:"t-data"},{binding:6,source:"bw-data"}]}],computeBounds(v){let Q=1/0,I=-1/0,q=1/0,K=-1/0;for(let $ of v)for(let z=0;z<$.rawX.length;z++){let j=$.rawX[z],J=$.rawY[z],C=$.extra.h?.[z]??0,O=J+C;if(j<Q)Q=j;if(j>I)I=j;if(J<q)q=J;if(O>K)K=O}if(!isFinite(Q))return{minX:0,maxX:1,minY:0,maxY:1};let V=(I-Q)*0.05||1,Z=(K-q)*0.1||0.1;return{minX:Q-V,maxX:I+V,minY:q-Z,maxY:K+Z}}};export{F as prepareWaterfall,G as WaterfallChart};

package/dist/charts/line.d.ts

@@ -0,0 +1,12 @@
+import type { RendererPlugin } from "../types.ts";
+export interface LineConfig {
+    pointSize?: number;
+    maxSamplesPerPixel?: number;
+}
+declare module "../types.ts" {
+    interface ChartTypeRegistry {
+        line: LineConfig;
+    }
+}
+export declare const LineChart: RendererPlugin;
+//# sourceMappingURL=line.d.ts.map

package/dist/charts/line.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"line.d.ts","sourceRoot":"","sources":["../../src/charts/line.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAIlD,MAAM,WAAW,UAAU;IACzB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,kBAAkB,CAAC,EAAE,MAAM,CAAC;CAC7B;AAED,OAAO,QAAQ,aAAa,CAAC;IAC3B,UAAU,iBAAiB;QACzB,IAAI,EAAE,UAAU,CAAC;KAClB;CACF;AAED,eAAO,MAAM,SAAS,EAAE,cAiDvB,CAAC"}

package/dist/charts/line.js

@@ -0,0 +1,62 @@
+import {
+  LINE_COMPUTE_SHADER,
+  LINE_RENDER_SHADER
+} from "../chunk-yabjrff2.js";
+import {
+  COMPUTE_WG
+} from "../chunk-0jepamv9.js";
+import"../chunk-5gtx3pza.js";
+
+// src/charts/line.ts
+var LineChart = {
+  name: "line",
+  shaders: {
+    compute: LINE_COMPUTE_SHADER,
+    render: LINE_RENDER_SHADER
+  },
+  uniforms: [
+    { name: "maxSamplesPerPixel", type: "u32", default: 1e4 }
+  ],
+  buffers: [
+    {
+      name: "lineBuffer",
+      bytes: ({ width }) => Math.max(16, width * 4 * 4),
+      usages: ["STORAGE"]
+    }
+  ],
+  passes: [
+    {
+      type: "compute",
+      shader: "compute",
+      perSeries: true,
+      dispatch: ({ width }) => ({ x: Math.ceil(Math.max(1, width) / COMPUTE_WG) }),
+      bindings: [
+        { binding: 0, source: "uniforms" },
+        { binding: 1, source: "x-data" },
+        { binding: 2, source: "y-data" },
+        { binding: 3, source: "lineBuffer", write: true },
+        { binding: 4, source: "series-info" },
+        { binding: 5, source: "custom-uniforms" }
+      ]
+    },
+    {
+      type: "render",
+      shader: "render",
+      topology: "line-list",
+      loadOp: "load",
+      blend: {
+        color: { srcFactor: "src-alpha", dstFactor: "one-minus-src-alpha" },
+        alpha: { srcFactor: "one", dstFactor: "one-minus-src-alpha" }
+      },
+      draw: ({ width }) => Math.max(0, width * 4 - 2),
+      bindings: [
+        { binding: 0, source: "uniforms" },
+        { binding: 1, source: "lineBuffer" },
+        { binding: 2, source: "series-info" }
+      ]
+    }
+  ]
+};
+export {
+  LineChart
+};

package/dist/charts/line.min.js

@@ -0,0 +1 @@
+import{d as k,e as q}from"../chunk-gm0d4cgx.js";import{f as j}from"../chunk-64q9a7nw.js";import"../chunk-bbyt23tw.js";var F={name:"line",shaders:{compute:k,render:q},uniforms:[{name:"maxSamplesPerPixel",type:"u32",default:1e4}],buffers:[{name:"lineBuffer",bytes:({width:b})=>Math.max(16,b*4*4),usages:["STORAGE"]}],passes:[{type:"compute",shader:"compute",perSeries:!0,dispatch:({width:b})=>({x:Math.ceil(Math.max(1,b)/j)}),bindings:[{binding:0,source:"uniforms"},{binding:1,source:"x-data"},{binding:2,source:"y-data"},{binding:3,source:"lineBuffer",write:!0},{binding:4,source:"series-info"},{binding:5,source:"custom-uniforms"}]},{type:"render",shader:"render",topology:"line-list",loadOp:"load",blend:{color:{srcFactor:"src-alpha",dstFactor:"one-minus-src-alpha"},alpha:{srcFactor:"one",dstFactor:"one-minus-src-alpha"}},draw:({width:b})=>Math.max(0,b*4-2),bindings:[{binding:0,source:"uniforms"},{binding:1,source:"lineBuffer"},{binding:2,source:"series-info"}]}]};export{F as LineChart};

package/dist/charts/scatter.d.ts

@@ -0,0 +1,11 @@
+import type { RendererPlugin } from "../types.ts";
+export interface ScatterConfig {
+    pointSize?: number;
+}
+declare module "../types.ts" {
+    interface ChartTypeRegistry {
+        scatter: ScatterConfig;
+    }
+}
+export declare const ScatterChart: RendererPlugin;
+//# sourceMappingURL=scatter.d.ts.map

package/dist/charts/scatter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scatter.d.ts","sourceRoot":"","sources":["../../src/charts/scatter.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAIlD,MAAM,WAAW,aAAa;IAC5B,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED,OAAO,QAAQ,aAAa,CAAC;IAC3B,UAAU,iBAAiB;QACzB,OAAO,EAAE,aAAa,CAAC;KACxB;CACF;AAID,eAAO,MAAM,YAAY,EAAE,cA+B1B,CAAC"}

package/dist/charts/scatter.js

@@ -0,0 +1,46 @@
+import {
+  COMPUTE_WG,
+  UNIFORM_STRUCT
+} from "../chunk-0jepamv9.js";
+import"../chunk-5gtx3pza.js";
+
+// src/shaders/scatter.ts
+var SCATTER_COMPUTE_SHADER = `${UNIFORM_STRUCT}struct ScatterUniforms{dispatchXCount: u32,pointSize: 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 outputTex: texture_storage_2d<rgba8unorm,write>;@group(0)@binding(4)var<storage,read> allSeries: array<SeriesInfo>;@group(0)@binding(5)var<uniform> seriesIdx: SeriesIndex;@group(0)@binding(6)var<uniform> su: ScatterUniforms;@compute @workgroup_size(${COMPUTE_WG})fn main(@builtin(global_invocation_id)id: vec3u){let series = allSeries[seriesIdx.index];let visStart = series.visibleRange.x;let visCount = series.visibleRange.y;let localIdx = id.y * su.dispatchXCount + id.x;if(localIdx >= visCount){return;}let idx = visStart + localIdx;let count = u.pointCount;if(idx >= count){return;}let x = dataX[idx];let y = dataY[idx];if(y < u.viewMinY || y > u.viewMaxY){return;}let width = u32(u.width);let height = u32(u.height);let rangeX = u.viewMaxX - u.viewMinX;let rangeY = u.viewMaxY - u.viewMinY;if(rangeX < 0.0001 || rangeY < 0.0001){return;}let normX =(x - u.viewMinX)/ rangeX;let normY =(y - u.viewMinY)/ rangeY;let screenX = normX;let screenY = 1.0 - normY;let pixelX = i32(screenX * f32(width));let pixelY = i32(screenY * f32(height));if(idx > visStart){let prevX = dataX[idx - 1u];let prevY = dataY[idx - 1u];let prevNormX =(prevX - u.viewMinX)/ rangeX;let prevNormY =(prevY - u.viewMinY)/ rangeY;let prevPx = i32(prevNormX * f32(width));let prevPy = i32((1.0 - prevNormY)* f32(height));if(pixelX == prevPx && pixelY == prevPy){return;}}let iWidth = i32(width);let iHeight = i32(height);if(pixelX < 0 || pixelX >= iWidth){return;}if(pixelY < 0 || pixelY >= iHeight){return;}let color = series.color;let radius = i32(su.pointSize);for(var dy = -radius;dy <= radius;dy++){for(var dx = -radius;dx <= radius;dx++){if(dx * dx + dy * dy > radius * radius){continue;}let px = pixelX + dx;let py = pixelY + dy;if(px >= 0 && px < iWidth && py >= 0 && py < iHeight){textureStore(outputTex,vec2i(px,py),color);}}}}`;
+
+// src/charts/scatter.ts
+var MAX_WG_DIM = 65535;
+var ScatterChart = {
+  name: "scatter",
+  shaders: {
+    compute: SCATTER_COMPUTE_SHADER
+  },
+  uniforms: [
+    { name: "dispatchXCount", type: "u32", default: 1 },
+    { name: "pointSize", type: "f32", default: 3 }
+  ],
+  passes: [
+    {
+      type: "compute",
+      shader: "compute",
+      perSeries: true,
+      dispatch: ({ samples }) => {
+        const totalWG = Math.ceil(Math.max(1, samples) / COMPUTE_WG);
+        const wgX = Math.min(totalWG, MAX_WG_DIM);
+        const wgY = Math.ceil(totalWG / MAX_WG_DIM);
+        return { x: wgX, y: wgY, xCount: wgX * COMPUTE_WG };
+      },
+      bindings: [
+        { binding: 0, source: "uniforms" },
+        { binding: 1, source: "x-data" },
+        { binding: 2, source: "y-data" },
+        { binding: 3, source: "render-target", write: true },
+        { binding: 4, source: "series-info" },
+        { binding: 5, source: "series-index" },
+        { binding: 6, source: "custom-uniforms" }
+      ]
+    }
+  ]
+};
+export {
+  ScatterChart
+};

package/dist/charts/scatter.min.js

@@ -0,0 +1 @@
+import{f as e,g as t}from"../chunk-64q9a7nw.js";import"../chunk-bbyt23tw.js";var n=`${t}struct ScatterUniforms{dispatchXCount: u32,pointSize: 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 outputTex: texture_storage_2d<rgba8unorm,write>;@group(0)@binding(4)var<storage,read> allSeries: array<SeriesInfo>;@group(0)@binding(5)var<uniform> seriesIdx: SeriesIndex;@group(0)@binding(6)var<uniform> su: ScatterUniforms;@compute @workgroup_size(${e})fn main(@builtin(global_invocation_id)id: vec3u){let series = allSeries[seriesIdx.index];let visStart = series.visibleRange.x;let visCount = series.visibleRange.y;let localIdx = id.y * su.dispatchXCount + id.x;if(localIdx >= visCount){return;}let idx = visStart + localIdx;let count = u.pointCount;if(idx >= count){return;}let x = dataX[idx];let y = dataY[idx];if(y < u.viewMinY || y > u.viewMaxY){return;}let width = u32(u.width);let height = u32(u.height);let rangeX = u.viewMaxX - u.viewMinX;let rangeY = u.viewMaxY - u.viewMinY;if(rangeX < 0.0001 || rangeY < 0.0001){return;}let normX =(x - u.viewMinX)/ rangeX;let normY =(y - u.viewMinY)/ rangeY;let screenX = normX;let screenY = 1.0 - normY;let pixelX = i32(screenX * f32(width));let pixelY = i32(screenY * f32(height));if(idx > visStart){let prevX = dataX[idx - 1u];let prevY = dataY[idx - 1u];let prevNormX =(prevX - u.viewMinX)/ rangeX;let prevNormY =(prevY - u.viewMinY)/ rangeY;let prevPx = i32(prevNormX * f32(width));let prevPy = i32((1.0 - prevNormY)* f32(height));if(pixelX == prevPx && pixelY == prevPy){return;}}let iWidth = i32(width);let iHeight = i32(height);if(pixelX < 0 || pixelX >= iWidth){return;}if(pixelY < 0 || pixelY >= iHeight){return;}let color = series.color;let radius = i32(su.pointSize);for(var dy = -radius;dy <= radius;dy++){for(var dx = -radius;dx <= radius;dx++){if(dx * dx + dy * dy > radius * radius){continue;}let px = pixelX + dx;let py = pixelY + dy;if(px >= 0 && px < iWidth && py >= 0 && py < iHeight){textureStore(outputTex,vec2i(px,py),color);}}}}`;var a=65535,g={name:"scatter",shaders:{compute:n},uniforms:[{name:"dispatchXCount",type:"u32",default:1},{name:"pointSize",type:"f32",default:3}],passes:[{type:"compute",shader:"compute",perSeries:!0,dispatch:({samples:o})=>{let i=Math.ceil(Math.max(1,o)/e),r=Math.min(i,a),u=Math.ceil(i/a);return{x:r,y:u,xCount:r*e}},bindings:[{binding:0,source:"uniforms"},{binding:1,source:"x-data"},{binding:2,source:"y-data"},{binding:3,source:"render-target",write:!0},{binding:4,source:"series-info"},{binding:5,source:"series-index"},{binding:6,source:"custom-uniforms"}]}]};export{g as ScatterChart};

package/dist/chunk-0eh4rzy9.min.js

@@ -0,0 +1,2 @@
+var t={left:55,right:10,top:8,bottom:45};
+export{t as o};

package/dist/chunk-0jepamv9.js

@@ -0,0 +1,7 @@
+// src/shaders/shared.ts
+var COMPUTE_WG = 256;
+var UNIFORM_STRUCT = `struct Uniforms{width: f32,height: f32,viewMinX: f32,viewMaxX: f32,viewMinY: f32,viewMaxY: f32,pointCount: u32,seriesCount: u32,isDark: u32,bgR: f32,bgG: f32,bgB: f32,dataMinX: f32,dataMaxX: f32,dataMinY: f32,dataMaxY: f32,};struct SeriesInfo{color: vec4f,visibleRange: vec2u,_pad0: f32,_pad1: f32,};struct SeriesIndex{index: u32,_pad0: u32,_pad1: u32,_pad2: u32,};`;
+var BINARY_SEARCH = `fn lowerBound(val: f32,count: u32)-> u32{var lo = 0u;var hi = count;while(lo < hi){let mid =(lo + hi)/ 2u;if(dataX[mid] < val){lo = mid + 1u;}else{hi = mid;}}return lo;}`;
+var BLIT_SHADER = `fn luma(c:vec4f)->f32{return dot(c.rgb,vec3f(.299,.587,.114));}fn laaa(uv:vec2f,t:texture_2d<f32>,s:sampler)->vec4f{let r=1./vec2f(textureDimensions(t));let m=textureSample(t,s,uv);let n=textureSample(t,s,uv+vec2f(0.,-r.y));let e=textureSample(t,s,uv+vec2f(r.x,0.));let w=textureSample(t,s,uv+vec2f(-r.x,0.));let sv=textureSample(t,s,uv+vec2f(0.,r.y));let lm=luma(m);let ln=luma(n);let le=luma(e);let lw=luma(w);let ls=luma(sv);let lo=min(lm,min(min(ln,ls),min(le,lw)));let hi=max(lm,max(max(ln,ls),max(le,lw)));let rng=hi-lo;if(rng<max(.0833,hi*.166)){return m;}return mix(m,(m+n+e+w+sv)*.2,min(rng*3.,1.));}struct BV{@builtin(position)p:vec4f,@location(0)uv:vec2f}@group(0)@binding(0)var inputTex:texture_2d<f32>;@group(0)@binding(1)var samp:sampler;@vertex fn vs(@builtin(vertex_index)i:u32)->BV{var p=array<vec2f,4>(vec2f(-1,-1),vec2f(1,-1),vec2f(-1,1),vec2f(1,1));var u=array<vec2f,4>(vec2f(0,1),vec2f(1,1),vec2f(0,0),vec2f(1,0));return BV(vec4f(p[i],0,1),u[i]);}@fragment fn fs(v:BV)->@location(0)vec4f{return laaa(v.uv,inputTex,samp);}`;
+
+export { COMPUTE_WG, UNIFORM_STRUCT, BINARY_SEARCH, BLIT_SHADER };