@pie-element/complex-rubric 7.1.2-next.1 → 7.1.2

package/src/__tests__/index.test.js

@@ -0,0 +1,256 @@
+jest.mock('@pie-element/rubric', () => {
+  class MockRubric {
+    constructor() {}
+  }
+  return MockRubric;
+});
+
+jest.mock('@pie-element/multi-trait-rubric', () => {
+  class MockMultiTraitRubric {
+    constructor() {}
+  }
+  return MockMultiTraitRubric;
+});
+
+jest.mock('@pie-lib/rubric', () => ({
+  RUBRIC_TYPES: {
+    SIMPLE_RUBRIC: 'simpleRubric',
+    MULTI_TRAIT_RUBRIC: 'multiTraitRubric',
+  },
+}));
+
+const 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', () => {
+  let Def;
+  let el;
+  let complexRubric;
+
+  beforeAll(() => {
+    Def = require('../index').default;
+    // Register the custom element for testing
+    if (!customElements.get('complex-rubric-test')) {
+      customElements.define('complex-rubric-test', Def);
+    }
+  });
+
+  beforeEach(() => {
+    el = document.createElement('complex-rubric-test');
+
+    // Mock _render to avoid innerHTML issues in jsdom
+    el._render = jest.fn();
+
+    complexRubric = {
+      simpleRubric: document.createElement('div'),
+      multiTraitRubric: document.createElement('div'),
+    };
+    el.querySelector = jest.fn((s) => {
+      if (s === '#simpleRubric') {
+        return complexRubric.simpleRubric;
+      } else {
+        return complexRubric.multiTraitRubric;
+      }
+    });
+    el.model = defaultModel;
+  });
+
+  describe('model', () => {
+    it('should have set the model', () => {
+      expect(el._model).toEqual(defaultModel);
+    });
+
+    it('sets rubric type', () => {
+      expect(el._type).toEqual('simpleRubric');
+      el.model = { ...el._model, rubricType: 'multiTraitRubric' };
+      expect(el._type).toEqual('multiTraitRubric');
+    });
+  });
+});

package/src/index.js

@@ -0,0 +1,152 @@
+import Rubric from '@pie-element/rubric';
+import MultiTraitRubric from '@pie-element/multi-trait-rubric';
+import { RUBRIC_TYPES } from '@pie-lib/rubric';
+
+const RUBRIC_TAG_NAME = 'complex-rubric-simple';
+const MULTI_TRAIT_RUBRIC_TAG_NAME = 'complex-rubric-multi-trait';
+
+class ComplexRubricSimple extends Rubric {}
+
+class ComplexRubricMultiTrait extends MultiTraitRubric {}
+
+const defineRubrics = () => {
+  if (!customElements.get(RUBRIC_TAG_NAME)) {
+    customElements.define(RUBRIC_TAG_NAME, ComplexRubricSimple);
+  }
+
+  if (!customElements.get(MULTI_TRAIT_RUBRIC_TAG_NAME)) {
+    customElements.define(MULTI_TRAIT_RUBRIC_TAG_NAME, ComplexRubricMultiTrait);
+  }
+};
+
+defineRubrics();
+
+class ComplexRubric extends HTMLElement {
+  constructor() {
+    super();
+    this._model = {};
+    this._type = RUBRIC_TYPES.SIMPLE_RUBRIC;
+  }
+
+  set type(t) {
+    this._type = t;
+  }
+
+  get type() {
+    return this._type;
+  }
+
+  set model(m) {
+    this._model = m;
+    const oldType = this._type;
+    this.type = m.rubricType;
+
+    switch (this._type) {
+      case RUBRIC_TYPES.SIMPLE_RUBRIC:
+      default:
+        customElements.whenDefined(RUBRIC_TAG_NAME).then(() => {
+          this.setRubricModel(this.simpleRubric);
+        });
+        break;
+      case RUBRIC_TYPES.MULTI_TRAIT_RUBRIC:
+        customElements.whenDefined(MULTI_TRAIT_RUBRIC_TAG_NAME).then(() => {
+          this.setMultiTraitRubricModel(this.multiTraitRubric);
+        });
+        break;
+      case RUBRIC_TYPES.RUBRICLESS:
+        customElements.whenDefined(RUBRIC_TAG_NAME).then(() => {
+          this.setRubriclessModel(this.rubricless);
+        });
+        break;
+    }
+
+    if (oldType !== this.type) {
+      this._render();
+    }
+  }
+
+  setRubricModel(simpleRubric) {
+    if (this._model && this._model.rubrics && this._model.rubrics.simpleRubric) {
+      const { mode } = this._model;
+
+      simpleRubric.model = {
+        ...this._model.rubrics.simpleRubric,
+        mode,
+      };
+    }
+  }
+
+  setMultiTraitRubricModel(multiTraitRubric) {
+    if (this._model && this._model.rubrics && this._model.rubrics.multiTraitRubric) {
+      const { mode } = this._model;
+
+      multiTraitRubric.model = {
+        ...this._model.rubrics.multiTraitRubric,
+        mode,
+      };
+    }
+  }
+
+  setRubriclessModel(rubricless) {
+    if (this._model && this._model.rubrics && this._model.rubrics.rubricless) {
+      const { mode } = this._model;
+
+      rubricless.model = {
+        ...this._model.rubrics.rubricless,
+        mode,
+      };
+    }
+  }
+
+  get multiTraitRubric() {
+    return this.querySelector(`${MULTI_TRAIT_RUBRIC_TAG_NAME}#multiTraitRubric`);
+  }
+
+  get simpleRubric() {
+    return this.querySelector(`${RUBRIC_TAG_NAME}#simpleRubric`);
+  }
+
+  get rubricless() {
+    return this.querySelector(`${RUBRIC_TAG_NAME}#rubricless`);
+  }
+
+  connectedCallback() {
+    this._render();
+  }
+
+  _render() {
+    let rubricTag;
+    if (this._type === RUBRIC_TYPES.SIMPLE_RUBRIC) {
+      rubricTag = `<${RUBRIC_TAG_NAME} id="simpleRubric" />`;
+    } else if (this._type === RUBRIC_TYPES.RUBRICLESS) {
+      rubricTag = `<${RUBRIC_TAG_NAME} id="rubricless" />`;
+    } else {
+      rubricTag = `<${MULTI_TRAIT_RUBRIC_TAG_NAME} id="multiTraitRubric" />`;
+    }
+
+    this.innerHTML = rubricTag;
+
+    // when item is re-rendered (due to connectedCallback), if the custom element is already defined,
+    // we need to set the model and session, otherwise the setters are not reached again
+    switch (this._type) {
+      case RUBRIC_TYPES.SIMPLE_RUBRIC:
+      default:
+        if (customElements.get(RUBRIC_TAG_NAME)) {
+          this.setRubricModel(this.simpleRubric);
+        }
+        break;
+      case RUBRIC_TYPES.MULTI_TRAIT_RUBRIC:
+        if (customElements.get(MULTI_TRAIT_RUBRIC_TAG_NAME)) {
+          this.setMultiTraitRubricModel(this.multiTraitRubric);
+        }
+        break;
+      case RUBRIC_TYPES.RUBRICLESS:
+        if (customElements.get(RUBRIC_TAG_NAME)) {
+          this.setRubriclessModel(this.rubricless);
+        }
+        break;
+    }
+  }
+}
+
+export default ComplexRubric;

package/src/print.js

@@ -0,0 +1,140 @@
+// here it is actually using rubric/src/index.js, instead of using rubric/src/print.js
+import Rubric from '@pie-element/rubric';
+// here it is actually using multi-trait-rubric/src/index.js, instead of using multi-trait-rubric/src/print.js
+import MultiTraitRubric from '@pie-element/multi-trait-rubric';
+import { RUBRIC_TYPES } from '@pie-lib/rubric';
+
+const RUBRIC_TAG_NAME = 'complex-rubric-simple';
+const MULTI_TRAIT_RUBRIC_TAG_NAME = 'complex-rubric-multi-trait';
+
+class ComplexRubricSimple extends Rubric {}
+class ComplexRubricMultiTrait extends MultiTraitRubric {}
+
+const rubricTags = {
+  [RUBRIC_TYPES.SIMPLE_RUBRIC]: `<${RUBRIC_TAG_NAME} id="simpleRubric" />`,
+  [RUBRIC_TYPES.RUBRICLESS]: `<${RUBRIC_TAG_NAME} id="rubricless" />`,
+  [RUBRIC_TYPES.MULTI_TRAIT_RUBRIC]: `<${MULTI_TRAIT_RUBRIC_TAG_NAME} id="multiTraitRubric" />`,
+};
+
+const preparePrintModel = (model, opts) => {
+  const instr = opts.role === 'instructor';
+
+  if (!instr) {
+    return {};
+  }
+
+  model.mode = 'evaluate';
+  model.animationsDisabled = true;
+
+  return model;
+};
+
+const defineRubrics = () => {
+  if (!customElements.get(RUBRIC_TAG_NAME)) {
+    customElements.define(RUBRIC_TAG_NAME, ComplexRubricSimple);
+  }
+
+  if (!customElements.get(MULTI_TRAIT_RUBRIC_TAG_NAME)) {
+    customElements.define(MULTI_TRAIT_RUBRIC_TAG_NAME, ComplexRubricMultiTrait);
+  }
+};
+
+defineRubrics();
+
+class ComplexRubricPrint extends HTMLElement {
+  constructor() {
+    super();
+    this._model = {};
+    this._type = RUBRIC_TYPES.SIMPLE_RUBRIC;
+    this._options = null;
+  }
+
+  set type(t) {
+    this._type = t;
+  }
+
+  get type() {
+    return this._type;
+  }
+
+  set model(m) {
+    this._model = m;
+    const oldType = this._type;
+    this.type = m.rubricType;
+
+    switch (this._type) {
+      case RUBRIC_TYPES.SIMPLE_RUBRIC:
+      default:
+        customElements.whenDefined(RUBRIC_TAG_NAME).then(() => {
+          this.setRubricModel(this.simpleRubric);
+        });
+        break;
+      case RUBRIC_TYPES.MULTI_TRAIT_RUBRIC:
+        customElements.whenDefined(MULTI_TRAIT_RUBRIC_TAG_NAME).then(() => {
+          this.setMultiTraitRubricModel(this.multiTraitRubric);
+        });
+        break;
+      case RUBRIC_TYPES.RUBRICLESS:
+        customElements.whenDefined(RUBRIC_TAG_NAME).then(() => {
+          this.setRubriclessModel(this.rubricless);
+        });
+        break;
+    }
+
+    if (oldType !== this.type) {
+      this._render();
+    }
+  }
+
+  setRubricModel(simpleRubric) {
+    if (this._model && this._model.rubrics && this._model.rubrics.simpleRubric) {
+      simpleRubric.model = preparePrintModel(this._model.rubrics.simpleRubric, this._options);
+    }
+  }
+
+  setMultiTraitRubricModel(multiTraitRubric) {
+    if (this._model && this._model.rubrics && this._model.rubrics.multiTraitRubric) {
+      const { scales, excludeZero } = this._model.rubrics.multiTraitRubric || {};
+      const parsedScales = (scales || []).map((scale) => ({ ...scale, excludeZero }));
+
+      multiTraitRubric.model = {
+        ...preparePrintModel(this._model.rubrics.multiTraitRubric, this._options),
+        visible: true,
+        arrowsDisabled: true,
+        scales: parsedScales,
+      };
+    }
+  }
+
+  setRubriclessModel(rubricless) {
+    if (this._model && this._model.rubrics && this._model.rubrics.rubricless) {
+      rubricless.model = preparePrintModel(this._model.rubrics.rubricless, this._options);
+    }
+  }
+
+  set options(o) {
+    this._options = o;
+  }
+
+  get multiTraitRubric() {
+    return this.querySelector(`${MULTI_TRAIT_RUBRIC_TAG_NAME}#multiTraitRubric`);
+  }
+
+  get simpleRubric() {
+    return this.querySelector(`${RUBRIC_TAG_NAME}#simpleRubric`);
+  }
+
+  get rubricless() {
+    return this.querySelector(`${RUBRIC_TAG_NAME}#rubricless`);
+  }
+
+  connectedCallback() {
+    this._render();
+  }
+
+  _render() {
+    this.innerHTML = rubricTags[this._type] || '';
+  }
+}
+
+export default ComplexRubricPrint;

package/configure.js

@@ -1,2 +0,0 @@
-export { default } from './dist/author/index.js';
-export * from './dist/author/index.js';

package/controller.js

@@ -1 +0,0 @@
-export * from './dist/controller/index.js';