@flexem/fc-gui 3.0.0-alpha.16 → 3.0.0-alpha.161

package/model/shared/condition/word-condition-item-observer.js

@@ -1,165 +1,165 @@
-import { VariableValueType } from './variable-value-type';
-import { ConditionItemObserver } from './condition-item-observer';
-import { VariableValue, VariableStateEnum, VariableState } from '../../../communication';
-import { RelationType } from './relation-type';
-import { RelationalOperator } from './relational-operator';
-import { RelationConditionResultState } from './relation-condition-result-state';
-import { VariableUtil } from '../../../utils/variable-util';
-import { VariableDefinition } from '../../../communication/variable/variable-definition';
-export class WordConditionItemObserver extends ConditionItemObserver {
-    constructor(wordCondition, variableCommunicator, variableStore) {
-        super(wordCondition, variableStore);
-        this.wordCondition = wordCondition;
-        this.variableCommunicator = variableCommunicator;
-    }
-    get baseVariable() {
-        const variableValue = this.wordCondition.baseVariableValue;
-        if (!variableValue || !variableValue.variableName) {
-            return;
-        }
-        const variable = new VariableDefinition(variableValue.variableName, variableValue.variableGroupName, variableValue.dataSourceCode, variableValue.variableVersion);
-        return VariableUtil.getConvertedVariableName(this.variableStore, variable);
-    }
-    get realtionVariable() {
-        const variableValue = this.wordCondition.realtionVariableValue;
-        if (!variableValue || !variableValue.variableName) {
-            return;
-        }
-        const variable = new VariableDefinition(variableValue.variableName, variableValue.variableGroupName, variableValue.dataSourceCode, variableValue.variableVersion);
-        return VariableUtil.getConvertedVariableName(this.variableStore, variable);
-    }
-    requestData(appId) {
-        if (!this.wordCondition) {
-            throw new Error('WordConditionModel cannot be null.');
-        }
-        if (!this.wordCondition.baseVariableValue) {
-            throw new Error('WordConditionModel.baseVariableValue cannot be null.');
-        }
-        // eslint-disable-next-line eqeqeq
-        if (this.wordCondition.baseVariableValue.valueType == VariableValueType.Constant) {
-            this.baseVariableValue = new VariableValue(undefined, VariableStateEnum.DataNormal, this.wordCondition.baseVariableValue.constValue);
-        }
-        else {
-            if (this.variableName) {
-                this.variableCommunicator.subscribeVariableState(this.variableName).subscribe(variableValue => {
-                    if (variableValue.state === VariableStateEnum.Normal) {
-                        this.requestconditionEffectiveBaseValue(this.variableCommunicator, appId);
-                    }
-                    else {
-                        this.conditionEffectiveChanged.emit(new RelationConditionResultState(new VariableState(this.variableName, variableValue.state), false));
-                    }
-                });
-            }
-        }
-        if (+this.wordCondition.relationType !== 0) {
-            if (!this.wordCondition.baseVariableValue) {
-                throw new Error('WordConditionModel.realtionVariableValue cannot be null.');
-            }
-            // eslint-disable-next-line eqeqeq
-            if (this.wordCondition.realtionVariableValue.valueType == VariableValueType.Constant) {
-                this.realtionVariableValue = new VariableValue(undefined, VariableStateEnum.DataNormal, this.wordCondition.realtionVariableValue.constValue);
-            }
-            else {
-                if (this.variableName) {
-                    this.variableCommunicator.subscribeVariableState(this.variableName).subscribe(variableState => {
-                        if (variableState.state === VariableStateEnum.Normal) {
-                            this.requestconditionEffectiveRealtionValue(this.variableCommunicator, appId);
-                        }
-                        else {
-                            this.conditionEffectiveChanged.emit(new RelationConditionResultState(new VariableState(this.variableName, variableState.state), false));
-                        }
-                    });
-                }
-                else {
-                    this.requestconditionEffectiveRealtionValue(this.variableCommunicator, appId);
-                }
-            }
-        }
-        if (this.variableName) {
-            this.variableCommunicator.subscribeVariableState(this.variableName).subscribe(variableValue => {
-                if (variableValue.state === VariableStateEnum.Normal) {
-                    this.requestconditionEffectiveValue(this.variableCommunicator, appId);
-                }
-                else {
-                    this.conditionEffectiveChanged.emit(new RelationConditionResultState(new VariableState(this.variableName, variableValue.state), false));
-                }
-            });
-        }
-    }
-    requestconditionEffectiveValue(variableCommunicator, appId = '') {
-        variableCommunicator.openVariable(this.variableName, appId).subscribe(variableValue => {
-            this.currentValue = variableValue;
-            this.isConditionEffective = this.getIsConditionEffective();
-            this.conditionEffectiveChanged.emit(new RelationConditionResultState(new VariableState(this.variableName, variableValue.state), this.isConditionEffective));
-        });
-    }
-    requestconditionEffectiveBaseValue(variableCommunicator, appId = '') {
-        variableCommunicator.openVariable(this.baseVariable, appId).subscribe(variableValue => {
-            this.baseVariableValue = variableValue;
-            this.isConditionEffective = this.getIsConditionEffective();
-            this.conditionEffectiveChanged.emit(new RelationConditionResultState(new VariableState(this.variableName, variableValue.state), this.isConditionEffective));
-        });
-    }
-    requestconditionEffectiveRealtionValue(variableCommunicator, appId = '') {
-        variableCommunicator.openVariable(this.realtionVariable, appId).subscribe(variableValue => {
-            this.realtionVariableValue = variableValue;
-            this.isConditionEffective = this.getIsConditionEffective();
-            this.conditionEffectiveChanged.emit(new RelationConditionResultState(new VariableState(this.variableName, variableValue.state), this.isConditionEffective));
-        });
-    }
-    getIsConditionEffective() {
-        // eslint-disable-next-line eqeqeq
-        if (this.wordCondition.relationType == RelationType.None) {
-            return this.comparator(this.baseVariableValue, this.wordCondition.baseVariableValue.operator);
-            // eslint-disable-next-line eqeqeq
-        }
-        else if (this.wordCondition.relationType == RelationType.And) {
-            return this.comparator(this.baseVariableValue, this.wordCondition.baseVariableValue.operator)
-                && this.comparator(this.realtionVariableValue, this.wordCondition.realtionVariableValue.operator);
-            // eslint-disable-next-line eqeqeq
-        }
-        else if (this.wordCondition.relationType == RelationType.Or) {
-            return this.comparator(this.baseVariableValue, this.wordCondition.baseVariableValue.operator)
-                || this.comparator(this.realtionVariableValue, this.wordCondition.realtionVariableValue.operator);
-        }
-    }
-    comparator(comparatorValue, relationalOperator) {
-        if (comparatorValue == null) {
-            return false;
-        }
-        if (this.currentValue == null) {
-            return false;
-        }
-        if (comparatorValue.state !== VariableStateEnum.DataNormal || (this.currentValue.state !== VariableStateEnum.DataNormal)) {
-            return false;
-        }
-        // eslint-disable-next-line eqeqeq
-        if (relationalOperator == RelationalOperator.Equal) {
-            // eslint-disable-next-line eqeqeq
-            return (+this.currentValue.value) == (+comparatorValue.value);
-            // eslint-disable-next-line eqeqeq
-        }
-        else if (relationalOperator == RelationalOperator.GreaterOrEqual) {
-            // eslint-disable-next-line eqeqeq
-            return (+this.currentValue.value) > (+comparatorValue.value) || (+this.currentValue.value) == (+comparatorValue.value);
-            // eslint-disable-next-line eqeqeq
-        }
-        else if (relationalOperator == RelationalOperator.GreaterThan) {
-            return (+this.currentValue.value) > (+comparatorValue.value);
-            // eslint-disable-next-line eqeqeq
-        }
-        else if (relationalOperator == RelationalOperator.LessOrEqual) {
-            // eslint-disable-next-line eqeqeq
-            return (+this.currentValue.value) < (+comparatorValue.value) || (+this.currentValue.value) == (+comparatorValue.value);
-            // eslint-disable-next-line eqeqeq
-        }
-        else if (relationalOperator == RelationalOperator.LessThan) {
-            return (+this.currentValue.value) < (+comparatorValue.value);
-            // eslint-disable-next-line eqeqeq
-        }
-        else if (relationalOperator == RelationalOperator.NotEqual) {
-            // eslint-disable-next-line eqeqeq
-            return (+this.currentValue.value) != (+comparatorValue.value);
-        }
-    }
-}
+import { VariableValueType } from './variable-value-type';
+import { ConditionItemObserver } from './condition-item-observer';
+import { VariableValue, VariableStateEnum, VariableState } from '../../../communication';
+import { RelationType } from './relation-type';
+import { RelationalOperator } from './relational-operator';
+import { RelationConditionResultState } from './relation-condition-result-state';
+import { VariableUtil } from '../../../utils/variable-util';
+import { VariableDefinition } from '../../../communication/variable/variable-definition';
+export class WordConditionItemObserver extends ConditionItemObserver {
+    constructor(wordCondition, variableCommunicator, variableStore) {
+        super(wordCondition, variableStore);
+        this.wordCondition = wordCondition;
+        this.variableCommunicator = variableCommunicator;
+    }
+    get baseVariable() {
+        const variableValue = this.wordCondition.baseVariableValue;
+        if (!variableValue || !variableValue.variableName) {
+            return;
+        }
+        const variable = new VariableDefinition(variableValue.variableName, variableValue.variableGroupName, variableValue.dataSourceCode, variableValue.variableVersion);
+        return VariableUtil.getConvertedVariableName(this.variableStore, variable);
+    }
+    get realtionVariable() {
+        const variableValue = this.wordCondition.realtionVariableValue;
+        if (!variableValue || !variableValue.variableName) {
+            return;
+        }
+        const variable = new VariableDefinition(variableValue.variableName, variableValue.variableGroupName, variableValue.dataSourceCode, variableValue.variableVersion);
+        return VariableUtil.getConvertedVariableName(this.variableStore, variable);
+    }
+    requestData(appId) {
+        if (!this.wordCondition) {
+            throw new Error('WordConditionModel cannot be null.');
+        }
+        if (!this.wordCondition.baseVariableValue) {
+            throw new Error('WordConditionModel.baseVariableValue cannot be null.');
+        }
+        // eslint-disable-next-line eqeqeq
+        if (this.wordCondition.baseVariableValue.valueType == VariableValueType.Constant) {
+            this.baseVariableValue = new VariableValue(undefined, VariableStateEnum.DataNormal, this.wordCondition.baseVariableValue.constValue);
+        }
+        else {
+            if (this.variableName) {
+                this.variableCommunicator.subscribeVariableState(this.variableName).subscribe(variableValue => {
+                    if (variableValue.state === VariableStateEnum.Normal) {
+                        this.requestconditionEffectiveBaseValue(this.variableCommunicator, appId);
+                    }
+                    else {
+                        this.conditionEffectiveChanged.emit(new RelationConditionResultState(new VariableState(this.variableName, variableValue.state), false));
+                    }
+                });
+            }
+        }
+        if (+this.wordCondition.relationType !== 0) {
+            if (!this.wordCondition.baseVariableValue) {
+                throw new Error('WordConditionModel.realtionVariableValue cannot be null.');
+            }
+            // eslint-disable-next-line eqeqeq
+            if (this.wordCondition.realtionVariableValue.valueType == VariableValueType.Constant) {
+                this.realtionVariableValue = new VariableValue(undefined, VariableStateEnum.DataNormal, this.wordCondition.realtionVariableValue.constValue);
+            }
+            else {
+                if (this.variableName) {
+                    this.variableCommunicator.subscribeVariableState(this.variableName).subscribe(variableState => {
+                        if (variableState.state === VariableStateEnum.Normal) {
+                            this.requestconditionEffectiveRealtionValue(this.variableCommunicator, appId);
+                        }
+                        else {
+                            this.conditionEffectiveChanged.emit(new RelationConditionResultState(new VariableState(this.variableName, variableState.state), false));
+                        }
+                    });
+                }
+                else {
+                    this.requestconditionEffectiveRealtionValue(this.variableCommunicator, appId);
+                }
+            }
+        }
+        if (this.variableName) {
+            this.variableCommunicator.subscribeVariableState(this.variableName).subscribe(variableValue => {
+                if (variableValue.state === VariableStateEnum.Normal) {
+                    this.requestconditionEffectiveValue(this.variableCommunicator, appId);
+                }
+                else {
+                    this.conditionEffectiveChanged.emit(new RelationConditionResultState(new VariableState(this.variableName, variableValue.state), false));
+                }
+            });
+        }
+    }
+    requestconditionEffectiveValue(variableCommunicator, appId = '') {
+        variableCommunicator.openVariable(this.variableName, appId).subscribe(variableValue => {
+            this.currentValue = variableValue;
+            this.isConditionEffective = this.getIsConditionEffective();
+            this.conditionEffectiveChanged.emit(new RelationConditionResultState(new VariableState(this.variableName, variableValue.state), this.isConditionEffective));
+        });
+    }
+    requestconditionEffectiveBaseValue(variableCommunicator, appId = '') {
+        variableCommunicator.openVariable(this.baseVariable, appId).subscribe(variableValue => {
+            this.baseVariableValue = variableValue;
+            this.isConditionEffective = this.getIsConditionEffective();
+            this.conditionEffectiveChanged.emit(new RelationConditionResultState(new VariableState(this.variableName, variableValue.state), this.isConditionEffective));
+        });
+    }
+    requestconditionEffectiveRealtionValue(variableCommunicator, appId = '') {
+        variableCommunicator.openVariable(this.realtionVariable, appId).subscribe(variableValue => {
+            this.realtionVariableValue = variableValue;
+            this.isConditionEffective = this.getIsConditionEffective();
+            this.conditionEffectiveChanged.emit(new RelationConditionResultState(new VariableState(this.variableName, variableValue.state), this.isConditionEffective));
+        });
+    }
+    getIsConditionEffective() {
+        // eslint-disable-next-line eqeqeq
+        if (this.wordCondition.relationType == RelationType.None) {
+            return this.comparator(this.baseVariableValue, this.wordCondition.baseVariableValue.operator);
+            // eslint-disable-next-line eqeqeq
+        }
+        else if (this.wordCondition.relationType == RelationType.And) {
+            return this.comparator(this.baseVariableValue, this.wordCondition.baseVariableValue.operator)
+                && this.comparator(this.realtionVariableValue, this.wordCondition.realtionVariableValue.operator);
+            // eslint-disable-next-line eqeqeq
+        }
+        else if (this.wordCondition.relationType == RelationType.Or) {
+            return this.comparator(this.baseVariableValue, this.wordCondition.baseVariableValue.operator)
+                || this.comparator(this.realtionVariableValue, this.wordCondition.realtionVariableValue.operator);
+        }
+    }
+    comparator(comparatorValue, relationalOperator) {
+        if (comparatorValue == null) {
+            return false;
+        }
+        if (this.currentValue == null) {
+            return false;
+        }
+        if (comparatorValue.state !== VariableStateEnum.DataNormal || (this.currentValue.state !== VariableStateEnum.DataNormal)) {
+            return false;
+        }
+        // eslint-disable-next-line eqeqeq
+        if (relationalOperator == RelationalOperator.Equal) {
+            // eslint-disable-next-line eqeqeq
+            return (+this.currentValue.value) == (+comparatorValue.value);
+            // eslint-disable-next-line eqeqeq
+        }
+        else if (relationalOperator == RelationalOperator.GreaterOrEqual) {
+            // eslint-disable-next-line eqeqeq
+            return (+this.currentValue.value) > (+comparatorValue.value) || (+this.currentValue.value) == (+comparatorValue.value);
+            // eslint-disable-next-line eqeqeq
+        }
+        else if (relationalOperator == RelationalOperator.GreaterThan) {
+            return (+this.currentValue.value) > (+comparatorValue.value);
+            // eslint-disable-next-line eqeqeq
+        }
+        else if (relationalOperator == RelationalOperator.LessOrEqual) {
+            // eslint-disable-next-line eqeqeq
+            return (+this.currentValue.value) < (+comparatorValue.value) || (+this.currentValue.value) == (+comparatorValue.value);
+            // eslint-disable-next-line eqeqeq
+        }
+        else if (relationalOperator == RelationalOperator.LessThan) {
+            return (+this.currentValue.value) < (+comparatorValue.value);
+            // eslint-disable-next-line eqeqeq
+        }
+        else if (relationalOperator == RelationalOperator.NotEqual) {
+            // eslint-disable-next-line eqeqeq
+            return (+this.currentValue.value) != (+comparatorValue.value);
+        }
+    }
+}

package/model/shared/condition/word-condition-model.d.ts

@@ -1,8 +1,8 @@
-import { RelationType } from './relation-type';
-import { ConditionModel } from './condition-model';
-import { VariableValueLogicModel } from './variable-value-logic-model';
-export interface WordConditionModel extends ConditionModel {
-    readonly relationType: RelationType;
-    readonly baseVariableValue: VariableValueLogicModel;
-    readonly realtionVariableValue?: VariableValueLogicModel;
-}
+import { RelationType } from './relation-type';
+import { ConditionModel } from './condition-model';
+import { VariableValueLogicModel } from './variable-value-logic-model';
+export interface WordConditionModel extends ConditionModel {
+    readonly relationType: RelationType;
+    readonly baseVariableValue: VariableValueLogicModel;
+    readonly realtionVariableValue?: VariableValueLogicModel;
+}

package/model/shared/condition/word-condition.d.ts

@@ -1,5 +1,5 @@
-import { RelationalOperator } from './relational-operator';
-export interface WordCondition {
-    readonly operator: RelationalOperator;
-    readonly operand: number;
-}
+import { RelationalOperator } from './relational-operator';
+export interface WordCondition {
+    readonly operator: RelationalOperator;
+    readonly operand: number;
+}

package/model/shared/data-type/display-data-type.d.ts

@@ -1,5 +1,5 @@
-export declare enum DisplayDataType {
-    Decimal = 0,
-    Hex = 1,
-    Binary = 2
-}
+export declare enum DisplayDataType {
+    Decimal = 0,
+    Hex = 1,
+    Binary = 2
+}

package/model/shared/data-type/display-data-type.js

@@ -1,6 +1,6 @@
-export var DisplayDataType;
-(function (DisplayDataType) {
-    DisplayDataType[DisplayDataType["Decimal"] = 0] = "Decimal";
-    DisplayDataType[DisplayDataType["Hex"] = 1] = "Hex";
-    DisplayDataType[DisplayDataType["Binary"] = 2] = "Binary";
-})(DisplayDataType || (DisplayDataType = {}));
+export var DisplayDataType;
+(function (DisplayDataType) {
+    DisplayDataType[DisplayDataType["Decimal"] = 0] = "Decimal";
+    DisplayDataType[DisplayDataType["Hex"] = 1] = "Hex";
+    DisplayDataType[DisplayDataType["Binary"] = 2] = "Binary";
+})(DisplayDataType || (DisplayDataType = {}));

package/model/shared/data-type/fbox-data-type.d.ts

@@ -1,15 +1,15 @@
-export declare enum FBoxDataType {
-    Bit = 0,
-    UInt16 = 1,
-    Int16 = 2,
-    Bcd16 = 3,
-    Hex16 = 4,
-    Binary16 = 5,
-    UInt32 = 11,
-    Int32 = 12,
-    Bcd32 = 13,
-    Hex32 = 14,
-    Binary32 = 15,
-    Single = 16,
-    String = 30
-}
+export declare enum FBoxDataType {
+    Bit = 0,
+    UInt16 = 1,
+    Int16 = 2,
+    Bcd16 = 3,
+    Hex16 = 4,
+    Binary16 = 5,
+    UInt32 = 11,
+    Int32 = 12,
+    Bcd32 = 13,
+    Hex32 = 14,
+    Binary32 = 15,
+    Single = 16,
+    String = 30
+}

package/model/shared/data-type/fbox-data-type.js

@@ -1,16 +1,16 @@
-export var FBoxDataType;
-(function (FBoxDataType) {
-    FBoxDataType[FBoxDataType["Bit"] = 0] = "Bit";
-    FBoxDataType[FBoxDataType["UInt16"] = 1] = "UInt16";
-    FBoxDataType[FBoxDataType["Int16"] = 2] = "Int16";
-    FBoxDataType[FBoxDataType["Bcd16"] = 3] = "Bcd16";
-    FBoxDataType[FBoxDataType["Hex16"] = 4] = "Hex16";
-    FBoxDataType[FBoxDataType["Binary16"] = 5] = "Binary16";
-    FBoxDataType[FBoxDataType["UInt32"] = 11] = "UInt32";
-    FBoxDataType[FBoxDataType["Int32"] = 12] = "Int32";
-    FBoxDataType[FBoxDataType["Bcd32"] = 13] = "Bcd32";
-    FBoxDataType[FBoxDataType["Hex32"] = 14] = "Hex32";
-    FBoxDataType[FBoxDataType["Binary32"] = 15] = "Binary32";
-    FBoxDataType[FBoxDataType["Single"] = 16] = "Single";
-    FBoxDataType[FBoxDataType["String"] = 30] = "String";
-})(FBoxDataType || (FBoxDataType = {}));
+export var FBoxDataType;
+(function (FBoxDataType) {
+    FBoxDataType[FBoxDataType["Bit"] = 0] = "Bit";
+    FBoxDataType[FBoxDataType["UInt16"] = 1] = "UInt16";
+    FBoxDataType[FBoxDataType["Int16"] = 2] = "Int16";
+    FBoxDataType[FBoxDataType["Bcd16"] = 3] = "Bcd16";
+    FBoxDataType[FBoxDataType["Hex16"] = 4] = "Hex16";
+    FBoxDataType[FBoxDataType["Binary16"] = 5] = "Binary16";
+    FBoxDataType[FBoxDataType["UInt32"] = 11] = "UInt32";
+    FBoxDataType[FBoxDataType["Int32"] = 12] = "Int32";
+    FBoxDataType[FBoxDataType["Bcd32"] = 13] = "Bcd32";
+    FBoxDataType[FBoxDataType["Hex32"] = 14] = "Hex32";
+    FBoxDataType[FBoxDataType["Binary32"] = 15] = "Binary32";
+    FBoxDataType[FBoxDataType["Single"] = 16] = "Single";
+    FBoxDataType[FBoxDataType["String"] = 30] = "String";
+})(FBoxDataType || (FBoxDataType = {}));

package/model/shared/data-type/fcloud-data-Type.d.ts

@@ -1,8 +1,8 @@
-export declare enum FCloudDataType {
-    Int32 = 1,
-    Float = 2,
-    Bool = 4,
-    String = 8,
-    Binary = 90,
-    Hex = 99
-}
+export declare enum FCloudDataType {
+    Int32 = 1,
+    Float = 2,
+    Bool = 4,
+    String = 8,
+    Binary = 90,
+    Hex = 99
+}

package/model/shared/data-type/fcloud-data-Type.js

@@ -1,9 +1,9 @@
-export var FCloudDataType;
-(function (FCloudDataType) {
-    FCloudDataType[FCloudDataType["Int32"] = 1] = "Int32";
-    FCloudDataType[FCloudDataType["Float"] = 2] = "Float";
-    FCloudDataType[FCloudDataType["Bool"] = 4] = "Bool";
-    FCloudDataType[FCloudDataType["String"] = 8] = "String";
-    FCloudDataType[FCloudDataType["Binary"] = 90] = "Binary";
-    FCloudDataType[FCloudDataType["Hex"] = 99] = "Hex";
-})(FCloudDataType || (FCloudDataType = {}));
+export var FCloudDataType;
+(function (FCloudDataType) {
+    FCloudDataType[FCloudDataType["Int32"] = 1] = "Int32";
+    FCloudDataType[FCloudDataType["Float"] = 2] = "Float";
+    FCloudDataType[FCloudDataType["Bool"] = 4] = "Bool";
+    FCloudDataType[FCloudDataType["String"] = 8] = "String";
+    FCloudDataType[FCloudDataType["Binary"] = 90] = "Binary";
+    FCloudDataType[FCloudDataType["Hex"] = 99] = "Hex";
+})(FCloudDataType || (FCloudDataType = {}));

package/model/shared/dynamic-display/dynamic-behavior-type.d.ts

@@ -1,5 +1,5 @@
-export declare enum DynamicBehaviorType {
-    HorizontalTranslation = 0,
-    VerticalTranslation = 1,
-    Rotation = 2
-}
+export declare enum DynamicBehaviorType {
+    HorizontalTranslation = 0,
+    VerticalTranslation = 1,
+    Rotation = 2
+}

package/model/shared/dynamic-display/dynamic-behavior-type.js

@@ -1,6 +1,6 @@
-export var DynamicBehaviorType;
-(function (DynamicBehaviorType) {
-    DynamicBehaviorType[DynamicBehaviorType["HorizontalTranslation"] = 0] = "HorizontalTranslation";
-    DynamicBehaviorType[DynamicBehaviorType["VerticalTranslation"] = 1] = "VerticalTranslation";
-    DynamicBehaviorType[DynamicBehaviorType["Rotation"] = 2] = "Rotation";
-})(DynamicBehaviorType || (DynamicBehaviorType = {}));
+export var DynamicBehaviorType;
+(function (DynamicBehaviorType) {
+    DynamicBehaviorType[DynamicBehaviorType["HorizontalTranslation"] = 0] = "HorizontalTranslation";
+    DynamicBehaviorType[DynamicBehaviorType["VerticalTranslation"] = 1] = "VerticalTranslation";
+    DynamicBehaviorType[DynamicBehaviorType["Rotation"] = 2] = "Rotation";
+})(DynamicBehaviorType || (DynamicBehaviorType = {}));

package/model/shared/dynamic-display/dynamic-display-behavior-model.d.ts

@@ -1,5 +1,5 @@
-import { DynamicDisplayResultModel } from './dynamic-display-result-model';
-import { EventEmitter } from '@angular/core';
-export interface DynamicDisplayBehaviorModel {
-    readonly doBehavior: EventEmitter<DynamicDisplayResultModel>;
-}
+import { DynamicDisplayResultModel } from './dynamic-display-result-model';
+import { EventEmitter } from '@angular/core';
+export interface DynamicDisplayBehaviorModel {
+    readonly doBehavior: EventEmitter<DynamicDisplayResultModel>;
+}

package/model/shared/dynamic-display/dynamic-display-model.d.ts

@@ -1,10 +1,10 @@
-import { RotationModel } from '../rotation/rotation-model';
-import { TranslationModel } from '../translation/translation-model';
-export interface DynamicDisplayModel {
-    readonly isHorizontalTranslation: boolean;
-    readonly horizontalTranslation?: TranslationModel;
-    readonly isVerticalTranslation: boolean;
-    readonly verticalTranslation?: TranslationModel;
-    readonly isRotation: boolean;
-    readonly rotation?: RotationModel;
-}
+import { RotationModel } from '../rotation/rotation-model';
+import { TranslationModel } from '../translation/translation-model';
+export interface DynamicDisplayModel {
+    readonly isHorizontalTranslation: boolean;
+    readonly horizontalTranslation?: TranslationModel;
+    readonly isVerticalTranslation: boolean;
+    readonly verticalTranslation?: TranslationModel;
+    readonly isRotation: boolean;
+    readonly rotation?: RotationModel;
+}

package/model/shared/dynamic-display/dynamic-display-result-model.d.ts

@@ -1,7 +1,7 @@
-import { DynamicBehaviorType } from './dynamic-behavior-type';
-export declare class DynamicDisplayResultModel {
-    readonly translation: number;
-    readonly angel: number;
-    readonly behaviorType: DynamicBehaviorType;
-    constructor(translation: number, angel: number, behaviorType: DynamicBehaviorType);
-}
+import { DynamicBehaviorType } from './dynamic-behavior-type';
+export declare class DynamicDisplayResultModel {
+    readonly translation: number;
+    readonly angel: number;
+    readonly behaviorType: DynamicBehaviorType;
+    constructor(translation: number, angel: number, behaviorType: DynamicBehaviorType);
+}

package/model/shared/dynamic-display/dynamic-display-result-model.js

@@ -1,7 +1,7 @@
-export class DynamicDisplayResultModel {
-    constructor(translation, angel, behaviorType) {
-        this.translation = translation;
-        this.angel = angel;
-        this.behaviorType = behaviorType;
-    }
-}
+export class DynamicDisplayResultModel {
+    constructor(translation, angel, behaviorType) {
+        this.translation = translation;
+        this.angel = angel;
+        this.behaviorType = behaviorType;
+    }
+}

package/model/shared/dynamic-display/dynamic-display.d.ts

@@ -1,11 +1,11 @@
-import { EventEmitter } from '@angular/core';
-import { DynamicDisplayBehaviorModel } from './dynamic-display-behavior-model';
-import { DynamicDisplayModel } from './dynamic-display-model';
-import { DynamicDisplayResultModel } from './dynamic-display-result-model';
-import { VariableCommunicator } from '../../../communication';
-import { Point } from '../point.model';
-import { VariableStore } from '../../../config';
-export declare class DynamicDisplay implements DynamicDisplayBehaviorModel {
-    readonly doBehavior: EventEmitter<DynamicDisplayResultModel>;
-    constructor(dynamicDisplay: DynamicDisplayModel, variableCommunicator: VariableCommunicator, variableStore: VariableStore, location: Point, signalRAppId: string);
-}
+import { EventEmitter } from '@angular/core';
+import { DynamicDisplayBehaviorModel } from './dynamic-display-behavior-model';
+import { DynamicDisplayModel } from './dynamic-display-model';
+import { DynamicDisplayResultModel } from './dynamic-display-result-model';
+import { VariableCommunicator } from '../../../communication';
+import { Point } from '../point.model';
+import { VariableStore } from '../../../config';
+export declare class DynamicDisplay implements DynamicDisplayBehaviorModel {
+    readonly doBehavior: EventEmitter<DynamicDisplayResultModel>;
+    constructor(dynamicDisplay: DynamicDisplayModel, variableCommunicator: VariableCommunicator, variableStore: VariableStore, location: Point, signalRAppId: string);
+}