@geneui/components 2.11.1

package/CellMeasurerCache-c11cec83.js

@@ -0,0 +1,229 @@
+import { _ as _createClass, n as _classCallCheck } from './index-0cf65939.js';
+import { _ as _defineProperty } from './objectWithoutPropertiesLoose-299691d8.js';
+
+var DEFAULT_HEIGHT = 30;
+var DEFAULT_WIDTH = 100; // Enables more intelligent mapping of a given column and row index to an item ID.
+// This prevents a cell cache from being invalidated when its parent collection is modified.
+
+/**
+ * Caches measurements for a given cell.
+ */
+var CellMeasurerCache =
+/*#__PURE__*/
+function () {
+  function CellMeasurerCache() {
+    var _this = this;
+
+    var params = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+
+    _classCallCheck(this, CellMeasurerCache);
+
+    _defineProperty(this, "_cellHeightCache", {});
+
+    _defineProperty(this, "_cellWidthCache", {});
+
+    _defineProperty(this, "_columnWidthCache", {});
+
+    _defineProperty(this, "_rowHeightCache", {});
+
+    _defineProperty(this, "_defaultHeight", void 0);
+
+    _defineProperty(this, "_defaultWidth", void 0);
+
+    _defineProperty(this, "_minHeight", void 0);
+
+    _defineProperty(this, "_minWidth", void 0);
+
+    _defineProperty(this, "_keyMapper", void 0);
+
+    _defineProperty(this, "_hasFixedHeight", void 0);
+
+    _defineProperty(this, "_hasFixedWidth", void 0);
+
+    _defineProperty(this, "_columnCount", 0);
+
+    _defineProperty(this, "_rowCount", 0);
+
+    _defineProperty(this, "columnWidth", function (_ref) {
+      var index = _ref.index;
+
+      var key = _this._keyMapper(0, index);
+
+      return _this._columnWidthCache[key] !== undefined ? _this._columnWidthCache[key] : _this._defaultWidth;
+    });
+
+    _defineProperty(this, "rowHeight", function (_ref2) {
+      var index = _ref2.index;
+
+      var key = _this._keyMapper(index, 0);
+
+      return _this._rowHeightCache[key] !== undefined ? _this._rowHeightCache[key] : _this._defaultHeight;
+    });
+
+    var defaultHeight = params.defaultHeight,
+        defaultWidth = params.defaultWidth,
+        fixedHeight = params.fixedHeight,
+        fixedWidth = params.fixedWidth,
+        keyMapper = params.keyMapper,
+        minHeight = params.minHeight,
+        minWidth = params.minWidth;
+    this._hasFixedHeight = fixedHeight === true;
+    this._hasFixedWidth = fixedWidth === true;
+    this._minHeight = minHeight || 0;
+    this._minWidth = minWidth || 0;
+    this._keyMapper = keyMapper || defaultKeyMapper;
+    this._defaultHeight = Math.max(this._minHeight, typeof defaultHeight === 'number' ? defaultHeight : DEFAULT_HEIGHT);
+    this._defaultWidth = Math.max(this._minWidth, typeof defaultWidth === 'number' ? defaultWidth : DEFAULT_WIDTH);
+
+    if (process.env.NODE_ENV !== 'production') {
+      if (this._hasFixedHeight === false && this._hasFixedWidth === false) {
+        console.warn("CellMeasurerCache should only measure a cell's width or height. " + 'You have configured CellMeasurerCache to measure both. ' + 'This will result in poor performance.');
+      }
+
+      if (this._hasFixedHeight === false && this._defaultHeight === 0) {
+        console.warn('Fixed height CellMeasurerCache should specify a :defaultHeight greater than 0. ' + 'Failing to do so will lead to unnecessary layout and poor performance.');
+      }
+
+      if (this._hasFixedWidth === false && this._defaultWidth === 0) {
+        console.warn('Fixed width CellMeasurerCache should specify a :defaultWidth greater than 0. ' + 'Failing to do so will lead to unnecessary layout and poor performance.');
+      }
+    }
+  }
+
+  _createClass(CellMeasurerCache, [{
+    key: "clear",
+    value: function clear(rowIndex) {
+      var columnIndex = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
+
+      var key = this._keyMapper(rowIndex, columnIndex);
+
+      delete this._cellHeightCache[key];
+      delete this._cellWidthCache[key];
+
+      this._updateCachedColumnAndRowSizes(rowIndex, columnIndex);
+    }
+  }, {
+    key: "clearAll",
+    value: function clearAll() {
+      this._cellHeightCache = {};
+      this._cellWidthCache = {};
+      this._columnWidthCache = {};
+      this._rowHeightCache = {};
+      this._rowCount = 0;
+      this._columnCount = 0;
+    }
+  }, {
+    key: "hasFixedHeight",
+    value: function hasFixedHeight() {
+      return this._hasFixedHeight;
+    }
+  }, {
+    key: "hasFixedWidth",
+    value: function hasFixedWidth() {
+      return this._hasFixedWidth;
+    }
+  }, {
+    key: "getHeight",
+    value: function getHeight(rowIndex) {
+      var columnIndex = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
+
+      if (this._hasFixedHeight) {
+        return this._defaultHeight;
+      } else {
+        var _key = this._keyMapper(rowIndex, columnIndex);
+
+        return this._cellHeightCache[_key] !== undefined ? Math.max(this._minHeight, this._cellHeightCache[_key]) : this._defaultHeight;
+      }
+    }
+  }, {
+    key: "getWidth",
+    value: function getWidth(rowIndex) {
+      var columnIndex = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
+
+      if (this._hasFixedWidth) {
+        return this._defaultWidth;
+      } else {
+        var _key2 = this._keyMapper(rowIndex, columnIndex);
+
+        return this._cellWidthCache[_key2] !== undefined ? Math.max(this._minWidth, this._cellWidthCache[_key2]) : this._defaultWidth;
+      }
+    }
+  }, {
+    key: "has",
+    value: function has(rowIndex) {
+      var columnIndex = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
+
+      var key = this._keyMapper(rowIndex, columnIndex);
+
+      return this._cellHeightCache[key] !== undefined;
+    }
+  }, {
+    key: "set",
+    value: function set(rowIndex, columnIndex, width, height) {
+      var key = this._keyMapper(rowIndex, columnIndex);
+
+      if (columnIndex >= this._columnCount) {
+        this._columnCount = columnIndex + 1;
+      }
+
+      if (rowIndex >= this._rowCount) {
+        this._rowCount = rowIndex + 1;
+      } // Size is cached per cell so we don't have to re-measure if cells are re-ordered.
+
+
+      this._cellHeightCache[key] = height;
+      this._cellWidthCache[key] = width;
+
+      this._updateCachedColumnAndRowSizes(rowIndex, columnIndex);
+    }
+  }, {
+    key: "_updateCachedColumnAndRowSizes",
+    value: function _updateCachedColumnAndRowSizes(rowIndex, columnIndex) {
+      // :columnWidth and :rowHeight are derived based on all cells in a column/row.
+      // Pre-cache these derived values for faster lookup later.
+      // Reads are expected to occur more frequently than writes in this case.
+      // Only update non-fixed dimensions though to avoid doing unnecessary work.
+      if (!this._hasFixedWidth) {
+        var columnWidth = 0;
+
+        for (var i = 0; i < this._rowCount; i++) {
+          columnWidth = Math.max(columnWidth, this.getWidth(i, columnIndex));
+        }
+
+        var columnKey = this._keyMapper(0, columnIndex);
+
+        this._columnWidthCache[columnKey] = columnWidth;
+      }
+
+      if (!this._hasFixedHeight) {
+        var rowHeight = 0;
+
+        for (var _i = 0; _i < this._columnCount; _i++) {
+          rowHeight = Math.max(rowHeight, this.getHeight(rowIndex, _i));
+        }
+
+        var rowKey = this._keyMapper(rowIndex, 0);
+
+        this._rowHeightCache[rowKey] = rowHeight;
+      }
+    }
+  }, {
+    key: "defaultHeight",
+    get: function get() {
+      return this._defaultHeight;
+    }
+  }, {
+    key: "defaultWidth",
+    get: function get() {
+      return this._defaultWidth;
+    }
+  }]);
+
+  return CellMeasurerCache;
+}();
+
+function defaultKeyMapper(rowIndex, columnIndex) {
+  return "".concat(rowIndex, "-").concat(columnIndex);
+}
+
+export { CellMeasurerCache as C };

package/Charts.js

@@ -0,0 +1,99 @@
+import './globalStyling-9c60a159.js';
+export { A as AreaChart, B as BarChart, e as ColumnChart, l as ColumnRangeChart, f as DalColumnChart, i as DonutChart, F as FunnelChart, k as HeatMapChart, L as LineChart, c as MapChart, h as PieChart, j as ScatterChart, S as StackedBarChart, g as StackedColumnChart, d as TreeMapChart } from './index-0cf65939.js';
+import './style-inject.es-746bb8ed.js';
+import './Editor.js';
+import './_rollupPluginBabelHelpers-e8fb2e5c.js';
+import 'react';
+import './index-e0af0caf.js';
+import './_commonjsHelpers-24198af3.js';
+import 'react-dom';
+import './index-6ff23041.js';
+import './index-ac59cb10.js';
+import './dateValidation-67caec66.js';
+import './useMount-6fef51a5.js';
+import './useDeviceType-dd51db38.js';
+import './configs-91c86664.js';
+import './useWindowSize-80369d76.js';
+import './Button.js';
+import './Icon.js';
+import './ValidatableUploader.js';
+import './index-d9e8a888.js';
+import './Grid.js';
+import './useWidth-9f4647f8.js';
+import './useKeyDown-38102ae7.js';
+import './BusyLoader.js';
+import './Image.js';
+import './Empty.js';
+import './Tooltip.js';
+import './Popover-f4d1cac0.js';
+import './GeneUIProvider.js';
+import './Checkbox.js';
+import './checkboxRadioSwitcher-5b69d7bd.js';
+import './guid-8ddf77b3.js';
+import './ExtendedInput.js';
+import './index-5cea9a7d.js';
+import './useClickOutside-5183e396.js';
+import './Scrollbar.js';
+import './ValidatableRadio.js';
+import './RadioGroup.js';
+import './Radio.js';
+import './ValidatableCheckbox.js';
+import './ValidatableSwitcher.js';
+import './Switcher.js';
+import './ValidatableNumberInput.js';
+import './ValidatableTextInput.js';
+import './ValidatableDatePicker.js';
+import './index-5e722d91.js';
+import './index-702bf24a.js';
+import './index-122432cd.js';
+import './debounce-4419bc2f.js';
+import './DatePicker.js';
+import './localization-4ba17032.js';
+import './checkTimeValidation-e56771be.js';
+import './useEllipsisDetection-ef536015.js';
+import './Tabs.js';
+import './Steps.js';
+import './index-a4635754.js';
+import './Portal.js';
+import './Timeline.js';
+import './Card.js';
+import './MobilePopup.js';
+import './Menu.js';
+import './Option.js';
+import './SkeletonLoader.js';
+import './KeyValue.js';
+import './configs.js';
+import './Tag.js';
+import './Alert.js';
+import './index-00fe8887.js';
+import './rangeAndSlider-20599da4.js';
+import './Slider.js';
+import './Pagination.js';
+import './Divider.js';
+import './objectWithoutPropertiesLoose-299691d8.js';
+import './clsx.m-2bb6df4b.js';
+import './index-a59530cd.js';
+import './Notification.js';
+import './Modal.js';
+import './Collapse.js';
+import './Status.js';
+import './Avatar.js';
+import './Search.js';
+import './TextLink.js';
+import './Label.js';
+import './Paper.js';
+import './Badge.js';
+import './Time.js';
+import './Title.js';
+import './index-b7a33c58.js';
+import './QRCode.js';
+import './Progress.js';
+import './MobileNavigation.js';
+import './Products.js';
+import './Breadcrumb.js';
+import './Section.js';
+import './ColorPicker.js';
+import './NavigationMenu.js';
+import './Textarea.js';
+import './AdvancedSearch.js';
+import './LinkButton.js';

package/Checkbox.js

@@ -0,0 +1,232 @@
+import { _ as _extends } from './_rollupPluginBabelHelpers-e8fb2e5c.js';
+import React__default, { forwardRef, useState, useMemo } from 'react';
+import { p as propTypesExports } from './index-e0af0caf.js';
+import { c as classnames } from './index-6ff23041.js';
+import { c as checkboxRadioSwitcherConfig } from './configs-91c86664.js';
+import { n as noop, i as interceptValue, s as stopEvent } from './index-ac59cb10.js';
+import Tooltip from './Tooltip.js';
+import './globalStyling-9c60a159.js';
+import './checkboxRadioSwitcher-5b69d7bd.js';
+import { g as guid } from './guid-8ddf77b3.js';
+import './dateValidation-67caec66.js';
+import './_commonjsHelpers-24198af3.js';
+import 'react-dom';
+import './Popover-f4d1cac0.js';
+import './useDeviceType-dd51db38.js';
+import './useWindowSize-80369d76.js';
+import './GeneUIProvider.js';
+import './style-inject.es-746bb8ed.js';
+
+const Checkbox = /*#__PURE__*/forwardRef((props, ref) => {
+  const {
+    size,
+    label,
+    labelPosition,
+    labelTooltip,
+    labelAlignment,
+    description,
+    indeterminate,
+    readOnly,
+    disabled,
+    required,
+    isValid,
+    errorText,
+    defaultChecked,
+    onChange,
+    value,
+    className,
+    onKeyPress,
+    checked,
+    onWrapperClick,
+    onMouseEnter,
+    onMouseLeave,
+    ...restProps
+  } = props;
+  const [checkedState, setCheckedState] = useState(defaultChecked);
+  const isControlled = 'checked' in props && typeof checked !== 'undefined';
+  const localChecked = isControlled ? checked : checkedState;
+  const randomId = useMemo(guid, []);
+  const handleChange = e => {
+    const {
+      checked
+    } = e.target;
+    !isControlled && setCheckedState(checked);
+    onChange(interceptValue(e, value));
+  };
+  const handleKeyPress = e => {
+    if (e.which === 13 || e.keyCode === 13) {
+      // need this for prevent form default submit
+      stopEvent(e);
+      const {
+        checked
+      } = e.target;
+
+      // need this because in event time checkbox value is old.
+      const changedEvent = {
+        ...e
+      };
+      changedEvent.target.checked = !checked;
+      !isControlled && setCheckedState(checked => !checked);
+      onChange(interceptValue(changedEvent, value));
+    }
+    onKeyPress(e);
+  };
+  const hasError = !isValid;
+  return /*#__PURE__*/React__default.createElement("div", {
+    onMouseEnter: onMouseEnter,
+    onMouseLeave: onMouseLeave,
+    className: classnames('crs-holder', className, "lp-".concat(labelPosition), "la-".concat(labelAlignment), {
+      disabled,
+      error: hasError,
+      'read-only': readOnly
+    }),
+    onClick: onWrapperClick
+  }, /*#__PURE__*/React__default.createElement("div", {
+    className: classnames('label-holder', {
+      'has-label': !!label
+    })
+  }, label && /*#__PURE__*/React__default.createElement(Tooltip, {
+    position: "auto",
+    title: label,
+    isVisible: labelTooltip
+  }, /*#__PURE__*/React__default.createElement("div", {
+    className: "crs-item crs-label"
+  }, /*#__PURE__*/React__default.createElement("label", {
+    className: "ellipsis-text",
+    title: labelTooltip,
+    htmlFor: randomId
+  }, required && "* ", label))), /*#__PURE__*/React__default.createElement("div", {
+    className: "crs-item crs-component"
+  }, /*#__PURE__*/React__default.createElement("input", _extends({
+    type: "checkbox",
+    onKeyPress: handleKeyPress,
+    onChange: handleChange,
+    checked: localChecked,
+    disabled: disabled,
+    value: value,
+    ref: ref,
+    id: randomId
+  }, restProps)), /*#__PURE__*/React__default.createElement("label", {
+    className: classnames('checkbox', 'cr-element', "s-".concat(size), {
+      indeterminate,
+      active: !indeterminate && localChecked,
+      'error-color': !indeterminate && !localChecked && !errorText && hasError
+    }),
+    htmlFor: randomId
+  }))), hasError && errorText && /*#__PURE__*/React__default.createElement("div", {
+    className: "information-message color-danger"
+  }, errorText), description && /*#__PURE__*/React__default.createElement("div", {
+    className: "input-description"
+  }, description));
+});
+Checkbox.propTypes = {
+  /**
+   * At what point an element becomes focusable when a user is interacting with the page via a keyboard
+   */
+  tabIndex: propTypesExports.number,
+  /**
+   * Use this prop to control Checkbox state. Note that when you specify this prop, the Checkbox will not functionate itself
+   */
+  checked: propTypesExports.bool,
+  /**
+   * Checkbox size
+   */
+  size: propTypesExports.oneOf(checkboxRadioSwitcherConfig.size),
+  /**
+   * Use this prop to add an additional label to Checkbox
+   */
+  label: propTypesExports.node,
+  /**
+   * Tooltip for label
+   */
+  labelTooltip: propTypesExports.string,
+  /**
+   * Specify "label" position
+   */
+  labelPosition: propTypesExports.oneOf(checkboxRadioSwitcherConfig.labelPosition),
+  /**
+   * Specify "label" alignment
+   */
+  labelAlignment: propTypesExports.oneOf(checkboxRadioSwitcherConfig.labelAlignment),
+  /**
+   * Use this prop to add an additional description field to the Checkbox
+   */
+  description: propTypesExports.node,
+  /**
+   * Use this prop to make checkbox neither checked nor unchecked
+   */
+  indeterminate: propTypesExports.bool,
+  /**
+   * Makes Checkbox readonly when set to "true"
+   */
+  readOnly: propTypesExports.bool,
+  /**
+   * Makes Checkbox disabled when set to "true"
+   */
+  disabled: propTypesExports.bool,
+  /**
+   * Checkbox adds an extra asterisk to the "label". For more info see "ValidatableCheckbox"(integrated Checkbox with "Form" organism).
+   */
+  required: propTypesExports.bool,
+  /**
+   * Control Checkbox validation. For more info see "ValidatableCheckbox"(integrated Checkbox with "Form" organism).
+   */
+  isValid: propTypesExports.bool,
+  /**
+   * Use this prop to specify error message. This will be displayed when "isValid" is set to "false"
+   */
+  errorText: propTypesExports.node,
+  /**
+   * This prop will only applied once as defaultState for "checked" when Checkbox mounts.
+   * Note that specifying this prop does not mean to control it.
+   */
+  defaultChecked: propTypesExports.bool,
+  /**
+   * Fires an event when Checkbox is clicked or "enter" key is pressed((event: Event) => void).
+   */
+  onChange: propTypesExports.func,
+  /**
+   * Fires an event when any key is pressed((event: Event) => void).
+   */
+  onKeyPress: propTypesExports.func,
+  /**
+   * Fires an event when mouse enter((event: Event) => void).
+   */
+  onMouseEnter: propTypesExports.func,
+  /**
+   * Fires an event when mouse leave((event: Event) => void).
+   */
+  onMouseLeave: propTypesExports.func,
+  /**
+   * Fires an event when clicking on parent/wrapper of input ((event: Event) => void).
+   */
+  onWrapperClick: propTypesExports.func,
+  /**
+   * Use this prop to get specified value when "onChange" is fired
+   */
+  value: propTypesExports.oneOfType([propTypesExports.string, propTypesExports.bool, propTypesExports.number]),
+  /**
+   * Additional className
+   */
+  className: propTypesExports.string
+};
+Checkbox.defaultProps = {
+  tabIndex: 0,
+  size: checkboxRadioSwitcherConfig.size[0],
+  label: '',
+  labelPosition: checkboxRadioSwitcherConfig.labelPosition[0],
+  labelAlignment: checkboxRadioSwitcherConfig.labelAlignment[0],
+  description: '',
+  indeterminate: false,
+  readOnly: false,
+  disabled: false,
+  required: false,
+  isValid: true,
+  errorText: '',
+  defaultChecked: false,
+  onKeyPress: noop,
+  onChange: noop,
+  onWrapperClick: noop
+};
+
+export { Checkbox as default };