@uwdata/mosaic-core 0.5.0 → 0.6.0

package/dist/mosaic-core.js

@@ -12302,8 +12302,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
@@ -12710,6 +12709,89 @@ function isDoubleQuoted(s) {
   return s[0] === '"' && s[s.length - 1] === '"';
 }
 
+// ../sql/src/scales.js
+var identity = (x3) => x3;
+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: (x3) => Math.pow(10, x3),
+      sqlApply: (c) => sql`LOG(${asColumn(c)})`,
+      sqlInvert: (c) => sql`POW(10, ${c})`
+    };
+  } else {
+    const b2 = +base;
+    return {
+      apply: (x3) => Math.log(x3) / Math.log(b2),
+      invert: (x3) => Math.pow(b2, x3),
+      sqlApply: (c) => sql`LN(${asColumn(c)}) / LN(${b2})`,
+      sqlInvert: (c) => sql`POW(${b2}, ${c})`
+    };
+  }
+}
+function scaleSymlog({ constant = 1 } = {}) {
+  const _2 = +constant;
+  return {
+    apply: (x3) => Math.sign(x3) * Math.log1p(Math.abs(x3)),
+    invert: (x3) => Math.sign(x3) * Math.exp(Math.abs(x3) - _2),
+    sqlApply: (c) => (c = asColumn(c), sql`SIGN(${c}) * LN(${_2} + ABS(${c}))`),
+    sqlInvert: (c) => sql`SIGN(${c}) * (EXP(ABS(${c})) - ${_2})`
+  };
+}
+function scaleSqrt() {
+  return {
+    apply: (x3) => Math.sign(x3) * Math.sqrt(Math.abs(x3)),
+    invert: (x3) => Math.sign(x3) * x3 * x3,
+    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: (x3) => Math.sign(x3) * Math.pow(Math.abs(x3), e),
+    invert: (x3) => Math.sign(x3) * Math.pow(Math.abs(x3), 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: (x3) => +x3,
+    invert: (x3) => new Date(x3),
+    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,
@@ -12869,7 +12951,6 @@ function fnv_mix(a2) {
 }
 
 // src/DataCubeIndexer.js
-var identity = (x3) => x3;
 var DataCubeIndexer = class {
   /**
    *
@@ -12962,10 +13043,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((b2) => b2 == null))
       return null;
     if (bins.length === 1) {
@@ -12978,7 +13059,7 @@ function getActiveView(clause) {
       );
     }
   } else if (type === "point") {
-    predicate = identity;
+    predicate = (x3) => x3;
     columns = Object.fromEntries(columns.map((col) => [col.toString(), col]));
   } else {
     return null;
@@ -12986,39 +13067,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 = (x3) => Math.sign(x3) * Math.log1p(Math.abs(x3));
-      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 = (x3) => +x3;
-      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 a2 = Math.abs(range[1] - range[0]) / (hi - lo) / pixelSize;
+    const s = pixelSize === 1 ? "" : `${pixelSize}::INTEGER * `;
+    return (value) => sql`${s}FLOOR(${a2}::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 a2 = Math.abs(lift(range[1]) - lift(range[0])) / (hi - lo) / pixelSize;
-  const s = pixelSize === 1 ? "" : `${pixelSize}::INTEGER * `;
-  return (value) => sql`${s}FLOOR(${a2}::DOUBLE * (${toSql(value)} - ${lo}::DOUBLE))::INTEGER`;
 }
 var NO_INDEX = { from: NaN };
 function getIndexColumns(client) {