@constela/runtime 2.0.5 → 2.0.6

package/dist/index.js

@@ -376,6 +376,7 @@ function createTypedStateStore(definitions) {
 }
 
 // src/expression/evaluator.ts
+import { CHART_HELPERS } from "@constela/core";
 var SAFE_ARRAY_METHODS = /* @__PURE__ */ new Set([
   "length",
   "at",
@@ -958,28 +959,8 @@ var GLOBAL_FUNCTIONS = {
   // Virtual scroll helpers
   getVisibleRange: (scrollTop, itemHeight, containerHeight, overscan) => getVisibleRange(scrollTop, itemHeight, containerHeight, overscan),
   getTotalHeight: (itemCount, itemHeight) => getTotalHeight(itemCount, itemHeight),
-  // Chart helpers - Coordinate calculation
-  normalizeValue: (value, min, max) => normalizeValue(value, min, max),
-  scaleValue: (value, domainMin, domainMax, rangeMin, rangeMax) => scaleValue(value, domainMin, domainMax, rangeMin, rangeMax),
-  getBarDimensions: (data, index, width, height, gap, orientation) => getBarDimensions(data, index, width, height, gap, orientation),
-  // Chart helpers - Path generation
-  getLinePath: (points, curved) => getLinePath(points, curved),
-  getAreaPath: (points, baseline, curved) => getAreaPath(points, baseline, curved),
-  getArcPath: (cx, cy, radius, startAngle, endAngle) => getArcPath(cx, cy, radius, startAngle, endAngle),
-  // Chart helpers - Pie/Donut
-  getPieSlices: (data, valueKey) => getPieSlices(data, valueKey),
-  getDonutSlices: (data, valueKey, innerRadius) => getDonutSlices(data, valueKey, innerRadius),
-  // Chart helpers - Radar
-  getRadarPoints: (data, valueKey, cx, cy, radius, maxValue) => getRadarPoints(data, valueKey, cx, cy, radius, maxValue),
-  getRadarAxes: (labels, cx, cy, radius) => getRadarAxes(labels, cx, cy, radius),
-  // Chart helpers - Utilities
-  getChartBounds: (data, valueKey) => getChartBounds(data, valueKey),
-  getLinePoints: (data, valueKey, width, height, padding) => getLinePoints(data, valueKey, width, height, padding),
-  generateTicks: (min, max, count) => generateTicks(min, max, count),
-  // Chart helpers - Data aggregation
-  binData: (data, valueKey, binCount) => binData(data, valueKey, binCount),
-  aggregateData: (data, groupKey, valueKey, aggregation) => aggregateData(data, groupKey, valueKey, aggregation),
-  downsample: (data, targetCount, method) => downsample(data, targetCount, method)
+  // Chart helpers (from @constela/core)
+  ...CHART_HELPERS
 };
 function callGlobalFunction(method, args) {
   const fn = GLOBAL_FUNCTIONS[method];
@@ -1312,546 +1293,6 @@ function evaluateBinary(op, left, right, ctx) {
       throw new Error("Unknown binary operator: " + op);
   }
 }
-function normalizeValue(value, min, max) {
-  if (typeof value !== "number" || typeof min !== "number" || typeof max !== "number") {
-    return void 0;
-  }
-  if (max === min) {
-    return 0;
-  }
-  return (value - min) / (max - min);
-}
-function scaleValue(value, domainMin, domainMax, rangeMin, rangeMax) {
-  if (typeof value !== "number" || typeof domainMin !== "number" || typeof domainMax !== "number" || typeof rangeMin !== "number" || typeof rangeMax !== "number") {
-    return void 0;
-  }
-  if (domainMax === domainMin) {
-    return rangeMin;
-  }
-  const normalized = (value - domainMin) / (domainMax - domainMin);
-  return rangeMin + normalized * (rangeMax - rangeMin);
-}
-function getBarDimensions(data, index, width, height, gap, orientation) {
-  if (!Array.isArray(data) || data.length === 0) {
-    return void 0;
-  }
-  if (typeof index !== "number" || index < 0 || index >= data.length) {
-    return void 0;
-  }
-  if (typeof width !== "number" || typeof height !== "number" || typeof gap !== "number") {
-    return void 0;
-  }
-  const isVertical = orientation === "vertical";
-  const barCount = data.length;
-  const values = data.map((d2) => typeof d2 === "number" ? d2 : 0);
-  const maxValue = Math.max(...values);
-  if (isVertical) {
-    const totalGap = gap * (barCount + 1);
-    const barWidth = (width - totalGap) / barCount;
-    const barX = gap + index * (barWidth + gap);
-    const value = values[index] ?? 0;
-    const barHeight = maxValue > 0 ? value / maxValue * height : 0;
-    const barY = height - barHeight;
-    return {
-      x: barX,
-      y: barY,
-      width: barWidth,
-      height: barHeight
-    };
-  } else {
-    const totalGap = gap * barCount;
-    const barHeight = (height - totalGap) / barCount;
-    const barY = gap + index * (barHeight + gap);
-    const value = values[index] ?? 0;
-    const barWidth = maxValue > 0 ? value / maxValue * width : 0;
-    return {
-      x: 0,
-      y: barY,
-      width: barWidth,
-      height: barHeight
-    };
-  }
-}
-function getCurvedPath(points) {
-  if (points.length < 2) {
-    return points.length === 1 ? `M${points[0].x},${points[0].y}` : "";
-  }
-  if (points.length === 2) {
-    return `M${points[0].x},${points[0].y} L${points[1].x},${points[1].y}`;
-  }
-  const pathParts = [`M${points[0].x},${points[0].y}`];
-  for (let i = 0; i < points.length - 1; i++) {
-    const p0 = points[Math.max(0, i - 1)];
-    const p1 = points[i];
-    const p2 = points[i + 1];
-    const p3 = points[Math.min(points.length - 1, i + 2)];
-    const cp1x = p1.x + (p2.x - p0.x) / 6;
-    const cp1y = p1.y + (p2.y - p0.y) / 6;
-    const cp2x = p2.x - (p3.x - p1.x) / 6;
-    const cp2y = p2.y - (p3.y - p1.y) / 6;
-    pathParts.push(`C${cp1x},${cp1y} ${cp2x},${cp2y} ${p2.x},${p2.y}`);
-  }
-  return pathParts.join(" ");
-}
-function getLinePath(points, curved) {
-  if (!Array.isArray(points)) {
-    return void 0;
-  }
-  if (points.length === 0) {
-    return "";
-  }
-  for (const point of points) {
-    if (typeof point !== "object" || point === null || typeof point.x !== "number" || typeof point.y !== "number") {
-      return void 0;
-    }
-  }
-  const validPoints = points;
-  if (validPoints.length === 1) {
-    return `M${validPoints[0].x},${validPoints[0].y}`;
-  }
-  if (curved !== true) {
-    const pathParts = validPoints.map((point, i) => {
-      const command = i === 0 ? "M" : "L";
-      return `${command}${point.x},${point.y}`;
-    });
-    return pathParts.join(" ");
-  }
-  return getCurvedPath(validPoints);
-}
-function getAreaPath(points, baseline, curved) {
-  if (!Array.isArray(points)) {
-    return void 0;
-  }
-  if (typeof baseline !== "number") {
-    return void 0;
-  }
-  if (points.length === 0) {
-    return "";
-  }
-  for (const point of points) {
-    if (typeof point !== "object" || point === null || typeof point.x !== "number" || typeof point.y !== "number") {
-      return void 0;
-    }
-  }
-  const validPoints = points;
-  let upperPath;
-  if (curved === true && validPoints.length > 2) {
-    upperPath = getCurvedPath(validPoints);
-  } else {
-    upperPath = validPoints.map((p2, i) => (i === 0 ? "M" : "L") + `${p2.x},${p2.y}`).join(" ");
-  }
-  const lastPoint = validPoints[validPoints.length - 1];
-  const firstPoint = validPoints[0];
-  return `${upperPath} L${lastPoint.x},${baseline} L${firstPoint.x},${baseline} Z`;
-}
-function getArcPath(cx, cy, radius, startAngle, endAngle) {
-  if (typeof cx !== "number" || typeof cy !== "number" || typeof radius !== "number" || typeof startAngle !== "number" || typeof endAngle !== "number") {
-    return void 0;
-  }
-  if (radius <= 0) {
-    return void 0;
-  }
-  const x1 = cx + radius * Math.cos(startAngle);
-  const y1 = cy + radius * Math.sin(startAngle);
-  const x2 = cx + radius * Math.cos(endAngle);
-  const y2 = cy + radius * Math.sin(endAngle);
-  const angleDiff = endAngle - startAngle;
-  const largeArcFlag = Math.abs(angleDiff) > Math.PI ? 1 : 0;
-  return `M${x1},${y1} A${radius},${radius} 0 ${largeArcFlag},1 ${x2},${y2}`;
-}
-function getPieSlices(data, valueKey) {
-  if (!Array.isArray(data)) {
-    return void 0;
-  }
-  if (typeof valueKey !== "string") {
-    return void 0;
-  }
-  if (data.length === 0) {
-    return [];
-  }
-  const values = data.map((item) => {
-    if (typeof item !== "object" || item === null) return 0;
-    const val = item[valueKey];
-    return typeof val === "number" ? val : 0;
-  });
-  const total = values.reduce((sum, val) => sum + val, 0);
-  const slices = [];
-  let currentAngle = 0;
-  for (let i = 0; i < values.length; i++) {
-    const value = values[i];
-    const percentage = total > 0 ? value / total * 100 : 0;
-    const angleSpan = total > 0 ? value / total * Math.PI * 2 : 0;
-    slices.push({
-      startAngle: currentAngle,
-      endAngle: currentAngle + angleSpan,
-      value,
-      percentage
-    });
-    currentAngle += angleSpan;
-  }
-  return slices;
-}
-function getDonutSlices(data, valueKey, innerRadius) {
-  if (typeof innerRadius !== "number" || innerRadius < 0) {
-    return void 0;
-  }
-  const pieSlices = getPieSlices(data, valueKey);
-  if (pieSlices === void 0) {
-    return void 0;
-  }
-  const outerRadius = 100;
-  return pieSlices.map((slice) => ({
-    ...slice,
-    outerRadius,
-    innerRadius
-  }));
-}
-function getRadarPoints(data, valueKey, cx, cy, radius, maxValue) {
-  if (!Array.isArray(data)) {
-    return void 0;
-  }
-  if (typeof valueKey !== "string") {
-    return void 0;
-  }
-  if (typeof cx !== "number" || typeof cy !== "number" || typeof radius !== "number" || typeof maxValue !== "number") {
-    return void 0;
-  }
-  if (maxValue <= 0) {
-    return void 0;
-  }
-  if (data.length === 0) {
-    return [];
-  }
-  const points = [];
-  const angleStep = Math.PI * 2 / data.length;
-  for (let i = 0; i < data.length; i++) {
-    const item = data[i];
-    const value = typeof item === "object" && item !== null ? item[valueKey] : 0;
-    const numValue = typeof value === "number" ? value : 0;
-    const scaledRadius = numValue / maxValue * radius;
-    const angle = -Math.PI / 2 + i * angleStep;
-    const x2 = cx + scaledRadius * Math.cos(angle);
-    const y2 = cy + scaledRadius * Math.sin(angle);
-    points.push({ x: x2, y: y2 });
-  }
-  return points;
-}
-function getRadarAxes(labels, cx, cy, radius) {
-  if (!Array.isArray(labels)) {
-    return void 0;
-  }
-  if (typeof cx !== "number" || typeof cy !== "number" || typeof radius !== "number") {
-    return void 0;
-  }
-  if (radius < 0) {
-    return void 0;
-  }
-  if (labels.length === 0) {
-    return [];
-  }
-  const axes = [];
-  const angleStep = Math.PI * 2 / labels.length;
-  for (let i = 0; i < labels.length; i++) {
-    const label = String(labels[i]);
-    const angle = -Math.PI / 2 + i * angleStep;
-    const x2 = cx + radius * Math.cos(angle);
-    const y2 = cy + radius * Math.sin(angle);
-    axes.push({
-      x1: cx,
-      y1: cy,
-      x2,
-      y2,
-      label,
-      angle
-    });
-  }
-  return axes;
-}
-function getChartBounds(data, valueKey) {
-  if (!Array.isArray(data) || data.length === 0) {
-    return void 0;
-  }
-  if (typeof valueKey !== "string") {
-    return void 0;
-  }
-  const values = [];
-  for (const item of data) {
-    if (typeof item !== "object" || item === null) {
-      continue;
-    }
-    const val = item[valueKey];
-    if (typeof val === "number") {
-      values.push(val);
-    }
-  }
-  if (values.length === 0) {
-    return void 0;
-  }
-  return {
-    min: Math.min(...values),
-    max: Math.max(...values)
-  };
-}
-function getLinePoints(data, valueKey, width, height, padding) {
-  if (!Array.isArray(data) || data.length === 0) return void 0;
-  if (typeof valueKey !== "string") return void 0;
-  if (typeof width !== "number" || typeof height !== "number") return void 0;
-  const pad = typeof padding === "number" ? padding : 40;
-  const bounds = getChartBounds(data, valueKey);
-  if (!bounds) return void 0;
-  const { min, max } = bounds;
-  const chartWidth = width - pad * 2;
-  const chartHeight = height - pad * 2;
-  return data.map((item, idx) => {
-    const value = item[valueKey];
-    if (typeof value !== "number") return { x: 0, y: 0 };
-    const x2 = pad + (data.length > 1 ? idx / (data.length - 1) * chartWidth : chartWidth / 2);
-    const y2 = min === max ? pad + chartHeight / 2 : pad + chartHeight - scaleValue(value, min, max, 0, chartHeight);
-    return { x: x2, y: y2 };
-  });
-}
-function generateTicks(min, max, count) {
-  if (typeof min !== "number" || typeof max !== "number" || typeof count !== "number") {
-    return [];
-  }
-  if (count <= 0) {
-    return [];
-  }
-  if (min === max) {
-    return [min];
-  }
-  if (count === 1) {
-    return [min];
-  }
-  if (count === 2) {
-    return [min, max];
-  }
-  const range = max - min;
-  const rawStep = range / (count - 1);
-  const niceStep = getNiceStep(rawStep);
-  const niceMin = Math.floor(min / niceStep) * niceStep;
-  const ticks = [];
-  for (let i = 0; i < count; i++) {
-    const tick = niceMin + i * niceStep;
-    ticks.push(Math.round(tick * 1e10) / 1e10);
-  }
-  return ticks;
-}
-function getNiceStep(rawStep) {
-  const magnitude = Math.pow(10, Math.floor(Math.log10(rawStep)));
-  const normalized = rawStep / magnitude;
-  let niceNormalized;
-  if (normalized <= 1) {
-    niceNormalized = 1;
-  } else if (normalized <= 2) {
-    niceNormalized = 2;
-  } else if (normalized <= 2.5) {
-    niceNormalized = 2.5;
-  } else if (normalized <= 5) {
-    niceNormalized = 5;
-  } else {
-    niceNormalized = 10;
-  }
-  return niceNormalized * magnitude;
-}
-function binData(data, valueKey, binCount) {
-  if (!Array.isArray(data)) {
-    return void 0;
-  }
-  if (typeof valueKey !== "string") {
-    return void 0;
-  }
-  if (typeof binCount !== "number" || binCount <= 0) {
-    return [];
-  }
-  if (data.length === 0) {
-    return [];
-  }
-  const values = [];
-  for (const item of data) {
-    if (typeof item !== "object" || item === null) continue;
-    const val = item[valueKey];
-    if (typeof val === "number") {
-      values.push(val);
-    }
-  }
-  if (values.length === 0) {
-    return [];
-  }
-  const minVal = Math.min(...values);
-  const maxVal = Math.max(...values);
-  const binWidth = maxVal === minVal ? 1 : (maxVal - minVal) / binCount;
-  const bins = [];
-  for (let i = 0; i < binCount; i++) {
-    bins.push({
-      binStart: minVal + i * binWidth,
-      binEnd: minVal + (i + 1) * binWidth,
-      count: 0,
-      values: []
-    });
-  }
-  for (const val of values) {
-    let binIndex = Math.floor((val - minVal) / binWidth);
-    if (binIndex >= binCount) {
-      binIndex = binCount - 1;
-    }
-    bins[binIndex].count++;
-    bins[binIndex].values.push(val);
-  }
-  return bins;
-}
-function aggregateData(data, groupKey, valueKey, aggregation) {
-  if (!Array.isArray(data)) {
-    return void 0;
-  }
-  if (typeof groupKey !== "string" || typeof valueKey !== "string") {
-    return void 0;
-  }
-  const validAggregations = /* @__PURE__ */ new Set(["sum", "avg", "min", "max", "count"]);
-  if (typeof aggregation !== "string" || !validAggregations.has(aggregation)) {
-    return void 0;
-  }
-  if (data.length === 0) {
-    return [];
-  }
-  const groups = /* @__PURE__ */ new Map();
-  for (const item of data) {
-    if (typeof item !== "object" || item === null) continue;
-    const obj = item;
-    const group = String(obj[groupKey] ?? "");
-    const val = obj[valueKey];
-    const numVal = typeof val === "number" ? val : 0;
-    if (!groups.has(group)) {
-      groups.set(group, []);
-    }
-    groups.get(group).push(numVal);
-  }
-  const result = [];
-  for (const [group, values] of groups) {
-    let aggregatedValue;
-    switch (aggregation) {
-      case "sum":
-        aggregatedValue = values.reduce((sum, v2) => sum + v2, 0);
-        break;
-      case "avg":
-        aggregatedValue = values.reduce((sum, v2) => sum + v2, 0) / values.length;
-        break;
-      case "min":
-        aggregatedValue = Math.min(...values);
-        break;
-      case "max":
-        aggregatedValue = Math.max(...values);
-        break;
-      case "count":
-        aggregatedValue = values.length;
-        break;
-      default:
-        aggregatedValue = 0;
-    }
-    result.push({ group, value: aggregatedValue });
-  }
-  return result;
-}
-function downsample(data, targetCount, method) {
-  if (!Array.isArray(data)) {
-    return void 0;
-  }
-  if (typeof targetCount !== "number" || targetCount <= 0) {
-    return void 0;
-  }
-  const validMethods = /* @__PURE__ */ new Set(["uniform", "lttb"]);
-  if (typeof method !== "string" || !validMethods.has(method)) {
-    return void 0;
-  }
-  if (data.length === 0) {
-    return [];
-  }
-  if (targetCount >= data.length) {
-    return data;
-  }
-  if (method === "uniform") {
-    return downsampleUniform(data, targetCount);
-  } else {
-    return downsampleLTTB(data, targetCount);
-  }
-}
-function downsampleUniform(data, targetCount) {
-  if (targetCount === 1) {
-    return [data[0]];
-  }
-  if (targetCount === 2) {
-    return [data[0], data[data.length - 1]];
-  }
-  const result = [];
-  const step = (data.length - 1) / (targetCount - 1);
-  for (let i = 0; i < targetCount; i++) {
-    const index = Math.round(i * step);
-    result.push(data[index]);
-  }
-  return result;
-}
-function downsampleLTTB(data, targetCount) {
-  if (targetCount === 1) {
-    return [data[0]];
-  }
-  if (targetCount === 2) {
-    return [data[0], data[data.length - 1]];
-  }
-  const getXY = (point) => {
-    if (typeof point !== "object" || point === null) {
-      return { x: 0, y: 0 };
-    }
-    const obj = point;
-    const x2 = typeof obj["x"] === "number" ? obj["x"] : typeof obj["timestamp"] === "number" ? obj["timestamp"] : 0;
-    const y2 = typeof obj["y"] === "number" ? obj["y"] : typeof obj["value"] === "number" ? obj["value"] : 0;
-    return { x: x2, y: y2 };
-  };
-  const result = [];
-  result.push(data[0]);
-  const numBuckets = targetCount - 2;
-  const middleData = data.length - 2;
-  const bucketSize = middleData / numBuckets;
-  let prevSelectedIndex = 0;
-  for (let bucketIndex = 0; bucketIndex < numBuckets; bucketIndex++) {
-    const bucketStart = Math.floor(bucketIndex * bucketSize) + 1;
-    const bucketEnd = Math.floor((bucketIndex + 1) * bucketSize) + 1;
-    const nextBucketStart = bucketEnd;
-    const nextBucketEnd = bucketIndex < numBuckets - 1 ? Math.floor((bucketIndex + 2) * bucketSize) + 1 : data.length;
-    let avgX = 0;
-    let avgY = 0;
-    const nextLen = nextBucketEnd - nextBucketStart;
-    if (nextLen > 0) {
-      for (let j2 = nextBucketStart; j2 < nextBucketEnd; j2++) {
-        const point = getXY(data[j2]);
-        avgX += point.x;
-        avgY += point.y;
-      }
-      avgX /= nextLen;
-      avgY /= nextLen;
-    } else {
-      const lastPoint = getXY(data[data.length - 1]);
-      avgX = lastPoint.x;
-      avgY = lastPoint.y;
-    }
-    const pointA = getXY(data[prevSelectedIndex]);
-    let maxArea = -1;
-    let maxAreaIndex = bucketStart;
-    for (let j2 = bucketStart; j2 < bucketEnd; j2++) {
-      const pointB = getXY(data[j2]);
-      const area = Math.abs(
-        pointA.x * (pointB.y - avgY) + pointB.x * (avgY - pointA.y) + avgX * (pointA.y - pointB.y)
-      );
-      if (area > maxArea) {
-        maxArea = area;
-        maxAreaIndex = j2;
-      }
-    }
-    result.push(data[maxAreaIndex]);
-    prevSelectedIndex = maxAreaIndex;
-  }
-  result.push(data[data.length - 1]);
-  return result;
-}
 function evaluateStyle(expr, ctx) {
   const preset = ctx.styles?.[expr.name];
   if (!preset) return void 0;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@constela/runtime",
-  "version": "2.0.5",
+  "version": "2.0.6",
   "description": "Runtime DOM renderer for Constela UI framework",
   "type": "module",
   "main": "./dist/index.js",
@@ -18,8 +18,8 @@
     "dompurify": "^3.3.1",
     "marked": "^17.0.1",
     "shiki": "^3.20.0",
-    "@constela/core": "0.18.2",
-    "@constela/compiler": "0.15.8"
+    "@constela/core": "0.18.3",
+    "@constela/compiler": "0.15.9"
   },
   "devDependencies": {
     "@types/dompurify": "^3.2.0",
@@ -29,10 +29,10 @@
     "tsup": "^8.0.0",
     "typescript": "^5.3.0",
     "vitest": "^2.0.0",
-    "@constela/server": "14.0.3"
+    "@constela/server": "14.0.4"
   },
   "peerDependencies": {
-    "@constela/ai": "3.0.2"
+    "@constela/ai": "3.0.3"
   },
   "peerDependenciesMeta": {
     "@constela/ai": {