@pie-element/complex-rubric 2.6.6 → 2.6.7

package/controller/node_modules/@pie-lib/pie-toolbox/src/code/mask-markup/index.js

@@ -1,7 +0,0 @@
-import { withMask, buildLayoutFromMarkup } from './with-mask';
-import DragInTheBlank from './drag-in-the-blank';
-import ConstructedResponse from './constructed-response';
-import InlineDropdown from './inline-dropdown';
-import componentize from './componentize';
-
-export { withMask, buildLayoutFromMarkup, DragInTheBlank, ConstructedResponse, InlineDropdown, componentize };

package/controller/node_modules/@pie-lib/pie-toolbox/src/code/mask-markup/inline-dropdown.jsx

@@ -1,27 +0,0 @@
-import React from 'react';
-import Dropdown from './components/dropdown';
-import { withMask } from './with-mask';
-
-// eslint-disable-next-line react/display-name
-export default withMask('dropdown', (props) => (node, data, onChange) => {
-  const dataset = node.data ? node.data.dataset || {} : {};
-  if (dataset.component === 'dropdown') {
-    // eslint-disable-next-line react/prop-types
-    const { choices, disabled, feedback, showCorrectAnswer } = props;
-    const correctAnswer = choices && choices[dataset.id] && choices[dataset.id].find((c) => c.correct);
-    const finalChoice = showCorrectAnswer ? correctAnswer && correctAnswer.value : data[dataset.id];
-
-    return (
-      <Dropdown
-        key={`${node.type}-dropdown-${dataset.id}`}
-        correct={feedback && feedback[dataset.id] && feedback[dataset.id] === 'correct'}
-        disabled={disabled || showCorrectAnswer}
-        value={finalChoice}
-        id={dataset.id}
-        onChange={onChange}
-        choices={choices[dataset.id]}
-        showCorrectAnswer={showCorrectAnswer}
-      />
-    );
-  }
-});

package/controller/node_modules/@pie-lib/pie-toolbox/src/code/mask-markup/mask.jsx

@@ -1,137 +0,0 @@
-import React from 'react';
-import PropTypes from 'prop-types';
-import get from 'lodash/get';
-import { withStyles } from '@material-ui/core/styles';
-import { MARK_TAGS } from './serialization';
-
-const Paragraph = withStyles((theme) => ({
-  para: {
-    paddingTop: 2 * theme.spacing.unit,
-    paddingBottom: 2 * theme.spacing.unit,
-  },
-}))((props) => <div className={props.classes.para}>{props.children}</div>);
-
-const restrictWhitespaceTypes = ['tbody', 'tr'];
-
-const addText = (parentNode, text) => {
-  const isWhitespace = text.trim() === '';
-  const parentType = parentNode && parentNode.type;
-
-  if (isWhitespace && restrictWhitespaceTypes.includes(parentType)) {
-    return undefined;
-  } else {
-    return text;
-  }
-};
-
-const getMark = (n) => {
-  const mark = n.leaves.find((leave) => get(leave, 'marks', []).length);
-
-  if (mark) {
-    return mark.marks[0];
-  }
-
-  return null;
-};
-
-export const renderChildren = (layout, value, onChange, rootRenderChildren, parentNode) => {
-  if (!value) {
-    return null;
-  }
-
-  const children = [];
-
-  (layout.nodes || []).forEach((n, index) => {
-    const key = n.type ? `${n.type}-${index}` : `${index}`;
-
-    if (n.isMath) {
-      children.push(
-        <span
-          dangerouslySetInnerHTML={{
-            __html: `<math displaystyle="true">${n.nodes[0].innerHTML}</math>`,
-          }}
-        />,
-      );
-      return children;
-    }
-
-    if (rootRenderChildren) {
-      const c = rootRenderChildren(n, value, onChange);
-      if (c) {
-        children.push(c);
-        return;
-      }
-    }
-
-    if (n.object === 'text') {
-      const content = n.leaves.reduce((acc, l) => {
-        const t = l.text;
-        const extraText = addText(parentNode, t);
-        return extraText ? acc + extraText : acc;
-      }, '');
-      const mark = getMark(n);
-
-      if (mark) {
-        let markKey;
-
-        for (markKey in MARK_TAGS) {
-          if (MARK_TAGS[markKey] === mark.type) {
-            const Tag = markKey;
-
-            children.push(<Tag key={key}>{content}</Tag>);
-            break;
-          }
-        }
-      } else if (content.length > 0) {
-        children.push(content);
-      }
-    } else {
-      const subNodes = renderChildren(n, value, onChange, rootRenderChildren, n);
-      if (n.type === 'p' || n.type === 'paragraph') {
-        children.push(<Paragraph key={key}>{subNodes}</Paragraph>);
-      } else {
-        const Tag = n.type;
-        if (n.nodes && n.nodes.length > 0) {
-          children.push(
-            <Tag key={key} {...n.data.attributes}>
-              {subNodes}
-            </Tag>,
-          );
-        } else {
-          children.push(<Tag key={key} {...n.data.attributes} />);
-        }
-      }
-    }
-  });
-  return children;
-};
-
-const MaskContainer = withStyles(() => ({
-  main: {
-    display: 'initial',
-  },
-}))((props) => <div className={props.classes.main}>{props.children}</div>);
-
-/**
- * Renders a layout that uses the slate.js Value model structure.
- */
-export default class Mask extends React.Component {
-  static propTypes = {
-    renderChildren: PropTypes.func,
-    layout: PropTypes.object,
-    value: PropTypes.object,
-    onChange: PropTypes.func,
-  };
-
-  handleChange = (id, value) => {
-    const data = { ...this.props.value, [id]: value };
-    this.props.onChange(data);
-  };
-
-  render() {
-    const { value, layout } = this.props;
-    const children = renderChildren(layout, value, this.handleChange, this.props.renderChildren);
-
-    return <MaskContainer>{children}</MaskContainer>;
-  }
-}

package/controller/node_modules/@pie-lib/pie-toolbox/src/code/mask-markup/serialization.js

@@ -1,170 +0,0 @@
-import Html from 'slate-html-serializer';
-import { object as toStyleObject } from 'to-style';
-import debug from 'debug';
-
-const log = debug('@pie-lib:mask-markup:serialization');
-
-const INLINE = ['span'];
-const MARK = ['em', 'strong', 'u'];
-const TEXT_NODE = 3;
-const COMMENT_NODE = 8;
-
-const attr = (el) => {
-  if (!el.attributes || el.attributes.length <= 0) {
-    return undefined;
-  }
-
-  const out = {};
-  let i;
-
-  for (i = 0; i < el.attributes.length; i++) {
-    const a = el.attributes[i];
-
-    out[a.name] = a.value;
-  }
-
-  return out;
-};
-
-const getObject = (type) => {
-  if (INLINE.includes(type)) {
-    return 'inline';
-  } else if (MARK.includes(type)) {
-    return 'mark';
-  }
-  return 'block';
-};
-
-export const parseStyleString = (s) => {
-  const regex = /([\w-]*)\s*:\s*([^;]*)/g;
-  let match;
-  const result = {};
-  while ((match = regex.exec(s))) {
-    result[match[1]] = match[2].trim();
-  }
-  return result;
-};
-
-export const reactAttributes = (o) => toStyleObject(o, { camelize: true, addUnits: false });
-
-const handleStyles = (el, attribute) => {
-  const styleString = el.getAttribute(attribute);
-
-  return reactAttributes(parseStyleString(styleString));
-};
-
-const handleClass = (el, acc, attribute) => {
-  const classNames = el.getAttribute(attribute);
-
-  delete acc.class;
-
-  return classNames;
-};
-
-const attributesToMap = (el) => (acc, attribute) => {
-  if (!el.getAttribute) {
-    return acc;
-  }
-
-  const value = el.getAttribute(attribute);
-
-  if (value) {
-    switch (attribute) {
-      case 'style':
-        acc.style = handleStyles(el, attribute);
-        break;
-      case 'class':
-        acc.className = handleClass(el, acc, attribute);
-        break;
-      default:
-        acc[attribute] = el.getAttribute(attribute);
-        break;
-    }
-  }
-
-  return acc;
-};
-
-const attributes = ['border', 'class', 'style'];
-
-/**
- * Tags to marks.
- *
- * @type {Object}
- */
-
-export const MARK_TAGS = {
-  b: 'bold',
-  em: 'italic',
-  u: 'underline',
-  s: 'strikethrough',
-  code: 'code',
-  strong: 'strong',
-};
-
-const marks = {
-  deserialize(el, next) {
-    const mark = MARK_TAGS[el.tagName.toLowerCase()];
-    if (!mark) return;
-    log('[deserialize] mark: ', mark);
-    return {
-      object: 'mark',
-      type: mark,
-      nodes: next(el.childNodes),
-    };
-  },
-};
-
-const rules = [
-  marks,
-  {
-    /**
-     * deserialize everything, we're not fussy about the dom structure for now.
-     */
-    deserialize: (el, next) => {
-      if (el.nodeType === COMMENT_NODE) {
-        return undefined;
-      }
-
-      if (el.nodeType === TEXT_NODE) {
-        return {
-          object: 'text',
-          leaves: [{ text: el.textContent }],
-        };
-      }
-
-      const type = el.tagName.toLowerCase();
-
-      const normalAttrs = attr(el) || {};
-
-      if (type == 'audio' && normalAttrs.controls == '') {
-        normalAttrs.controls = true;
-      }
-
-      const allAttrs = attributes.reduce(attributesToMap(el), { ...normalAttrs });
-      const object = getObject(type);
-
-      if (el.tagName.toLowerCase() === 'math') {
-        return {
-          isMath: true,
-          nodes: [el],
-        };
-      }
-
-      return {
-        object,
-        type,
-        data: { dataset: { ...el.dataset }, attributes: { ...allAttrs } },
-        nodes: next(el.childNodes),
-      };
-    },
-  },
-];
-
-/**
- * Create a new serializer instance with our `rules` from above.
- * Having a default div block will just put every div on it's own line, which is not ideal.
- */
-const html = new Html({ rules, defaultBlock: 'span' });
-
-export const deserialize = (s) => html.deserialize(s, { toJSON: true });

package/controller/node_modules/@pie-lib/pie-toolbox/src/code/mask-markup/with-mask.jsx

@@ -1,35 +0,0 @@
-import React from 'react';
-import PropTypes from 'prop-types';
-import Mask from './mask';
-import componentize from './componentize';
-import { deserialize } from './serialization';
-
-export const buildLayoutFromMarkup = (markup, type) => {
-  const { markup: processed } = componentize(markup, type);
-  const value = deserialize(processed);
-  return value.document;
-};
-
-export const withMask = (type, renderChildren) => {
-  return class WithMask extends React.Component {
-    static propTypes = {
-      /**
-       * At the start we'll probably work with markup
-       */
-      markup: PropTypes.string,
-      /**
-       * Once we start authoring, it may make sense for use to us layout, which will be a simple js object that maps to `slate.Value`.
-       */
-      layout: PropTypes.object,
-      value: PropTypes.object,
-      onChange: PropTypes.func,
-    };
-
-    render() {
-      const { markup, layout, value, onChange } = this.props;
-
-      const maskLayout = layout ? layout : buildLayoutFromMarkup(markup, type);
-      return <Mask layout={maskLayout} value={value} onChange={onChange} renderChildren={renderChildren(this.props)} />;
-    }
-  };
-};

package/controller/node_modules/@pie-lib/pie-toolbox/src/code/math-evaluator/index.js

@@ -1,169 +0,0 @@
-/* eslint-disable no-console */
-import * as mathjs from 'mathjs';
-import me from '@pie-framework/math-expressions';
-
-const decimalCommaRegex = /,/g;
-const decimalRegex = /\.|,/g;
-const decimalWithThousandSeparatorNumberRegex = /^(?!0+\.00)(?=.{1,9}(\.|$))(?!0(?!\.))\d{1,3}(,\d{3})*(\.\d+)?$/;
-
-const rationalizeAllPossibleSubNodes = (expression) => rationalize(mathjs.parse(expression));
-const rationalize = (tree) => {
-  const transformedTree = tree.transform((node) => {
-    try {
-      const rationalizedNode = mathjs.rationalize(node);
-      return rationalizedNode;
-    } catch {
-      return node;
-    }
-  });
-  return transformedTree;
-};
-
-function prepareExpression(string, isLatex) {
-  let returnValue = string ? string.trim() : '';
-
-  returnValue = returnValue.replace(decimalCommaRegex, '.');
-
-  returnValue = isLatex
-    ? latexToText(`${returnValue}`)
-    : textToMathText(`${returnValue}`, { unknownCommands: 'passthrough' }).toString();
-
-  returnValue = returnValue.replace('=', '==');
-  return rationalizeAllPossibleSubNodes(returnValue);
-}
-
-const latexToAstOpts = {
-  missingFactor: (token, e) => {
-    console.warn('missing factor for: ', token.token_type);
-    if (token.token_type === 'NUMBER') {
-      throw e;
-    }
-    return 0;
-  },
-  unknownCommandBehavior: 'passthrough',
-};
-
-const astToTextOpts = {
-  unicode_operators: {
-    ne: function(operands) {
-      return operands.join(' != ');
-    },
-    '%': function(operands) {
-      return `percent(${operands[0]})`;
-    },
-  },
-};
-
-export const latexToText = (latex, extraOtps = {}) => {
-  const la = new me.converters.latexToAstObj({ ...latexToAstOpts, ...extraOtps });
-
-  const at = new me.converters.astToTextObj({ ...astToTextOpts, ...extraOtps });
-
-  const ast = la.convert(latex);
-
-  return at.convert(ast);
-};
-
-export const textToMathText = (latex, extraOtps = {}) => {
-  const la = new me.converters.textToAstObj({ ...latexToAstOpts, ...extraOtps });
-
-  const at = new me.converters.astToTextObj({ ...astToTextOpts, ...extraOtps });
-
-  const ast = la.convert(latex);
-
-  return at.convert(ast);
-};
-
-function shouldRationalizeEntireTree(tree) {
-  let shouldDoIt = true;
-
-  // we need to iterate the entire tree to check for some conditions that might make rationalization impossible
-  try {
-    tree.traverse((node) => {
-      // if we have a variable as an exponent for power operation, we should not rationalize
-      // try to see if there are power operations with variable exponents
-      if (node.type === 'OperatorNode' && node.fn === 'pow') {
-        const exponent = node.args[1];
-
-        // try to see if it can be compiled and evaluated - if it's a non-numerical value, it'll throw an error
-        exponent.compile().eval();
-      }
-
-      // we cannot have variables for unresolved function calls either
-      if (node.type === 'FunctionNode') {
-        //try to see if the argument that the function is called with can be resolved as non-variable
-        const functionParameter = node.args[0];
-
-        // if it holds variables, this will throw an error
-        functionParameter.compile().eval();
-      }
-    });
-
-    mathjs.rationalize(tree);
-  } catch {
-    shouldDoIt = false;
-  }
-
-  return shouldDoIt;
-}
-
-function containsDecimal(expression = '') {
-  return expression.match(decimalRegex);
-}
-const SIMPLIFY_RULES = [
-  { l: 'n1^(1/n2)', r: 'nthRoot(n1, n2)' },
-  { l: 'sqrt(n1)', r: 'nthRoot(n1, 2)' },
-];
-
-const simplify = (v) => mathjs.simplify(v, SIMPLIFY_RULES.concat(mathjs.simplify.rules)); //.concat(SIMPLIFY_RULES));
-
-const areValuesEqual = (valueOne, valueTwo, options = {}) => {
-  const {
-    // if explicitly set to false, having a decimal value in either side will result in a false equality
-    // regardless of mathematical correctness
-    allowDecimals,
-    isLatex, // if the passed in values are latex, they need to be escaped
-    inverse, // returns inverse for the comparison result
-  } = options;
-
-  let valueOneToUse = valueOne;
-  let valueTwoToUse = valueTwo;
-
-  if (allowDecimals === false) {
-    if (containsDecimal(valueOne) || containsDecimal(valueTwo)) {
-      return false;
-    }
-  } else if (allowDecimals === true) {
-    if (containsDecimal(valueOne) && decimalWithThousandSeparatorNumberRegex.test(valueOne)) {
-      valueOneToUse = valueOne.replace(decimalCommaRegex, '');
-    }
-
-    if (containsDecimal(valueTwo) && decimalWithThousandSeparatorNumberRegex.test(valueTwo)) {
-      valueTwoToUse = valueTwo.replace(decimalCommaRegex, '');
-    }
-  }
-
-  const preparedValueOne = prepareExpression(valueOneToUse, isLatex, allowDecimals);
-  const preparedValueTwo = prepareExpression(valueTwoToUse, isLatex, allowDecimals);
-
-  let one = shouldRationalizeEntireTree(preparedValueOne) ? mathjs.rationalize(preparedValueOne) : preparedValueOne;
-  let two = shouldRationalizeEntireTree(preparedValueTwo) ? mathjs.rationalize(preparedValueTwo) : preparedValueTwo;
-
-  one = simplify(one);
-  two = simplify(two);
-
-  const equals = one.equals(two);
-
-  return inverse ? !equals : equals;
-};
-
-export const ave = (a, b) => {
-  const am = mathjs.parse(a);
-  const bm = mathjs.parse(b);
-
-  const arm = simplify(am);
-  const brm = simplify(bm);
-  return arm.equals(brm);
-};
-
-export default areValuesEqual;

package/controller/node_modules/@pie-lib/pie-toolbox/src/code/math-input/horizontal-keypad.jsx

@@ -1,56 +0,0 @@
-import React from 'react';
-import PropTypes from 'prop-types';
-import { keysForGrade, normalizeAdditionalKeys } from './keys/grades';
-import { extendKeySet } from './keys/utils';
-import Keypad from './keypad';
-
-const toOldModel = (d) => {
-  if (d.command) {
-    return { value: d.command, type: 'command' };
-  } else if (d.write) {
-    return { value: d.write };
-  } else if (d.keystroke) {
-    return { type: 'cursor', value: d.keystroke };
-  }
-};
-
-export default class HorizontalKeypad extends React.Component {
-  static propTypes = {
-    className: PropTypes.string,
-    mode: PropTypes.oneOfType([PropTypes.string, PropTypes.number]),
-    layoutForKeyPad: PropTypes.object,
-    onClick: PropTypes.func.isRequired,
-    onFocus: PropTypes.func,
-    noDecimal: PropTypes.bool,
-    additionalKeys: PropTypes.array,
-  };
-
-  static defaultProps = {
-    mode: 'scientific',
-    noDecimal: false,
-    additionalKeys: [],
-  };
-
-  keypadPress = (data) => {
-    const { onClick } = this.props;
-
-    onClick(toOldModel(data));
-  };
-
-  render() {
-    const { mode, onFocus, noDecimal, className, additionalKeys, layoutForKeyPad } = this.props;
-    const normalizedKeys = normalizeAdditionalKeys(additionalKeys);
-
-    return (
-      <Keypad
-        className={className}
-        onFocus={onFocus}
-        noDecimal={noDecimal}
-        layoutForKeyPad={layoutForKeyPad}
-        additionalKeys={extendKeySet(keysForGrade(mode), normalizedKeys)}
-        onPress={this.keypadPress}
-        mode={mode}
-      />
-    );
-  }
-}

package/controller/node_modules/@pie-lib/pie-toolbox/src/code/math-input/index.jsx

@@ -1,18 +0,0 @@
-import { keysForGrade } from './keys/grades';
-import { updateSpans} from "./updateSpans";
-
-const addLeftBracket = (s) => (s.indexOf('\\(') === 0 ? s : `\\(${s}`);
-const addRightBracket = (s) => (s.indexOf('\\)') === s.length - 2 ? s : `${s}\\)`);
-const rmLeftBracket = (s) => (s.indexOf('\\(') === 0 ? s.substring(2) : s);
-const rmRightBracket = (s) => (s.indexOf('\\)') === s.length - 2 ? s.substring(0, s.length - 2) : s);
-
-const addBrackets = (s) => addRightBracket(addLeftBracket(s));
-const removeBrackets = (s) => rmRightBracket(rmLeftBracket(s));
-
-import * as keys from './keys';
-
-import HorizontalKeypad from './horizontal-keypad';
-
-import * as mq from './mq';
-
-export { keysForGrade, addBrackets, removeBrackets, keys, HorizontalKeypad, mq, updateSpans };