@wg-npm/survey-core 0.3.13 → 0.3.377-8.develop

package/dist/survey-core.esm.js

@@ -69,7 +69,7 @@ class ChoiceModel {
         this.options = {
             score: null,
             star: false,
-            starCount: null
+            starCount: null,
         };
     }
     static createChoiceId() {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wg-npm/survey-core",
-  "version": "0.3.13",
+  "version": "0.3.3778.develop",
   "description": "",
   "license": "MIT",
   "scripts": {

package/src/models.ts

@@ -1,390 +1,388 @@
 import _ from "lodash";
-import {QuestionFactory} from "./quetion-factory";
+import { QuestionFactory } from "./quetion-factory";
 
 const defaultText = function getText(locale: string): object {
-    return _.set({}, locale, "");
+  return _.set({}, locale, "");
 };
 
 export const enum SurveyLocales {
-    ZH_CN = "zh-CN",
-    ZH_TW = "zh-TW",
-    EN_US = "en-US",
+  ZH_CN = "zh-CN",
+  ZH_TW = "zh-TW",
+  EN_US = "en-US",
 }
 
 export const enum SurveyLayout {
-    HORIZONTAL = "HORIZONTAL",
-    VERTICAL = "VERTICAL",
+  HORIZONTAL = "HORIZONTAL",
+  VERTICAL = "VERTICAL",
 }
 
 export const enum QuestionType {
-    SINGLE_SELECTION = "SINGLE_SELECTION",
-    MULTI_SELECTION = "MULTI_SELECTION",
-    FILL_BLANK = "FILL_BLANK",
-    SHORT_ANSWER = "SHORT_ANSWER",
-    MATRIX = "MATRIX",
-    TEXT_TITLE = "TEXT_TITLE",
-    EVALUATION = "EVALUATION",
+  SINGLE_SELECTION = "SINGLE_SELECTION",
+  MULTI_SELECTION = "MULTI_SELECTION",
+  FILL_BLANK = "FILL_BLANK",
+  SHORT_ANSWER = "SHORT_ANSWER",
+  MATRIX = "MATRIX",
+  TEXT_TITLE = "TEXT_TITLE",
+  EVALUATION = "EVALUATION",
 }
 
 export const enum EvaluationType {
-    STAR = "STAR",
-    EXPR = "EXPR"
+  STAR = "STAR",
+  EXPR = "EXPR",
 }
 
 export const enum ExprConditionType {
-    ASSIGN = "ASSIGN",
-    AUTO = "AUTO"
+  ASSIGN = "ASSIGN",
+  AUTO = "AUTO",
+  SCORE = "SCORE",
 }
 
 export const enum ExprEvaluationItemType {
-    IF = "IF",
-    ELSE = "ELSE"
+  IF = "IF",
+  ELSE = "ELSE",
 }
 
 export class ChoiceModel {
-    id: string;
-    options?: Object;
-    text: object;
-
-    constructor(locale: string) {
-        this.id = ChoiceModel.createChoiceId();
-        this.text = defaultText(locale);
-        this.options = {
-            score: null,
-            star: false,
-            starCount: null
-        };
-    }
+  id: string;
+  options?: Object;
+  text: object;
 
-    static createChoiceId(): string {
-        return `Choice-${_.now()}-${_.random(0, 9999999)}`;
-    }
+  constructor(locale: string) {
+    this.id = ChoiceModel.createChoiceId();
+    this.text = defaultText(locale);
+    this.options = {
+      score: null,
+      star: false,
+      starCount: null,
+    };
+  }
+
+  static createChoiceId(): string {
+    return `Choice-${_.now()}-${_.random(0, 9999999)}`;
+  }
 }
 
 export class LevelRange {
-    min?: Number;
-    max?: Number;
+  min?: Number;
+  max?: Number;
 }
 
 export class EvaluationItemModel {
-    id: string;
-    options?: Object;
-    text: object;
+  id: string;
+  options?: Object;
+  text: object;
 
-    constructor(locale: string) {
-        this.id = EvaluationItemModel.createChoiceId();
-        this.text = defaultText(locale);
-    }
+  constructor(locale: string) {
+    this.id = EvaluationItemModel.createChoiceId();
+    this.text = defaultText(locale);
+  }
 
-    static createChoiceId(): string {
-        return `Evaluation-Item-${_.now()}-${_.random(0, 9999999)}`;
-    }
+  static createChoiceId(): string {
+    return `Evaluation-Item-${_.now()}-${_.random(0, 9999999)}`;
+  }
 }
 
 export class StarEvaluationItemModel extends EvaluationItemModel {
-    level?: Number;
-    range?: LevelRange;
+  level?: Number;
+  range?: LevelRange;
 
-    constructor(locale: string) {
-        super(locale);
-    }
+  constructor(locale: string) {
+    super(locale);
+  }
 }
 
 export class ExprEvaluationItemModel extends EvaluationItemModel {
-    type: ExprEvaluationItemType;
-    conditions?: Array<ExprConditionModel>;
+  type: ExprEvaluationItemType;
+  conditions?: Array<ExprConditionModel>;
 
-    constructor(locale: string, type: ExprEvaluationItemType) {
-        super(locale);
-        this.type = type;
-    }
+  constructor(locale: string, type: ExprEvaluationItemType) {
+    super(locale);
+    this.type = type;
+  }
 }
 
 export class ExprConditionModel {
-    type: ExprConditionType;
-    expr?: string;
-    desc?: string;
-    payload?: any;
+  type: ExprConditionType;
+  expr?: string;
+  desc?: string;
+  payload?: any;
 
-    constructor(type: ExprConditionType) {
-        this.type = type;
-    }
+  constructor(type: ExprConditionType) {
+    this.type = type;
+  }
 }
 
 export class QuestionOptionsModel {
-    required: Boolean;
-    visible: Boolean;
-    layout?: SurveyLayout;
-    wordLimit?: Number;
-    scoringEnabled?: Boolean;
-    starEnabled?: Boolean;
-    starMinCount?: Number;
-
-    constructor(required: Boolean) {
-        this.required = required;
-        this.visible = true;
-    }
+  required: Boolean;
+  visible: Boolean;
+  layout?: SurveyLayout;
+  wordLimit?: Number;
+  scoringEnabled?: Boolean;
+  starEnabled?: Boolean;
+  starMinCount?: Number;
+
+  constructor(required: Boolean) {
+    this.required = required;
+    this.visible = true;
+  }
 }
 
 export class QuestionHeaderModel {
-    number?: Number | null;
-    text: Object;
+  number?: Number | null;
+  text: Object;
 
-    constructor(locale: string) {
-        this.text = defaultText(locale);
-        this.number = null;
-    }
+  constructor(locale: string) {
+    this.text = defaultText(locale);
+    this.number = null;
+  }
 }
 
 export class SubQuestionModel {
-    id: string;
-    number?: Number | null;
-    text?: Object;
-
-    constructor(locale: string) {
-        this.id = `SubQ-${_.now()}-${_.random(0, 9999999)}`;
-        this.text = defaultText(locale);
-        this.number = null;
-    }
+  id: string;
+  number?: Number | null;
+  text?: Object;
+
+  constructor(locale: string) {
+    this.id = `SubQ-${_.now()}-${_.random(0, 9999999)}`;
+    this.text = defaultText(locale);
+    this.number = null;
+  }
 }
 
 export class QuestionExprModel {
-    id: string;
-    answer: any;
+  id: string;
+  answer: any;
 
-    constructor(id: string, answer: any) {
-        this.id = id;
-        this.answer = answer;
-    }
+  constructor(id: string, answer: any) {
+    this.id = id;
+    this.answer = answer;
+  }
 }
 
 export class BaseQuestionModel {
-    id: string;
-    type: string;
-    options: QuestionOptionsModel;
-    header: QuestionHeaderModel;
-
-    constructor(type: string, locale: string) {
-        this.id = BaseQuestionModel.createQuestionId();
-        this.type = type;
-        this.header = new QuestionHeaderModel(locale);
-        this.options = new QuestionOptionsModel(false);
-    }
-
-    static getMaxScore(question): number {
-        if (question.type == QuestionType.SINGLE_SELECTION) {
-            return _.max(
-                _.map(question.choices, (choice) =>
-                    parseFloat(_.get(choice, "options.score", 0) || 0)
-                )
-            );
-        } else if (question.type == QuestionType.MULTI_SELECTION) {
-            return _.sumBy(
-                question.choices,
-                (item) => parseFloat(_.get(item, "options.score") || 0)
-            );
-        } else if (question.type == QuestionType.MATRIX) {
-            let score = _.max(
-                _.map(question.choices, (choice) =>
-                    parseFloat(_.get(choice, "options.score", 0) || 0)
-                )
-            );
-            return score * question.subQuestions.length;
-        }
-        return 0;
-    }
-
-    static createQuestionId(): string {
-        return `Q-${_.now()}-${_.random(0, 9999999)}`;
-    }
-
-    static getNumber(
-        preNumber: number,
-        question: BaseQuestionModel
-    ): null | number {
-        return preNumber + 1;
-    }
-
-    static refreshSurvey(survey): void {
-        this.rebuildQuestionNumber(survey.questions);
-        survey.statistics.maxScore = this.calculationAllQuestionMaxScore(
-            survey.questions
-        );
-        survey.statistics.questionCount = this.calculationAllQuestionCount(
-            survey.questions
+  id: string;
+  type: string;
+  options: QuestionOptionsModel;
+  header: QuestionHeaderModel;
+
+  constructor(type: string, locale: string) {
+    this.id = BaseQuestionModel.createQuestionId();
+    this.type = type;
+    this.header = new QuestionHeaderModel(locale);
+    this.options = new QuestionOptionsModel(false);
+  }
+
+  static getMaxScore(question): number {
+    if (question.type == QuestionType.SINGLE_SELECTION) {
+      return _.max(
+        _.map(question.choices, (choice) =>
+          parseFloat(_.get(choice, "options.score", 0) || 0)
+        )
+      );
+    } else if (question.type == QuestionType.MULTI_SELECTION) {
+      return _.sumBy(question.choices, (item) =>
+        parseFloat(_.get(item, "options.score") || 0)
+      );
+    } else if (question.type == QuestionType.MATRIX) {
+      let score = _.max(
+        _.map(question.choices, (choice) =>
+          parseFloat(_.get(choice, "options.score", 0) || 0)
+        )
+      );
+      return score * question.subQuestions.length;
+    }
+    return 0;
+  }
+
+  static createQuestionId(): string {
+    return `Q-${_.now()}-${_.random(0, 9999999)}`;
+  }
+
+  static getNumber(
+    preNumber: number,
+    question: BaseQuestionModel
+  ): null | number {
+    return preNumber + 1;
+  }
+
+  static refreshSurvey(survey): void {
+    this.rebuildQuestionNumber(survey.questions);
+    survey.statistics.maxScore = this.calculationAllQuestionMaxScore(
+      survey.questions
+    );
+    survey.statistics.questionCount = this.calculationAllQuestionCount(
+      survey.questions
+    );
+  }
+
+  static calculationAllQuestionCount(questions): number {
+    let count = 0;
+    let exclude = [QuestionType.TEXT_TITLE];
+    _.forEach(questions, (question) => {
+      if (!_.includes(exclude, question.type)) {
+        count++;
+      }
+    });
+    return count;
+  }
+
+  static calculationAllQuestionMaxScore(questions): number {
+    let maxScore = 0;
+    _.forEach(questions, (question) => {
+      maxScore += this.getMaxScore(question);
+    });
+    return maxScore;
+  }
+
+  static setActiveQuestion(currentQuestion, questions): void {
+    _.forEach(questions, (question) => {
+      if (question.id == currentQuestion.id) {
+        question.active = true;
+      } else {
+        question.active = false;
+      }
+    });
+  }
+
+  static rebuildQuestionNumber(questions): void {
+    let preNumber = 0;
+    _.forEach(questions, function (question: BaseQuestionModel) {
+      let number;
+      if (question.type === QuestionType.TEXT_TITLE) {
+        number = QuestionTextTitleModel.getNumber(preNumber, question);
+      } else if (question.type === QuestionType.MATRIX) {
+        number = QuestionMatrixModel.getNumber(
+          preNumber,
+          question as QuestionMatrixModel
         );
-    }
-
-    static calculationAllQuestionCount(questions): number {
-        let count = 0;
-        let exclude = [QuestionType.TEXT_TITLE];
-        _.forEach(questions, (question) => {
-            if (!_.includes(exclude, question.type)) {
-                count++;
-            }
-        });
-        return count;
-    }
-
-    static calculationAllQuestionMaxScore(questions): number {
-        let maxScore = 0;
-        _.forEach(questions, (question) => {
-            maxScore += this.getMaxScore(question);
-        });
-        return maxScore;
-    }
-
-    static setActiveQuestion(currentQuestion, questions): void {
-        _.forEach(questions, (question) => {
-            if (question.id == currentQuestion.id) {
-                question.active = true;
-            } else {
-                question.active = false;
-            }
-        });
-    }
-
-    static rebuildQuestionNumber(questions): void {
-        let preNumber = 0;
-        _.forEach(questions, function (question: BaseQuestionModel) {
-            let number;
-            if (question.type === QuestionType.TEXT_TITLE) {
-                number = QuestionTextTitleModel.getNumber(preNumber, question);
-            } else if (question.type === QuestionType.MATRIX) {
-                number = QuestionMatrixModel.getNumber(
-                    preNumber,
-                    question as QuestionMatrixModel
-                );
-            } else {
-                number = BaseQuestionModel.getNumber(preNumber, question);
-            }
-            question.header.number = number;
-            if (number) {
-                preNumber = number;
-            }
-        });
-    }
+      } else {
+        number = BaseQuestionModel.getNumber(preNumber, question);
+      }
+      question.header.number = number;
+      if (number) {
+        preNumber = number;
+      }
+    });
+  }
 }
 
 export class QuestionCheckBoxModel extends BaseQuestionModel {
-    choices: Array<any>;
+  choices: Array<any>;
 
-    constructor(type: QuestionType, locale: string) {
-        super(type, locale);
-        this.choices = QuestionFactory.createSelectionQuestionChoices(locale);
-    }
+  constructor(type: QuestionType, locale: string) {
+    super(type, locale);
+    this.choices = QuestionFactory.createSelectionQuestionChoices(locale);
+  }
 }
 
 export class QuestionEvaluationModel extends BaseQuestionModel {
-    evaluationItems: Array<EvaluationItemModel>;
+  evaluationItems: Array<EvaluationItemModel>;
 
-    constructor(type: QuestionType, locale: string) {
-        super(type, locale);
-        this.evaluationItems = QuestionFactory.createEvaluationItems(locale);
-    }
+  constructor(type: QuestionType, locale: string) {
+    super(type, locale);
+    this.evaluationItems = QuestionFactory.createEvaluationItems(locale);
+  }
 }
 
 export class QuestionTextTitleModel extends BaseQuestionModel {
-    constructor(type: QuestionType, locale: string) {
-        super(type, locale);
-    }
+  constructor(type: QuestionType, locale: string) {
+    super(type, locale);
+  }
 
-    static getNumber(
-        preNumber: number,
-        question: BaseQuestionModel
-    ): null | number {
-        return null;
-    }
+  static getNumber(
+    preNumber: number,
+    question: BaseQuestionModel
+  ): null | number {
+    return null;
+  }
 }
 
 export class QuestionFillBlankModel extends BaseQuestionModel {
-    constructor(type: QuestionType, locale: string) {
-        super(type, locale);
-    }
+  constructor(type: QuestionType, locale: string) {
+    super(type, locale);
+  }
 
-    static getNumber(
-        preNumber: number,
-        question: BaseQuestionModel
-    ): null | number {
-        return null;
-    }
+  static getNumber(
+    preNumber: number,
+    question: BaseQuestionModel
+  ): null | number {
+    return null;
+  }
 }
 
 export class QuestionShortAnswerModel extends BaseQuestionModel {
-    constructor(type: QuestionType, locale: string) {
-        super(type, locale);
-    }
+  constructor(type: QuestionType, locale: string) {
+    super(type, locale);
+  }
 
-    getNumber(preNumber: number): null | number {
-        return null;
-    }
+  getNumber(preNumber: number): null | number {
+    return null;
+  }
 }
 
 export class QuestionSingleSelectionModel extends QuestionCheckBoxModel {
-    constructor(type: QuestionType, locale: string) {
-        super(type, locale);
-    }
+  constructor(type: QuestionType, locale: string) {
+    super(type, locale);
+  }
 }
 
 export class QuestionMulitSelectionModel extends QuestionCheckBoxModel {
-    constructor(type: QuestionType, locale: string) {
-        super(type, locale);
-    }
+  constructor(type: QuestionType, locale: string) {
+    super(type, locale);
+  }
 }
 
 export class QuestionMatrixModel extends BaseQuestionModel {
-    choices: Array<any>;
-    subQuestions: Array<SubQuestionModel>;
-
-    constructor(type: QuestionType, locale: string) {
-        super(type, locale);
-        this.choices = QuestionFactory.createMatrixQuestionChoices(locale);
-        this.subQuestions = [QuestionFactory.createSubQuestion(locale)];
-    }
-
-    static getNumber(
-        preNumber: number,
-        question: QuestionMatrixModel
-    ): null | number {
-        let number = preNumber + 1;
-        _.forEach(question.subQuestions, (sq, index) => {
-            sq.number = index + 1;
-        });
-        return number;
-    }
+  choices: Array<any>;
+  subQuestions: Array<SubQuestionModel>;
+
+  constructor(type: QuestionType, locale: string) {
+    super(type, locale);
+    this.choices = QuestionFactory.createMatrixQuestionChoices(locale);
+    this.subQuestions = [QuestionFactory.createSubQuestion(locale)];
+  }
+
+  static getNumber(
+    preNumber: number,
+    question: QuestionMatrixModel
+  ): null | number {
+    let number = preNumber + 1;
+    _.forEach(question.subQuestions, (sq, index) => {
+      sq.number = index + 1;
+    });
+    return number;
+  }
 }
 
 export interface SurveyOptionsModel {
-    primaryLanguage: SurveyLocales;
-    languages: SurveyLocales[];
-    layout: SurveyLayout;
+  primaryLanguage: SurveyLocales;
+  languages: SurveyLocales[];
+  layout: SurveyLayout;
 }
 
 export interface SurveyStatisticsModel {
-    maxScore: Number;
-    questionCount: Number;
+  maxScore: Number;
+  questionCount: Number;
 }
 
 export interface SurveyModel {
-    id: string;
-    name: any;
-    options: SurveyOptionsModel;
-    statistics: SurveyStatisticsModel;
-    questions: BaseQuestionModel[];
+  id: string;
+  name: any;
+  options: SurveyOptionsModel;
+  statistics: SurveyStatisticsModel;
+  questions: BaseQuestionModel[];
 }
 
 export class ResponseModel {
-    id?: string;
+  id?: string;
 }
 
 export class PlanModel {
-    id?: string;
+  id?: string;
 }
 
 //todo remove
-export class PlanStatisticsModel {
-}
+export class PlanStatisticsModel {}
 
 //todo remove
-export class ResponseStatisticsModel {
-}
+export class ResponseStatisticsModel {}