@astryxdesign/lab 0.0.0-bootstrap.0 → 0.1.2-canary.04e71b2

package/dist/ThreeD/ThreeDGrid.js

@@ -0,0 +1,55 @@
+// Copyright (c) Meta Platforms, Inc. and affiliates.
+
+/**
+ * @file ThreeDGrid.tsx
+ * @output 3D wireframe grid on the floor plane (y=0)
+ */
+
+import { useMemo } from 'react';
+import { use3D } from "./ThreeDContext.js";
+import { jsx as _jsx } from "react/jsx-runtime";
+export function ThreeDGrid({
+  divisions = 5
+}) {
+  const {
+    project
+  } = use3D();
+  const lines = useMemo(() => {
+    const result = [];
+    for (let i = 0; i <= divisions; i++) {
+      const t = i / divisions;
+      // X-parallel lines (along z)
+      const a = project(t, 0, 0);
+      const b = project(t, 0, 1);
+      result.push({
+        x1: a.px,
+        y1: a.py,
+        x2: b.px,
+        y2: b.py,
+        depth: (a.depth + b.depth) / 2
+      });
+      // Z-parallel lines (along x)
+      const c = project(0, 0, t);
+      const d = project(1, 0, t);
+      result.push({
+        x1: c.px,
+        y1: c.py,
+        x2: d.px,
+        y2: d.py,
+        depth: (c.depth + d.depth) / 2
+      });
+    }
+    return result.sort((a, b) => a.depth - b.depth);
+  }, [project, divisions]);
+  return /*#__PURE__*/_jsx("g", {
+    children: lines.map((l, i) => /*#__PURE__*/_jsx("line", {
+      x1: l.x1,
+      y1: l.y1,
+      x2: l.x2,
+      y2: l.y2,
+      stroke: "var(--color-border)",
+      strokeOpacity: 0.3,
+      strokeWidth: 1
+    }, i))
+  });
+}

package/dist/ThreeD/ThreeDScatter.d.ts

@@ -0,0 +1,7 @@
+export interface ThreeDScatterProps {
+    color: string;
+    radius?: number;
+    opacity?: number;
+}
+export declare function ThreeDScatter({ color, radius, opacity, }: ThreeDScatterProps): import("react").JSX.Element;
+//# sourceMappingURL=ThreeDScatter.d.ts.map

package/dist/ThreeD/ThreeDScatter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ThreeDScatter.d.ts","sourceRoot":"","sources":["../../src/ThreeD/ThreeDScatter.tsx"],"names":[],"mappings":"AAUA,MAAM,WAAW,kBAAkB;IACjC,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED,wBAAgB,aAAa,CAAC,EAC5B,KAAK,EACL,MAAU,EACV,OAAc,GACf,EAAE,kBAAkB,+BA0CpB"}

package/dist/ThreeD/ThreeDScatter.js

@@ -0,0 +1,57 @@
+// Copyright (c) Meta Platforms, Inc. and affiliates.
+
+/**
+ * @file ThreeDScatter.tsx
+ * @output 3D scatter plot — projected circles with depth-based sizing/opacity
+ */
+
+import { useMemo } from 'react';
+import { use3D } from "./ThreeDContext.js";
+import { jsx as _jsx } from "react/jsx-runtime";
+export function ThreeDScatter({
+  color,
+  radius = 4,
+  opacity = 0.85
+}) {
+  const {
+    data,
+    xKey,
+    yKey,
+    zKey,
+    project,
+    xDomain,
+    yDomain,
+    zDomain,
+    normalize
+  } = use3D();
+  const points = useMemo(() => {
+    return data.map((d, i) => {
+      const nx = normalize(d[xKey], xDomain);
+      const ny = normalize(d[yKey], yDomain);
+      const nz = normalize(d[zKey], zDomain);
+      const {
+        px,
+        py,
+        depth
+      } = project(nx, ny, nz);
+      return {
+        px,
+        py,
+        depth,
+        index: i
+      };
+    }).sort((a, b) => a.depth - b.depth); // painter's algorithm
+  }, [data, xKey, yKey, zKey, project, xDomain, yDomain, zDomain, normalize]);
+  return /*#__PURE__*/_jsx("g", {
+    children: points.map(p => {
+      const depthFactor = 0.75 + (p.depth + 0.5) * 0.25; // 0.5-1.0
+      return /*#__PURE__*/_jsx("circle", {
+        cx: p.px,
+        cy: p.py,
+        r: radius * depthFactor,
+        fill: color,
+        fillOpacity: opacity * depthFactor
+      }, p.index);
+    })
+  });
+}

package/dist/ThreeD/ThreeDScatterGL.d.ts

@@ -0,0 +1,7 @@
+export interface ThreeDScatterGLProps {
+    color: string;
+    size?: number;
+    opacity?: number;
+}
+export declare function ThreeDScatterGL({ color, size, opacity, }: ThreeDScatterGLProps): import("react").JSX.Element | null;
+//# sourceMappingURL=ThreeDScatterGL.d.ts.map

package/dist/ThreeD/ThreeDScatterGL.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ThreeDScatterGL.d.ts","sourceRoot":"","sources":["../../src/ThreeD/ThreeDScatterGL.tsx"],"names":[],"mappings":"AAkBA,MAAM,WAAW,oBAAoB;IACnC,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AA4FD,wBAAgB,eAAe,CAAC,EAC9B,KAAK,EACL,IAAQ,EACR,OAAc,GACf,EAAE,oBAAoB,sCAuJtB"}

package/dist/ThreeD/ThreeDScatterGL.js

@@ -0,0 +1,243 @@
+// Copyright (c) Meta Platforms, Inc. and affiliates.
+
+/**
+ * @file ThreeDScatterGL.tsx
+ * @output WebGL 3D scatter — canvas overlaid outside SVG for sharp DPR rendering
+ * @position Child of ThreeDChart; reads camera from context (Tier 1)
+ *
+ * SYNC: The vertex shader replicates ThreeDChart's project() math exactly.
+ * Verified by projection.test.ts.
+ *
+ * The canvas renders as an absolute-positioned sibling to the SVG (not inside
+ * foreignObject) to avoid the browser's 1x compositing of foreignObject content
+ * on Retina displays.
+ */
+
+import { useRef, useEffect, useMemo } from 'react';
+import { use3D } from "./ThreeDContext.js";
+import { jsx as _jsx } from "react/jsx-runtime";
+function hexToGL(hex) {
+  const n = parseInt(hex.replace('#', ''), 16);
+  return [(n >> 16) / 255, (n >> 8 & 0xff) / 255, (n & 0xff) / 255];
+}
+
+// SYNC: Steps 1-5 match ThreeDChart.project() exactly.
+const VERT = `
+  attribute vec3 a_position;
+  uniform vec2 u_resolution;
+  uniform vec2 u_center;
+  uniform float u_scale;
+  uniform float u_cosAz;
+  uniform float u_sinAz;
+  uniform float u_cosEl;
+  uniform float u_sinEl;
+  uniform float u_size;
+  varying float v_depth;
+  void main() {
+    vec3 p = a_position - 0.5;
+    float x1 = p.x * u_cosAz + p.z * u_sinAz;
+    float z1 = -p.x * u_sinAz + p.z * u_cosAz;
+    float y1 = p.y * u_cosEl - z1 * u_sinEl;
+    float z2 = p.y * u_sinEl + z1 * u_cosEl;
+    float px = u_center.x + x1 * u_scale;
+    float py = u_center.y - y1 * u_scale;
+    vec2 clip = (vec2(px, py) / u_resolution) * 2.0 - 1.0;
+    gl_Position = vec4(clip.x, -clip.y, z2, 1.0);
+    v_depth = z2;
+    float depthFactor = 0.75 + (z2 + 0.5) * 0.25;
+    // Compensate for smoothstep edge erosion (visible at r=0.48, not 0.5)
+    // so visible circle matches SVG radius exactly
+    gl_PointSize = (u_size * depthFactor) / 0.96;
+  }
+`;
+const FRAG = `
+  precision mediump float;
+  uniform vec3 u_color;
+  uniform float u_opacity;
+  varying float v_depth;
+  void main() {
+    vec2 coord = gl_PointCoord - vec2(0.5);
+    float dist = length(coord);
+    if (dist > 0.5) discard;
+    float edge = 1.0 - smoothstep(0.48, 0.5, dist);
+    float depthFactor = 0.75 + (v_depth + 0.5) * 0.25;
+    float a = u_opacity * depthFactor * edge;
+    // Premultiplied alpha — required for correct compositing over page
+    gl_FragColor = vec4(u_color * a, a);
+  }
+`;
+function compileShader(gl, type, src) {
+  const s = gl.createShader(type);
+  if (!s) {
+    return null;
+  }
+  gl.shaderSource(s, src);
+  gl.compileShader(s);
+  if (!gl.getShaderParameter(s, gl.COMPILE_STATUS)) {
+    gl.deleteShader(s);
+    return null;
+  }
+  return s;
+}
+function createProgram(gl) {
+  const vs = compileShader(gl, gl.VERTEX_SHADER, VERT);
+  const fs = compileShader(gl, gl.FRAGMENT_SHADER, FRAG);
+  if (!vs || !fs) {
+    return null;
+  }
+  const p = gl.createProgram();
+  if (!p) {
+    return null;
+  }
+  gl.attachShader(p, vs);
+  gl.attachShader(p, fs);
+  gl.linkProgram(p);
+  if (!gl.getProgramParameter(p, gl.LINK_STATUS)) {
+    gl.deleteProgram(p);
+    return null;
+  }
+  return p;
+}
+export function ThreeDScatterGL({
+  color,
+  size = 4,
+  opacity = 0.85
+}) {
+  const {
+    data,
+    xKey,
+    yKey,
+    zKey,
+    xDomain,
+    yDomain,
+    zDomain,
+    normalize,
+    camera,
+    width,
+    height
+  } = use3D();
+  const canvasRef = useRef(null);
+  const containerRef = useRef(null);
+  const glRef = useRef(null);
+  const programRef = useRef(null);
+  const markerRef = useRef(null);
+
+  // Normalized 3D positions
+  const positions = useMemo(() => {
+    const buf = new Float32Array(data.length * 3);
+    for (let i = 0; i < data.length; i++) {
+      buf[i * 3] = normalize(data[i][xKey], xDomain);
+      buf[i * 3 + 1] = normalize(data[i][yKey], yDomain);
+      buf[i * 3 + 2] = normalize(data[i][zKey], zDomain);
+    }
+    return buf;
+  }, [data, xKey, yKey, zKey, xDomain, yDomain, zDomain, normalize]);
+
+  // Mount canvas as sibling to SVG
+  useEffect(() => {
+    const marker = markerRef.current;
+    if (!marker) {
+      return;
+    }
+    const svg = marker.ownerSVGElement;
+    if (!svg) {
+      return;
+    }
+    const parent = svg.parentElement;
+    if (!parent) {
+      return;
+    }
+
+    // Ensure parent is positioned for absolute child
+    if (getComputedStyle(parent).position === 'static') {
+      parent.style.position = 'relative';
+    }
+
+    // Create canvas if not exists
+    if (!canvasRef.current) {
+      const canvas = document.createElement('canvas');
+      canvas.style.position = 'absolute';
+      canvas.style.top = '0';
+      canvas.style.left = '0';
+      canvas.style.pointerEvents = 'none';
+      canvasRef.current = canvas;
+    }
+    const canvas = canvasRef.current;
+    parent.appendChild(canvas);
+    containerRef.current = parent;
+    return () => {
+      if (canvas.parentElement) {
+        canvas.parentElement.removeChild(canvas);
+      }
+    };
+  }, []);
+
+  // Draw
+  useEffect(() => {
+    const canvas = canvasRef.current;
+    if (!canvas || width <= 0 || height <= 0) {
+      return;
+    }
+    const dpr = (window.devicePixelRatio || 2) * 2; // 2x supersampling + smoothstep for crisp circles // supersampling for crisp circles
+    canvas.width = width * dpr;
+    canvas.height = height * dpr;
+    canvas.style.width = `${width}px`;
+    canvas.style.height = `${height}px`;
+    if (!glRef.current) {
+      glRef.current = canvas.getContext('webgl', {
+        alpha: true,
+        premultipliedAlpha: true,
+        antialias: true
+      });
+    }
+    const gl = glRef.current;
+    if (!gl) {
+      return;
+    }
+    if (!programRef.current) {
+      programRef.current = createProgram(gl);
+    }
+    const program = programRef.current;
+    if (!program) {
+      return;
+    }
+    const buf = gl.createBuffer();
+    gl.bindBuffer(gl.ARRAY_BUFFER, buf);
+    gl.bufferData(gl.ARRAY_BUFFER, positions, gl.STATIC_DRAW);
+    gl.viewport(0, 0, canvas.width, canvas.height);
+    gl.clearColor(0, 0, 0, 0);
+    gl.clear(gl.COLOR_BUFFER_BIT);
+    gl.enable(gl.BLEND);
+    gl.blendFunc(gl.ONE, gl.ONE_MINUS_SRC_ALPHA);
+    gl.useProgram(program);
+    const aPos = gl.getAttribLocation(program, 'a_position');
+    gl.enableVertexAttribArray(aPos);
+    gl.vertexAttribPointer(aPos, 3, gl.FLOAT, false, 0, 0);
+
+    // All uniforms in logical pixels — viewport handles DPR
+    const azRad = camera.azimuth * Math.PI / 180;
+    const elRad = camera.elevation * Math.PI / 180;
+    const scale = Math.min(width, height) * 0.35;
+    const [r, g, b] = hexToGL(color);
+    gl.uniform2f(gl.getUniformLocation(program, 'u_resolution'), width, height);
+    gl.uniform2f(gl.getUniformLocation(program, 'u_center'), width / 2, height / 2);
+    gl.uniform1f(gl.getUniformLocation(program, 'u_scale'), scale);
+    gl.uniform1f(gl.getUniformLocation(program, 'u_cosAz'), Math.cos(azRad));
+    gl.uniform1f(gl.getUniformLocation(program, 'u_sinAz'), Math.sin(azRad));
+    gl.uniform1f(gl.getUniformLocation(program, 'u_cosEl'), Math.cos(elRad));
+    gl.uniform1f(gl.getUniformLocation(program, 'u_sinEl'), Math.sin(elRad));
+    gl.uniform3f(gl.getUniformLocation(program, 'u_color'), r, g, b);
+    gl.uniform1f(gl.getUniformLocation(program, 'u_size'), size * dpr);
+    gl.uniform1f(gl.getUniformLocation(program, 'u_opacity'), opacity);
+    gl.drawArrays(gl.POINTS, 0, data.length);
+    gl.deleteBuffer(buf);
+  }, [positions, camera, color, size, opacity, width, height, data.length]);
+  if (width <= 0 || height <= 0) {
+    return null;
+  }
+
+  // Render an invisible SVG marker — the canvas is mounted imperatively as a sibling
+  return /*#__PURE__*/_jsx("g", {
+    ref: markerRef
+  });
+}

package/dist/ThreeD/ThreeDSurface.d.ts

@@ -0,0 +1,15 @@
+export interface ThreeDSurfaceProps {
+    /**
+     * Color ramp for surface height — low to high.
+     * Use useChartColors().sequential.blue(5).
+     */
+    colorRange: string[];
+    opacity?: number;
+    wireframe?: boolean;
+}
+/**
+ * 3D surface mesh. Data should be a grid of points with x, y (height), z.
+ * Points are triangulated in order and colored by y-value.
+ */
+export declare function ThreeDSurface({ colorRange, opacity, wireframe, }: ThreeDSurfaceProps): import("react").JSX.Element;
+//# sourceMappingURL=ThreeDSurface.d.ts.map

package/dist/ThreeD/ThreeDSurface.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ThreeDSurface.d.ts","sourceRoot":"","sources":["../../src/ThreeD/ThreeDSurface.tsx"],"names":[],"mappings":"AAUA,MAAM,WAAW,kBAAkB;IACjC;;;OAGG;IACH,UAAU,EAAE,MAAM,EAAE,CAAC;IACrB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,SAAS,CAAC,EAAE,OAAO,CAAC;CACrB;AAcD;;;GAGG;AACH,wBAAgB,aAAa,CAAC,EAC5B,UAAU,EACV,OAAa,EACb,SAAiB,GAClB,EAAE,kBAAkB,+BAqGpB"}

package/dist/ThreeD/ThreeDSurface.js

@@ -0,0 +1,97 @@
+// Copyright (c) Meta Platforms, Inc. and affiliates.
+
+/**
+ * @file ThreeDSurface.tsx
+ * @output 3D surface mesh — projected triangulated grid with color mapping
+ */
+
+import { useMemo } from 'react';
+import { use3D } from "./ThreeDContext.js";
+import { jsx as _jsx } from "react/jsx-runtime";
+function lerpColor(colors, t) {
+  const clamped = Math.max(0, Math.min(1, t));
+  if (colors.length === 1) {
+    return colors[0];
+  }
+  const scaled = clamped * (colors.length - 1);
+  const lo = Math.floor(scaled);
+  const hi = Math.min(lo + 1, colors.length - 1);
+  // Simple: just return the nearest
+  return scaled - lo < 0.5 ? colors[lo] : colors[hi];
+}
+
+/**
+ * 3D surface mesh. Data should be a grid of points with x, y (height), z.
+ * Points are triangulated in order and colored by y-value.
+ */
+export function ThreeDSurface({
+  colorRange,
+  opacity = 0.8,
+  wireframe = false
+}) {
+  const {
+    data,
+    xKey,
+    yKey,
+    zKey,
+    project,
+    xDomain,
+    yDomain,
+    zDomain,
+    normalize
+  } = use3D();
+  const faces = useMemo(() => {
+    // Detect grid dimensions from unique x and z values
+    const xVals = [...new Set(data.map(d => d[xKey]))].sort((a, b) => a - b);
+    const zVals = [...new Set(data.map(d => d[zKey]))].sort((a, b) => a - b);
+    const cols = xVals.length;
+    const rows = zVals.length;
+    if (cols < 2 || rows < 2) {
+      return [];
+    }
+
+    // Build lookup grid
+    const grid = new Map();
+    for (const d of data) {
+      grid.set(`${d[xKey]},${d[zKey]}`, d);
+    }
+    const result = [];
+    for (let r = 0; r < rows - 1; r++) {
+      for (let c = 0; c < cols - 1; c++) {
+        const corners = [grid.get(`${xVals[c]},${zVals[r]}`), grid.get(`${xVals[c + 1]},${zVals[r]}`), grid.get(`${xVals[c + 1]},${zVals[r + 1]}`), grid.get(`${xVals[c]},${zVals[r + 1]}`)];
+        if (corners.some(c => !c)) {
+          continue;
+        }
+        const validCorners = corners.filter(c => c != null);
+        const projected = validCorners.map(d => {
+          const nx = normalize(d[xKey], xDomain);
+          const ny = normalize(d[yKey], yDomain);
+          const nz = normalize(d[zKey], zDomain);
+          return {
+            ...project(nx, ny, nz),
+            ny
+          };
+        });
+        const avgY = projected.reduce((s, p) => s + p.ny, 0) / 4;
+        const avgDepth = projected.reduce((s, p) => s + p.depth, 0) / 4;
+        const color = lerpColor(colorRange, avgY);
+        result.push({
+          points: projected.map(p => `${p.px},${p.py}`).join(' '),
+          color,
+          depth: avgDepth
+        });
+      }
+    }
+    return result.sort((a, b) => a.depth - b.depth);
+  }, [data, xKey, yKey, zKey, project, xDomain, yDomain, zDomain, normalize, colorRange]);
+  return /*#__PURE__*/_jsx("g", {
+    children: faces.map((f, i) => /*#__PURE__*/_jsx("polygon", {
+      points: f.points,
+      fill: wireframe ? 'none' : f.color,
+      fillOpacity: opacity,
+      stroke: wireframe ? f.color : f.color,
+      strokeWidth: wireframe ? 1 : 0.5,
+      strokeOpacity: wireframe ? 0.8 : 0.3
+    }, i))
+  });
+}

package/dist/ThreeD/index.d.ts

@@ -0,0 +1,10 @@
+export { ThreeDChart, type ThreeDChartProps } from './ThreeDChart';
+export { ThreeDScatter, type ThreeDScatterProps } from './ThreeDScatter';
+export { ThreeDScatterGL, type ThreeDScatterGLProps } from './ThreeDScatterGL';
+export { ThreeDBar, type ThreeDBarProps } from './ThreeDBar';
+export { ThreeDGrid, type ThreeDGridProps } from './ThreeDGrid';
+export { ThreeDAxis, type ThreeDAxisProps } from './ThreeDAxis';
+export { ThreeDSurface, type ThreeDSurfaceProps } from './ThreeDSurface';
+export { use3D } from './ThreeDContext';
+export type { ThreeDContext, Camera, Point3D, ProjectedPoint } from './types';
+//# sourceMappingURL=index.d.ts.map

package/dist/ThreeD/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/ThreeD/index.ts"],"names":[],"mappings":"AAEA,OAAO,EAAC,WAAW,EAAE,KAAK,gBAAgB,EAAC,MAAM,eAAe,CAAC;AACjE,OAAO,EAAC,aAAa,EAAE,KAAK,kBAAkB,EAAC,MAAM,iBAAiB,CAAC;AACvE,OAAO,EAAC,eAAe,EAAE,KAAK,oBAAoB,EAAC,MAAM,mBAAmB,CAAC;AAC7E,OAAO,EAAC,SAAS,EAAE,KAAK,cAAc,EAAC,MAAM,aAAa,CAAC;AAC3D,OAAO,EAAC,UAAU,EAAE,KAAK,eAAe,EAAC,MAAM,cAAc,CAAC;AAC9D,OAAO,EAAC,UAAU,EAAE,KAAK,eAAe,EAAC,MAAM,cAAc,CAAC;AAC9D,OAAO,EAAC,aAAa,EAAE,KAAK,kBAAkB,EAAC,MAAM,iBAAiB,CAAC;AACvE,OAAO,EAAC,KAAK,EAAC,MAAM,iBAAiB,CAAC;AACtC,YAAY,EAAC,aAAa,EAAE,MAAM,EAAE,OAAO,EAAE,cAAc,EAAC,MAAM,SAAS,CAAC"}

package/dist/ThreeD/index.js

@@ -0,0 +1,10 @@
+// Copyright (c) Meta Platforms, Inc. and affiliates.
+
+export { ThreeDChart } from "./ThreeDChart.js";
+export { ThreeDScatter } from "./ThreeDScatter.js";
+export { ThreeDScatterGL } from "./ThreeDScatterGL.js";
+export { ThreeDBar } from "./ThreeDBar.js";
+export { ThreeDGrid } from "./ThreeDGrid.js";
+export { ThreeDAxis } from "./ThreeDAxis.js";
+export { ThreeDSurface } from "./ThreeDSurface.js";
+export { use3D } from "./ThreeDContext.js";

package/dist/ThreeD/types.d.ts

@@ -0,0 +1,57 @@
+/**
+ * @file types.ts
+ * @output 3D chart types and context
+ * @position Foundation types consumed by all 3D sub-components
+ *
+ * Uses a simple perspective projection — no WebGL dependency for the
+ * coordinate system. Marks can render as projected SVG or WebGL.
+ */
+/** 3D point in data space */
+export interface Point3D {
+    x: number;
+    y: number;
+    z: number;
+}
+/** 2D projected point with depth for sorting */
+export interface ProjectedPoint {
+    px: number;
+    py: number;
+    depth: number;
+}
+/** Camera configuration */
+export interface Camera {
+    /** Rotation around the vertical axis in degrees (default: 30) */
+    azimuth: number;
+    /** Rotation above the horizontal plane in degrees (default: 20) */
+    elevation: number;
+    /** Distance from origin — affects perspective strength (default: 5) */
+    distance?: number;
+}
+/** 3D context provided by ThreeDChart to children */
+export interface ThreeDContext {
+    /** Inner width in pixels */
+    width: number;
+    /** Inner height in pixels */
+    height: number;
+    /** The full dataset */
+    data: Record<string, unknown>[];
+    /** Data key for x dimension */
+    xKey: string;
+    /** Data key for y dimension (vertical) */
+    yKey: string;
+    /** Data key for z dimension (depth) */
+    zKey: string;
+    /** Project a 3D data point to 2D screen coordinates */
+    project: (x: number, y: number, z: number) => ProjectedPoint;
+    /** Domain for x axis [min, max] */
+    xDomain: [number, number];
+    /** Domain for y axis [min, max] */
+    yDomain: [number, number];
+    /** Domain for z axis [min, max] */
+    zDomain: [number, number];
+    /** Normalize a value within a domain to [0, 1] */
+    normalize: (value: number, domain: [number, number]) => number;
+    /** Camera settings */
+    camera: Camera;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/ThreeD/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/ThreeD/types.ts"],"names":[],"mappings":"AAEA;;;;;;;GAOG;AAEH,6BAA6B;AAC7B,MAAM,WAAW,OAAO;IACtB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX;AAED,gDAAgD;AAChD,MAAM,WAAW,cAAc;IAC7B,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,EAAE,MAAM,CAAC;CACf;AAED,2BAA2B;AAC3B,MAAM,WAAW,MAAM;IACrB,iEAAiE;IACjE,OAAO,EAAE,MAAM,CAAC;IAChB,mEAAmE;IACnE,SAAS,EAAE,MAAM,CAAC;IAClB,uEAAuE;IACvE,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED,qDAAqD;AACrD,MAAM,WAAW,aAAa;IAC5B,4BAA4B;IAC5B,KAAK,EAAE,MAAM,CAAC;IACd,6BAA6B;IAC7B,MAAM,EAAE,MAAM,CAAC;IACf,uBAAuB;IACvB,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,CAAC;IAChC,+BAA+B;IAC/B,IAAI,EAAE,MAAM,CAAC;IACb,0CAA0C;IAC1C,IAAI,EAAE,MAAM,CAAC;IACb,uCAAuC;IACvC,IAAI,EAAE,MAAM,CAAC;IACb,uDAAuD;IACvD,OAAO,EAAE,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,KAAK,cAAc,CAAC;IAC7D,mCAAmC;IACnC,OAAO,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC1B,mCAAmC;IACnC,OAAO,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC1B,mCAAmC;IACnC,OAAO,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC1B,kDAAkD;IAClD,SAAS,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,KAAK,MAAM,CAAC;IAC/D,sBAAsB;IACtB,MAAM,EAAE,MAAM,CAAC;CAChB"}

package/dist/ThreeD/types.js

@@ -0,0 +1 @@
+export {};

package/dist/index.d.ts

@@ -0,0 +1,26 @@
+/**
+ * @astryxdesign/lab — Experimental Astryx components
+ *
+ * Components here are functional but not yet hardened for production.
+ * They're available in storybook and sandbox for testing and iteration.
+ * Once vetted, components graduate to @astryxdesign/core.
+ *
+ * This package is published to npm ONLY under the @canary dist-tag
+ * (npm install @astryxdesign/lab@canary). It is never released as a
+ * stable (latest) version.
+ */
+export { CodeBlock, type CodeBlockProps } from './CodeBlock';
+export { CodeEditor, type CodeEditorProps } from './CodeEditor';
+export { tokenize, tokenizeAsync, SYNC_TOKENIZE_THRESHOLD, type SyntaxToken, } from '@astryxdesign/core/CodeBlock';
+export { ChatReasoning, type ChatReasoningProps, } from './ChatReasoning/ChatReasoning';
+export * from './Schedule';
+export { SVGIcon, type SVGIconProps, type SVGIconVariation, type SVGIconSize, type SVGIconColor, type SVGIconDef, type IconShape, type IconShapeRole, iconVars, variations, opticalSize, xIcon, checkIcon, bellIcon, homeIcon, settingsIcon, calendarIcon, menuIcon, heartIcon, eyeIcon, starIcon, folderIcon, shieldIcon, searchIcon, mailIcon, lockIcon, starterIcons, } from './SVGIcon';
+export { Chart, type ChartProps, type YBaseline, ChartAxis, type ChartAxisProps, ChartGrid, type ChartGridProps, ChartBar, type ChartBarProps, ChartLine, type ChartLineProps, ChartArea, type ChartAreaProps, ChartErrorBar, type ChartErrorBarProps, ChartCandlestick, type ChartCandlestickProps, ChartDot, type ChartDotProps, ChartDotGL, type ChartDotGLProps, ChartDotGLInteractive, type ChartDotGLInteractiveProps, ChartHeatmapGL, type ChartHeatmapGLProps, ChartStreamGL, type ChartStreamGLProps, type ChartStreamGLHandle, ChartTooltip, type ChartTooltipProps, type ChartCrosshairMode, ChartLegend, type ChartLegendProps, type ChartLegendItem, useChart, type ChartContext, type ChartMargin, type ChartScale, m4Reduce, type M4Point, useChartColors, useChartRange, type UseChartRangeOptions, type UseChartRangeReturn, getChartColors, getChartColorsFromResolver, type ChartColorsAPI, type SequentialHue, type TokenResolver, compactNumber, currency, percent, shortDate, monthYear, } from './Chart';
+export { RadialChart, type RadialChartProps, RadialGrid, type RadialGridProps, RadialArea, type RadialAreaProps, RadialAxis, type RadialAxisProps, RadialSlice, type RadialSliceProps, RadialTooltip, type RadialTooltipProps, type RadialTooltipDatum, useRadial, type RadialContext, type RadialMode, } from './Radial';
+export { ThreeDChart, type ThreeDChartProps, ThreeDScatter, ThreeDScatterGL, type ThreeDScatterProps, type ThreeDScatterGLProps, ThreeDBar, type ThreeDBarProps, ThreeDGrid, type ThreeDGridProps, ThreeDAxis, type ThreeDAxisProps, ThreeDSurface, type ThreeDSurfaceProps, use3D, type ThreeDContext, type Camera, type Point3D, type ProjectedPoint, } from './ThreeD';
+export { ChartBrush, type ChartBrushProps, type BrushMode, type BrushRange, ChartZoom, type ChartZoomProps, ChartSelect, type ChartSelectProps, ChartReferenceLine, type ChartReferenceLineProps, } from './Chart';
+export { SankeyChart, type SankeyChartProps, SankeyLink, type SankeyLinkProps, SankeyNode, type SankeyNodeProps, SankeyLabel, type SankeyLabelProps, useSankey, type SankeyNodeDatum, type SankeyLinkDatum, type SankeyColumn, type SankeyColumnDef, type SankeyNodeLayout, type SankeyLinkLayout, type SankeyColumnLayout, SankeyGrid, type SankeyGridProps, type SankeyContext, } from './Sankey';
+export { Chart as ChartV2, type ChartProps as ChartV2Props, ChartLegend as ChartV2Legend, type ChartLegendProps as ChartV2LegendProps, type LegendItem as ChartV2LegendItem, ChartAxis as ChartV2Axis, type ChartAxisProps as ChartV2AxisProps, ChartGrid as ChartV2Grid, type ChartGridProps as ChartV2GridProps, ChartSwatch as ChartV2Swatch, swatchVariantForType as xdsChartV2SwatchVariantForType, type ChartSwatchProps as ChartV2SwatchProps, type ChartSwatchVariant as ChartV2SwatchVariant, ChartTooltip as ChartV2Tooltip, type ChartTooltipProps as ChartV2TooltipProps, type ChartTooltipPlacement as ChartV2TooltipPlacement, type TooltipSeriesValue as ChartV2TooltipSeriesValue, bar, line, dot, area, band, candlestick, errorBar, referenceLine, dotGL, dotGLInteractive, heatmapGL, streamGL, useChartV2, type SeriesDef, type ChartV2Context, type ChartPointerEvent, type ResolvedPoint, type ResolvedPositions, type SeriesContext, type ErrorBarOptions, type ReferenceLineOptions, type DotGLOptions, type DotGLInteractiveOptions, type HeatmapGLOptions, type StreamGLOptions, type StreamGLHandle, } from './ChartV2';
+export * from './Stepper';
+export * from './CircularProgress';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}