@pie-lib/math-input-mathlive 1.0.0

package/src/keys/grades.js

@@ -0,0 +1,367 @@
+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],
+      [exponent.squared, exponent.xToPowerOfN],
+    ],
+  },
+  {
+    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,
+      ],
+    ],
+  },
+  // for grade 1-2, we want to display the base set only
+  // we need it here because we don't want to display the default set (grade 8)
+  {
+    predicate: (n) => n >= 1 && n <= 2,
+    set: [],
+  },
+];
+
+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 || [];
+  }
+
+  // if the grade is not found, return the default set which is grade 8 (as per PD-3549), for mode language it is not the default
+  if (n !== 'language') {
+    return gradeSets[2].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 !latex ? additionalkey : predefinedKey || additionalkey;
+  });
+};

package/src/keys/index.js

@@ -0,0 +1,20 @@
+import digits from './digits';
+import * as nav from './navigation';
+import * as edit from './edit';
+import { divide, equals, minus, multiply, plus } from './basic-operators';
+import * as comparison from './comparison';
+import * as fractions from './fractions';
+import * as exponent from './exponent';
+import * as misc from './misc';
+
+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],
+];
+
+export { comparison, fractions, exponent, misc };

package/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 base n',
+  label: 'log s',
+  latex: '\\log_{}',
+  command: ['\\log', '_'],
+});
+export const ln = set({
+  name: 'natural log',
+  label: 'ln',
+  command: '\\ln',
+  latex: '\\ln',
+});

package/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/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/src/keys/misc.js

@@ -0,0 +1,65 @@
+import { mkSet } from './utils';
+
+const set = mkSet('misc');
+
+export const plusMinus = set({
+  name: 'Plus or 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: 'Percent',
+  latex: '%',
+  command: '%',
+});
+
+export const approx = set({
+  latex: '\\approx',
+  command: '\\approx',
+  ariaLabel: 'Approximately equal to',
+});
+
+export const nApprox = set({
+  latex: '\\napprox',
+  command: '\\napprox',
+  ariaLabel: 'Not pproximately equal to',
+});
+
+export const notEqual = set({
+  latex: '\\neq',
+  command: '\\neq',
+  ariaLabel: 'Not equals',
+});
+
+export const similar = set({
+  latex: '\\sim',
+  command: '\\sim',
+  ariaLabel: 'Similar',
+});
+export const notSimilar = set({
+  latex: '\\nsim',
+  command: '\\nsim',
+  ariaLabel: 'Not similar',
+});

package/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', ariaLabel: 'Move cursor left' });
+
+export const right = set({ label: RIGHT_ARROW, keystroke: 'Right', ariaLabel: 'Move cursor right' });

package/src/keys/operators.js

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

package/src/keys/statistics.js

@@ -0,0 +1,38 @@
+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',
+  ariaLabel: 'Uppercase Sigma',
+  label: '\\Sigma',
+  latex: '\\Sigma',
+  write: '\\Sigma',
+});
+
+export const smallSigma = set({
+  name: 'sigma',
+  ariaLabel: 'Lowercase Sigma',
+  label: '\\sigma',
+  latex: '\\sigma',
+  write: '\\sigma',
+});

package/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/src/keys/trigonometry.js

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

package/src/keys/utils.js

@@ -0,0 +1,66 @@
+import { flatten, times } from 'lodash-es';
+
+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/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',
+});