@wg-npm/survey-core 0.1.272 → 0.2.0

package/dist/survey-core.esm.js

@@ -1,27 +1,295 @@
-var TemplateModel = /** @class */ (function () {
-    function TemplateModel() {
-    }
-    return TemplateModel;
-}());
-var SurveyModel = /** @class */ (function () {
-    function SurveyModel() {
-    }
-    return SurveyModel;
-}());
-var ResponseModel = /** @class */ (function () {
-    function ResponseModel() {
-    }
-    return ResponseModel;
-}());
-var QuestionModel = /** @class */ (function () {
-    function QuestionModel() {
-    }
-    return QuestionModel;
-}());
-var PlanModel = /** @class */ (function () {
-    function PlanModel() {
-    }
-    return PlanModel;
-}());
+import _ from 'lodash';
 
-export { PlanModel, QuestionModel, ResponseModel, SurveyModel, TemplateModel };
+class QuestionFactory {
+    constructor(locale) {
+        this.creatorHash = {};
+        this.locale = locale;
+        this.registerQuestion("FILL_BLANK", (locale) => {
+            return new BaseQuestionModel("FILL_BLANK", locale);
+        });
+        this.registerQuestion("SHORT_ANSWER", (locale) => {
+            return new BaseQuestionModel("SHORT_ANSWER", locale);
+        });
+        this.registerQuestion("MATRIX", (locale) => {
+            return new QuestionMatrixModel("MATRIX", locale);
+        });
+        this.registerQuestion("TEXT_TITLE", (locale) => {
+            return new QuestionTextTitleModel("TEXT_TITLE", locale);
+        });
+        this.registerQuestion("SINGLE_SELECTION", (locale) => {
+            return new QuestionCheckBoxModel("SINGLE_SELECTION", locale);
+        });
+        this.registerQuestion("MULTI_SELECTION", (locale) => {
+            return new QuestionCheckBoxModel("MULTI_SELECTION", locale);
+        });
+        this.registerQuestion("EVALUATION", (locale) => {
+            return new QuestionEvaluationModel("EVALUATION", locale);
+        });
+    }
+    static getInstance(locale) {
+        if (!QuestionFactory.instance) {
+            QuestionFactory.instance = new QuestionFactory(locale);
+        }
+        return QuestionFactory.instance;
+    }
+    static createDefault(locale) {
+        return new ChoiceModel(locale);
+    }
+    static createSubQuestion(locale) {
+        return new SubQuestionModel(locale);
+    }
+    static createEvaluationItem(locale) {
+        return new StarEvaluationItemModel(locale);
+    }
+    static createSelectionQuestionChoices(locale) {
+        return _.range(4).map(() => this.createDefault(locale));
+    }
+    static createMatrixQuestionChoices(locale) {
+        return _.range(5).map(() => this.createDefault(locale));
+    }
+    static createEvaluationItems(locale) {
+        return _.range(5).map(() => this.createEvaluationItem(locale));
+    }
+    registerQuestion(questionType, questionCreator) {
+        this.creatorHash[questionType] = questionCreator;
+    }
+    createQuestion(questionType) {
+        let creator = this.creatorHash[questionType];
+        return creator(this.locale);
+    }
+}
+
+const defaultText = function getText(locale) {
+    return _.set({}, locale, "");
+};
+class ChoiceModel {
+    constructor(locale) {
+        this.id = ChoiceModel.createChoiceId();
+        this.text = defaultText(locale);
+        this.options = {
+            score: null,
+            star: false,
+            starCount: null,
+        };
+    }
+    static createChoiceId() {
+        return `Choice-${_.now()}-${_.random(0, 9999999)}`;
+    }
+}
+class EvaluationItemModel {
+    constructor(locale) {
+        this.id = EvaluationItemModel.createChoiceId();
+        this.text = defaultText(locale);
+    }
+    static createChoiceId() {
+        return `Evaluation-Item-${_.now()}-${_.random(0, 9999999)}`;
+    }
+}
+class StarEvaluationItemModel extends EvaluationItemModel {
+    constructor(locale) {
+        super(locale);
+    }
+}
+class ExprEvaluationItemModel extends EvaluationItemModel {
+    constructor(locale, type) {
+        super(locale);
+        this.type = type;
+    }
+}
+class ExprConditionModel {
+    constructor(type) {
+        this.type = type;
+    }
+}
+class QuestionOptionsModel {
+    constructor(required) {
+        this.required = required;
+        this.visible = true;
+    }
+}
+class QuestionHeaderModel {
+    constructor(locale) {
+        this.text = defaultText(locale);
+        this.number = null;
+    }
+}
+class SubQuestionModel {
+    constructor(locale) {
+        this.id = `SubQ-${_.now()}-${_.random(0, 9999999)}`;
+        this.text = defaultText(locale);
+        this.number = null;
+    }
+}
+class BaseQuestionModel {
+    constructor(type, locale) {
+        this.id = BaseQuestionModel.createQuestionId();
+        this.type = type;
+        this.header = new QuestionHeaderModel(locale);
+        this.options = new QuestionOptionsModel(false);
+    }
+    static getMaxScore(question) {
+        if (question.type == "SINGLE_SELECTION") {
+            return _.max(_.map(question.choices, (choice) => parseFloat(_.get(choice, "options.score", 0) || 0)));
+        }
+        else if (question.type == "MULTI_SELECTION") {
+            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)));
+            return score * question.subQuestions.length;
+        }
+        return 0;
+    }
+    static createQuestionId() {
+        return `Q-${_.now()}-${_.random(0, 9999999)}`;
+    }
+    static getNumber(preNumber, question) {
+        return preNumber + 1;
+    }
+    static refreshSurvey(survey) {
+        this.rebuildQuestionNumber(survey.questions);
+        survey.statistics.maxScore = this.calculationAllQuestionMaxScore(survey.questions);
+        survey.statistics.questionCount = this.calculationAllQuestionCount(survey.questions);
+    }
+    static calculationAllQuestionCount(questions) {
+        let count = 0;
+        let exclude = ["TEXT_TITLE"];
+        _.forEach(questions, (question) => {
+            if (!_.includes(exclude, question.type)) {
+                count++;
+            }
+        });
+        return count;
+    }
+    static calculationAllQuestionMaxScore(questions) {
+        let maxScore = 0;
+        _.forEach(questions, (question) => {
+            maxScore += this.getMaxScore(question);
+        });
+        return maxScore;
+    }
+    static setActiveQuestion(currentQuestion, questions) {
+        _.forEach(questions, (question) => {
+            if (question.id == currentQuestion.id) {
+                question.active = true;
+            }
+            else {
+                question.active = false;
+            }
+        });
+    }
+    static rebuildQuestionNumber(questions) {
+        let preNumber = 0;
+        _.forEach(questions, function (question) {
+            let number;
+            if (question.type === "TEXT_TITLE") {
+                number = QuestionTextTitleModel.getNumber(preNumber, question);
+            }
+            else if (question.type === "MATRIX") {
+                number = QuestionMatrixModel.getNumber(preNumber, question);
+            }
+            else {
+                number = BaseQuestionModel.getNumber(preNumber, question);
+            }
+            question.header.number = number;
+            if (number) {
+                preNumber = number;
+            }
+        });
+    }
+}
+class QuestionCheckBoxModel extends BaseQuestionModel {
+    constructor(type, locale) {
+        super(type, locale);
+        this.choices = QuestionFactory.createSelectionQuestionChoices(locale);
+    }
+}
+class QuestionEvaluationModel extends BaseQuestionModel {
+    constructor(type, locale) {
+        super(type, locale);
+        this.evaluationItems = QuestionFactory.createEvaluationItems(locale);
+    }
+}
+class QuestionTextTitleModel extends BaseQuestionModel {
+    constructor(type, locale) {
+        super(type, locale);
+    }
+    static getNumber(preNumber, question) {
+        return null;
+    }
+}
+class QuestionFillBlankModel extends BaseQuestionModel {
+    constructor(type, locale) {
+        super(type, locale);
+    }
+    static getNumber(preNumber, question) {
+        return null;
+    }
+}
+class QuestionShortAnswerModel extends BaseQuestionModel {
+    constructor(type, locale) {
+        super(type, locale);
+    }
+    getNumber(preNumber) {
+        return null;
+    }
+}
+class QuestionSingleSelectionModel extends QuestionCheckBoxModel {
+    constructor(type, locale) {
+        super(type, locale);
+    }
+}
+class QuestionMulitSelectionModel extends QuestionCheckBoxModel {
+    constructor(type, locale) {
+        super(type, locale);
+    }
+}
+class QuestionMatrixModel extends BaseQuestionModel {
+    constructor(type, locale) {
+        super(type, locale);
+        this.choices = QuestionFactory.createMatrixQuestionChoices(locale);
+        this.subQuestions = [QuestionFactory.createSubQuestion(locale)];
+    }
+    static getNumber(preNumber, question) {
+        let number = preNumber + 1;
+        _.forEach(question.subQuestions, (sq, index) => {
+            sq.number = index + 1;
+        });
+        return number;
+    }
+}
+class ResponseModel {
+}
+class PlanModel {
+}
+class PlanStatisticsModel {
+}
+class ResponseStatisticsModel {
+}
+
+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), '');
+    if (!_.isEmpty(value)) {
+        return value;
+    }
+    return _.get(obj, locale, '');
+}
+function translate(obj, locale, prettyMath = false) {
+    let 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"];
+}
+
+function move(array, fromIndex, toIndex) {
+    let moveValue = array[fromIndex];
+    array[fromIndex] = array[toIndex];
+    array[toIndex] = moveValue;
+}
+
+export { BaseQuestionModel, ChoiceModel, EvaluationItemModel, ExprConditionModel, ExprEvaluationItemModel, PlanModel, PlanStatisticsModel, QuestionCheckBoxModel, QuestionEvaluationModel, QuestionFactory, QuestionFillBlankModel, QuestionHeaderModel, QuestionMatrixModel, QuestionMulitSelectionModel, QuestionOptionsModel, QuestionShortAnswerModel, QuestionSingleSelectionModel, QuestionTextTitleModel, ResponseModel, ResponseStatisticsModel, StarEvaluationItemModel, SubQuestionModel, move, translate };

package/package.json

@@ -1,38 +1,57 @@
 {
   "name": "@wg-npm/survey-core",
-  "version": "0.1.272",
+  "version": "0.2.0",
   "description": "",
   "license": "MIT",
   "scripts": {
     "dts": "rollup -c rollup.dts.js --environment INCLUDE_DEPS,BUILD:production",
-    "build": "rollup -c --environment INCLUDE_DEPS,BUILD:production"
+    "build": "rollup -c --environment INCLUDE_DEPS,BUILD:production",
+    "watch": "rollup -c --watch.include \"src/**\" --environment INCLUDE_DEPS,BUILD:production",
+    "lint": "eslint \"**/*.ts\"  \"**/*.vue\" --no-error-on-unmatched-pattern",
+    "lint-fix": "eslint \"**/*.ts\"  \"**/*.vue\" --fix --no-error-on-unmatched-pattern"
+  },
+  "peerDependencies": {
+    "lodash": "^4.17.15"
   },
   "devDependencies": {
+    "@rollup/plugin-buble": "^0.21.3",
+    "@rollup/plugin-commonjs": "^13.0.0",
+    "@rollup/plugin-node-resolve": "^8.1.0",
+    "@rollup/plugin-replace": "^2.3.3",
+    "@typescript-eslint/eslint-plugin": "^3.6.0",
+    "@typescript-eslint/parser": "^3.6.0",
+    "@vue/eslint-config-prettier": "^6.0.0",
+    "@vue/eslint-config-typescript": "^5.0.2",
+    "acorn": "^7.3.1",
+    "eslint": "^7.4.0",
+    "eslint-plugin-prettier": "^3.1.4",
+    "eslint-plugin-vue": "^6.2.2",
     "lodash": "^4.17.15",
-    "rollup": "^1.19.4",
-    "rollup-plugin-buble": "^0.19.8",
-    "rollup-plugin-commonjs": "^10.0.2",
-    "rollup-plugin-dts": "^1.1.6",
-    "rollup-plugin-node-resolve": "^5.2.0",
-    "rollup-plugin-replace": "^2.2.0",
-    "rollup-plugin-terser": "^5.1.1",
-    "rollup-plugin-typescript": "^1.0.1",
-    "tslib": "^1.10.0",
-    "typescript": "^3.5.3"
+    "prettier": "^2.0.5",
+    "rollup": "^2.20.0",
+    "rollup-plugin-dts": "^1.4.7",
+    "rollup-plugin-terser": "^6.1.0",
+    "rollup-plugin-typescript2": "^0.27.1",
+    "tslib": "^2.0.0",
+    "typescript": "^3.9.6"
   },
-  "main": "dist/survey-core.common.js",
-  "module": "dist/survey-core.esm.js",
-  "unpkg": "dist/survey-core.js",
-  "jsdelivr": "dist/survey-core.js",
+  "main": "dist/survey-core.esm.js",
   "sideEffects": false,
-  "typings": "types/index.d.ts",
+  "typings": "src/index.ts",
   "files": [
     "src",
-    "types",
     "dist"
   ],
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "c61e91cd95628e67ba9f8813b7bf0761f506e29c"
+  "gitHead": "577c7fabd6df149e573991c6dddbe7ac1fd7eedd",
+  "rollup": {
+    "external": [
+      "lodash"
+    ],
+    "output": {
+      "name": "SurveyCore"
+    }
+  }
 }

package/src/array-utils.ts

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

package/src/expr-evaluation-question.ts

@@ -0,0 +1,110 @@
+import _ from "lodash";
+
+export class ExprEvaluationQuestion {
+  questions;
+  scope;
+  questionMap;
+
+  constructor(questions, scope) {
+    this.questions = questions;
+    this.scope = _.sortBy(scope);
+
+    this.questionMap = this.buildQuestionMap();
+  }
+
+  calculateNumbers() {
+    const checkedQuestions = this.checkedQuestion();
+    const checkedNumberElements = new Array();
+    this.recurs(checkedQuestions, checkedNumberElements);
+
+    return checkedNumberElements;
+  }
+
+  buildQuestionMap() {
+    const questionMap = {};
+    _.forEach(this.questions, (question) => {
+      questionMap[question.id] = question;
+      if (question.type == "MATRIX") {
+        _.forEach(_.get(question, "subQuestions", []), (subQuestion) => {
+          questionMap[subQuestion.id] = subQuestion;
+        });
+      }
+    });
+    return questionMap;
+  }
+
+  checkedQuestion() {
+    const questions = new Array();
+    _.forEach(this.questions, (question) => {
+      if (_.get(question, "type") == "MATRIX") {
+        const markedQuestions = new Array();
+        _.forEach(_.get(question, "subQuestions", []), (subQuestion) => {
+          if (_.includes(this.scope, subQuestion.id)) {
+            const newSubQuestion = _.cloneDeep(subQuestion);
+            _.set(newSubQuestion, "type", "MATRIX");
+            _.set(newSubQuestion, "parentId", _.get(question, "id"));
+            markedQuestions.push(newSubQuestion);
+          }
+        });
+        if (!_.isEmpty(markedQuestions)) {
+          questions.push(markedQuestions);
+        }
+      } else if (_.includes(this.scope, question.id)) {
+        questions.push(question);
+      }
+    });
+    return questions;
+  }
+
+  recurs(elements, numbers) {
+    for (let i = 0; i < elements.length; i++) {
+      const element = elements[i];
+      if (_.isArray(element)) {
+        numbers.push(new Array());
+        this.recurs(element, numbers[numbers.length - 1]);
+      } else {
+        const temp = new Array();
+        temp.push(this.getFullNumber(element));
+        if (i == elements.length - 1) {
+          numbers.push(temp);
+          continue;
+        }
+        for (let j = i + 1; ; j++) {
+          if (
+            j == elements.length ||
+            !this.isContinuous(elements[j - 1], elements[j])
+          ) {
+            numbers.push(temp);
+            i = j - 1;
+            break;
+          }
+          if (_.size(temp) > 1) {
+            temp.pop();
+          }
+          temp.push(this.getFullNumber(elements[j]));
+        }
+      }
+    }
+  }
+
+  isContinuous(front, hind) {
+    return (
+      !_.isArray(hind) && this.getNumber(hind) - this.getNumber(front) == 1
+    );
+  }
+
+  getFullNumber(question) {
+    if (question.type == "MATRIX") {
+      return (
+        this.questionMap[question.parentId].header.number +
+        "." +
+        this.getNumber(question)
+      );
+    }
+    return this.getNumber(question).toString();
+  }
+
+  getNumber(question) {
+    return question.type == "MATRIX" ? question.number : question.header.number;
+  }
+}

package/src/index.ts

@@ -1 +1,35 @@
-export * from './models'
+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
+} from "./models";
+export {
+    QuestionFactory
+} from "./quetion-factory"
+export { translate } from "./locale-utils";
+export { move } from "./array-utils";

package/src/locale-utils.ts

@@ -0,0 +1,23 @@
+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), '');
+  if (!_.isEmpty(value)) {
+    return value;
+  }
+  return _.get(obj, locale, '');
+}
+
+export function translate(obj: any, locale: string, prettyMath: boolean = false): any {
+  let 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];
+}

package/src/models.ts

@@ -1,19 +1,388 @@
-export class TemplateModel {
-    id?: string;
+import _ from "lodash";
+import { QuestionFactory } from "./quetion-factory";
+
+const defaultText = function getText(locale: string): object {
+  return _.set({}, locale, "");
+};
+
+export const enum SurveyLocales {
+  ZH_CN = "zh-CN",
+  ZH_TW = "zh-TW",
+  EN_US = "en-US",
 }
-export class SurveyModel {
-    id?: string
 
+export const enum SurveyLayout {
+  HORIZONTAL = "HORIZONTAL",
+  VERTICAL = "VERTICAL",
 }
 
-export class ResponseModel {
-    id?: string
+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",
+}
+
+export const enum EvaluationType {
+  STAR = "STAR",
+  EXPR = "EXPR",
+}
+
+export const enum ExprConditionType {
+  ASSIGN = "ASSIGN",
+  AUTO = "AUTO",
+  SCORE = "SCORE",
+}
+
+export const enum ExprEvaluationItemType {
+  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,
+    };
+  }
+
+  static createChoiceId(): string {
+    return `Choice-${_.now()}-${_.random(0, 9999999)}`;
+  }
+}
+
+export class LevelRange {
+  min?: Number;
+  max?: Number;
+}
+
+export class EvaluationItemModel {
+  id: string;
+  options?: Object;
+  text: object;
+
+  constructor(locale: string) {
+    this.id = EvaluationItemModel.createChoiceId();
+    this.text = defaultText(locale);
+  }
+
+  static createChoiceId(): string {
+    return `Evaluation-Item-${_.now()}-${_.random(0, 9999999)}`;
+  }
+}
+
+export class StarEvaluationItemModel extends EvaluationItemModel {
+  level?: Number;
+  range?: LevelRange;
+
+  constructor(locale: string) {
+    super(locale);
+  }
+}
+
+export class ExprEvaluationItemModel extends EvaluationItemModel {
+  type: ExprEvaluationItemType;
+  conditions?: Array<ExprConditionModel>;
+
+  constructor(locale: string, type: ExprEvaluationItemType) {
+    super(locale);
+    this.type = type;
+  }
+}
+
+export class ExprConditionModel {
+  type: ExprConditionType;
+  expr?: string;
+  desc?: string;
+  payload?: any;
+
+  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;
+  }
+}
+
+export class QuestionHeaderModel {
+  number?: Number | null;
+  text: Object;
+
+  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;
+  }
+}
+
+export class QuestionExprModel {
+  id: string;
+  answer: any;
+
+  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
+        );
+      } else {
+        number = BaseQuestionModel.getNumber(preNumber, question);
+      }
+      question.header.number = number;
+      if (number) {
+        preNumber = number;
+      }
+    });
+  }
+}
+
+export class QuestionCheckBoxModel extends BaseQuestionModel {
+  choices: Array<any>;
+
+  constructor(type: QuestionType, locale: string) {
+    super(type, locale);
+    this.choices = QuestionFactory.createSelectionQuestionChoices(locale);
+  }
+}
+
+export class QuestionEvaluationModel extends BaseQuestionModel {
+  evaluationItems: Array<EvaluationItemModel>;
+
+  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);
+  }
+
+  static getNumber(
+    preNumber: number,
+    question: BaseQuestionModel
+  ): null | number {
+    return null;
+  }
+}
+
+export class QuestionFillBlankModel extends BaseQuestionModel {
+  constructor(type: QuestionType, locale: string) {
+    super(type, locale);
+  }
+
+  static getNumber(
+    preNumber: number,
+    question: BaseQuestionModel
+  ): null | number {
+    return null;
+  }
 }
 
-export class QuestionModel {
-    id?: string
+export class QuestionShortAnswerModel extends BaseQuestionModel {
+  constructor(type: QuestionType, locale: string) {
+    super(type, locale);
+  }
+
+  getNumber(preNumber: number): null | number {
+    return null;
+  }
+}
+
+export class QuestionSingleSelectionModel extends QuestionCheckBoxModel {
+  constructor(type: QuestionType, locale: string) {
+    super(type, locale);
+  }
+}
+
+export class QuestionMulitSelectionModel extends QuestionCheckBoxModel {
+  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;
+  }
+}
+
+export interface SurveyOptionsModel {
+  primaryLanguage: SurveyLocales;
+  languages: SurveyLocales[];
+  layout: SurveyLayout;
+}
+
+export interface SurveyStatisticsModel {
+  maxScore: Number;
+  questionCount: Number;
+}
+
+export interface SurveyModel {
+  id: string;
+  name: any;
+  options: SurveyOptionsModel;
+  statistics: SurveyStatisticsModel;
+  questions: BaseQuestionModel[];
+}
+
+export class ResponseModel {
+  id?: string;
 }
 
 export class PlanModel {
-    id?: string
-}
+  id?: string;
+}
+
+//todo remove
+export class PlanStatisticsModel {}
+
+//todo remove
+export class ResponseStatisticsModel {}

package/src/quetion-factory.ts

@@ -0,0 +1,90 @@
+import {
+    BaseQuestionModel,
+    ChoiceModel,
+    QuestionType,
+    QuestionMatrixModel,
+    QuestionTextTitleModel,
+    QuestionCheckBoxModel,
+    SubQuestionModel,
+    QuestionEvaluationModel,
+    StarEvaluationItemModel
+} from "./models";
+import _ from "lodash";
+
+interface HashTable<T> {
+    [key: string]: T;
+}
+
+export class QuestionFactory {
+    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;
+    }
+
+    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 createSubQuestion(locale: string): SubQuestionModel {
+        return new SubQuestionModel(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 createMatrixQuestionChoices(locale: string) {
+        return _.range(5).map(() => this.createDefault(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 createQuestion(questionType: string): BaseQuestionModel {
+        let creator = this.creatorHash[questionType];
+        return creator(this.locale);
+    }
+}

package/dist/survey-core.common.js

@@ -1,35 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-var TemplateModel = /** @class */ (function () {
-    function TemplateModel() {
-    }
-    return TemplateModel;
-}());
-var SurveyModel = /** @class */ (function () {
-    function SurveyModel() {
-    }
-    return SurveyModel;
-}());
-var ResponseModel = /** @class */ (function () {
-    function ResponseModel() {
-    }
-    return ResponseModel;
-}());
-var QuestionModel = /** @class */ (function () {
-    function QuestionModel() {
-    }
-    return QuestionModel;
-}());
-var PlanModel = /** @class */ (function () {
-    function PlanModel() {
-    }
-    return PlanModel;
-}());
-
-exports.PlanModel = PlanModel;
-exports.QuestionModel = QuestionModel;
-exports.ResponseModel = ResponseModel;
-exports.SurveyModel = SurveyModel;
-exports.TemplateModel = TemplateModel;

package/dist/survey-core.esm.browser.js

@@ -1,38 +0,0 @@
-var SurveyCore = (function (exports) {
-    'use strict';
-
-    var TemplateModel = /** @class */ (function () {
-        function TemplateModel() {
-        }
-        return TemplateModel;
-    }());
-    var SurveyModel = /** @class */ (function () {
-        function SurveyModel() {
-        }
-        return SurveyModel;
-    }());
-    var ResponseModel = /** @class */ (function () {
-        function ResponseModel() {
-        }
-        return ResponseModel;
-    }());
-    var QuestionModel = /** @class */ (function () {
-        function QuestionModel() {
-        }
-        return QuestionModel;
-    }());
-    var PlanModel = /** @class */ (function () {
-        function PlanModel() {
-        }
-        return PlanModel;
-    }());
-
-    exports.PlanModel = PlanModel;
-    exports.QuestionModel = QuestionModel;
-    exports.ResponseModel = ResponseModel;
-    exports.SurveyModel = SurveyModel;
-    exports.TemplateModel = TemplateModel;
-
-    return exports;
-
-}({}));

package/dist/survey-core.esm.browser.min.js

@@ -1 +0,0 @@
-var SurveyCore=function(n){"use strict";var e=function(){},o=function(){},t=function(){},u=function(){},i=function(){};return n.PlanModel=i,n.QuestionModel=u,n.ResponseModel=t,n.SurveyModel=o,n.TemplateModel=e,n}({});

package/dist/survey-core.js

@@ -1,41 +0,0 @@
-(function (global, factory) {
-    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
-    typeof define === 'function' && define.amd ? define(['exports'], factory) :
-    (global = global || self, factory(global.SurveyCore = {}));
-}(this, (function (exports) { 'use strict';
-
-    var TemplateModel = /** @class */ (function () {
-        function TemplateModel() {
-        }
-        return TemplateModel;
-    }());
-    var SurveyModel = /** @class */ (function () {
-        function SurveyModel() {
-        }
-        return SurveyModel;
-    }());
-    var ResponseModel = /** @class */ (function () {
-        function ResponseModel() {
-        }
-        return ResponseModel;
-    }());
-    var QuestionModel = /** @class */ (function () {
-        function QuestionModel() {
-        }
-        return QuestionModel;
-    }());
-    var PlanModel = /** @class */ (function () {
-        function PlanModel() {
-        }
-        return PlanModel;
-    }());
-
-    exports.PlanModel = PlanModel;
-    exports.QuestionModel = QuestionModel;
-    exports.ResponseModel = ResponseModel;
-    exports.SurveyModel = SurveyModel;
-    exports.TemplateModel = TemplateModel;
-
-    Object.defineProperty(exports, '__esModule', { value: true });
-
-})));

package/dist/survey-core.min.js

@@ -1 +0,0 @@
-!function(e,o){"object"==typeof exports&&"undefined"!=typeof module?o(exports):"function"==typeof define&&define.amd?define(["exports"],o):o((e=e||self).SurveyCore={})}(this,(function(e){"use strict";var o=function(){},n=function(){},t=function(){},f=function(){},i=function(){};e.PlanModel=i,e.QuestionModel=f,e.ResponseModel=t,e.SurveyModel=n,e.TemplateModel=o,Object.defineProperty(e,"__esModule",{value:!0})}));

package/src/index.d.ts

@@ -1 +0,0 @@
-export * from './models';

package/src/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["index.ts"],"names":[],"mappings":"AAAA,cAAc,UAAU,CAAA"}

package/types/index.d.ts

@@ -1,65 +0,0 @@
-declare class TemplateModel {
-    id?: string;
-}
-
-declare class PlanModel {
-    id?: string;
-}
-
-declare class SurveyModel {
-    id?: string;
-}
-
-declare class ResponseModel {
-    id?: string;
-}
-
-declare class QuestionModel {
-    id?: string;
-}
-
-declare enum RespondStatusEnum {
-    Saved = 'SAVED',
-    Submitted = 'SUBMITTED',
-    All = 'ALL'
-}
-
-declare enum MongodbComparisonOperatorsEnum {
-    EQ = 'EQ',  // =
-    GT = 'GT',  // >
-    GTE = 'GTE',  // >=
-    IN = 'IN',
-    LT = 'LT',  // <
-    LTE = 'LTE',  // <=
-    NE = 'NE',  // !=
-    NIN = 'NIN',  // not in
-}
-
-declare class OptionsFiltersModel {
-    operator: MongodbComparisonOperatorsEnum;
-    column: string;
-    value: any;
-}
-
-declare class StatisticsModel {
-    respondentOptionsFilters?: Array<OptionsFiltersModel>;
-    targetOptionsFilters?: Array<OptionsFiltersModel>;
-}
-
-declare class PlanStatisticsModel extends StatisticsModel {
-}
-
-declare class ResponseStatisticsModel extends StatisticsModel {
-    targetId?: string;
-    status?: RespondStatusEnum;
-}
-
-export {
-    QuestionModel,
-    ResponseModel,
-    SurveyModel,
-    TemplateModel,
-    PlanModel,
-    PlanStatisticsModel,
-    ResponseStatisticsModel
-};