@pie-element/complex-rubric 3.8.4-next.9 → 5.0.1-esmbeta.0

package/configure/node_modules/@pie-element/rubric/configure/node_modules/@pie-lib/math-input/src/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-element/rubric/configure/node_modules/@pie-lib/math-input/src/keys/geometry.js

@@ -0,0 +1,144 @@
+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',
+  // eslint-disable-next-line
+  latex: "''",
+  // eslint-disable-next-line
+  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-element/rubric/configure/node_modules/@pie-lib/math-input/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/configure/node_modules/@pie-element/rubric/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-element/rubric/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 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-element/rubric/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-element/rubric/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-element/rubric/configure/node_modules/@pie-lib/math-input/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/configure/node_modules/@pie-element/rubric/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', ariaLabel: 'Move cursor left' });
+
+export const right = set({ label: RIGHT_ARROW, keystroke: 'Right', ariaLabel: 'Move cursor right' });

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