@pie-element/hotspot 9.0.2-esm.0 → 11.0.5-esm.0

package/controller/node_modules/@pie-lib/controller-utils/lib/persistence.js

@@ -0,0 +1,140 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.lockChoices = exports.getShuffledChoices = exports.compact = void 0;
+
+var _typeof2 = _interopRequireDefault(require("@babel/runtime/helpers/typeof"));
+
+var _get = _interopRequireDefault(require("lodash/get"));
+
+var _shuffle = _interopRequireDefault(require("lodash/shuffle"));
+
+var _isEmpty = _interopRequireDefault(require("lodash/isEmpty"));
+
+// eslint-disable-next-line no-console
+var lg = function lg(n) {
+  return console[n].bind(console, 'controller-utils:');
+};
+
+var debug = lg('debug');
+var log = lg('log');
+var warn = lg('warn');
+var error = lg('error');
+
+var compact = function compact(arr) {
+  if (Array.isArray(arr)) {
+    return arr.filter(function (v) {
+      return v !== null && v !== undefined;
+    });
+  }
+
+  return arr;
+};
+
+exports.compact = compact;
+
+var getShuffledChoices = function getShuffledChoices(choices, session, updateSession, choiceKey) {
+  return new Promise(function (resolve) {
+    var _session$data;
+
+    log('updateSession type: ', (0, _typeof2["default"])(updateSession));
+    log('session: ', session);
+    var currentShuffled = compact((session === null || session === void 0 ? void 0 : (_session$data = session.data) === null || _session$data === void 0 ? void 0 : _session$data.shuffledValues) || (session === null || session === void 0 ? void 0 : session.shuffledValues) || []);
+
+    if (!session) {
+      // eslint-disable-next-line quotes
+      warn("unable to save shuffled choices because there's no session.");
+      resolve(undefined);
+    } else if (!(0, _isEmpty["default"])(currentShuffled)) {
+      var _session$data2;
+
+      debug('use shuffledValues to sort the choices...', (_session$data2 = session.data) === null || _session$data2 === void 0 ? void 0 : _session$data2.shuffledValues);
+      resolve(compact(currentShuffled.map(function (v) {
+        return choices.find(function (c) {
+          return c[choiceKey] === v;
+        });
+      })));
+    } else {
+      var shuffledChoices = (0, _shuffle["default"])(choices);
+
+      if (updateSession && typeof updateSession === 'function') {
+        try {
+          //Note: session.id refers to the id of the element within a session
+          var shuffledValues = compact(shuffledChoices.map(function (c) {
+            return c[choiceKey];
+          }));
+          log('try to save shuffledValues to session...', shuffledValues);
+          log('call updateSession... ', session.id, session.element);
+
+          if ((0, _isEmpty["default"])(shuffledValues)) {
+            error("shuffledValues is an empty array? - refusing to call updateSession: shuffledChoices: ".concat(JSON.stringify(shuffledChoices), ", key: ").concat(choiceKey));
+          } else {
+            updateSession(session.id, session.element, {
+              shuffledValues: shuffledValues
+            })["catch"](function (e) {
+              return (// eslint-disable-next-line no-console
+                console.error('update session failed for: ', session.id, e)
+              );
+            });
+          }
+        } catch (e) {
+          warn('unable to save shuffled order for choices');
+          error(e);
+        }
+      } else {
+        warn('unable to save shuffled choices, shuffle will happen every time.');
+      } //save this shuffle to the session for later retrieval
+
+
+      resolve(shuffledChoices);
+    }
+  });
+};
+/**
+ * If we return:
+ * - true - that means that the order of the choices will be ordinal (as is created in the configure item)
+ * - false - that means the getShuffledChoices above will be called and that in turn means that we either
+ * return the shuffled values on the session (if any exists) or we shuffle the choices
+ * @param model - model to check if we should lock order
+ * @param session - session to check if we should lock order
+ * @param env - env to check if we should lock order
+ * @returns {boolean}
+ */
+
+
+exports.getShuffledChoices = getShuffledChoices;
+
+var lockChoices = function lockChoices(model, session, env) {
+  if (model.lockChoiceOrder) {
+    return true;
+  }
+
+  log('lockChoiceOrder: ', (0, _get["default"])(env, ['@pie-element', 'lockChoiceOrder'], false));
+
+  if ((0, _get["default"])(env, ['@pie-element', 'lockChoiceOrder'], false)) {
+    return true;
+  }
+
+  var role = (0, _get["default"])(env, 'role', 'student');
+
+  if (role === 'instructor') {
+    // TODO: .. in the future the instructor can toggle between ordinal and shuffled here, so keeping this code until then
+
+    /*const alreadyShuffled = hasShuffledValues(session);
+     if (alreadyShuffled) {
+      return false;
+    }
+     return true;*/
+    return true;
+  } // here it's a student, so don't lock and it will shuffle if needs be
+
+
+  return false;
+};
+
+exports.lockChoices = lockChoices;
+//# sourceMappingURL=persistence.js.map

package/controller/node_modules/@pie-lib/controller-utils/lib/persistence.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/persistence.js"],"names":["lg","n","console","bind","debug","log","warn","error","compact","arr","Array","isArray","filter","v","undefined","getShuffledChoices","choices","session","updateSession","choiceKey","Promise","resolve","currentShuffled","data","shuffledValues","map","find","c","shuffledChoices","id","element","JSON","stringify","e","lockChoices","model","env","lockChoiceOrder","role"],"mappings":";;;;;;;;;;;AAAA;;AACA;;AACA;;AAEA;AACA,IAAMA,EAAE,GAAG,SAALA,EAAK,CAACC,CAAD;AAAA,SAAOC,OAAO,CAACD,CAAD,CAAP,CAAWE,IAAX,CAAgBD,OAAhB,EAAyB,mBAAzB,CAAP;AAAA,CAAX;;AACA,IAAME,KAAK,GAAGJ,EAAE,CAAC,OAAD,CAAhB;AACA,IAAMK,GAAG,GAAGL,EAAE,CAAC,KAAD,CAAd;AACA,IAAMM,IAAI,GAAGN,EAAE,CAAC,MAAD,CAAf;AACA,IAAMO,KAAK,GAAGP,EAAE,CAAC,OAAD,CAAhB;;AAEO,IAAMQ,OAAO,GAAG,SAAVA,OAAU,CAACC,GAAD,EAAS;AAC9B,MAAIC,KAAK,CAACC,OAAN,CAAcF,GAAd,CAAJ,EAAwB;AACtB,WAAOA,GAAG,CAACG,MAAJ,CAAW,UAACC,CAAD;AAAA,aAAOA,CAAC,KAAK,IAAN,IAAcA,CAAC,KAAKC,SAA3B;AAAA,KAAX,CAAP;AACD;;AACD,SAAOL,GAAP;AACD,CALM;;;;AAOA,IAAMM,kBAAkB,GAAG,SAArBA,kBAAqB,CAACC,OAAD,EAAUC,OAAV,EAAmBC,aAAnB,EAAkCC,SAAlC;AAAA,SAChC,IAAIC,OAAJ,CAAY,UAACC,OAAD,EAAa;AAAA;;AACvBhB,IAAAA,GAAG,CAAC,sBAAD,2BAAgCa,aAAhC,EAAH;AACAb,IAAAA,GAAG,CAAC,WAAD,EAAcY,OAAd,CAAH;AAEA,QAAMK,eAAe,GAAGd,OAAO,CAAC,CAAAS,OAAO,SAAP,IAAAA,OAAO,WAAP,6BAAAA,OAAO,CAAEM,IAAT,gEAAeC,cAAf,MAAiCP,OAAjC,aAAiCA,OAAjC,uBAAiCA,OAAO,CAAEO,cAA1C,KAA4D,EAA7D,CAA/B;;AAEA,QAAI,CAACP,OAAL,EAAc;AACZ;AACAX,MAAAA,IAAI,CAAC,6DAAD,CAAJ;AACAe,MAAAA,OAAO,CAACP,SAAD,CAAP;AACD,KAJD,MAIO,IAAI,CAAC,yBAAQQ,eAAR,CAAL,EAA+B;AAAA;;AACpClB,MAAAA,KAAK,CAAC,2CAAD,oBAA8Ca,OAAO,CAACM,IAAtD,mDAA8C,eAAcC,cAA5D,CAAL;AACAH,MAAAA,OAAO,CAACb,OAAO,CAACc,eAAe,CAACG,GAAhB,CAAoB,UAACZ,CAAD;AAAA,eAAOG,OAAO,CAACU,IAAR,CAAa,UAACC,CAAD;AAAA,iBAAOA,CAAC,CAACR,SAAD,CAAD,KAAiBN,CAAxB;AAAA,SAAb,CAAP;AAAA,OAApB,CAAD,CAAR,CAAP;AACD,KAHM,MAGA;AACL,UAAMe,eAAe,GAAG,yBAAQZ,OAAR,CAAxB;;AAEA,UAAIE,aAAa,IAAI,OAAOA,aAAP,KAAyB,UAA9C,EAA0D;AACxD,YAAI;AACF;AACA,cAAMM,cAAc,GAAGhB,OAAO,CAACoB,eAAe,CAACH,GAAhB,CAAoB,UAACE,CAAD;AAAA,mBAAOA,CAAC,CAACR,SAAD,CAAR;AAAA,WAApB,CAAD,CAA9B;AACAd,UAAAA,GAAG,CAAC,0CAAD,EAA6CmB,cAA7C,CAAH;AACAnB,UAAAA,GAAG,CAAC,wBAAD,EAA2BY,OAAO,CAACY,EAAnC,EAAuCZ,OAAO,CAACa,OAA/C,CAAH;;AACA,cAAI,yBAAQN,cAAR,CAAJ,EAA6B;AAC3BjB,YAAAA,KAAK,gGACqFwB,IAAI,CAACC,SAAL,CACtFJ,eADsF,CADrF,oBAGQT,SAHR,EAAL;AAKD,WAND,MAMO;AACLD,YAAAA,aAAa,CAACD,OAAO,CAACY,EAAT,EAAaZ,OAAO,CAACa,OAArB,EAA8B;AAAEN,cAAAA,cAAc,EAAdA;AAAF,aAA9B,CAAb,UAAqE,UAACS,CAAD;AAAA,qBACnE;AACA/B,gBAAAA,OAAO,CAACK,KAAR,CAAc,6BAAd,EAA6CU,OAAO,CAACY,EAArD,EAAyDI,CAAzD;AAFmE;AAAA,aAArE;AAID;AACF,SAjBD,CAiBE,OAAOA,CAAP,EAAU;AACV3B,UAAAA,IAAI,CAAC,2CAAD,CAAJ;AACAC,UAAAA,KAAK,CAAC0B,CAAD,CAAL;AACD;AACF,OAtBD,MAsBO;AACL3B,QAAAA,IAAI,CAAC,kEAAD,CAAJ;AACD,OA3BI,CA4BL;;;AACAe,MAAAA,OAAO,CAACO,eAAD,CAAP;AACD;AACF,GA5CD,CADgC;AAAA,CAA3B;AA+CP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;AACO,IAAMM,WAAW,GAAG,SAAdA,WAAc,CAACC,KAAD,EAAQlB,OAAR,EAAiBmB,GAAjB,EAAyB;AAClD,MAAID,KAAK,CAACE,eAAV,EAA2B;AACzB,WAAO,IAAP;AACD;;AAEDhC,EAAAA,GAAG,CAAC,mBAAD,EAAsB,qBAAI+B,GAAJ,EAAS,CAAC,cAAD,EAAiB,iBAAjB,CAAT,EAA8C,KAA9C,CAAtB,CAAH;;AAEA,MAAI,qBAAIA,GAAJ,EAAS,CAAC,cAAD,EAAiB,iBAAjB,CAAT,EAA8C,KAA9C,CAAJ,EAA0D;AACxD,WAAO,IAAP;AACD;;AAED,MAAME,IAAI,GAAG,qBAAIF,GAAJ,EAAS,MAAT,EAAiB,SAAjB,CAAb;;AAEA,MAAIE,IAAI,KAAK,YAAb,EAA2B;AACzB;;AACA;AACJ;AACA;AACA;AACA;AAGI,WAAO,IAAP;AACD,GAvBiD,CAyBlD;;;AACA,SAAO,KAAP;AACD,CA3BM","sourcesContent":["import get from 'lodash/get';\nimport shuffle from 'lodash/shuffle';\nimport isEmpty from 'lodash/isEmpty';\n\n// eslint-disable-next-line no-console\nconst lg = (n) => console[n].bind(console, 'controller-utils:');\nconst debug = lg('debug');\nconst log = lg('log');\nconst warn = lg('warn');\nconst error = lg('error');\n\nexport const compact = (arr) => {\n  if (Array.isArray(arr)) {\n    return arr.filter((v) => v !== null && v !== undefined);\n  }\n  return arr;\n};\n\nexport const getShuffledChoices = (choices, session, updateSession, choiceKey) =>\n  new Promise((resolve) => {\n    log('updateSession type: ', typeof updateSession);\n    log('session: ', session);\n\n    const currentShuffled = compact(session?.data?.shuffledValues || session?.shuffledValues || []);\n\n    if (!session) {\n      // eslint-disable-next-line quotes\n      warn(\"unable to save shuffled choices because there's no session.\");\n      resolve(undefined);\n    } else if (!isEmpty(currentShuffled)) {\n      debug('use shuffledValues to sort the choices...', session.data?.shuffledValues);\n      resolve(compact(currentShuffled.map((v) => choices.find((c) => c[choiceKey] === v))));\n    } else {\n      const shuffledChoices = shuffle(choices);\n\n      if (updateSession && typeof updateSession === 'function') {\n        try {\n          //Note: session.id refers to the id of the element within a session\n          const shuffledValues = compact(shuffledChoices.map((c) => c[choiceKey]));\n          log('try to save shuffledValues to session...', shuffledValues);\n          log('call updateSession... ', session.id, session.element);\n          if (isEmpty(shuffledValues)) {\n            error(\n              `shuffledValues is an empty array? - refusing to call updateSession: shuffledChoices: ${JSON.stringify(\n                shuffledChoices,\n              )}, key: ${choiceKey}`,\n            );\n          } else {\n            updateSession(session.id, session.element, { shuffledValues }).catch((e) =>\n              // eslint-disable-next-line no-console\n              console.error('update session failed for: ', session.id, e),\n            );\n          }\n        } catch (e) {\n          warn('unable to save shuffled order for choices');\n          error(e);\n        }\n      } else {\n        warn('unable to save shuffled choices, shuffle will happen every time.');\n      }\n      //save this shuffle to the session for later retrieval\n      resolve(shuffledChoices);\n    }\n  });\n\n/**\n * If we return:\n * - true - that means that the order of the choices will be ordinal (as is created in the configure item)\n * - false - that means the getShuffledChoices above will be called and that in turn means that we either\n * return the shuffled values on the session (if any exists) or we shuffle the choices\n * @param model - model to check if we should lock order\n * @param session - session to check if we should lock order\n * @param env - env to check if we should lock order\n * @returns {boolean}\n */\nexport const lockChoices = (model, session, env) => {\n  if (model.lockChoiceOrder) {\n    return true;\n  }\n\n  log('lockChoiceOrder: ', get(env, ['@pie-element', 'lockChoiceOrder'], false));\n\n  if (get(env, ['@pie-element', 'lockChoiceOrder'], false)) {\n    return true;\n  }\n\n  const role = get(env, 'role', 'student');\n\n  if (role === 'instructor') {\n    // TODO: .. in the future the instructor can toggle between ordinal and shuffled here, so keeping this code until then\n    /*const alreadyShuffled = hasShuffledValues(session);\n\n    if (alreadyShuffled) {\n      return false;\n    }\n\n    return true;*/\n    return true;\n  }\n\n  // here it's a student, so don't lock and it will shuffle if needs be\n  return false;\n};\n"],"file":"persistence.js"}

package/controller/node_modules/@pie-lib/controller-utils/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "@pie-lib/controller-utils",
+  "version": "0.19.2",
+  "description": "",
+  "main": "lib/index.js",
+  "module": "src/index.js",
+  "dependencies": {
+    "debug": "^4.1.1",
+    "lodash": "^4.17.11"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {},
+  "author": "",
+  "license": "ISC",
+  "gitHead": "8a327571bd64249e4c88c0c8e750d16d6213f535",
+  "exports": {
+    ".": {
+      "import": "./esm/index.js",
+      "require": "./lib/index.js",
+      "default": "./esm/index.js"
+    }
+  }
+}

package/controller/node_modules/@pie-lib/controller-utils/src/__tests__/partial-scoring.test.js

@@ -0,0 +1,25 @@
+import { enabled } from '../partial-scoring';
+
+describe('enabled', () => {
+  const assertEnabled = (config, env, expected) => {
+    it(`returns ${expected} for: config: ${config.partialScoring}, env:${env.partialScoring}`, () => {
+      const result = enabled(config, env);
+      expect(result).toEqual(expected);
+    });
+  };
+
+  const config = (v) => ({ partialScoring: v });
+  const env = (v) => ({ partialScoring: v });
+
+  assertEnabled(config(undefined), env(undefined), true);
+  assertEnabled(config(undefined), env(true), true);
+  assertEnabled(config(undefined), env(false), false);
+
+  assertEnabled(config(false), env(undefined), false);
+  assertEnabled(config(false), env(true), false);
+  assertEnabled(config(false), env(false), false);
+
+  assertEnabled(config(true), env(undefined), true);
+  assertEnabled(config(true), env(true), true);
+  assertEnabled(config(true), env(false), false);
+});

package/controller/node_modules/@pie-lib/controller-utils/src/__tests__/persistence.test.js

@@ -0,0 +1,151 @@
+import { getShuffledChoices, lockChoices } from '../persistence';
+
+describe('getShuffledChoices', () => {
+  let choices, session, updateSession, key;
+
+  beforeEach(() => {
+    updateSession = jest.fn().mockResolvedValue([]);
+    session = {
+      id: '1',
+      element: 'element',
+    };
+    choices = [
+      {
+        value: 1,
+      },
+      {
+        value: 2,
+      },
+    ];
+    key = 'value';
+  });
+
+  describe('0 key', () => {
+    it('calls update session w/ 0 as a key', async () => {
+      const result = await getShuffledChoices([{ value: 0 }, { value: 1 }], session, updateSession, 'value');
+      expect(updateSession).toHaveBeenCalledWith(session.id, session.element, {
+        shuffledValues: expect.arrayContaining([0, 1]),
+      });
+    });
+  });
+
+  describe('handles null values in session', () => {
+    beforeEach(async () => {
+      const result = await getShuffledChoices(choices, { ...session, shuffledValues: [null] }, updateSession, 'value');
+    });
+
+    it('calls updateSession w/ new shuffle cos [null] is treated as empty', () => {
+      expect(updateSession).toHaveBeenCalledWith(session.id, session.element, {
+        shuffledValues: expect.arrayContaining([1, 2]),
+      });
+    });
+  });
+  describe('bad shuffle generation does not call updateSession', () => {
+    beforeEach(async () => {
+      const result = await getShuffledChoices(choices, {}, updateSession, 'foo');
+    });
+    it('does not call update session', () => {
+      expect(updateSession).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('session does not exist', () => {
+    it('returns undefined for empty session', async () => {
+      const result = await getShuffledChoices(choices, undefined, updateSession, key);
+      expect(result).toEqual(undefined);
+    });
+  });
+
+  describe('session exists', () => {
+    it('returns compact choices if session has shuffledValues', async () => {
+      session = { shuffledValues: [2, 1] };
+      const result = await getShuffledChoices(choices, session, updateSession, key);
+      expect(result).toEqual(expect.arrayContaining(choices));
+    });
+
+    it('returns shuffled choices if updateSession is a function', async () => {
+      session = {};
+      updateSession = jest.fn().mockResolvedValue();
+      const result = await getShuffledChoices(choices, session, updateSession, key);
+      expect(result).toEqual(expect.arrayContaining(choices));
+    });
+
+    it('calls updateSession as expected if updateSession is a function', async () => {
+      session = { id: '1', element: 'pie-element' };
+      await getShuffledChoices(choices, session, updateSession, key);
+      expect(updateSession).toHaveBeenCalledWith('1', 'pie-element', {
+        shuffledValues: expect.arrayContaining([1, 2]),
+      });
+    });
+  });
+});
+
+describe('lockChoices', () => {
+  const env = (lockChoiceOrder, role = 'student') => ({
+    '@pie-element': { lockChoiceOrder },
+    role,
+  });
+  const session = (shuffledValues) => ({ shuffledValues });
+  it.each`
+    modelLock    | session            | env                         | expected
+    ${true}      | ${session()}       | ${env(true)}                | ${true}
+    ${true}      | ${session()}       | ${env(false)}               | ${true}
+    ${false}     | ${session()}       | ${env(true)}                | ${true}
+    ${false}     | ${session()}       | ${env(false)}               | ${false}
+    ${false}     | ${session()}       | ${undefined}                | ${false}
+    ${false}     | ${undefined}       | ${undefined}                | ${false}
+    ${undefined} | ${session()}       | ${env(false)}               | ${false}
+    ${undefined} | ${session()}       | ${env(undefined)}           | ${false}
+    ${false}     | ${session()}       | ${env(false, 'instructor')} | ${true}
+    ${false}     | ${session([0, 1])} | ${env(false, 'instructor')} | ${true}
+    ${false}     | ${undefined}       | ${env(false, 'instructor')} | ${true}
+  `('1. model.lockChoiceOrder: $modelLock, $session, $env => $expected', ({ modelLock, session, env, expected }) => {
+    const model = { lockChoiceOrder: modelLock };
+    const result = lockChoices(model, session, env);
+    expect(result).toEqual(expected);
+  });
+});
+
+describe('lockChoices mod', () => {
+  const env = (lockChoiceOrder, role = 'student') => ({
+    '@pie-element': { lockChoiceOrder },
+    role,
+  });
+  const session = (answers = ['foo', 'bar']) => ({ answers });
+  it.each`
+    modelLock    | session      | env                             | expected
+    ${true}      | ${session()} | ${env(true)}                    | ${true}
+    ${true}      | ${session()} | ${env(false)}                   | ${true}
+    ${false}     | ${session()} | ${env(true)}                    | ${true}
+    ${false}     | ${session()} | ${env(false)}                   | ${false}
+    ${undefined} | ${session()} | ${env(true)}                    | ${true}
+    ${undefined} | ${session()} | ${env(undefined)}               | ${false}
+    ${undefined} | ${session()} | ${env(undefined, 'instructor')} | ${true}
+  `('2. model.lockChoiceOrder: $modelLock, $session, $env => $expected', ({ modelLock, session, env, expected }) => {
+    const model = { lockChoiceOrder: modelLock };
+    const result = lockChoices(model, session, env);
+    expect(result).toEqual(expected);
+  });
+});
+
+describe('lockChoices', () => {
+  const env = (lockChoiceOrder, role = 'student') => ({
+    '@pie-element': { lockChoiceOrder },
+    role,
+  });
+  const session = (shuffledValues) => ({ shuffledValues, answers: ['foo', 'bar'] });
+  it.each`
+    modelLock    | session      | env                             | expected
+    ${true}      | ${session()} | ${env(true)}                    | ${true}
+    ${true}      | ${session()} | ${env(false)}                   | ${true}
+    ${false}     | ${session()} | ${env(true)}                    | ${true}
+    ${false}     | ${session()} | ${env(false)}                   | ${false}
+    ${undefined} | ${session()} | ${env(true)}                    | ${true}
+    ${undefined} | ${session()} | ${env(undefined)}               | ${false}
+    ${undefined} | ${session()} | ${env(undefined, 'instructor')} | ${true}
+  `('3. model.lockChoiceOrder: $modelLock, $env => $expected', ({ modelLock, session, env, expected }) => {
+    const model = { lockChoiceOrder: modelLock };
+    const result = lockChoices(model, session, env);
+    expect(result).toEqual(expected);
+  });
+});

package/controller/node_modules/@pie-lib/controller-utils/src/index.js

@@ -0,0 +1,4 @@
+import * as partialScoring from './partial-scoring';
+
+export { lockChoices, getShuffledChoices } from './persistence';
+export { partialScoring };

package/controller/node_modules/@pie-lib/controller-utils/src/partial-scoring.js

@@ -0,0 +1,19 @@
+export const enabled = (config, env, defaultValue) => {
+  // if model.partialScoring = false
+  //  - if env.partialScoring = false || env.partialScoring = true => use dichotomous scoring
+  // else if model.partialScoring = true || undefined
+  //  - if env.partialScoring = false, use dichotomous scoring
+  //  - else if env.partialScoring = true, use partial scoring
+  config = config || {};
+  env = env || {};
+
+  if (config.partialScoring === false) {
+    return false;
+  }
+
+  if (env.partialScoring === false) {
+    return false;
+  }
+
+  return typeof defaultValue === 'boolean' ? defaultValue : true;
+};

package/controller/node_modules/@pie-lib/controller-utils/src/persistence.js

@@ -0,0 +1,103 @@
+import get from 'lodash/get';
+import shuffle from 'lodash/shuffle';
+import isEmpty from 'lodash/isEmpty';
+
+// eslint-disable-next-line no-console
+const lg = (n) => console[n].bind(console, 'controller-utils:');
+const debug = lg('debug');
+const log = lg('log');
+const warn = lg('warn');
+const error = lg('error');
+
+export const compact = (arr) => {
+  if (Array.isArray(arr)) {
+    return arr.filter((v) => v !== null && v !== undefined);
+  }
+  return arr;
+};
+
+export const getShuffledChoices = (choices, session, updateSession, choiceKey) =>
+  new Promise((resolve) => {
+    log('updateSession type: ', typeof updateSession);
+    log('session: ', session);
+
+    const currentShuffled = compact(session?.data?.shuffledValues || session?.shuffledValues || []);
+
+    if (!session) {
+      // eslint-disable-next-line quotes
+      warn("unable to save shuffled choices because there's no session.");
+      resolve(undefined);
+    } else if (!isEmpty(currentShuffled)) {
+      debug('use shuffledValues to sort the choices...', session.data?.shuffledValues);
+      resolve(compact(currentShuffled.map((v) => choices.find((c) => c[choiceKey] === v))));
+    } else {
+      const shuffledChoices = shuffle(choices);
+
+      if (updateSession && typeof updateSession === 'function') {
+        try {
+          //Note: session.id refers to the id of the element within a session
+          const shuffledValues = compact(shuffledChoices.map((c) => c[choiceKey]));
+          log('try to save shuffledValues to session...', shuffledValues);
+          log('call updateSession... ', session.id, session.element);
+          if (isEmpty(shuffledValues)) {
+            error(
+              `shuffledValues is an empty array? - refusing to call updateSession: shuffledChoices: ${JSON.stringify(
+                shuffledChoices,
+              )}, key: ${choiceKey}`,
+            );
+          } else {
+            updateSession(session.id, session.element, { shuffledValues }).catch((e) =>
+              // eslint-disable-next-line no-console
+              console.error('update session failed for: ', session.id, e),
+            );
+          }
+        } catch (e) {
+          warn('unable to save shuffled order for choices');
+          error(e);
+        }
+      } else {
+        warn('unable to save shuffled choices, shuffle will happen every time.');
+      }
+      //save this shuffle to the session for later retrieval
+      resolve(shuffledChoices);
+    }
+  });
+
+/**
+ * If we return:
+ * - true - that means that the order of the choices will be ordinal (as is created in the configure item)
+ * - false - that means the getShuffledChoices above will be called and that in turn means that we either
+ * return the shuffled values on the session (if any exists) or we shuffle the choices
+ * @param model - model to check if we should lock order
+ * @param session - session to check if we should lock order
+ * @param env - env to check if we should lock order
+ * @returns {boolean}
+ */
+export const lockChoices = (model, session, env) => {
+  if (model.lockChoiceOrder) {
+    return true;
+  }
+
+  log('lockChoiceOrder: ', get(env, ['@pie-element', 'lockChoiceOrder'], false));
+
+  if (get(env, ['@pie-element', 'lockChoiceOrder'], false)) {
+    return true;
+  }
+
+  const role = get(env, 'role', 'student');
+
+  if (role === 'instructor') {
+    // TODO: .. in the future the instructor can toggle between ordinal and shuffled here, so keeping this code until then
+    /*const alreadyShuffled = hasShuffledValues(session);
+
+    if (alreadyShuffled) {
+      return false;
+    }
+
+    return true;*/
+    return true;
+  }
+
+  // here it's a student, so don't lock and it will shuffle if needs be
+  return false;
+};

package/controller/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@pie-element/hotspot-controller",
   "private": true,
-  "version": "6.0.2",
+  "version": "11.0.5-esm.0",
   "description": "",
   "scripts": {
     "test": "echo \"Error: no test specified\" && exit 1"
@@ -11,7 +11,7 @@
   "main": "lib/index.js",
   "module": "src/index.js",
   "dependencies": {
-    "@pie-lib/controller-utils": "^0.19.0",
+    "@pie-lib/controller-utils": "^0.19.2",
     "debug": "^4.1.1",
     "lodash": "^4.17.15"
   }