@pie-element/ebsr 6.6.2 → 6.6.3-next.1008

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

@@ -0,0 +1,379 @@
+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';
+import * as nav from './navigation';
+import * as edit from './edit';
+
+const hs = [
+  [fractions.blankOverBlank, misc.percentage, vars.x, exponent.squared, exponent.squareRoot],
+  [operators.circleDot, vars.y, subSup.subscript, exponent.xToPowerOfN, exponent.nthRoot],
+  [
+    misc.plusMinus,
+    comparison.lessThan,
+    comparison.greaterThan,
+    comparison.lessThanEqual,
+    comparison.greaterThanEqual
+  ],
+  [constants.pi, vars.theta, misc.parenthesis, misc.brackets, misc.absValue],
+  [misc.notEqual, trigonometry.sin, trigonometry.cos, trigonometry.tan, geometry.degree]
+];
+
+const advancedAlgebra = (() => {
+  const out = [...hs.map(arr => [...arr])];
+
+  out[0].push({ name: 'i', latex: 'i', write: 'i' });
+  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[0].push(statistics.mu);
+  out[1].push(statistics.xBar);
+  out[2].push(statistics.yBar);
+  out[3].push(statistics.sigma);
+  out[4].push(statistics.smallSigma);
+  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: [
+      [geometry.degree, comparison.lessThan, comparison.greaterThan],
+      [operators.circleDot, comparison.lessThanEqual, comparison.greaterThanEqual],
+      [vars.x, vars.y, exponent.squared, exponent.xToPowerOfN],
+      [misc.plusMinus, fractions.xOverBlank, fractions.xBlankBlank, exponent.squareRoot],
+      [constants.pi, misc.parenthesis, misc.absValue, exponent.nthRoot]
+    ]
+  },
+  {
+    predicate: n => n >= 8 || n === 'HS',
+    set: hs
+  },
+  {
+    predicate: 'non-negative-integers',
+    set: [
+      [digits.seven, digits.eight, digits.nine],
+      [digits.four, digits.five, digits.six],
+      [digits.one, digits.two, digits.three],
+      [digits.zero, { name: '', latex: '', write: '' }, { name: '', latex: '', write: '' }],
+      [nav.left, nav.right, edit.del]
+    ]
+  },
+  {
+    predicate: 'integers',
+    set: [
+      [digits.seven, digits.eight, digits.nine],
+      [digits.four, digits.five, digits.six],
+      [digits.one, digits.two, digits.three],
+      [digits.zero, { name: '', latex: '', write: '' }, basicOperators.minus],
+      [nav.left, nav.right, edit.del]
+    ]
+  },
+  {
+    predicate: 'decimals',
+    set: [
+      [digits.seven, digits.eight, digits.nine],
+      [digits.four, digits.five, digits.six],
+      [digits.one, digits.two, digits.three],
+      [digits.zero, digits.decimalPoint, basicOperators.minus],
+      [nav.left, nav.right, edit.del]
+    ]
+  },
+  {
+    predicate: 'fractions',
+    set: [
+      [digits.seven, digits.eight, digits.nine],
+      [digits.four, digits.five, digits.six],
+      [digits.one, digits.two, digits.three],
+      [digits.zero, fractions.blankOverBlank, basicOperators.minus],
+      [nav.left, nav.right, edit.del]
+    ]
+  },
+  {
+    predicate: 'geometry',
+    set: [
+      [
+        fractions.blankOverBlank,
+        geometry.degree,
+        geometry.primeArcminute,
+        geometry.doublePrimeArcSecond,
+        geometry.congruentTo,
+        geometry.similarTo
+      ],
+      [
+        operators.circleDot,
+        geometry.angle,
+        geometry.measureOfAngle,
+        geometry.triangle,
+        geometry.notCongruentTo,
+        misc.notSimilar
+      ],
+      [
+        trigonometry.sin,
+        trigonometry.cos,
+        trigonometry.tan,
+        constants.pi,
+        exponent.squareRoot,
+        exponent.nthRoot
+      ],
+      [
+        trigonometry.csc,
+        trigonometry.sec,
+        trigonometry.cot,
+        vars.theta,
+        subSup.subscript,
+        exponent.xToPowerOfN
+      ],
+      [
+        geometry.overline,
+        geometry.overRightArrow,
+        geometry.overLeftRightArrow,
+        geometry.overArc,
+        geometry.perpindicular,
+        geometry.parallel
+      ]
+    ]
+  },
+  // {
+  //   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
+  },
+  {
+    predicate: 'item-authoring',
+    set: [
+      [
+        basicOperators.divide,
+        fractions.blankOverBlank,
+        logic.longDivision,
+        constants.halfInfinity,
+        exponent.squared,
+        exponent.squareRoot,
+        geometry.overline,
+        geometry.overRightArrow,
+        geometry.overLeftRightArrow,
+        log.log
+      ],
+      [
+        basicOperators.multiply,
+        operators.circleDot,
+        { name: '', latex: '', write: '' },
+        subSup.subscript,
+        exponent.xToPowerOfN,
+        exponent.nthRoot,
+        geometry.perpindicular,
+        geometry.parallel,
+        geometry.overArc,
+        log.logSubscript
+      ],
+      [
+        misc.plusMinus,
+        constants.pi,
+        vars.theta,
+        geometry.degree,
+        geometry.angle,
+        geometry.leftArrow,
+        geometry.rightArrow,
+        geometry.triangle,
+        geometry.square,
+        log.ln
+      ],
+      [
+        misc.notEqual,
+        misc.absValue,
+        statistics.smallSigma,
+        statistics.mu,
+        logic.therefore,
+        statistics.sigma,
+        geometry.leftrightArrow,
+        trigonometry.sin,
+        trigonometry.cos,
+        trigonometry.tan
+      ],
+      [
+        comparison.lessThanEqual,
+        comparison.greaterThanEqual,
+        { name: '', latex: '', write: '' },
+        { name: '', latex: '', write: '' },
+        constants.infinity,
+        { name: '', latex: '', write: '' },
+        { name: '', latex: '', write: '' },
+        trigonometry.csc,
+        trigonometry.sec,
+        trigonometry.cot
+      ]
+    ]
+  }
+];
+
+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,36 @@
+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'
+});
+
+export const smallSigma = 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'
+});