@asymmetric-effort/specifyjs 0.2.98 → 0.2.100

package/dist/types/components/viz/3dSpace/src/index.d.ts

@@ -0,0 +1,32 @@
+export type { Color, Vertex, ShadeParams, Texture, ObjectPicker, Mat4, Quaternion } from './types';
+export { DefaultObjectPicker } from './types';
+export { Mesh } from './mesh';
+export type { Material } from './material';
+export { createMaterial } from './material';
+export type { LightType } from './light';
+export { Light } from './light';
+export type { ProjectionMode } from './camera';
+export { Camera } from './camera';
+export { Viewport } from './viewport';
+export { SceneObject } from './scene-object';
+export type { LightingModel } from './lighting-model';
+export { FlatShading, LambertianShading } from './lighting-model';
+export { SceneGraph } from './scene-graph';
+export type { RenderPipeline } from './render-pipeline';
+export { WebGLPipeline, toFloat32, compileShader, linkProgram, setUniform } from './webgl-pipeline';
+export { CpuPipeline } from './cpu-pipeline';
+export type { SpaceBounds, BoundaryMode } from './bounds';
+export { clampToBounds, isInBounds, boundsCenter, boundsSize, applyBoundary } from './bounds';
+export { solidTexture, checkerboardTexture, gradientTexture, noiseTexture } from './texture';
+export { Space3D } from './Space3D';
+export type { Space3DProps } from './Space3D';
+export type { CameraControllerFn, InputState } from './camera-controller';
+export { createInputTracker, resetFrameDeltas, orbitController, flyController } from './camera-controller';
+export type { HeightFunction, TerrainColorFunction } from './terrain';
+export { generateTerrain, sineTerrain, heightGradientColor } from './terrain';
+export type { Ray, PickResult } from './picking';
+export { screenToRay, rayIntersectSphere, rayIntersectAABB, BoundingSpherePicker, pickAtScreen } from './picking';
+export type { AnimationFn, AnimationBinding } from './animation';
+export { AnimationManager, rotateY, bob, orbit, compose } from './animation';
+export type { ColliderType, CollisionInfo, CollisionResponse, AABB } from './collision';
+export { CollisionManager, computeBoundingSphereRadius, computeAABB, sphereSphereTest, aabbTest } from './collision';

package/dist/types/components/viz/3dSpace/src/light.d.ts

@@ -0,0 +1,23 @@
+import type { Vec3 } from '../../../math/src/vec';
+import type { Color } from './types';
+/** Types of light source. */
+export type LightType = 'directional' | 'point' | 'spot';
+/** A light source in the scene. */
+export declare class Light {
+    type: LightType;
+    position: Vec3;
+    direction: Vec3;
+    color: Color;
+    intensity: number;
+    range: number;
+    spotAngle: number;
+    constructor(options: {
+        type: LightType;
+        position?: Vec3;
+        direction?: Vec3;
+        color?: Color;
+        intensity?: number;
+        range?: number;
+        spotAngle?: number;
+    });
+}

package/dist/types/components/viz/3dSpace/src/lighting-model.d.ts

@@ -0,0 +1,34 @@
+import type { Color, ShadeParams } from './types';
+import type { Light } from './light';
+import type { Material } from './material';
+/** Pluggable lighting model interface. */
+export interface LightingModel {
+    name: string;
+    vertexShaderSource(): string;
+    fragmentShaderSource(): string;
+    shade(params: ShadeParams): Color;
+    uniforms(lights: Light[], material: Material): Record<string, unknown>;
+}
+/**
+ * Flat shading: returns the material color unchanged.
+ * No diffuse/specular computation.
+ */
+export declare class FlatShading implements LightingModel {
+    readonly name = "FlatShading";
+    vertexShaderSource(): string;
+    fragmentShaderSource(): string;
+    shade(params: ShadeParams): Color;
+    uniforms(_lights: Light[], material: Material): Record<string, unknown>;
+}
+/**
+ * Lambertian diffuse shading.
+ * Computes intensity as max(dot(normal, lightDir), 0) and combines
+ * an ambient term with a diffuse term.
+ */
+export declare class LambertianShading implements LightingModel {
+    readonly name = "lambertian";
+    vertexShaderSource(): string;
+    fragmentShaderSource(): string;
+    shade(params: ShadeParams): Color;
+    uniforms(lights: Light[], material: Material): Record<string, unknown>;
+}

package/dist/types/components/viz/3dSpace/src/material.d.ts

@@ -0,0 +1,12 @@
+import type { Color, Texture } from './types';
+/** Material definition for a scene object. */
+export interface Material {
+    color: Color;
+    texture?: Texture;
+    wireframe: boolean;
+}
+/** Create a default material with the given color. */
+export declare function createMaterial(color: Color, options?: {
+    texture?: Texture;
+    wireframe?: boolean;
+}): Material;

package/dist/types/components/viz/3dSpace/src/mesh.d.ts

@@ -0,0 +1,35 @@
+/** Mesh geometry with packed vertex data. */
+export declare class Mesh {
+    readonly vertices: Float32Array;
+    readonly normals: Float32Array;
+    readonly indices: Uint32Array;
+    readonly uvs?: Float32Array;
+    readonly colors?: Float32Array;
+    constructor(vertices: Float32Array, normals: Float32Array, indices: Uint32Array, uvs?: Float32Array, colors?: Float32Array);
+    /** Number of vertices (each vertex is 3 floats: x, y, z). */
+    get vertexCount(): number;
+    /** Number of indices. */
+    get indexCount(): number;
+    /**
+     * Create a box mesh centered at the origin.
+     * @param width - Size along x axis.
+     * @param height - Size along y axis.
+     * @param depth - Size along z axis.
+     */
+    static createBox(width: number, height: number, depth: number): Mesh;
+    /**
+     * Create a plane mesh on the XZ plane centered at the origin.
+     * @param width - Size along x axis.
+     * @param depth - Size along z axis.
+     * @param segmentsX - Number of segments along x.
+     * @param segmentsZ - Number of segments along z.
+     */
+    static createPlane(width: number, depth: number, segmentsX?: number, segmentsZ?: number): Mesh;
+    /**
+     * Create a UV sphere.
+     * @param radius - Sphere radius.
+     * @param stacks - Number of horizontal slices (latitude). Default 16.
+     * @param slices - Number of vertical slices (longitude). Default 24.
+     */
+    static createSphere(radius: number, stacks?: number, slices?: number): Mesh;
+}

package/dist/types/components/viz/3dSpace/src/picking.d.ts

@@ -0,0 +1,51 @@
+import type { Vec3 } from '../../../math/src/vec';
+import type { Camera } from './camera';
+import type { Viewport } from './viewport';
+import type { SceneObject } from './scene-object';
+import type { ObjectPicker } from './types';
+/**
+ * A ray in 3D space defined by an origin point and a direction vector.
+ */
+export interface Ray {
+    origin: Vec3;
+    direction: Vec3;
+}
+/**
+ * Result of a pick/raycast operation.
+ */
+export interface PickResult {
+    /** The object that was hit */
+    object: SceneObject;
+    /** Distance from the ray origin to the hit point */
+    distance: number;
+    /** World-space position of the hit */
+    hitPoint: Vec3;
+}
+/**
+ * Convert a screen-space mouse position to a world-space ray.
+ * Uses the camera's view and projection matrices to unproject.
+ */
+export declare function screenToRay(screenX: number, screenY: number, camera: Camera, viewport: Viewport): Ray;
+/**
+ * Test if a ray intersects an axis-aligned bounding sphere.
+ * Returns distance to intersection or null if no hit.
+ */
+export declare function rayIntersectSphere(ray: Ray, center: Vec3, radius: number): number | null;
+/**
+ * Test if a ray intersects an axis-aligned bounding box (AABB).
+ * Returns distance to intersection or null if no hit.
+ */
+export declare function rayIntersectAABB(ray: Ray, min: Vec3, max: Vec3): number | null;
+/**
+ * Built-in bounding-sphere object picker.
+ * Tests each object's bounding sphere (computed from mesh extents)
+ * against the ray. Returns the closest hit.
+ */
+export declare class BoundingSpherePicker implements ObjectPicker {
+    pick(origin: Vec3, direction: Vec3, objects: SceneObject[]): SceneObject | null;
+}
+/**
+ * Pick the nearest scene object at the given screen coordinates.
+ * Convenience function that combines screenToRay + picker.pick.
+ */
+export declare function pickAtScreen(screenX: number, screenY: number, camera: Camera, viewport: Viewport, objects: SceneObject[], picker: ObjectPicker): SceneObject | null;

package/dist/types/components/viz/3dSpace/src/render-pipeline.d.ts

@@ -0,0 +1,12 @@
+import type { SceneGraph } from './scene-graph';
+import type { Camera } from './camera';
+import type { Viewport } from './viewport';
+import type { LightingModel } from './lighting-model';
+import type { Light } from './light';
+/** Pluggable render pipeline interface. */
+export interface RenderPipeline {
+    name: string;
+    initialize(canvas: HTMLCanvasElement): void;
+    dispose(): void;
+    render(scene: SceneGraph, camera: Camera, viewport: Viewport, lighting: LightingModel, lights?: Light[]): void;
+}

package/dist/types/components/viz/3dSpace/src/scene-graph.d.ts

@@ -0,0 +1,20 @@
+import { SceneObject } from './scene-object';
+/** Scene graph that manages a hierarchy of scene objects. */
+export declare class SceneGraph {
+    /** Invisible root node. All registered objects are children of root. */
+    readonly root: SceneObject;
+    constructor();
+    /** Register a scene object by adding it as a child of the root. */
+    register(obj: SceneObject): void;
+    /** Unregister a scene object by id. Removes it from its parent. */
+    unregister(id: string): void;
+    /**
+     * Depth-first traversal of all objects in the scene graph.
+     * Uses an iterative approach with an explicit stack.
+     */
+    traverse(callback: (obj: SceneObject) => void): void;
+    /** Return all visible objects via depth-first traversal. */
+    getVisibleObjects(): SceneObject[];
+    /** Find an object by id using depth-first search. Returns null if not found. */
+    private findById;
+}

package/dist/types/components/viz/3dSpace/src/scene-object.d.ts

@@ -0,0 +1,31 @@
+import type { Vec3 } from '../../../math/src/vec';
+import type { Mat4, Quaternion } from './types';
+import type { Mesh } from './mesh';
+import type { Material } from './material';
+/**
+ * Base scene object that consumers can extend.
+ * Maintains a transform (position, rotation, scale) and a parent/child hierarchy.
+ */
+export declare class SceneObject {
+    readonly id: string;
+    position: Vec3;
+    rotation: Quaternion;
+    scale: Vec3;
+    mesh?: Mesh;
+    material?: Material;
+    children: SceneObject[];
+    parent: SceneObject | null;
+    visible: boolean;
+    /** Render order: lower values draw first (background). Default: 0. */
+    renderOrder: number;
+    constructor(id: string);
+    /** Add a child object. Sets the child's parent reference. */
+    addChild(obj: SceneObject): void;
+    /** Remove a child object by reference. Clears the child's parent reference. */
+    removeChild(obj: SceneObject): void;
+    /**
+     * Compute the world matrix by composing own transform with parent chain.
+     * Uses iterative traversal up the parent chain.
+     */
+    getWorldMatrix(): Mat4;
+}

package/dist/types/components/viz/3dSpace/src/terrain.d.ts

@@ -0,0 +1,34 @@
+import { Mesh } from './mesh';
+import type { Color } from './types';
+/**
+ * Consumer-provided terrain height function.
+ * Returns the height (Y value) at a given (x, z) world position.
+ */
+export type HeightFunction = (x: number, z: number) => number;
+/**
+ * Consumer-provided terrain color function.
+ * Returns the color at a given (x, z) world position based on height.
+ * If not provided, a default green-brown gradient based on height is used.
+ */
+export type TerrainColorFunction = (x: number, z: number, height: number) => Color;
+/**
+ * Generate a terrain mesh from a consumer-provided height function.
+ * Creates a grid of vertices in the XZ plane with Y values from the height function.
+ *
+ * @param width - Total width of the terrain in world units (X axis)
+ * @param depth - Total depth of the terrain in world units (Z axis)
+ * @param segmentsX - Number of segments along X
+ * @param segmentsZ - Number of segments along Z
+ * @param heightFn - Function that returns height at (x, z)
+ * @param colorFn - Optional function that returns color at (x, z, height)
+ */
+export declare function generateTerrain(width: number, depth: number, segmentsX: number, segmentsZ: number, heightFn: HeightFunction, colorFn?: TerrainColorFunction): Mesh;
+/**
+ * Simple procedural terrain using sine waves (no external noise library).
+ * Returns height values between -amplitude and +amplitude.
+ */
+export declare function sineTerrain(amplitude?: number, frequency?: number): HeightFunction;
+/**
+ * Default terrain coloring: green at low elevation, brown at mid, white at peaks.
+ */
+export declare function heightGradientColor(minH: number, maxH: number): TerrainColorFunction;

package/dist/types/components/viz/3dSpace/src/texture.d.ts

@@ -0,0 +1,22 @@
+import type { Texture, Color } from './types';
+/**
+ * Create a solid color texture (single color everywhere).
+ */
+export declare function solidTexture(color: Color): Texture;
+/**
+ * Create a checkerboard texture.
+ * @param color1 - First color (e.g., white)
+ * @param color2 - Second color (e.g., black)
+ * @param tilesU - Number of tiles along U axis (default 8)
+ * @param tilesV - Number of tiles along V axis (default 8)
+ */
+export declare function checkerboardTexture(color1: Color, color2: Color, tilesU?: number, tilesV?: number): Texture;
+/**
+ * Create a smooth gradient texture from one color to another along U axis.
+ */
+export declare function gradientTexture(colorA: Color, colorB: Color): Texture;
+/**
+ * Create a procedural noise texture (smooth random patterns).
+ * Uses value noise with bilinear interpolation.
+ */
+export declare function noiseTexture(baseColor: Color, noiseColor: Color, resolution?: number): Texture;

package/dist/types/components/viz/3dSpace/src/types.d.ts

@@ -0,0 +1,42 @@
+import type { Vec2, Vec3 } from '../../../math/src/vec';
+import type { Mat4 } from '../../../math/src/mat4';
+import type { Quaternion } from '../../../math/src/quaternion';
+import type { SceneObject } from './scene-object';
+export type { Mat4, Quaternion };
+/** RGBA color with channels in the 0-1 range. */
+export interface Color {
+    r: number;
+    g: number;
+    b: number;
+    a: number;
+}
+/** Vertex data for a mesh. */
+export interface Vertex {
+    position: Vec3;
+    normal: Vec3;
+    uv?: Vec2;
+    color?: Color;
+}
+/** Parameters passed to a lighting model's shade function. */
+export interface ShadeParams {
+    normal: Vec3;
+    lightDir: Vec3;
+    viewDir: Vec3;
+    lightColor: Color;
+    materialColor: Color;
+    ambientStrength: number;
+}
+/** Pluggable texture interface. */
+export interface Texture {
+    width: number;
+    height: number;
+    sample(u: number, v: number): Color;
+}
+/** Pluggable object picking interface. */
+export interface ObjectPicker {
+    pick(origin: Vec3, direction: Vec3, objects: SceneObject[]): SceneObject | null;
+}
+/** No-op default picker that always returns null. */
+export declare class DefaultObjectPicker implements ObjectPicker {
+    pick(): SceneObject | null;
+}

package/dist/types/components/viz/3dSpace/src/viewport.d.ts

@@ -0,0 +1,19 @@
+import type { Camera } from './camera';
+import type { Color } from './types';
+/** A viewport defines the screen rectangle and associated camera. */
+export declare class Viewport {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    camera: Camera;
+    clearColor: Color;
+    constructor(options: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+        camera: Camera;
+        clearColor?: Color;
+    });
+}

package/dist/types/components/viz/3dSpace/src/webgl-pipeline.d.ts

@@ -0,0 +1,54 @@
+import type { RenderPipeline } from './render-pipeline';
+import type { SceneGraph } from './scene-graph';
+import type { Camera } from './camera';
+import type { Viewport } from './viewport';
+import type { LightingModel } from './lighting-model';
+import type { Light } from './light';
+/**
+ * Convert a Float64Array to Float32Array for WebGL uniform uploads.
+ * WebGL expects Float32Array for matrix uniforms.
+ */
+export declare function toFloat32(src: Float64Array): Float32Array;
+/**
+ * Compile a WebGL shader from source.
+ * @param gl - The WebGL rendering context.
+ * @param type - gl.VERTEX_SHADER or gl.FRAGMENT_SHADER.
+ * @param source - GLSL source code.
+ * @returns The compiled shader.
+ * @throws Error if compilation fails.
+ */
+export declare function compileShader(gl: WebGLRenderingContext, type: number, source: string): WebGLShader;
+/**
+ * Link a vertex and fragment shader into a program.
+ * @param gl - The WebGL rendering context.
+ * @param vertexShader - Compiled vertex shader.
+ * @param fragmentShader - Compiled fragment shader.
+ * @returns The linked program.
+ * @throws Error if linking fails.
+ */
+export declare function linkProgram(gl: WebGLRenderingContext, vertexShader: WebGLShader, fragmentShader: WebGLShader): WebGLProgram;
+/**
+ * Set a uniform value on a WebGL program. Supports vec4 (number[]) and mat4 (Float32Array).
+ * @param gl - The WebGL rendering context.
+ * @param program - The active WebGL program.
+ * @param name - Uniform name.
+ * @param value - Uniform value.
+ */
+export declare function setUniform(gl: WebGLRenderingContext, program: WebGLProgram, name: string, value: unknown): void;
+/** WebGL-based render pipeline implementing the RenderPipeline interface. */
+export declare class WebGLPipeline implements RenderPipeline {
+    name: string;
+    private gl;
+    private shaderCache;
+    initialize(canvas: HTMLCanvasElement): void;
+    dispose(): void;
+    render(scene: SceneGraph, camera: Camera, viewport: Viewport, lighting: LightingModel, lights?: Light[]): void;
+    /**
+     * Get a cached shader program or compile a new one from the lighting model's source.
+     */
+    private getOrCompileProgram;
+    /**
+     * Render a single scene object.
+     */
+    private renderObject;
+}

package/dist/types/components/viz/big-number/src/BigNumber.d.ts

@@ -0,0 +1,29 @@
+export interface BigNumberProps {
+    /** The main value to display */
+    value: number | string;
+    /** Descriptive label beneath the value */
+    label?: string;
+    /** Prefix before the value (e.g. '$') */
+    prefix?: string;
+    /** Suffix after the value (e.g. '%') */
+    suffix?: string;
+    /** Trend value — positive = up, negative = down */
+    trend?: number;
+    /** Trend context label (e.g. 'vs last week') */
+    trendLabel?: string;
+    /** Small line chart data points */
+    sparkline?: number[];
+    /** SVG width in pixels (default: 280) */
+    width?: number;
+    /** SVG height in pixels (default: 160) */
+    height?: number;
+    /** Main value text color (default: 'currentColor') */
+    valueColor?: string;
+    /** Trend arrow color when positive (default: '#22c55e') */
+    trendUpColor?: string;
+    /** Trend arrow color when negative (default: '#ef4444') */
+    trendDownColor?: string;
+    /** Card background color (default: '#ffffff') */
+    backgroundColor?: string;
+}
+export declare function BigNumber(props: BigNumberProps): import("specifyjs/shared/types").SpecElement<import("specifyjs/shared/types").Props>;

package/dist/types/components/viz/big-number/src/index.d.ts

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

package/dist/types/components/viz/bloch-sphere/src/BlochSphere.d.ts

@@ -0,0 +1,73 @@
+/** Qubit state in Bloch sphere coordinates */
+export interface BlochState {
+    /** Polar angle from |0⟩ (north pole) in radians [0, π] */
+    theta: number;
+    /** Azimuthal angle in the XY plane in radians [0, 2π) */
+    phi: number;
+}
+/** A point on the sphere trail */
+export interface TrailPoint {
+    x: number;
+    y: number;
+    z: number;
+}
+/** Standard quantum gate names */
+export type GateName = 'X' | 'Y' | 'Z' | 'H' | 'S' | 'T' | 'Rx' | 'Ry' | 'Rz';
+/** Gate to apply with optional rotation angle */
+export interface GateOp {
+    gate: GateName;
+    /** Rotation angle in radians (for Rx, Ry, Rz gates) */
+    angle?: number;
+}
+export interface BlochSphereProps {
+    /** Current qubit state (default: |0⟩ = {theta: 0, phi: 0}) */
+    state?: BlochState;
+    /** Sequence of gates to animate (applied one per frame) */
+    gates?: GateOp[];
+    /** SVG viewBox width (default: 400) */
+    width?: number;
+    /** SVG viewBox height (default: 400) */
+    height?: number;
+    /** Initial rotation around Y axis in degrees (default: -25) */
+    rotateY?: number;
+    /** Initial rotation around X axis in degrees (default: 15) */
+    rotateX?: number;
+    /** Zoom level (default: 1.0, range 0.5–3.0) */
+    zoom?: number;
+    /** Allow interactive rotation via drag (default: true) */
+    interactive?: boolean;
+    /** Allow zoom via scroll (default: true) */
+    zoomable?: boolean;
+    /** Show state vector arrow (default: true) */
+    showVector?: boolean;
+    /** Show axis labels (default: true) */
+    showLabels?: boolean;
+    /** Show wireframe circles (default: true) */
+    showWireframe?: boolean;
+    /** Show trajectory trail (default: true) */
+    showTrail?: boolean;
+    /** Max trail points (default: 200) */
+    trailMaxPoints?: number;
+    /** Trail color (default: '#ef4444') */
+    trailColor?: string;
+    /** Sphere wireframe color (default: '#cbd5e1') */
+    wireframeColor?: string;
+    /** State vector color (default: '#3b82f6') */
+    vectorColor?: string;
+    /** Background color (default: transparent) */
+    backgroundColor?: string;
+    /** Sphere radius in viewBox units (default: 130) */
+    sphereRadius?: number;
+    /** Title text */
+    title?: string;
+    /** Called when state changes (from gates or interaction) */
+    onStateChange?: (state: BlochState) => void;
+}
+export declare function blochToCartesian(state: BlochState): {
+    x: number;
+    y: number;
+    z: number;
+};
+export declare function cartesianToBloch(x: number, y: number, z: number): BlochState;
+export declare function applyGate(state: BlochState, op: GateOp): BlochState;
+export declare function BlochSphere(props: BlochSphereProps): import("specifyjs/shared/types").SpecElement<import("specifyjs/shared/types").Props>;

package/dist/types/components/viz/bloch-sphere/src/index.d.ts

@@ -0,0 +1,2 @@
+export { BlochSphere, blochToCartesian, cartesianToBloch, applyGate } from './BlochSphere';
+export type { BlochSphereProps, BlochState, TrailPoint, GateName, GateOp } from './BlochSphere';

package/dist/types/components/viz/box-plot/src/BoxPlot.d.ts

@@ -0,0 +1,47 @@
+export interface BoxPlotDatum {
+    /** Category label */
+    label: string;
+    /** Raw numeric values to compute statistics from */
+    values: number[];
+    /** Optional box fill color */
+    color?: string;
+}
+export interface BoxPlotProps {
+    /** Array of box plot data */
+    data: BoxPlotDatum[];
+    /** SVG width in pixels (default: 600) */
+    width?: number;
+    /** SVG height in pixels (default: 400) */
+    height?: number;
+    /** Plot orientation (default: 'vertical') */
+    orientation?: 'horizontal' | 'vertical';
+    /** Show outlier circles (default: true) */
+    showOutliers?: boolean;
+    /** Show mean marker (default: false) */
+    showMean?: boolean;
+    /** Whisker line color (default: '#374151') */
+    whiskerColor?: string;
+    /** Box width as fraction of available space (default: 0.6) */
+    boxWidth?: number;
+    /** Show grid lines (default: true) */
+    showGrid?: boolean;
+    /** Chart title */
+    title?: string;
+    /** Padding around chart area in px (default: 60) */
+    padding?: number;
+}
+export interface BoxStats {
+    q1: number;
+    median: number;
+    q3: number;
+    iqr: number;
+    whiskerLow: number;
+    whiskerHigh: number;
+    mean: number;
+    outliers: number[];
+    min: number;
+    max: number;
+}
+/** Compute box-plot statistics from raw values. */
+export declare function computeBoxStats(values: number[]): BoxStats | null;
+export declare function BoxPlot(props: BoxPlotProps): import("specifyjs/shared/types").SpecElement<import("specifyjs/shared/types").Props>;

package/dist/types/components/viz/box-plot/src/index.d.ts

@@ -0,0 +1,2 @@
+export { BoxPlot, computeBoxStats } from './BoxPlot';
+export type { BoxPlotProps, BoxPlotDatum, BoxStats } from './BoxPlot';

package/dist/types/components/viz/bubble-chart/src/BubbleChart.d.ts

@@ -0,0 +1,38 @@
+export interface BubbleDatum {
+    x: number;
+    y: number;
+    r: number;
+    label?: string;
+    color?: string;
+}
+export interface BubbleChartProps {
+    /** Array of bubble data points */
+    data: BubbleDatum[];
+    /** SVG width in pixels (default: 600) */
+    width?: number;
+    /** SVG height in pixels (default: 400) */
+    height?: number;
+    /** X-axis label */
+    xLabel?: string;
+    /** Y-axis label */
+    yLabel?: string;
+    /** Show grid lines (default: true) */
+    showGrid?: boolean;
+    /** Show axes (default: true) */
+    showAxes?: boolean;
+    /** Show datum labels (default: false) */
+    showLabels?: boolean;
+    /** Maximum rendered bubble radius in px (default: 40) */
+    maxBubbleRadius?: number;
+    /** Minimum rendered bubble radius in px (default: 4) */
+    minBubbleRadius?: number;
+    /** Default bubble fill color (default: '#3b82f6') */
+    defaultColor?: string;
+    /** Bubble fill opacity (default: 0.7) */
+    opacity?: number;
+    /** Chart title */
+    title?: string;
+    /** Padding around chart area in px (default: 60) */
+    padding?: number;
+}
+export declare function BubbleChart(props: BubbleChartProps): import("specifyjs/shared/types").SpecElement<import("specifyjs/shared/types").Props>;

package/dist/types/components/viz/bubble-chart/src/index.d.ts

@@ -0,0 +1,2 @@
+export { BubbleChart } from './BubbleChart';
+export type { BubbleChartProps, BubbleDatum } from './BubbleChart';