@graphysdk/viz-engine 0.0.1-plugins.1 → 0.0.1-plugins.2

package/dist/index.d.ts

@@ -1028,6 +1028,12 @@ export declare interface CompiledAxisGuide {
     aesthetic: AestheticKey;
     /** Axis placement */
     position: AxisPosition;
+    /**
+     * Axis geometry: `'linear'` for cartesian (straight edge axis), `'circular'` for the angular axis
+     * of a polar chart (ticks around the rim — the radar spokes/labels), `'radial'` for the radial axis
+     * (concentric ring gridlines). Renderers branch on this before `position`.
+     */
+    geometry: GuideGeometry;
     /** Title text, null means no title */
     label: string | null;
     /** Whether the axis (line + ticks + labels) is visible */
@@ -4047,6 +4053,13 @@ export declare class LayoutCompiler {
 export declare interface LayoutCompileResult {
     layout: GraphLayout;
     formattedAxes: FormattedAxis[];
+    /**
+     * Polar axes (circular angular + radial), formatted with every tick (no fit-based selection or
+     * truncation — a radar shows one spoke per category and rings at the radial ticks). Empty for cartesian
+     * charts. The polar guide renderer consumes these together with the panel/plot rects; they are kept apart
+     * from {@link formattedAxes} because they project around a circle, not onto the four cartesian edges.
+     */
+    formattedPolarAxes: FormattedAxis[];
 }
 
 /** Input for the layout compiler. */
@@ -4631,6 +4644,13 @@ export declare interface PolarCoordSystem {
     axisMapping: AxisMapping;
     /** Donut hole radius as a fraction of the outer radius (0-1). 0 for a full pie. */
     innerRadius: number;
+    /**
+     * Angular offset, in radians, applied to every angular position — the spec's `startAngle` (degrees)
+     * converted once at setup. The polar guide renderer recovers a tick's angle as `position * 2π +
+     * startAngle`, matching the angular transform the coord applies to the data, so spokes/labels align
+     * with the painted marks.
+     */
+    startAngle: number;
 }
 
 export declare const POSITION_VARIABLES: {
@@ -5501,14 +5521,21 @@ export declare interface SourceContent {
  * instead provides a render-side hit-test function (injected per-instance through the renderer),
  * and the engine resolves the observation it returns against the declared identity key. Only the
  * kind rides in the compiled spec — the closure never crosses the serialisable boundary.
+ *
+ * `polar-points` is the polar refinement of `points` (a radar's vertices read in polar). The cursor
+ * and the vertices live in incompatible spaces for the cartesian nearest query — vertices are
+ * `(angle, radius)`, the cursor is plot-local `[0,1]` — so the polar query converts each at query
+ * time (no stored cartesian, no Delaunay), staying correct across resizes. Geoms never declare it; a
+ * polar coord refines a `points`-natural mark to it during the coord transform.
  */
-declare type SpatialIndexKind = 'buckets' | 'rects' | 'points' | 'arcs' | 'noop' | 'render-hit-test';
+declare type SpatialIndexKind = 'buckets' | 'rects' | 'points' | 'arcs' | 'noop' | 'render-hit-test' | 'polar-points';
 
 /**
  * A layer's geometry-agnostic hit-test declaration. Pure serialisable data riding in the compiled
  * spec: it names the spatial structure the marks present so the runtime can build the matching
  * index without knowing which geom produced it. A geom declares its cartesian-natural kind on its
- * definition; a polar coord refines it to `arcs` during the coord transform.
+ * definition; a polar coord refines it to `arcs` (filled wedges) or `polar-points` (radar vertices)
+ * during the coord transform.
  */
 declare interface SpatialMapDescriptor {
     kind: SpatialIndexKind;