@pie-element/ebsr 6.6.3-next.264 → 6.6.3-next.280

package/configure/node_modules/@pie-lib/math-input/src/keys/grades.js

@@ -0,0 +1,265 @@
+import * as comparison from './comparison';
+import * as vars from './vars';
+import * as fractions from './fractions';
+import * as exponent from './exponent';
+import * as misc from './misc';
+import * as constants from './constants';
+import * as trigonometry from './trigonometry';
+import * as geometry from './geometry';
+import * as operators from './operators';
+import * as log from './log';
+import * as subSup from './sub-sup';
+import * as statistics from './statistics';
+import * as basicOperators from './basic-operators';
+import * as matrices from './matrices';
+import digits from './digits';
+import * as logic from './logic';
+
+const hs = [
+  [vars.x, vars.y, exponent.squared, exponent.squareRoot, vars.theta],
+  [fractions.xOverBlank, subSup.subscript, exponent.xToPowerOfN, exponent.nthRoot],
+  [comparison.lessThanEqual, comparison.greaterThanEqual, misc.plusMinus, misc.absValue],
+  [constants.pi, { name: 'i', latex: 'i', write: 'i' }, misc.parenthesis, misc.brackets],
+  [trigonometry.sin, trigonometry.cos, trigonometry.tan, geometry.degree]
+];
+
+const advancedAlgebra = (() => {
+  const out = [...hs.map(arr => [...arr])];
+
+  out[1].push(log.log);
+  out[2].push(log.logSubscript);
+  out[3].push(log.ln);
+  out[4].push(constants.eulers);
+  return out;
+})();
+
+const statisticsSet = (() => {
+  const out = [...hs.map(arr => [...arr])];
+  out[1].push(statistics.mu);
+  out[2].push(statistics.xBar);
+  out[3].push(statistics.yBar);
+  out[4].push(statistics.sigma);
+  return out;
+})();
+
+export const gradeSets = [
+  {
+    predicate: n => n >= 3 && n <= 5,
+    set: [
+      [comparison.lessThan, comparison.greaterThan],
+      [fractions.xOverBlank, fractions.xBlankBlank],
+      [vars.x, logic.longDivision]
+    ]
+  },
+  {
+    predicate: n => n >= 6 && n <= 7,
+    set: [
+      [vars.x, vars.y, exponent.squared, exponent.squareRoot, operators.circleDot],
+      [fractions.xOverBlank, fractions.xBlankBlank, exponent.xToPowerOfN, exponent.nthRoot, logic.longDivision],
+      [comparison.lessThan, comparison.greaterThan, misc.plusMinus, misc.absValue],
+      [comparison.lessThanEqual, comparison.greaterThanEqual, misc.parenthesis, constants.pi],
+      [trigonometry.sin, trigonometry.cos, trigonometry.tan, geometry.degree]
+    ]
+  },
+  {
+    predicate: n => n >= 8 || n === 'HS',
+    set: [
+      [vars.x, vars.y, exponent.squared, exponent.squareRoot, operators.circleDot],
+      [fractions.xOverBlank, subSup.subscript, exponent.xToPowerOfN, exponent.nthRoot],
+      [
+        comparison.lessThanEqual,
+        comparison.greaterThanEqual,
+        misc.plusMinus,
+        misc.absValue
+        // matrices.singleCellMatrix
+      ],
+      [
+        constants.pi,
+        { name: 'i', latex: 'i', write: 'i' },
+        misc.parenthesis,
+        misc.brackets
+        // matrices.doubleCellMatrix
+      ],
+      [trigonometry.sin, trigonometry.cos, trigonometry.tan, geometry.degree]
+    ]
+  },
+  {
+    predicate: 'geometry',
+    set: [
+      [
+        geometry.degree,
+        geometry.primeArcminute,
+        geometry.doublePrimeArcSecond,
+        geometry.triangle,
+        fractions.xOverBlank
+      ],
+      [
+        geometry.angle,
+        geometry.measureOfAngle,
+        geometry.similarTo,
+        geometry.congruentTo,
+        exponent.squareRoot
+      ],
+      [trigonometry.sin, trigonometry.cos, trigonometry.tan, trigonometry.sec, exponent.nthRoot],
+      [trigonometry.csc, trigonometry.cot, exponent.xToPowerOfN, constants.pi, subSup.subscript],
+      [
+        geometry.overline,
+        geometry.overRightArrow,
+        geometry.overLeftRightArrow,
+        geometry.overArc,
+        vars.theta
+      ]
+    ]
+  },
+  {
+    predicate: 'miscellaneous',
+    set: [
+      [
+        subSup.superscript,
+        subSup.subscript,
+        fractions.blankOverBlank,
+        misc.percentage,
+        geometry.segment,
+        geometry.parallel
+      ],
+      [
+        exponent.squareRoot,
+        exponent.nthRoot,
+        misc.absValue,
+        misc.parenthesis,
+        geometry.perpindicular,
+        geometry.angle
+      ],
+      [
+        comparison.lessThan,
+        comparison.greaterThan,
+        geometry.degree,
+        misc.approx,
+        geometry.measureOfAngle,
+        geometry.triangle
+      ],
+      [
+        misc.nApprox,
+        misc.notEqual,
+        geometry.congruentTo,
+        geometry.notCongruentTo,
+        geometry.parallelogram,
+        geometry.circledDot
+      ],
+      [
+        misc.similar,
+        misc.notSimilar,
+        comparison.lessThanEqual,
+        comparison.greaterThanEqual,
+        vars.x,
+        vars.y
+      ]
+    ]
+  },
+  // {
+  //   predicate: 'everything',
+  //   set: [
+  //     [
+  //       subSup.superscript,
+  //       subSup.subscript,
+  //       fractions.blankOverBlank,
+  //       misc.percentage,
+  //       geometry.segment,
+  //       geometry.parallel
+  //     ],
+  //     [
+  //       exponent.squareRoot,
+  //       exponent.nthRoot,
+  //       misc.absValue,
+  //       misc.parenthesis,
+  //       geometry.perpindicular,
+  //       geometry.angle
+  //     ],
+  //     [
+  //       comparison.lessThan,
+  //       comparison.greaterThan,
+  //       geometry.degree,
+  //       misc.approx,
+  //       geometry.measureOfAngle,
+  //       geometry.triangle
+  //     ],
+  //     [
+  //       misc.nApprox,
+  //       misc.notEqual,
+  //       geometry.congruentTo,
+  //       geometry.notCongruentTo,
+  //       geometry.parallelogram,
+  //       geometry.circledDot
+  //     ],
+  //     [
+  //       misc.similar,
+  //       misc.notSimilar,
+  //       comparison.lessThanEqual,
+  //       comparison.greaterThanEqual,
+  //       vars.x,
+  //       vars.y
+  //     ]
+  //   ]
+  // },
+  {
+    predicate: 'advanced-algebra',
+    set: advancedAlgebra
+  },
+  {
+    predicate: 'statistics',
+    set: statisticsSet
+  }
+];
+
+export const keysForGrade = n => {
+  const number = parseInt(n, 10);
+  n = isNaN(number) ? n : number;
+  if (!n) {
+    return [];
+  }
+
+  const match = gradeSets.find(gs => {
+    if (typeof gs.predicate === 'string') {
+      return gs.predicate === n;
+    } else {
+      return gs.predicate(n);
+    }
+  });
+
+  if (match) {
+    return match.set || [];
+  }
+};
+
+const ALL_KEYS = [
+  ...Object.values(basicOperators),
+  ...Object.values(comparison),
+  ...Object.values(constants),
+  ...Object.values(digits),
+  ...Object.values(exponent),
+  ...Object.values(fractions),
+  ...Object.values(geometry),
+  ...Object.values(log),
+  ...Object.values(matrices),
+  ...Object.values(misc),
+  ...Object.values(operators),
+  ...Object.values(statistics),
+  ...Object.values(subSup),
+  ...Object.values(trigonometry),
+  ...Object.values(vars)
+];
+
+export const normalizeAdditionalKeys = additionalKeys => {
+  return (additionalKeys || []).map(additionalkey => {
+    const { latex } = additionalkey;
+    const predefinedKey = (ALL_KEYS || []).find(
+      key =>
+        latex === key.latex ||
+        latex === key.write ||
+        latex === key.command ||
+        latex === key.otherNotation
+    );
+
+    return predefinedKey || additionalkey;
+  });
+};

package/configure/node_modules/@pie-lib/math-input/src/keys/index.js

@@ -0,0 +1,21 @@
+import digits from './digits';
+import * as nav from './navigation';
+import * as edit from './edit';
+import { divide, multiply, plus, minus, equals } from './basic-operators';
+
+const { one, two, three, four, five, six, seven, eight, nine, zero, comma, decimalPoint } = digits;
+
+export const baseSet = [
+  [seven, eight, nine, divide],
+  [four, five, six, multiply],
+  [one, two, three, minus],
+  [zero, decimalPoint, comma, plus],
+  [nav.left, nav.right, edit.del, equals]
+];
+
+import * as comparison from './comparison';
+import * as fractions from './fractions';
+import * as exponent from './exponent';
+import * as misc from './misc';
+
+export { comparison, fractions, exponent, misc };

package/configure/node_modules/@pie-lib/math-input/src/keys/log.js

@@ -0,0 +1,22 @@
+import { mkSet } from './utils';
+
+const set = mkSet('log');
+
+export const log = set({
+  name: 'Log',
+  label: 'log',
+  command: '\\log',
+  latex: '\\log'
+});
+export const logSubscript = set({
+  name: 'Log with subscript',
+  label: 'log s',
+  latex: '\\log_{}',
+  command: ['\\log', '_']
+});
+export const ln = set({
+  name: 'Ln',
+  label: 'ln',
+  command: '\\ln',
+  latex: '\\ln'
+});

package/configure/node_modules/@pie-lib/math-input/src/keys/logic.js

@@ -0,0 +1,15 @@
+import { mkSet } from './utils';
+
+const set = mkSet('logic');
+
+export const therefore = set({
+  name: 'Therefore',
+  label: '∴',
+  write: '∴'
+});
+
+export const longDivision = set({
+  name: 'Long division',
+  latex: '\\longdiv{}',
+  command: '\\longdiv'
+});

package/configure/node_modules/@pie-lib/math-input/src/keys/matrices.js

@@ -0,0 +1,15 @@
+import { mkSet } from './utils';
+
+const set = mkSet('matrices');
+
+export const singleCellMatrix = set({
+  name: 'Single Cell Matrix',
+  label: '[ ]',
+  write: '\\begin{pmatrix}\\end{pmatrix}'
+});
+
+export const doubleCellMatrix = set({
+  name: 'Double Cell Matrix',
+  label: '[ ] [ ] \\\\newline [ ] [ ]',
+  write: '\\begin{bmatrix}&\\\\&\\end{bmatrix}'
+});

package/configure/node_modules/@pie-lib/math-input/src/keys/misc.js

@@ -0,0 +1,60 @@
+import { mkSet } from './utils';
+
+const set = mkSet('misc');
+
+export const plusMinus = set({
+  name: 'Plus/Minus',
+  latex: '\\pm',
+  write: '\\pm'
+});
+
+export const absValue = set({
+  name: 'Absolute Value',
+  latex: '\\abs{}',
+  symbol: '| |',
+  command: '|'
+});
+
+export const parenthesis = set({
+  name: 'Parenthesis',
+  latex: '\\left(\\right)',
+  symbol: '( )',
+  command: '('
+});
+
+export const brackets = set({
+  name: 'Brackets',
+  latex: '\\left[\\right]',
+  symbol: '[ ]',
+  command: '['
+});
+
+export const percentage = set({
+  name: 'Percentage',
+  latex: '%',
+  command: '%'
+});
+
+export const approx = set({
+  latex: '\\approx',
+  command: '\\approx'
+});
+
+export const nApprox = set({
+  latex: '\\napprox',
+  command: '\\napprox'
+});
+
+export const notEqual = set({
+  latex: '\\neq',
+  command: '\\neq'
+});
+
+export const similar = set({
+  latex: '\\sim',
+  command: '\\sim'
+});
+export const notSimilar = set({
+  latex: '\\nsim',
+  command: '\\nsim'
+});

package/configure/node_modules/@pie-lib/math-input/src/keys/navigation.js

@@ -0,0 +1,8 @@
+import { LEFT_ARROW, RIGHT_ARROW } from './chars';
+import { mkSet } from './utils';
+
+const set = mkSet('navigation');
+
+export const left = set({ label: LEFT_ARROW, keystroke: 'Left' });
+
+export const right = set({ label: RIGHT_ARROW, keystroke: 'Right' });

package/configure/node_modules/@pie-lib/math-input/src/keys/operators.js

@@ -0,0 +1,9 @@
+import { mkSet } from './utils';
+
+const set = mkSet('operators');
+
+export const circleDot = set({
+  name: 'CircleDot',
+  label: '⋅',
+  write: '\\cdot'
+});

package/configure/node_modules/@pie-lib/math-input/src/keys/statistics.js

@@ -0,0 +1,29 @@
+import { mkSet } from './utils';
+
+const set = mkSet('statistics');
+export const xBar = set({
+  name: 'X Bar',
+  label: 'x̄',
+  latex: '\\overline{x}',
+  write: '\\overline{x}'
+});
+
+export const yBar = set({
+  name: 'Y Bar',
+  latex: '\\overline{y}',
+  write: '\\overline{y}'
+});
+
+export const mu = set({
+  name: 'mu',
+  label: 'mu',
+  latex: '\\mu',
+  write: '\\mu'
+});
+
+export const sigma = set({
+  name: 'Sigma',
+  label: '\\Sigma',
+  latex: '\\Sigma',
+  write: '\\Sigma'
+});

package/configure/node_modules/@pie-lib/math-input/src/keys/sub-sup.js

@@ -0,0 +1,15 @@
+import { mkSet } from './utils';
+
+const set = mkSet('sub-sup');
+
+export const superscript = set({
+  name: 'Superscript',
+  latex: 'x^{}',
+  command: '^'
+});
+
+export const subscript = set({
+  name: 'Subscript',
+  latex: 'x_{}',
+  command: '_'
+});

package/configure/node_modules/@pie-lib/math-input/src/keys/trigonometry.js

@@ -0,0 +1,15 @@
+import { mkSet } from './utils';
+
+const set = mkSet('trigonometry');
+
+export const sin = set({ name: 'sin', label: 'sin', command: '\\sin', latex: '\\sin' });
+
+export const cos = set({ name: 'cos', label: 'cos', command: '\\cos', latex: '\\cos' });
+
+export const tan = set({ name: 'tan', label: 'tan', command: '\\tan', latex: '\\tan' });
+
+export const sec = set({ name: 'sec', label: 'sec', command: '\\sec', latex: '\\sec' });
+
+export const csc = set({ name: 'csc', label: 'csc', command: '\\csc', latex: '\\csc' });
+
+export const cot = set({ name: 'cot', label: 'cot', command: '\\cot', latex: '\\cot' });

package/configure/node_modules/@pie-lib/math-input/src/keys/utils.js

@@ -0,0 +1,71 @@
+import _ from 'lodash';
+
+export const mkSet = category => o => ({ ...o, category });
+
+export const toArray = o => Object.keys(o).map(k => o[k]);
+
+export const toKey = category => v => {
+  if (typeof v === 'string') {
+    return {
+      name: v,
+      label: v,
+      category,
+      write: v
+    };
+  } else {
+    return {
+      ...v,
+      category
+    };
+  }
+};
+
+export const transformToKeySetStructure = (data = []) => {
+  const structure = [];
+
+  _.times(5, () => {
+    structure.push([]);
+  });
+
+  let ln = data.length;
+  let i = 0;
+  let j = 0;
+
+  while (j < ln) {
+    structure[i++].push(data[j++]);
+
+    if (i === 5) {
+      i = 0;
+    }
+  }
+
+  return structure;
+};
+
+const latexAndNameDontExist = base => k => {
+  const flattened = _.flatten(base);
+  const latexExists = flattened.some(b => b.latex === k.latex);
+  const nameExists = flattened.some(b => b.name === k.name);
+  return !latexExists && !nameExists;
+};
+
+export const extendKeySet = (base = [], keySetData = []) => {
+  keySetData = keySetData.filter(latexAndNameDontExist(base));
+
+  const final = [];
+
+  _.times(5 - base.length, () => {
+    base.push([]);
+  });
+  _.times(5, () => {
+    final.push([]);
+  });
+
+  const extra = transformToKeySetStructure(keySetData);
+
+  for (let i = 0; i < 5; i++) {
+    final[i] = [...base[i], ...extra[i]];
+  }
+
+  return final;
+};

package/configure/node_modules/@pie-lib/math-input/src/keys/vars.js

@@ -0,0 +1,19 @@
+import { mkSet } from './utils';
+
+const set = mkSet('vars');
+
+export const x = set({
+  name: 'X',
+  latex: 'x',
+  write: 'x'
+});
+export const y = set({
+  name: 'Y',
+  latex: 'y',
+  write: 'y'
+});
+export const theta = set({
+  name: 'Theta',
+  latex: '\\theta',
+  write: '\\theta'
+});

package/configure/node_modules/@pie-lib/math-input/src/math-input.jsx

@@ -0,0 +1,128 @@
+import React from 'react';
+import PropTypes from 'prop-types';
+import { withStyles } from '@material-ui/core/styles';
+import classNames from 'classnames';
+import * as mq from './mq';
+import { baseSet } from './keys';
+import KeyPad from './keypad';
+import debug from 'debug';
+
+const log = debug('pie-lib:math-input');
+
+export class MathInput extends React.Component {
+  static propTypes = {
+    classes: PropTypes.object.isRequired,
+    className: PropTypes.string,
+    keyset: PropTypes.array,
+    displayMode: PropTypes.oneOf(['block', 'block-on-focus']),
+    latex: PropTypes.string,
+    onChange: PropTypes.func
+  };
+
+  static defaultProps = {
+    keyset: [],
+    displayMode: 'block'
+  };
+
+  constructor(props) {
+    super(props);
+    this.state = {
+      focused: false
+    };
+  }
+
+  keypadPress = key => {
+    log('[keypadPress] key:', key);
+
+    if (!this.input) {
+      return;
+    }
+
+    if (key.latex && !key.command) {
+      this.input.write(key.latex);
+    } else if (key.write) {
+      this.input.write(key.write);
+    } else if (key.command) {
+      this.input.command(key.command);
+    } else if (key.keystroke) {
+      this.input.keystroke(key.keystroke);
+    }
+  };
+
+  inputFocus = () => {
+    this.setState({ focused: true });
+  };
+
+  inputBlur = () => {
+    this.setState({ focused: false });
+  };
+
+  changeLatex = l => {
+    const { onChange } = this.props;
+
+    if (onChange && l !== this.props.latex) {
+      log('[changeLatex]', l, this.props.latex);
+      onChange(l);
+    }
+  };
+
+  render() {
+    const { classes, className, keyset, latex } = this.props;
+    const { focused } = this.state;
+
+    const showKeypad = true; // TODO: add support for different displayModes - displayMode === 'block' || focused;
+
+    return (
+      <div className={classNames(classes.mathInput, className, focused && classes.focused)}>
+        <mq.Input
+          className={classes.mqInput}
+          innerRef={r => (this.input = r)}
+          onFocus={this.inputFocus}
+          onBlur={this.inputBlur}
+          latex={latex}
+          onChange={this.changeLatex}
+        />
+        {showKeypad && (
+          <div className={classes.pad}>
+            <KeyPad baseSet={baseSet} additionalKeys={keyset} onPress={this.keypadPress} />
+          </div>
+        )}
+      </div>
+    );
+  }
+}
+
+const grey = 'rgba(0, 0, 0, 0.23)';
+const styles = theme => ({
+  formGroup: {
+    display: 'flex',
+    textAlign: 'right',
+    float: 'right'
+  },
+  pad: {
+    width: '100%',
+    display: 'flex'
+  },
+  mathInput: {
+    borderRadius: '4px',
+    border: `solid 1px ${grey}`,
+    marginTop: theme.spacing.unit,
+    marginBottom: theme.spacing.unit,
+    transition: 'border 200ms linear'
+  },
+  focused: {
+    border: `solid 1px ${theme.palette.primary.main}`
+  },
+  mqInput: {
+    width: '100%',
+    border: `solid 0px ${theme.palette.primary.light}`,
+    transition: 'border 200ms linear',
+    padding: theme.spacing.unit,
+    '&.mq-focused': {
+      outline: 'none',
+      boxShadow: 'none',
+      border: `solid 0px ${theme.palette.primary.dark}`
+    }
+  }
+});
+export default withStyles(styles)(MathInput);