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

package/model/shared/condition/condition-items-observer.d.ts

@@ -1,5 +1,5 @@
-import { EventEmitter } from '@angular/core';
-import { ConditionControlResultValue } from './condition-control-result-value';
-export interface ConditionItemsObserver {
-    readonly conditionResultChanged: EventEmitter<ConditionControlResultValue>;
-}
+import { EventEmitter } from '@angular/core';
+import { ConditionControlResultValue } from './condition-control-result-value';
+export interface ConditionItemsObserver {
+    readonly conditionResultChanged: EventEmitter<ConditionControlResultValue>;
+}

package/model/shared/condition/condition-items-result-observer.d.ts

@@ -1,16 +1,16 @@
-import { EventEmitter } from '@angular/core';
-import { ConditionItemModel } from './condition-item-model';
-import { ConditionItemsObserver } from './condition-items-observer';
-import { VariableCommunicator } from '../../../communication';
-import { ConditionControlResultValue } from './condition-control-result-value';
-import { VariableStore } from '../../../config';
-export declare class ConditionItemsResultObserver implements ConditionItemsObserver {
-    private readonly sourceConditionItems;
-    private readonly variableCommunicator;
-    private readonly variableStore;
-    readonly conditionResultChanged: EventEmitter<ConditionControlResultValue>;
-    private conditionResults;
-    constructor(sourceConditionItems: ConditionItemModel[], variableCommunicator: VariableCommunicator, variableStore: VariableStore);
-    requestData(appId: string): void;
-    private emitConditionResult;
-}
+import { EventEmitter } from '@angular/core';
+import { ConditionItemModel } from './condition-item-model';
+import { ConditionItemsObserver } from './condition-items-observer';
+import { VariableCommunicator } from '../../../communication';
+import { ConditionControlResultValue } from './condition-control-result-value';
+import { VariableStore } from '../../../config';
+export declare class ConditionItemsResultObserver implements ConditionItemsObserver {
+    private readonly sourceConditionItems;
+    private readonly variableCommunicator;
+    private readonly variableStore;
+    readonly conditionResultChanged: EventEmitter<ConditionControlResultValue>;
+    private conditionResults;
+    constructor(sourceConditionItems: ConditionItemModel[], variableCommunicator: VariableCommunicator, variableStore: VariableStore);
+    requestData(appId: string): void;
+    private emitConditionResult;
+}

package/model/shared/condition/condition-items-result-observer.js

@@ -1,87 +1,87 @@
-import { EventEmitter } from '@angular/core';
-import { sortBy } from 'lodash';
-import { ConditionType } from './condition-type';
-import { BitConditionItemObserver } from './bit-condition-item-observer';
-import { RelationConditionResult } from './relation-condition-result';
-import { WordConditionItemObserver } from './word-condition-item-observer';
-import { RelationType } from './relation-type';
-export class ConditionItemsResultObserver {
-    constructor(sourceConditionItems, variableCommunicator, variableStore) {
-        this.sourceConditionItems = sourceConditionItems;
-        this.variableCommunicator = variableCommunicator;
-        this.variableStore = variableStore;
-        this.conditionResultChanged = new EventEmitter();
-        this.conditionResults = new Map();
-    }
-    requestData(appId) {
-        if (null == this.sourceConditionItems || !this.sourceConditionItems.length) {
-            return;
-        }
-        const conditionItems = this.sourceConditionItems.sort(t => t.index);
-        conditionItems.forEach(item => {
-            switch (item.conditionType) {
-                case ConditionType.Bit:
-                    const bitItem = new BitConditionItemObserver(item.condition, this.variableCommunicator, this.variableStore);
-                    bitItem.conditionEffectiveChanged.subscribe(itemResult => {
-                        if (this.conditionResults.has(conditionItems.indexOf(item))) {
-                            this.conditionResults.delete(conditionItems.indexOf(item));
-                        }
-                        this.conditionResults.set(conditionItems.indexOf(item), new RelationConditionResult(conditionItems.indexOf(item), item.relationType, itemResult));
-                        this.emitConditionResult();
-                    });
-                    bitItem.requestData(appId);
-                    break;
-                case ConditionType.Word:
-                    const wordItem = new WordConditionItemObserver(item.condition, this.variableCommunicator, this.variableStore);
-                    wordItem.conditionEffectiveChanged.subscribe(itemResult => {
-                        if (this.conditionResults.has(conditionItems.indexOf(item))) {
-                            this.conditionResults.delete(conditionItems.indexOf(item));
-                        }
-                        this.conditionResults.set(conditionItems.indexOf(item), new RelationConditionResult(conditionItems.indexOf(item), item.relationType, itemResult));
-                        this.emitConditionResult();
-                    });
-                    wordItem.requestData(appId);
-                    break;
-                default:
-                    throw new Error(`Unknown ConditionType :${item.conditionType}`);
-            }
-        });
-    }
-    emitConditionResult() {
-        let isControl = true;
-        const elementStates = [];
-        const formatConditionResults = [];
-        this.conditionResults.forEach(t => {
-            formatConditionResults.push({
-                key: t.key,
-                result: t
-            });
-            // eslint-disable-next-line eqeqeq
-            if (t.relationType == RelationType.None) {
-                isControl = t.result.value;
-                elementStates.push(t.result.state);
-            }
-        });
-        const formatResults = sortBy(formatConditionResults, data => {
-            return data.key;
-        });
-        formatResults.forEach(item => {
-            const relationCondition = item.result;
-            // eslint-disable-next-line eqeqeq
-            if (relationCondition.relationType == RelationType.Or) {
-                isControl = isControl || relationCondition.result.value;
-                elementStates.push(relationCondition.result.state);
-                // eslint-disable-next-line eqeqeq
-            }
-            else if (relationCondition.relationType == RelationType.And) {
-                isControl = isControl && relationCondition.result.value;
-                elementStates.push(relationCondition.result.state);
-            }
-        });
-        const conditionControlResult = {
-            states: elementStates,
-            value: isControl
-        };
-        this.conditionResultChanged.emit(conditionControlResult);
-    }
-}
+import { EventEmitter } from '@angular/core';
+import { sortBy } from 'lodash';
+import { ConditionType } from './condition-type';
+import { BitConditionItemObserver } from './bit-condition-item-observer';
+import { RelationConditionResult } from './relation-condition-result';
+import { WordConditionItemObserver } from './word-condition-item-observer';
+import { RelationType } from './relation-type';
+export class ConditionItemsResultObserver {
+    constructor(sourceConditionItems, variableCommunicator, variableStore) {
+        this.sourceConditionItems = sourceConditionItems;
+        this.variableCommunicator = variableCommunicator;
+        this.variableStore = variableStore;
+        this.conditionResultChanged = new EventEmitter();
+        this.conditionResults = new Map();
+    }
+    requestData(appId) {
+        if (null == this.sourceConditionItems || !this.sourceConditionItems.length) {
+            return;
+        }
+        const conditionItems = this.sourceConditionItems.sort(t => t.index);
+        conditionItems.forEach(item => {
+            switch (item.conditionType) {
+                case ConditionType.Bit:
+                    const bitItem = new BitConditionItemObserver(item.condition, this.variableCommunicator, this.variableStore);
+                    bitItem.conditionEffectiveChanged.subscribe(itemResult => {
+                        if (this.conditionResults.has(conditionItems.indexOf(item))) {
+                            this.conditionResults.delete(conditionItems.indexOf(item));
+                        }
+                        this.conditionResults.set(conditionItems.indexOf(item), new RelationConditionResult(conditionItems.indexOf(item), item.relationType, itemResult));
+                        this.emitConditionResult();
+                    });
+                    bitItem.requestData(appId);
+                    break;
+                case ConditionType.Word:
+                    const wordItem = new WordConditionItemObserver(item.condition, this.variableCommunicator, this.variableStore);
+                    wordItem.conditionEffectiveChanged.subscribe(itemResult => {
+                        if (this.conditionResults.has(conditionItems.indexOf(item))) {
+                            this.conditionResults.delete(conditionItems.indexOf(item));
+                        }
+                        this.conditionResults.set(conditionItems.indexOf(item), new RelationConditionResult(conditionItems.indexOf(item), item.relationType, itemResult));
+                        this.emitConditionResult();
+                    });
+                    wordItem.requestData(appId);
+                    break;
+                default:
+                    throw new Error(`Unknown ConditionType :${item.conditionType}`);
+            }
+        });
+    }
+    emitConditionResult() {
+        let isControl = true;
+        const elementStates = [];
+        const formatConditionResults = [];
+        this.conditionResults.forEach(t => {
+            formatConditionResults.push({
+                key: t.key,
+                result: t
+            });
+            // eslint-disable-next-line eqeqeq
+            if (t.relationType == RelationType.None) {
+                isControl = t.result.value;
+                elementStates.push(t.result.state);
+            }
+        });
+        const formatResults = sortBy(formatConditionResults, data => {
+            return data.key;
+        });
+        formatResults.forEach(item => {
+            const relationCondition = item.result;
+            // eslint-disable-next-line eqeqeq
+            if (relationCondition.relationType == RelationType.Or) {
+                isControl = isControl || relationCondition.result.value;
+                elementStates.push(relationCondition.result.state);
+                // eslint-disable-next-line eqeqeq
+            }
+            else if (relationCondition.relationType == RelationType.And) {
+                isControl = isControl && relationCondition.result.value;
+                elementStates.push(relationCondition.result.state);
+            }
+        });
+        const conditionControlResult = {
+            states: elementStates,
+            value: isControl
+        };
+        this.conditionResultChanged.emit(conditionControlResult);
+    }
+}

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

@@ -1,6 +1,6 @@
-export interface ConditionModel {
-    readonly variableName: string;
-    readonly variableGroupName: string;
-    readonly dataSourceCode?: number;
-    readonly variableVersion?: number;
-}
+export interface ConditionModel {
+    readonly variableName: string;
+    readonly variableGroupName: string;
+    readonly dataSourceCode?: number;
+    readonly variableVersion?: number;
+}

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

@@ -1,4 +1,4 @@
-export declare enum ConditionType {
-    Bit = 0,
-    Word = 1
-}
+export declare enum ConditionType {
+    Bit = 0,
+    Word = 1
+}

package/model/shared/condition/condition-type.js

@@ -1,5 +1,5 @@
-export var ConditionType;
-(function (ConditionType) {
-    ConditionType[ConditionType["Bit"] = 0] = "Bit";
-    ConditionType[ConditionType["Word"] = 1] = "Word";
-})(ConditionType || (ConditionType = {}));
+export var ConditionType;
+(function (ConditionType) {
+    ConditionType[ConditionType["Bit"] = 0] = "Bit";
+    ConditionType[ConditionType["Word"] = 1] = "Word";
+})(ConditionType || (ConditionType = {}));

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

@@ -1,5 +1,5 @@
-import { RelationConditionResult } from './relation-condition-result';
-export interface ConvertConditionModel {
-    readonly key: number;
-    readonly result: RelationConditionResult;
-}
+import { RelationConditionResult } from './relation-condition-result';
+export interface ConvertConditionModel {
+    readonly key: number;
+    readonly result: RelationConditionResult;
+}

package/model/shared/condition/index.d.ts

@@ -1,11 +1,11 @@
-export { RelationalOperator } from './relational-operator';
-export { BitCondition } from './bit-condition';
-export { BitConditonLogic } from './bit-condition-logic';
-export { WordCondition } from './word-condition';
-import { BitCondition } from './bit-condition';
-import { WordCondition } from './word-condition';
-export { ConditionHelper } from './condition-helper';
-export declare type Condition = BitCondition | WordCondition;
-export { ConditionItemsResultObserver } from './condition-items-result-observer';
-export { ConditionItemModel } from './condition-item-model';
-export { ConditionControlResultValue } from './condition-control-result-value';
+export { RelationalOperator } from './relational-operator';
+export { BitCondition } from './bit-condition';
+export { BitConditonLogic } from './bit-condition-logic';
+export { WordCondition } from './word-condition';
+import { BitCondition } from './bit-condition';
+import { WordCondition } from './word-condition';
+export { ConditionHelper } from './condition-helper';
+export declare type Condition = BitCondition | WordCondition;
+export { ConditionItemsResultObserver } from './condition-items-result-observer';
+export { ConditionItemModel } from './condition-item-model';
+export { ConditionControlResultValue } from './condition-control-result-value';

package/model/shared/condition/index.js

@@ -1,4 +1,4 @@
-export { RelationalOperator } from './relational-operator';
-export { BitConditonLogic } from './bit-condition-logic';
-export { ConditionHelper } from './condition-helper';
-export { ConditionItemsResultObserver } from './condition-items-result-observer';
+export { RelationalOperator } from './relational-operator';
+export { BitConditonLogic } from './bit-condition-logic';
+export { ConditionHelper } from './condition-helper';
+export { ConditionItemsResultObserver } from './condition-items-result-observer';

package/model/shared/condition/relation-condition-result-state.d.ts

@@ -1,6 +1,6 @@
-import { VariableState } from '../../../communication/variable/variable-state';
-export declare class RelationConditionResultState {
-    readonly state: VariableState;
-    readonly value: boolean;
-    constructor(state: VariableState, value: boolean);
-}
+import { VariableState } from '../../../communication/variable/variable-state';
+export declare class RelationConditionResultState {
+    readonly state: VariableState;
+    readonly value: boolean;
+    constructor(state: VariableState, value: boolean);
+}

package/model/shared/condition/relation-condition-result-state.js

@@ -1,8 +1,8 @@
-export class RelationConditionResultState {
-    constructor(state, value) {
-        this.state = state;
-        this.value = value;
-        this.state = state;
-        this.value = value;
-    }
-}
+export class RelationConditionResultState {
+    constructor(state, value) {
+        this.state = state;
+        this.value = value;
+        this.state = state;
+        this.value = value;
+    }
+}

package/model/shared/condition/relation-condition-result.d.ts

@@ -1,8 +1,8 @@
-import { RelationType } from './relation-type';
-import { RelationConditionResultState } from './relation-condition-result-state';
-export declare class RelationConditionResult {
-    readonly key: number;
-    readonly relationType: RelationType;
-    readonly result: RelationConditionResultState;
-    constructor(key: number, relationType: RelationType, result: RelationConditionResultState);
-}
+import { RelationType } from './relation-type';
+import { RelationConditionResultState } from './relation-condition-result-state';
+export declare class RelationConditionResult {
+    readonly key: number;
+    readonly relationType: RelationType;
+    readonly result: RelationConditionResultState;
+    constructor(key: number, relationType: RelationType, result: RelationConditionResultState);
+}

package/model/shared/condition/relation-condition-result.js

@@ -1,7 +1,7 @@
-export class RelationConditionResult {
-    constructor(key, relationType, result) {
-        this.key = key;
-        this.relationType = relationType;
-        this.result = result;
-    }
-}
+export class RelationConditionResult {
+    constructor(key, relationType, result) {
+        this.key = key;
+        this.relationType = relationType;
+        this.result = result;
+    }
+}

package/model/shared/condition/relation-type.d.ts

@@ -1,5 +1,5 @@
-export declare enum RelationType {
-    None = 0,
-    And = 1,
-    Or = 2
-}
+export declare enum RelationType {
+    None = 0,
+    And = 1,
+    Or = 2
+}

package/model/shared/condition/relation-type.js

@@ -1,6 +1,6 @@
-export var RelationType;
-(function (RelationType) {
-    RelationType[RelationType["None"] = 0] = "None";
-    RelationType[RelationType["And"] = 1] = "And";
-    RelationType[RelationType["Or"] = 2] = "Or";
-})(RelationType || (RelationType = {}));
+export var RelationType;
+(function (RelationType) {
+    RelationType[RelationType["None"] = 0] = "None";
+    RelationType[RelationType["And"] = 1] = "And";
+    RelationType[RelationType["Or"] = 2] = "Or";
+})(RelationType || (RelationType = {}));

package/model/shared/condition/relational-operator.d.ts

@@ -1,8 +1,8 @@
-export declare enum RelationalOperator {
-    Equal = 0,
-    NotEqual = 1,
-    GreaterThan = 2,
-    LessThan = 3,
-    GreaterOrEqual = 4,
-    LessOrEqual = 5
-}
+export declare enum RelationalOperator {
+    Equal = 0,
+    NotEqual = 1,
+    GreaterThan = 2,
+    LessThan = 3,
+    GreaterOrEqual = 4,
+    LessOrEqual = 5
+}

package/model/shared/condition/relational-operator.js

@@ -1,9 +1,9 @@
-export var RelationalOperator;
-(function (RelationalOperator) {
-    RelationalOperator[RelationalOperator["Equal"] = 0] = "Equal";
-    RelationalOperator[RelationalOperator["NotEqual"] = 1] = "NotEqual";
-    RelationalOperator[RelationalOperator["GreaterThan"] = 2] = "GreaterThan";
-    RelationalOperator[RelationalOperator["LessThan"] = 3] = "LessThan";
-    RelationalOperator[RelationalOperator["GreaterOrEqual"] = 4] = "GreaterOrEqual";
-    RelationalOperator[RelationalOperator["LessOrEqual"] = 5] = "LessOrEqual";
-})(RelationalOperator || (RelationalOperator = {}));
+export var RelationalOperator;
+(function (RelationalOperator) {
+    RelationalOperator[RelationalOperator["Equal"] = 0] = "Equal";
+    RelationalOperator[RelationalOperator["NotEqual"] = 1] = "NotEqual";
+    RelationalOperator[RelationalOperator["GreaterThan"] = 2] = "GreaterThan";
+    RelationalOperator[RelationalOperator["LessThan"] = 3] = "LessThan";
+    RelationalOperator[RelationalOperator["GreaterOrEqual"] = 4] = "GreaterOrEqual";
+    RelationalOperator[RelationalOperator["LessOrEqual"] = 5] = "LessOrEqual";
+})(RelationalOperator || (RelationalOperator = {}));

package/model/shared/condition/variable-value-logic-model.d.ts

@@ -1,11 +1,11 @@
-import { VariableValueType } from './variable-value-type';
-import { RelationalOperator } from './relational-operator';
-export interface VariableValueLogicModel {
-    readonly variableName?: string;
-    readonly variableGroupName?: string;
-    readonly dataSourceCode?: number;
-    readonly valueType: VariableValueType;
-    readonly constValue?: number;
-    readonly operator: RelationalOperator;
-    readonly variableVersion?: number;
-}
+import { VariableValueType } from './variable-value-type';
+import { RelationalOperator } from './relational-operator';
+export interface VariableValueLogicModel {
+    readonly variableName?: string;
+    readonly variableGroupName?: string;
+    readonly dataSourceCode?: number;
+    readonly valueType: VariableValueType;
+    readonly constValue?: number;
+    readonly operator: RelationalOperator;
+    readonly variableVersion?: number;
+}

package/model/shared/condition/variable-value-type.d.ts

@@ -1,4 +1,4 @@
-export declare enum VariableValueType {
-    Constant = 0,
-    Variable = 1
-}
+export declare enum VariableValueType {
+    Constant = 0,
+    Variable = 1
+}

package/model/shared/condition/variable-value-type.js

@@ -1,5 +1,5 @@
-export var VariableValueType;
-(function (VariableValueType) {
-    VariableValueType[VariableValueType["Constant"] = 0] = "Constant";
-    VariableValueType[VariableValueType["Variable"] = 1] = "Variable";
-})(VariableValueType || (VariableValueType = {}));
+export var VariableValueType;
+(function (VariableValueType) {
+    VariableValueType[VariableValueType["Constant"] = 0] = "Constant";
+    VariableValueType[VariableValueType["Variable"] = 1] = "Variable";
+})(VariableValueType || (VariableValueType = {}));

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

@@ -1,21 +1,21 @@
-import { ConditionItemObserver } from './condition-item-observer';
-import { VariableCommunicator } from '../../../communication';
-import { WordConditionModel } from './word-condition-model';
-import { VariableStore } from '../../../config';
-export declare class WordConditionItemObserver extends ConditionItemObserver {
-    protected readonly wordCondition: WordConditionModel;
-    private readonly variableCommunicator;
-    isConditionEffective: boolean;
-    private currentValue;
-    private baseVariableValue;
-    private realtionVariableValue?;
-    get baseVariable(): string;
-    get realtionVariable(): string;
-    constructor(wordCondition: WordConditionModel, variableCommunicator: VariableCommunicator, variableStore: VariableStore);
-    requestData(appId: string): void;
-    private requestconditionEffectiveValue;
-    private requestconditionEffectiveBaseValue;
-    private requestconditionEffectiveRealtionValue;
-    getIsConditionEffective(): boolean;
-    private comparator;
-}
+import { ConditionItemObserver } from './condition-item-observer';
+import { VariableCommunicator } from '../../../communication';
+import { WordConditionModel } from './word-condition-model';
+import { VariableStore } from '../../../config';
+export declare class WordConditionItemObserver extends ConditionItemObserver {
+    protected readonly wordCondition: WordConditionModel;
+    private readonly variableCommunicator;
+    isConditionEffective: boolean;
+    private currentValue;
+    private baseVariableValue;
+    private realtionVariableValue?;
+    get baseVariable(): string;
+    get realtionVariable(): string;
+    constructor(wordCondition: WordConditionModel, variableCommunicator: VariableCommunicator, variableStore: VariableStore);
+    requestData(appId: string): void;
+    private requestconditionEffectiveValue;
+    private requestconditionEffectiveBaseValue;
+    private requestconditionEffectiveRealtionValue;
+    getIsConditionEffective(): boolean;
+    private comparator;
+}