@pie-lib/mask-markup 1.13.47-next.1 → 1.13.47-next.1639

package/src/components/dropdown.jsx

@@ -1,10 +1,18 @@
 import React from 'react';
 import PropTypes from 'prop-types';
-import Select from '@material-ui/core/Select';
+import Button from '@material-ui/core/Button';
+import InputLabel from '@material-ui/core/InputLabel';
+import Menu from '@material-ui/core/Menu';
 import MenuItem from '@material-ui/core/MenuItem';
-import CorrectInput from './correct-input';
+import ArrowDropDownIcon from '@material-ui/icons/ArrowDropDown';
+import ArrowDropUpIcon from '@material-ui/icons/ArrowDropUp';
+import Close from '@material-ui/icons/Close';
+import Check from '@material-ui/icons/Check';
 import { withStyles } from '@material-ui/core/styles';
+import classNames from 'classnames';
+
 import { color } from '@pie-lib/render-ui';
+import { renderMath } from '@pie-lib/math-rendering';
 
 class Dropdown extends React.Component {
   static propTypes = {
@@ -16,79 +24,253 @@ class Dropdown extends React.Component {
     correct: PropTypes.bool,
     choices: PropTypes.arrayOf(PropTypes.shape({ value: PropTypes.string, label: PropTypes.string })),
     showCorrectAnswer: PropTypes.bool,
+    singleQuery: PropTypes.bool,
+    correctValue: PropTypes.string,
   };
 
   constructor(props) {
     super(props);
 
     this.state = {
-      showCheckmark: false,
-      open: false,
+      anchorEl: null,
+      highlightedOptionId: null,
+      menuWidth: null,
+      previewValue: null,
     };
+    this.hiddenRef = React.createRef();
+    this.buttonRef = React.createRef();
+    this.previewRef = React.createRef();
+    this.elementRefs = [];
   }
 
-  showCheckmarkAndOpen = () => {
-    this.setState({
-      showCheckmark: true,
-      open: true,
-    });
+  componentDidMount() {
+    // measure hidden menu width once
+    if (this.hiddenRef.current && this.state.menuWidth === null) {
+      this.setState({ menuWidth: this.hiddenRef.current.clientWidth });
+    }
+  }
+
+  componentDidUpdate(prevProps, prevState) {
+    const hiddenEl = this.hiddenRef.current;
+
+    const dropdownJustOpened = !prevState.anchorEl && this.state.anchorEl;
+    if (dropdownJustOpened) {
+      this.elementRefs.forEach((ref) => {
+        if (!ref) return;
+
+        const containsLatex = ref.querySelector('[data-latex], [data-raw]');
+        const hasMathJax = ref.querySelector('mjx-container');
+        const mathHandled = ref.querySelector('[data-math-handled="true"]');
+
+        if (containsLatex && (!mathHandled || !hasMathJax)) {
+          renderMath(ref);
+        }
+      });
+    }
+
+    if (hiddenEl) {
+      const newWidth = hiddenEl.clientWidth;
+      if (newWidth !== this.state.menuWidth) {
+        this.elementRefs.forEach((ref) => {
+          if (ref) renderMath(ref);
+        });
+
+        renderMath(hiddenEl);
+        this.setState({ menuWidth: newWidth });
+      }
+    }
+  }
+
+  handleClick = (event) => this.setState({ anchorEl: event.currentTarget });
+
+  handleClose = () => {
+    const { value } = this.props;
+    this.setState({ anchorEl: null, previewValue: null, highlightedOptionId: null });
+    // clear displayed preview if no selection
+    if (!value && this.previewRef.current) {
+      this.previewRef.current.innerHTML = '';
+    }
   };
 
-  hideCheckmarkAndClose = () => {
-    this.setState({
-      showCheckmark: false,
-      open: false,
+  handleHighlight = (index) => {
+    const highlightedOptionId = `dropdown-option-${this.props.id}-${index}`;
+
+    // preview on hover if nothing selected
+    const stateUpdate = { highlightedOptionId };
+    if (!this.props.value) {
+      stateUpdate.previewValue = this.props.choices[index].value;
+    }
+    this.setState(stateUpdate);
+  };
+
+  handleSelect = (value, index) => {
+    this.props.onChange(this.props.id, value);
+    this.handleHighlight(index);
+    this.handleClose();
+  };
+
+  handleHover = (index) => {
+    const selectedValue = this.props.value;
+
+    if (selectedValue) return;
+
+    const highlightedOptionId = `dropdown-option-${this.props.id}-${index}`;
+    const previewValue = this.state.previewValue;
+
+    this.setState({ highlightedOptionId, previewValue }, () => {
+      // On hover, preview the math-rendered content inside the button if no value is selected.
+      const ref = this.elementRefs[index];
+      const preview = this.previewRef.current;
+
+      if (ref && preview) {
+        preview.innerHTML = ref.innerHTML;
+      }
     });
   };
 
+  getLabel(choices, value) {
+    const found = (choices || []).find((choice) => choice.value === value);
+
+    return found ? found.label.trim() : undefined;
+  }
+
   render() {
-    const { classes, id, correct, disabled, value, onChange, choices, showCorrectAnswer } = this.props;
+    const { classes, id, correct, disabled, value, choices, showCorrectAnswer, singleQuery, correctValue } = this.props;
+    const { anchorEl } = this.state;
+    const open = Boolean(anchorEl);
+    const buttonId = `dropdown-button-${id}`;
+    const menuId = `dropdown-menu-${id}`;
+    const valueDisplayId = `dropdown-value-${id}`;
+
+    // Determine the class for disabled state, view mode and evaluate mode
+    let disabledClass;
+    // Reset elementRefs before each render to avoid stale references
+    this.elementRefs = [];
 
-    const { showCheckmark, open } = this.state;
+    if (disabled && correct !== undefined) {
+      disabledClass = correct || showCorrectAnswer ? classes.disabledCorrect : classes.disabledIncorrect;
+    }
+
+    // Create distinct, visually hidden labels for each dropdown
+    const incrementedId = parseInt(id, 10) + 1;
+    const labelId = singleQuery ? 'Query-label' : `Query-label-${incrementedId}`;
+    const labelText = singleQuery ? 'Query' : `Query ${incrementedId}`;
+
+    // Changed from Select to Button for dropdown to enhance accessibility. This modification offers explicit control over aria attributes and focuses management, ensuring the dropdown is compliant with accessibility standards. The use of Button and Menu components allows for better handling of keyboard interactions and provides accessible labels and menus, aligning with WCAG guidelines and improving usability for assistive technology users.
+    let correctnessIcon = null;
+    if (disabled && correct !== undefined) {
+      correctnessIcon =
+        correct || showCorrectAnswer ? (
+          <Check className={classNames(classes.correctnessIndicatorIcon, classes.correctIcon)} />
+        ) : (
+          <Close className={classNames(classes.correctnessIndicatorIcon, classes.incorrectIcon)} />
+        );
+    }
 
     return (
-      <Select
-        classes={{
-          root: classes.root,
-          icon: classes.icon,
-          selectMenu: classes.selectMenu,
-          select: classes.select,
-        }}
-        disabled={disabled}
-        value={value || ''}
-        onOpen={this.showCheckmarkAndOpen}
-        onClose={this.hideCheckmarkAndClose}
-        open={open}
-        input={<CorrectInput correct={showCorrectAnswer || correct} />}
-        MenuProps={{
-          keepMounted: true,
-          disablePortal: true,
-        }}
-        onChange={(e) => {
-          onChange(id, e.target.value);
-        }}
-      >
-        {(choices || []).map((c, index) => (
-          <MenuItem
-            classes={{ root: classes.menuRoot, selected: classes.selected }}
-            key={`${c.label}-${index}`}
-            value={c.value}
-          >
-            <span
-              className={classes.label}
-              dangerouslySetInnerHTML={{
-                __html: c.label,
-              }}
-            />
-            {showCheckmark && (
-              <span
-                className={classes.label}
-                dangerouslySetInnerHTML={{ __html: c.value === value ? ' &check;' : '' }}
-              />
-            )}
-          </MenuItem>
-        ))}
-      </Select>
+      <>
+        <div
+          ref={this.hiddenRef}
+          style={{ position: 'absolute', visibility: 'hidden', top: 0, left: 0 }}
+          tabIndex={-1}
+          aria-hidden="true"
+        >
+          {(choices || []).map((c, index) => (
+            <MenuItem
+              key={index}
+              classes={{ root: classes.menuRoot, selected: classes.selected }}
+              tabIndex={-1}
+              aria-hidden="true"
+            >
+              <span className={classes.label} dangerouslySetInnerHTML={{ __html: c.label }} />
+            </MenuItem>
+          ))}
+        </div>
+        <InputLabel className={classes.srOnly} id={labelId} tabIndex={-1} aria-hidden="true">
+          {labelText}
+        </InputLabel>
+        <Button
+          ref={this.buttonRef}
+          style={{
+            ...(this.state.menuWidth && { minWidth: `calc(${this.state.menuWidth}px + 8px)` }),
+            borderWidth: open ? '2px' : '1px',
+            transition: 'border-width 0.2s ease-in-out',
+          }}
+          aria-controls={open ? menuId : undefined}
+          aria-haspopup="listbox"
+          aria-expanded={open ? 'true' : undefined}
+          aria-activedescendant={this.state.highlightedOptionId}
+          onClick={this.handleClick}
+          classes={{
+            root: classes.root,
+            disabled: disabledClass,
+          }}
+          disabled={disabled}
+          id={buttonId}
+          role="combobox"
+          aria-label={`Select an option for ${labelText}`}
+          aria-labelledby={valueDisplayId}
+        >
+          {correctnessIcon}
+          <span
+            id={valueDisplayId}
+            ref={this.previewRef}
+            className={classes.label}
+            dangerouslySetInnerHTML={{
+              __html: correctValue
+                ? correctValue
+                : open && this.state.previewValue
+                ? this.getLabel(choices, this.state.previewValue)
+                : this.getLabel(choices, value) || '',
+            }}
+          />
+          {open ? <ArrowDropUpIcon /> : <ArrowDropDownIcon />}
+        </Button>
+        <Menu
+          id={menuId}
+          anchorEl={anchorEl}
+          className={classes.selectMenu}
+          keepMounted
+          open={open}
+          onClose={this.handleClose}
+          getContentAnchorEl={null}
+          anchorOrigin={{ vertical: 'bottom', horizontal: 'left' }}
+          transformOrigin={{ vertical: 'top', horizontal: 'left' }}
+          PaperProps={this.state.menuWidth ? { style: { minWidth: this.state.menuWidth, padding: '4px' } } : undefined}
+          MenuListProps={{
+            'aria-labelledby': buttonId,
+            role: 'listbox',
+            disablePadding: true,
+          }}
+        >
+          {(choices || []).map((c, index) => {
+            const optionId = `dropdown-option-${id}-${index}`;
+
+            return (
+              <MenuItem
+                id={optionId}
+                classes={{ root: classes.menuRoot, selected: classes.selected }}
+                key={`${c.label}-${index}`}
+                value={c.value}
+                onClick={() => this.handleSelect(c.value, index)}
+                role="option"
+                aria-selected={this.state.highlightedOptionId === optionId ? 'true' : undefined}
+                onMouseOver={() => this.handleHover(index)}
+              >
+                <span
+                  ref={(ref) => (this.elementRefs[index] = ref)}
+                  className={classes.label}
+                  dangerouslySetInnerHTML={{ __html: c.label }}
+                />
+                <span
+                  className={classes.selectedIndicator}
+                  dangerouslySetInnerHTML={{ __html: c.value === value ? ' &check;' : '' }}
+                />
+              </MenuItem>
+            );
+          })}
+        </Menu>
+      </>
     );
   }
 }
@@ -96,65 +278,117 @@ class Dropdown extends React.Component {
 const styles = () => ({
   root: {
     color: color.text(),
+    border: `1px solid ${color.borderGray()}`,
+    borderRadius: '4px',
+    justifyContent: 'space-between',
     backgroundColor: color.background(),
-    borderColor: color.secondaryLight(),
-    '& ul': {
-      paddingTop: 0,
-      paddingBottom: 0,
-      border: `1px solid ${color.text()}`,
-      borderRadius: '5px',
+    position: 'relative',
+    height: '45px',
+    width: 'fit-content',
+    margin: '2px',
+    textTransform: 'none',
+    '& span': {
+      paddingRight: '5px',
+    },
+    '& svg': {
+      position: 'absolute',
+      right: 0,
+      top: 'calc(50% - 12px)',
+      pointerEvents: 'none',
       color: color.text(),
-      backgroundColor: color.background(),
+      marginLeft: '5px',
     },
-  },
-  select: {
-    '&:focus': {
-      borderRadius: '4px',
+    '&:focus, &:focus-visible': {
+      outline: `3px solid ${color.tertiary()}`,
+      outlineOffset: '2px',
+      borderWidth: '3px',
     },
   },
+  disabledCorrect: {
+    borderWidth: '2px',
+    borderColor: color.correct(),
+    color: `${color.text()} !important`,
+  },
+  disabledIncorrect: {
+    borderWidth: '2px',
+    borderColor: color.incorrectWithIcon(),
+    color: `${color.text()} !important`,
+  },
   selectMenu: {
     backgroundColor: color.background(),
+    border: `1px solid ${color.correct()} !important`,
     '&:hover': {
+      border: `1px solid ${color.text()} `,
       borderColor: 'initial',
     },
     '&:focus': {
+      border: `1px solid ${color.text()}`,
       borderColor: 'initial',
     },
-  },
-  icon: {
-    color: color.text(),
+    // remove default padding on the inner list
+    '& .MuiList-root': {
+      padding: 0,
+    },
   },
   selected: {
     color: `${color.text()} !important`,
     backgroundColor: `${color.background()} !important`,
     '&:hover': {
       color: color.text(),
-      backgroundColor: `${color.secondaryLight()} !important`,
+      backgroundColor: `${color.dropdownBackground()} !important`,
     },
   },
   menuRoot: {
     color: color.text(),
     backgroundColor: color.background(),
+    '&:focus, &:focus-visible': {
+      outline: `3px solid ${color.tertiary()}`,
+      outlineOffset: '-1px', // keeps it inside the item
+    },
     '&:focus': {
       color: color.text(),
       backgroundColor: color.background(),
     },
     '&:hover': {
       color: color.text(),
-      backgroundColor: color.secondaryLight(),
+      backgroundColor: color.dropdownBackground(),
     },
     boxSizing: 'border-box',
     padding: '25px',
-    '&:first-of-type': {
-      borderRadius: '3px 3px 0 0',
-    },
-    '&:last-of-type': {
-      borderRadius: '0 0 3px 3px',
-    },
+    borderRadius: '4px',
   },
   label: {
     fontSize: 'max(1rem, 14px)',
   },
+  selectedIndicator: {
+    fontSize: 'max(1rem, 14px)',
+    position: 'absolute',
+    right: '10px',
+  },
+  srOnly: {
+    position: 'absolute',
+    left: '-10000px',
+    top: 'auto',
+    width: '1px',
+    height: '1px',
+    overflow: 'hidden',
+  },
+  correctnessIndicatorIcon: {
+    color: `${color.white()} !important`,
+    position: 'absolute',
+    top: '-8px !important',
+    left: '-8px',
+    marginLeft: '0 !important',
+    borderRadius: '50%',
+    fontSize: '16px',
+    padding: '2px',
+  },
+  correctIcon: {
+    backgroundColor: color.correct(),
+  },
+  incorrectIcon: {
+    backgroundColor: color.incorrectWithIcon(),
+  },
 });
 
 export default withStyles(styles)(Dropdown);

package/src/constructed-response.jsx

@@ -1,34 +1,92 @@
 import React from 'react';
-import Input from './components/input';
+import { withStyles } from '@material-ui/core/styles';
+import classnames from 'classnames';
+
+import { color } from '@pie-lib/render-ui';
+import EditableHtml from '@pie-lib/editable-html';
 import { withMask } from './with-mask';
 
-// eslint-disable-next-line react/display-name
-export default withMask('input', (props) => (node, data, onChange) => {
-  const dataset = node.data ? node.data.dataset || {} : {};
-  if (dataset.component === 'input') {
-    // eslint-disable-next-line react/prop-types
-    const { adjustedLimit, disabled, feedback, showCorrectAnswer, maxLength, spellCheck } = props;
+const styles = () => ({
+  editableHtmlCustom: {
+    display: 'inline-block',
+    verticalAlign: 'middle',
+    margin: '4px',
+    borderRadius: '4px',
+    border: `1px solid ${color.black()}`,
+  },
+  correct: {
+    border: `1px solid ${color.correct()}`,
+  },
+  incorrect: {
+    border: `1px solid ${color.incorrect()}`,
+  },
+});
 
-    // the first answer is the correct one
-    // eslint-disable-next-line react/prop-types
+const MaskedInput = (props) => (node, data) => {
+  const {
+    adjustedLimit,
+    disabled,
+    feedback,
+    showCorrectAnswer,
+    maxLength,
+    spellCheck,
+    classes,
+    pluginProps,
+    onChange,
+  } = props;
+  const dataset = node.data?.dataset || {};
+
+  if (dataset.component === 'input') {
     const correctAnswer = ((props.choices && dataset && props.choices[dataset.id]) || [])[0];
     const finalValue = showCorrectAnswer ? correctAnswer && correctAnswer.label : data[dataset.id] || '';
     const width = maxLength && maxLength[dataset.id];
+    const feedbackStatus = feedback && feedback[dataset.id];
+    const isCorrect = showCorrectAnswer || feedbackStatus === 'correct';
+    const isIncorrect = !showCorrectAnswer && feedbackStatus === 'incorrect';
+
+    const handleInputChange = (newValue) => {
+      const updatedValue = {
+        ...data,
+        [dataset.id]: newValue,
+      };
+      onChange(updatedValue);
+    };
+
+    const handleKeyDown = (event) => {
+      // the keyCode value for the Enter/Return key is 13
+      if (event.key === 'Enter' || event.keyCode === 13) {
+        return false;
+      }
+    };
 
     return (
-      <Input
+      <EditableHtml
+        id={dataset.id}
         key={`${node.type}-input-${dataset.id}`}
-        correct={feedback && feedback[dataset.id] && feedback[dataset.id] === 'correct'}
         disabled={showCorrectAnswer || disabled}
-        value={finalValue}
-        id={dataset.id}
-        onChange={onChange}
-        showCorrectAnswer={showCorrectAnswer}
-        width={width}
+        disableUnderline
+        onChange={handleInputChange}
+        markup={finalValue || ''}
         charactersLimit={adjustedLimit ? width : 25}
-        isConstructedResponse={true}
+        activePlugins={['languageCharacters']}
+        pluginProps={pluginProps}
+        languageCharactersProps={[{ language: 'spanish' }]}
         spellCheck={spellCheck}
+        width={`calc(${width}em + 42px)`} // added 42px for left and right padding of editable-html
+        onKeyDown={handleKeyDown}
+        autoWidthToolbar
+        toolbarOpts={{
+          minWidth: 'auto',
+          noBorder: true,
+          isHidden: !!pluginProps?.characters?.disabled,
+        }}
+        className={classnames(classes.editableHtmlCustom, {
+          [classes.correct]: isCorrect,
+          [classes.incorrect]: isIncorrect,
+        })}
       />
     );
   }
-});
+};
+
+export default withStyles(styles)(withMask('input', MaskedInput));

package/src/customizable.jsx

@@ -0,0 +1,35 @@
+import React from 'react';
+// import Input from './components/input';
+import { withMask } from './with-mask';
+
+// eslint-disable-next-line react/display-name
+export default withMask('input', (props) => (node, data, onChange) => {
+  const dataset = node.data ? node.data.dataset || {} : {};
+  if (dataset.component === 'input') {
+    // eslint-disable-next-line react/prop-types
+    // const { adjustedLimit, disabled, feedback, showCorrectAnswer, maxLength, spellCheck } = props;
+
+    // the first answer is the correct one
+    // eslint-disable-next-line react/prop-types
+    // const correctAnswer = ((props.choices && dataset && props.choices[dataset.id]) || [])[0];
+    // const finalValue = showCorrectAnswer ? correctAnswer && correctAnswer.label : data[dataset.id] || '';
+    // const width = maxLength && maxLength[dataset.id];
+
+    return props.customMarkMarkupComponent(dataset.id);
+    // return (
+    //   <Input
+    //     key={`${node.type}-input-${dataset.id}`}
+    //     correct={feedback && feedback[dataset.id] && feedback[dataset.id] === 'correct'}
+    //     disabled={showCorrectAnswer || disabled}
+    //     value={finalValue}
+    //     id={dataset.id}
+    //     onChange={onChange}
+    //     showCorrectAnswer={showCorrectAnswer}
+    //     width={width}
+    //     charactersLimit={adjustedLimit ? width : 25}
+    //     isConstructedResponse={true}
+    //     spellCheck={spellCheck}
+    //   />
+    // );
+  }
+});