@zohodesk/dot 1.0.0-beta.22 → 1.0.0-beta.223

package/es/FreezeLayer/FreezeLayer.js

@@ -1,139 +1,156 @@
-import _Object$getPrototypeOf from 'babel-runtime/core-js/object/get-prototype-of';
-import _classCallCheck from 'babel-runtime/helpers/classCallCheck';
-import _createClass from 'babel-runtime/helpers/createClass';
-import _possibleConstructorReturn from 'babel-runtime/helpers/possibleConstructorReturn';
-import _inherits from 'babel-runtime/helpers/inherits';
 import React, { Component } from 'react';
 import PropTypes from 'prop-types';
 import { Container } from '@zohodesk/components/lib/Layout';
 import VelocityAnimationGroup from '@zohodesk/components/lib/VelocityAnimation/VelocityAnimationGroup/VelocityAnimationGroup';
-import style from './FreezeLayer.module.css';
-import { Shortcut } from '../utils/KeyboardApi';
+import style from './FreezeLayer.module.css'; //import { Shortcut } from '../utils/KeyboardApi';
 
-var FreezeLayer = function (_Component) {
-  _inherits(FreezeLayer, _Component);
-
-  function FreezeLayer(props) {
-    _classCallCheck(this, FreezeLayer);
-
-    var _this = _possibleConstructorReturn(this, (FreezeLayer.__proto__ || _Object$getPrototypeOf(FreezeLayer)).call(this, props));
+import { getZIndex } from '@zohodesk/components/lib/Provider/ZindexProvider';
+import { getDotLibraryConfig } from '../Provider/Config';
+export default class FreezeLayer extends Component {
+  constructor(props) {
+    super(props);
+    this.state = {
+      isActive: props.isActive,
+      isChildActive: false
+    };
+    this.getNextIndex = getZIndex(this);
+    this.isFreezeLayerEnabled = false;
+  }
 
-    _this.state = { isActive: props.isActive, isChildActive: false };
-    return _this;
+  enableFreeze() {
+    if (!this.isFreezeLayerEnabled) {
+      this.isFreezeLayerEnabled = true;
+      const freezeLayerEnable = (getDotLibraryConfig('freezeLayer') || {}).enable;
+      freezeLayerEnable && freezeLayerEnable();
+    }
   }
 
-  // componentDidMount(){
-  //   Shortcut && Shortcut.setState(false);
-  // }
-  //
-  // componentWillUnmount(){
-  //   Shortcut && Shortcut.setState(true);
-  // }
+  disableFreeze() {
+    if (this.isFreezeLayerEnabled) {
+      this.isFreezeLayerEnabled = false;
+      const freezeLayerDisable = (getDotLibraryConfig('freezeLayer') || {}).disable;
+      freezeLayerDisable && freezeLayerDisable();
+    }
+  }
 
-  _createClass(FreezeLayer, [{
-    key: 'componentDidUpdate',
-    value: function componentDidUpdate(prevProps) {
-      var isActive = this.props.isActive;
+  componentDidMount() {
+    let {
+      isActive
+    } = this.props;
 
-      if (isActive != prevProps.isActive) {
-        if (isActive) {
-          Shortcut && Shortcut.setState(false);
-        } else {
-          Shortcut && Shortcut.setState(true);
-        }
-      }
+    if (isActive) {
+      this.setState({
+        isChildActive: true
+      });
+      this.enableFreeze();
     }
-  }, {
-    key: 'render',
-    value: function render() {
-      var _props = this.props,
-          children = _props.children,
-          align = _props.align,
-          childAnimationName = _props.childAnimationName,
-          palette = _props.palette,
-          onClick = _props.onClick,
-          animationName = _props.animationName,
-          zIndex = _props.zIndex,
-          isActive = _props.isActive,
-          runOnMount = _props.runOnMount,
-          forwardRef = _props.forwardRef,
-          isSvgMask = _props.isSvgMask;
+  }
 
-      return React.createElement(
-        VelocityAnimationGroup,
-        {
-          name: animationName && animationName,
-          isActive: isActive,
-          runOnMount: runOnMount
-        },
-        React.createElement(
-          'div',
-          {
-            className: '\n              ' + style.container + ' ' + style['index' + zIndex] + '  ' + (!isSvgMask ? style[palette] : '') + '\n            ',
-            onClick: onClick ? onClick : null,
-            ref: forwardRef
-          },
-          children && React.createElement(
-            React.Fragment,
-            null,
-            childAnimationName ? React.createElement(
-              VelocityAnimationGroup,
-              {
-                name: childAnimationName,
-                isActive: true,
-                runOnMount: true,
-                enterDelay: palette === 'plain' ? 0 : 300,
-                component: Container,
-                alignBox: 'row',
-                align: align,
-                dataId: 'reactFreezeLayer'
-              },
-              children
-            ) : isSvgMask ? React.createElement(
-              React.Fragment,
-              null,
-              children
-            ) : React.createElement(
-              Container,
-              {
-                alignBox: 'row',
-                align: align,
-                dataId: 'reactFreezeLayer'
-              },
-              children
-            )
-          )
-        )
-      );
-    }
-  }]);
+  componentDidUpdate(prevProps) {
+    let {
+      isActive
+    } = this.props;
 
-  return FreezeLayer;
-}(Component);
+    if (isActive != prevProps.isActive) {
+      if (isActive) {
+        this.enableFreeze(); // Shortcut && Shortcut.setState(false);
 
-export default FreezeLayer;
+        this.setState({
+          isActive: true
+        }, () => {
+          this.setState({
+            isChildActive: true
+          });
+        });
+      } else {
+        this.disableFreeze(); // Shortcut && Shortcut.setState(true);
 
+        this.setState({
+          isChildActive: false
+        }, () => {
+          this.setState({
+            isActive: false
+          });
+        });
+      }
+    }
+  }
 
-var animationValues = ['fade', 'shrink', 'expand', 'slideRight', 'slideDown', 'flyDown'];
+  componentWillUnmount() {
+    this.disableFreeze();
+  }
+
+  render() {
+    let {
+      children,
+      align,
+      childAnimationName,
+      palette,
+      onClick,
+      animationName,
+      zIndex,
+      runOnMount,
+      forwardRef,
+      isSvgMask,
+      customClass,
+      needAutoZindex
+    } = this.props;
+    let {
+      isActive,
+      isChildActive
+    } = this.state;
+    return /*#__PURE__*/React.createElement(VelocityAnimationGroup, {
+      name: animationName && animationName,
+      isActive: isActive,
+      runOnMount: runOnMount
+    }, /*#__PURE__*/React.createElement("div", {
+      style: isActive && needAutoZindex ? {
+        zIndex: `${this.getNextIndex()}`
+      } : {},
+      className: `
+              ${style.container} ${customClass} ${style[`index${zIndex}`]}  ${!isSvgMask ? style[palette] : ''}
+            `,
+      onClick: onClick ? onClick : null,
+      ref: forwardRef
+    }, children && /*#__PURE__*/React.createElement(React.Fragment, null, childAnimationName ? /*#__PURE__*/React.createElement(VelocityAnimationGroup, {
+      name: childAnimationName,
+      isActive: isChildActive,
+      enterDelay: palette === 'plain' ? 0 : 300,
+      component: Container,
+      alignBox: "row",
+      align: align,
+      dataId: "reactFreezeLayer"
+    }, children) : isSvgMask ? /*#__PURE__*/React.createElement(React.Fragment, null, children) : /*#__PURE__*/React.createElement(Container, {
+      alignBox: "row",
+      align: align,
+      dataId: "reactFreezeLayer"
+    }, children))));
+  }
 
+}
+let animationValues = ['fade', 'shrink', 'expand', 'slideRight', 'slideDown', 'flyDown'];
 FreezeLayer.propTypes = {
   align: PropTypes.oneOf(['horizontal', 'vertical', 'both']),
   animationName: PropTypes.oneOf(animationValues),
   childAnimationName: PropTypes.oneOf(animationValues),
   children: PropTypes.node,
+  customClass: PropTypes.string,
   forwardRef: PropTypes.object,
   isActive: PropTypes.bool,
+  isSvgMask: PropTypes.bool,
+  needAutoZindex: PropTypes.bool,
   onClick: PropTypes.oneOfType([PropTypes.func, PropTypes.bool]),
   palette: PropTypes.oneOf(['dark', 'default', 'darkLight', 'plain', 'snow']),
   runOnMount: PropTypes.bool,
-  zIndex: PropTypes.oneOf(['3', '5', '7', '10']),
-  isSvgMask: PropTypes.bool
+  zIndex: PropTypes.oneOf(['3', '5', '7', '10'])
 };
 FreezeLayer.defaultProps = {
   isActive: false,
   palette: 'default',
   zIndex: '5',
-  isSvgMask: false
+  isSvgMask: false,
+  customClass: '',
+  needAutoZindex: true
 };
 
 if (false) {

package/es/FreezeLayer/FreezeLayer.module.css

@@ -1,28 +1,25 @@
 .container {
   top: 0;
-  bottom: 0;
-  position: absolute;
-}[dir=ltr] .container {
   left: 0;
+  bottom: 0;
   right: 0;
-}[dir=rtl] .container {
-  right: 0;
-  left: 0;
+  position: absolute;
+  overflow: hidden;
 }
 .default {
-  background-color: rgba(0, 0, 0, 0.45);
+  background-color: var(--zdt_freezelayer_default_bg);
 }
 .dark {
-  background-color: rgba(0, 0, 0, 0.9);
+  background-color: var(--zdt_freezelayer_dark_bg);
 }
 .darkLight {
-  background-color: var(--zd_bg_dark16);
+  background-color: var(--zdt_freezelayer_darklight_bg);
 }
 .plain {
-  background-color: transparent;
+  background-color: var(--zdt_freezelayer_plain_bg);
 }
 .snow {
-  background-color: rgba(30, 38, 51, 0.4);
+  background-color: var(--zdt_freezelayer_snow_bg);
 }
 .index3 {
   z-index: 3;
@@ -37,5 +34,5 @@
   z-index: 10;
 }
 .delay {
-  transition-delay: 0.2s;
+  transition-delay: var(--zd_transition2);
 }

package/es/IconButton/IconButton.js

@@ -0,0 +1,188 @@
+import React from 'react';
+import PropTypes from 'prop-types';
+import Icon from '@zohodesk/icons/lib/Icon';
+import { Container } from '@zohodesk/components/lib/Layout';
+import btnStyle from '@zohodesk/components/lib/semantic/Button/semanticButton.module.css';
+import RippleEffect from '@zohodesk/components/lib/RippleEffect/RippleEffect';
+import style from './IconButton.module.css';
+export default class IconButton extends React.Component {
+  constructor(props) {
+    super(props);
+    this.state = {
+      isPressed: false
+    };
+    this.handleToggle = this.handleToggle.bind(this);
+    this.triggerClick = this.triggerClick.bind(this);
+    this.triggerMouseDown = this.triggerMouseDown.bind(this);
+    this.triggerMouseOver = this.triggerMouseOver.bind(this);
+    this.onBlur = this.onBlur.bind(this);
+  }
+
+  handleToggle(e) {
+    if (e.key === ' ' || e.key === 'Enter' || e.key === 'Spacebar') {
+      e.preventDefault();
+      this.triggerClick(e);
+      this.triggerMouseDown(e);
+    }
+  }
+
+  triggerClick(e) {
+    let {
+      onClick,
+      isDisabled
+    } = this.props;
+    !isDisabled ? (onClick && onClick(e), this.setState({
+      isPressed: true
+    })) : null;
+  }
+
+  triggerMouseOver(e) {
+    let {
+      onMouseOver,
+      isDisabled
+    } = this.props;
+    !isDisabled ? (onMouseOver && onMouseOver(e), this.setState({
+      isPressed: true
+    })) : null;
+  }
+
+  triggerMouseDown(e) {
+    let {
+      onMouseDown,
+      isDisabled
+    } = this.props;
+    !isDisabled ? (onMouseDown && onMouseDown(e), this.setState({
+      isPressed: true
+    })) : null;
+  }
+
+  onBlur(e) {
+    let {
+      isDisabled
+    } = this.props;
+    !isDisabled ? this.setState({
+      isPressed: false
+    }) : null;
+  }
+
+  render() {
+    let {
+      palette,
+      iconSize,
+      iconName,
+      className,
+      iconClass,
+      dataId,
+      eleRef,
+      isActive,
+      tourId,
+      isDisabled,
+      children,
+      hoverType,
+      title,
+      isBold,
+      isNeedEffect,
+      needButtonTag,
+      a11y,
+      dataIsHtml
+    } = this.props;
+    let {
+      isPressed
+    } = this.state;
+    let {
+      ariaHaspopup,
+      ariaExpanded,
+      ariaLabel,
+      ariaControls,
+      ariaLabelledby
+    } = a11y;
+    return /*#__PURE__*/React.createElement(RippleEffect, {
+      palette: palette,
+      isActive: isActive,
+      hoverType: hoverType,
+      isDisabled: isDisabled,
+      isNeedEffect: isNeedEffect
+    }, /*#__PURE__*/React.createElement(Container, {
+      "aria-label": ariaLabel,
+      "aria-haspopup": ariaHaspopup,
+      "aria-expanded": ariaExpanded,
+      "aria-controls": ariaControls,
+      "aria-labelledby": ariaLabelledby,
+      tagName: needButtonTag ? 'button' : 'div',
+      isInline: true,
+      tourId: tourId,
+      align: "both",
+      isCover: false,
+      className: `${needButtonTag && btnStyle.buttonReset} ${style.wrapper} ${className ? className : ''} ${isActive ? style[`${palette}_active`] : style[palette]}`,
+      dataId: dataId,
+      onClick: this.triggerClick,
+      "data-title": title,
+      "data-ishtml": dataIsHtml,
+      eleRef: eleRef,
+      onMouseDown: this.triggerMouseDown,
+      onMouseEnter: this.triggerMouseOver,
+      "aria-pressed": isPressed,
+      onKeyDown: this.handleToggle,
+      onFocus: this.triggerMouseOver,
+      onBlur: this.onBlur,
+      disabled: isDisabled
+    }, iconName ? /*#__PURE__*/React.createElement(Icon, {
+      isBold: isBold,
+      size: iconSize,
+      name: iconName,
+      iconClass: iconClass
+    }) : null, children ? children : null));
+  }
+
+}
+IconButton.propTypes = {
+  children: PropTypes.node,
+  className: PropTypes.string,
+  dataId: PropTypes.string,
+  eleRef: PropTypes.func,
+  hoverType: PropTypes.oneOf(['default', 'border', 'bg']),
+  iconClass: PropTypes.string,
+  iconName: PropTypes.string,
+  iconSize: PropTypes.string,
+  isActive: PropTypes.bool,
+  isBold: PropTypes.bool,
+  isDisabled: PropTypes.bool,
+  isNeedEffect: PropTypes.bool,
+  onClick: PropTypes.func,
+  onMouseDown: PropTypes.func,
+  onMouseOver: PropTypes.func,
+  palette: PropTypes.oneOf(['primary', 'primaryFilled', 'default']),
+  title: PropTypes.string,
+  tourId: PropTypes.string,
+  isNeedEffect: PropTypes.bool,
+  needButtonTag: PropTypes.bool,
+  a11y: PropTypes.shape({
+    ariaHaspopup: PropTypes.bool,
+    ariaExpanded: PropTypes.bool,
+    ariaLabel: PropTypes.string,
+    ariaControls: PropTypes.string,
+    ariaLabelledby: PropTypes.string
+  }),
+  dataIsHtml: PropTypes.bool
+};
+IconButton.defaultProps = {
+  palette: 'default',
+  iconSize: '13',
+  className: '',
+  iconClass: '',
+  dataId: 'iconContainer',
+  isActive: false,
+  isDisabled: false,
+  hoverType: 'default',
+  isBold: false,
+  isNeedEffect: true,
+  needButtonTag: true,
+  a11y: {},
+  dataIsHtml: false
+};
+
+if (false) {
+  IconButton.docs = {
+    componentGroup: 'Atom'
+  };
+}

package/es/IconButton/IconButton.module.css

@@ -0,0 +1,22 @@
+.varClass {
+  --iconColor: var(--zdt_iconButton_icon_black);
+}
+.wrapper {
+  height: var(--zd_size28);
+  cursor: pointer;
+  width: var(--zd_size28);
+  composes: offSelection from '~@zohodesk/components/lib/common/common.module.css';
+  composes: varClass;
+  color: var(--iconColor);
+}
+.primary {
+  --iconColor: var(--zdt_iconButton_icon_primary);
+}
+.primary:hover {
+  --iconColor: var(--zdt_iconButton_icon_primaryHover);
+}
+.primary_active,
+.primaryFilled,
+.primaryFilled_active {
+  --iconColor: var(--zdt_iconButton_icon_primaryActive);
+}

package/es/Image/Image.js

@@ -1,64 +1,51 @@
-import _Object$getPrototypeOf from 'babel-runtime/core-js/object/get-prototype-of';
-import _classCallCheck from 'babel-runtime/helpers/classCallCheck';
-import _createClass from 'babel-runtime/helpers/createClass';
-import _possibleConstructorReturn from 'babel-runtime/helpers/possibleConstructorReturn';
-import _inherits from 'babel-runtime/helpers/inherits';
 import React from 'react';
 import PropTypes from 'prop-types';
 import style from './Image.module.css';
-
-var Image = function (_React$Component) {
-  _inherits(Image, _React$Component);
-
-  function Image() {
-    _classCallCheck(this, Image);
-
-    return _possibleConstructorReturn(this, (Image.__proto__ || _Object$getPrototypeOf(Image)).apply(this, arguments));
+export default class Image extends React.Component {
+  render() {
+    let {
+      alt,
+      src,
+      className,
+      isCover,
+      title,
+      onClick,
+      dataId,
+      htmlId,
+      eleRef,
+      original
+    } = this.props;
+    return /*#__PURE__*/React.createElement("img", {
+      src: src,
+      alt: alt,
+      "data-title": title,
+      "data-id": dataId,
+      className: ` ${className} ${isCover ? style.imgFullSize : style.imgMaxFullSize} `,
+      onClick: onClick,
+      id: htmlId,
+      ref: eleRef,
+      "data-original": original
+    });
   }
 
-  _createClass(Image, [{
-    key: 'render',
-    value: function render() {
-      var _props = this.props,
-          alt = _props.alt,
-          src = _props.src,
-          className = _props.className,
-          isCover = _props.isCover,
-          title = _props.title,
-          onClick = _props.onClick,
-          dataId = _props.dataId;
-
-      return React.createElement('img', {
-        src: src,
-        alt: alt,
-        'data-title': title,
-        'data-id': dataId,
-        className: ' ' + className + ' ' + (isCover ? style.imgFullSize : style.imgMaxFullSize) + ' ',
-        onClick: onClick
-      });
-    }
-  }]);
-
-  return Image;
-}(React.Component);
-
-export default Image;
-
-
+}
 Image.propTypes = {
   alt: PropTypes.string.isRequired,
   className: PropTypes.string,
   dataId: PropTypes.string,
+  eleRef: PropTypes.func,
+  htmlId: PropTypes.string,
   isCover: PropTypes.bool,
   onClick: PropTypes.func,
+  original: PropTypes.string,
   src: PropTypes.string.isRequired,
   title: PropTypes.string
 };
-
 Image.defaultProps = {
   isCover: false,
   className: ''
 };
+
 if (false) {
   Image.docs = {
     componentGroup: 'Atom'

package/es/ImportantNotes/ImportantNotes.js

@@ -0,0 +1,60 @@
+import React from 'react';
+import PropTypes from 'prop-types';
+import { Container, Box } from '@zohodesk/components/lib/Layout';
+import Icon from '@zohodesk/icons/lib/Icon';
+import style from './ImportantNotes.module.css';
+export default class ImportantNotes extends React.Component {
+  constructor(props) {
+    super(props);
+  }
+
+  render() {
+    let {
+      text,
+      iconName,
+      iconSize,
+      children,
+      iconClass,
+      isCover
+    } = this.props;
+    return /*#__PURE__*/React.createElement(Container, {
+      isInline: !isCover,
+      isCover: false,
+      alignBox: "row",
+      align: "top",
+      className: style.section
+    }, iconName ? /*#__PURE__*/React.createElement(Box, {
+      className: style.icon,
+      align: "start"
+    }, /*#__PURE__*/React.createElement(Icon, {
+      name: iconName,
+      size: iconSize,
+      iconClass: iconClass
+    })) : null, text || children ? /*#__PURE__*/React.createElement(Box, {
+      flexible: true,
+      className: style.title
+    }, text, children ? children : null) : null);
+  }
+
+}
+ImportantNotes.propTypes = {
+  children: PropTypes.node,
+  iconClass: PropTypes.string,
+  iconName: PropTypes.string,
+  iconSize: PropTypes.string,
+  isCover: PropTypes.bool,
+  text: PropTypes.string
+};
+ImportantNotes.defaultProps = {
+  iconName: 'ZD-helpCentre',
+  iconSize: '14',
+  iconClass: '',
+  isCover: true
+};
+
+if (false) {
+  ImportantNotes.docs = {
+    componentGroup: 'Common',
+    folderName: 'General'
+  };
+}

package/es/ImportantNotes/ImportantNotes.module.css

@@ -0,0 +1,15 @@
+.section {
+  background: var(--zdt_importantnotes_bg);
+  padding: var(--zd_size5) var(--zd_size10);
+}
+.title {
+  font-size: var(--zd_font_size13);
+  line-height: var(--zd_font_size18);
+  color: var(--zdt_importantnotes_title_text);
+}
+.icon {
+  margin-top: var(--zd_size1);
+  margin-right: var(--zd_size5);
+  color: var(--zdt_importantnotes_icon);
+  font-size: 0;
+}