@instructure/ui-editable 8.25.1-snapshot-10 → 8.25.1-snapshot-15

package/CHANGELOG.md

@@ -3,7 +3,7 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
-## [8.25.1-snapshot-10](https://github.com/instructure/instructure-ui/compare/v8.25.0...v8.25.1-snapshot-10) (2022-06-20)
+## [8.25.1-snapshot-15](https://github.com/instructure/instructure-ui/compare/v8.25.0...v8.25.1-snapshot-15) (2022-06-23)
 
 **Note:** Version bump only for package @instructure/ui-editable
 

package/es/Editable/index.js

@@ -32,26 +32,140 @@ import { propTypes, allowedProps } from './props';
 category: components
 experimental: true
 ---
+@tsProps
 **/
 class Editable extends Component {
-  static displayName = "Editable";
-  static propTypes = propTypes;
-  static allowedProps = allowedProps;
-  static defaultProps = {
-    readOnly: false,
-    children: null
-  };
-  state = {
-    showModeToggle: false,
-    valueOnEdit: null // the value when mode flips from view -> edit
-
-  };
-  _editorRef = null;
-  _editButtonRef = null;
-
-  constructor(props) {
-    super(props);
-    warn(props.readOnly ? props.mode === 'view' : true, '[Editable] When readOnly is true, mode must be "view"');
+  constructor(_props) {
+    var _this;
+
+    super(_props);
+    _this = this;
+    this.state = {
+      showModeToggle: false,
+      valueOnEdit: null // the value when mode flips from view -> edit
+
+    };
+    this._editorRef = null;
+    this._editButtonRef = null;
+
+    this.handleEditESC = event => {
+      if (event.key === 'Escape') {
+        this.enterView();
+      }
+    };
+
+    this.handleViewMouseOver = event => {
+      if (this.props.mode === 'view') {
+        // because the mouse event handlers are on the container, not the view
+        event.stopPropagation();
+        this.setState({
+          showModeToggle: true
+        });
+      }
+    };
+
+    this.handleViewMouseOut = event => {
+      if (this.props.mode === 'view') {
+        event.stopPropagation();
+        this.setState({
+          showModeToggle: document.activeElement === this._editButtonRef
+        });
+      }
+    };
+
+    this.handleViewClick = event => {
+      if (event.buttons === 1) {
+        requestAnimationFrame(() => {
+          this.enterEdit();
+        });
+      }
+    };
+
+    this.handleEditBlur = () => {
+      this.enterView();
+    };
+
+    this.handleEditButtonFocus = () => {
+      this.setState({
+        showModeToggle: true
+      });
+    };
+
+    this.handleEditButtonBlur = () => {
+      this.setState({
+        showModeToggle: false
+      });
+    };
+
+    this.handleEditButtonClick = () => {
+      this.enterEdit();
+    };
+
+    this.ref = null;
+
+    this.handleContainerRef = el => {
+      const elementRef = this.props.elementRef;
+      this.ref = el;
+
+      if (typeof elementRef === 'function') {
+        elementRef(el);
+      }
+    };
+
+    this.getContainerProps = function () {
+      let props = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {};
+      const _this$props = _this.props,
+            mode = _this$props.mode,
+            readOnly = _this$props.readOnly;
+      return {
+        onMouseOver: _this.handleViewMouseOver,
+        onMouseOut: _this.handleViewMouseOut,
+        onMouseDown: mode !== 'edit' ? _this.handleViewClick : void 0,
+        onKeyUp: mode === 'edit' ? _this.handleEditESC : void 0,
+        readOnly,
+        ...props,
+        ref: _this.handleContainerRef
+      };
+    };
+
+    this.getViewerProps = function () {
+      let props = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {};
+      return {
+        mode: _this.props.mode,
+        readOnly: _this.props.readOnly,
+        ...props
+      };
+    };
+
+    this.getEditorProps = function () {
+      let props = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {};
+      return {
+        mode: _this.props.mode,
+        onBlur: _this.handleEditBlur,
+        editorRef: el => {
+          _this._editorRef = el;
+        },
+        readOnly: _this.props.readOnly,
+        ...props
+      };
+    };
+
+    this.getEditButtonProps = function () {
+      let props = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {};
+      return {
+        onClick: _this.handleEditButtonClick,
+        onFocus: _this.handleEditButtonFocus,
+        onBlur: _this.handleEditButtonBlur,
+        isVisible: _this.state.showModeToggle,
+        buttonRef: el => {
+          _this._editButtonRef = el;
+        },
+        readOnly: _this.props.readOnly,
+        ...props
+      };
+    };
+
+    warn(_props.readOnly ? _props.mode === 'view' : true, '[Editable] When readOnly is true, mode must be "view"');
   }
 
   componentDidMount() {
@@ -60,13 +174,11 @@ class Editable extends Component {
     }
   }
 
-  componentWillUnmount() {}
-
   componentDidUpdate(prevProps) {
-    const _this$props = this.props,
-          mode = _this$props.mode,
-          value = _this$props.value,
-          onChange = _this$props.onChange; // on the switch from view -> edit
+    const _this$props2 = this.props,
+          mode = _this$props2.mode,
+          value = _this$props2.value,
+          onChange = _this$props2.onChange; // on the switch from view -> edit
 
     if (prevProps.mode !== 'edit' && mode === 'edit') {
       this.setState({
@@ -114,122 +226,6 @@ class Editable extends Component {
     }
   }
 
-  handleEditESC = event => {
-    if (event.key === 'Escape') {
-      this.enterView();
-    }
-  };
-  handleViewMouseOver = event => {
-    if (this.props.mode === 'view') {
-      // because the mouse event handlers are on the container, not the view
-      event.stopPropagation();
-      this.setState({
-        showModeToggle: true
-      });
-    }
-  };
-  handleViewMouseOut = event => {
-    if (this.props.mode === 'view') {
-      event.stopPropagation();
-      this.setState({
-        showModeToggle: document.activeElement === this._editButtonRef
-      });
-    }
-  };
-  handleViewClick = event => {
-    if (event.buttons === 1) {
-      requestAnimationFrame(() => {
-        this.enterEdit();
-      });
-    }
-  };
-  handleEditBlur = event => {
-    this.enterView();
-  };
-  handleEditButtonFocus = event => {
-    this.setState({
-      showModeToggle: true
-    });
-  };
-  handleEditButtonBlur = event => {
-    this.setState({
-      showModeToggle: false
-    });
-  };
-  handleEditButtonClick = event => {
-    this.enterEdit();
-  };
-  ref = null;
-  handleContainerRef = el => {
-    const elementRef = this.props.elementRef;
-    this.ref = el;
-
-    if (typeof elementRef === 'function') {
-      elementRef(el);
-    }
-  }; // ------- prop getters ------
-
-  getContainerProps = (() => {
-    var _this = this;
-
-    return function () {
-      let props = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {};
-      const _this$props2 = _this.props,
-            mode = _this$props2.mode,
-            readOnly = _this$props2.readOnly;
-      return {
-        onMouseOver: _this.handleViewMouseOver,
-        onMouseOut: _this.handleViewMouseOut,
-        onMouseDown: mode !== 'edit' ? _this.handleViewClick : null,
-        onKeyUp: mode === 'edit' ? _this.handleEditESC : null,
-        readOnly,
-        ...props,
-        ref: _this.handleContainerRef
-      };
-    };
-  })();
-  getViewerProps = (() => {
-    var _this2 = this;
-
-    return function () {
-      let props = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {};
-      return {
-        mode: _this2.props.mode,
-        readOnly: _this2.props.readOnly,
-        ...props
-      };
-    };
-  })();
-  getEditorProps = props => {
-    return {
-      mode: this.props.mode,
-      onBlur: this.handleEditBlur,
-      editorRef: el => {
-        this._editorRef = el;
-      },
-      readOnly: this.props.readOnly,
-      ...props
-    };
-  };
-  getEditButtonProps = (() => {
-    var _this3 = this;
-
-    return function () {
-      let props = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {};
-      return {
-        onClick: _this3.handleEditButtonClick,
-        onFocus: _this3.handleEditButtonFocus,
-        onBlur: _this3.handleEditButtonBlur,
-        isVisible: _this3.state.showModeToggle,
-        buttonRef: el => {
-          _this3._editButtonRef = el;
-        },
-        readOnly: _this3.props.readOnly,
-        ...props
-      };
-    };
-  })();
-
   render() {
     const _this$props3 = this.props,
           children = _this$props3.children,
@@ -252,5 +248,12 @@ class Editable extends Component {
 
 }
 
+Editable.displayName = "Editable";
+Editable.propTypes = propTypes;
+Editable.allowedProps = allowedProps;
+Editable.defaultProps = {
+  readOnly: false,
+  children: null
+};
 export default Editable;
 export { Editable };

package/es/Editable/props.js

@@ -23,53 +23,13 @@
  */
 import PropTypes from 'prop-types';
 const propTypes = {
-  /**
-   * If `'view'`: the view component is rendered,
-   * if `'edit'`: the edit component is rendered
-   */
   mode: PropTypes.oneOf(['view', 'edit']).isRequired,
-
-  /**
-   * Called when the component's mode changes
-   * @param {string} new_mode
-   */
   onChangeMode: PropTypes.func.isRequired,
-
-  /**
-   * @param {Object} renderProps
-   * @param {Boolean} mode
-   * @param {Function} renderProps.getContainerProps - Props to be spread onto the container element
-   * @param {Function} renderProps.getEditorProps - Props to be spread onto the editor element
-   * @param {Function} renderProps.getEditButtonProps - Props to be spread onto the edit button element
-   */
   children: PropTypes.func,
-
-  /**
-   * Identical to children
-   */
   render: PropTypes.func,
-
-  /**
-   * The current value.
-   * The value is managed by the consuming app, but we need to tell Editable
-   * it's changed or it won't re-render
-   */
   value: PropTypes.any,
-
-  /**
-   * Called when Editable switches from edit to view mode and the value has changed.
-   * @param {any} value
-   */
   onChange: PropTypes.func,
-
-  /**
-   * The mode is fixed as 'view'
-   */
   readOnly: PropTypes.bool,
-
-  /**
-   * provides a reference to the underlying html root element (container)
-   */
   elementRef: PropTypes.func
 };
 const allowedProps = ['mode', 'onChangeMode', 'children', 'render', 'value', 'onChange', 'readOnly', 'elementRef'];

package/es/InPlaceEdit/index.js

@@ -2,7 +2,7 @@ import _objectWithoutProperties from "@babel/runtime/helpers/esm/objectWithoutPr
 const _excluded = ["buttonRef"],
       _excluded2 = ["isVisible", "readOnly", "label"];
 
-var _dec, _class;
+var _dec, _class, _class2;
 
 /*
  * The MIT License (MIT)
@@ -45,50 +45,67 @@ import { propTypes, allowedProps } from './props';
 ---
 category: components
 ---
+@tsProps
 **/
-let InPlaceEdit = (_dec = withStyle(generateStyle, null), _dec(_class = class InPlaceEdit extends Component {
-  static displayName = "InPlaceEdit";
-  static componentId = 'InPlaceEdit';
-  static propTypes = propTypes;
-  static allowedProps = allowedProps;
-  static defaultProps = {
-    readOnly: false,
-    showFocusRing: true,
-    inline: true,
-    editButtonPlacement: 'end'
-  };
-  ref = null;
-  handleRef = el => {
-    this.ref = el;
-  };
-
+let InPlaceEdit = (_dec = withStyle(generateStyle, null), _dec(_class = (_class2 = class InPlaceEdit extends Component {
   constructor(props) {
     super(props);
+    this.ref = null;
+    this._editButtonRef = null;
+
+    this.handleRef = el => {
+      this.ref = el;
+    };
+
+    this.handleEditButtonRef = el => {
+      this._editButtonRef = el;
+    };
+
+    this.renderAll = _ref => {
+      let getContainerProps = _ref.getContainerProps,
+          getViewerProps = _ref.getViewerProps,
+          getEditorProps = _ref.getEditorProps,
+          getEditButtonProps = _ref.getEditButtonProps;
+      const flexDir = this.props.editButtonPlacement === 'start' ? 'row-reverse' : 'row';
+      const justifyItems = flexDir === 'row-reverse' ? 'end' : 'start';
+      const buttonMargin = this.props.editButtonPlacement === 'start' ? '0 xx-small 0 0' : '0 0 0 xx-small';
+      return jsx(Flex, Object.assign({
+        display: this.props.inline ? 'inline-flex' : 'flex',
+        direction: flexDir,
+        justifyItems: justifyItems
+      }, getContainerProps()), jsx(Flex.Item, {
+        shouldGrow: true,
+        shouldShrink: true
+      }, this.renderEditor(getEditorProps()), this.renderViewer(getViewerProps())), jsx(Flex.Item, {
+        margin: buttonMargin
+      }, this.renderEditButton(getEditButtonProps())));
+    };
+
     warn(props.readOnly ? props.mode === 'view' : true, '[InPlaceEdit] When readOnly is true, mode is forced to "view"');
   }
 
   componentDidMount() {
-    this.props.makeStyles();
-  }
+    var _this$props$makeStyle, _this$props;
 
-  componentDidUpdate(prevProps, prevState, snapshot) {
-    this.props.makeStyles();
+    (_this$props$makeStyle = (_this$props = this.props).makeStyles) === null || _this$props$makeStyle === void 0 ? void 0 : _this$props$makeStyle.call(_this$props);
   }
 
-  handleEditButtonRef = el => {
-    this._editButtonRef = el;
-  };
+  componentDidUpdate() {
+    var _this$props$makeStyle2, _this$props2;
+
+    (_this$props$makeStyle2 = (_this$props2 = this.props).makeStyles) === null || _this$props$makeStyle2 === void 0 ? void 0 : _this$props$makeStyle2.call(_this$props2);
+  }
 
-  renderEditor(_ref) {
+  renderEditor(_ref2) {
     var _this$props$styles;
 
-    let mode = _ref.mode,
-        onBlur = _ref.onBlur,
-        editorRef = _ref.editorRef,
-        readOnly = _ref.readOnly;
-    const _this$props = this.props,
-          showFocusRing = _this$props.showFocusRing,
-          renderEditor = _this$props.renderEditor;
+    let mode = _ref2.mode,
+        onBlur = _ref2.onBlur,
+        editorRef = _ref2.editorRef,
+        readOnly = _ref2.readOnly;
+    const _this$props3 = this.props,
+          showFocusRing = _this$props3.showFocusRing,
+          renderEditor = _this$props3.renderEditor;
     const isEditMode = !readOnly && mode === 'edit';
     return isEditMode ? jsx(View, {
       as: "span",
@@ -104,15 +121,15 @@ let InPlaceEdit = (_dec = withStyle(generateStyle, null), _dec(_class = class In
     })) : null;
   }
 
-  renderViewer(_ref2) {
-    let readOnly = _ref2.readOnly,
-        mode = _ref2.mode;
+  renderViewer(_ref3) {
+    let readOnly = _ref3.readOnly,
+        mode = _ref3.mode;
     return readOnly || mode === 'view' ? this.props.renderViewer() : null;
   }
 
-  renderEditButton(_ref3) {
-    let buttonRef = _ref3.buttonRef,
-        rest = _objectWithoutProperties(_ref3, _excluded);
+  renderEditButton(_ref4) {
+    let buttonRef = _ref4.buttonRef,
+        rest = _objectWithoutProperties(_ref4, _excluded);
 
     return this.props.renderEditButton({
       elementRef: createChainedFunction(this.handleEditButtonRef, buttonRef),
@@ -122,50 +139,13 @@ let InPlaceEdit = (_dec = withStyle(generateStyle, null), _dec(_class = class In
   // the margin makes room for the focus ring
 
 
-  static renderDefaultEditButton = _ref4 => {
-    let isVisible = _ref4.isVisible,
-        readOnly = _ref4.readOnly,
-        label = _ref4.label,
-        buttonProps = _objectWithoutProperties(_ref4, _excluded2);
-
-    if (readOnly) {
-      return null;
-    }
-
-    return jsx(IconButton, Object.assign({
-      size: "small",
-      screenReaderLabel: label,
-      withBackground: false,
-      withBorder: false
-    }, buttonProps), isVisible ? IconEditLine : null);
-  };
-  renderAll = _ref5 => {
-    let getContainerProps = _ref5.getContainerProps,
-        getViewerProps = _ref5.getViewerProps,
-        getEditorProps = _ref5.getEditorProps,
-        getEditButtonProps = _ref5.getEditButtonProps;
-    const flexDir = this.props.editButtonPlacement === 'start' ? 'row-reverse' : 'row';
-    const justifyItems = flexDir === 'row-reverse' ? 'end' : 'start';
-    const buttonMargin = this.props.editButtonPlacement === 'start' ? '0 xx-small 0 0' : '0 0 0 xx-small';
-    return jsx(Flex, Object.assign({
-      display: this.props.inline ? 'inline-flex' : 'flex',
-      direction: flexDir,
-      justifyItems: justifyItems
-    }, getContainerProps()), jsx(Flex.Item, {
-      shouldGrow: true,
-      shouldShrink: true
-    }, this.renderEditor(getEditorProps()), this.renderViewer(getViewerProps())), jsx(Flex.Item, {
-      margin: buttonMargin
-    }, this.renderEditButton(getEditButtonProps())));
-  };
-
   render() {
-    const _this$props2 = this.props,
-          mode = _this$props2.mode,
-          value = _this$props2.value,
-          onChange = _this$props2.onChange,
-          onChangeMode = _this$props2.onChangeMode,
-          readOnly = _this$props2.readOnly;
+    const _this$props4 = this.props,
+          mode = _this$props4.mode,
+          value = _this$props4.value,
+          onChange = _this$props4.onChange,
+          onChangeMode = _this$props4.onChangeMode,
+          readOnly = _this$props4.readOnly;
     return jsx(Editable, {
       mode: mode,
       onChangeMode: onChangeMode,
@@ -177,6 +157,27 @@ let InPlaceEdit = (_dec = withStyle(generateStyle, null), _dec(_class = class In
     });
   }
 
-}) || _class);
+}, _class2.displayName = "InPlaceEdit", _class2.componentId = 'InPlaceEdit', _class2.propTypes = propTypes, _class2.allowedProps = allowedProps, _class2.defaultProps = {
+  readOnly: false,
+  showFocusRing: true,
+  inline: true,
+  editButtonPlacement: 'end'
+}, _class2.renderDefaultEditButton = _ref5 => {
+  let isVisible = _ref5.isVisible,
+      readOnly = _ref5.readOnly,
+      label = _ref5.label,
+      buttonProps = _objectWithoutProperties(_ref5, _excluded2);
+
+  if (readOnly) {
+    return null;
+  }
+
+  return jsx(IconButton, Object.assign({
+    size: "small",
+    screenReaderLabel: label,
+    withBackground: false,
+    withBorder: false
+  }, buttonProps), isVisible ? IconEditLine : null);
+}, _class2)) || _class);
 export default InPlaceEdit;
 export { InPlaceEdit };

package/es/InPlaceEdit/props.js

@@ -23,86 +23,16 @@
  */
 import PropTypes from 'prop-types';
 const propTypes = {
-  /**
-   * Function to render the view mode component.
-   * It is the consumer's responsibility to provide the
-   * current value or children.
-   *
-   * @returns {element} the viewer DOM sub-tree.
-   */
   renderViewer: PropTypes.func.isRequired,
-
-  /**
-   * Function to render the edit mode component
-   * It is the consumer's responsibility to provide the
-   * current value, and to attach the appropriate onChange
-   * event handler needed to capture the updated value. This
-   * new value must then be forwarded to the view mode component.
-   *
-   * @returns {element} the editor DOM sub-tree.
-   */
   renderEditor: PropTypes.func.isRequired,
-
-  /**
-   * Function to render the edit button.
-   *
-   * @param {Object} { isVisible, onClick, onFocus, onBlur, buttonRef }
-   * @returns {element} the edit button DOM sub-tree
-   *
-   * If you choose to use the default edit button, add `label` to the
-   * incoming `props` parameter and call `InPlaceEdit.renderDefaultEditButton(props)`
-   *
-   * If you choose to render a custom button, attach the on* event handlers
-   * and set `buttonRef` as a `ref` type property on the `button` element.
-   *
-   * `isVisible` is a hint as to whether the button is _typically_ shown,
-   * but you're free to ignore it for your use-case.
-   */
   renderEditButton: PropTypes.func.isRequired,
-
-  /**
-   * If `'view'`: the view component is rendered,
-   * if `'edit'`: the edit component is rendered
-   */
   mode: PropTypes.oneOf(['view', 'edit']).isRequired,
-
-  /**
-   * Called when the component's mode changes
-   * @param {string} newMode
-   */
   onChangeMode: PropTypes.func.isRequired,
-
-  /**
-   * The current value.
-   * The value is managed by the consuming app, but we need to tell InPlaceEdit
-   * it's changed or it won't re-render
-   */
   value: PropTypes.any,
-
-  /**
-   * Called when Editable switches from edit to view mode and the value has changed.
-   * @param {any} value
-   */
   onChange: PropTypes.func,
-
-  /**
-   * The mode is fixed as 'view'
-   */
   readOnly: PropTypes.bool,
-
-  /**
-   * Show a focus outline when the input is focused
-   */
   showFocusRing: PropTypes.bool,
-
-  /**
-   * Put the edit button before or after the view
-   */
   editButtonPlacement: PropTypes.oneOf(['start', 'end']),
-
-  /**
-   * Render outermost element inline v. block
-   */
   inline: PropTypes.bool
 };
 const allowedProps = ['renderViewer', 'renderEditor', 'renderEditButton', 'mode', 'onChangeMode', 'value', 'onChange', 'readOnly', 'showFocusRing', 'editButtonPlacement', 'inline'];