@plesk/ui-library 3.27.2 → 3.28.0

package/esm/components/Dialog/Dialog.js

@@ -40,6 +40,7 @@ const Dialog = ({
   closable,
   onClose,
   closingConfirmation,
+  canClose,
   ...props
 }) => {
   const [isVisible, setIsVisible] = useState(isOpen);
@@ -150,8 +151,8 @@ const Dialog = ({
     className: classNames(baseClassName, className),
     isOpen: isVisible,
     onClose: onCloseWithConfirmation,
-    canCloseOnBackdropClick: closable,
-    canCloseOnEscapePress: closable,
+    canCloseOnBackdropClick: canClose && closable,
+    canCloseOnEscapePress: canClose && closable,
     size: size
   }, props), (title || subtitle || actions) && /*#__PURE__*/React.createElement("header", {
     className: `${baseClassName}__header`
@@ -174,6 +175,7 @@ const Dialog = ({
     className: `${baseClassName}__header-actions`
   }, actions, closable && /*#__PURE__*/React.createElement(Button, {
     className: `${baseClassName}__header-close`,
+    disabled: !canClose,
     ghost: true,
     size: "lg",
     icon: "cross-mark",
@@ -279,6 +281,12 @@ Dialog.propTypes = {
    */
   closable: PropTypes.bool,
 
+  /**
+   * Disable close dialog button
+   * @since 4.0.0
+   */
+  canClose: PropTypes.bool,
+
   /**
    * On close event handler. Called immediately after dialog closed by "cancel" button or "Esc" key.
    * @since 0.0.68
@@ -322,6 +330,7 @@ Dialog.defaultProps = {
   form: undefined,
   size: 'md',
   closable: true,
+  canClose: true,
   onClose: undefined,
   closingConfirmation: undefined,
   children: undefined,

package/esm/components/Form/Form.js

@@ -248,9 +248,11 @@ class Form extends Component {
       let field;
       let fieldErrors;
       Object.keys(this.fields).every(name => {
-        if (errors && errors[name] && typeof errors[name] === 'object' && Object.keys(errors[name]).length > 0) {
+        const foundError = getIn(errors, name);
+
+        if (foundError && typeof foundError === 'object' && Object.keys(foundError).length > 0) {
           field = this.fields[name];
-          fieldErrors = errors[name];
+          fieldErrors = foundError;
           return false;
         }
 

package/esm/components/FormFieldPassword/FormFieldPassword.js

@@ -1,49 +1,30 @@
 import _extends from "@babel/runtime/helpers/extends";
 import _defineProperty from "@babel/runtime/helpers/defineProperty";
-// Copyright 1999-2021. Plesk International GmbH. All rights reserved.
+// Copyright 1999-2022. Plesk International GmbH. All rights reserved.
 import React, { Component, Fragment, createRef } from 'react';
-import PropTypes from 'prop-types';
 import classNames from 'classnames';
 import { CLS_PREFIX } from '../../constants';
 import Button from '../Button';
 import FormField from '../FormField';
 import Input from '../Input';
-import Popover from '../Popover';
 import Translate from '../Translate';
-import passwordScore, { PASSWORD_SCORE_RULES } from './passwordScore';
+import PasswordMeter from './PasswordMeter';
+import generatePassword from './generatePassword';
 import locale from './locale/en-US';
-const symbolClasses = {
-  upper: 'ABCDEFGHIJKLMNOPQRSTUVWXYZ',
-  lower: 'abcdefghijklmnopqrstuvwxyz',
-  number: '0123456789',
-  special: '!@#$%^&*?_~'
-};
-export const generatePassword = () => {
-  const password = ['upper', 'lower', 'lower', 'lower', 'number', 'number', 'special', 'number', 'upper', 'upper', 'lower', 'lower', 'lower', 'lower', 'lower', 'lower'];
-  return password.sort((a, b) => Math.floor(b.length * Math.random()) - Math.floor(a.length * Math.random())).map(symbolClass => symbolClasses[symbolClass][Math.floor(symbolClasses[symbolClass].length * Math.random())]).join('');
-};
+
 /**
  * `FormFieldPassword` component provides secure way to enter a password.
  * @since 0.0.58
  */
-
 class FormFieldPassword extends Component {
   constructor(...args) {
     super(...args);
 
     _defineProperty(this, "state", {
       visible: false,
-      passwordMeterVisible: false,
-      scoreResult: {
-        password: null,
-        intent: null,
-        strength: null,
-        unusedRules: []
-      }
+      passwordMeterVisible: false
     });
 
-    _defineProperty(this, "passwordOnScoring", null);
-
     _defineProperty(this, "targetRef", /*#__PURE__*/createRef());
 
     _defineProperty(this, "handleToggleClick", () => {
@@ -63,134 +44,6 @@ class FormFieldPassword extends Component {
     _defineProperty(this, "handleBlur", this.handleClosePasswordMeter);
   }
 
-  async passwordScore(value) {
-    if (!value) {
-      return {
-        password: null,
-        intent: null,
-        strength: null,
-        unusedRules: []
-      };
-    }
-
-    const {
-      passwordScoreRules
-    } = this.props;
-    const {
-      password,
-      score,
-      unusedRules
-    } = await passwordScore(value, passwordScoreRules);
-    let intent = 'success';
-    let strength = /*#__PURE__*/React.createElement(Translate, {
-      content: "FormFieldPassword.strengthVeryStrong",
-      fallback: locale.strengthVeryStrong
-    });
-
-    if (score < 16) {
-      intent = 'danger';
-      strength = /*#__PURE__*/React.createElement(Translate, {
-        content: "FormFieldPassword.strengthVeryWeak",
-        fallback: locale.strengthVeryWeak
-      });
-    } else if (score < 25) {
-      intent = 'danger';
-      strength = /*#__PURE__*/React.createElement(Translate, {
-        content: "FormFieldPassword.strengthWeak",
-        fallback: locale.strengthWeak
-      });
-    } else if (score < 35) {
-      intent = 'warning';
-      strength = /*#__PURE__*/React.createElement(Translate, {
-        content: "FormFieldPassword.strengthMedium",
-        fallback: locale.strengthMedium
-      });
-    } else if (score < 45) {
-      intent = 'success';
-      strength = /*#__PURE__*/React.createElement(Translate, {
-        content: "FormFieldPassword.strengthStrong",
-        fallback: locale.strengthStrong
-      });
-    }
-
-    return {
-      password,
-      intent,
-      strength,
-      unusedRules
-    };
-  }
-
-  renderPasswordMeter(value, target) {
-    const {
-      passwordMeterVisible
-    } = this.state;
-    const {
-      passwordMeterProps
-    } = this.props;
-    const {
-      password,
-      intent,
-      strength,
-      unusedRules
-    } = this.state.scoreResult;
-
-    if (!!value && value !== password && value !== this.passwordOnScoring) {
-      this.passwordOnScoring = value;
-      this.passwordScore(value).then(scoreResult => {
-        if (this.passwordOnScoring === scoreResult.password) {
-          this.passwordOnScoring = null;
-          this.setState({
-            scoreResult
-          });
-        }
-      });
-    }
-
-    return /*#__PURE__*/React.createElement(Popover, _extends({
-      visible: passwordMeterVisible && !!value,
-      target: target,
-      targetRef: this.targetRef,
-      placement: "bottom-right",
-      intent: intent,
-      canCloseOnOutsideClick: false,
-      canCloseOnEscapePress: false,
-      onClose: this.handleClosePasswordMeter
-    }, passwordMeterProps), /*#__PURE__*/React.createElement(Translate, {
-      content: "FormFieldPassword.passwordStrength",
-      fallback: locale.passwordStrength,
-      params: {
-        strength: /*#__PURE__*/React.createElement("b", null, strength)
-      }
-    }), /*#__PURE__*/React.createElement("br", null), unusedRules.length ? /*#__PURE__*/React.createElement(Fragment, null, /*#__PURE__*/React.createElement(Translate, {
-      content: "FormFieldPassword.improvePassword",
-      fallback: locale.improvePassword
-    }), /*#__PURE__*/React.createElement("br", null), /*#__PURE__*/React.createElement("ul", null, unusedRules.slice(0, 3).map(({
-      rule
-    }, index) => {
-      const {
-        name
-      } = rule;
-      let {
-        message
-      } = rule;
-
-      if (name && !message) {
-        message = /*#__PURE__*/React.createElement(Translate, {
-          content: `FormFieldPassword.${name}`,
-          fallback: locale[name]
-        });
-      }
-
-      return /*#__PURE__*/React.createElement("li", {
-        key: name || index.toString()
-      }, message);
-    }))) : /*#__PURE__*/React.createElement(Translate, {
-      content: "FormFieldPassword.yourPasswordIsStrong",
-      fallback: locale.yourPasswordIsStrong
-    }));
-  }
-
   renderGenerateButton({
     setValue,
     isDisabled
@@ -232,12 +85,15 @@ class FormFieldPassword extends Component {
       hideGenerateButton,
       hidePasswordMeter,
       passwordMeterProps,
-      passwordScoreRules,
       size,
       autoFocus,
       autoComplete,
       ...props
     } = this.props;
+    const {
+      visible,
+      passwordMeterVisible
+    } = this.state;
     return /*#__PURE__*/React.createElement(FormField, _extends({
       className: classNames(baseClassName, className)
     }, props), ({
@@ -247,18 +103,18 @@ class FormFieldPassword extends Component {
       setValue,
       isDisabled
     }) => {
+      const value = getValue('');
       const input = /*#__PURE__*/React.createElement(Input, {
         id: getId(),
         name: getName(),
-        type: this.state.visible ? 'text' : 'password',
-        value: getValue(''),
+        type: visible ? 'text' : 'password',
+        value: value,
         onChange: e => {
           setValue(e.target.value);
           this.setState({
             passwordMeterVisible: true
           });
         },
-        onFocus: this.handleFocus,
         onBlur: this.handleBlur,
         autoFocus: autoFocus,
         autoComplete: autoComplete,
@@ -267,8 +123,8 @@ class FormFieldPassword extends Component {
         suffix: hideShowButton ? null : /*#__PURE__*/React.createElement(Button, {
           className: `${baseClassName}__button--show`,
           onClick: this.handleToggleClick,
-          icon: this.state.visible ? 'visible' : 'invisible',
-          tooltip: this.state.visible ? /*#__PURE__*/React.createElement(Translate, {
+          icon: visible ? 'visible' : 'invisible',
+          tooltip: visible ? /*#__PURE__*/React.createElement(Translate, {
             content: "FormFieldPassword.hidePassword",
             fallback: locale.hidePassword
           }) : /*#__PURE__*/React.createElement(Translate, {
@@ -287,7 +143,12 @@ class FormFieldPassword extends Component {
         className: classNames(`${baseClassName}__control`, `${baseClassName}__control--${size}`)
       }, /*#__PURE__*/React.createElement("div", {
         className: classNames(`${baseClassName}__field`, `${baseClassName}__field--${size}`)
-      }, hidePasswordMeter ? input : this.renderPasswordMeter(getValue(), input)), hideGenerateButton ? null : this.renderGenerateButton({
+      }, hidePasswordMeter ? input : /*#__PURE__*/React.createElement(PasswordMeter, _extends({
+        value: value,
+        targetRef: this.targetRef,
+        visible: passwordMeterVisible && value !== '',
+        onClose: this.handleClosePasswordMeter
+      }, passwordMeterProps), input)), hideGenerateButton ? null : this.renderGenerateButton({
         setValue,
         isDisabled
       }));
@@ -296,87 +157,17 @@ class FormFieldPassword extends Component {
 
 }
 
-FormFieldPassword.propTypes = {
-  /**
-   * Is show button hidden?
-   * @since 0.0.59
-   */
-  hideShowButton: PropTypes.bool,
-
-  /**
-   * Is generate button hidden?
-   * @since 0.0.59
-   */
-  hideGenerateButton: PropTypes.bool,
-
-  /**
-   * Is password meter hidden?
-   * @since 0.0.59
-   */
-  hidePasswordMeter: PropTypes.bool,
-
-  /**
-   * Additional props for password meter. . See [Popover](#!/Popover) for more information.
-   * @since 1.5.6
-   */
-  passwordMeterProps: PropTypes.object,
-
-  /**
-   * A set of custom password score rules.
-   * @since 3.21.0
-   */
-  passwordScoreRules: PropTypes.arrayOf(PropTypes.shape({
-    name: PropTypes.string,
-    message: PropTypes.oneOfType([PropTypes.string, PropTypes.element]),
-    score: PropTypes.func.isRequired
-  })),
-
-  /**
-   * Size of the control
-   * @since 1.5.6
-   */
-  size: PropTypes.oneOf(['md', 'lg', 'xl', 'fill']),
-
-  /**
-   * The browser will automatically focus on the component upon rendering the screen
-   * @since 1.9.0
-   */
-  autoFocus: PropTypes.bool,
-
-  /**
-   * Prevent password autocompletion.
-   * @since 2.5.1
-   */
-  autoComplete: PropTypes.oneOf(['new-password']),
-
-  /**
-   * A render function for customizing the password generation button.
-   * @since 3.13.0
-   */
-  generateButton: PropTypes.func,
-
-  /**
-   * @ignore
-   */
-  className: PropTypes.string,
-
-  /**
-   * @ignore
-   */
-  baseClassName: PropTypes.string
-};
-FormFieldPassword.defaultProps = {
+_defineProperty(FormFieldPassword, "defaultProps", {
   hideShowButton: false,
   generateButton: undefined,
   hideGenerateButton: false,
   hidePasswordMeter: false,
   passwordMeterProps: {},
-  passwordScoreRules: undefined,
   size: 'md',
   autoFocus: undefined,
   autoComplete: undefined,
   className: undefined,
   baseClassName: `${CLS_PREFIX}form-field-password`
-};
-FormFieldPassword.PASSWORD_SCORE_RULES = PASSWORD_SCORE_RULES;
+});
+
 export default FormFieldPassword;

package/esm/components/FormFieldPassword/PasswordMeter.js

@@ -0,0 +1,61 @@
+import _extends from "@babel/runtime/helpers/extends";
+// Copyright 1999-2022. Plesk International GmbH. All rights reserved.
+import React, { Fragment, useState, useEffect } from 'react';
+import Popover from '../Popover';
+import Translate from '../Translate';
+import estimatePassword, { DEFAULT_RULES } from './estimatePassword';
+import locale from './locale/en-US';
+const strengthIntents = {
+  VeryWeak: 'danger',
+  Weak: 'danger',
+  Medium: 'warning',
+  Strong: 'success',
+  VeryStrong: 'success'
+};
+
+const PasswordMeter = ({
+  value,
+  visible,
+  onEstimate,
+  children,
+  ...props
+}) => {
+  const [result, setResult] = useState(null);
+  useEffect(() => {
+    if (!visible) {
+      return;
+    }
+
+    Promise.resolve(onEstimate ? onEstimate(value, estimatePassword, DEFAULT_RULES) : estimatePassword(value)).then(result => {
+      setResult(result);
+    });
+  }, [visible, value, onEstimate]);
+  return /*#__PURE__*/React.createElement(Popover, _extends({
+    visible: visible && result !== null,
+    target: children,
+    placement: "bottom-right",
+    intent: result ? strengthIntents[result.strength] : undefined,
+    canCloseOnOutsideClick: false,
+    canCloseOnEscapePress: false
+  }, props), result !== null && result !== void 0 && result.strength ? /*#__PURE__*/React.createElement(Translate, {
+    component: "div",
+    content: "FormFieldPassword.passwordStrength",
+    fallback: locale.passwordStrength,
+    params: {
+      strength: /*#__PURE__*/React.createElement("b", null, /*#__PURE__*/React.createElement(Translate, {
+        content: `FormFieldPassword.strength${result === null || result === void 0 ? void 0 : result.strength}`,
+        fallback: locale[`strength${result === null || result === void 0 ? void 0 : result.strength}`]
+      }))
+    }
+  }) : null, result !== null && result !== void 0 && result.suggestions.length ? /*#__PURE__*/React.createElement(Fragment, null, /*#__PURE__*/React.createElement(Translate, {
+    content: "FormFieldPassword.improvePassword",
+    fallback: locale.improvePassword
+  }), /*#__PURE__*/React.createElement("br", null), /*#__PURE__*/React.createElement("ul", null, result.suggestions.slice(0, 3).map((suggestion, index) => /*#__PURE__*/React.createElement("li", {
+    key: index.toString()
+  }, suggestion)))) : /*#__PURE__*/React.createElement(Translate, {
+    content: "FormFieldPassword.yourPasswordIsStrong",
+    fallback: locale.yourPasswordIsStrong
+  }));
+};
+
+export default PasswordMeter;

package/esm/components/FormFieldPassword/estimatePassword.js

@@ -0,0 +1,196 @@
+// Copyright 1999-2022. Plesk International GmbH. All rights reserved.
+import React from 'react';
+import Translate from '../Translate';
+import locale from './locale/en-US';
+const EXCLUSIONS = {
+  numbers1: 'numbers3',
+  specialChar1: 'specialChar2',
+  lettersLowerCase: 'comboUpperAndLower',
+  lettersUpperCase: 'comboUpperAndLower'
+};
+export const DEFAULT_RULES = [{
+  name: 'passwordTooShort',
+  suggestion: /*#__PURE__*/React.createElement(Translate, {
+    content: `FormFieldPassword.passwordTooShort`,
+    fallback: locale.passwordTooShort
+  }),
+
+  score(passwd) {
+    return passwd.length < 5 ? -1 : 0;
+  }
+
+}, {
+  name: 'passwordLength',
+
+  score(passwd) {
+    if (passwd.length < 5) {
+      return 3;
+    }
+
+    if (passwd.length > 4 && passwd.length < 8) {
+      return 6;
+    }
+
+    if (passwd.length > 7 && passwd.length < 16) {
+      return 12;
+    }
+
+    return 18;
+  }
+
+}, {
+  name: 'lettersLowerCase',
+  suggestion: /*#__PURE__*/React.createElement(Translate, {
+    content: `FormFieldPassword.lettersLowerCase`,
+    fallback: locale.lettersLowerCase
+  }),
+
+  score(passwd) {
+    // [verified] at least one lower case letter
+    return passwd.match(/[a-z]/) ? 1 : -1;
+  }
+
+}, {
+  name: 'lettersUpperCase',
+  suggestion: /*#__PURE__*/React.createElement(Translate, {
+    content: `FormFieldPassword.lettersUpperCase`,
+    fallback: locale.lettersUpperCase
+  }),
+
+  score(passwd) {
+    // [verified] at least one upper case letter
+    return passwd.match(/[A-Z]/) ? 5 : -1;
+  }
+
+}, {
+  name: 'numbers1',
+  suggestion: /*#__PURE__*/React.createElement(Translate, {
+    content: `FormFieldPassword.numbers1`,
+    fallback: locale.numbers1
+  }),
+
+  score(passwd) {
+    // [verified] at least one number
+    return passwd.match(/\d+/) ? 5 : -1;
+  }
+
+}, {
+  name: 'numbers3',
+  suggestion: /*#__PURE__*/React.createElement(Translate, {
+    content: `FormFieldPassword.numbers3`,
+    fallback: locale.numbers3
+  }),
+
+  score(passwd) {
+    // [verified] at least three numbers
+    return passwd.match(/(.*[0-9].*[0-9].*[0-9])/) ? 5 : -1;
+  }
+
+}, {
+  name: 'specialChar1',
+  suggestion: /*#__PURE__*/React.createElement(Translate, {
+    content: `FormFieldPassword.specialChar1`,
+    fallback: locale.specialChar1
+  }),
+
+  score(passwd) {
+    // [verified] at least one special character
+    return passwd.match(/[!@#$%^&*?_~]/) ? 5 : -1;
+  }
+
+}, {
+  name: 'specialChar2',
+  suggestion: /*#__PURE__*/React.createElement(Translate, {
+    content: `FormFieldPassword.specialChar2`,
+    fallback: locale.specialChar2
+  }),
+
+  score(passwd) {
+    // [verified] at least two special characters
+    return passwd.match(/(.*[!@#$%^&*?_~].*[!@#$%^&*?_~])/) ? 5 : -1;
+  }
+
+}, {
+  name: 'comboUpperAndLower',
+  suggestion: /*#__PURE__*/React.createElement(Translate, {
+    content: `FormFieldPassword.comboUpperAndLower`,
+    fallback: locale.comboUpperAndLower
+  }),
+
+  score(passwd) {
+    // [verified] both upper and lower case
+    return passwd.match(/([a-z].*[A-Z])|([A-Z].*[a-z])/) ? 2 : -1;
+  }
+
+}, {
+  name: 'comboLettersAndNumbers',
+  suggestion: /*#__PURE__*/React.createElement(Translate, {
+    content: `FormFieldPassword.comboLettersAndNumbers`,
+    fallback: locale.comboLettersAndNumbers
+  }),
+
+  score(passwd) {
+    // [verified] both letters and numbers
+    return passwd.match(/([a-zA-Z])/) && passwd.match(/([0-9])/) ? 2 : -1;
+  }
+
+}, {
+  name: 'comboLettersNumbersSpecial',
+  suggestion: /*#__PURE__*/React.createElement(Translate, {
+    content: `FormFieldPassword.comboLettersNumbersSpecial`,
+    fallback: locale.comboLettersNumbersSpecial
+  }),
+
+  score(passwd) {
+    // [verified] letters, numbers, and special characters
+    return passwd.match(/([a-zA-Z0-9].*[!@#$%^&*?_~])|([!@#$%^&*?_~].*[a-zA-Z0-9])/) ? 2 : -1;
+  }
+
+}];
+export default ((password, rules = DEFAULT_RULES) => {
+  let passwordScore = 0;
+  const suggestions = [];
+  const skippedRules = new Set();
+  rules.forEach(rule => {
+    const ruleScore = rule.score(password);
+
+    if (ruleScore >= 0) {
+      passwordScore += ruleScore;
+      return;
+    }
+
+    skippedRules.add(EXCLUSIONS[rule.name]);
+
+    if (!skippedRules.has(rule.name) && rule.suggestion) {
+      suggestions.push(rule.suggestion);
+    }
+  });
+  let strength;
+
+  switch (true) {
+    case passwordScore < 16:
+      strength = 'VeryWeak';
+      break;
+
+    case passwordScore < 25:
+      strength = 'Weak';
+      break;
+
+    case passwordScore < 35:
+      strength = 'Medium';
+      break;
+
+    case passwordScore < 45:
+      strength = 'Strong';
+      break;
+
+    default:
+      strength = 'VeryStrong';
+      break;
+  }
+
+  return {
+    strength,
+    suggestions
+  };
+});

package/esm/components/FormFieldPassword/generatePassword.js

@@ -0,0 +1,14 @@
+// Copyright 1999-2022. Plesk International GmbH. All rights reserved.
+const symbolClasses = {
+  upper: 'ABCDEFGHIJKLMNOPQRSTUVWXYZ',
+  lower: 'abcdefghijklmnopqrstuvwxyz',
+  number: '0123456789',
+  special: '!@#$%^&*?_~'
+};
+
+const generatePassword = () => {
+  const password = ['upper', 'upper', 'upper', 'lower', 'lower', 'lower', 'lower', 'lower', 'lower', 'lower', 'lower', 'number', 'number', 'number', 'special', 'special'];
+  return password.sort((a, b) => Math.floor(b.length * Math.random()) - Math.floor(a.length * Math.random())).map(symbolClass => symbolClasses[symbolClass][Math.floor(symbolClasses[symbolClass].length * Math.random())]).join('');
+};
+
+export default generatePassword;

package/esm/components/FormFieldPassword/index.js

@@ -1,2 +1,3 @@
-// Copyright 1999-2017. Plesk International GmbH. All rights reserved.
-export { default, generatePassword } from './FormFieldPassword';
+// Copyright 1999-2022. Plesk International GmbH. All rights reserved.
+export { default } from './FormFieldPassword';
+export { default as generatePassword } from './generatePassword';