@wg-npm/survey-core 0.3.377-8.develop → 0.3.479-2.release

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.3778.develop",
+  "version": "0.3.4792.release",
   "description": "",
   "license": "MIT",
   "scripts": {

package/src/models.ts

@@ -1,388 +1,390 @@
 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",
-  SCORE = "SCORE",
+    ASSIGN = "ASSIGN",
+    AUTO = "AUTO"
 }
 
 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;
+
+    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)}`;
-  }
+    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
-    );
-  }
-
-  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
+    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
         );
-      } else {
-        number = BaseQuestionModel.getNumber(preNumber, question);
-      }
-      question.header.number = number;
-      if (number) {
-        preNumber = number;
-      }
-    });
-  }
+    }
+
+    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;
+            }
+        });
+    }
 }
 
 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 {
+}