@uwdata/mosaic-inputs 0.5.0 → 0.6.0

package/dist/mosaic-inputs.js

@@ -12311,8 +12311,7 @@ var arrayAgg = aggf("ARRAY_AGG");
 
 // ../sql/src/datetime.js
 var epoch_ms = (expr) => {
-  const d = asColumn(expr);
-  return sql`(1000 * (epoch(${d}) - second(${d})) + millisecond(${d}))::DOUBLE`;
+  return sql`epoch_ms(${asColumn(expr)})`;
 };
 
 // ../sql/src/spatial.js
@@ -12719,6 +12718,89 @@ function isDoubleQuoted(s) {
   return s[0] === '"' && s[s.length - 1] === '"';
 }
 
+// ../sql/src/scales.js
+var identity = (x2) => x2;
+function scaleLinear() {
+  return {
+    apply: identity,
+    invert: identity,
+    sqlApply: asColumn,
+    sqlInvert: identity
+  };
+}
+function scaleLog({ base } = {}) {
+  if (base == null || base === Math.E) {
+    return {
+      apply: Math.log,
+      invert: Math.exp,
+      sqlApply: (c) => sql`LN(${asColumn(c)})`,
+      sqlInvert: (c) => sql`EXP(${c})`
+    };
+  } else if (base === 10) {
+    return {
+      apply: Math.log10,
+      invert: (x2) => Math.pow(10, x2),
+      sqlApply: (c) => sql`LOG(${asColumn(c)})`,
+      sqlInvert: (c) => sql`POW(10, ${c})`
+    };
+  } else {
+    const b = +base;
+    return {
+      apply: (x2) => Math.log(x2) / Math.log(b),
+      invert: (x2) => Math.pow(b, x2),
+      sqlApply: (c) => sql`LN(${asColumn(c)}) / LN(${b})`,
+      sqlInvert: (c) => sql`POW(${b}, ${c})`
+    };
+  }
+}
+function scaleSymlog({ constant = 1 } = {}) {
+  const _ = +constant;
+  return {
+    apply: (x2) => Math.sign(x2) * Math.log1p(Math.abs(x2)),
+    invert: (x2) => Math.sign(x2) * Math.exp(Math.abs(x2) - _),
+    sqlApply: (c) => (c = asColumn(c), sql`SIGN(${c}) * LN(${_} + ABS(${c}))`),
+    sqlInvert: (c) => sql`SIGN(${c}) * (EXP(ABS(${c})) - ${_})`
+  };
+}
+function scaleSqrt() {
+  return {
+    apply: (x2) => Math.sign(x2) * Math.sqrt(Math.abs(x2)),
+    invert: (x2) => Math.sign(x2) * x2 * x2,
+    sqlApply: (c) => (c = asColumn(c), sql`SIGN(${c}) * SQRT(ABS(${c}))`),
+    sqlInvert: (c) => sql`SIGN(${c}) * (${c}) ** 2`
+  };
+}
+function scalePow({ exponent = 1 } = {}) {
+  const e = +exponent;
+  return {
+    apply: (x2) => Math.sign(x2) * Math.pow(Math.abs(x2), e),
+    invert: (x2) => Math.sign(x2) * Math.pow(Math.abs(x2), 1 / e),
+    sqlApply: (c) => (c = asColumn(c), sql`SIGN(${c}) * POW(ABS(${c}), ${e})`),
+    sqlInvert: (c) => sql`SIGN(${c}) * POW(ABS(${c}), 1/${e})`
+  };
+}
+function scaleTime() {
+  return {
+    apply: (x2) => +x2,
+    invert: (x2) => new Date(x2),
+    sqlApply: (c) => c instanceof Date ? +c : epoch_ms(asColumn(c)),
+    sqlInvert: identity
+  };
+}
+var scales = {
+  linear: scaleLinear,
+  log: scaleLog,
+  symlog: scaleSymlog,
+  sqrt: scaleSqrt,
+  pow: scalePow,
+  time: scaleTime,
+  utc: scaleTime
+};
+function scaleTransform(options) {
+  const scale = scales[options.type];
+  return scale ? { ...options, ...scale(options) } : null;
+}
+
 // ../sql/src/load/create.js
 function create(name, query, {
   replace = false,
@@ -12878,7 +12960,6 @@ function fnv_mix(a) {
 }
 
 // ../core/src/DataCubeIndexer.js
-var identity = (x2) => x2;
 var DataCubeIndexer = class {
   /**
    *
@@ -12971,10 +13052,10 @@ function getActiveView(clause) {
   let columns = clause.predicate?.columns;
   if (!schema || !columns)
     return null;
-  const { type, scales, pixelSize = 1 } = schema;
+  const { type, scales: scales2, pixelSize = 1 } = schema;
   let predicate;
-  if (type === "interval" && scales) {
-    const bins = scales.map((s) => binInterval(s, pixelSize));
+  if (type === "interval" && scales2) {
+    const bins = scales2.map((s) => binInterval(s, pixelSize));
     if (bins.some((b) => b == null))
       return null;
     if (bins.length === 1) {
@@ -12987,7 +13068,7 @@ function getActiveView(clause) {
       );
     }
   } else if (type === "point") {
-    predicate = identity;
+    predicate = (x2) => x2;
     columns = Object.fromEntries(columns.map((col) => [col.toString(), col]));
   } else {
     return null;
@@ -12995,39 +13076,15 @@ function getActiveView(clause) {
   return { source, columns, predicate };
 }
 function binInterval(scale, pixelSize) {
-  const { type, domain, range } = scale;
-  let lift, toSql;
-  switch (type) {
-    case "linear":
-      lift = identity;
-      toSql = asColumn;
-      break;
-    case "log":
-      lift = Math.log;
-      toSql = (c) => sql`LN(${asColumn(c)})`;
-      break;
-    case "symlog":
-      lift = (x2) => Math.sign(x2) * Math.log1p(Math.abs(x2));
-      toSql = (c) => (c = asColumn(c), sql`SIGN(${c}) * LN(1 + ABS(${c}))`);
-      break;
-    case "sqrt":
-      lift = Math.sqrt;
-      toSql = (c) => sql`SQRT(${asColumn(c)})`;
-      break;
-    case "utc":
-    case "time":
-      lift = (x2) => +x2;
-      toSql = (c) => c instanceof Date ? +c : epoch_ms(asColumn(c));
-      break;
+  const { apply, sqlApply } = scaleTransform(scale);
+  if (apply) {
+    const { domain, range } = scale;
+    const lo = apply(Math.min(...domain));
+    const hi = apply(Math.max(...domain));
+    const a = Math.abs(range[1] - range[0]) / (hi - lo) / pixelSize;
+    const s = pixelSize === 1 ? "" : `${pixelSize}::INTEGER * `;
+    return (value) => sql`${s}FLOOR(${a}::DOUBLE * (${sqlApply(value)} - ${lo}::DOUBLE))::INTEGER`;
   }
-  return lift ? binFunction(domain, range, pixelSize, lift, toSql) : null;
-}
-function binFunction(domain, range, pixelSize, lift, toSql) {
-  const lo = lift(Math.min(domain[0], domain[1]));
-  const hi = lift(Math.max(domain[0], domain[1]));
-  const a = Math.abs(lift(range[1]) - lift(range[0])) / (hi - lo) / pixelSize;
-  const s = pixelSize === 1 ? "" : `${pixelSize}::INTEGER * `;
-  return (value) => sql`${s}FLOOR(${a}::DOUBLE * (${toSql(value)} - ${lo}::DOUBLE))::INTEGER`;
 }
 var NO_INDEX = { from: NaN };
 function getIndexColumns(client) {