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

package/elements/shared/text/text-state.model.metadata.json

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

package/elements/shared/text/text-utils.d.ts

@@ -0,0 +1,5 @@
+import { Font } from '../../../model';
+export declare class TextUtils {
+    static setText(textElement: SVGTextElement, content: string, font: Font, width: number, height: number, cursor?: string): void;
+    private static alignText;
+}

package/elements/shared/text/text-utils.js

@@ -0,0 +1,45 @@
+export class TextUtils {
+    static setText(textElement, content, font, width, height, cursor = 'hand') {
+        this.alignText(textElement, font.textAlign, width, height);
+        textElement.setAttribute('cursor', cursor);
+        textElement.setAttribute('alignment-baseline', 'central');
+        textElement.setAttribute('font-family', font.fontFamily);
+        textElement.setAttribute('font-size', font.fontSize + '');
+        textElement.setAttribute('fill', font.color);
+        if (font.isBold) {
+            textElement.setAttribute('font-weight', 'bold');
+        }
+        else {
+            textElement.removeAttribute('font-weight');
+        }
+        if (font.isItalic) {
+            textElement.setAttribute('font-style', 'italic');
+        }
+        else {
+            textElement.removeAttribute('font-style');
+        }
+        if (font.isUnderline) {
+            textElement.setAttribute('text-decoration', 'underline');
+        }
+        else {
+            textElement.removeAttribute('text-decoration');
+        }
+        textElement.textContent = content;
+    }
+    static alignText(textElement, align, width, height) {
+        switch (align) {
+            case 'right':
+                textElement.setAttribute('text-anchor', 'end');
+                textElement.setAttribute('transform', `translate(${width},${height / 2})`);
+                break;
+            case 'left':
+                textElement.setAttribute('text-anchor', 'start');
+                textElement.setAttribute('transform', `translate(0,${height / 2})`);
+                break;
+            default:
+                textElement.setAttribute('text-anchor', 'middle');
+                textElement.setAttribute('transform', `translate(${width / 2},${height / 2})`);
+                break;
+        }
+    }
+}

package/elements/shared/text/text-utils.metadata.json

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

package/elements/static-elements/hyperlink-element.d.ts

@@ -0,0 +1,14 @@
+import { PermissionChecker } from '../../service';
+import { VariableCommunicator } from '../../communication';
+import { ConditionalDynamicDisplayElement } from '../base/conditional-dynamic-display-element';
+import { GraphStore, VariableStore } from '../../config';
+import { LoggerService } from '../../logger';
+import { Injector } from '@angular/core';
+import { HyperlinkModel } from '../../model/hyperlink/hyperlink.model';
+export declare class HyperlinkElement extends ConditionalDynamicDisplayElement {
+    private readonly graphStore;
+    protected readonly model: HyperlinkModel;
+    protected readonly logger: LoggerService;
+    constructor(element: HTMLElement, injector: Injector, permissionChecker: PermissionChecker, variableCommunicator: VariableCommunicator, variableStore: VariableStore, graphStore: GraphStore, signalRAppId: string);
+    private initGraphAndText;
+}

package/elements/static-elements/hyperlink-element.js

@@ -0,0 +1,48 @@
+import { ConditionalDynamicDisplayElement } from '../base/conditional-dynamic-display-element';
+import { GraphStateElement } from '../shared/graph/graph-state-element';
+import { LOGGER_SERVICE_TOKEN } from '../../logger';
+import { TextElementModal } from '../shared/text/text-element';
+export class HyperlinkElement extends ConditionalDynamicDisplayElement {
+    constructor(element, injector, permissionChecker, variableCommunicator, variableStore, graphStore, signalRAppId) {
+        super(element, permissionChecker, variableCommunicator, variableStore, signalRAppId);
+        this.graphStore = graphStore;
+        this.logger = injector.get(LOGGER_SERVICE_TOKEN);
+        if (this.model.size) {
+            this.initGraphAndText();
+        }
+        if (this.model && this.model.linkAddress) {
+            this.rootElement.style('cursor', 'hand');
+            this.rootElement.on('mousedown', () => {
+                let linkAddress = this.model.linkAddress;
+                const reg = /^http(s)?:\/\/.+$/;
+                if (!reg.test(linkAddress)) {
+                    linkAddress = 'http://' + linkAddress;
+                }
+                window.open(linkAddress, '_system');
+            });
+        }
+    }
+    initGraphAndText() {
+        this.rootElement.selectAll('*').remove();
+        const size = this.model.size;
+        const width = size.width;
+        const height = size.height;
+        this.rootElement.append('rect').attr('id', 'StateFrame').attr('width', width).attr('height', height).attr('fill', 'transparent');
+        if (this.model.useGraph === true) {
+            const graphStateElement = new GraphStateElement(this.model.graphSetting, width, height, this.graphStore, this.logger);
+            graphStateElement.switchToState(0);
+            this.$element.prepend(graphStateElement.Element);
+        }
+        const font = {
+            isUnderline: this.model.isUnderline,
+            isBold: this.isBold(this.model.font),
+            isItalic: this.isItalic(this.model.font),
+            fontSize: this.model.fontSize,
+            fontFamily: this.fontFamily(this.model.font),
+            color: this.model.stroke,
+            textAlign: this.model.textAlign
+        };
+        const textElement = new TextElementModal(this.model.text, font, width, height);
+        this.$element.append(textElement.Element);
+    }
+}

package/elements/static-elements/hyperlink-element.metadata.json

@@ -0,0 +1 @@
+[{"__symbolic":"module","version":4,"metadata":{"HyperlinkElement":{"__symbolic":"class","extends":{"__symbolic":"reference","module":"../base/conditional-dynamic-display-element","name":"ConditionalDynamicDisplayElement","line":12,"character":38},"members":{"__ctor__":[{"__symbolic":"constructor","parameters":[{"__symbolic":"error","message":"Could not resolve type","line":17,"character":25,"context":{"typeName":"HTMLElement"}},{"__symbolic":"reference","module":"@angular/core","name":"Injector","line":17,"character":48},{"__symbolic":"reference","module":"../../service","name":"PermissionChecker","line":17,"character":77},{"__symbolic":"reference","module":"../../communication","name":"VariableCommunicator","line":18,"character":30},{"__symbolic":"reference","module":"../../config","name":"VariableStore","line":18,"character":67},{"__symbolic":"reference","module":"../../config","name":"GraphStore","line":18,"character":111},{"__symbolic":"reference","name":"string"}]}],"initGraphAndText":[{"__symbolic":"method"}]}}}}]

package/elements/static-elements/image-element.d.ts

@@ -0,0 +1,14 @@
+import { ImageStore, GraphStore, VariableStore } from '../../config';
+import { Image } from '../../model';
+import { PermissionChecker } from '../../service';
+import { VariableCommunicator } from '../../communication';
+import { ConditionalDynamicDisplayElement } from '../base/conditional-dynamic-display-element';
+import { LoggerService } from '../../logger';
+import { Injector } from '@angular/core';
+export declare class ImageElement extends ConditionalDynamicDisplayElement {
+    private readonly graphStore;
+    readonly model: Image;
+    protected readonly logger: LoggerService;
+    constructor(element: HTMLElement, injector: Injector, imageStore: ImageStore, permissionChecker: PermissionChecker, variableCommunicator: VariableCommunicator, variableStore: VariableStore, graphStore: GraphStore, signalRAppId: string);
+    private initGraph;
+}

package/elements/static-elements/image-element.js

@@ -0,0 +1,41 @@
+import { ConditionalDynamicDisplayElement } from '../base/conditional-dynamic-display-element';
+import { ImageFillType } from '../../model/image/image-fill-type';
+import { GraphStateElement } from '../shared/graph/graph-state-element';
+import { LOGGER_SERVICE_TOKEN } from '../../logger';
+export class ImageElement extends ConditionalDynamicDisplayElement {
+    constructor(element, injector, imageStore, permissionChecker, variableCommunicator, variableStore, graphStore, signalRAppId) {
+        super(element, permissionChecker, variableCommunicator, variableStore, signalRAppId);
+        this.graphStore = graphStore;
+        this.logger = injector.get(LOGGER_SERVICE_TOKEN);
+        if (!this.model.version || this.model.version < 4 || this.model.fillType !== ImageFillType.Graph) {
+            let imageSourceUrl = '';
+            if (this.model.imageId) {
+                imageSourceUrl = imageStore.getImageUrl(this.model.imageId);
+            }
+            const imageEl = this.rootElement.select('image');
+            // gojs-v1.7.11不输出image元素导致图片不显示，这里专门处理一下。
+            if (imageEl.empty()) {
+                const size = this.model.size;
+                if (size) {
+                    this.rootElement.append('image')
+                        .attr('width', size.width)
+                        .attr('height', size.height)
+                        .attr('xlink:href', imageSourceUrl)
+                        .attr('preserveAspectRatio', 'none')
+                        .attr('crossorigin', 'anonymous');
+                }
+            }
+            else {
+                imageEl.attr('xlink:href', imageSourceUrl).attr('crossorigin', 'anonymous');
+            }
+        }
+        else {
+            this.initGraph(this.model.size.width, this.model.size.height);
+        }
+    }
+    initGraph(width, height) {
+        const graphStateElement = new GraphStateElement(this.model.graphSetting, width, height, this.graphStore, this.logger);
+        graphStateElement.switchToState(0);
+        this.$element.prepend(graphStateElement.Element);
+    }
+}

package/elements/static-elements/image-element.metadata.json

@@ -0,0 +1 @@
+[{"__symbolic":"module","version":4,"metadata":{"ImageElement":{"__symbolic":"class","extends":{"__symbolic":"reference","module":"../base/conditional-dynamic-display-element","name":"ConditionalDynamicDisplayElement","line":10,"character":34},"members":{"__ctor__":[{"__symbolic":"constructor","parameters":[{"__symbolic":"error","message":"Could not resolve type","line":15,"character":25,"context":{"typeName":"HTMLElement"}},{"__symbolic":"reference","module":"@angular/core","name":"Injector","line":16,"character":18},{"__symbolic":"reference","module":"../../config","name":"ImageStore","line":17,"character":20},{"__symbolic":"reference","module":"../../service","name":"PermissionChecker","line":18,"character":27},{"__symbolic":"reference","module":"../../communication","name":"VariableCommunicator","line":19,"character":30},{"__symbolic":"reference","module":"../../config","name":"VariableStore","line":20,"character":23},{"__symbolic":"reference","module":"../../config","name":"GraphStore","line":21,"character":37},{"__symbolic":"reference","name":"string"}]}],"initGraph":[{"__symbolic":"method"}]}}}}]

package/elements/static-elements/text-element.d.ts

@@ -0,0 +1,16 @@
+import { TextModel } from '../../model';
+import { VariableCommunicator } from '../../communication';
+import { ConditionalDynamicDisplayElement } from '../base/conditional-dynamic-display-element';
+import { GraphStore, VariableStore } from '../../config';
+import { LoggerService } from '../../logger';
+import { Injector } from '@angular/core';
+import { PermissionChecker } from '../../service';
+export declare class TextElement extends ConditionalDynamicDisplayElement {
+    private readonly graphStore;
+    protected readonly model: TextModel;
+    protected readonly logger: LoggerService;
+    constructor(element: HTMLElement, injector: Injector, permissionChecker: PermissionChecker, variableCommunicator: VariableCommunicator, variableStore: VariableStore, graphStore: GraphStore, signalRAppId: string);
+    dispose(): void;
+    private handleTextValue;
+    private initGraph;
+}

package/elements/static-elements/text-element.js

@@ -0,0 +1,55 @@
+import { ConditionalDynamicDisplayElement } from '../base/conditional-dynamic-display-element';
+import { GraphStateElement } from '../shared/graph/graph-state-element';
+import { LOGGER_SERVICE_TOKEN } from '../../logger';
+import { TextElementModal } from '../shared/text/text-element';
+export class TextElement extends ConditionalDynamicDisplayElement {
+    constructor(element, injector, permissionChecker, variableCommunicator, variableStore, graphStore, signalRAppId) {
+        super(element, permissionChecker, variableCommunicator, variableStore, signalRAppId);
+        this.graphStore = graphStore;
+        this.logger = injector.get(LOGGER_SERVICE_TOKEN);
+        if (this.model.text && this.model.size) {
+            const width = this.model.size.width;
+            const height = this.model.size.height;
+            this.rootElement.selectAll('*').remove();
+            this.rootElement.append('rect').attr('width', width).attr('height', height).attr('fill', 'transparent');
+            if (this.model.useGraph === true) {
+                const graphStateElement = new GraphStateElement(this.model.graphSetting, width, height, this.graphStore, this.logger);
+                graphStateElement.switchToState(0);
+                this.$element.prepend(graphStateElement.Element);
+            }
+            const font = {
+                isUnderline: this.model.isUnderline,
+                isBold: this.isBold(this.model.font),
+                isItalic: this.isItalic(this.model.font),
+                fontSize: this.model.fontSize,
+                fontFamily: this.fontFamily(this.model.font),
+                color: this.model.stroke,
+                textAlign: this.model.textAlign
+            };
+            const textElement = new TextElementModal(this.model.text, font, width, height);
+            this.$element.append(textElement.Element);
+        }
+        else {
+            this.handleTextValue();
+            if (this.model.size && this.model.useGraph) {
+                this.initGraph(this.model.size.width, this.model.size.height);
+            }
+        }
+    }
+    dispose() {
+        if (this.$element) {
+            this.$element.remove();
+        }
+    }
+    handleTextValue() {
+        const allText = this.$element.find('text');
+        for (let i = 0; i < allText.length; i++) {
+            allText[i].style.whiteSpace = 'pre';
+        }
+    }
+    initGraph(width, height) {
+        const graphStateElement = new GraphStateElement(this.model.graphSetting, width, height, this.graphStore, this.logger);
+        graphStateElement.switchToState(0);
+        this.$element.prepend(graphStateElement.Element);
+    }
+}

package/elements/static-elements/text-element.metadata.json

@@ -0,0 +1 @@
+[{"__symbolic":"module","version":4,"metadata":{"TextElement":{"__symbolic":"class","extends":{"__symbolic":"reference","module":"../base/conditional-dynamic-display-element","name":"ConditionalDynamicDisplayElement","line":10,"character":33},"members":{"__ctor__":[{"__symbolic":"constructor","parameters":[{"__symbolic":"error","message":"Could not resolve type","line":15,"character":25,"context":{"typeName":"HTMLElement"}},{"__symbolic":"reference","module":"@angular/core","name":"Injector","line":15,"character":48},{"__symbolic":"reference","module":"../../service","name":"PermissionChecker","line":15,"character":77},{"__symbolic":"reference","module":"../../communication","name":"VariableCommunicator","line":16,"character":30},{"__symbolic":"reference","module":"../../config","name":"VariableStore","line":16,"character":67},{"__symbolic":"reference","module":"../../config","name":"GraphStore","line":16,"character":111},{"__symbolic":"reference","name":"string"}]}],"dispose":[{"__symbolic":"method"}],"handleTextValue":[{"__symbolic":"method"}],"initGraph":[{"__symbolic":"method"}]}}}}]

package/elements/switch-indicator-light/bit-indicator-light-operator.d.ts

@@ -0,0 +1,20 @@
+import { EventEmitter } from '@angular/core';
+import { BitIndicatorLightSettings, SwitchIndicatorState } from '../../model';
+import { VariableCommunicator } from '../../communication';
+import { IndicatorLightOperator } from './indicator-light-operator';
+import { CurrentStateIdValue } from './current-stateId-value';
+import { VariableStore } from '../../config';
+export declare class BitIndicatorLightOperator implements IndicatorLightOperator {
+    private readonly settings;
+    private readonly variableCommunicator;
+    private readonly variableStore;
+    private binary;
+    currentStateId?: number;
+    currentStateIdChanged: EventEmitter<CurrentStateIdValue>;
+    private offStateId?;
+    private onStateId?;
+    get variableName(): string;
+    constructor(settings: BitIndicatorLightSettings, states: SwitchIndicatorState[], variableCommunicator: VariableCommunicator, variableStore: VariableStore);
+    requestData(appId: string): void;
+    private requestCurrentSateIdValue;
+}

package/elements/switch-indicator-light/bit-indicator-light-operator.js

@@ -0,0 +1,78 @@
+import { EventEmitter } from '@angular/core';
+import { each } from 'lodash';
+import { BitConditonLogic } from '../../model';
+import { VariableStateEnum, VariableValue, VariableState } from '../../communication';
+import { CurrentStateIdValue } from './current-stateId-value';
+import { Binary } from '../../model/shared/binary';
+import { VariableUtil } from '../../utils/variable-util';
+import { VariableDefinition } from '../../communication/variable/variable-definition';
+export class BitIndicatorLightOperator {
+    constructor(settings, states, variableCommunicator, variableStore) {
+        this.settings = settings;
+        this.variableCommunicator = variableCommunicator;
+        this.variableStore = variableStore;
+        this.currentStateIdChanged = new EventEmitter();
+        if (!this.settings) {
+            throw new Error('settings cannot be null');
+        }
+        each(states, state => {
+            const condition = state.condition;
+            if (!condition) {
+                throw new Error('Invalid bit condition.');
+            }
+            switch (+condition.logic) {
+                case BitConditonLogic.Off:
+                    if (this.offStateId) {
+                        throw new Error('Dumplicate off state.');
+                    }
+                    this.offStateId = state.id;
+                    break;
+                case BitConditonLogic.On:
+                    if (this.onStateId) {
+                        throw new Error('Dumplicate on state.');
+                    }
+                    this.onStateId = state.id;
+                    break;
+                default:
+                    throw new Error(`Unknown BitConditonLogic:${condition.logic}`);
+            }
+        });
+    }
+    get variableName() {
+        const variableName = new VariableDefinition(this.settings.variableName, this.settings.variableGroupName, this.settings.dataSourceCode, this.settings.variableVersion);
+        return VariableUtil.getConvertedVariableName(this.variableStore, variableName);
+    }
+    requestData(appId) {
+        if (this.variableName) {
+            this.variableCommunicator.subscribeVariableState(this.variableName).subscribe(variableStete => {
+                if (variableStete.state === VariableStateEnum.Normal) {
+                    this.requestCurrentSateIdValue(this.variableCommunicator, appId);
+                }
+                else {
+                    this.currentStateIdChanged.emit(new CurrentStateIdValue(new VariableState(this.variableName, variableStete.state)));
+                }
+            });
+        }
+    }
+    requestCurrentSateIdValue(variableCommunicator, appId = '') {
+        variableCommunicator.openVariable(this.variableName, appId).subscribe(value => {
+            if (value.state === VariableStateEnum.DataNormal) {
+                if (this.settings.isBitwiseIndex) {
+                    const maxBitIndex = 31;
+                    this.binary = new Binary(value.value, maxBitIndex + 1);
+                    const newValue = new VariableValue(value.variableName, value.state, Number(this.binary.convertToBinary().substr(maxBitIndex - this.settings.bitIndex, 1)));
+                    this.currentStateId = !newValue.value ? this.offStateId : this.onStateId;
+                    this.currentStateIdChanged.emit(new CurrentStateIdValue(new VariableState(this.variableName, value.state), this.currentStateId));
+                }
+                else {
+                    this.currentStateId = !value.value ? this.offStateId : this.onStateId;
+                    this.currentStateIdChanged.emit(new CurrentStateIdValue(new VariableState(this.variableName, value.state), this.currentStateId));
+                }
+            }
+            else {
+                delete this.currentStateId;
+                this.currentStateIdChanged.emit(new CurrentStateIdValue(new VariableState(this.variableName, value.state)));
+            }
+        });
+    }
+}

package/elements/switch-indicator-light/bit-indicator-light-operator.metadata.json

@@ -0,0 +1 @@
+[{"__symbolic":"module","version":4,"metadata":{"BitIndicatorLightOperator":{"__symbolic":"class","members":{"__ctor__":[{"__symbolic":"constructor","parameters":[{"__symbolic":"reference","module":"../../model","name":"BitIndicatorLightSettings","line":26,"character":43},{"__symbolic":"reference","name":"Array","arguments":[{"__symbolic":"reference","module":"../../model","name":"SwitchIndicatorState","line":27,"character":16}]},{"__symbolic":"reference","module":"../../communication","name":"VariableCommunicator","line":28,"character":47},{"__symbolic":"reference","module":"../../config","name":"VariableStore","line":29,"character":40}]}],"requestData":[{"__symbolic":"method"}],"requestCurrentSateIdValue":[{"__symbolic":"method"}]}}}}]

package/elements/switch-indicator-light/bit-switch-operator.d.ts

@@ -0,0 +1,19 @@
+import { BitSwitchSettings } from '../../model';
+import { VariableCommunicator } from '../../communication';
+import { SwitchOperator } from './switch-operator';
+import { VariableOptionModel } from '../../service';
+import { VariableStore } from '../../config';
+export declare class BitSwitchOperator implements SwitchOperator {
+    private readonly settings;
+    private readonly variableCommunicator;
+    private readonly variableStore;
+    private readonly signalRAppId;
+    private currentValue;
+    private canExecuteInternal;
+    private binary;
+    get variableName(): string;
+    constructor(settings: BitSwitchSettings, variableCommunicator: VariableCommunicator, variableStore: VariableStore, signalRAppId: string);
+    canExecute(): boolean;
+    execute(): Promise<VariableOptionModel>;
+    writeValue(value: any): Promise<VariableOptionModel>;
+}

package/elements/switch-indicator-light/bit-switch-operator.js

@@ -0,0 +1,107 @@
+import { BitSwitchOperation } from '../../model';
+import { VariableStateEnum } from '../../communication';
+import { Binary } from '../../model/shared/binary';
+import { VariableUtil } from '../../utils/variable-util';
+import { VariableDefinition } from '../../communication/variable/variable-definition';
+export class BitSwitchOperator {
+    constructor(settings, variableCommunicator, variableStore, signalRAppId) {
+        this.settings = settings;
+        this.variableCommunicator = variableCommunicator;
+        this.variableStore = variableStore;
+        this.signalRAppId = signalRAppId;
+        if (!this.settings) {
+            throw new Error('settings cannot be null');
+        }
+        if (this.settings.isWriteOnly) {
+            this.canExecuteInternal = true;
+        }
+        else {
+            variableCommunicator.openVariable(this.variableName, this.signalRAppId).subscribe(value => {
+                this.currentValue = value;
+                this.canExecuteInternal = this.currentValue && this.currentValue.state === VariableStateEnum.DataNormal;
+            });
+        }
+    }
+    get variableName() {
+        const variable = new VariableDefinition(this.settings.variableName, this.settings.variableGroupName, this.settings.dataSourceCode, this.settings.variableVersion);
+        return VariableUtil.getConvertedVariableName(this.variableStore, variable);
+    }
+    canExecute() {
+        return this.canExecuteInternal;
+    }
+    execute() {
+        if (!this.canExecute()) {
+            throw new Error('Can not execute.');
+        }
+        const settings = this.settings;
+        let newValue;
+        let maxBitIndex;
+        if (settings.isBitwiseIndex) {
+            maxBitIndex = 31;
+            this.binary = new Binary(this.currentValue.value, maxBitIndex + 1);
+        }
+        switch (+settings.operation) {
+            case BitSwitchOperation.On:
+                newValue = 1;
+                if (settings.isBitwiseIndex) {
+                    this.variableCommunicator.writeWordByBit(this.variableName, settings.bitIndex, newValue).subscribe();
+                }
+                else {
+                    this.variableCommunicator.write(this.variableName, newValue).subscribe();
+                }
+                break;
+            case BitSwitchOperation.Off:
+                newValue = 0;
+                if (settings.isBitwiseIndex) {
+                    this.variableCommunicator.writeWordByBit(this.variableName, settings.bitIndex, newValue).subscribe();
+                }
+                else {
+                    this.variableCommunicator.write(this.variableName, newValue).subscribe();
+                }
+                break;
+            case BitSwitchOperation.Inverse:
+                if (!this.settings.isWriteOnly) {
+                    newValue = this.currentValue.value === 0 ? 1 : 0;
+                    if (settings.isBitwiseIndex) {
+                        let wordByBitValue = Number(this.binary.convertToBinary().substr(maxBitIndex - this.settings.bitIndex, 1));
+                        wordByBitValue = wordByBitValue === 0 ? 1 : 0;
+                        this.variableCommunicator.writeWordByBit(this.variableName, settings.bitIndex, wordByBitValue).subscribe();
+                    }
+                    else {
+                        this.variableCommunicator.write(this.variableName, newValue).subscribe();
+                    }
+                }
+                break;
+            case BitSwitchOperation.Restoration:
+                break;
+            default:
+                throw new Error(`Unknown BitSwitchOperation:${settings.operation}`);
+        }
+        let originValue;
+        if (this.currentValue && this.currentValue.value !== undefined) {
+            originValue = this.currentValue.value;
+        }
+        return Promise.resolve({
+            variableName: this.variableName,
+            originValue: originValue,
+            newValue: newValue
+        });
+    }
+    writeValue(value) {
+        if (this.settings.isBitwiseIndex) {
+            this.variableCommunicator.writeWordByBit(this.variableName, this.settings.bitIndex, value).subscribe();
+        }
+        else {
+            this.variableCommunicator.write(this.variableName, value).subscribe();
+        }
+        let originValue;
+        if (this.currentValue && this.currentValue.value !== undefined) {
+            originValue = this.currentValue.value;
+        }
+        return Promise.resolve({
+            variableName: this.variableName,
+            originValue: originValue,
+            newValue: value
+        });
+    }
+}

package/elements/switch-indicator-light/bit-switch-operator.metadata.json

@@ -0,0 +1 @@
+[{"__symbolic":"module","version":4,"metadata":{"BitSwitchOperator":{"__symbolic":"class","members":{"__ctor__":[{"__symbolic":"constructor","parameters":[{"__symbolic":"reference","module":"../../model","name":"BitSwitchSettings","line":21,"character":43},{"__symbolic":"reference","module":"../../communication","name":"VariableCommunicator","line":21,"character":101},{"__symbolic":"reference","module":"../../config","name":"VariableStore","line":22,"character":40},{"__symbolic":"reference","name":"string"}]}],"canExecute":[{"__symbolic":"method"}],"execute":[{"__symbolic":"method"}],"writeValue":[{"__symbolic":"method"}]}}}}]

package/elements/switch-indicator-light/current-stateId-value.d.ts

@@ -0,0 +1,6 @@
+import { VariableState } from '../../communication';
+export declare class CurrentStateIdValue {
+    readonly state: VariableState;
+    readonly value?: any;
+    constructor(state: VariableState, value?: any);
+}

package/elements/switch-indicator-light/current-stateId-value.js

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

package/elements/switch-indicator-light/current-stateId-value.metadata.json

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

package/elements/switch-indicator-light/indicator-light-operator.d.ts

@@ -0,0 +1,8 @@
+import { EventEmitter } from '@angular/core';
+import { CurrentStateIdValue } from './current-stateId-value';
+export interface IndicatorLightOperator {
+    readonly variableName: string;
+    currentStateId?: number;
+    currentStateIdChanged: EventEmitter<CurrentStateIdValue>;
+    requestData: (appId: string) => void;
+}

package/elements/switch-indicator-light/indicator-light-operator.metadata.json

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

package/elements/switch-indicator-light/switch-indicator-light-element.d.ts

@@ -0,0 +1,39 @@
+import { Injector } from '@angular/core';
+import { BsModalService } from 'ngx-bootstrap/modal';
+import { GraphStore, VariableStore } from '../../config';
+import { Localization } from '../../localization';
+import { SwitchIndicatorLight } from '../../model';
+import { PermissionChecker, OperationRecordService } from '../../service';
+import { VariableCommunicator } from '../../communication';
+import { ConditionalEnableElement } from '../base/conditional-enable-element';
+import { SecurityChecker } from '../../security';
+export declare class SwitchIndicatorLightElement extends ConditionalEnableElement {
+    private readonly modalService;
+    private readonly graphStore;
+    private readonly operationRecordService;
+    private readonly securityChecker;
+    protected readonly model: SwitchIndicatorLight;
+    private readonly logger;
+    private switchOperator;
+    private indicatorLightOperator;
+    private graphStateElement?;
+    private textStateElement;
+    private isMobileMode;
+    private isBitRestoration;
+    private isVerifiedForRestoration;
+    private restorationTimer;
+    private isWriteRestorationDownValue;
+    private onDocMouseUp;
+    constructor(element: HTMLElement, injector: Injector, modalService: BsModalService, variableCommunicator: VariableCommunicator, graphStore: GraphStore, permissionChecker: PermissionChecker, operationRecordService: OperationRecordService, securityChecker: SecurityChecker, variableStore: VariableStore, localization: Localization, signalRAppId: string);
+    handleMouseUp(): void;
+    private initOnDocMouseUpEvent;
+    private checkElementPassword;
+    private doSwitchOperator;
+    private writeValue;
+    private initSwitchOperator;
+    private initIndictorLightOperator;
+    private currentStateIdChange;
+    private switchToState;
+    private initGraphAndText;
+    private checkState;
+}