@pie-lib/mask-markup 0.1.0

package/src/components/dropdown.tsx

@@ -0,0 +1,448 @@
+// @ts-nocheck
+/**
+ * @synced-from pie-lib/packages/mask-markup/src/components/dropdown.jsx
+ * @auto-generated
+ *
+ * This file is automatically synced from pie-elements and converted to TypeScript.
+ * Manual edits will be overwritten on next sync.
+ * To make changes, edit the upstream JavaScript file and run sync again.
+ */
+
+import React from 'react';
+import PropTypes from 'prop-types';
+import Button from '@mui/material/Button';
+import InputLabel from '@mui/material/InputLabel';
+import { InlineMenu as MenuImport } from '@pie-lib/render-ui';
+
+function isRenderableReactInteropType(value: any) {
+  return (
+    typeof value === 'function' ||
+    (typeof value === 'object' && value !== null && typeof value.$$typeof === 'symbol')
+  );
+}
+
+function unwrapReactInteropSymbol(maybeSymbol: any, namedExport?: string) {
+  if (!maybeSymbol) return maybeSymbol;
+  if (isRenderableReactInteropType(maybeSymbol)) return maybeSymbol;
+  if (isRenderableReactInteropType(maybeSymbol.default)) return maybeSymbol.default;
+  if (namedExport && isRenderableReactInteropType(maybeSymbol[namedExport])) {
+    return maybeSymbol[namedExport];
+  }
+  if (namedExport && isRenderableReactInteropType(maybeSymbol[namedExport]?.default)) {
+    return maybeSymbol[namedExport].default;
+  }
+  return maybeSymbol;
+}
+const Menu = unwrapReactInteropSymbol(MenuImport, 'InlineMenu') || unwrapReactInteropSymbol(renderUi.InlineMenu, 'InlineMenu');
+import * as RenderUiNamespace from '@pie-lib/render-ui';
+const renderUiNamespaceAny = RenderUiNamespace as any;
+const renderUiDefaultMaybe = renderUiNamespaceAny['default'];
+const renderUi =
+  renderUiDefaultMaybe && typeof renderUiDefaultMaybe === 'object'
+    ? renderUiDefaultMaybe
+    : renderUiNamespaceAny;
+import MenuItem from '@mui/material/MenuItem';
+import ArrowDropDownIcon from '@mui/icons-material/ArrowDropDown';
+import ArrowDropUpIcon from '@mui/icons-material/ArrowDropUp';
+import Close from '@mui/icons-material/Close';
+import Check from '@mui/icons-material/Check';
+import { styled } from '@mui/material/styles';
+
+import { color } from '@pie-lib/render-ui';
+import { renderMath } from '@pie-element/shared-math-rendering-mathjax';
+
+const StyledButton: any = styled(Button)(() => ({
+  color: color.text(),
+  border: `1px solid ${color.borderGray()}`,
+  borderRadius: '4px',
+  justifyContent: 'space-between',
+  backgroundColor: color.background(),
+  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(),
+    marginLeft: '5px',
+  },
+  '&.Mui-focused': {
+    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`,
+  },
+}));
+
+const StyledMenu: any = styled(Menu)(() => ({
+  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',
+  },
+  // remove default padding on the inner list
+  '& .MuiList-root': {
+    padding: 0,
+  },
+}));
+
+const StyledMenuItem: any = styled(MenuItem)(() => ({
+  // base text/layout styles (from old JSS - before mui v5 migration)
+  height: 24,
+  overflow: 'hidden',
+  fontSize: '1rem',
+  fontWeight: 400,
+  fontFamily: 'inherit',
+  lineHeight: '1.5em',
+  whiteSpace: 'nowrap',
+
+  // custom styles
+  color: color.text(),
+  backgroundColor: color.background(),
+  '&.Mui-focusVisible': {
+    outline: `3px solid ${color.tertiary()}`,
+    outlineOffset: '-1px', // keeps it inside the item
+    color: color.text(),
+    backgroundColor: color.background(),
+  },
+  '&:hover': {
+    color: color.text(),
+    backgroundColor: color.dropdownBackground(),
+  },
+  boxSizing: 'border-box',
+  padding: '25px',
+  borderRadius: '4px',
+  '&.selected': {
+    color: `${color.text()} !important`,
+    backgroundColor: `${color.background()} !important`,
+    '&:hover': {
+      color: color.text(),
+      backgroundColor: `${color.dropdownBackground()} !important`,
+    },
+  },
+}));
+
+const StyledLabel: any = styled('span')(() => ({
+  fontSize: 'max(1rem, 14px)',
+}));
+
+const StyledSelectedIndicator: any = styled('span')(() => ({
+  fontSize: 'max(1rem, 14px)',
+  position: 'absolute',
+  right: '10px',
+}));
+
+const StyledInputLabel: any = styled(InputLabel)(() => ({
+  position: 'absolute',
+  left: '-10000px',
+  top: 'auto',
+  width: '1px',
+  height: '1px',
+  overflow: 'hidden',
+}));
+
+const StyledCorrectnessIcon: any = styled(Check)(() => ({
+  color: `${color.white()} !important`,
+  position: 'absolute',
+  top: '-8px !important',
+  left: '-8px',
+  marginLeft: '0 !important',
+  borderRadius: '50%',
+  fontSize: '16px',
+  padding: '2px',
+  '&.correct': {
+    backgroundColor: color.correct(),
+  },
+  '&.incorrect': {
+    backgroundColor: color.incorrectWithIcon(),
+  },
+}));
+
+const StyledIncorrectnessIcon: any = styled(Close)(() => ({
+  color: `${color.white()} !important`,
+  position: 'absolute',
+  top: '-8px !important',
+  left: '-8px',
+  marginLeft: '0 !important',
+  borderRadius: '50%',
+  fontSize: '16px',
+  padding: '2px',
+  '&.correct': {
+    backgroundColor: color.correct(),
+  },
+  '&.incorrect': {
+    backgroundColor: color.incorrectWithIcon(),
+  },
+}));
+
+class Dropdown extends React.Component {
+  static propTypes = {
+    id: PropTypes.string,
+    value: PropTypes.string,
+    disabled: PropTypes.bool,
+    onChange: PropTypes.func,
+    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 = {
+      anchorEl: null,
+      highlightedOptionId: null,
+      menuWidth: null,
+      previewValue: null,
+    };
+    this.hiddenRef = React.createRef();
+    this.buttonRef = React.createRef();
+    this.previewRef = React.createRef();
+    this.elementRefs = [];
+  }
+
+  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: any = () => {
+    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 = '';
+    }
+  };
+
+  handleHighlight: any = (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: any = (value, index) => {
+    this.props.onChange(this.props.id, value);
+    this.handleHighlight(index);
+    this.handleClose();
+  };
+
+  handleHover: any = (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 { 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 = [];
+
+    if (disabled && correct !== undefined) {
+      disabledClass = correct || showCorrectAnswer ? 'disabledCorrect' : '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 ? (
+          <StyledCorrectnessIcon className="correct" />
+        ) : (
+          <StyledIncorrectnessIcon className="incorrect" />
+        );
+    }
+
+    return (
+      <>
+        <div
+          ref={this.hiddenRef}
+          style={{ position: 'absolute', visibility: 'hidden', top: 0, left: 0 }}
+          tabIndex={-1}
+          aria-hidden="true"
+        >
+          {(choices || []).map((c, index) => (
+            <StyledMenuItem key={index} tabIndex={-1} aria-hidden="true">
+              <StyledLabel dangerouslySetInnerHTML={{ __html: c.label }} />
+            </StyledMenuItem>
+          ))}
+        </div>
+        <StyledInputLabel id={labelId} tabIndex={-1} aria-hidden="true">
+          {labelText}
+        </StyledInputLabel>
+        <StyledButton
+          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}
+          className={disabledClass}
+          disabled={disabled}
+          id={buttonId}
+          role="combobox"
+          aria-label={`Select an option for ${labelText}`}
+          aria-labelledby={valueDisplayId}
+        >
+          {correctnessIcon}
+          <StyledLabel
+            id={valueDisplayId}
+            ref={this.previewRef}
+            dangerouslySetInnerHTML={{
+              __html: correctValue
+                ? correctValue
+                : open && this.state.previewValue
+                  ? this.getLabel(choices, this.state.previewValue)
+                  : this.getLabel(choices, value) || '',
+            }}
+          />
+          {open ? <ArrowDropUpIcon /> : <ArrowDropDownIcon />}
+        </StyledButton>
+        <StyledMenu
+          id={menuId}
+          anchorEl={anchorEl}
+          keepMounted
+          open={open}
+          onClose={this.handleClose}
+          getContentAnchorEl={null}
+          anchorOrigin={{ vertical: 'bottom', horizontal: 'left' }}
+          transformOrigin={{ vertical: 'top', horizontal: 'left' }}
+          transitionDuration={{ enter: 225, exit: 195 }}
+          slotProps={{
+            paper: this.state.menuWidth ? { style: { minWidth: this.state.menuWidth, padding: '4px' } } : undefined,
+            list: {
+              'aria-labelledby': buttonId,
+              role: 'listbox',
+              disablePadding: true,
+            },
+          }}
+        >
+          {(choices || []).map((c, index) => {
+            const optionId = `dropdown-option-${id}-${index}`;
+
+            return (
+              <StyledMenuItem
+                id={optionId}
+                className={c.value === value ? '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)}
+              >
+                <StyledLabel
+                  ref={(ref) => (this.elementRefs[index] = ref)}
+                  dangerouslySetInnerHTML={{ __html: c.label }}
+                />
+                <StyledSelectedIndicator dangerouslySetInnerHTML={{ __html: c.value === value ? ' &check;' : '' }} />
+              </StyledMenuItem>
+            );
+          })}
+        </StyledMenu>
+      </>
+    );
+  }
+}
+
+export default Dropdown;

package/src/components/input.tsx

@@ -0,0 +1,58 @@
+// @ts-nocheck
+/**
+ * @synced-from pie-lib/packages/mask-markup/src/components/input.jsx
+ * @auto-generated
+ *
+ * This file is automatically synced from pie-elements and converted to TypeScript.
+ * Manual edits will be overwritten on next sync.
+ * To make changes, edit the upstream JavaScript file and run sync again.
+ */
+
+import React from 'react';
+import PropTypes from 'prop-types';
+import CorrectInput from './correct-input.js';
+
+const Input = ({
+  disabled,
+  correct,
+  charactersLimit,
+  id,
+  isConstructedResponse,
+  value,
+  onChange,
+  showCorrectAnswer,
+  spellCheck,
+  width,
+}) => {
+  return (
+    <CorrectInput
+      disabled={disabled}
+      correct={showCorrectAnswer || correct}
+      charactersLimit={charactersLimit}
+      variant="outlined"
+      value={value}
+      isConstructedResponse={isConstructedResponse}
+      spellCheck={spellCheck}
+      isBox={true}
+      width={width}
+      onChange={(e) => {
+        onChange(id, e.target.value);
+      }}
+    />
+  );
+};
+
+Input.propTypes = {
+  id: PropTypes.string,
+  value: PropTypes.string,
+  onChange: PropTypes.func,
+  disabled: PropTypes.bool,
+  spellCheck: PropTypes.bool,
+  correct: PropTypes.bool,
+  showCorrectAnswer: PropTypes.bool,
+  charactersLimit: PropTypes.number,
+  width: PropTypes.number,
+  isConstructedResponse: PropTypes.bool,
+};
+
+export default Input;

package/src/constructed-response.tsx

@@ -0,0 +1,91 @@
+// @ts-nocheck
+/**
+ * @synced-from pie-lib/packages/mask-markup/src/constructed-response.jsx
+ * @auto-generated
+ *
+ * This file is automatically synced from pie-elements and converted to TypeScript.
+ * Manual edits will be overwritten on next sync.
+ * To make changes, edit the upstream JavaScript file and run sync again.
+ */
+
+import React from 'react';
+import { styled } from '@mui/material/styles';
+import classnames from 'classnames';
+
+import { color } from '@pie-lib/render-ui';
+import { withMask } from './with-mask.js';
+import EditableHtmlImport from '@pie-lib/editable-html-tip-tap';
+
+const EditableHtml = EditableHtmlImport;
+const StyledEditableHtml: any = styled(EditableHtml)(() => ({
+    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()}`,
+    },
+  }));
+
+const MaskedInput = (props) => (node, data) => {
+  const { adjustedLimit, disabled, feedback, showCorrectAnswer, maxLength, spellCheck, 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 true;
+      }
+    };
+
+    return (
+      <StyledEditableHtml
+        id={dataset.id}
+        key={`${node.type}-input-${dataset.id}`}
+        disabled={showCorrectAnswer || disabled}
+        disableUnderline
+        onChange={handleInputChange}
+        markup={finalValue || ''}
+        charactersLimit={adjustedLimit ? width : 25}
+        activePlugins={['languageCharacters']}
+        pluginProps={pluginProps}
+        languageCharactersProps={[{ language: 'spanish' }]}
+        spellCheck={spellCheck}
+        adjustWidthForLimit
+        onKeyDown={handleKeyDown}
+        autoWidthToolbar
+        toolbarOpts={{
+          minWidth: 'auto',
+          noBorder: true,
+          isHidden: !!pluginProps?.characters?.disabled,
+        }}
+        className={classnames({
+          correct: isCorrect,
+          incorrect: isIncorrect,
+        })}
+      />
+    );
+  }
+};
+
+export default withMask('input', MaskedInput);

package/src/customizable.tsx

@@ -0,0 +1,44 @@
+// @ts-nocheck
+/**
+ * @synced-from pie-lib/packages/mask-markup/src/customizable.jsx
+ * @auto-generated
+ *
+ * This file is automatically synced from pie-elements and converted to TypeScript.
+ * Manual edits will be overwritten on next sync.
+ * To make changes, edit the upstream JavaScript file and run sync again.
+ */
+
+// import Input from './components/input.js';
+import { withMask } from './with-mask.js';
+
+// 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}
+    //   />
+    // );
+  }
+});