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

package/docs/pie-schema.json.md

@@ -7,6 +7,7 @@ The schema defines the following properties:
 This element must be one of the following enum values:
 
 * `multiTraitRubric`
+* `rubricless`
 * `simpleRubric`
 
 # `rubrics` (object, required)
@@ -143,6 +144,30 @@ Identifier to identify the Pie Element in html markup, Must be unique within a p
 
 The html Element tag name
 
+## `rubricless` (object, required)
+
+Properties of the `rubricless` object:
+
+### `maxPoints` (number)
+
+Indicates the max limit for scoring points
+
+### `excludeZeros` (boolean)
+
+Indicates if point 0 should be shown
+
+### `rubriclessInstructionEnabled` (boolean, required)
+
+Indicates that rubricInstruction is enabled
+
+### `id` (string, required)
+
+Identifier to identify the Pie Element in html markup, Must be unique within a pie item config.
+
+### `element` (string, required)
+
+The html Element tag name
+
 # `id` (string, required)
 
 Identifier to identify the Pie Element in html markup, Must be unique within a pie item config.
@@ -468,6 +493,134 @@ Dialog box title
 
 Dialog box text
 
+## `RubriclessConfigure` (object)
+
+Properties of the `RubriclessConfigure` object:
+
+### `settingsPanelDisabled` (boolean)
+
+Indicates if the settings panel is not available
+
+### `showExcludeZero` (object)
+
+Properties of the `showExcludeZero` object:
+
+#### `settings` (boolean)
+
+Indicates if the item has to be displayed in the Settings Panel
+
+#### `label` (string)
+
+Indicates the label for the item that has to be displayed in the Settings Panel
+
+### `showMaxPoint` (object)
+
+Properties of the `showMaxPoint` object:
+
+#### `settings` (boolean)
+
+Indicates if the item has to be displayed in the Settings Panel
+
+#### `label` (string)
+
+Indicates the label for the item that has to be displayed in the Settings Panel
+
+### `width` (string)
+
+How large can the rubric be
+
+### `mathMlOptions` (object)
+
+Properties of the `mathMlOptions` object:
+
+#### `mmlOutput` (number)
+
+Indicates if model should have mathML output instead of latex
+
+#### `mmlEditing` (number)
+
+Indicates if mathML that's already in model should be editable
+
+### `maxMaxPoints` (number)
+
+Indicates the max limit for scoring points
+
+### `rubricless` (boolean, enum, required)
+
+Indicates that it is rubricless
+
+This element must be one of the following enum values:
+
+* `true`
+
+### `rubriclessInstruction` (object, required)
+
+Properties of the `rubriclessInstruction` object:
+
+#### `settings` (boolean, enum, required)
+
+This element must be one of the following enum values:
+
+* `true`
+
+#### `label` (string, enum, required)
+
+This element must be one of the following enum values:
+
+* `Instruction`
+
+### `showPrompt` (boolean)
+
+Determines whether prompt field will be displayed or not
+
+Default: `true`
+
+### `promptLabel` (string)
+
+The label for the item stem/prompt field
+
+Default: `"Item Stemm"`
+
+### `contentDimensions` (object)
+
+Indicates the dimensions configuration for the authoring container
+Note: Some items have a default minimum width because of their content, but if
+the minWidth is lower than this, the overflow behavior will take care of that
+
+Properties of the `contentDimensions` object:
+
+#### `maxHeight` (string,number)
+
+Indicates the max height of the authoring container
+
+Default: `"undefined"`
+
+#### `maxWidth` (string,number)
+
+Indicates the max width of the authoring container
+
+Default: `"undefined"`
+
+#### `minHeight` (string,number)
+
+Indicates the min height of the authoring container
+
+Default: `"undefined"`
+
+#### `minWidth` (string,number)
+
+Indicates the min width of the authoring container
+
+Default: `"undefined"`
+
+Default: `": {}"`
+
+### `settingsPartialScoring` (boolean)
+
+Indicates whether the settings panel wil allow the author to modify settings for partial scoring
+
+Default: `true`
+
 ## `RubricType` (string)
 
 ## `RubricModels` (object)
@@ -604,6 +757,30 @@ Identifier to identify the Pie Element in html markup, Must be unique within a p
 
 The html Element tag name
 
+### `rubricless` (object, required)
+
+Properties of the `rubricless` object:
+
+#### `maxPoints` (number)
+
+Indicates the max limit for scoring points
+
+#### `excludeZeros` (boolean)
+
+Indicates if point 0 should be shown
+
+#### `rubriclessInstructionEnabled` (boolean, required)
+
+Indicates that rubricInstruction is enabled
+
+#### `id` (string, required)
+
+Identifier to identify the Pie Element in html markup, Must be unique within a pie item config.
+
+#### `element` (string, required)
+
+The html Element tag name
+
 ## `RubricPie` (object)
 
 Model for the RubricPie Interaction
@@ -802,4 +979,28 @@ Trait description
 
 Score point descriptors. Starting from 0 to max.
 
-The object is an array with all elements of the type `string`.
+The object is an array with all elements of the type `string`.
+
+## `RubriclessPie` (object)
+
+Properties of the `RubriclessPie` object:
+
+### `maxPoints` (number)
+
+Indicates the max limit for scoring points
+
+### `excludeZeros` (boolean)
+
+Indicates if point 0 should be shown
+
+### `rubriclessInstructionEnabled` (boolean, required)
+
+Indicates that rubricInstruction is enabled
+
+### `id` (string, required)
+
+Identifier to identify the Pie Element in html markup, Must be unique within a pie item config.
+
+### `element` (string, required)
+
+The html Element tag name

package/lib/__tests__/index.test.js

@@ -0,0 +1,127 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { (0, _defineProperty2["default"])(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+
+jest.mock('@pie-element/rubric', function () {
+  return jest.fn();
+});
+jest.mock('@pie-element/multi-trait-rubric', function () {
+  return jest.fn();
+});
+jest.mock('@pie-lib/pie-toolbox/rubric', function () {
+  return {
+    RUBRIC_TYPES: {
+      SIMPLE_RUBRIC: 'simpleRubric',
+      MULTI_TRAIT_RUBRIC: 'multiTraitRubric'
+    }
+  };
+});
+var defaultModel = {
+  rubricType: 'simpleRubric',
+  rubrics: {
+    simpleRubric: {
+      points: ['nothing right', 'a teeny bit right', 'mostly right', 'bingo'],
+      sampleAnswers: [null, 'just right', 'not left', null],
+      maxPoints: 4,
+      excludeZero: false
+    },
+    multiTraitRubric: {
+      visibleToStudent: true,
+      halfScoring: false,
+      excludeZero: true,
+      pointLabels: true,
+      description: false,
+      standards: false,
+      scales: [{
+        maxPoints: 4,
+        scorePointsLabels: ['Non-Scorable', 'Developing', 'Progressing', 'Effective', 'Strong'],
+        traitLabel: 'Trait',
+        traits: [{
+          name: 'Ideas',
+          standards: [],
+          description: 'the main message',
+          scorePointsDescriptors: ['Student’s response is blank, not in English, not legible, or does not respond to the prompt.', 'Topic undefined and/or difficult to follow\n' + '\n' + 'Details are unclear', 'Topic too broad\n' + '\n' + 'Details are limited', 'Writing stays on topic\n' + '\n' + 'Complete details given', 'Strong control of topic\n' + '\n' + 'Relevant, accurate, specific details that support topic']
+        }, {
+          name: 'Organization',
+          standards: [],
+          description: 'the internal structure of the piece',
+          scorePointsDescriptors: ['Student’s response is blank, not in English, not legible, or does not respond to the prompt.', 'Does not have a beginning, middle and/or end\n' + '\n' + 'Does not have a lead and/or conclusion\n' + '\n' + 'Transitions confusing and/or not present\n' + '\n' + 'Not written in logical order\n' + '\n' + 'No sign of paragraphing / incorrect paragraphing', 'Weak beginning, middle and end\n' + '\n' + 'Has evidence of a lead and/or conclusion but missing elements\n' + '\n' + 'Transitions are used sometimes\n' + '\n' + 'Some logical order\n' + '\n' + 'Most paragraphing incorrect', 'Has an acceptable beginning, middle and end\n' + '\n' + 'Includes a lead and conclusion\n' + '\n' + 'Transitions are used correctly\n' + '\n' + 'Mostly logical order\n' + '\n' + 'Mostly correct paragraphing', 'Has an effective beginning, middle and end\n' + '\n' + 'Powerful introduction / lead and conclusion\n' + '\n' + 'Effective transitions\n' + '\n' + 'Logical order / sequencing\n' + '\n' + 'Uses appropriate paragraphing']
+        }, {
+          name: 'Word Choice',
+          standards: [],
+          description: 'the vocabulary a writer chooses to convey meaning',
+          scorePointsDescriptors: ['Student’s response is blank, not in English, not legible, or does not respond to the prompt.', 'Vocabulary is limited/used incorrectly\n' + '\n' + 'No figurative language; words do not convey meaning', 'Generally correct words\n' + '\n' + 'Attempt at figurative language\n' + '\n' + 'and/or words convey general meaning', 'Some active verbs and precise nouns\n' + '\n' + 'Effective use of figurative language and/or words that enhance meaning', 'Powerful and engaging words\n' + '\n' + 'Artful use of figurative language and/or sensory detail']
+        }, {
+          name: 'Sentence Fluency',
+          standards: [],
+          description: 'the rhythm and flow of the language',
+          scorePointsDescriptors: ['Student’s response is blank, not in English, not legible, or does not respond to the prompt.', 'No sentences are clear\n' + '\n' + 'No variety in sentence structure\n' + '\n' + 'Frequent run-ons and/or fragments are present', 'Some sentences are clear\n' + '\n' + 'Sentence variety used rarely\n' + '\n' + 'Some run-ons and/or fragments are present', 'Most sentences are clear\n' + '\n' + 'Some sentence variety is used\n' + '\n' + 'Run-ons and/or fragments are rare', 'All Sentences are clear\n' + '\n' + 'Variety of sentence structure is used\n' + '\n' + 'Run-ons and/or fragments are not present']
+        }, {
+          name: 'Conventions',
+          standards: [],
+          description: 'the mechanical correctness',
+          scorePointsDescriptors: ['Student’s response is blank, not in English, not legible, or does not respond to the prompt.', 'Many distracting errors are present in grammar, punctuation, capitalization and/or spelling', 'Errors in grammar, punctuation, capitalization and/or spelling are present and some distract from meaning', 'Errors in grammar, punctuation, capitalization and/or spelling are present but don’t distract from meaning', 'Few errors in grammar, punctuation,\n' + '\n' + 'capitalization and/or spelling']
+        }, {
+          name: 'Voice',
+          standards: [],
+          description: "the personal tone and flavor of the author's message",
+          scorePointsDescriptors: ['Student’s response is blank, not in English, not legible, or does not respond to the prompt.', 'Not concerned with audience or purpose\n' + '\n' + 'No viewpoint (perspective) used\n' + '\n' + 'Writing is mechanical and lifeless', 'Shows beginning awareness of audience/purpose\n' + '\n' + 'Some viewpoint (perspective) used throughout the piece\n' + '\n' + 'Writing is distant, too formal or informal', 'Awareness of audience; purpose is clear most of the time\n' + '\n' + 'Uses viewpoint (perspective) throughout most of the paper\n' + '\n' + 'Writing is pleasant, agreeable and satisfying', 'Powerful connection with audience; purpose is clearly communicated\n' + '\n' + 'Maintains strong viewpoint (perspective) throughout entire piece\n' + '\n' + 'Writing is expressive, engaging and has lots of energy']
+        }]
+      }, {
+        maxPoints: 5,
+        scorePointsLabels: ['Non-Scorable', 'Unsatisfactory', 'Satisfactory'],
+        traitLabel: 'Category',
+        traits: [{
+          name: 'Presentation',
+          standards: [],
+          description: '',
+          scorePointsDescriptors: ['Handwriting is unreadable, or response is blank, not in English, or too brief to evaluate. ', 'Handwriting poor\n' + '\n' + 'Overall appearance is distracting to unacceptable', 'Handwriting is generally legible\n' + '\n' + 'Overall appearance is acceptable or better']
+        }]
+      }]
+    }
+  }
+};
+describe('complex-rubric', function () {
+  var Def;
+  var el;
+  var complexRubric;
+  beforeAll(function () {
+    Def = require('../index')["default"];
+  });
+  beforeEach(function () {
+    el = new Def();
+    el.connectedCallback();
+    complexRubric = {
+      simpleRubric: new HTMLElement(),
+      multiTraitRubric: new HTMLElement()
+    };
+    el.querySelector = jest.fn(function (s) {
+      if (s === '#simpleRubric') {
+        return complexRubric.simpleRubric;
+      } else {
+        return complexRubric.multiTraitRubric;
+      }
+    });
+    el.tagName = 'complex-rubric-element';
+    el.model = defaultModel;
+  });
+  describe('model', function () {
+    it('should have set the model', function () {
+      expect(el._model).toEqual(defaultModel);
+    });
+    it('sets rubric type', function () {
+      expect(el._type).toEqual('simpleRubric');
+      el.model = _objectSpread(_objectSpread({}, el._model), {}, {
+        rubricType: 'multiTraitRubric'
+      });
+      expect(el._type).toEqual('multiTraitRubric');
+    });
+  });
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/__tests__/index.test.js"],"names":["jest","mock","fn","RUBRIC_TYPES","SIMPLE_RUBRIC","MULTI_TRAIT_RUBRIC","defaultModel","rubricType","rubrics","simpleRubric","points","sampleAnswers","maxPoints","excludeZero","multiTraitRubric","visibleToStudent","halfScoring","pointLabels","description","standards","scales","scorePointsLabels","traitLabel","traits","name","scorePointsDescriptors","describe","Def","el","complexRubric","beforeAll","require","beforeEach","connectedCallback","HTMLElement","querySelector","s","tagName","model","it","expect","_model","toEqual","_type"],"mappings":"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","sourcesContent":["jest.mock('@pie-element/rubric', () => jest.fn());\njest.mock('@pie-element/multi-trait-rubric', () => jest.fn());\njest.mock('@pie-lib/pie-toolbox/rubric', () => ({\n  RUBRIC_TYPES: {\n    SIMPLE_RUBRIC: 'simpleRubric',\n    MULTI_TRAIT_RUBRIC: 'multiTraitRubric',\n  },\n}));\n\nconst defaultModel = {\n  rubricType: 'simpleRubric',\n  rubrics: {\n    simpleRubric: {\n      points: ['nothing right', 'a teeny bit right', 'mostly right', 'bingo'],\n      sampleAnswers: [null, 'just right', 'not left', null],\n      maxPoints: 4,\n      excludeZero: false,\n    },\n    multiTraitRubric: {\n      visibleToStudent: true,\n      halfScoring: false,\n      excludeZero: true,\n      pointLabels: true,\n      description: false,\n      standards: false,\n      scales: [\n        {\n          maxPoints: 4,\n          scorePointsLabels: ['Non-Scorable', 'Developing', 'Progressing', 'Effective', 'Strong'],\n          traitLabel: 'Trait',\n          traits: [\n            {\n              name: 'Ideas',\n              standards: [],\n              description: 'the main message',\n              scorePointsDescriptors: [\n                'Student’s response is blank, not in English, not legible, or does not respond to the prompt.',\n                'Topic undefined and/or difficult to follow\\n' + '\\n' + 'Details are unclear',\n                'Topic too broad\\n' + '\\n' + 'Details are limited',\n                'Writing stays on topic\\n' + '\\n' + 'Complete details given',\n                'Strong control of topic\\n' + '\\n' + 'Relevant, accurate, specific details that support topic',\n              ],\n            },\n            {\n              name: 'Organization',\n              standards: [],\n              description: 'the internal structure of the piece',\n              scorePointsDescriptors: [\n                'Student’s response is blank, not in English, not legible, or does not respond to the prompt.',\n                'Does not have a beginning, middle and/or end\\n' +\n                  '\\n' +\n                  'Does not have a lead and/or conclusion\\n' +\n                  '\\n' +\n                  'Transitions confusing and/or not present\\n' +\n                  '\\n' +\n                  'Not written in logical order\\n' +\n                  '\\n' +\n                  'No sign of paragraphing / incorrect paragraphing',\n                'Weak beginning, middle and end\\n' +\n                  '\\n' +\n                  'Has evidence of a lead and/or conclusion but missing elements\\n' +\n                  '\\n' +\n                  'Transitions are used sometimes\\n' +\n                  '\\n' +\n                  'Some logical order\\n' +\n                  '\\n' +\n                  'Most paragraphing incorrect',\n                'Has an acceptable beginning, middle and end\\n' +\n                  '\\n' +\n                  'Includes a lead and conclusion\\n' +\n                  '\\n' +\n                  'Transitions are used correctly\\n' +\n                  '\\n' +\n                  'Mostly logical order\\n' +\n                  '\\n' +\n                  'Mostly correct paragraphing',\n                'Has an effective beginning, middle and end\\n' +\n                  '\\n' +\n                  'Powerful introduction / lead and conclusion\\n' +\n                  '\\n' +\n                  'Effective transitions\\n' +\n                  '\\n' +\n                  'Logical order / sequencing\\n' +\n                  '\\n' +\n                  'Uses appropriate paragraphing',\n              ],\n            },\n            {\n              name: 'Word Choice',\n              standards: [],\n              description: 'the vocabulary a writer chooses to convey meaning',\n              scorePointsDescriptors: [\n                'Student’s response is blank, not in English, not legible, or does not respond to the prompt.',\n                'Vocabulary is limited/used incorrectly\\n' +\n                  '\\n' +\n                  'No figurative language; words do not convey meaning',\n                'Generally correct words\\n' +\n                  '\\n' +\n                  'Attempt at figurative language\\n' +\n                  '\\n' +\n                  'and/or words convey general meaning',\n                'Some active verbs and precise nouns\\n' +\n                  '\\n' +\n                  'Effective use of figurative language and/or words that enhance meaning',\n                'Powerful and engaging words\\n' + '\\n' + 'Artful use of figurative language and/or sensory detail',\n              ],\n            },\n            {\n              name: 'Sentence Fluency',\n              standards: [],\n              description: 'the rhythm and flow of the language',\n              scorePointsDescriptors: [\n                'Student’s response is blank, not in English, not legible, or does not respond to the prompt.',\n                'No sentences are clear\\n' +\n                  '\\n' +\n                  'No variety in sentence structure\\n' +\n                  '\\n' +\n                  'Frequent run-ons and/or fragments are present',\n                'Some sentences are clear\\n' +\n                  '\\n' +\n                  'Sentence variety used rarely\\n' +\n                  '\\n' +\n                  'Some run-ons and/or fragments are present',\n                'Most sentences are clear\\n' +\n                  '\\n' +\n                  'Some sentence variety is used\\n' +\n                  '\\n' +\n                  'Run-ons and/or fragments are rare',\n                'All Sentences are clear\\n' +\n                  '\\n' +\n                  'Variety of sentence structure is used\\n' +\n                  '\\n' +\n                  'Run-ons and/or fragments are not present',\n              ],\n            },\n            {\n              name: 'Conventions',\n              standards: [],\n              description: 'the mechanical correctness',\n              scorePointsDescriptors: [\n                'Student’s response is blank, not in English, not legible, or does not respond to the prompt.',\n                'Many distracting errors are present in grammar, punctuation, capitalization and/or spelling',\n                'Errors in grammar, punctuation, capitalization and/or spelling are present and some distract from meaning',\n                'Errors in grammar, punctuation, capitalization and/or spelling are present but don’t distract from meaning',\n                'Few errors in grammar, punctuation,\\n' + '\\n' + 'capitalization and/or spelling',\n              ],\n            },\n            {\n              name: 'Voice',\n              standards: [],\n              description: \"the personal tone and flavor of the author's message\",\n              scorePointsDescriptors: [\n                'Student’s response is blank, not in English, not legible, or does not respond to the prompt.',\n                'Not concerned with audience or purpose\\n' +\n                  '\\n' +\n                  'No viewpoint (perspective) used\\n' +\n                  '\\n' +\n                  'Writing is mechanical and lifeless',\n                'Shows beginning awareness of audience/purpose\\n' +\n                  '\\n' +\n                  'Some viewpoint (perspective) used throughout the piece\\n' +\n                  '\\n' +\n                  'Writing is distant, too formal or informal',\n                'Awareness of audience; purpose is clear most of the time\\n' +\n                  '\\n' +\n                  'Uses viewpoint (perspective) throughout most of the paper\\n' +\n                  '\\n' +\n                  'Writing is pleasant, agreeable and satisfying',\n                'Powerful connection with audience; purpose is clearly communicated\\n' +\n                  '\\n' +\n                  'Maintains strong viewpoint (perspective) throughout entire piece\\n' +\n                  '\\n' +\n                  'Writing is expressive, engaging and has lots of energy',\n              ],\n            },\n          ],\n        },\n        {\n          maxPoints: 5,\n          scorePointsLabels: ['Non-Scorable', 'Unsatisfactory', 'Satisfactory'],\n          traitLabel: 'Category',\n          traits: [\n            {\n              name: 'Presentation',\n              standards: [],\n              description: '',\n              scorePointsDescriptors: [\n                'Handwriting is unreadable, or response is blank, not in English, or too brief to evaluate. ',\n                'Handwriting poor\\n' + '\\n' + 'Overall appearance is distracting to unacceptable',\n                'Handwriting is generally legible\\n' + '\\n' + 'Overall appearance is acceptable or better',\n              ],\n            },\n          ],\n        },\n      ],\n    },\n  },\n};\n\ndescribe('complex-rubric', () => {\n  let Def;\n  let el;\n  let complexRubric;\n\n  beforeAll(() => {\n    Def = require('../index').default;\n  });\n\n  beforeEach(() => {\n    el = new Def();\n    el.connectedCallback();\n    complexRubric = {\n      simpleRubric: new HTMLElement(),\n      multiTraitRubric: new HTMLElement(),\n    };\n    el.querySelector = jest.fn((s) => {\n      if (s === '#simpleRubric') {\n        return complexRubric.simpleRubric;\n      } else {\n        return complexRubric.multiTraitRubric;\n      }\n    });\n    el.tagName = 'complex-rubric-element';\n    el.model = defaultModel;\n  });\n\n  describe('model', () => {\n    it('should have set the model', () => {\n      expect(el._model).toEqual(defaultModel);\n    });\n\n    it('sets rubric type', () => {\n      expect(el._type).toEqual('simpleRubric');\n      el.model = { ...el._model, rubricType: 'multiTraitRubric' };\n      expect(el._type).toEqual('multiTraitRubric');\n    });\n  });\n});\n"]}

package/lib/index.js

@@ -229,4 +229,4 @@ var ComplexRubric = /*#__PURE__*/function (_HTMLElement) {
 
 var _default = ComplexRubric;
 exports["default"] = _default;
-//# sourceMappingURL=index.js.map
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../src/index.js"],"names":["RUBRIC_TAG_NAME","MULTI_TRAIT_RUBRIC_TAG_NAME","ComplexRubricSimple","Rubric","ComplexRubricMultiTrait","MultiTraitRubric","defineRubrics","customElements","get","define","ComplexRubric","_model","_type","RUBRIC_TYPES","SIMPLE_RUBRIC","t","m","oldType","type","rubricType","whenDefined","then","setRubricModel","simpleRubric","MULTI_TRAIT_RUBRIC","setMultiTraitRubricModel","multiTraitRubric","RUBRICLESS","setRubriclessModel","rubricless","_render","rubrics","mode","model","querySelector","rubricTag","innerHTML","HTMLElement"],"mappings":"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","sourcesContent":["import Rubric from '@pie-element/rubric';\nimport MultiTraitRubric from '@pie-element/multi-trait-rubric';\nimport { RUBRIC_TYPES } from '@pie-lib/pie-toolbox/rubric';\n\nconst RUBRIC_TAG_NAME = 'complex-rubric-simple';\nconst MULTI_TRAIT_RUBRIC_TAG_NAME = 'complex-rubric-multi-trait';\n\nclass ComplexRubricSimple extends Rubric {\n}\n\nclass ComplexRubricMultiTrait extends MultiTraitRubric {\n}\n\nconst defineRubrics = () => {\n  if (!customElements.get(RUBRIC_TAG_NAME)) {\n    customElements.define(RUBRIC_TAG_NAME, ComplexRubricSimple);\n  }\n\n  if (!customElements.get(MULTI_TRAIT_RUBRIC_TAG_NAME)) {\n    customElements.define(MULTI_TRAIT_RUBRIC_TAG_NAME, ComplexRubricMultiTrait);\n  }\n};\n\ndefineRubrics();\n\nclass ComplexRubric extends HTMLElement {\n  constructor() {\n    super();\n    this._model = {};\n    this._type = RUBRIC_TYPES.SIMPLE_RUBRIC;\n  }\n\n  set type(t) {\n    this._type = t;\n  }\n\n  get type() {\n    return this._type;\n  }\n\n  set model(m) {\n    this._model = m;\n    const oldType = this._type;\n    this.type = m.rubricType;\n\n    switch (this._type) {\n      case RUBRIC_TYPES.SIMPLE_RUBRIC:\n      default:\n        customElements.whenDefined(RUBRIC_TAG_NAME).then(() => {\n          this.setRubricModel(this.simpleRubric);\n        });\n        break;\n      case RUBRIC_TYPES.MULTI_TRAIT_RUBRIC:\n        customElements.whenDefined(MULTI_TRAIT_RUBRIC_TAG_NAME).then(() => {\n          this.setMultiTraitRubricModel(this.multiTraitRubric);\n        });\n        break;\n      case RUBRIC_TYPES.RUBRICLESS:\n        customElements.whenDefined(RUBRIC_TAG_NAME).then(() => {\n          this.setRubriclessModel(this.rubricless);\n        });\n        break;\n    }\n\n    if (oldType !== this.type) {\n      this._render();\n    }\n  }\n\n  setRubricModel(simpleRubric) {\n    if (this._model && this._model.rubrics && this._model.rubrics.simpleRubric) {\n      const { mode } = this._model;\n\n      simpleRubric.model = {\n        ...this._model.rubrics.simpleRubric,\n        mode,\n      };\n    }\n  }\n\n  setMultiTraitRubricModel(multiTraitRubric) {\n    if (this._model && this._model.rubrics && this._model.rubrics.multiTraitRubric) {\n      const { mode } = this._model;\n\n      multiTraitRubric.model = {\n        ...this._model.rubrics.multiTraitRubric,\n        mode,\n      };\n    }\n  }\n\n  setRubriclessModel(rubricless) {\n    if (this._model && this._model.rubrics && this._model.rubrics.rubricless) {\n      const { mode } = this._model;\n\n      rubricless.model = {\n        ...this._model.rubrics.rubricless,\n        mode,\n      };\n    }\n  }\n\n  get multiTraitRubric() {\n    return this.querySelector(`${MULTI_TRAIT_RUBRIC_TAG_NAME}#multiTraitRubric`);\n  }\n\n  get simpleRubric() {\n    return this.querySelector(`${RUBRIC_TAG_NAME}#simpleRubric`);\n  }\n\n  get rubricless() {\n    return this.querySelector(`${RUBRIC_TAG_NAME}#rubricless`);\n  }\n\n  connectedCallback() {\n    this._render();\n  }\n\n  _render() {\n    let rubricTag;\n    if (this._type === RUBRIC_TYPES.SIMPLE_RUBRIC) {\n      rubricTag = `<${RUBRIC_TAG_NAME} id=\"simpleRubric\" />`\n    }\n    else if (this._type === RUBRIC_TYPES.RUBRICLESS){\n      rubricTag = `<${RUBRIC_TAG_NAME} id=\"rubricless\" />`;\n    }\n    else{\n      rubricTag = `<${MULTI_TRAIT_RUBRIC_TAG_NAME} id=\"multiTraitRubric\" />`;\n    }\n\n    this.innerHTML = rubricTag;\n\n    // when item is re-rendered (due to connectedCallback), if the custom element is already defined,\n    // we need to set the model and session, otherwise the setters are not reached again\n    switch (this._type) {\n      case RUBRIC_TYPES.SIMPLE_RUBRIC:\n      default:\n        if (customElements.get(RUBRIC_TAG_NAME)) {\n          this.setRubricModel(this.simpleRubric);\n        }\n        break;\n      case RUBRIC_TYPES.MULTI_TRAIT_RUBRIC:\n        if (customElements.get(MULTI_TRAIT_RUBRIC_TAG_NAME)) {\n          this.setMultiTraitRubricModel(this.multiTraitRubric);\n        }\n        break;\n      case RUBRIC_TYPES.RUBRICLESS:\n        if (customElements.get(RUBRIC_TAG_NAME)) {\n          this.setRubriclessModel(this.rubricless);\n        }\n        break;\n\n    }\n  }\n}\n\nexport default ComplexRubric;\n"]}

package/lib/print.js

@@ -198,4 +198,4 @@ var ComplexRubricPrint = /*#__PURE__*/function (_HTMLElement) {
 
 var _default = ComplexRubricPrint;
 exports["default"] = _default;
-//# sourceMappingURL=print.js.map
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../src/print.js"],"names":["RUBRIC_TAG_NAME","MULTI_TRAIT_RUBRIC_TAG_NAME","ComplexRubricSimple","Rubric","ComplexRubricMultiTrait","MultiTraitRubric","preparePrintModel","model","opts","instr","role","mode","animationsDisabled","defineRubrics","customElements","get","define","ComplexRubricPrint","_model","_type","RUBRIC_TYPES","SIMPLE_RUBRIC","_options","t","m","oldType","type","rubricType","whenDefined","then","setRubricModel","simpleRubric","MULTI_TRAIT_RUBRIC","setMultiTraitRubricModel","multiTraitRubric","_render","rubrics","scales","excludeZero","parsedScales","map","scale","visible","arrowsDisabled","o","querySelector","innerHTML","HTMLElement"],"mappings":"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","sourcesContent":["import Rubric from '@pie-element/rubric';\nimport MultiTraitRubric from '@pie-element/multi-trait-rubric';\nimport { RUBRIC_TYPES } from '@pie-lib/pie-toolbox/rubric';\n\nconst RUBRIC_TAG_NAME = 'complex-rubric-simple';\nconst MULTI_TRAIT_RUBRIC_TAG_NAME = 'complex-rubric-multi-trait';\n\nclass ComplexRubricSimple extends Rubric {}\nclass ComplexRubricMultiTrait extends MultiTraitRubric {}\n\nconst preparePrintModel = (model, opts) => {\n  const instr = opts.role === 'instructor';\n\n  if (!instr) {\n    return {};\n  }\n\n  model.mode = 'evaluate';\n  model.animationsDisabled = true;\n\n  return model;\n};\n\nconst defineRubrics = () => {\n  if (!customElements.get(RUBRIC_TAG_NAME)) {\n    customElements.define(RUBRIC_TAG_NAME, ComplexRubricSimple);\n  }\n\n  if (!customElements.get(MULTI_TRAIT_RUBRIC_TAG_NAME)) {\n    customElements.define(MULTI_TRAIT_RUBRIC_TAG_NAME, ComplexRubricMultiTrait);\n  }\n};\n\ndefineRubrics();\n\nclass ComplexRubricPrint extends HTMLElement {\n  constructor() {\n    super();\n    this._model = {};\n    this._type = RUBRIC_TYPES.SIMPLE_RUBRIC;\n    this._options = null;\n  }\n\n  set type(t) {\n    this._type = t;\n  }\n\n  get type() {\n    return this._type;\n  }\n\n  set model(m) {\n    this._model = m;\n    const oldType = this._type;\n    this.type = m.rubricType;\n\n    switch (this._type) {\n      case RUBRIC_TYPES.SIMPLE_RUBRIC:\n      default:\n        customElements.whenDefined(RUBRIC_TAG_NAME).then(() => {\n          this.setRubricModel(this.simpleRubric);\n        });\n        break;\n      case RUBRIC_TYPES.MULTI_TRAIT_RUBRIC:\n        customElements.whenDefined(MULTI_TRAIT_RUBRIC_TAG_NAME).then(() => {\n          this.setMultiTraitRubricModel(this.multiTraitRubric);\n        });\n        break;\n    }\n\n    if (oldType !== this.type) {\n      this._render();\n    }\n  }\n\n  setRubricModel(simpleRubric) {\n    if (this._model && this._model.rubrics && this._model.rubrics.simpleRubric) {\n      simpleRubric.model = preparePrintModel(this._model.rubrics.simpleRubric, this._options);\n    }\n  }\n\n  setMultiTraitRubricModel(multiTraitRubric) {\n    if (this._model && this._model.rubrics && this._model.rubrics.multiTraitRubric) {\n      const { scales, excludeZero } = this._model.rubrics.multiTraitRubric || {};\n      const parsedScales = (scales || []).map((scale) => ({ ...scale, excludeZero }));\n\n      multiTraitRubric.model = {\n        ...preparePrintModel(this._model.rubrics.multiTraitRubric, this._options),\n        visible: true,\n        arrowsDisabled: true,\n        scales: parsedScales,\n      };\n    }\n  }\n\n  set options(o) {\n    this._options = o;\n  }\n\n  get multiTraitRubric() {\n    return this.querySelector(`${MULTI_TRAIT_RUBRIC_TAG_NAME}#multiTraitRubric`);\n  }\n\n  get simpleRubric() {\n    return this.querySelector(`${RUBRIC_TAG_NAME}#simpleRubric`);\n  }\n\n  connectedCallback() {\n    this._render();\n  }\n\n  _render() {\n    this.innerHTML = this._type === RUBRIC_TYPES.SIMPLE_RUBRIC\n      ? `<${RUBRIC_TAG_NAME} id=\"simpleRubric\" />`\n      : `<${MULTI_TRAIT_RUBRIC_TAG_NAME} id=\"multiTraitRubric\" />`;\n  }\n}\n\nexport default ComplexRubricPrint;\n"]}