@semcore/d3-chart 16.0.0-prerelease.7 → 16.0.0

package/lib/esm/Venn.mjs

@@ -0,0 +1,233 @@
+import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+import _extends from "@babel/runtime/helpers/esm/extends";
+import _classCallCheck from "@babel/runtime/helpers/esm/classCallCheck";
+import _createClass from "@babel/runtime/helpers/esm/createClass";
+import _assertThisInitialized from "@babel/runtime/helpers/esm/assertThisInitialized";
+import _inherits from "@babel/runtime/helpers/esm/inherits";
+import _createSuper from "@babel/runtime/helpers/esm/createSuper";
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+import { sstyled, Component, assignProps } from "@semcore/core";
+import React from "react";
+import { scaleSolution, normalizeSolution, venn, intersectionAreaPath } from "@upsetjs/venn.js";
+import canUseDOM from "@semcore/core/lib/utils/canUseDOM";
+import { FadeInOut } from "@semcore/animation";
+import createElement from "./createElement.mjs";
+import { getChartDefaultColorName } from "./utils.mjs";
+import Tooltip from "./Tooltip.mjs";
+import { PatternFill } from "./Pattern.mjs";
+import uniqueIDEnhancement from "@semcore/core/lib/utils/uniqueID";
+/*!__reshadow-styles__:"./style/venn.shadow.css"*/
+var style = (
+  /*__reshadow_css_start__*/
+  (sstyled.insert(
+    /*__inner_css_start__*/
+    ".___SCircle_wmt8p_gg_,.___SIntersection_wmt8p_gg_{stroke:var(--intergalactic-chart-grid-border, #ffffff);stroke-width:2px}.___SCircle_wmt8p_gg_{fill:var(--intergalactic-chart-palette-order-2, #59ddaa);fill-opacity:.5;transition-property:cx,cy;transition-duration:var(--duration_wmt8p);transition-timing-function:ease-in-out}@media (hover:hover){.___SCircle_wmt8p_gg_:hover{fill-opacity:.7}}.___SCircle_wmt8p_gg_.__color_wmt8p_gg_{fill:var(--color_wmt8p)}.___SCircle_wmt8p_gg_.__pattern_wmt8p_gg_.__color_wmt8p_gg_{fill:var(--pattern_wmt8p);fill-opacity:.7;stroke:var(--color_wmt8p);stroke-width:1px}@media (hover:hover){.___SCircle_wmt8p_gg_.__pattern_wmt8p_gg_.__color_wmt8p_gg_:hover{fill-opacity:.85}}.___SCircle_wmt8p_gg_.__transparent_wmt8p_gg_{opacity:.3}.___SIntersection_wmt8p_gg_{fill-opacity:0}@media (hover:hover){.___SIntersection_wmt8p_gg_:hover{fill-opacity:.1}}.___SIntersection_wmt8p_gg_.__transparent_wmt8p_gg_{opacity:.3}",
+    /*__inner_css_end__*/
+    "wmt8p_gg_"
+  ), /*__reshadow_css_end__*/
+  {
+    "__SCircle": "___SCircle_wmt8p_gg_",
+    "_color": "__color_wmt8p_gg_",
+    "--color": "--color_wmt8p",
+    "_transparent": "__transparent_wmt8p_gg_",
+    "__SIntersection": "___SIntersection_wmt8p_gg_",
+    "--duration": "--duration_wmt8p",
+    "_pattern": "__pattern_wmt8p_gg_",
+    "--pattern": "--pattern_wmt8p"
+  })
+);
+var VennRoot = /* @__PURE__ */ function(_Component) {
+  _inherits(VennRoot2, _Component);
+  var _super = _createSuper(VennRoot2);
+  function VennRoot2() {
+    var _this;
+    _classCallCheck(this, VennRoot2);
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+    _this = _super.call.apply(_super, [this].concat(args));
+    _defineProperty(_assertThisInitialized(_this), "virtualElement", canUseDOM() ? document.createElement("div") : {});
+    _defineProperty(_assertThisInitialized(_this), "bindHandlerTooltip", function(visible, props, tooltipProps) {
+      return function(_ref5) {
+        var clientX = _ref5.clientX, clientY = _ref5.clientY;
+        var eventEmitter = _this.asProps.eventEmitter;
+        eventEmitter.emit("setTooltipPosition", clientX, clientY);
+        eventEmitter.emit("setTooltipRenderingProps", props, tooltipProps);
+        eventEmitter.emit("setTooltipVisible", visible);
+      };
+    });
+    _defineProperty(_assertThisInitialized(_this), "renderElement", /* @__PURE__ */ React.forwardRef(function(props, ref) {
+      return /* @__PURE__ */ React.createElement(FadeInOut, _extends({
+        "aria-hidden": true,
+        ref,
+        tag: "g",
+        visible: true
+      }, props));
+    }));
+    return _this;
+  }
+  _createClass(VennRoot2, [{
+    key: "generateGetBoundingClientRect",
+    value: function generateGetBoundingClientRect() {
+      var x = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : 0;
+      var y = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : 0;
+      return function() {
+        return {
+          width: 0,
+          height: 0,
+          top: y,
+          right: x,
+          bottom: y,
+          left: x
+        };
+      };
+    }
+  }, {
+    key: "getVennData",
+    value: function getVennData() {
+      var _this$asProps = this.asProps, data = _this$asProps.data, orientation = _this$asProps.orientation, orientationOrder2 = _this$asProps.orientationOrder, size = _this$asProps.size;
+      var _size = _slicedToArray(size, 2), width = _size[0], height = _size[1];
+      var vennData = Object.entries(data).map(function(_ref6) {
+        var _ref7 = _slicedToArray(_ref6, 2), dataKey = _ref7[0], size2 = _ref7[1];
+        return {
+          sets: dataKey.split("/"),
+          size: size2
+        };
+      });
+      return scaleSolution(normalizeSolution(venn(vennData), orientation, orientationOrder2), width, height, 10);
+    }
+  }, {
+    key: "getCircleProps",
+    value: function getCircleProps(props, index) {
+      var colorBackwardCapabilityOffset = 1;
+      var color = props.color || getChartDefaultColorName(index + colorBackwardCapabilityOffset);
+      var tooltipProps = {
+        dataKey: props.dataKey,
+        name: props.name,
+        color,
+        patterns: this.asProps.patterns
+      };
+      return {
+        duration: this.asProps.duration,
+        data: this.vennData[props.dataKey],
+        originalData: this.asProps.data[props.dataKey],
+        onMouseMove: this.bindHandlerTooltip(true, props, tooltipProps),
+        onMouseLeave: this.bindHandlerTooltip(false, props, tooltipProps),
+        transparent: this.asProps.transparent,
+        resolveColor: this.asProps.resolveColor,
+        color,
+        uid: "".concat(this.asProps.uid, "-").concat(index),
+        patterns: this.asProps.patterns,
+        minRadius: this.asProps.minRadius
+      };
+    }
+  }, {
+    key: "getIntersectionProps",
+    value: function getIntersectionProps(props) {
+      var _this$asProps2 = this.asProps, duration = _this$asProps2.duration, transparent = _this$asProps2.transparent;
+      var dataKeys = props.dataKey.split("/");
+      var tooltipProps = {
+        dataKey: props.dataKey,
+        name: props.name,
+        color: props.color,
+        duration: props.duration,
+        transparent: props.transparent
+      };
+      return {
+        duration,
+        delay: duration,
+        data: Object.values(this.vennData).filter(function(d) {
+          return dataKeys.includes(d.setid);
+        }),
+        originalData: this.asProps.data[props.dataKey],
+        onMouseMove: this.bindHandlerTooltip(true, props, tooltipProps),
+        onMouseLeave: this.bindHandlerTooltip(false, props, tooltipProps),
+        transparent,
+        resolveColor: this.asProps.resolveColor
+      };
+    }
+  }, {
+    key: "render",
+    value: function render() {
+      var Element = this.Element;
+      this.asProps.dataHintsHandler.establishDataType("values-set");
+      this.vennData = this.getVennData();
+      return /* @__PURE__ */ React.createElement(Element, {
+        "aria-hidden": true,
+        render: this.renderElement,
+        childrenPosition: "inside",
+        vennData: this.vennData
+      });
+    }
+  }]);
+  return VennRoot2;
+}(Component);
+_defineProperty(VennRoot, "displayName", "Venn");
+_defineProperty(VennRoot, "style", style);
+_defineProperty(VennRoot, "defaultProps", {
+  orientation: Math.PI / 2,
+  orientationOrder: function orientationOrder(c1, c2) {
+    return c2.radius - c1.radius;
+  },
+  duration: 500,
+  minRadius: 6
+});
+_defineProperty(VennRoot, "enhance", [uniqueIDEnhancement()]);
+function Circle(_ref8) {
+  var _ref2;
+  var SCircle = _ref8.Element, styles = _ref8.styles, color = _ref8.color, resolveColor = _ref8.resolveColor, data = _ref8.data, duration = _ref8.duration, name = _ref8.name, dataKey = _ref8.dataKey, dataHintsHandler = _ref8.dataHintsHandler, transparent = _ref8.transparent, uid = _ref8.uid, patterns = _ref8.patterns, minRadius = _ref8.minRadius;
+  dataHintsHandler.describeValueEntity(dataKey, name);
+  var radius = data.radius < minRadius ? minRadius : data.radius;
+  if (data.radius === 0) return null;
+  return /* @__PURE__ */ React.createElement(React.Fragment, null, (_ref2 = sstyled(styles), /* @__PURE__ */ React.createElement(SCircle, _ref2.cn("SCircle", {
+    "aria-hidden": true,
+    "render": "circle",
+    "color": resolveColor(color),
+    "pattern": patterns ? "url(#".concat(uid, "-pattern)") : void 0,
+    "cx": data.x,
+    "cy": data.y,
+    "r": radius,
+    "transparent": transparent,
+    "use:duration": "".concat(duration, "ms")
+  }))), patterns && /* @__PURE__ */ React.createElement(PatternFill, _ref2.cn("PatternFill", {
+    "id": "".concat(uid, "-pattern"),
+    "patternKey": color,
+    "color": resolveColor(color),
+    "patterns": patterns
+  })));
+}
+function Intersection(props) {
+  var _ref3;
+  var SIntersection = props.Element, styles = props.styles, data = props.data, name = props.name, dataKey = props.dataKey, dataHintsHandler = props.dataHintsHandler, transparent = props.transparent;
+  dataHintsHandler.describeValueEntity(dataKey, name);
+  var renderIntersection = React.useCallback(/* @__PURE__ */ React.forwardRef(function(props2, ref) {
+    return /* @__PURE__ */ React.createElement(FadeInOut, _extends({
+      "aria-hidden": true,
+      ref,
+      tag: "path",
+      visible: true
+    }, props2));
+  }), [props]);
+  return _ref3 = sstyled(styles), /* @__PURE__ */ React.createElement(SIntersection, _ref3.cn("SIntersection", {
+    "aria-hidden": true,
+    "render": renderIntersection,
+    "d": intersectionAreaPath(data),
+    "transparent": transparent
+  }));
+}
+var VennTooltip = function VennTooltip2(props) {
+  var _ref = arguments[0], _ref4;
+  var SVennTooltip = Tooltip;
+  return _ref4 = sstyled(props.styles), /* @__PURE__ */ React.createElement(SVennTooltip, _ref4.cn("SVennTooltip", _objectSpread({}, assignProps({
+    "excludeAnchorProps": true
+  }, _ref))));
+};
+var Venn = createElement(VennRoot, {
+  Circle,
+  Intersection,
+  Tooltip: [VennTooltip, Tooltip._______childrenComponents]
+});
+export {
+  Venn as default
+};

package/lib/esm/a11y/DataAccessibilityTable.mjs

@@ -0,0 +1,100 @@
+import _typeof from "@babel/runtime/helpers/esm/typeof";
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+import _createForOfIteratorHelper from "@babel/runtime/helpers/esm/createForOfIteratorHelper";
+import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
+import React from "react";
+import { defaultValueFormatter } from "./serialize.mjs";
+var DataAccessibilityTable = function DataAccessibilityTable2(_ref) {
+  var id = _ref.id, dataTableRef = _ref.dataTableRef, data = _ref.data, hints = _ref.hints, config = _ref.config, intl = _ref.intl;
+  var keys = React.useMemo(function() {
+    var _fromHints, _fromHints2, _fromHints3, _fromHints4, _fromHints5;
+    var fromHints = [];
+    (_fromHints = fromHints).push.apply(_fromHints, _toConsumableArray(hints.fields.verticalAxes));
+    (_fromHints2 = fromHints).push.apply(_fromHints2, _toConsumableArray(hints.fields.horizontalAxes));
+    (_fromHints3 = fromHints).push.apply(_fromHints3, _toConsumableArray(hints.fields.valueAxes));
+    (_fromHints4 = fromHints).push.apply(_fromHints4, _toConsumableArray(config.additionalFields));
+    (_fromHints5 = fromHints).push.apply(_fromHints5, _toConsumableArray(Object.keys(hints.fields.values)));
+    fromHints = _toConsumableArray(new Set(fromHints)).filter(function(key) {
+      return key in data[0];
+    });
+    if (fromHints.length === 0) {
+      data.forEach(function(row) {
+        var _fromHints6;
+        return (_fromHints6 = fromHints).push.apply(_fromHints6, _toConsumableArray(Object.keys(row)));
+      });
+    }
+    return _toConsumableArray(new Set(fromHints));
+  }, [data, hints]);
+  var duplicatedBaseKeys = React.useMemo(function() {
+    var baseKeys = keys.filter(function(key2) {
+      return !hints.titles.valuesAxes[key2];
+    }).map(function(key2) {
+      if (hints.fields.verticalAxes.has(key2) && hints.axesTitle.vertical) return [key2, hints.axesTitle.vertical];
+      if (hints.fields.horizontalAxes.has(key2) && hints.axesTitle.horizontal) return [key2, hints.axesTitle.horizontal];
+    }).filter(function(entry) {
+      return entry !== void 0;
+    }).map(function(entry) {
+      return entry;
+    });
+    var doublicated = {};
+    var handled = {};
+    var _iterator = _createForOfIteratorHelper(baseKeys), _step;
+    try {
+      for (_iterator.s(); !(_step = _iterator.n()).done; ) {
+        var _step$value = _slicedToArray(_step.value, 2), key = _step$value[0], label = _step$value[1];
+        if (handled[label]) {
+          doublicated[key] = true;
+          doublicated[handled[label]] = true;
+        }
+        handled[label] = key;
+      }
+    } catch (err) {
+      _iterator.e(err);
+    } finally {
+      _iterator.f();
+    }
+    return doublicated;
+  }, [keys, hints]);
+  var renderTitle = React.useCallback(function(dataKey) {
+    var _config$titlesFormatt;
+    var formatted = (_config$titlesFormatt = config.titlesFormatter) === null || _config$titlesFormatt === void 0 ? void 0 : _config$titlesFormatt.call(config, dataKey);
+    if (formatted !== void 0) return formatted;
+    if (hints.titles.valuesAxes[dataKey]) return hints.titles.valuesAxes[dataKey];
+    if (!duplicatedBaseKeys[dataKey]) {
+      if (hints.fields.verticalAxes.has(dataKey) && hints.axesTitle.vertical) return hints.axesTitle.vertical;
+      if (hints.fields.horizontalAxes.has(dataKey) && hints.axesTitle.horizontal) return hints.axesTitle.horizontal;
+    }
+    return dataKey;
+  }, [data, hints, duplicatedBaseKeys, config]);
+  var formatValue = React.useCallback(function(value, row) {
+    var _config$valuesFormatt, _config$valuesFormatt2;
+    return (_config$valuesFormatt = (_config$valuesFormatt2 = config.valuesFormatter) === null || _config$valuesFormatt2 === void 0 ? void 0 : _config$valuesFormatt2.call(config, value, row)) !== null && _config$valuesFormatt !== void 0 ? _config$valuesFormatt : defaultValueFormatter(intl, value);
+  }, [intl, config]);
+  return /* @__PURE__ */ React.createElement("table", {
+    id: "".concat(id, "-data-table"),
+    tabIndex: 0,
+    ref: dataTableRef
+  }, /* @__PURE__ */ React.createElement("thead", null, /* @__PURE__ */ React.createElement("tr", null, keys.map(function(key, index) {
+    return /* @__PURE__ */ React.createElement("th", {
+      key: "".concat(key, "-").concat(index)
+    }, renderTitle(key));
+  }))), /* @__PURE__ */ React.createElement("tbody", null, data.map(function(row, index) {
+    var key = "".concat(Object.values(row).filter(function(item) {
+      return _typeof(item) !== "symbol";
+    }).join("-"), "-").concat(index);
+    var cells = keys.map(function(key2) {
+      return _typeof(row[key2]) !== "symbol" ? [key2, row[key2]] : [key2, ""];
+    });
+    return /* @__PURE__ */ React.createElement("tr", {
+      key
+    }, cells.map(function(_ref2, index2) {
+      var _ref3 = _slicedToArray(_ref2, 2), key2 = _ref3[0], value = _ref3[1];
+      return /* @__PURE__ */ React.createElement("td", {
+        key: "".concat(key2, "-").concat(index2)
+      }, formatValue(value, keys[index2]));
+    }));
+  })));
+};
+export {
+  DataAccessibilityTable
+};

package/lib/esm/a11y/PlotA11yModule.mjs

@@ -0,0 +1,116 @@
+import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
+import _extends from "@babel/runtime/helpers/esm/extends";
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+import { sstyled, assignProps } from "@semcore/core";
+import React from "react";
+import { normalizeLocale } from "./locale.mjs";
+import { localizedMessages } from "./translations/module/__intergalactic-dynamic-locales.mjs";
+import { Context, useI18n } from "@semcore/core/lib/utils/enhances/WithI18n";
+import { Box } from "@semcore/flex-box";
+/*!__reshadow-styles__:"../style/plotA11yModule.shadow.css"*/
+var styles = (
+  /*__reshadow_css_start__*/
+  (sstyled.insert(
+    /*__inner_css_start__*/
+    ".___SPlotA11yModule_i0svk_gg_{-webkit-user-select:none;-moz-user-select:none;user-select:none;pointer-events:none;opacity:0}.___SPlotA11yModule_i0svk_gg_:focus{-webkit-user-select:all;-moz-user-select:all;user-select:all;pointer-events:all;opacity:1}",
+    /*__inner_css_end__*/
+    "i0svk_gg_"
+  ), /*__reshadow_css_end__*/
+  {
+    "__SPlotA11yModule": "___SPlotA11yModule_i0svk_gg_"
+  })
+);
+var globalWasFocused = false;
+var globalNavWithKeyboard = false;
+var PlotA11yModule = function PlotA11yModule2(props) {
+  var _ref = arguments[0], _ref5;
+  var SPlotA11yModule = Box;
+  var _React$useState = React.useState(globalWasFocused), _React$useState2 = _slicedToArray(_React$useState, 2), wasFocused = _React$useState2[0], setWasFocused = _React$useState2[1];
+  var _React$useState3 = React.useState(globalNavWithKeyboard), _React$useState4 = _slicedToArray(_React$useState3, 2), navWithKeyboard = _React$useState4[0], setNavWithKeyboard = _React$useState4[1];
+  var _React$useState5 = React.useState(null), _React$useState6 = _slicedToArray(_React$useState5, 2), plotA11yView = _React$useState6[0], setPlotA11yView = _React$useState6[1];
+  var hadnleHiddenElementsFocus = React.useCallback(function() {
+    setWasFocused(true);
+    setNavWithKeyboard(true);
+  }, []);
+  var _React$useState7 = React.useState(false), _React$useState8 = _slicedToArray(_React$useState7, 2), loading = _React$useState8[0], setLoading = _React$useState8[1];
+  var _React$useState9 = React.useState(null), _React$useState10 = _slicedToArray(_React$useState9, 2), error = _React$useState10[0], setError = _React$useState10[1];
+  var contextLocale = React.useContext(Context);
+  var locale = React.useMemo(function() {
+    var _props$locale;
+    return normalizeLocale((_props$locale = props.locale) !== null && _props$locale !== void 0 ? _props$locale : contextLocale, localizedMessages);
+  }, [props.locale]);
+  var t = useI18n(localizedMessages, locale);
+  React.useEffect(function() {
+    var _props$plotRef$curren;
+    if (wasFocused) return;
+    var focusListener = function focusListener2() {
+      globalWasFocused = true;
+      setWasFocused(true);
+    };
+    (_props$plotRef$curren = props.plotRef.current) === null || _props$plotRef$curren === void 0 ? void 0 : _props$plotRef$curren.addEventListener("focus", focusListener);
+    return function() {
+      var _props$plotRef$curren2;
+      return (_props$plotRef$curren2 = props.plotRef.current) === null || _props$plotRef$curren2 === void 0 ? void 0 : _props$plotRef$curren2.removeEventListener("focus", focusListener);
+    };
+  }, [wasFocused, props.plotRef]);
+  React.useEffect(function() {
+    var _document$body;
+    if (navWithKeyboard) return;
+    var keyboardListener = function keyboardListener2(event) {
+      var navigationKeys = ["Tab", "ArrowUp", "ArrowLeft", "ArrowDown", "ArrowRight", "ArrowUp", "ArrowLeft"];
+      if ("key" in event && navigationKeys.includes(event.key)) {
+        setNavWithKeyboard(true);
+        globalNavWithKeyboard = true;
+      }
+    };
+    (_document$body = document.body) === null || _document$body === void 0 ? void 0 : _document$body.addEventListener("keydown", keyboardListener);
+    return function() {
+      var _document$body2;
+      return (_document$body2 = document.body) === null || _document$body2 === void 0 ? void 0 : _document$body2.removeEventListener("keydown", keyboardListener);
+    };
+  }, [navWithKeyboard]);
+  var shouldDisplayView = wasFocused && navWithKeyboard;
+  React.useEffect(function() {
+    if (!shouldDisplayView) return;
+    if (plotA11yView) return;
+    if (loading) return;
+    setLoading(true);
+    import("./PlotA11yView.mjs").then(function(_ref6) {
+      var PlotA11yView = _ref6.PlotA11yView;
+      setPlotA11yView({
+        Component: PlotA11yView
+      });
+      setLoading(false);
+      setError(null);
+    })["catch"](function(error2) {
+      console.error(error2);
+      setError(error2);
+    });
+  }, [plotA11yView, shouldDisplayView, loading, setLoading]);
+  if (plotA11yView) {
+    return sstyled(styles), /* @__PURE__ */ React.createElement(plotA11yView.Component, _extends({}, props, {
+      locale
+    }));
+  }
+  if (error) {
+    var _ref3;
+    return _ref3 = sstyled(styles), /* @__PURE__ */ React.createElement(SPlotA11yModule, _ref3.cn("SPlotA11yModule", _objectSpread({}, assignProps({
+      "tabIndex": 0,
+      "aria-live": "assertive"
+    }, _ref))), t("failed"));
+  }
+  if (loading) {
+    var _ref4;
+    return _ref4 = sstyled(styles), /* @__PURE__ */ React.createElement(SPlotA11yModule, _ref4.cn("SPlotA11yModule", _objectSpread({}, assignProps({
+      "tabIndex": 0,
+      "aria-live": "polite"
+    }, _ref))), t("loading"));
+  }
+  return _ref5 = sstyled(styles), /* @__PURE__ */ React.createElement(SPlotA11yModule, _ref5.cn("SPlotA11yModule", _objectSpread({}, assignProps({
+    "tabIndex": 0,
+    "onFocus": hadnleHiddenElementsFocus
+  }, _ref))), t("disabled"));
+};
+export {
+  PlotA11yModule
+};

package/lib/esm/a11y/PlotA11yView.mjs

@@ -0,0 +1,145 @@
+import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+import { sstyled, assignProps } from "@semcore/core";
+import React from "react";
+import { heavyFindNextFocusableElement } from "./focus.mjs";
+import { makeDataSummarizationConfig } from "./hints.mjs";
+import { getIntl } from "./intl.mjs";
+import { summarize } from "./summarize.mjs";
+import { Box } from "@semcore/flex-box";
+import { useAsyncI18nMessages } from "@semcore/core/lib/utils/enhances/i18nEnhance";
+import { localizedMessages } from "./translations/view/__intergalactic-dynamic-locales.mjs";
+import { DataAccessibilityTable } from "./DataAccessibilityTable.mjs";
+/*!__reshadow-styles__:"../style/plotA11yView.shadow.css"*/
+var styles = (
+  /*__reshadow_css_start__*/
+  (sstyled.insert(
+    /*__inner_css_start__*/
+    ".___SPlotA11yView_1anfm_gg_{-webkit-user-select:none;-moz-user-select:none;user-select:none;pointer-events:none;opacity:0;background-color:var(--intergalactic-bg-primary-neutral, #ffffff);color:var(--intergalactic-text-primary, #191b23);border:3px solid var(--intergalactic-border-primary, #c4c7cf);font-size:var(--intergalactic-fs-50, 10px);padding:2px;width:200px;height:200px;max-width:80%;max-height:80%;overflow:auto}.___SPlotA11yView_1anfm_gg_:focus,.___SPlotA11yView_1anfm_gg_:focus-within{-webkit-user-select:all;-moz-user-select:all;user-select:all;pointer-events:all;opacity:1;z-index:var(--intergalactic-z-index-overlay, 500);position:relative;display:block}.___SPlotA11yView_1anfm_gg_ a{cursor:pointer;-webkit-text-decoration:underline;text-decoration:underline;margin-bottom:var(--intergalactic-spacing-2x, 8px);display:block}.___SPlotA11yView_1anfm_gg_ table,.___SPlotA11yView_1anfm_gg_ td,.___SPlotA11yView_1anfm_gg_ th{border:1px solid var(--intergalactic-border-primary, #c4c7cf)}",
+    /*__inner_css_end__*/
+    "1anfm_gg_"
+  ), /*__reshadow_css_end__*/
+  {
+    "__SPlotA11yView": "___SPlotA11yView_1anfm_gg_"
+  })
+);
+var PlotA11yView = function PlotA11yView2(_ref3) {
+  var _ref = arguments[0], _ref2;
+  var id = _ref3.id, providedData = _ref3.data, hints = _ref3.hints, plotLabel = _ref3.plotLabel, plotRef = _ref3.plotRef, providedConfig = _ref3.config, locale = _ref3.locale;
+  var SPlotA11yView = Box;
+  var translations = useAsyncI18nMessages(localizedMessages, locale);
+  var intl = React.useMemo(function() {
+    return getIntl(locale, translations, localizedMessages);
+  }, [locale, translations, localizedMessages]);
+  var config = React.useMemo(function() {
+    return makeDataSummarizationConfig(providedConfig);
+  }, [providedConfig]);
+  var data = React.useMemo(function() {
+    return Array.isArray(providedData) ? providedData : [providedData];
+  }, [providedData]);
+  var _React$useState = React.useState(null), _React$useState2 = _slicedToArray(_React$useState, 2), summary = _React$useState2[0], setSummary = _React$useState2[1];
+  var _React$useState3 = React.useState(true), _React$useState4 = _slicedToArray(_React$useState3, 2), generatingSummary = _React$useState4[0], setGeneratingSummary = _React$useState4[1];
+  React.useEffect(function() {
+    if (config.disable) {
+      setSummary("");
+      setGeneratingSummary(false);
+      return;
+    }
+    if (config.override) {
+      setSummary(config.override);
+      setGeneratingSummary(false);
+      return;
+    }
+    setTimeout(function() {
+      setSummary(summarize(providedData, hints, config, locale, translations, localizedMessages));
+      setGeneratingSummary(false);
+    }, 0);
+  }, [providedData, hints, config, locale, translations, localizedMessages]);
+  var handleClose = React.useCallback(function() {
+    var _plotRef$current;
+    (_plotRef$current = plotRef.current) === null || _plotRef$current === void 0 ? void 0 : _plotRef$current.focus();
+  }, []);
+  var handleSkip = React.useCallback(function(event) {
+    var _heavyFindNextFocusab;
+    event.preventDefault();
+    if (!plotRef.current) return;
+    (_heavyFindNextFocusab = heavyFindNextFocusableElement(plotRef.current)) === null || _heavyFindNextFocusab === void 0 ? void 0 : _heavyFindNextFocusab.focus();
+  }, []);
+  var handleSkipKeyboard = React.useCallback(function(event) {
+    if (!(event.key === "Enter" || event.key === " ")) return;
+    handleSkip(event);
+  }, [handleSkip]);
+  var handleGoToTable = React.useCallback(function(event) {
+    var _dataTableRef$current;
+    event.preventDefault();
+    (_dataTableRef$current = dataTableRef.current) === null || _dataTableRef$current === void 0 ? void 0 : _dataTableRef$current.focus();
+  }, []);
+  var handleGoToTableKeyboard = React.useCallback(function(event) {
+    if (!(event.key === "Enter" || event.key === " ")) return;
+    handleGoToTable(event);
+  }, [handleGoToTable]);
+  var texts = React.useMemo(function() {
+    return {
+      label: intl.formatMessage({
+        id: "view-label"
+      }, {
+        plotLabel: plotLabel !== null && plotLabel !== void 0 ? plotLabel : intl.formatMessage({
+          id: "view-default-plot-label"
+        })
+      }),
+      close: intl.formatMessage({
+        id: "view-close"
+      }),
+      skipPlot: intl.formatMessage({
+        id: "view-skip-plot"
+      }),
+      goToTable: intl.formatMessage({
+        id: "view-go-to-table"
+      }),
+      summary: intl.formatMessage({
+        id: "view-data-summary"
+      }),
+      summaryPlaceholder: intl.formatMessage({
+        id: "view-summary-placeholder"
+      }),
+      table: intl.formatMessage({
+        id: "view-table"
+      })
+    };
+  }, [intl, plotLabel]);
+  var dataTableRef = React.useRef(null);
+  return _ref2 = sstyled(styles), /* @__PURE__ */ React.createElement(SPlotA11yView, _ref2.cn("SPlotA11yView", _objectSpread({}, assignProps({
+    "tabIndex": 0,
+    "aria-label": texts.label,
+    "role": "dialog",
+    "__excludeProps": ["data"]
+  }, _ref))), /* @__PURE__ */ React.createElement("button", _ref2.cn("button", {
+    "type": "button",
+    "onClick": handleClose
+  }), texts.close), /* @__PURE__ */ React.createElement("a", _ref2.cn("a", {
+    "href": "#",
+    "onKeyDown": handleSkipKeyboard,
+    "onClick": handleSkip
+  }), texts.skipPlot), /* @__PURE__ */ React.createElement("a", _ref2.cn("a", {
+    "href": "#".concat(id, "-data-table"),
+    "onKeyDown": handleGoToTableKeyboard,
+    "onClick": handleGoToTable
+  }), texts.goToTable), /* @__PURE__ */ React.createElement("strong", _ref2.cn("strong", {}), /* @__PURE__ */ React.createElement("label", _ref2.cn("label", {
+    "htmlFor": "".concat(id, "-data-summary")
+  }), texts.summary)), /* @__PURE__ */ React.createElement("div", _ref2.cn("div", {
+    "id": "".concat(id, "-data-summary"),
+    "aria-busy": generatingSummary
+  }), generatingSummary ? texts.summaryPlaceholder : summary), /* @__PURE__ */ React.createElement("strong", _ref2.cn("strong", {}), /* @__PURE__ */ React.createElement("label", _ref2.cn("label", {
+    "htmlFor": "".concat(id, "-data-table")
+  }), texts.table)), /* @__PURE__ */ React.createElement(DataAccessibilityTable, _ref2.cn("DataAccessibilityTable", {
+    "id": id,
+    "dataTableRef": dataTableRef,
+    "data": data,
+    "hints": hints,
+    "config": config,
+    "intl": intl
+  })));
+};
+export {
+  PlotA11yView
+};

package/lib/esm/a11y/bezier.mjs

@@ -0,0 +1,32 @@
+var makeBezier = function makeBezier2(points, bounds) {
+  var yPoints = points.map(function(point) {
+    return point.y;
+  });
+  var noPoints = points.map(function() {
+    return 1;
+  });
+  var weightPoints = points.map(function(point) {
+    var _point$weight;
+    return (_point$weight = point.weight) !== null && _point$weight !== void 0 ? _point$weight : 1;
+  });
+  var process = function process2(t, points2) {
+    var result = 0;
+    for (var i = 0; i < points2.length; i++) {
+      var tPower = i;
+      var reversedTPower = points2.length - 1 - i;
+      var edge = i === 0 || i === points2.length - 1;
+      var factor = edge ? 1 : points2.length - 1;
+      var point = points2[i];
+      var weight = weightPoints[i];
+      result += factor * Math.pow(t, tPower) * Math.pow(1 - t, reversedTPower) * point * weight;
+    }
+    return result;
+  };
+  return function(x) {
+    var t = x / bounds.width;
+    return process(t, yPoints) / process(t, noPoints);
+  };
+};
+export {
+  makeBezier
+};

package/lib/esm/a11y/focus.mjs

@@ -0,0 +1,44 @@
+import { isFocusable } from "@semcore/core/lib/utils/focus-lock/isFocusable";
+var findNextFocusableElementInChildren = function findNextFocusableElementInChildren2(element) {
+  if (element && isFocusable(element)) {
+    return element;
+  }
+  var children = element === null || element === void 0 ? void 0 : element.children;
+  if (children) {
+    for (var i = 0; i < children.length; i++) {
+      var childChild = children.item(i);
+      if (!childChild) continue;
+      var result = findNextFocusableElementInChildren2(childChild);
+      if (result) return result;
+    }
+  }
+  return null;
+};
+var makeParentsChain = function makeParentsChain2(element) {
+  var parents = [];
+  var parent = element.parentElement;
+  while (parent) {
+    parents.push(parent);
+    parent = parent.parentElement;
+  }
+  return parents;
+};
+var heavyFindNextFocusableElement = function heavyFindNextFocusableElement2(base) {
+  var parents = makeParentsChain(base);
+  for (var i = 0; i < parents.length; i++) {
+    var _parent$children;
+    var parent = parents[i];
+    var siblings = Array.from((_parent$children = parent === null || parent === void 0 ? void 0 : parent.children) !== null && _parent$children !== void 0 ? _parent$children : []);
+    if (siblings.indexOf(parents[i - 1] || base) !== -1) {
+      siblings = siblings.slice(siblings.indexOf(parents[i - 1] || base) + 1);
+    }
+    for (var _i = 0; _i < siblings.length; _i++) {
+      var focusable = findNextFocusableElementInChildren(siblings[_i]);
+      if (focusable) return focusable;
+    }
+  }
+  return null;
+};
+export {
+  heavyFindNextFocusableElement
+};