@pie-element/ebsr 9.0.2-next.16 → 9.0.2-next.27

package/configure/node_modules/@pie-element/multiple-choice/node_modules/@pie-lib/pie-toolbox/src/code/math-rendering/mstack/chtml.js

@@ -0,0 +1,220 @@
+import { CHTMLWrapper } from 'mathjax-full/js/output/chtml/Wrapper';
+import _ from 'lodash';
+
+const reduceText = (acc, n) => {
+  if (n.node && n.node.kind === 'text') {
+    acc += n.node.text;
+  }
+  return acc;
+};
+
+export class Line {
+  constructor() {
+    this.kind = 'line';
+  }
+
+  get columns() {
+    return [];
+  }
+}
+
+export class Row {
+  constructor(columns, operator) {
+    this.kind = 'row';
+    this.operator = operator;
+    this.columns = columns;
+  }
+
+  pad(count, direction = 'right') {
+    if (count < this.columns.length) {
+      throw new Error('no');
+    }
+
+    const diff = count - this.columns.length;
+
+    const padding = _.times(diff).map(() => '__pad__');
+    return direction === 'right' ? [...padding, ...this.columns] : [...this.columns, ...padding];
+  }
+}
+
+const mathNodeToCharArray = (mn) => {
+  const text = mn.childNodes.reduce(reduceText, '');
+  return text.split('');
+};
+
+/**
+ * Convert child a column entry
+ * @param {*} child
+ * @return an array of column content
+ */
+const toColumnArray = (child) => {
+  if (!child || !child.kind) {
+    return [];
+  }
+
+  if (child.kind === 'msrow') {
+    throw new Error('msrow in msrow?');
+  }
+
+  if (child.kind === 'mo') {
+    // We are going to treat this operator as a text array.
+    // It's probably going to be a decimal point
+    // eslint-disable-next-line no-console
+    console.warn('mo that is not 1st node in msrow?');
+    return mathNodeToCharArray(child);
+    // throw new Error('mo must be first child of msrow');
+  }
+
+  if (child.kind === 'mn') {
+    return mathNodeToCharArray(child);
+  }
+
+  if (child.toCHTML) {
+    return child;
+  }
+};
+
+/**
+ *  convert mstack chtml childNodes into a Row
+ *  @param child chtml child node of mstack
+ *  @return Row | Line
+ */
+const rowStack = (child) => {
+  if (!child || !child.kind) {
+    return;
+  }
+
+  if (child.kind === 'msrow') {
+    if (!child.childNodes || child.childNodes.length === 0) {
+      return new Row([]);
+    }
+    const f = _.first(child.childNodes);
+    const nodes = f && f.kind === 'mo' ? _.tail(child.childNodes) : child.childNodes;
+
+    const columns = _.flatten(nodes.map(toColumnArray));
+
+    return new Row(columns, f.kind === 'mo' ? f : undefined);
+  }
+
+  if (child.kind === 'mn') {
+    const columns = mathNodeToCharArray(child);
+    return new Row(columns, undefined);
+  }
+
+  if (child.kind === 'mo') {
+    // eslint-disable-next-line no-console
+    console.warn('mo on its own row?');
+    return new Row([], child);
+  }
+
+  if (child.kind === 'msline') {
+    return new Line();
+  }
+
+  if (child.toCHTML) {
+    return new Row([child]);
+  }
+};
+
+/** convert MathJax chtml tree to Row[]
+ * @param mstack the root of the mathjax chtml tree
+ * @return Row[]
+ */
+
+export const getStackData = (mstack) => {
+  if (!mstack || !mstack.childNodes) {
+    return [];
+  }
+  return _.compact(mstack.childNodes.map(rowStack));
+};
+
+export class CHTMLmstack extends CHTMLWrapper {
+  constructor(factory, node, parent = null) {
+    super(factory, node, parent);
+
+    this.ce = this.adaptor.document.createElement.bind(this.adaptor.document);
+  }
+
+  toCHTML(parent) {
+    const chtml = this.standardCHTMLnode(parent);
+
+    const stackData = getStackData(this);
+
+    // console.log('stackData', stackData);
+    const maxCols = stackData.reduce((acc, r) => {
+      if (r && r.columns.length > acc) {
+        acc = r.columns.length;
+      }
+      return acc;
+    }, 0);
+
+    const table = this.ce('table');
+    chtml.appendChild(table);
+
+    stackData.forEach((row) => {
+      const tr = this.ce('tr');
+      table.appendChild(tr);
+
+      if (row.kind === 'row') {
+        const td = this.ce('td');
+        tr.appendChild(td);
+        if (row.operator && row.operator.toCHTML) {
+          td.setAttribute('class', 'inner');
+          row.operator.toCHTML(td);
+        } else {
+          td.textContent = '';
+        }
+
+        // align right for now:
+        const cols = row.pad(maxCols, 'right');
+        cols.forEach((c) => {
+          const t = this.ce('td');
+          tr.appendChild(t);
+          if (c === '__pad__') {
+            t.textContent = '';
+          } else if (typeof c === 'string') {
+            t.textContent = c;
+          } else if (c.kind === 'none') {
+            t.textContent = '';
+          } else if (c.toCHTML) {
+            t.setAttribute('class', 'inner');
+            c.toCHTML(t);
+          }
+        });
+      } else if (row.kind === 'line') {
+        const td = this.ce('td');
+        tr.appendChild(td);
+        td.setAttribute('colspan', maxCols + 1);
+        td.setAttribute('class', 'mjx-line');
+        td.textContent = '';
+      }
+    });
+  }
+}
+CHTMLmstack.styles = {
+  'mjx-mstack > table': {
+    'line-height': 'initial',
+    border: 'solid 0px red',
+    'border-spacing': '0em',
+    'border-collapse': 'separate',
+  },
+  'mjx-mstack > table > tr': {
+    'line-height': 'initial',
+  },
+  'mjx-mstack > table > tr > td': {
+    // padding: '1.2rem',
+    border: 'solid 0px blue',
+    'font-family': 'sans-serif',
+    'line-height': 'initial',
+  },
+  'mjx-mstack > table > tr > td.inner': {
+    'font-family': 'inherit',
+  },
+  'mjx-mstack > table > tr > .mjx-line': {
+    padding: 0,
+    'border-top': 'solid 1px black',
+  },
+  '.TEX-A': {
+    'font-family': 'MJXZERO, MJXTEX !important',
+  },
+};

package/configure/node_modules/@pie-element/multiple-choice/node_modules/@pie-lib/pie-toolbox/src/code/math-rendering/mstack/index.js

@@ -0,0 +1,13 @@
+import { CHTMLmstack } from './chtml';
+import { MmlNone, MmlMsline, MmlMstack, MmlMsrow } from './mml';
+
+export const chtmlNodes = {
+  mstack: CHTMLmstack,
+};
+
+export const mmlNodes = {
+  mstack: MmlMstack,
+  msline: MmlMsline,
+  msrow: MmlMsrow,
+  none: MmlNone,
+};

package/configure/node_modules/@pie-element/multiple-choice/node_modules/@pie-lib/pie-toolbox/src/code/math-rendering/mstack/mml.js

@@ -0,0 +1,24 @@
+import { AbstractMmlNode } from 'mathjax-full/js/core/MmlTree/MmlNode';
+
+export class MmlNone extends AbstractMmlNode {
+  get kind() {
+    return 'none';
+  }
+}
+
+export class MmlMstack extends AbstractMmlNode {
+  get kind() {
+    return 'mstack';
+  }
+}
+
+export class MmlMsrow extends AbstractMmlNode {
+  get kind() {
+    return 'msrow';
+  }
+}
+export class MmlMsline extends AbstractMmlNode {
+  get kind() {
+    return 'msline';
+  }
+}

package/configure/node_modules/@pie-element/multiple-choice/node_modules/@pie-lib/pie-toolbox/src/code/math-rendering/normalization.js

@@ -0,0 +1,69 @@
+export const BracketTypes = {};
+
+BracketTypes.ROUND_BRACKETS = 'round_brackets';
+BracketTypes.SQUARE_BRACKETS = 'square_brackets';
+BracketTypes.DOLLAR = 'dollar';
+BracketTypes.DOUBLE_DOLLAR = 'double_dollar';
+
+const PAIRS = {
+  [BracketTypes.ROUND_BRACKETS]: ['\\(', '\\)'],
+  [BracketTypes.SQUARE_BRACKETS]: ['\\[', '\\]'],
+  [BracketTypes.DOLLAR]: ['$', '$'],
+  [BracketTypes.DOUBLE_DOLLAR]: ['$$', '$$'],
+};
+
+export const wrapMath = (content, wrapType) => {
+  if (wrapType === BracketTypes.SQUARE_BRACKETS) {
+    console.warn('\\[...\\] is not supported yet'); // eslint-disable-line
+    wrapType = BracketTypes.ROUND_BRACKETS;
+  }
+  if (wrapType === BracketTypes.DOUBLE_DOLLAR) {
+    console.warn('$$...$$ is not supported yet'); // eslint-disable-line
+    wrapType = BracketTypes.DOLLAR;
+  }
+
+  const [start, end] = PAIRS[wrapType] || PAIRS[BracketTypes.ROUND_BRACKETS];
+  return `${start}${content}${end}`;
+};
+
+export const unWrapMath = (content) => {
+  const displayStyleIndex = content.indexOf('\\displaystyle');
+  if (displayStyleIndex !== -1) {
+    console.warn('\\displaystyle is not supported - removing'); // eslint-disable-line
+    content = content.replace('\\displaystyle', '').trim();
+  }
+
+  if (content.startsWith('$$') && content.endsWith('$$')) {
+    console.warn('$$ syntax is not yet supported'); // eslint-disable-line
+    return {
+      unwrapped: content.substring(2, content.length - 2),
+      wrapType: BracketTypes.DOLLAR,
+    };
+  }
+  if (content.startsWith('$') && content.endsWith('$')) {
+    return {
+      unwrapped: content.substring(1, content.length - 1),
+      wrapType: BracketTypes.DOLLAR,
+    };
+  }
+
+  if (content.startsWith('\\[') && content.endsWith('\\]')) {
+    console.warn('\\[..\\] syntax is not yet supported'); // eslint-disable-line
+    return {
+      unwrapped: content.substring(2, content.length - 2),
+      wrapType: BracketTypes.ROUND_BRACKETS,
+    };
+  }
+
+  if (content.startsWith('\\(') && content.endsWith('\\)')) {
+    return {
+      unwrapped: content.substring(2, content.length - 2),
+      wrapType: BracketTypes.ROUND_BRACKETS,
+    };
+  }
+
+  return {
+    unwrapped: content,
+    wrapType: BracketTypes.ROUND_BRACKETS,
+  };
+};

package/configure/node_modules/@pie-element/multiple-choice/node_modules/@pie-lib/pie-toolbox/src/code/math-rendering/render-math.js

@@ -0,0 +1,339 @@
+import { mathjax } from 'mathjax-full/js/mathjax';
+import { MathML } from 'mathjax-full/js/input/mathml';
+import { TeX } from 'mathjax-full/js/input/tex';
+
+import { CHTML } from 'mathjax-full/js/output/chtml';
+import { RegisterHTMLHandler } from 'mathjax-full/js/handlers/html';
+import { browserAdaptor } from 'mathjax-full/js/adaptors/browserAdaptor';
+import { AllPackages } from 'mathjax-full/js/input/tex/AllPackages';
+
+if (typeof window !== 'undefined') {
+  RegisterHTMLHandler(browserAdaptor());
+}
+
+// import pkg from '../../package.json';
+import { mmlNodes, chtmlNodes } from './mstack';
+import debug from 'debug';
+import { wrapMath, unWrapMath } from './normalization';
+import { MmlFactory } from 'mathjax-full/js/core/MmlTree/MmlFactory';
+import { SerializedMmlVisitor } from 'mathjax-full/js/core/MmlTree/SerializedMmlVisitor';
+import { CHTMLWrapperFactory } from 'mathjax-full/js/output/chtml/WrapperFactory';
+import { CHTMLmspace } from 'mathjax-full/js/output/chtml/Wrappers/mspace';
+
+const visitor = new SerializedMmlVisitor();
+const toMMl = (node) => visitor.visitTree(node);
+
+const log = debug('pie-lib:math-rendering');
+
+const NEWLINE_BLOCK_REGEX = /\\embed\{newLine\}\[\]/g;
+const NEWLINE_LATEX = '\\newline ';
+
+const getGlobal = () => {
+  // TODO does it make sense to use version?
+  // const key = `${pkg.name}@${pkg.version.split('.')[0]}`;
+  // It looks like Ed made this change when he switched from mathjax3 to mathjax-full
+  // I think it was supposed to make sure version 1 (using mathjax3) is not used
+  // in combination with version 2 (using mathjax-full)
+
+  // TODO higher level wrappers use this instance of math-rendering, and if 2 different instances are used, math rendering is not working
+  //  so I will hardcode this for now until a better solution is found
+  const key = '@pie-lib/math-rendering@2';
+
+  if (typeof window !== 'undefined') {
+    if (!window[key]) {
+      window[key] = {};
+    }
+    return window[key];
+  } else {
+    return {};
+  }
+};
+
+/** Add temporary support for a global singleDollar override
+ *  <code>
+ *   // This will enable single dollar rendering
+ *   window.pie = window.pie || {};
+ *   window.pie.mathRendering =  {useSingleDollar: true };
+ *  </code>
+ */
+const defaultOpts = () => getGlobal().opts || {};
+
+export const fixMathElement = (element) => {
+  if (element.dataset.mathHandled) {
+    return;
+  }
+
+  let property = 'innerText';
+
+  if (element.textContent) {
+    property = 'textContent';
+  }
+
+  if (element[property]) {
+    element[property] = wrapMath(unWrapMath(element[property]).unwrapped);
+    // because mathquill doesn't understand line breaks, sometimes we end up with custom elements on prompts/rationale/etc.
+    // we need to replace the custom embedded elements with valid latex that Mathjax can understand
+    element[property] = element[property].replace(NEWLINE_BLOCK_REGEX, NEWLINE_LATEX);
+    element.dataset.mathHandled = true;
+  }
+};
+
+export const fixMathElements = (el = document) => {
+  const mathElements = el.querySelectorAll('[data-latex]');
+
+  mathElements.forEach((item) => fixMathElement(item));
+};
+
+const adjustMathMLStyle = (el = document) => {
+  const nodes = el.querySelectorAll('math');
+  nodes.forEach((node) => node.setAttribute('displaystyle', 'true'));
+};
+
+const createMathMLInstance = (opts, docProvided = document) => {
+  opts = opts || defaultOpts();
+
+  if (opts.useSingleDollar) {
+    // eslint-disable-next-line
+    console.warn('[math-rendering] using $ is not advisable, please use $$..$$ or \\(...\\)');
+  }
+
+  const packages = AllPackages.filter((name) => name !== 'bussproofs'); // Bussproofs needs an output jax
+
+  // The autoload extension predefines all the macros from the extensions that haven't been loaded already
+  // so that they automatically load the needed extension when they are first used
+  packages.push('autoload');
+
+  const macros = {
+    parallelogram: '\\lower.2em{\\Huge\\unicode{x25B1}}',
+    overarc: '\\overparen',
+    napprox: '\\not\\approx',
+    longdiv: '\\enclose{longdiv}',
+  };
+
+  const texConfig = opts.useSingleDollar
+    ? {
+        packages,
+        macros,
+        inlineMath: [
+          ['$', '$'],
+          ['\\(', '\\)'],
+        ],
+        processEscapes: true,
+        options: {
+          enableExplorer: true,
+          enableAssistiveMml: true,
+          a11y: {
+            speech: true,
+            braille: true,
+            subtitles: true,
+          },
+          sre: {
+            domain: 'default',
+            style: 'default',
+            locale: 'en',
+          },
+        },
+      }
+    : {
+        packages,
+        macros,
+        options: {
+          enableExplorer: true,
+          enableAssistiveMml: true,
+          a11y: {
+            speech: true,
+            braille: true,
+            subtitles: true,
+          },
+          sre: {
+            domain: 'default',
+            style: 'default',
+            locale: 'en',
+          },
+        },
+      };
+
+  const mmlConfig = {
+    options: {
+      a11y: {
+        speech: true,
+        braille: true,
+        subtitles: true,
+      },
+    },
+    parseError: function(node) {
+      // function to process parsing errors
+      // eslint-disable-next-line no-console
+      console.log('error:', node);
+      this.error(this.adaptor.textContent(node).replace(/\n.*/g, ''));
+    },
+  };
+
+  const fontURL = `https://unpkg.com/mathjax-full@${mathjax.version}/ts/output/chtml/fonts/tex-woff-v2`;
+  const htmlConfig = {
+    fontURL,
+
+    wrapperFactory: new CHTMLWrapperFactory({
+      ...CHTMLWrapperFactory.defaultNodes,
+      ...chtmlNodes,
+    }),
+
+    options: {
+      renderActions: {
+        assistiveMml: [['AssistiveMmlHandler']],
+      },
+    },
+  };
+
+  const mml = new MathML(mmlConfig);
+
+  const customMmlFactory = new MmlFactory({
+    ...MmlFactory.defaultNodes,
+    ...mmlNodes,
+  });
+
+  const html = mathjax.document(docProvided, {
+    compileError: (mj, math, err) => {
+      // eslint-disable-next-line no-console
+      console.log('bad math?:', math);
+      // eslint-disable-next-line no-console
+      console.error(err);
+    },
+    typesetError: function(doc, math, err) {
+      // eslint-disable-next-line no-console
+      console.log('typeset error');
+      // eslint-disable-next-line no-console
+      console.error(err);
+      doc.typesetError(math, err);
+    },
+
+    options: {
+      enableAssistiveMml: true,
+      menuOptions: {
+        settings: {
+          assistiveMml: true,
+          collapsible: true,
+          explorer: true,
+        },
+      },
+    },
+
+    InputJax: [new TeX(texConfig), mml],
+    OutputJax: new CHTML(htmlConfig),
+  });
+
+  // Note: we must set this *after* mathjax.document (no idea why)
+  mml.setMmlFactory(customMmlFactory);
+
+  return html;
+};
+
+const bootstrap = (opts) => {
+  if (typeof window === 'undefined') {
+    return { Typeset: () => ({}) };
+  }
+
+  const html = createMathMLInstance(opts);
+
+  return {
+    version: mathjax.version,
+    html: html,
+    Typeset: function(...elements) {
+      const updatedDocument = this.html
+        .findMath(elements.length ? { elements } : {})
+        .compile()
+        .getMetrics()
+        .typeset()
+        .updateDocument();
+
+      try {
+        const list = updatedDocument.math.list;
+
+        for (let item = list.next; typeof item.data !== 'symbol'; item = item.next) {
+          const mathMl = toMMl(item.data.root);
+          const parsedMathMl = mathMl.replaceAll('\n', '');
+
+          item.data.typesetRoot.setAttribute('data-mathml', parsedMathMl);
+        }
+      } catch (e) {
+        // eslint-disable-next-line no-console
+        console.error(e.toString());
+      }
+
+      updatedDocument.clear();
+    },
+  };
+};
+
+const renderMath = (el, renderOpts) => {
+  const isString = typeof el === 'string';
+  let executeOn = document.body;
+
+  if (isString) {
+    const div = document.createElement('div');
+
+    div.innerHTML = el;
+    executeOn = div;
+  }
+
+  fixMathElements(executeOn);
+  adjustMathMLStyle(executeOn);
+
+  if (isString) {
+    const html = createMathMLInstance(undefined, executeOn);
+
+    const updatedDocument = html
+      .findMath()
+      .compile()
+      .getMetrics()
+      .typeset()
+      .updateDocument();
+
+    const list = updatedDocument.math.list;
+    const item = list.next;
+
+    if (!item) {
+      return '';
+    }
+
+    const mathMl = toMMl(item.data.root);
+    const parsedMathMl = mathMl.replaceAll('\n', '');
+
+    return parsedMathMl;
+  }
+
+  if (!getGlobal().instance) {
+    getGlobal().instance = bootstrap(renderOpts);
+  }
+
+  if (!el) {
+    log('el is undefined');
+    return;
+  }
+
+  if (el instanceof Element) {
+    getGlobal().instance.Typeset(el);
+  } else if (el.length) {
+    const arr = Array.from(el);
+    getGlobal().instance.Typeset(...arr);
+  }
+};
+
+/**
+ * This style is added to overried default styling of mjx-mspace Mathjax tag
+ * In mathjax src code \newline latex gets parsed to <mjx-mspace></mjx-mspace>,
+ * but has the default style
+ * 'mjx-mspace': {
+  "display": 'in-line',
+  "text-align": 'left'
+} which prevents it from showing as a newline value
+ */
+CHTMLmspace.styles = {
+  'mjx-mspace': {
+    display: 'block',
+    'text-align': 'center',
+    height: '5px',
+  },
+};
+
+export default renderMath;

package/configure/node_modules/@pie-element/multiple-choice/node_modules/@pie-lib/pie-toolbox/src/code/math-toolbar/done-button.jsx

@@ -0,0 +1,47 @@
+import React from 'react';
+
+import IconButton from '@material-ui/core/IconButton';
+import Check from '@material-ui/icons/Check';
+import { withStyles } from '@material-ui/core/styles';
+import PropTypes from 'prop-types';
+import classNames from 'classnames';
+
+export const RawDoneButton = ({ classes, onClick, hideBackground }) => (
+  <IconButton
+    aria-label="Done"
+    className={classes.iconRoot}
+    onClick={onClick}
+    classes={{
+      label: classes.label,
+      root: classNames(classes.iconRoot, { [classes.hideBackground]: hideBackground }),
+    }}
+  >
+    <Check />
+  </IconButton>
+);
+
+RawDoneButton.propTypes = {
+  classes: PropTypes.object.isRequired,
+  onClick: PropTypes.func,
+};
+
+const styles = (theme) => ({
+  iconRoot: {
+    verticalAlign: 'top',
+    width: '28px',
+    height: '28px',
+    color: '#00bb00',
+  },
+  hideBackground: {
+    backgroundColor: theme.palette.common.white,
+
+    '&:hover': {
+      backgroundColor: theme.palette.grey[200],
+    },
+  },
+  label: {
+    position: 'absolute',
+    top: '2px',
+  },
+});
+export const DoneButton = withStyles(styles)(RawDoneButton);