@uwdata/mosaic-plot 0.10.0 → 0.11.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uwdata/mosaic-plot",
-  "version": "0.10.0",
+  "version": "0.11.0",
   "description": "A Mosaic-powered plotting framework based on Observable Plot.",
   "keywords": [
     "data",
@@ -24,15 +24,15 @@
     "prebuild": "rimraf dist && mkdir dist",
     "build": "node ../../esbuild.js mosaic-plot",
     "lint": "eslint src test",
-    "test": "mocha 'test/**/*-test.js'",
+    "test": "vitest run",
     "prepublishOnly": "npm run test && npm run lint && npm run build"
   },
   "dependencies": {
-    "@observablehq/plot": "^0.6.15",
-    "@uwdata/mosaic-core": "^0.10.0",
-    "@uwdata/mosaic-sql": "^0.10.0",
+    "@observablehq/plot": "^0.6.16",
+    "@uwdata/mosaic-core": "^0.11.0",
+    "@uwdata/mosaic-sql": "^0.11.0",
     "d3": "^7.9.0",
     "isoformat": "^0.2.1"
   },
-  "gitHead": "94fc4f0d4efc622001f6afd6714d1e9dda745be2"
+  "gitHead": "861d616f39926a1d2aee83b59dbdd70b0b3caf12"
 }

package/src/interactors/Highlight.js

@@ -99,6 +99,6 @@ async function predicateFunction(mark, selection) {
   const data = await mark.coordinator.query(q);
   const v = data.getChild?.('__');
   return !(data.numRows || data.length) ? (() => false)
-    : v ? (i => v.get(i))
+    : v ? (i => v.at(i))
     : (i => data[i].__);
 }

package/src/interactors/Nearest.js

@@ -1,4 +1,4 @@
-import { clausePoints, isSelection } from '@uwdata/mosaic-core';
+import { clausePoint, clausePoints, isSelection } from '@uwdata/mosaic-core';
 import { select, pointer } from 'd3';
 import { getField } from './util/get-field.js';
 
@@ -24,10 +24,12 @@ export class Nearest {
 
   clause(value) {
     const { clients, fields } = this;
-    return clausePoints(fields, value ? [value] : value, {
-      source: this,
-      clients
-    });
+    const opt = { source: this, clients };
+    // if only one field, use a simpler clause that passes the value
+    // this allows a single field selection value to act like a param
+    return fields.length > 1
+      ? clausePoints(fields, value ? [value] : value, opt)
+      : clausePoint(fields[0], value?.[0], opt);
   }
 
   init(svg) {
@@ -56,11 +58,10 @@ export class Nearest {
       if (i !== this.valueIndex) {
         this.valueIndex = i;
         const v = i < 0 ? undefined : keys.map(k => columns[k][i]);
-        if (param) {
-          if (i > -1) selection.update(v.length > 1 ? v : v[0]);
-        } else {
-          selection.update(that.clause(v));
-        }
+        selection.update(
+          // provide value for param, clause for selection
+          param ? (!v || v.length > 1 ? v : v[0]) : that.clause(v)
+        );
       }
     });
 

package/src/marks/ConnectedMark.js

@@ -45,7 +45,7 @@ export class ConnectedMark extends Mark {
 
 /**
  * M4 is an optimization for value-preserving time-series aggregation
- * (http://www.vldb.org/pvldb/vol7/p797-jugel.pdf). This implementation uses
+ * (https://www.vldb.org/pvldb/vol7/p797-jugel.pdf). This implementation uses
  * an efficient version with a single scan and the aggregate function
  * argmin and argmax, following https://arxiv.org/pdf/2306.03714.pdf.
  */

package/src/marks/util/stats.js

@@ -172,7 +172,7 @@ export function qt(p, dof) {
 export function erfinv(x) {
   // Implementation from "Approximating the erfinv function" by Mike Giles,
   // GPU Computing Gems, volume 2, 2010.
-  // Ported from Apache Commons Math, http://www.apache.org/licenses/LICENSE-2.0
+  // Ported from Apache Commons Math, https://www.apache.org/licenses/LICENSE-2.0
 
   // beware that the logarithm argument must be
   // computed as (1.0 - x) * (1.0 + x),

package/src/plot.js

@@ -132,7 +132,7 @@ export class Plot {
         params.set(param, [mark]);
         param.addEventListener('value', () => {
           return Promise.allSettled(
-            params.get(param).map(mark => mark.requestQuery())
+            params.get(param).map(mark => mark.initialize())
           );
         });
       }

package/src/transforms/time-interval.js

@@ -43,7 +43,7 @@ export function timeInterval(min, max, steps) {
   const target = span / steps;
   let i = bisector(i => i[2]).right(intervals, target);
   if (i === intervals.length) {
-    return { interval: YEAR, step: binStep(span, steps) };
+    return { interval: YEAR, step: binStep(span / durationYear, steps) };
   } else if (i) {
     i = intervals[target / intervals[i - 1][2] < intervals[i][2] / target ? i - 1 : i];
     return { interval: i[0], step: i[1] };