@pie-element/complex-rubric 2.1.2-next.57 → 2.1.2-next.69

package/configure/node_modules/@pie-lib/pie-toolbox/src/code/math-input/keys/constants.js

@@ -0,0 +1,35 @@
+import { mkSet } from './utils';
+
+const set = mkSet('constants');
+
+export const pi = set({
+  name: 'Pi',
+  label: 'π',
+  latex: '\\pi',
+  command: '\\pi',
+  category: 'constants',
+});
+
+export const eulers = set({
+  name: 'Eulers',
+  label: 'e',
+  latex: 'e',
+  command: 'e',
+  category: 'constants',
+});
+
+export const infinity = set({
+  name: 'Infinity',
+  label: '\\infty',
+  latex: '\\infty',
+  command: '\\infty',
+  category: 'constants',
+});
+
+export const halfInfinity = set({
+  name: 'Half Infinity',
+  label: '\\propto',
+  latex: '\\propto',
+  command: '\\propto',
+  category: 'constants',
+});

package/configure/node_modules/@pie-lib/pie-toolbox/src/code/math-input/keys/digits.js

@@ -0,0 +1,40 @@
+import times from 'lodash/times';
+
+const digitMap = {
+  0: 'zero',
+  1: 'one',
+  2: 'two',
+  3: 'three',
+  4: 'four',
+  5: 'five',
+  6: 'six',
+  7: 'seven',
+  8: 'eight',
+  9: 'nine',
+};
+
+const comma = { name: 'comma', label: ',', write: ',', category: 'digit' };
+
+const decimalPoint = {
+  name: 'decimal-point',
+  label: '.',
+  write: '.',
+  category: 'digit',
+};
+
+export default times(10, String)
+  .map((n) => {
+    return {
+      name: digitMap[n],
+      write: n,
+      label: n,
+      category: 'digit',
+    };
+  })
+  .reduce(
+    (acc, o) => {
+      acc[o.name] = o;
+      return acc;
+    },
+    { comma, decimalPoint },
+  );

package/configure/node_modules/@pie-lib/pie-toolbox/src/code/math-input/keys/edit.js

@@ -0,0 +1,3 @@
+import { DELETE } from './chars';
+
+export const del = { label: DELETE, category: 'edit', keystroke: 'Backspace', ariaLabel: 'Delete' };

package/configure/node_modules/@pie-lib/pie-toolbox/src/code/math-input/keys/exponent.js

@@ -0,0 +1,28 @@
+import { mkSet } from './utils';
+
+const set = mkSet('exponent');
+
+export const squared = set({
+  name: 'Squared',
+  latex: 'x^2',
+  write: '^2',
+});
+
+export const xToPowerOfN = set({
+  name: 'X to the power of n',
+  latex: 'x^{}',
+  command: '^',
+  ariaLabel: 'exponent',
+});
+
+export const squareRoot = set({
+  name: 'Square root',
+  latex: '\\sqrt{}',
+  command: '\\sqrt',
+});
+
+export const nthRoot = set({
+  name: 'Nth root',
+  latex: '\\sqrt[{}]{}',
+  command: '\\nthroot',
+});

package/configure/node_modules/@pie-lib/pie-toolbox/src/code/math-input/keys/fractions.js

@@ -0,0 +1,26 @@
+import { mkSet } from './utils';
+
+const set = mkSet('fractions');
+
+export const blankOverBlank = set({
+  name: 'blank/blank',
+  latex: '\\frac{}{}',
+  command: '\\frac',
+  ariaLabel: 'fraction',
+});
+
+export const xOverBlank = set({
+  latex: '\\frac{x}{ }',
+  name: 'X/blank',
+  label: 'x/[]',
+  command: '/',
+  ariaLabel: 'x over blank fraction',
+});
+
+export const xBlankBlank = set({
+  name: 'X (blank/blank)',
+  latex: 'x\\frac{}{}',
+  label: 'x([]/[])',
+  command: '\\frac',
+  ariaLabel: 'mixed number',
+});

package/configure/node_modules/@pie-lib/pie-toolbox/src/code/math-input/keys/geometry.js

@@ -0,0 +1,140 @@
+const set = (o) => ({ ...o, category: 'geometry' });
+
+export const overline = set({
+  name: 'Line',
+  latex: '\\overline{}',
+  command: '\\overline',
+});
+
+export const overRightArrow = set({
+  name: 'Ray',
+  latex: '\\overrightarrow{}',
+  command: '\\overrightarrow',
+});
+
+export const overLeftRightArrow = set({
+  name: 'Segment',
+  latex: '\\overleftrightarrow{\\overline{}}', // used this notation to display the pink box
+  symbol: 'AB',
+  command: '\\overleftrightarrow',
+});
+
+export const segment = set({
+  name: 'Segment',
+  latex: '\\overleftrightarrow{AB}',
+  write: '\\overleftrightarrow{AB}',
+  label: 'AB',
+});
+
+export const parallel = set({
+  name: 'Parallel',
+  latex: '\\parallel',
+  command: '\\parallel',
+});
+
+export const notParallel = set({
+  name: 'Not Parallel',
+  latex: '\\nparallel',
+  command: '\\nparallel',
+});
+
+export const perpindicular = set({
+  name: 'Perpendicular',
+  latex: '\\perp',
+  command: '\\perpendicular',
+});
+
+export const angle = set({
+  name: 'Angle',
+  latex: '\\angle',
+  command: '\\angle',
+});
+export const overArc = set({
+  name: 'Over arc',
+  latex: '\\overarc{\\overline{}}', // used this notation to display the pink box
+  command: '\\overarc',
+});
+export const measureOfAngle = set({
+  name: 'Measured Angle',
+  latex: '\\measuredangle',
+  command: ['m', '\\angle'],
+});
+
+export const triangle = set({
+  name: 'Triangle',
+  latex: '\\triangle',
+  command: '\\triangle',
+});
+
+export const square = set({
+  name: 'Square',
+  latex: '\\square',
+  command: '\\square',
+});
+
+export const parallelogram = set({
+  name: 'Parallelogram',
+  latex: '\\parallelogram',
+  command: '\\parallelogram',
+});
+
+export const circledDot = set({
+  name: 'Circled Dot',
+  latex: '\\odot',
+  command: '\\odot',
+});
+
+export const degree = set({
+  name: 'Degree',
+  latex: '\\degree',
+  command: '\\degree',
+});
+
+export const similarTo = set({
+  name: 'Similar',
+  command: '\\sim',
+  latex: '\\sim',
+});
+
+export const congruentTo = set({
+  name: 'Congruent To',
+  command: '\\cong',
+  latex: '\\cong',
+});
+export const notCongruentTo = set({
+  name: 'Not Congruent To',
+  command: '\\ncong',
+  latex: '\\ncong',
+});
+
+export const primeArcminute = set({
+  name: 'Prime',
+  label: 'pam',
+  // eslint-disable-next-line
+  latex: "'",
+  // eslint-disable-next-line
+  write: "'",
+});
+export const doublePrimeArcSecond = set({
+  name: 'Double Prime',
+  latex: '"',
+  write: '"',
+});
+
+export const leftArrow = set({
+  name: 'Left Arrow',
+  latex: '\\leftarrow',
+  command: '\\leftarrow',
+});
+
+export const rightArrow = set({
+  name: 'Right Arrow',
+  latex: '\\rightarrow',
+  command: '\\rightarrow',
+});
+
+export const leftrightArrow = set({
+  name: 'Left and Right Arrow',
+  latex: '\\leftrightarrow',
+  command: '\\leftrightarrow',
+});

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

@@ -0,0 +1,356 @@
+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,
+      ],
+    ],
+  },
+];
+
+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 !latex ? additionalkey : predefinedKey || additionalkey;
+  });
+};

package/configure/node_modules/@pie-lib/pie-toolbox/src/code/math-input/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/pie-toolbox/src/code/math-input/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/configure/node_modules/@pie-lib/pie-toolbox/src/code/math-input/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',
+});