@opendata-ai/openchart-engine 8.0.0-rc.17 → 8.0.0-rc.18

package/dist/index.js

@@ -15430,11 +15430,9 @@ function compileLayerIndependent(leaves, layerSpec, options, compileChart2) {
   };
   const xField0 = leaf0.encoding?.x?.field;
   const xField1 = leaf1.encoding?.x?.field;
-  const unionXValues = /* @__PURE__ */ new Set();
-  if (xField0) for (const row of leaf0.data) unionXValues.add(row[xField0]);
-  if (xField1) for (const row of leaf1.data) unionXValues.add(row[xField1]);
-  let leaf0WithUnionX = ensureXDomainCoverage(leaf0, xField0, unionXValues);
-  let leaf1WithUnionX = ensureXDomainCoverage(leaf1, xField1, unionXValues);
+  const union = withUnionXDomain(leaf0, leaf1);
+  let leaf0WithUnionX = union.leaf0;
+  let leaf1WithUnionX = union.leaf1;
   const aligned = alignYDomains(leaf0WithUnionX, leaf1WithUnionX);
   if (aligned) {
     leaf0WithUnionX = withYDomain(leaf0WithUnionX, aligned.domain0);
@@ -15581,20 +15579,75 @@ function compileLayerIndependent(leaves, layerSpec, options, compileChart2) {
     tooltipDescriptors: mergedTooltips
   };
 }
-function ensureXDomainCoverage(leaf, xField, allXValues) {
-  if (!xField || allXValues.size === 0) return leaf;
-  const existingXValues = /* @__PURE__ */ new Set();
-  for (const row of leaf.data) existingXValues.add(row[xField]);
-  const missingRows = [];
-  for (const xVal of allXValues) {
-    if (!existingXValues.has(xVal)) {
-      missingRows.push({ [xField]: xVal });
+function withXDomain(leaf, domain) {
+  if (!leaf.encoding?.x) return leaf;
+  return {
+    ...leaf,
+    encoding: {
+      ...leaf.encoding,
+      x: {
+        ...leaf.encoding.x,
+        scale: {
+          ...leaf.encoding.x.scale,
+          domain
+        }
+      }
     }
+  };
+}
+function withUnionXDomain(leaf0, leaf1) {
+  const xEnc0 = leaf0.encoding?.x;
+  const xEnc1 = leaf1.encoding?.x;
+  const xField0 = xEnc0?.field;
+  const xField1 = xEnc1?.field;
+  if (!xField0 || !xField1) return { leaf0, leaf1 };
+  const xType = xEnc0?.type ?? xEnc1?.type;
+  const pinned0 = xEnc0?.scale?.domain !== void 0;
+  const pinned1 = xEnc1?.scale?.domain !== void 0;
+  if (pinned0 && pinned1) return { leaf0, leaf1 };
+  const values0 = leaf0.data.map((row) => row[xField0]);
+  const values1 = leaf1.data.map((row) => row[xField1]);
+  const allValues = [...values0, ...values1].filter((v) => v != null);
+  if (allValues.length === 0) return { leaf0, leaf1 };
+  let domain;
+  if (xType === "temporal") {
+    let minMs = Number.POSITIVE_INFINITY;
+    let maxMs = Number.NEGATIVE_INFINITY;
+    for (const v of allValues) {
+      const ms = (v instanceof Date ? v : new Date(String(v))).getTime();
+      if (Number.isNaN(ms)) continue;
+      if (ms < minMs) minMs = ms;
+      if (ms > maxMs) maxMs = ms;
+    }
+    if (minMs <= maxMs) {
+      domain = [new Date(minMs).toISOString(), new Date(maxMs).toISOString()];
+    }
+  } else if (xType === "quantitative") {
+    let min4 = Number.POSITIVE_INFINITY;
+    let max4 = Number.NEGATIVE_INFINITY;
+    for (const v of allValues) {
+      const n = typeof v === "number" ? v : Number(v);
+      if (!Number.isFinite(n)) continue;
+      if (n < min4) min4 = n;
+      if (n > max4) max4 = n;
+    }
+    if (min4 <= max4) domain = [min4, max4];
+  } else {
+    const seen = /* @__PURE__ */ new Set();
+    const categories = [];
+    for (const v of allValues) {
+      const s = String(v);
+      if (!seen.has(s)) {
+        seen.add(s);
+        categories.push(s);
+      }
+    }
+    if (categories.length > 0) domain = categories;
   }
-  if (missingRows.length === 0) return leaf;
+  if (domain === void 0) return { leaf0, leaf1 };
   return {
-    ...leaf,
-    data: [...leaf.data, ...missingRows]
+    leaf0: pinned0 ? leaf0 : withXDomain(leaf0, domain),
+    leaf1: pinned1 ? leaf1 : withXDomain(leaf1, domain)
   };
 }
 function alignYDomains(leaf0, leaf1) {