@constela/core 0.18.4 → 0.19.0

package/dist/index.d.ts

@@ -2439,78 +2439,34 @@ declare function isSuspenseBoundary(value: unknown): value is SuspenseBoundary;
 declare function isStreamChunk(value: unknown): value is StreamChunk;
 
 /**
- * Chart Helper Functions
+ * Global Helper Functions
  *
- * Shared chart helper functions used by both runtime evaluator and SSR renderer.
- * This module provides coordinate calculation, path generation, and data utilities
- * for chart rendering.
- */
-/**
- * Normalizes a value to 0-1 range
- *
- * @param value - The value to normalize
- * @param min - The minimum value of the range
- * @param max - The maximum value of the range
- * @returns Normalized value (0-1), or undefined for invalid input
- */
-declare function normalizeValue(value: unknown, min: unknown, max: unknown): number | undefined;
-/**
- * Scales a value from one range to another
+ * Pure helper functions shared between runtime (client) and server (SSR).
+ * These functions are callable as global helpers in Constela expressions.
  *
- * @param value - The value to scale
- * @param domainMin - Minimum of source range
- * @param domainMax - Maximum of source range
- * @param rangeMin - Minimum of target range
- * @param rangeMax - Maximum of target range
- * @returns Scaled value, or undefined for invalid input
+ * All functions are pure (no DOM, no browser APIs).
+ * They use only: Math, Date, Intl.DateTimeFormat, Array methods.
  */
-declare function scaleValue(value: unknown, domainMin: unknown, domainMax: unknown, rangeMin: unknown, rangeMax: unknown): number | undefined;
 /**
- * Finds min and max values in data
- *
- * @param data - Array of objects
- * @param valueKey - Key to use for values
- * @returns Object with min and max, or undefined for invalid input
+ * CalendarDay type - represents a day in the calendar grid
  */
-declare function getChartBounds(data: unknown, valueKey: unknown): {
-    min: number;
-    max: number;
-} | undefined;
-/**
- * Generates scaled line chart points from data.
- *
- * @param data - Array of data objects
- * @param valueKey - Key to extract values from data
- * @param width - Chart width
- * @param height - Chart height
- * @param padding - Padding around chart area (default: 40)
- * @returns Array of {x, y} points scaled to fit the chart area
- */
-declare function getLinePoints(data: unknown, valueKey: unknown, width: unknown, height: unknown, padding?: unknown): Array<{
-    x: number;
-    y: number;
-}> | undefined;
-/**
- * Generates SVG path string for line chart
- *
- * @param points - Array of {x, y} points
- * @param curved - Whether to use curved lines (Catmull-Rom spline)
- * @returns SVG path string, or undefined for invalid input
- */
-declare function getLinePath(points: unknown, curved?: unknown): string | undefined;
+interface CalendarDay {
+    readonly date: number;
+    readonly month: number;
+    readonly year: number;
+    readonly isCurrentMonth: boolean;
+}
 /**
- * Registry of chart helper functions that can be called from expressions.
- * This is used by both runtime evaluator and SSR renderer.
+ * Whitelist of global helper functions that can be called with target: null
  */
-declare const CHART_HELPERS: Record<string, (...args: unknown[]) => unknown>;
+declare const GLOBAL_FUNCTIONS: Record<string, (...args: unknown[]) => unknown>;
 /**
- * Calls a chart helper function by name.
- * Returns undefined if the function is not found.
+ * Calls a global helper function by name
  *
  * @param method - The function name to call
  * @param args - Arguments to pass to the function
- * @returns The function result, or undefined if not found
+ * @returns The function result, or undefined if the function is not found
  */
-declare function callChartHelper(method: string, args: unknown[]): unknown;
+declare function callGlobalFunction(method: string, args: unknown[]): unknown;
 
-export { AI_OUTPUT_TYPES, AI_PROVIDER_TYPES, type ActionDefinition, type ActionStep, type AiDataSource, type AiOutputType, type AiProviderType, type ArrayExpr, BINARY_OPERATORS, type BinExpr, type BinaryOperator, type BindStep, type BooleanField, CHART_HELPERS, CLIPBOARD_OPERATIONS, COLOR_SCHEMES, type CallExpr, type CallStep, type ClearTimerStep, type ClipboardOperation, type ClipboardStep, type CloseStep, type CodeNode, type ColorScheme, type ComponentDef, type ComponentNode, type ComponentsRef, type CompoundVariant, type ConcatExpr, type CondExpr, type ConfirmStep, type ConstelaAst, ConstelaError, type ConstelaProgram, type CookieInitialExpr, DATA_SOURCE_TYPES, DATA_TRANSFORMS, type DataExpr, type DataSource, type DataSourceType, type DataTransform, type DelayStep, type DisposeStep, type DomStep, type EachNode, type ElementNode, type ErrorBoundaryNode, type ErrorCode, type ErrorOptions, type EventHandler, type EventHandlerOptions, type Expression, FOCUS_OPERATIONS, type FetchStep, type FlushStrategy, type FocusOperation, type FocusStep, type GenerateStep, type GetExpr, HTTP_METHODS, type HttpMethod, ISLAND_STRATEGIES, type IfNode, type IfStep, type ImportExpr, type ImportStep, type IndexExpr, type IntervalStep, type IslandNode, type IslandStrategy, type IslandStrategyOptions, type LambdaExpr, type LayoutProgram, type LifecycleHooks, type ListField, type LitExpr, type LocalActionDefinition, type LocalActionStep, type LocalExpr, type MarkdownNode, NAVIGATE_TARGETS, type NavigateStep, type NavigateTarget, type NotExpr, type NumberField, type ObjExpr, type ObjectField, type OptimisticStep, PARAM_TYPES, type ParamDef, type ParamExpr, type ParamType, type PortalNode, type Program, type ReconnectConfig, type RefExpr, type RejectStep, type RouteDefinition, type RouteExpr, type SSECloseStep, type SSEConnectStep, STORAGE_OPERATIONS, STORAGE_TYPES, type SendStep, type SetPathStep, type SetStep, type SlotNode, type StateExpr, type StateField, type StaticPathsDefinition, type StorageOperation, type StorageStep, type StorageType, type StreamChunk, type StreamChunkType, type StreamingRenderOptions, type StringField, type StyleExpr, type StylePreset, type SubscribeStep, type SuspenseBoundary, type SuspenseNode, type TextNode, type ThemeColors, type ThemeConfig, type ThemeFonts, UPDATE_OPERATIONS, type UnbindStep, type UpdateOperation, type UpdateStep, VALIDITY_PROPERTIES, type ValidationFailure, type ValidationResult, type ValidationSuccess, type ValidityExpr, type ValidityProperty, type VarExpr, type ViewNode, astSchema, callChartHelper, createClipboardWriteMissingValueError, createComponentCycleError, createComponentNotFoundError, createComponentPropMissingError, createComponentPropTypeError, createCondElseRequiredError, createDataNotDefinedError, createDuplicateActionError, createDuplicateDefaultSlotError, createDuplicateIslandIdError, createDuplicateSlotNameError, createImportsNotDefinedError, createInvalidClipboardOperationError, createInvalidDataSourceError, createInvalidNavigateTargetError, createInvalidSlotNameError, createInvalidStorageOperationError, createInvalidStorageTypeError, createLayoutMissingSlotError, createLayoutNotFoundError, createLocalActionInvalidStepError, createOperationInvalidForTypeError, createOperationMissingFieldError, createOperationUnknownError, createRouteNotDefinedError, createSchemaError, createSlotInLoopError, createStorageSetMissingValueError, createUndefinedActionError, createUndefinedDataError, createUndefinedDataSourceError, createUndefinedImportError, createUndefinedLocalStateError, createUndefinedParamError, createUndefinedRefError, createUndefinedRouteParamError, createUndefinedStateError, createUndefinedStyleError, createUndefinedVarError, createUndefinedVariantError, createUnsupportedVersionError, findSimilarNames, getChartBounds, getLinePath, getLinePoints, isActionStep, isAiDataSource, isArrayExpr, isBinExpr, isBooleanField, isCallStep, isClipboardStep, isCodeNode, isColorScheme, isComponentNode, isConcatExpr, isCondExpr, isConstelaError, isCookieInitialExpr, isDataExpr, isDataSource, isDisposeStep, isEachNode, isElementNode, isErrorBoundaryNode, isEventHandler, isExpression, isFetchStep, isFocusStep, isGenerateStep, isGetExpr, isIfNode, isImportExpr, isImportStep, isIslandNode, isIslandStrategy, isIslandStrategyOptions, isLayoutProgram, isLifecycleHooks, isListField, isLitExpr, isLocalActionDefinition, isLocalActionStep, isMarkdownNode, isNamedSlotNode, isNavigateStep, isNotExpr, isNumberField, isObjectField, isParamExpr, isPortalNode, isRefExpr, isRouteDefinition, isRouteExpr, isSetPathStep, isSetStep, isSlotNode, isStateExpr, isStateField, isStaticPathsDefinition, isStorageStep, isStreamChunk, isStreamingRenderOptions, isStringField, isStyleExpr, isSubscribeStep, isSuspenseBoundary, isSuspenseNode, isTextNode, isThemeColors, isThemeConfig, isThemeFonts, isUpdateStep, isValidityExpr, isVarExpr, isViewNode, normalizeValue, scaleValue, validateAst };
+export { AI_OUTPUT_TYPES, AI_PROVIDER_TYPES, type ActionDefinition, type ActionStep, type AiDataSource, type AiOutputType, type AiProviderType, type ArrayExpr, BINARY_OPERATORS, type BinExpr, type BinaryOperator, type BindStep, type BooleanField, CLIPBOARD_OPERATIONS, COLOR_SCHEMES, type CalendarDay, type CallExpr, type CallStep, type ClearTimerStep, type ClipboardOperation, type ClipboardStep, type CloseStep, type CodeNode, type ColorScheme, type ComponentDef, type ComponentNode, type ComponentsRef, type CompoundVariant, type ConcatExpr, type CondExpr, type ConfirmStep, type ConstelaAst, ConstelaError, type ConstelaProgram, type CookieInitialExpr, DATA_SOURCE_TYPES, DATA_TRANSFORMS, type DataExpr, type DataSource, type DataSourceType, type DataTransform, type DelayStep, type DisposeStep, type DomStep, type EachNode, type ElementNode, type ErrorBoundaryNode, type ErrorCode, type ErrorOptions, type EventHandler, type EventHandlerOptions, type Expression, FOCUS_OPERATIONS, type FetchStep, type FlushStrategy, type FocusOperation, type FocusStep, GLOBAL_FUNCTIONS, type GenerateStep, type GetExpr, HTTP_METHODS, type HttpMethod, ISLAND_STRATEGIES, type IfNode, type IfStep, type ImportExpr, type ImportStep, type IndexExpr, type IntervalStep, type IslandNode, type IslandStrategy, type IslandStrategyOptions, type LambdaExpr, type LayoutProgram, type LifecycleHooks, type ListField, type LitExpr, type LocalActionDefinition, type LocalActionStep, type LocalExpr, type MarkdownNode, NAVIGATE_TARGETS, type NavigateStep, type NavigateTarget, type NotExpr, type NumberField, type ObjExpr, type ObjectField, type OptimisticStep, PARAM_TYPES, type ParamDef, type ParamExpr, type ParamType, type PortalNode, type Program, type ReconnectConfig, type RefExpr, type RejectStep, type RouteDefinition, type RouteExpr, type SSECloseStep, type SSEConnectStep, STORAGE_OPERATIONS, STORAGE_TYPES, type SendStep, type SetPathStep, type SetStep, type SlotNode, type StateExpr, type StateField, type StaticPathsDefinition, type StorageOperation, type StorageStep, type StorageType, type StreamChunk, type StreamChunkType, type StreamingRenderOptions, type StringField, type StyleExpr, type StylePreset, type SubscribeStep, type SuspenseBoundary, type SuspenseNode, type TextNode, type ThemeColors, type ThemeConfig, type ThemeFonts, UPDATE_OPERATIONS, type UnbindStep, type UpdateOperation, type UpdateStep, VALIDITY_PROPERTIES, type ValidationFailure, type ValidationResult, type ValidationSuccess, type ValidityExpr, type ValidityProperty, type VarExpr, type ViewNode, astSchema, callGlobalFunction, createClipboardWriteMissingValueError, createComponentCycleError, createComponentNotFoundError, createComponentPropMissingError, createComponentPropTypeError, createCondElseRequiredError, createDataNotDefinedError, createDuplicateActionError, createDuplicateDefaultSlotError, createDuplicateIslandIdError, createDuplicateSlotNameError, createImportsNotDefinedError, createInvalidClipboardOperationError, createInvalidDataSourceError, createInvalidNavigateTargetError, createInvalidSlotNameError, createInvalidStorageOperationError, createInvalidStorageTypeError, createLayoutMissingSlotError, createLayoutNotFoundError, createLocalActionInvalidStepError, createOperationInvalidForTypeError, createOperationMissingFieldError, createOperationUnknownError, createRouteNotDefinedError, createSchemaError, createSlotInLoopError, createStorageSetMissingValueError, createUndefinedActionError, createUndefinedDataError, createUndefinedDataSourceError, createUndefinedImportError, createUndefinedLocalStateError, createUndefinedParamError, createUndefinedRefError, createUndefinedRouteParamError, createUndefinedStateError, createUndefinedStyleError, createUndefinedVarError, createUndefinedVariantError, createUnsupportedVersionError, findSimilarNames, isActionStep, isAiDataSource, isArrayExpr, isBinExpr, isBooleanField, isCallStep, isClipboardStep, isCodeNode, isColorScheme, isComponentNode, isConcatExpr, isCondExpr, isConstelaError, isCookieInitialExpr, isDataExpr, isDataSource, isDisposeStep, isEachNode, isElementNode, isErrorBoundaryNode, isEventHandler, isExpression, isFetchStep, isFocusStep, isGenerateStep, isGetExpr, isIfNode, isImportExpr, isImportStep, isIslandNode, isIslandStrategy, isIslandStrategyOptions, isLayoutProgram, isLifecycleHooks, isListField, isLitExpr, isLocalActionDefinition, isLocalActionStep, isMarkdownNode, isNamedSlotNode, isNavigateStep, isNotExpr, isNumberField, isObjectField, isParamExpr, isPortalNode, isRefExpr, isRouteDefinition, isRouteExpr, isSetPathStep, isSetStep, isSlotNode, isStateExpr, isStateField, isStaticPathsDefinition, isStorageStep, isStreamChunk, isStreamingRenderOptions, isStringField, isStyleExpr, isSubscribeStep, isSuspenseBoundary, isSuspenseNode, isTextNode, isThemeColors, isThemeConfig, isThemeFonts, isUpdateStep, isValidityExpr, isVarExpr, isViewNode, validateAst };

package/dist/index.js

@@ -2655,7 +2655,273 @@ function isStreamChunk(value) {
   return true;
 }
 
-// src/helpers/chart.ts
+// src/helpers/global-functions.ts
+function getCalendarDays(year, month) {
+  if (typeof year !== "number" || typeof month !== "number") {
+    return void 0;
+  }
+  if (month < 0 || month > 11) {
+    return void 0;
+  }
+  const days = [];
+  const firstDayOfMonth = new Date(year, month, 1);
+  const dayOfWeek = firstDayOfMonth.getDay();
+  const lastDayOfMonth = new Date(year, month + 1, 0);
+  const daysInMonth = lastDayOfMonth.getDate();
+  const prevMonthDays = dayOfWeek;
+  const prevMonthLastDay = new Date(year, month, 0);
+  const prevMonthDaysCount = prevMonthLastDay.getDate();
+  const prevMonth = month === 0 ? 11 : month - 1;
+  const prevYear = month === 0 ? year - 1 : year;
+  for (let i = prevMonthDays - 1; i >= 0; i--) {
+    days.push({
+      date: prevMonthDaysCount - i,
+      month: prevMonth,
+      year: prevYear,
+      isCurrentMonth: false
+    });
+  }
+  for (let i = 1; i <= daysInMonth; i++) {
+    days.push({
+      date: i,
+      month,
+      year,
+      isCurrentMonth: true
+    });
+  }
+  const totalDaysSoFar = days.length;
+  const totalWeeksNeeded = Math.ceil(totalDaysSoFar / 7);
+  const targetDays = totalWeeksNeeded * 7;
+  const nextMonth = month === 11 ? 0 : month + 1;
+  const nextYear = month === 11 ? year + 1 : year;
+  const nextMonthDaysNeeded = targetDays - totalDaysSoFar;
+  for (let i = 1; i <= nextMonthDaysNeeded; i++) {
+    days.push({
+      date: i,
+      month: nextMonth,
+      year: nextYear,
+      isCurrentMonth: false
+    });
+  }
+  return days;
+}
+function getWeekDays(locale) {
+  const effectiveLocale = typeof locale === "string" ? locale : "en-US";
+  const baseSunday = new Date(2024, 0, 7);
+  const weekDays = [];
+  try {
+    const formatter = new Intl.DateTimeFormat(effectiveLocale || "en-US", { weekday: "short" });
+    for (let i = 0; i < 7; i++) {
+      const date = new Date(baseSunday);
+      date.setDate(baseSunday.getDate() + i);
+      weekDays.push(formatter.format(date));
+    }
+    return weekDays;
+  } catch {
+    const fallbackFormatter = new Intl.DateTimeFormat("en-US", { weekday: "short" });
+    for (let i = 0; i < 7; i++) {
+      const date = new Date(baseSunday);
+      date.setDate(baseSunday.getDate() + i);
+      weekDays.push(fallbackFormatter.format(date));
+    }
+    return weekDays;
+  }
+}
+function getMonthName(month, locale) {
+  if (typeof month !== "number" || month < 0 || month > 11) {
+    return void 0;
+  }
+  const effectiveLocale = typeof locale === "string" ? locale : "en-US";
+  try {
+    const date = new Date(2024, month, 1);
+    const formatter = new Intl.DateTimeFormat(effectiveLocale, { month: "long" });
+    return formatter.format(date);
+  } catch {
+    const date = new Date(2024, month, 1);
+    const formatter = new Intl.DateTimeFormat("en-US", { month: "long" });
+    return formatter.format(date);
+  }
+}
+function formatDateISO(year, month, date) {
+  if (typeof year !== "number" || typeof month !== "number" || typeof date !== "number") {
+    return void 0;
+  }
+  const y = String(year).padStart(4, "0");
+  const m = String(month + 1).padStart(2, "0");
+  const d = String(date).padStart(2, "0");
+  return `${y}-${m}-${d}`;
+}
+function sortBy(items, key, direction) {
+  if (!Array.isArray(items)) {
+    return void 0;
+  }
+  if (typeof key !== "string") {
+    return void 0;
+  }
+  const forbiddenKeys = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
+  if (forbiddenKeys.has(key)) {
+    return void 0;
+  }
+  const dir = direction === "desc" ? "desc" : "asc";
+  const sorted = [...items];
+  sorted.sort((a, b) => {
+    const aVal = a != null && typeof a === "object" ? a[key] : void 0;
+    const bVal = b != null && typeof b === "object" ? b[key] : void 0;
+    if (aVal == null && bVal == null) return 0;
+    if (aVal == null) return 1;
+    if (bVal == null) return -1;
+    let comparison = 0;
+    if (typeof aVal === "number" && typeof bVal === "number") {
+      comparison = aVal - bVal;
+    } else {
+      comparison = String(aVal).localeCompare(String(bVal));
+    }
+    return dir === "desc" ? -comparison : comparison;
+  });
+  return sorted;
+}
+function getPaginatedItems(items, page, pageSize) {
+  if (!Array.isArray(items)) {
+    return void 0;
+  }
+  if (typeof page !== "number" || page < 0) {
+    return void 0;
+  }
+  if (typeof pageSize !== "number" || pageSize <= 0) {
+    return void 0;
+  }
+  const start = page * pageSize;
+  const end = start + pageSize;
+  return items.slice(start, end);
+}
+function getTotalPages(itemCount, pageSize) {
+  if (typeof itemCount !== "number" || typeof pageSize !== "number") {
+    return 0;
+  }
+  if (itemCount < 0 || pageSize <= 0) {
+    return 0;
+  }
+  if (itemCount === 0) {
+    return 0;
+  }
+  return Math.ceil(itemCount / pageSize);
+}
+function getPageNumbers(currentPage, totalPages, maxVisible) {
+  if (typeof currentPage !== "number" || typeof totalPages !== "number" || typeof maxVisible !== "number") {
+    return [];
+  }
+  if (totalPages <= 0) {
+    return [];
+  }
+  if (currentPage < 0 || currentPage >= totalPages) {
+    return [];
+  }
+  if (totalPages <= maxVisible) {
+    return Array.from({ length: totalPages }, (_, i) => i);
+  }
+  const result = [];
+  const firstPage = 0;
+  const lastPage = totalPages - 1;
+  result.push(firstPage);
+  const middleSlots = maxVisible - 2;
+  let middleStart = currentPage - Math.floor((middleSlots - 1) / 2);
+  let middleEnd = currentPage + Math.ceil((middleSlots - 1) / 2);
+  if (middleStart <= 1) {
+    middleStart = 1;
+    middleEnd = Math.min(middleSlots, lastPage - 1);
+  }
+  if (middleEnd >= lastPage - 1) {
+    middleEnd = lastPage - 1;
+    middleStart = Math.max(1, lastPage - middleSlots);
+  }
+  if (middleStart > 1) {
+    result.push(-1);
+  }
+  for (let i = middleStart; i <= middleEnd; i++) {
+    if (i > firstPage && i < lastPage) {
+      result.push(i);
+    }
+  }
+  if (middleEnd < lastPage - 1) {
+    result.push(-1);
+  }
+  result.push(lastPage);
+  return result;
+}
+function getVisibleRange(scrollTop, itemHeight, containerHeight, overscan) {
+  if (typeof scrollTop !== "number" || typeof itemHeight !== "number" || typeof containerHeight !== "number" || typeof overscan !== "number") {
+    return void 0;
+  }
+  if (scrollTop < 0 || itemHeight <= 0 || containerHeight <= 0) {
+    return void 0;
+  }
+  const firstVisible = Math.floor(scrollTop / itemHeight);
+  const visibleCount = Math.ceil(containerHeight / itemHeight);
+  const start = Math.max(0, firstVisible - overscan);
+  const end = firstVisible + visibleCount + overscan - 1;
+  return { start, end };
+}
+function getTotalHeight(itemCount, itemHeight) {
+  if (typeof itemCount !== "number" || typeof itemHeight !== "number") {
+    return 0;
+  }
+  if (itemCount < 0 || itemHeight <= 0) {
+    return 0;
+  }
+  return itemCount * itemHeight;
+}
+function formatDate(dateStr, format, locale) {
+  if (typeof dateStr !== "string" || !dateStr) {
+    return void 0;
+  }
+  const isoDateRegex = /^\d{4}-\d{2}-\d{2}$/;
+  if (!isoDateRegex.test(dateStr)) {
+    return void 0;
+  }
+  const [yearStr, monthStr, dayStr] = dateStr.split("-");
+  const year = parseInt(yearStr, 10);
+  const month = parseInt(monthStr, 10) - 1;
+  const day = parseInt(dayStr, 10);
+  const date = new Date(Date.UTC(year, month, day));
+  if (isNaN(date.getTime()) || date.getUTCFullYear() !== year || date.getUTCMonth() !== month || date.getUTCDate() !== day) {
+    return void 0;
+  }
+  const effectiveFormat = typeof format === "string" ? format : "medium";
+  const effectiveLocale = typeof locale === "string" ? locale : "en-US";
+  if (effectiveFormat === "iso") {
+    return dateStr;
+  }
+  try {
+    let options;
+    switch (effectiveFormat) {
+      case "short":
+        if (effectiveLocale.startsWith("ja")) {
+          options = { year: "numeric", month: "2-digit", day: "2-digit", timeZone: "UTC" };
+        } else {
+          options = { year: "2-digit", month: "numeric", day: "numeric", timeZone: "UTC" };
+        }
+        break;
+      case "medium":
+        options = { year: "numeric", month: "short", day: "numeric", timeZone: "UTC" };
+        break;
+      case "long":
+        options = { year: "numeric", month: "long", day: "numeric", timeZone: "UTC" };
+        break;
+      default:
+        options = { year: "numeric", month: "short", day: "numeric", timeZone: "UTC" };
+    }
+    const formatter = new Intl.DateTimeFormat(effectiveLocale, options);
+    return formatter.format(date);
+  } catch {
+    const formatter = new Intl.DateTimeFormat("en-US", {
+      year: "numeric",
+      month: "short",
+      day: "numeric",
+      timeZone: "UTC"
+    });
+    return formatter.format(date);
+  }
+}
 function normalizeValue(value, min, max) {
   if (typeof value !== "number" || typeof min !== "number" || typeof max !== "number") {
     return void 0;
@@ -2675,50 +2941,60 @@ function scaleValue(value, domainMin, domainMax, rangeMin, rangeMax) {
   const normalized = (value - domainMin) / (domainMax - domainMin);
   return rangeMin + normalized * (rangeMax - rangeMin);
 }
-function getChartBounds(data, valueKey) {
-  if (!Array.isArray(data) || data.length === 0) {
+function scaleChartY(value, boundsMin, boundsMax, height, paddingTop, paddingBottom) {
+  if (typeof value !== "number" || typeof boundsMin !== "number" || typeof boundsMax !== "number" || typeof height !== "number" || typeof paddingTop !== "number" || typeof paddingBottom !== "number") {
     return void 0;
   }
-  if (typeof valueKey !== "string") {
+  const drawableHeight = height - paddingTop - paddingBottom;
+  if (drawableHeight <= 0) {
+    return paddingTop;
+  }
+  if (boundsMax === boundsMin) {
+    return paddingTop + drawableHeight / 2;
+  }
+  const normalized = (value - boundsMin) / (boundsMax - boundsMin);
+  return paddingTop + drawableHeight * (1 - normalized);
+}
+function getBarDimensions(data, index, width, height, gap, orientation) {
+  if (!Array.isArray(data) || data.length === 0) {
     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 (typeof index !== "number" || index < 0 || index >= data.length) {
+    return void 0;
   }
-  if (values.length === 0) {
+  if (typeof width !== "number" || typeof height !== "number" || typeof gap !== "number") {
     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;
-  if (width <= 0 || height <= 0) return void 0;
-  const pad = typeof padding === "number" ? padding : 40;
-  if (typeof padding !== "undefined" && typeof padding !== "number") return void 0;
-  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 x = data.length === 1 ? pad : pad + idx / (data.length - 1) * chartWidth;
-    const y = min === max ? pad + chartHeight / 2 : pad + chartHeight - scaleValue(value, min, max, 0, chartHeight);
-    return { x, y };
-  });
+  const isVertical = orientation === "vertical";
+  const barCount = data.length;
+  const values = data.map((d) => typeof d === "number" ? d : 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) {
@@ -2766,15 +3042,462 @@ function getLinePath(points, curved) {
   }
   return getCurvedPath(validPoints);
 }
-var CHART_HELPERS = {
+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((p, i) => (i === 0 ? "M" : "L") + `${p.x},${p.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 x = cx + scaledRadius * Math.cos(angle);
+    const y = cy + scaledRadius * Math.sin(angle);
+    points.push({ x, y });
+  }
+  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 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, groupValues] of groups) {
+    let aggregatedValue;
+    switch (aggregation) {
+      case "sum":
+        aggregatedValue = groupValues.reduce((sum, v) => sum + v, 0);
+        break;
+      case "avg":
+        aggregatedValue = groupValues.reduce((sum, v) => sum + v, 0) / groupValues.length;
+        break;
+      case "min":
+        aggregatedValue = Math.min(...groupValues);
+        break;
+      case "max":
+        aggregatedValue = Math.max(...groupValues);
+        break;
+      case "count":
+        aggregatedValue = groupValues.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 x = typeof obj["x"] === "number" ? obj["x"] : typeof obj["timestamp"] === "number" ? obj["timestamp"] : 0;
+    const y = typeof obj["y"] === "number" ? obj["y"] : typeof obj["value"] === "number" ? obj["value"] : 0;
+    return { x, y };
+  };
+  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 j = nextBucketStart; j < nextBucketEnd; j++) {
+        const point = getXY(data[j]);
+        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 j = bucketStart; j < bucketEnd; j++) {
+      const pointB = getXY(data[j]);
+      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 = j;
+      }
+    }
+    result.push(data[maxAreaIndex]);
+    prevSelectedIndex = maxAreaIndex;
+  }
+  result.push(data[data.length - 1]);
+  return result;
+}
+var GLOBAL_FUNCTIONS = {
+  // Date helpers
+  getCalendarDays: (year, month) => getCalendarDays(year, month),
+  getWeekDays: (locale) => getWeekDays(locale),
+  getMonthName: (month, locale) => getMonthName(month, locale),
+  formatDate: (dateStr, format, locale) => formatDate(dateStr, format, locale),
+  formatDateISO: (year, month, date) => formatDateISO(year, month, date),
+  // DataTable helpers
+  sortBy: (items, key, direction) => sortBy(items, key, direction),
+  getPaginatedItems: (items, page, pageSize) => getPaginatedItems(items, page, pageSize),
+  getTotalPages: (itemCount, pageSize) => getTotalPages(itemCount, pageSize),
+  getPageNumbers: (currentPage, totalPages, maxVisible) => getPageNumbers(currentPage, totalPages, maxVisible),
+  // 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),
-  getLinePath: (points, curved) => getLinePath(points, curved)
+  scaleChartY: (value, boundsMin, boundsMax, height, paddingTop, paddingBottom) => scaleChartY(value, boundsMin, boundsMax, height, paddingTop, paddingBottom),
+  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)
 };
-function callChartHelper(method, args) {
-  const fn = CHART_HELPERS[method];
+function callGlobalFunction(method, args) {
+  const fn = GLOBAL_FUNCTIONS[method];
   if (!fn) {
     return void 0;
   }
@@ -2784,13 +3507,13 @@ export {
   AI_OUTPUT_TYPES,
   AI_PROVIDER_TYPES,
   BINARY_OPERATORS,
-  CHART_HELPERS,
   CLIPBOARD_OPERATIONS,
   COLOR_SCHEMES,
   ConstelaError,
   DATA_SOURCE_TYPES,
   DATA_TRANSFORMS,
   FOCUS_OPERATIONS,
+  GLOBAL_FUNCTIONS,
   HTTP_METHODS,
   ISLAND_STRATEGIES,
   NAVIGATE_TARGETS,
@@ -2800,7 +3523,7 @@ export {
   UPDATE_OPERATIONS,
   VALIDITY_PROPERTIES,
   astSchema,
-  callChartHelper,
+  callGlobalFunction,
   createClipboardWriteMissingValueError,
   createComponentCycleError,
   createComponentNotFoundError,
@@ -2843,9 +3566,6 @@ export {
   createUndefinedVariantError,
   createUnsupportedVersionError,
   findSimilarNames,
-  getChartBounds,
-  getLinePath,
-  getLinePoints,
   isActionStep,
   isAiDataSource,
   isArrayExpr,
@@ -2917,7 +3637,5 @@ export {
   isValidityExpr,
   isVarExpr,
   isViewNode,
-  normalizeValue,
-  scaleValue,
   validateAst
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@constela/core",
-  "version": "0.18.4",
+  "version": "0.19.0",
   "description": "Core types, schema, and validator for Constela UI framework",
   "type": "module",
   "main": "./dist/index.js",