@wavemaker/react-runtime 11.14.1-16.6404

package/components/chart/props.js

@@ -0,0 +1,5 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});

package/components/chart/utils.js

@@ -0,0 +1,691 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.truncateText = exports.triggerFn = exports.prettifyLabels = exports.isShowLegend = exports.isPieType = exports.isPieChart = exports.isNumberType = exports.isLineTypeChart = exports.isLineChart = exports.isEmptyObject = exports.isDonutChart = exports.isCumulativeLineChart = exports.isColumnChart = exports.isChartDataJSON = exports.isChartDataArray = exports.isBubbleChart = exports.isBarChart = exports.isAxisDomainSupported = exports.isAreaChart = exports.getSampleData = exports.getRadiusValue = exports.getNumberFormatedData = exports.getLodashOrderByFormat = exports.getLegendPopupStyle = exports.getDateList = exports.getDateFormatedData = exports.getBarSpacingValue = exports.formatNumber = exports.convertToRechartsFormat = exports.allShapes = exports.SAMPLE_DATA = exports.NONE = void 0;
+var _typeof2 = _interopRequireDefault(require("@babel/runtime/helpers/typeof"));
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _forEach = _interopRequireDefault(require("lodash-es/forEach"));
+var _includes = _interopRequireDefault(require("lodash-es/includes"));
+var _split = _interopRequireDefault(require("lodash-es/split"));
+var _invert = _interopRequireDefault(require("lodash-es/invert"));
+var _isArray = _interopRequireDefault(require("lodash-es/isArray"));
+var _momentTimezone = _interopRequireDefault(require("moment-timezone"));
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { (0, _defineProperty2["default"])(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; } //utils.ts
+// Constants - COMPLETE from Angular
+var chartTypes = ["Column", "Line", "Area", "Cumulative Line", "Bar", "Pie", "Donut", "Bubble"];
+var allShapes = exports.allShapes = ["circle", "square", "diamond", "cross", "triangle-up", "triangle-down"];
+var getCurrentAndPreviousYears = function getCurrentAndPreviousYears() {
+  var numberOfYears = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 3;
+  var currentYear = new Date().getFullYear();
+  return Array.from({
+    length: numberOfYears
+  }, function (_, index) {
+    var year = currentYear - (numberOfYears - 1) + index;
+    return "01/01/".concat(year);
+  });
+};
+var dateList = getCurrentAndPreviousYears();
+// This will generate dates like ['01/01/2022', '01/01/2023', '01/01/2024'] if current year is 2024
+
+var dataTypeJSON = ["Column", "Line", "Pie", "Bar", "Donut", "Bubble"];
+var lineTypeCharts = ["Line", "Area", "Cumulative Line"];
+var dataTypeArray = ["Cumulative Line", "Area"];
+var SAMPLE_DATA = exports.SAMPLE_DATA = {
+  group1: "Europe",
+  group2: "Asia",
+  group3: "America",
+  group4: "Australia"
+};
+var NONE = exports.NONE = "none";
+var barSpacingMap = {
+  small: 0.3,
+  medium: 0.5,
+  large: 0.8
+};
+var donutRatioMap = {
+  small: 0.3,
+  medium: 0.6,
+  large: 0.7
+};
+var barSpacingMapInvert = (0, _invert["default"])(barSpacingMap);
+var donutRatioMapInvert = (0, _invert["default"])(donutRatioMap);
+var tickformats = {
+  Thousand: {
+    prefix: "K",
+    divider: 1000
+  },
+  Million: {
+    prefix: "M",
+    divider: 1000000
+  },
+  Billion: {
+    prefix: "B",
+    divider: 1000000000
+  }
+};
+var aggregationFnMap = {
+  average: "AVG",
+  count: "COUNT",
+  maximum: "MAX",
+  minimum: "MIN",
+  sum: "SUM"
+};
+var advanceDataProps = ["aggregation", "aggregationcolumn", "groupby", "orderby"];
+
+// Chart type utility functions - COMPLETE from Angular
+var isPieChart = exports.isPieChart = function isPieChart(type) {
+  return type === "Pie";
+};
+var isLineChart = exports.isLineChart = function isLineChart(type) {
+  return type === "Line";
+};
+var isBarChart = exports.isBarChart = function isBarChart(type) {
+  return type === "Bar";
+};
+var isDonutChart = exports.isDonutChart = function isDonutChart(type) {
+  return type === "Donut";
+};
+var isBubbleChart = exports.isBubbleChart = function isBubbleChart(type) {
+  return type === "Bubble";
+};
+var isColumnChart = exports.isColumnChart = function isColumnChart(type) {
+  return type === "Column";
+};
+var isAreaChart = exports.isAreaChart = function isAreaChart(type) {
+  return type === "Area";
+};
+var isCumulativeLineChart = exports.isCumulativeLineChart = function isCumulativeLineChart(type) {
+  return type === "Cumulative Line";
+};
+var isPieType = exports.isPieType = function isPieType(type) {
+  return isPieChart(type) || isDonutChart(type);
+};
+var isChartDataJSON = exports.isChartDataJSON = function isChartDataJSON(type) {
+  return (0, _includes["default"])(dataTypeJSON, type) || !(0, _includes["default"])(chartTypes, type);
+};
+var isChartDataArray = exports.isChartDataArray = function isChartDataArray(type) {
+  return (0, _includes["default"])(dataTypeArray, type);
+};
+var isLineTypeChart = exports.isLineTypeChart = function isLineTypeChart(type) {
+  return (0, _includes["default"])(lineTypeCharts, type);
+};
+var isAxisDomainSupported = exports.isAxisDomainSupported = function isAxisDomainSupported(type) {
+  return isColumnChart(type) || isAreaChart(type);
+};
+
+// Enhanced number type checking to match Angular implementation
+var isNumberType = exports.isNumberType = function isNumberType(type) {
+  var numberTypes = ["number", "integer", "float", "double", "long", "short", "byte", "decimal", "bigdecimal", "biginteger", "int", "Number"];
+  return numberTypes.includes(type === null || type === void 0 ? void 0 : type.toLowerCase());
+};
+
+// Helper functions - COMPLETE from Angular
+var isShowLegend = exports.isShowLegend = function isShowLegend(value) {
+  if (value === "false" || value === false) {
+    return false;
+  }
+  if (value === "true" || value === true) {
+    return true;
+  }
+  return value === "hide" ? false : true;
+};
+var triggerFn = exports.triggerFn = function triggerFn(callback) {
+  if (typeof callback === "function") {
+    callback();
+  }
+};
+var getClonedObject = function getClonedObject(obj) {
+  return JSON.parse(JSON.stringify(obj));
+};
+var prettifyLabels = exports.prettifyLabels = function prettifyLabels(label) {
+  if (!label) return "";
+  return label.replace(/^./, function (str) {
+    return str.toUpperCase();
+  }).trim();
+};
+
+// COMPLETE constructSampleData function from Angular
+var constructSampleData = function constructSampleData(dataType, yaxisLength, shape) {
+  var first_series = [];
+  var second_series = [];
+  var third_series = [];
+  var first_series_array = [];
+  var second_series_array = [];
+  var third_series_array = [];
+  var first_series_bubble = [];
+  var second_series_bubble = [];
+  var third_series_bubble = [];
+  var data = [];
+  switch (dataType) {
+    case "jsonFormat":
+      first_series = [{
+        x: "01/01/2001",
+        y: 4000000
+      }, {
+        x: "01/01/2002",
+        y: 1000000
+      }, {
+        x: "01/01/2003",
+        y: 5000000
+      }];
+      second_series = [{
+        x: "01/01/2001",
+        y: 3000000
+      }, {
+        x: "01/01/2002",
+        y: 4000000
+      }, {
+        x: "01/01/2003",
+        y: 7000000
+      }];
+      third_series = [{
+        x: "01/01/2001",
+        y: 2000000
+      }, {
+        x: "01/01/2002",
+        y: 8000000
+      }, {
+        x: "01/01/2003",
+        y: 6000000
+      }];
+      data[0] = {
+        values: first_series,
+        key: SAMPLE_DATA.group1
+      };
+      if (yaxisLength >= 2) {
+        data[1] = {
+          values: second_series,
+          key: SAMPLE_DATA.group2
+        };
+      }
+      if (yaxisLength >= 3) {
+        data[2] = {
+          values: third_series,
+          key: SAMPLE_DATA.group3
+        };
+      }
+      break;
+    case "lineChartFormat":
+      first_series = [{
+        x: 1,
+        y: 4000000
+      }, {
+        x: 2,
+        y: 1000000
+      }, {
+        x: 3,
+        y: 5000000
+      }];
+      second_series = [{
+        x: 1,
+        y: 3000000
+      }, {
+        x: 2,
+        y: 4000000
+      }, {
+        x: 3,
+        y: 7000000
+      }];
+      third_series = [{
+        x: 1,
+        y: 2000000
+      }, {
+        x: 2,
+        y: 8000000
+      }, {
+        x: 3,
+        y: 6000000
+      }];
+      data[0] = {
+        values: first_series,
+        key: SAMPLE_DATA.group1
+      };
+      if (yaxisLength >= 2) {
+        data[1] = {
+          values: second_series,
+          key: SAMPLE_DATA.group2
+        };
+      }
+      if (yaxisLength >= 3) {
+        data[2] = {
+          values: third_series,
+          key: SAMPLE_DATA.group3
+        };
+      }
+      break;
+    case "arrayFormat":
+      first_series_array = [[1, 4000000], [2, 1000000], [3, 5000000]];
+      second_series_array = [[1, 3000000], [2, 4000000], [3, 7000000]];
+      third_series_array = [[1, 2000000], [2, 8000000], [3, 6000000]];
+      data[0] = {
+        values: first_series_array,
+        key: SAMPLE_DATA.group1
+      };
+      if (yaxisLength >= 2) {
+        data[1] = {
+          values: second_series_array,
+          key: SAMPLE_DATA.group2
+        };
+      }
+      if (yaxisLength >= 3) {
+        data[2] = {
+          values: third_series_array,
+          key: SAMPLE_DATA.group3
+        };
+      }
+      break;
+    case "bubbleFormat":
+      shape = shape === "random" ? allShapes[Math.floor(Math.random() * allShapes.length)] : shape;
+      first_series_bubble = [{
+        x: 80.66,
+        y: 33739900,
+        size: 78,
+        shape: shape
+      }, {
+        x: 79.84,
+        y: 81902300,
+        size: 90,
+        shape: shape
+      }, {
+        x: 78.6,
+        y: 5523100,
+        size: 45,
+        shape: shape
+      }];
+      second_series_bubble = [{
+        x: 72.73,
+        y: 79716200,
+        size: 98,
+        shape: shape
+      }, {
+        x: 80.05,
+        y: 61801600,
+        size: 20,
+        shape: shape
+      }, {
+        x: 72.49,
+        y: 73137200,
+        size: 34,
+        shape: shape
+      }];
+      third_series_bubble = [{
+        x: 68.09,
+        y: 33739900,
+        size: 45,
+        shape: shape
+      }, {
+        x: 81.55,
+        y: 7485600,
+        size: 78,
+        shape: shape
+      }, {
+        x: 68.6,
+        y: 141850000,
+        size: 56,
+        shape: shape
+      }];
+      data[0] = {
+        values: first_series_bubble,
+        key: SAMPLE_DATA.group1
+      };
+      if (yaxisLength >= 2) {
+        data[1] = {
+          values: second_series_bubble,
+          key: SAMPLE_DATA.group2
+        };
+      }
+      if (yaxisLength >= 3) {
+        data[2] = {
+          values: third_series_bubble,
+          key: SAMPLE_DATA.group3
+        };
+      }
+      break;
+    case "pieChartFormat":
+      data = [{
+        x: SAMPLE_DATA.group1,
+        y: 1000000
+      }, {
+        x: SAMPLE_DATA.group2,
+        y: 2000000
+      }, {
+        x: SAMPLE_DATA.group3,
+        y: 3000000
+      }, {
+        x: SAMPLE_DATA.group4,
+        y: 4000000
+      }];
+      break;
+  }
+
+  // Ensure every point carries an _dataObj reference like real datasets -----------------
+  if (Array.isArray(data)) {
+    var _data$;
+    if (data.length && (_data$ = data[0]) !== null && _data$ !== void 0 && _data$.values) {
+      // Series-based sample (Column/Line/Area/Bar/Bubble etc.)
+      data.forEach(function (series) {
+        if (Array.isArray(series.values)) {
+          series.values = series.values.map(function (pt) {
+            // Skip array-format points ([x,y]) – they aren't objects
+            if (Array.isArray(pt)) return pt;
+            return _objectSpread(_objectSpread({}, pt), {}, {
+              _dataObj: pt._dataObj || _objectSpread({}, pt)
+            });
+          });
+        }
+      });
+    } else {
+      // Flat array (Pie/Donut sample)
+      data = data.map(function (pt) {
+        return _objectSpread(_objectSpread({}, pt), {}, {
+          _dataObj: pt._dataObj || _objectSpread({}, pt)
+        });
+      });
+    }
+  }
+  return data;
+};
+var getDataType = function getDataType(widgetContext) {
+  var type = widgetContext.type;
+  if (isPieType(type)) {
+    return "pieChartFormat";
+  }
+  if (isBubbleChart(type)) {
+    return "bubbleFormat";
+  }
+  return isChartDataJSON(type) ? "jsonFormat" : "arrayFormat";
+};
+var getSampleData = exports.getSampleData = function getSampleData(widgetContext) {
+  return constructSampleData(getDataType(widgetContext), (0, _split["default"])(widgetContext.yaxisdatakey || "", ",").length, widgetContext.shape);
+};
+
+// Enhanced formatNumber function - Fixed NaN issue (BUG FIX 7)
+var formatNumber = exports.formatNumber = function formatNumber(value, format) {
+  // Handle NaN and invalid values
+  if (!value && value !== 0) return "";
+  if (isNaN(value) || !isFinite(value)) return "";
+  var formattedData;
+  var divider;
+  var prefix;
+  if (format) {
+    try {
+      if (format === "Thousand" || format === "Million" || format === "Billion") {
+        var _tickformats, _tickformats2;
+        divider = ((_tickformats = tickformats[format]) === null || _tickformats === void 0 ? void 0 : _tickformats.divider) || 1;
+        prefix = ((_tickformats2 = tickformats[format]) === null || _tickformats2 === void 0 ? void 0 : _tickformats2.prefix) || "";
+        if (divider > 1) {
+          var result = value / divider;
+          formattedData = "".concat(result.toFixed(2)).concat(prefix);
+        } else {
+          formattedData = value.toString();
+        }
+      } else if (format === "%") {
+        formattedData = "".concat((value * 100).toFixed(2), "%");
+      } else if (format === ".f") {
+        formattedData = value.toFixed(2);
+      } else {
+        formattedData = value.toString();
+      }
+    } catch (e) {
+      formattedData = value.toString();
+    }
+  } else {
+    // Auto formatting when no format option is chosen
+    if (value >= 1000000000) {
+      formattedData = "".concat((value / 1000000000).toFixed(1), "B");
+    } else if (value >= 1000000) {
+      formattedData = "".concat((value / 1000000).toFixed(1), "M");
+    } else if (value >= 1000) {
+      formattedData = "".concat((value / 1000).toFixed(1), "K");
+    } else {
+      formattedData = value.toString();
+    }
+  }
+  return removeTrailingZeros(formattedData);
+};
+
+// Remove trailing zeros function
+var removeTrailingZeros = function removeTrailingZeros(value) {
+  if (!value) {
+    return value;
+  }
+
+  // Remove trailing zeros after decimal point
+  return value.replace(/\.0+([A-Za-z]*)$/, "$1").replace(/\.([1-9]+)0+([A-Za-z]*)$/, ".$1$2");
+};
+
+// COMPLETE formatDate function from Angular
+var formatDate = function formatDate(date, format) {
+  if (!date) return "";
+  try {
+    var momentDate = (0, _momentTimezone["default"])(date);
+    if (!momentDate.isValid()) return "";
+    if (format) {
+      return momentDate.format(format);
+    }
+    return momentDate.format("MM/DD/YYYY");
+  } catch (e) {
+    return "";
+  }
+};
+
+// COMPLETE helper functions from Angular
+var getLodashOrderByFormat = exports.getLodashOrderByFormat = function getLodashOrderByFormat(orderby) {
+  var columns;
+  var orderByColumns = [];
+  var orders = [];
+  (0, _forEach["default"])((0, _split["default"])(orderby, ","), function (col) {
+    columns = (0, _split["default"])(col, ":");
+    orderByColumns.push(columns[0]);
+    orders.push(columns[1]);
+  });
+  return {
+    columns: orderByColumns,
+    orders: orders
+  };
+};
+var getBarSpacingValue = exports.getBarSpacingValue = function getBarSpacingValue(value, prop) {
+  if (prop === "value") {
+    return barSpacingMap[value];
+  }
+  if (prop === "key") {
+    return barSpacingMapInvert[value];
+  }
+};
+var getRadiusValue = exports.getRadiusValue = function getRadiusValue(value, prop) {
+  if (prop === "value") {
+    return donutRatioMap[value];
+  }
+  if (prop === "key") {
+    return donutRatioMapInvert[value];
+  }
+};
+var getLabelValues = function getLabelValues(showlabels, showlabelsoutside) {
+  var labelsConfig = {};
+  switch (showlabels) {
+    case "hide":
+      labelsConfig.showlabels = false;
+      break;
+    case "inside":
+      labelsConfig.showlabels = true;
+      labelsConfig.showlabelsoutside = false;
+      break;
+    case "outside":
+      labelsConfig.showlabels = true;
+      labelsConfig.showlabelsoutside = true;
+      break;
+  }
+  return labelsConfig;
+};
+var isAxisDomainValid = function isAxisDomainValid(widgetContext, axis) {
+  if (widgetContext[axis + "domain"] === "Min" && isAxisDomainSupported(widgetContext.type)) {
+    return true;
+  }
+  return false;
+};
+
+// Enhanced convertToRechartsFormat function - FIXED to handle proper data conversion
+var convertToRechartsFormat = exports.convertToRechartsFormat = function convertToRechartsFormat(data, type) {
+  var _data$2;
+  if (!data || data.length === 0) return [];
+  if (isPieType(type)) {
+    return data.map(function (item) {
+      return {
+        name: item.x,
+        value: item.y,
+        _dataObj: item._dataObj
+      };
+    });
+  }
+
+  // For other chart types
+  if ((0, _isArray["default"])((_data$2 = data[0]) === null || _data$2 === void 0 ? void 0 : _data$2.values)) {
+    var result = [];
+    var xValuesSet = new Set();
+
+    // Collect all unique x values
+    data.forEach(function (series) {
+      if (series.values) {
+        series.values.forEach(function (point) {
+          var xValue = isChartDataJSON(type) ? point.x : point[0];
+          xValuesSet.add(xValue);
+        });
+      }
+    });
+
+    // Sort x values
+    var sortedXValues = Array.from(xValuesSet).sort(function (a, b) {
+      // Handle different data types for sorting
+      if (typeof a === "number" && typeof b === "number") {
+        return a - b;
+      }
+      return String(a).localeCompare(String(b));
+    });
+
+    // Create data points for each x value
+    sortedXValues.forEach(function (x) {
+      var resultPoint = {
+        x: x
+      };
+      data.forEach(function (series) {
+        if (series.values) {
+          var point = series.values.find(function (p) {
+            var pointX = isChartDataJSON(type) ? p.x : p[0];
+            return pointX === x;
+          });
+          if (point) {
+            var key = prettifyLabels(series.key);
+            var yValue = isChartDataJSON(type) ? point.y : point[1];
+
+            // Ensure we have a valid number
+            resultPoint[key] = typeof yValue === "number" ? yValue : parseFloat(yValue) || 0;
+            resultPoint["".concat(key, "_dataObj")] = point._dataObj;
+            if (isBubbleChart(type) && point.size) {
+              resultPoint["".concat(key, "_size")] = point.size;
+            }
+          } else {
+            // Fill missing values with 0 for consistency
+            var _key = prettifyLabels(series.key);
+            resultPoint[_key] = 0;
+          }
+        }
+      });
+      result.push(resultPoint);
+    });
+    return result;
+  }
+
+  // If data is already in the correct format
+  return data;
+};
+
+// Additional utility functions to match Angular functionality
+var getDateFormatedData = exports.getDateFormatedData = function getDateFormatedData(dateFormat, d) {
+  if (!d) return "";
+  try {
+    var date = (0, _momentTimezone["default"])(d);
+    if (!date.isValid()) return d;
+
+    // Handle different date format patterns
+    var format = dateFormat || "MM/DD/YYYY";
+
+    // Convert D3 format patterns to moment.js patterns
+    if (format === "%x") format = "MM/DD/YYYY";
+    if (format === "%c") format = "ddd MMM DD HH:mm:ss YYYY";
+    return date.format(format);
+  } catch (e) {
+    return d;
+  }
+};
+var getNumberFormatedData = exports.getNumberFormatedData = function getNumberFormatedData(numberFormat, d) {
+  return formatNumber(d, numberFormat);
+};
+
+// Get date list for sample data
+var getDateList = exports.getDateList = function getDateList() {
+  return dateList;
+};
+
+// Utility to check if value is empty object
+var isEmptyObject = exports.isEmptyObject = function isEmptyObject(obj) {
+  return obj && (0, _typeof2["default"])(obj) === "object" && Object.keys(obj).length === 0;
+};
+var getLegendPopupStyle = exports.getLegendPopupStyle = function getLegendPopupStyle(position) {
+  // base styles for all positions
+  var baseStyle = {
+    position: "absolute",
+    zIndex: 10,
+    borderRadius: "4px",
+    padding: "8px"
+  };
+
+  // position-specific styles
+  switch (position) {
+    case "top":
+      return _objectSpread(_objectSpread({}, baseStyle), {}, {
+        right: "3%",
+        bottom: "100%",
+        width: "80%",
+        display: "flex",
+        flexWrap: "wrap",
+        gap: "8px",
+        justifyContent: "flex-end"
+      });
+    case "bottom":
+      return _objectSpread(_objectSpread({}, baseStyle), {}, {
+        right: "3%",
+        bottom: "0%",
+        width: "80%",
+        display: "flex",
+        flexWrap: "wrap",
+        gap: "8px",
+        justifyContent: "flex-end"
+      });
+    case "right":
+      return _objectSpread(_objectSpread({}, baseStyle), {}, {
+        right: "3%",
+        top: "50%",
+        transform: "translateY(-50%)",
+        maxHeight: "100%",
+        overflowY: "auto",
+        display: "flex",
+        flexDirection: "column",
+        gap: "8px",
+        maxWidth: "200px" // limit the width of right legend
+      });
+    case "hide":
+    default:
+      return {
+        display: "none"
+      };
+  }
+};
+var truncateText = exports.truncateText = function truncateText(text) {
+  var maxLength = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 30;
+  if (text.length <= maxLength) return text;
+  return text.substring(0, maxLength) + "...";
+};