@flexem/fc-gui 3.0.0-alpha.91 → 3.0.0-alpha.92

package/model/settings/background/view-background-fill-type.js

@@ -0,0 +1,6 @@
+export var ViewBackgroundFillType;
+(function (ViewBackgroundFillType) {
+    ViewBackgroundFillType[ViewBackgroundFillType["SolidColor"] = 0] = "SolidColor";
+    ViewBackgroundFillType[ViewBackgroundFillType["Image"] = 1] = "Image";
+    ViewBackgroundFillType[ViewBackgroundFillType["Graph"] = 2] = "Graph";
+})(ViewBackgroundFillType || (ViewBackgroundFillType = {}));

package/model/settings/background/view-background-fill-type.metadata.json

@@ -0,0 +1 @@
+[{"__symbolic":"module","version":4,"metadata":{"ViewBackgroundFillType":{"SolidColor":0,"Image":1,"Graph":2}}}]

package/model/settings/background/view-background.model.d.ts

@@ -0,0 +1,8 @@
+import { ViewBackgroundFillType } from './view-background-fill-type';
+import { GraphSetting } from '../../shared/graph/graph-setting';
+export interface ViewBackgroundModel {
+    fillType: ViewBackgroundFillType;
+    solidColor?: string;
+    imageId?: string;
+    graphSetting?: GraphSetting;
+}

package/model/settings/background/view-background.model.metadata.json

@@ -0,0 +1 @@
+[{"__symbolic":"module","version":4,"metadata":{"ViewBackgroundModel":{"__symbolic":"interface"}}}]

package/model/settings/index.js

@@ -0,0 +1,2 @@
+export { ViewPopupLocationType } from './popup/view-popup-location-type';
+export { ViewPopupBackdropType } from './popup/view-popup-backdrop-type';

package/model/settings/index.metadata.json

@@ -0,0 +1 @@
+[{"__symbolic":"module","version":4,"metadata":{},"exports":[{"from":"./view-settings.model","export":["ViewSettingsModel"]},{"from":"./popup/view-popup-location-type","export":["ViewPopupLocationType"]},{"from":"./popup/view-popup-backdrop-type","export":["ViewPopupBackdropType"]}]}]

package/model/settings/popup/view-popup-backdrop-type.d.ts

@@ -0,0 +1,4 @@
+export declare enum ViewPopupBackdropType {
+    Shadow = 0,
+    Musk = 1
+}

package/model/settings/popup/view-popup-backdrop-type.js

@@ -0,0 +1,5 @@
+export var ViewPopupBackdropType;
+(function (ViewPopupBackdropType) {
+    ViewPopupBackdropType[ViewPopupBackdropType["Shadow"] = 0] = "Shadow";
+    ViewPopupBackdropType[ViewPopupBackdropType["Musk"] = 1] = "Musk";
+})(ViewPopupBackdropType || (ViewPopupBackdropType = {}));

package/model/settings/popup/view-popup-backdrop-type.metadata.json

@@ -0,0 +1 @@
+[{"__symbolic":"module","version":4,"metadata":{"ViewPopupBackdropType":{"Shadow":0,"Musk":1}}}]

package/model/settings/popup/view-popup-location-type.d.ts

@@ -0,0 +1,4 @@
+export declare enum ViewPopupLocationType {
+    Center = 0,
+    Custom = 1
+}

package/model/settings/popup/view-popup-location-type.js

@@ -0,0 +1,5 @@
+export var ViewPopupLocationType;
+(function (ViewPopupLocationType) {
+    ViewPopupLocationType[ViewPopupLocationType["Center"] = 0] = "Center";
+    ViewPopupLocationType[ViewPopupLocationType["Custom"] = 1] = "Custom";
+})(ViewPopupLocationType || (ViewPopupLocationType = {}));

package/model/settings/popup/view-popup-location-type.metadata.json

@@ -0,0 +1 @@
+[{"__symbolic":"module","version":4,"metadata":{"ViewPopupLocationType":{"Center":0,"Custom":1}}}]

package/model/settings/popup/view-popup-setting.model.d.ts

@@ -0,0 +1,17 @@
+import { Point } from '../../shared';
+import { ViewPopupLocationType } from './view-popup-location-type';
+import { ViewPopupBackdropType } from './view-popup-backdrop-type';
+export declare class ViewPopupSettingModel {
+    /**
+     * 弹出位置类型：画面居中、自定义
+     */
+    locationType: ViewPopupLocationType;
+    /**
+     * 自定义弹出位置时的坐标
+     */
+    location?: Point;
+    /**
+     * 背景显示类型：阴影、蒙版（垄断）
+     */
+    backdropType: ViewPopupBackdropType;
+}

package/model/settings/popup/view-popup-setting.model.js

@@ -0,0 +1,2 @@
+export class ViewPopupSettingModel {
+}

package/model/settings/popup/view-popup-setting.model.metadata.json

@@ -0,0 +1 @@
+[{"__symbolic":"module","version":4,"metadata":{"ViewPopupSettingModel":{"__symbolic":"class"}}}]

package/model/settings/view-settings.model.d.ts

@@ -0,0 +1,6 @@
+import { ViewBackgroundModel } from './background/view-background.model';
+import { ViewPopupSettingModel } from './popup/view-popup-setting.model';
+export interface ViewSettingsModel {
+    background: ViewBackgroundModel;
+    popup?: ViewPopupSettingModel;
+}

package/model/settings/view-settings.model.metadata.json

@@ -0,0 +1 @@
+[{"__symbolic":"module","version":4,"metadata":{"ViewSettingsModel":{"__symbolic":"interface"}}}]

package/model/shared/alarm/alarm-range.model.metadata.json

@@ -0,0 +1 @@
+[{"__symbolic":"module","version":4,"metadata":{"AlarmRangeModel":{"__symbolic":"interface"}}}]

package/model/shared/arc.model.metadata.json

@@ -0,0 +1 @@
+[{"__symbolic":"module","version":4,"metadata":{"ArcModel":{"__symbolic":"interface"}}}]

package/model/shared/binary.d.ts

@@ -0,0 +1,7 @@
+export declare class Binary {
+    num: any;
+    bits: number;
+    constructor(num: any, bits: number);
+    decimalToBinary(num: number, bits: number): string;
+    convertToBinary(): string;
+}

package/model/shared/binary.js

@@ -0,0 +1,37 @@
+export class Binary {
+    constructor(num, bits) {
+        this.num = num ? num : 0;
+        this.bits = bits ? bits : 0;
+    }
+    decimalToBinary(num, bits) {
+        const resArry = [];
+        const xresArry = [];
+        let i = 0;
+        // 除2取余
+        for (; num > 0;) {
+            resArry.push(num % 2);
+            // eslint-disable-next-line radix
+            num = parseInt((num / 2).toString());
+            i++;
+        }
+        // 倒序排列
+        for (let j = i - 1; j >= 0; j--) {
+            xresArry.push(resArry[j]);
+        }
+        // 报错
+        if (bits < xresArry.length) {
+            console.log('控制位小于转换位数');
+        }
+        // 补0操作
+        if (bits) {
+            for (let r = xresArry.length; r < bits; r++) {
+                xresArry.unshift('0');
+            }
+        }
+        return xresArry.join().replace(/,/g, '');
+    }
+    convertToBinary() {
+        const value = Number(this.num);
+        return this.decimalToBinary(Math.abs(value), this.bits);
+    }
+}

package/model/shared/binary.metadata.json

@@ -0,0 +1 @@
+[{"__symbolic":"module","version":4,"metadata":{"Binary":{"__symbolic":"class","members":{"__ctor__":[{"__symbolic":"constructor","parameters":[{"__symbolic":"reference","name":"any"},{"__symbolic":"reference","name":"number"}]}],"decimalToBinary":[{"__symbolic":"method"}],"convertToBinary":[{"__symbolic":"method"}]}}}}]

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

@@ -0,0 +1,14 @@
+import { BitConditionModel } from './bit-condition-model';
+import { ConditionItemObserver } from './condition-item-observer';
+import { VariableCommunicator } from '../../../communication';
+import { VariableStore } from '../../../config';
+export declare class BitConditionItemObserver extends ConditionItemObserver {
+    protected readonly bitConditon: BitConditionModel;
+    private readonly variableCommunicator;
+    private currentValue;
+    private binary;
+    constructor(bitConditon: BitConditionModel, variableCommunicator: VariableCommunicator, variableStore: VariableStore);
+    requestData(appId: string): void;
+    private requestconditionEffectiveValue;
+    getIsConditionEffective(): boolean;
+}

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

@@ -0,0 +1,53 @@
+import { ConditionItemObserver } from './condition-item-observer';
+import { VariableValue, VariableStateEnum, VariableState } from '../../../communication';
+import { BitConditonLogic } from './bit-condition-logic';
+import { RelationConditionResultState } from './relation-condition-result-state';
+import { Binary } from '../binary';
+export class BitConditionItemObserver extends ConditionItemObserver {
+    constructor(bitConditon, variableCommunicator, variableStore) {
+        super(bitConditon, variableStore);
+        this.bitConditon = bitConditon;
+        this.variableCommunicator = variableCommunicator;
+    }
+    requestData(appId) {
+        if (!this.bitConditon) {
+            throw new Error('BitConditionModel cannot be null.');
+        }
+        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(value => {
+            if (this.bitConditon.isBitwiseIndex) {
+                const maxBitIndex = 31;
+                this.binary = new Binary(value.value, maxBitIndex + 1);
+                this.currentValue = new VariableValue(value.variableName, value.state, this.binary.convertToBinary().substr(maxBitIndex - this.bitConditon.bitIndex, 1));
+            }
+            else {
+                this.currentValue = value;
+            }
+            this.isConditionEffective = this.getIsConditionEffective();
+            this.conditionEffectiveChanged.emit(new RelationConditionResultState(new VariableState(this.variableName, value.state), this.isConditionEffective));
+        });
+    }
+    getIsConditionEffective() {
+        switch (this.bitConditon.bitConditionLogic) {
+            case BitConditonLogic.On:
+                // eslint-disable-next-line eqeqeq
+                return this.currentValue.state === VariableStateEnum.DataNormal && this.currentValue.value == 1;
+            case BitConditonLogic.Off:
+                // eslint-disable-next-line eqeqeq
+                return this.currentValue.state === VariableStateEnum.DataNormal && this.currentValue.value == 0;
+            default:
+                throw new Error(`Unknown BitConditonLogic : ${this.bitConditon.bitConditionLogic}.`);
+        }
+    }
+}

package/model/shared/condition/bit-condition-item-observer.metadata.json

@@ -0,0 +1 @@
+[{"__symbolic":"module","version":4,"metadata":{"BitConditionItemObserver":{"__symbolic":"class","extends":{"__symbolic":"reference","module":"./condition-item-observer","name":"ConditionItemObserver","line":8,"character":46},"members":{"__ctor__":[{"__symbolic":"constructor","parameters":[{"__symbolic":"reference","module":"./bit-condition-model","name":"BitConditionModel","line":13,"character":48},{"__symbolic":"reference","module":"../../../communication","name":"VariableCommunicator","line":14,"character":47},{"__symbolic":"reference","module":"../../../config","name":"VariableStore","line":15,"character":23}]}],"requestData":[{"__symbolic":"method"}],"requestconditionEffectiveValue":[{"__symbolic":"method"}],"getIsConditionEffective":[{"__symbolic":"method"}]}}}}]

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

@@ -0,0 +1,4 @@
+export declare enum BitConditonLogic {
+    Off = 0,
+    On = 1
+}

package/model/shared/condition/bit-condition-logic.js

@@ -0,0 +1,5 @@
+export var BitConditonLogic;
+(function (BitConditonLogic) {
+    BitConditonLogic[BitConditonLogic["Off"] = 0] = "Off";
+    BitConditonLogic[BitConditonLogic["On"] = 1] = "On";
+})(BitConditonLogic || (BitConditonLogic = {}));

package/model/shared/condition/bit-condition-logic.metadata.json

@@ -0,0 +1 @@
+[{"__symbolic":"module","version":4,"metadata":{"BitConditonLogic":{"Off":0,"On":1}}}]

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

@@ -0,0 +1,8 @@
+import { ConditionModel } from './condition-model';
+import { BitConditonLogic } from './bit-condition-logic';
+export interface BitConditionModel extends ConditionModel {
+    readonly variableName: string;
+    readonly bitConditionLogic: BitConditonLogic;
+    readonly isBitwiseIndex?: boolean;
+    readonly bitIndex?: number;
+}

package/model/shared/condition/bit-condition-model.metadata.json

@@ -0,0 +1 @@
+[{"__symbolic":"module","version":4,"metadata":{"BitConditionModel":{"__symbolic":"interface"}}}]

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

@@ -0,0 +1,4 @@
+import { BitConditonLogic } from './bit-condition-logic';
+export interface BitCondition {
+    readonly logic: BitConditonLogic;
+}

package/model/shared/condition/bit-condition.metadata.json

@@ -0,0 +1 @@
+[{"__symbolic":"module","version":4,"metadata":{"BitCondition":{"__symbolic":"interface"}}}]

package/model/shared/condition/condition-control-result-value.d.ts

@@ -0,0 +1,5 @@
+import { VariableState } from '../../../communication';
+export interface ConditionControlResultValue {
+    readonly states: VariableState[];
+    readonly value: boolean;
+}

package/model/shared/condition/condition-control-result-value.metadata.json

@@ -0,0 +1 @@
+[{"__symbolic":"module","version":4,"metadata":{"ConditionControlResultValue":{"__symbolic":"interface"}}}]

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

@@ -0,0 +1,4 @@
+import { RelationalOperator } from './relational-operator';
+export declare class ConditionHelper {
+    static isSatisfied(operator: RelationalOperator, operand: number, value: number): boolean;
+}

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

@@ -0,0 +1,22 @@
+import { RelationalOperator } from './relational-operator';
+export class ConditionHelper {
+    static isSatisfied(operator, operand, value) {
+        // TODO 考虑浮点数比较问题。
+        switch (+operator) {
+            case RelationalOperator.Equal:
+                return value === operand;
+            case RelationalOperator.GreaterOrEqual:
+                return value >= operand;
+            case RelationalOperator.GreaterThan:
+                return value > operand;
+            case RelationalOperator.LessOrEqual:
+                return value <= operand;
+            case RelationalOperator.LessThan:
+                return value < operand;
+            case RelationalOperator.NotEqual:
+                return value !== operand;
+            default:
+                throw new Error(`Unknown RelationalOperator:${operator}.`);
+        }
+    }
+}

package/model/shared/condition/condition-helper.metadata.json

@@ -0,0 +1 @@
+[{"__symbolic":"module","version":4,"metadata":{"ConditionHelper":{"__symbolic":"class"}}}]

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

@@ -0,0 +1,10 @@
+import { BitConditionModel } from './bit-condition-model';
+import { WordConditionModel } from './word-condition-model';
+import { ConditionType } from './condition-type';
+import { RelationType } from './relation-type';
+export interface ConditionItemModel {
+    readonly index: number;
+    readonly conditionType: ConditionType;
+    readonly relationType?: RelationType;
+    readonly condition: BitConditionModel | WordConditionModel;
+}

package/model/shared/condition/condition-item-model.metadata.json

@@ -0,0 +1 @@
+[{"__symbolic":"module","version":4,"metadata":{"ConditionItemModel":{"__symbolic":"interface"}}}]

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

@@ -0,0 +1,12 @@
+import { EventEmitter } from '@angular/core';
+import { ConditionModel } from './condition-model';
+import { RelationConditionResultState } from './relation-condition-result-state';
+import { VariableStore } from '../../../config';
+export declare abstract class ConditionItemObserver {
+    protected readonly condition: ConditionModel;
+    protected readonly variableStore: VariableStore;
+    isConditionEffective: boolean;
+    readonly conditionEffectiveChanged: EventEmitter<RelationConditionResultState>;
+    constructor(condition: ConditionModel, variableStore: VariableStore);
+    get variableName(): string;
+}

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

@@ -0,0 +1,14 @@
+import { EventEmitter } from '@angular/core';
+import { VariableUtil } from '../../../utils/variable-util';
+import { VariableDefinition } from '../../../communication/variable/variable-definition';
+export class ConditionItemObserver {
+    constructor(condition, variableStore) {
+        this.condition = condition;
+        this.variableStore = variableStore;
+        this.conditionEffectiveChanged = new EventEmitter();
+    }
+    get variableName() {
+        const variable = new VariableDefinition(this.condition.variableName, this.condition.variableGroupName, this.condition.dataSourceCode, this.condition.variableVersion);
+        return VariableUtil.getConvertedVariableName(this.variableStore, variable);
+    }
+}

package/model/shared/condition/condition-item-observer.metadata.json

@@ -0,0 +1 @@
+[{"__symbolic":"module","version":4,"metadata":{"ConditionItemObserver":{"__symbolic":"class","members":{"__ctor__":[{"__symbolic":"constructor","parameters":[{"__symbolic":"reference","module":"./condition-model","name":"ConditionModel","line":13,"character":46},{"__symbolic":"reference","module":"../../../config","name":"VariableStore","line":13,"character":96}]}]}}}}]

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

@@ -0,0 +1,5 @@
+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-observer.metadata.json

@@ -0,0 +1 @@
+[{"__symbolic":"module","version":4,"metadata":{"ConditionItemsObserver":{"__symbolic":"interface"}}}]

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

@@ -0,0 +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;
+}

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

@@ -0,0 +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);
+    }
+}

package/model/shared/condition/condition-items-result-observer.metadata.json

@@ -0,0 +1 @@
+[{"__symbolic":"module","version":4,"metadata":{"ConditionItemsResultObserver":{"__symbolic":"class","members":{"__ctor__":[{"__symbolic":"constructor","parameters":[{"__symbolic":"reference","name":"Array","arguments":[{"__symbolic":"reference","module":"./condition-item-model","name":"ConditionItemModel","line":20,"character":55}]},{"__symbolic":"reference","module":"../../../communication","name":"VariableCommunicator","line":21,"character":47},{"__symbolic":"reference","module":"../../../config","name":"VariableStore","line":22,"character":40}]}],"requestData":[{"__symbolic":"method"}],"emitConditionResult":[{"__symbolic":"method"}]}}}}]

package/model/shared/condition/condition-model.metadata.json

@@ -0,0 +1 @@
+[{"__symbolic":"module","version":4,"metadata":{"ConditionModel":{"__symbolic":"interface"}}}]

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

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

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

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

package/model/shared/condition/condition-type.metadata.json

@@ -0,0 +1 @@
+[{"__symbolic":"module","version":4,"metadata":{"ConditionType":{"Bit":0,"Word":1}}}]

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

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

package/model/shared/condition/convert-condition-model.metadata.json

@@ -0,0 +1 @@
+[{"__symbolic":"module","version":4,"metadata":{"ConvertConditionModel":{"__symbolic":"interface"}}}]

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

@@ -0,0 +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';

package/model/shared/condition/index.js

@@ -0,0 +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';

package/model/shared/condition/index.metadata.json

@@ -0,0 +1 @@
+[{"__symbolic":"module","version":4,"metadata":{"Condition":{"__symbolic":"interface"}},"exports":[{"from":"./relational-operator","export":["RelationalOperator"]},{"from":"./bit-condition","export":["BitCondition"]},{"from":"./bit-condition-logic","export":["BitConditonLogic"]},{"from":"./word-condition","export":["WordCondition"]},{"from":"./condition-helper","export":["ConditionHelper"]},{"from":"./condition-items-result-observer","export":["ConditionItemsResultObserver"]},{"from":"./condition-item-model","export":["ConditionItemModel"]},{"from":"./condition-control-result-value","export":["ConditionControlResultValue"]}]}]

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

@@ -0,0 +1,6 @@
+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

@@ -0,0 +1,8 @@
+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-state.metadata.json

@@ -0,0 +1 @@
+[{"__symbolic":"module","version":4,"metadata":{"RelationConditionResultState":{"__symbolic":"class","members":{"__ctor__":[{"__symbolic":"constructor","parameters":[{"__symbolic":"reference","module":"../../../communication/variable/variable-state","name":"VariableState","line":3,"character":39},{"__symbolic":"reference","name":"boolean"}]}]}}}}]

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

@@ -0,0 +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);
+}

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

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

package/model/shared/condition/relation-condition-result.metadata.json

@@ -0,0 +1 @@
+[{"__symbolic":"module","version":4,"metadata":{"RelationConditionResult":{"__symbolic":"class","members":{"__ctor__":[{"__symbolic":"constructor","parameters":[{"__symbolic":"reference","name":"number"},{"__symbolic":"reference","module":"./relation-type","name":"RelationType","line":4,"character":75},{"__symbolic":"reference","module":"./relation-condition-result-state","name":"RelationConditionResultState","line":4,"character":113}]}]}}}}]