gladly-plot 0.0.6 → 0.0.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gladly-plot",
-  "version": "0.0.6",
+  "version": "0.0.8",
   "description": "GPU-powered multi-axis plotting library with regl + d3",
   "type": "module",
   "exports": {

package/src/core/LayerType.js

@@ -242,15 +242,17 @@ export class LayerType {
     }
 
     for (const [suffix, qk] of Object.entries(layer.colorAxes)) {
-      uniforms[`colorscale${suffix}`]       = regl.prop(`colorscale_${qk}`)
-      uniforms[`color_range${suffix}`]      = regl.prop(`color_range_${qk}`)
-      uniforms[`color_scale_type${suffix}`] = regl.prop(`color_scale_type_${qk}`)
-      uniforms[`alpha_blend${suffix}`]      = regl.prop(`alpha_blend_${qk}`)
+      const pk = qk.replace(/\./g, '_')
+      uniforms[`colorscale${suffix}`]       = regl.prop(`colorscale_${pk}`)
+      uniforms[`color_range${suffix}`]      = regl.prop(`color_range_${pk}`)
+      uniforms[`color_scale_type${suffix}`] = regl.prop(`color_scale_type_${pk}`)
+      uniforms[`alpha_blend${suffix}`]      = regl.prop(`alpha_blend_${pk}`)
     }
 
     for (const [suffix, qk] of Object.entries(layer.filterAxes)) {
-      uniforms[`filter_range${suffix}`]      = regl.prop(`filter_range_${qk}`)
-      uniforms[`filter_scale_type${suffix}`] = regl.prop(`filter_scale_type_${qk}`)
+      const pk = qk.replace(/\./g, '_')
+      uniforms[`filter_range${suffix}`]      = regl.prop(`filter_range_${pk}`)
+      uniforms[`filter_scale_type${suffix}`] = regl.prop(`filter_scale_type_${pk}`)
     }
 
     // Strip spatial uniforms from vert (re-declared in buildSpatialGlsl)

package/src/core/Plot.js

@@ -98,46 +98,20 @@ function buildPlotSchema(data, config) {
       },
       axes: {
         type: "object",
-        properties: {
-          xaxis_bottom: {
+        properties: Object.fromEntries(AXES.map(axisId => {
+          const isXAxis = axisId.startsWith('x')
+          return [axisId, {
             type: "object",
             properties: {
+              quantity_kind: { type: "string" },
               min: { type: "number" },
               max: { type: "number" },
               label: { type: "string" },
               scale: { type: "string", enum: ["linear", "log"] },
-              rotate: { type: "boolean" }
+              ...(isXAxis ? { rotate: { type: "boolean" } } : {})
             }
-          },
-          xaxis_top: {
-            type: "object",
-            properties: {
-              min: { type: "number" },
-              max: { type: "number" },
-              label: { type: "string" },
-              scale: { type: "string", enum: ["linear", "log"] },
-              rotate: { type: "boolean" }
-            }
-          },
-          yaxis_left: {
-            type: "object",
-            properties: {
-              min: { type: "number" },
-              max: { type: "number" },
-              label: { type: "string" },
-              scale: { type: "string", enum: ["linear", "log"] }
-            }
-          },
-          yaxis_right: {
-            type: "object",
-            properties: {
-              min: { type: "number" },
-              max: { type: "number" },
-              label: { type: "string" },
-              scale: { type: "string", enum: ["linear", "log"] }
-            }
-          }
-        },
+          }]
+        })),
         additionalProperties: {
           // Color/filter/quantity-kind axes.
           // All fields from the quantity kind registration are valid here and override the registration.
@@ -335,7 +309,7 @@ export class Plot extends GlBase {
           const [min, max] = scale.domain()
           const qk    = this.axisRegistry.axisQuantityKinds[axisId]
           const qkDef = qk ? getAxisQuantityKind(qk) : {}
-          axes[axisId] = { ...qkDef, ...(axes[axisId] ?? {}), min, max }
+          axes[axisId] = { ...qkDef, ...(axes[axisId] ?? {}), min, max, ...(qk ? { quantity_kind: qk } : {}) }
         }
       }
     }
@@ -411,7 +385,21 @@ export class Plot extends GlBase {
     if (this._initEpoch !== epoch) return
     await this._processLayers(layers, this.currentData, epoch)
     if (this._initEpoch !== epoch) return
-    this._setDomains(axes)
+
+    // Discard any spatial axis config whose stored quantity_kind doesn't match
+    // Discard any spatial axis config whose stored quantity_kind doesn't match
+    // what the layers assigned — stale settings from a previous axis type.
+    const cleanAxes = { ...axes }
+    for (const axisId of AXES) {
+      const cfg = cleanAxes[axisId]
+      if (cfg?.quantity_kind != null &&
+          cfg.quantity_kind !== this.axisRegistry.axisQuantityKinds[axisId]) {
+        delete cleanAxes[axisId]
+      }
+    }
+    this.currentConfig = { ...this.currentConfig, axes: cleanAxes }
+
+    this._setDomains(cleanAxes)
 
     // Detect 3D mode: any axis outside the 4 standard 2D positions has a scale.
     this._is3D = AXES.some(a => !AXES_2D.includes(a) && this.axisRegistry.getScale(a) !== null)
@@ -1052,16 +1040,18 @@ void main() {
       }
 
       for (const qk of Object.values(layer.colorAxes)) {
-        props[`colorscale_${qk}`] = this.colorAxisRegistry.getColorscaleIndex(qk)
+        const pk = qk.replace(/\./g, '_')
+        props[`colorscale_${pk}`] = this.colorAxisRegistry.getColorscaleIndex(qk)
         const range = this.colorAxisRegistry.getRange(qk)
-        props[`color_range_${qk}`] = range ?? [0, 1]
-        props[`color_scale_type_${qk}`] = this._getScaleTypeFloat(qk)
-        props[`alpha_blend_${qk}`] = this.colorAxisRegistry.getAlphaBlend(qk)
+        props[`color_range_${pk}`] = range ?? [0, 1]
+        props[`color_scale_type_${pk}`] = this._getScaleTypeFloat(qk)
+        props[`alpha_blend_${pk}`] = this.colorAxisRegistry.getAlphaBlend(qk)
       }
 
       for (const qk of Object.values(layer.filterAxes)) {
-        props[`filter_range_${qk}`] = this.filterAxisRegistry.getRangeUniform(qk)
-        props[`filter_scale_type_${qk}`] = this._getScaleTypeFloat(qk)
+        const pk = qk.replace(/\./g, '_')
+        props[`filter_range_${pk}`] = this.filterAxisRegistry.getRangeUniform(qk)
+        props[`filter_scale_type_${pk}`] = this._getScaleTypeFloat(qk)
       }
 
       layer.draw(props)
@@ -1178,15 +1168,17 @@ void main() {
         }
         if (layer.instanceCount !== null) props.instances = layer.instanceCount
         for (const qk of Object.values(layer.colorAxes)) {
-          props[`colorscale_${qk}`] = this.colorAxisRegistry.getColorscaleIndex(qk)
+          const pk = qk.replace(/\./g, '_')
+          props[`colorscale_${pk}`] = this.colorAxisRegistry.getColorscaleIndex(qk)
           const range = this.colorAxisRegistry.getRange(qk)
-          props[`color_range_${qk}`] = range ?? [0, 1]
-          props[`color_scale_type_${qk}`] = this._getScaleTypeFloat(qk)
-          props[`alpha_blend_${qk}`] = this.colorAxisRegistry.getAlphaBlend(qk)
+          props[`color_range_${pk}`] = range ?? [0, 1]
+          props[`color_scale_type_${pk}`] = this._getScaleTypeFloat(qk)
+          props[`alpha_blend_${pk}`] = this.colorAxisRegistry.getAlphaBlend(qk)
         }
         for (const qk of Object.values(layer.filterAxes)) {
-          props[`filter_range_${qk}`] = this.filterAxisRegistry.getRangeUniform(qk)
-          props[`filter_scale_type_${qk}`] = this._getScaleTypeFloat(qk)
+          const pk = qk.replace(/\./g, '_')
+          props[`filter_range_${pk}`] = this.filterAxisRegistry.getRangeUniform(qk)
+          props[`filter_scale_type_${pk}`] = this._getScaleTypeFloat(qk)
         }
         layer.draw(props)
       }

package/src/data/Data.js

@@ -265,6 +265,18 @@ export class Data {
   }
 
   getDomain(col) {
-    return this._entry(col).domain
+    const entry = this._entry(col)
+    if (entry.domain) return entry.domain
+    const arr = entry.data
+    if (!arr || arr.length === 0) return null
+    let min = Infinity, max = -Infinity
+    for (let i = 0; i < arr.length; i++) {
+      const v = arr[i]
+      if (isFinite(v)) {
+        if (v < min) min = v
+        if (v > max) max = v
+      }
+    }
+    return min === Infinity ? null : [min, max]
   }
 }