@wg-npm/survey-core 0.3.480-5.release → 0.3.489-9.release

package/dist/survey-core.esm.js

@@ -54,7 +54,7 @@ class QuestionFactory {
         this.creatorHash[questionType] = questionCreator;
     }
     createQuestion(questionType) {
-        let creator = this.creatorHash[questionType];
+        const creator = this.creatorHash[questionType];
         return creator(this.locale);
     }
 }
@@ -69,7 +69,7 @@ class ChoiceModel {
         this.options = {
             score: null,
             star: false,
-            starCount: null
+            starCount: null,
         };
     }
     static createChoiceId() {
@@ -135,7 +135,7 @@ class BaseQuestionModel {
             return _.sumBy(question.choices, (item) => parseFloat(_.get(item, "options.score") || 0));
         }
         else if (question.type == "MATRIX") {
-            let score = _.max(_.map(question.choices, (choice) => parseFloat(_.get(choice, "options.score", 0) || 0)));
+            const score = _.max(_.map(question.choices, (choice) => parseFloat(_.get(choice, "options.score", 0) || 0)));
             return score * question.subQuestions.length;
         }
         return 0;
@@ -153,7 +153,7 @@ class BaseQuestionModel {
     }
     static calculationAllQuestionCount(questions) {
         let count = 0;
-        let exclude = ["TEXT_TITLE"];
+        const exclude = ["TEXT_TITLE"];
         _.forEach(questions, (question) => {
             if (!_.includes(exclude, question.type)) {
                 count++;
@@ -251,7 +251,7 @@ class QuestionMatrixModel extends BaseQuestionModel {
         this.subQuestions = [QuestionFactory.createSubQuestion(locale)];
     }
     static getNumber(preNumber, question) {
-        let number = preNumber + 1;
+        const number = preNumber + 1;
         _.forEach(question.subQuestions, (sq, index) => {
             sq.number = index + 1;
         });
@@ -271,23 +271,27 @@ const ZH_CN = _.camelCase("zh-CN");
 const EN_US = _.camelCase("en-US");
 const ZH_TW = _.camelCase("zh-TW");
 function getValue(obj, locale) {
-    let value = _.get(obj, _.camelCase(locale), '');
+    const value = _.get(obj, _.camelCase(locale), "");
     if (!_.isEmpty(value)) {
         return value;
     }
-    return _.get(obj, locale, '');
+    return _.get(obj, locale, "");
 }
 function translate(obj, locale, prettyMath = false) {
-    let value = getValue(obj, locale);
+    const value = getValue(obj, locale);
     if (!_.isEmpty(value) || !prettyMath) {
         return value;
     }
-    return obj[ZH_CN] || obj["zh-CN"] || obj[EN_US] || obj["en-US"]
-        || obj[ZH_TW] || obj["zh-TW"];
+    return (obj[ZH_CN] ||
+        obj["zh-CN"] ||
+        obj[EN_US] ||
+        obj["en-US"] ||
+        obj[ZH_TW] ||
+        obj["zh-TW"]);
 }
 
 function move(array, fromIndex, toIndex) {
-    let moveValue = array[fromIndex];
+    const moveValue = array[fromIndex];
     array[fromIndex] = array[toIndex];
     array[toIndex] = moveValue;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wg-npm/survey-core",
-  "version": "0.3.4805.release",
+  "version": "0.3.4899.release",
   "description": "",
   "license": "MIT",
   "scripts": {

package/src/array-utils.ts

@@ -1,5 +1,9 @@
-export function move(array: Array<any>, fromIndex: number, toIndex: number): void {
-  let moveValue: any = array[fromIndex];
+export function move(
+  array: Array<any>,
+  fromIndex: number,
+  toIndex: number
+): void {
+  const moveValue: any = array[fromIndex];
   array[fromIndex] = array[toIndex];
   array[toIndex] = moveValue;
 }

package/src/index.ts

@@ -1,35 +1,33 @@
 export {
-    SurveyLocales,
-    SurveyLayout,
-    QuestionType,
-    ResponseStatisticsModel,
-    PlanStatisticsModel,
-    QuestionOptionsModel,
-    QuestionHeaderModel,
-    BaseQuestionModel,
-    QuestionCheckBoxModel,
-    QuestionTextTitleModel,
-    QuestionMatrixModel,
-    QuestionFillBlankModel,
-    QuestionMulitSelectionModel,
-    QuestionShortAnswerModel,
-    QuestionSingleSelectionModel,
-    QuestionEvaluationModel,
-    SubQuestionModel,
-    SurveyOptionsModel,
-    SurveyModel,
-    ChoiceModel,
-    ResponseModel,
-    PlanModel,
-    EvaluationType,
-    EvaluationItemModel,
-    StarEvaluationItemModel,
-    ExprEvaluationItemModel,
-    ExprConditionModel,
-    ExprConditionType
+  SurveyLocales,
+  SurveyLayout,
+  QuestionType,
+  ResponseStatisticsModel,
+  PlanStatisticsModel,
+  QuestionOptionsModel,
+  QuestionHeaderModel,
+  BaseQuestionModel,
+  QuestionCheckBoxModel,
+  QuestionTextTitleModel,
+  QuestionMatrixModel,
+  QuestionFillBlankModel,
+  QuestionMulitSelectionModel,
+  QuestionShortAnswerModel,
+  QuestionSingleSelectionModel,
+  QuestionEvaluationModel,
+  SubQuestionModel,
+  SurveyOptionsModel,
+  SurveyModel,
+  ChoiceModel,
+  ResponseModel,
+  PlanModel,
+  EvaluationType,
+  EvaluationItemModel,
+  StarEvaluationItemModel,
+  ExprEvaluationItemModel,
+  ExprConditionModel,
+  ExprConditionType,
 } from "./models";
-export {
-    QuestionFactory
-} from "./quetion-factory"
+export { QuestionFactory } from "./quetion-factory";
 export { translate } from "./locale-utils";
 export { move } from "./array-utils";

package/src/locale-utils.ts

@@ -1,23 +1,33 @@
-import _ from 'lodash';
-import { SurveyLocales } from './models';
+import _ from "lodash";
+import { SurveyLocales } from "./models";
 
 const ZH_CN: string = _.camelCase(SurveyLocales.ZH_CN);
 const EN_US: string = _.camelCase(SurveyLocales.EN_US);
 const ZH_TW: string = _.camelCase(SurveyLocales.ZH_TW);
 
 function getValue(obj: any, locale: string) {
-  let value: any = _.get(obj, _.camelCase(locale), '');
+  const value: any = _.get(obj, _.camelCase(locale), "");
   if (!_.isEmpty(value)) {
     return value;
   }
-  return _.get(obj, locale, '');
+  return _.get(obj, locale, "");
 }
 
-export function translate(obj: any, locale: string, prettyMath: boolean = false): any {
-  let value: any = getValue(obj, locale);
+export function translate(
+  obj: any,
+  locale: string,
+  prettyMath: boolean = false
+): any {
+  const value: any = getValue(obj, locale);
   if (!_.isEmpty(value) || !prettyMath) {
     return value;
   }
-  return obj[ZH_CN] || obj[SurveyLocales.ZH_CN] || obj[EN_US] || obj[SurveyLocales.EN_US]
-      || obj[ZH_TW] || obj[SurveyLocales.ZH_TW];
+  return (
+    obj[ZH_CN] ||
+    obj[SurveyLocales.ZH_CN] ||
+    obj[EN_US] ||
+    obj[SurveyLocales.EN_US] ||
+    obj[ZH_TW] ||
+    obj[SurveyLocales.ZH_TW]
+  );
 }

package/src/models.ts

@@ -1,390 +1,387 @@
 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",
 }
 
 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) {
+      const 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;
+    const 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 {
+    const 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 {}

package/src/quetion-factory.ts

@@ -1,90 +1,90 @@
 import {
-    BaseQuestionModel,
-    ChoiceModel,
-    QuestionType,
-    QuestionMatrixModel,
-    QuestionTextTitleModel,
-    QuestionCheckBoxModel,
-    SubQuestionModel,
-    QuestionEvaluationModel,
-    StarEvaluationItemModel
+  BaseQuestionModel,
+  ChoiceModel,
+  QuestionType,
+  QuestionMatrixModel,
+  QuestionTextTitleModel,
+  QuestionCheckBoxModel,
+  SubQuestionModel,
+  QuestionEvaluationModel,
+  StarEvaluationItemModel,
 } from "./models";
 import _ from "lodash";
 
 interface HashTable<T> {
-    [key: string]: T;
+  [key: string]: T;
 }
 
 export class QuestionFactory {
-    private creatorHash: HashTable<(locale: string) => BaseQuestionModel> = {};
-    private static instance: QuestionFactory;
-    private locale: string;
+  private creatorHash: HashTable<(locale: string) => BaseQuestionModel> = {};
+  private static instance: QuestionFactory;
+  private locale: string;
 
-    public static getInstance(locale: string): QuestionFactory {
-        if (!QuestionFactory.instance) {
-            QuestionFactory.instance = new QuestionFactory(locale);
-        }
-        return QuestionFactory.instance;
+  public static getInstance(locale: string): QuestionFactory {
+    if (!QuestionFactory.instance) {
+      QuestionFactory.instance = new QuestionFactory(locale);
     }
+    return QuestionFactory.instance;
+  }
 
-    private constructor(locale: string) {
-        this.locale = locale;
-        this.registerQuestion(QuestionType.FILL_BLANK, (locale: string) => {
-            return new BaseQuestionModel(QuestionType.FILL_BLANK, locale);
-        });
-        this.registerQuestion(QuestionType.SHORT_ANSWER, (locale: string) => {
-            return new BaseQuestionModel(QuestionType.SHORT_ANSWER, locale);
-        });
-        this.registerQuestion(QuestionType.MATRIX, (locale: string) => {
-            return new QuestionMatrixModel(QuestionType.MATRIX, locale);
-        });
-        this.registerQuestion(QuestionType.TEXT_TITLE, (locale: string) => {
-            return new QuestionTextTitleModel(QuestionType.TEXT_TITLE, locale);
-        });
-        this.registerQuestion(QuestionType.SINGLE_SELECTION, (locale: string) => {
-            return new QuestionCheckBoxModel(QuestionType.SINGLE_SELECTION, locale);
-        });
-        this.registerQuestion(QuestionType.MULTI_SELECTION, (locale: string) => {
-            return new QuestionCheckBoxModel(QuestionType.MULTI_SELECTION, locale);
-        });
-        this.registerQuestion(QuestionType.EVALUATION, (locale: string) => {
-            return new QuestionEvaluationModel(QuestionType.EVALUATION, locale);
-        });
-    }
+  private constructor(locale: string) {
+    this.locale = locale;
+    this.registerQuestion(QuestionType.FILL_BLANK, (locale: string) => {
+      return new BaseQuestionModel(QuestionType.FILL_BLANK, locale);
+    });
+    this.registerQuestion(QuestionType.SHORT_ANSWER, (locale: string) => {
+      return new BaseQuestionModel(QuestionType.SHORT_ANSWER, locale);
+    });
+    this.registerQuestion(QuestionType.MATRIX, (locale: string) => {
+      return new QuestionMatrixModel(QuestionType.MATRIX, locale);
+    });
+    this.registerQuestion(QuestionType.TEXT_TITLE, (locale: string) => {
+      return new QuestionTextTitleModel(QuestionType.TEXT_TITLE, locale);
+    });
+    this.registerQuestion(QuestionType.SINGLE_SELECTION, (locale: string) => {
+      return new QuestionCheckBoxModel(QuestionType.SINGLE_SELECTION, locale);
+    });
+    this.registerQuestion(QuestionType.MULTI_SELECTION, (locale: string) => {
+      return new QuestionCheckBoxModel(QuestionType.MULTI_SELECTION, locale);
+    });
+    this.registerQuestion(QuestionType.EVALUATION, (locale: string) => {
+      return new QuestionEvaluationModel(QuestionType.EVALUATION, locale);
+    });
+  }
 
-    public static createDefault(locale: string): ChoiceModel {
-        return new ChoiceModel(locale);
-    }
+  public static createDefault(locale: string): ChoiceModel {
+    return new ChoiceModel(locale);
+  }
 
-    public static createSubQuestion(locale: string): SubQuestionModel {
-        return new SubQuestionModel(locale);
-    }
+  public static createSubQuestion(locale: string): SubQuestionModel {
+    return new SubQuestionModel(locale);
+  }
 
-      public static createEvaluationItem(locale: string): ChoiceModel {
-        return new StarEvaluationItemModel(locale);
-    }
+  public static createEvaluationItem(locale: string): ChoiceModel {
+    return new StarEvaluationItemModel(locale);
+  }
 
-    public static createSelectionQuestionChoices(locale: string) {
-        return _.range(4).map(() => this.createDefault(locale));
-    }
+  public static createSelectionQuestionChoices(locale: string) {
+    return _.range(4).map(() => this.createDefault(locale));
+  }
 
-    public static createMatrixQuestionChoices(locale: string) {
-        return _.range(5).map(() => this.createDefault(locale));
-    }
+  public static createMatrixQuestionChoices(locale: string) {
+    return _.range(5).map(() => this.createDefault(locale));
+  }
 
-    public static createEvaluationItems(locale: string) {
-        return _.range(5).map(() => this.createEvaluationItem(locale));
-    }
+  public static createEvaluationItems(locale: string) {
+    return _.range(5).map(() => this.createEvaluationItem(locale));
+  }
 
-    public registerQuestion(
-        questionType: string,
-        questionCreator: (locale: string) => BaseQuestionModel
-    ) {
-        this.creatorHash[questionType] = questionCreator;
-    }
+  public registerQuestion(
+    questionType: string,
+    questionCreator: (locale: string) => BaseQuestionModel
+  ) {
+    this.creatorHash[questionType] = questionCreator;
+  }
 
-    public createQuestion(questionType: string): BaseQuestionModel {
-        let creator = this.creatorHash[questionType];
-        return creator(this.locale);
-    }
+  public createQuestion(questionType: string): BaseQuestionModel {
+    const creator = this.creatorHash[questionType];
+    return creator(this.locale);
+  }
 }