@pie-element/placement-ordering 12.0.2-esm.0 → 12.2.0

package/esm/controller.js

@@ -1,924 +0,0 @@
-import _ from 'lodash';
-import debug from 'debug';
-import { getFeedbackForCorrectness } from '@pie-lib/feedback';
-import { partialScoring } from '@pie-lib/controller-utils';
-import isEqual from 'lodash/isEqual';
-import isEmpty from 'lodash/isEmpty';
-import Translator from '@pie-lib/translator';
-
-function _extends() {
-  _extends = Object.assign || function (target) {
-    for (var i = 1; i < arguments.length; i++) {
-      var source = arguments[i];
-
-      for (var key in source) {
-        if (Object.prototype.hasOwnProperty.call(source, key)) {
-          target[key] = source[key];
-        }
-      }
-    }
-
-    return target;
-  };
-
-  return _extends.apply(this, arguments);
-}
-
-var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
-
-var combinatorics = {exports: {}};
-
-/*
- * $Id: combinatorics.js,v 0.25 2013/03/11 15:42:14 dankogai Exp dankogai $
- *
- *  Licensed under the MIT license.
- *  http://www.opensource.org/licenses/mit-license.php
- *
- *  References:
- *    http://www.ruby-doc.org/core-2.0/Array.html#method-i-combination
- *    http://www.ruby-doc.org/core-2.0/Array.html#method-i-permutation
- *    http://en.wikipedia.org/wiki/Factorial_number_system
- */
-
-(function (module, exports) {
-(function (root, factory) {
-    {
-        module.exports = factory();
-    }
-}(commonjsGlobal, function () {
-    var version = "0.5.5";
-    /* combinatory arithmetics */
-    var P = function(m, n) {
-        if (n % 1 !== 0) throw new RangeError;
-        var p = 1;
-        while (n--) p *= m--;
-        return p;
-    };
-    var C = function(m, n) {
-        if (n > m) {
-            return 0;
-        }
-        return P(m, n) / P(n, n);
-    };
-    var factorial = function(n) {
-        return P(n, n);
-    };
-    var factoradic = function(n, d) {
-        var f = 1;
-        if (!d) {
-            for (d = 1; f < n; f *= ++d);
-            if (f > n) f /= d--;
-        } else {
-            f = factorial(d);
-        }
-        var result = [0];
-        for (; d; f /= d--) {
-            result[d] = Math.floor(n / f);
-            n %= f;
-        }
-        return result;
-    };
-    /* common methods */
-    var addProperties = function(dst, src) {
-        Object.keys(src).forEach(function(p) {
-            Object.defineProperty(dst, p, {
-                value: src[p],
-                configurable: p == 'next'
-            });
-        });
-    };
-    var hideProperty = function(o, p) {
-        Object.defineProperty(o, p, {
-            writable: true
-        });
-    };
-    var toArray = function(f) {
-        var e, result = [];
-        this.init();
-        while (e = this.next()) result.push(f ? f(e) : e);
-        this.init();
-        return result;
-    };
-    var common = {
-        toArray: toArray,
-        map: toArray,
-        forEach: function(f) {
-            var e;
-            this.init();
-            while (e = this.next()) f(e);
-            this.init();
-        },
-        filter: function(f) {
-            var e, result = [];
-            this.init();
-            while (e = this.next()) if (f(e)) result.push(e);
-            this.init();
-            return result;
-        },
-        find: function(f) {
-            var e, result;
-            this.init();
-            while (e = this.next()) {
-                if (f(e)) {
-                    result = e;
-                    break;
-                }
-            }
-            this.init();
-            return result;
-        },
-        reduce: function(reducer, result) {
-            // return this.toArray().reduce(reducer, init);
-            this.init();
-            var index = 0;
-            if (arguments.length < 2) {
-                result = this.next();
-                index += 1;
-            }
-            var length = this.length;
-            while(index < length) {
-                result = reducer(result, this.next(), index, this);
-                index += 1;
-            }
-            return result;
-        },
-        lazyMap: function(f) {
-            this._lazyMap = f;
-            return this;
-        },
-        lazyFilter: function(f) {
-            Object.defineProperty(this, 'next', {
-                writable: true
-            });
-            if (typeof f !== 'function') {
-                this.next = this._next;
-            } else {
-                if (typeof (this._next) !== 'function') {
-                    this._next = this.next;
-                }
-                var _next = this._next.bind(this);
-                this.next = (function() {
-                    var e;
-                    while (e = _next()) {
-                        if (f(e))
-                            return e;
-                    }
-                    return e;
-                }).bind(this);
-            }
-            Object.defineProperty(this, 'next', {
-                writable: false
-            });
-            return this;
-        }
-
-    };
-    /* power set */
-    var power = function(ary, fun) {
-        var size = 1 << ary.length,
-            sizeOf = function() {
-                return size;
-            },
-            that = Object.create(ary.slice(), {
-                length: {
-                    get: sizeOf
-                }
-            });
-        hideProperty(that, 'index');
-        addProperties(that, {
-            valueOf: sizeOf,
-            init: function() {
-                that.index = 0;
-            },
-            nth: function(n) {
-                if (n >= size) return;
-                var i = 0,
-                    result = [];
-                for (; n; n >>>= 1, i++) if (n & 1) result.push(this[i]);
-                return (typeof (that._lazyMap) === 'function')?that._lazyMap(result):result;
-            },
-            next: function() {
-                return this.nth(this.index++);
-            }
-        });
-        addProperties(that, common);
-        that.init();
-        return (typeof (fun) === 'function') ? that.map(fun) : that;
-    };
-    /* combination */
-    var nextIndex = function(n) {
-        var smallest = n & -n,
-            ripple = n + smallest,
-            new_smallest = ripple & -ripple,
-            ones = ((new_smallest / smallest) >> 1) - 1;
-        return ripple | ones;
-    };
-    var combination = function(ary, nelem, fun) {
-        if (!nelem) nelem = ary.length;
-        if (nelem < 1) throw new RangeError;
-        if (nelem > ary.length) throw new RangeError;
-        var first = (1 << nelem) - 1,
-            size = C(ary.length, nelem),
-            maxIndex = 1 << ary.length,
-            sizeOf = function() {
-                return size;
-            },
-            that = Object.create(ary.slice(), {
-                length: {
-                    get: sizeOf
-                }
-            });
-        hideProperty(that, 'index');
-        addProperties(that, {
-            valueOf: sizeOf,
-            init: function() {
-                this.index = first;
-            },
-            next: function() {
-                if (this.index >= maxIndex) return;
-                var i = 0,
-                    n = this.index,
-                    result = [];
-                for (; n; n >>>= 1, i++) {
-                    if (n & 1) result[result.length] = this[i];
-                }
-
-                this.index = nextIndex(this.index);
-                return (typeof (that._lazyMap) === 'function')?that._lazyMap(result):result;
-            }
-        });
-        addProperties(that, common);
-        that.init();
-        return (typeof (fun) === 'function') ? that.map(fun) : that;
-    };
-    /* bigcombination */
-    var bigNextIndex = function(n, nelem) {
-
-        var result = n;
-        var j = nelem;
-        var i = 0;
-        for (i = result.length - 1; i >= 0; i--) {
-            if (result[i] == 1) {
-                j--;
-            } else {
-                break;
-            }
-        } 
-        if (j == 0) {
-            // Overflow
-            result[result.length] = 1;
-            for (var k = result.length - 2; k >= 0; k--) {
-                result[k] = (k < nelem-1)?1:0;
-            }
-        } else {
-            // Normal
-
-            // first zero after 1
-            var i1 = -1;
-            var i0 = -1;
-            for (var i = 0; i < result.length; i++) {
-                if (result[i] == 0 && i1 != -1) {
-                    i0 = i;
-                }
-                if (result[i] == 1) {
-                    i1 = i;
-                }
-                if (i0 != -1 && i1 != -1) {
-                    result[i0] = 1;
-                    result[i1] = 0;
-                    break;
-                }
-            }
-
-            j = nelem;
-            for (var i = result.length - 1; i >= i1; i--) {
-                if (result[i] == 1)
-                    j--;
-            }
-            for (var i = 0; i < i1; i++) {
-                result[i] = (i < j)?1:0;
-            }
-        }
-
-        return result;
-
-    };
-    var buildFirst = function(nelem) {
-        var result = [];
-        for (var i = 0; i < nelem; i++) {
-            result[i] = 1;
-        }
-        result[0] = 1;
-        return result;
-    };
-    var bigCombination = function(ary, nelem, fun) {
-        if (!nelem) nelem = ary.length;
-        if (nelem < 1) throw new RangeError;
-        if (nelem > ary.length) throw new RangeError;
-        var first = buildFirst(nelem),
-            size = C(ary.length, nelem),
-            maxIndex = ary.length,
-            sizeOf = function() {
-                return size;
-            },
-            that = Object.create(ary.slice(), {
-                length: {
-                    get: sizeOf
-                }
-            });
-        hideProperty(that, 'index');
-        addProperties(that, {
-            valueOf: sizeOf,
-            init: function() {
-                this.index = first.concat();
-            },
-            next: function() {
-                if (this.index.length > maxIndex) return;
-                var i = 0,
-                    n = this.index,
-                    result = [];
-                for (var j = 0; j < n.length; j++, i++) {
-                    if (n[j])
-                        result[result.length] = this[i];
-                }
-                bigNextIndex(this.index, nelem);
-                return (typeof (that._lazyMap) === 'function')?that._lazyMap(result):result;
-            }
-        });
-        addProperties(that, common);
-        that.init();
-        return (typeof (fun) === 'function') ? that.map(fun) : that;
-    };
-    /* permutation */
-    var _permutation = function(ary) {
-        var that = ary.slice(),
-            size = factorial(that.length);
-        that.index = 0;
-        that.next = function() {
-            if (this.index >= size) return;
-            var copy = this.slice(),
-                digits = factoradic(this.index, this.length),
-                result = [],
-                i = this.length - 1;
-            for (; i >= 0; --i) result.push(copy.splice(digits[i], 1)[0]);
-            this.index++;
-            return (typeof (that._lazyMap) === 'function')?that._lazyMap(result):result;
-        };
-        return that;
-    };
-    // which is really a permutation of combination
-    var permutation = function(ary, nelem, fun) {
-        if (!nelem) nelem = ary.length;
-        if (nelem < 1) throw new RangeError;
-        if (nelem > ary.length) throw new RangeError;
-        var size = P(ary.length, nelem),
-            sizeOf = function() {
-                return size;
-            },
-            that = Object.create(ary.slice(), {
-                length: {
-                    get: sizeOf
-                }
-            });
-        hideProperty(that, 'cmb');
-        hideProperty(that, 'per');
-        addProperties(that, {
-            valueOf: function() {
-                return size;
-            },
-            init: function() {
-                /* combination can only be used for less than 31 elements */
-                if (ary.length < 31) {
-                    this.cmb = combination(ary, nelem);
-                } else {
-                    this.cmb = bigCombination(ary, nelem);
-                }
-                
-                this.per = _permutation(this.cmb.next());
-            },
-            next: function() {
-                var result = this.per.next();
-                if (!result) {
-                    var cmb = this.cmb.next();
-                    if (!cmb) return;
-                    this.per = _permutation(cmb);
-                    return this.next();
-                }
-                return (typeof (that._lazyMap) === 'function')?that._lazyMap(result):result;
-            }
-        });
-        addProperties(that, common);
-        that.init();
-        return (typeof (fun) === 'function') ? that.map(fun) : that;
-    };
-
-    var PC = function(m) {
-        var total = 0;
-        for (var n = 1; n <= m; n++) {
-            var p = P(m,n);
-            total += p;
-        }        return total;
-    };
-    // which is really a permutation of combination
-    var permutationCombination = function(ary, fun) {
-        // if (!nelem) nelem = ary.length;
-        // if (nelem < 1) throw new RangeError;
-        // if (nelem > ary.length) throw new RangeError;
-        var size = PC(ary.length),
-            sizeOf = function() {
-                return size;
-            },
-            that = Object.create(ary.slice(), {
-                length: {
-                    get: sizeOf
-                }
-            });
-        hideProperty(that, 'cmb');
-        hideProperty(that, 'per');
-        hideProperty(that, 'nelem');
-        addProperties(that, {
-            valueOf: function() {
-                return size;
-            },
-            init: function() {
-                this.nelem = 1;
-                // console.log("Starting nelem: " + this.nelem);
-                this.cmb = combination(ary, this.nelem);
-                this.per = _permutation(this.cmb.next());
-            },
-            next: function() {
-                var result = this.per.next();
-                if (!result) {
-                    var cmb = this.cmb.next();
-                    if (!cmb) {
-                        this.nelem++;
-                        // console.log("increment nelem: " + this.nelem + " vs " + ary.length);
-                        if (this.nelem > ary.length) return;
-                        this.cmb = combination(ary, this.nelem);
-                        cmb = this.cmb.next();
-                        if (!cmb) return;
-                    }
-                    this.per = _permutation(cmb);
-                    return this.next();
-                }
-                return (typeof (that._lazyMap) === 'function')?that._lazyMap(result):result;
-            }
-        });
-        addProperties(that, common);
-        that.init();
-        return (typeof (fun) === 'function') ? that.map(fun) : that;
-    };
-    /* Cartesian Product */
-    var arraySlice = Array.prototype.slice;
-    var cartesianProduct = function() {
-        if (!arguments.length) throw new RangeError;
-        var args = arraySlice.call(arguments),
-            size = args.reduce(function(p, a) {
-                return p * a.length;
-            }, 1),
-            sizeOf = function() {
-                return size;
-            },
-            dim = args.length,
-            that = Object.create(args, {
-                length: {
-                    get: sizeOf
-                }
-            });
-        if (!size) throw new RangeError;
-        hideProperty(that, 'index');
-        addProperties(that, {
-            valueOf: sizeOf,
-            dim: dim,
-            init: function() {
-                this.index = 0;
-            },
-            get: function() {
-                if (arguments.length !== this.length) return;
-                var result = [],
-                    d = 0;
-                for (; d < dim; d++) {
-                    var i = arguments[d];
-                    if (i >= this[d].length) return;
-                    result.push(this[d][i]);
-                }
-                return (typeof (that._lazyMap) === 'function')?that._lazyMap(result):result;
-            },
-            nth: function(n) {
-                var result = [],
-                    d = 0;
-                for (; d < dim; d++) {
-                    var l = this[d].length;
-                    var i = n % l;
-                    result.push(this[d][i]);
-                    n -= i;
-                    n /= l;
-                }
-                return (typeof (that._lazyMap) === 'function')?that._lazyMap(result):result;
-            },
-            next: function() {
-                if (this.index >= size) return;
-                var result = this.nth(this.index);
-                this.index++;
-                return result;
-            }
-        });
-        addProperties(that, common);
-        that.init();
-        return that;
-    };
-    /* baseN */
-    var baseN = function(ary, nelem, fun) {
-                if (!nelem) nelem = ary.length;
-        if (nelem < 1) throw new RangeError;
-        var base = ary.length,
-                size = Math.pow(base, nelem);
-        var sizeOf = function() {
-                return size;
-            },
-            that = Object.create(ary.slice(), {
-                length: {
-                    get: sizeOf
-                }
-            });
-        hideProperty(that, 'index');
-        addProperties(that, {
-            valueOf: sizeOf,
-            init: function() {
-                that.index = 0;
-            },
-            nth: function(n) {
-                if (n >= size) return;
-                var result = [];
-                for (var i = 0; i < nelem; i++) {
-                    var d = n % base;
-                    result.push(ary[d]);
-                    n -= d; n /= base;
-                }
-                return (typeof (that._lazyMap) === 'function')?that._lazyMap(result):result;
-            },
-            next: function() {
-                return this.nth(this.index++);
-            }
-        });
-        addProperties(that, common);
-        that.init();
-        return (typeof (fun) === 'function') ? that.map(fun) : that;
-    };
-
-    /* export */
-    var Combinatorics = Object.create(null);
-    addProperties(Combinatorics, {
-        C: C,
-        P: P,
-        factorial: factorial,
-        factoradic: factoradic,
-        cartesianProduct: cartesianProduct,
-        combination: combination,
-        bigCombination: bigCombination,
-        permutation: permutation,
-        permutationCombination: permutationCombination,
-        power: power,
-        baseN: baseN,
-        VERSION: version
-    });
-    return Combinatorics;
-}));
-}(combinatorics));
-
-const log$1 = debug('pie-elements:placement-ordering:controller');
-const illegalArgumentError = answer => new Error(`Cant score answer: ${answer} it has duplicates and allowDuplicates is false`);
-const pairwiseCombinationScore = (correct, answer, opts) => {
-  opts = _extends({
-    allowDuplicates: false,
-    orderMustBeComplete: false
-  }, opts);
-
-  if (!opts.allowDuplicates && !_.isEqual(_.uniq(correct), correct)) {
-    throw illegalArgumentError(answer);
-  }
-
-  if (opts.allowDuplicates === false && answer.length !== _.uniq(answer).length) {
-    return 0;
-  }
-
-  answer = opts.allowDuplicates !== false ? answer : _.uniq(answer);
-  log$1('answer:', answer);
-
-  if (!Array.isArray(correct) || correct.length === 0) {
-    throw new Error('correct must be non empty an array');
-  }
-
-  if (correct.length === 1) {
-    return _.isEqual(correct, answer) ? 1 : 0;
-  }
-
-  if (!Array.isArray(answer) || answer.length < 2) {
-    return 0;
-  }
-
-  if (answer.length > correct.length) {
-    return 0;
-  }
-
-  if (correct.length !== answer.length && opts.orderMustBeComplete) {
-    return 0;
-  }
-
-  const correctCombo = combinatorics.exports.combination(correct, 2).toArray();
-  const answerCombo = combinatorics.exports.combination(answer, 2).toArray();
-
-  const diff = _.differenceWith(answerCombo, correctCombo, _.isEqual);
-
-  const comboLengthDiff = correctCombo.length - answerCombo.length;
-  const total = correctCombo.length;
-  const actual = total - diff.length - comboLengthDiff;
-  const n = (actual / total).toFixed(2);
-  return parseFloat(n);
-};
-/**
- * Flattens the correctResponse into an array of ordered identifiers representing the
- * correct response.
- */
-
-const flattenCorrect = question => question.correctResponse ? question.correctResponse.map(r => r && r.id ? r.id : r) : [];
-/**
- * Returns all correct responses for this question
- * @param question - array
- */
-
-const getAllCorrectResponses = question => {
-  const alternates = (question.alternateResponses || []).map(alternate => {
-    if (Array.isArray(alternate)) {
-      return alternate;
-    }
-
-    return alternate.response;
-  }).filter(item => item !== undefined);
-  return [flattenCorrect(question), ...alternates];
-};
-/**
- * Returns the score for a session. If weighted scoring is present in the correctResponse
- * field for the question, this will be used. If partial scoring is present in the question
- * model, this will be used. Otherwise the default scoring mechanism (0 for any incorrect, 1
- * for all correct) will be used.
- */
-
-const score = (question, session) => {
-  const {
-    value
-  } = session || {};
-
-  if (!value) {
-    return 0;
-  }
-
-  const allCorrectResponse = getAllCorrectResponses(question);
-  const allowDuplicates = (question.configure && question.configure.removeTilesAfterPlacing) !== false;
-  /**
-   * We require this to be the case - locking
-   */
-  //const orderMustBeComplete = true;
-
-  let bestScore = 0;
-  allCorrectResponse.forEach(cr => {
-    const currentScore = pairwiseCombinationScore(cr, value, {
-      allowDuplicates
-    });
-
-    if (currentScore >= bestScore) {
-      bestScore = currentScore;
-    }
-  });
-  return bestScore;
-};
-
-var defaults = {
-  choiceLabel: '',
-  choiceLabelEnabled: true,
-  choices: [],
-  correctResponse: [],
-  feedbackEnabled: false,
-  numberedGuides: false,
-  orientation: 'vertical',
-  partialScoring: true,
-  placementArea: false,
-  prompt: '',
-  promptEnabled: true,
-  rationale: '',
-  rationaleEnabled: true,
-  removeTilesAfterPlacing: true,
-  scoringType: 'auto',
-  studentInstructionsEnabled: true,
-  targetLabel: '',
-  teacherInstructions: '',
-  teacherInstructionsEnabled: true,
-  toolbarEditorPosition: 'bottom'
-};
-
-const log = debug('@pie-element:placement-ordering:controller');
-const {
-  translator
-} = Translator;
-const questionError = () => new Error('Question is missing required array: correctResponse');
-function outcome(question, session, env) {
-  return new Promise((resolve, reject) => {
-    if (!session || _.isEmpty(session)) {
-      resolve({
-        score: 0,
-        empty: true
-      });
-    }
-
-    if (!question || !question.correctResponse || _.isEmpty(question.correctResponse)) {
-      reject(questionError());
-    } else {
-      try {
-        const s = score(question, session);
-        const finalScore = partialScoring.enabled(question, env || {}) ? s : s === 1 ? 1 : 0;
-        resolve({
-          score: finalScore
-        });
-      } catch (e) {
-        reject(e);
-      }
-    }
-  });
-}
-function createDefaultModel(model = {}) {
-  return new Promise(resolve => {
-    resolve(_extends({}, defaults, model));
-  });
-}
-const normalize = question => _extends({}, defaults, {
-  rationaleEnabled: true,
-  feedbackEnabled: false,
-  promptEnabled: true,
-  teacherInstructionsEnabled: true,
-  studentInstructionsEnabled: true
-}, question);
-/**
- *
- * @param {*} question
- * @param {*} session
- * @param {*} env
- */
-
-function model(question, session, env) {
-  return new Promise(async resolve => {
-    const normalizedQuestion = normalize(question);
-    const base = {};
-
-    if (question.alternateResponses && _.every(question.alternateResponses, _.isArray)) {
-      log('Deprecated structure of alternateResponses is in use'); // eslint-disable-next-line no-console
-
-      console.error('Deprecated structure of alternateResponses is in use');
-    }
-
-    base.env = env;
-    base.extraCSSRules = normalizedQuestion.extraCSSRules;
-    base.outcomes = [];
-    base.completeLength = (normalizedQuestion.correctResponse || []).length;
-    base.choices = (normalizedQuestion.choices || []).filter(choice => choice.label);
-    base.note = normalizedQuestion.note;
-    base.showNote = normalizedQuestion.alternateResponses && normalizedQuestion.alternateResponses.length > 0;
-    base.language = normalizedQuestion.language;
-    log('[model] removing tileSize for the moment.');
-    base.prompt = normalizedQuestion.promptEnabled ? normalizedQuestion.prompt : null;
-    base.config = {
-      orientation: normalizedQuestion.orientation || 'vertical',
-      includeTargets: normalizedQuestion.placementArea,
-      choiceLabelEnabled: normalizedQuestion.choiceLabelEnabled,
-      targetLabel: normalizedQuestion.targetLabel,
-      choiceLabel: normalizedQuestion.choiceLabel,
-      showOrdering: normalizedQuestion.numberedGuides,
-      allowSameChoiceInTargets: !normalizedQuestion.removeTilesAfterPlacing
-    };
-    base.disabled = env.mode !== 'gather';
-
-    if (!base.note) {
-      base.note = translator.t('common:commonCorrectAnswerWithAlternates', {
-        lng: normalizedQuestion.language
-      });
-    }
-
-    if (env.role === 'instructor' && (env.mode === 'view' || env.mode === 'evaluate')) {
-      base.rationale = normalizedQuestion.rationaleEnabled ? normalizedQuestion.rationale : null;
-      base.teacherInstructions = normalizedQuestion.teacherInstructionsEnabled ? normalizedQuestion.teacherInstructions : null;
-    } else {
-      base.rationale = null;
-      base.teacherInstructions = null;
-    }
-
-    if (env.mode === 'evaluate') {
-      const value = session && session.value || [];
-      const allCorrectResponses = getAllCorrectResponses(normalizedQuestion);
-      const bestSetOfResponses = allCorrectResponses.reduce((info, cr) => {
-        const currentScore = _.reduce(value, (acc, c, idx) => acc + (Array.isArray(cr) && cr[idx] === c ? 1 : 0), 0);
-
-        if (currentScore > info.score) {
-          return {
-            arr: cr,
-            score: currentScore
-          };
-        }
-
-        return info;
-      }, {
-        arr: [],
-        score: 0
-      });
-      base.outcomes = _.map(value, (c, idx) => {
-        return {
-          id: c,
-          outcome: bestSetOfResponses.arr[idx] === c ? 'correct' : 'incorrect'
-        };
-      });
-      const isResponseCorrect = allCorrectResponses.some(response => _.isEqual(response, value));
-      const responseScore = score(question, session);
-      const isCorrect = responseScore === 1;
-      const isPartialCorrect = !isCorrect && partialScoring.enabled(normalizedQuestion, env || {}) && responseScore !== 0;
-      base.correctness = isCorrect ? 'correct' : isPartialCorrect ? 'partial' : 'incorrect';
-
-      if (!isResponseCorrect) {
-        base.correctResponse = flattenCorrect(normalizedQuestion);
-      } // requirement made in PD-2182
-
-
-      if (!normalizedQuestion.feedback) {
-        normalizedQuestion.feedbackEnabled = false;
-      }
-
-      const fb = normalizedQuestion.feedbackEnabled ? getFeedbackForCorrectness(base.correctness, normalizedQuestion.feedback) : Promise.resolve(undefined);
-      fb.then(feedback => {
-        base.feedback = feedback;
-        resolve(base);
-      });
-    } else {
-      resolve(base);
-    }
-  });
-}
-const createCorrectResponseSession = (question, env) => {
-  return new Promise(resolve => {
-    if (env.mode !== 'evaluate' && env.role === 'instructor') {
-      resolve({
-        id: '1',
-        value: flattenCorrect(question)
-      });
-    } else {
-      resolve(null);
-    }
-  });
-}; // remove all html tags
-
-
-const getContent = html => (html || '').replace(/(<(?!img|iframe|source)([^>]+)>)/gi, '');
-
-const validate = (model = {}, config = {}) => {
-  const {
-    choices,
-    correctResponse
-  } = model;
-  const errors = {};
-  ['teacherInstructions', 'prompt', 'rationale'].forEach(field => {
-    var _config$field;
-
-    if ((_config$field = config[field]) != null && _config$field.required && !getContent(model[field])) {
-      errors[field] = 'This field is required.';
-    }
-  });
-  const reversedChoices = [...(choices || [])].reverse();
-  const choicesErrors = {};
-  reversedChoices.forEach((choice, index) => {
-    const {
-      id,
-      label
-    } = choice;
-
-    if (!getContent(label)) {
-      choicesErrors[id] = 'Content should not be empty.';
-    } else {
-      const identicalAnswer = reversedChoices.slice(index + 1).some(c => c.label === label);
-
-      if (identicalAnswer) {
-        choicesErrors[id] = 'Content should be unique.';
-      }
-    }
-  });
-  const choicesIds = (choices || []).map(choice => choice.id);
-  const correctResponseIds = (correctResponse || []).map(response => response.id || response);
-
-  if (isEqual(choicesIds, correctResponseIds)) {
-    errors.orderError = 'The correct ordering should not be identical to the initial ordering.';
-  }
-
-  if (!isEmpty(choicesErrors)) {
-    errors.choicesErrors = choicesErrors;
-  }
-
-  return errors;
-};
-
-export { createCorrectResponseSession, createDefaultModel, model, normalize, outcome, questionError, validate };
-//# sourceMappingURL=controller.js.map