@pie-element/ebsr 9.12.1 → 9.12.2-next.19

package/configure/node_modules/@pie-element/multiple-choice/node_modules/@pie-lib/pie-toolbox/src/code/mask-markup/serialization.js

@@ -0,0 +1,170 @@
+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/configure/node_modules/@pie-element/multiple-choice/node_modules/@pie-lib/pie-toolbox/src/code/mask-markup/with-mask.jsx

@@ -0,0 +1,35 @@
+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/configure/node_modules/@pie-element/multiple-choice/node_modules/@pie-lib/pie-toolbox/src/code/math-evaluator/index.js

@@ -0,0 +1,169 @@
+/* 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/configure/node_modules/@pie-element/multiple-choice/node_modules/@pie-lib/pie-toolbox/src/code/math-input/horizontal-keypad.jsx

@@ -0,0 +1,56 @@
+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/configure/node_modules/@pie-element/multiple-choice/node_modules/@pie-lib/pie-toolbox/src/code/math-input/index.jsx

@@ -0,0 +1,18 @@
+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 };