@flexem/fc-gui 3.0.0-alpha.17 → 3.0.0-alpha.171

package/model/base/font-setting-model.d.ts

@@ -1,8 +1,29 @@
+export interface TextLibrarySetting {
+    readonly labelType: 'text' | 'textLibrary';
+    readonly selectedTextLibraryItem?: string | number;
+    readonly selectedTextItem?: string | number;
+}
+export interface TextCultures {
+    readonly cultures: {
+        [languageCode: string]: string;
+    };
+}
+export interface FontStyleCultures {
+    readonly [languageCode: string]: {
+        readonly fontSize: string;
+        readonly fontStyle: string;
+        readonly fontColor: string;
+        readonly isUnderline: boolean;
+        readonly textAlign: string;
+    };
+}
 export interface FontSettingModel {
-    readonly text: string;
+    readonly text: string | TextCultures;
     readonly stroke: string;
     readonly font: string;
     readonly fontSize: string;
     readonly isUnderline: boolean;
     readonly textAlign: string;
+    readonly textLibrary?: TextLibrarySetting;
+    readonly fontStyleCultures?: FontStyleCultures;
 }

package/model/base/font-setting-model.metadata.json

@@ -1 +1 @@
-[{"__symbolic":"module","version":4,"metadata":{"FontSettingModel":{"__symbolic":"interface"}}}]
+[{"__symbolic":"module","version":4,"metadata":{"TextLibrarySetting":{"__symbolic":"interface"},"TextCultures":{"__symbolic":"interface"},"FontStyleCultures":{"__symbolic":"interface"},"FontSettingModel":{"__symbolic":"interface"}}}]

package/model/base/readable-model.d.ts

@@ -7,4 +7,8 @@ export interface ReadableModel extends ConditionalEnableModel {
     readonly version?: number;
     readonly variableName?: string;
     readonly readVariable?: VariableDefinition;
+    readonly minVariable?: any;
+    readonly maxVariable?: any;
+    readonly minValueType?: any;
+    readonly maxValueType?: any;
 }

package/model/datetime-display/datetime-display.d.ts

@@ -17,4 +17,5 @@ export interface DatetimeDisplay extends ConditionalDisplayModel {
     readonly version: number;
     readonly useGraph?: boolean;
     readonly graphSetting?: GraphSetting;
+    readonly timeZone?: string;
 }

package/model/historical-curve/historical-curve-axis-settings.d.ts

@@ -1,6 +1,17 @@
 import { Font } from '../shared/text/font';
 export interface HistoricalCurveAxisSettings {
+    readonly yAxisRangeType: AxisRangeType;
+    readonly yAxisMax?: number;
+    readonly yAxisMin?: number;
     readonly axisColor: string;
     readonly showAxisLabel: boolean;
     readonly axisLabelFont: Font;
+    readonly showTick?: boolean;
+    readonly xAxisTickColor?: string;
+    readonly yAxisTickColor?: string;
+    readonly filterBackgroudColor?: string;
+}
+export declare enum AxisRangeType {
+    Auto = 0,
+    Custom = 1
 }

package/model/historical-curve/historical-curve-axis-settings.js

@@ -0,0 +1,5 @@
+export var AxisRangeType;
+(function (AxisRangeType) {
+    AxisRangeType[AxisRangeType["Auto"] = 0] = "Auto";
+    AxisRangeType[AxisRangeType["Custom"] = 1] = "Custom"; // 自定义范围
+})(AxisRangeType || (AxisRangeType = {}));

package/model/historical-curve/historical-curve-axis-settings.metadata.json

@@ -1 +1 @@
-[{"__symbolic":"module","version":4,"metadata":{"HistoricalCurveAxisSettings":{"__symbolic":"interface"}}}]
+[{"__symbolic":"module","version":4,"metadata":{"HistoricalCurveAxisSettings":{"__symbolic":"interface"},"AxisRangeType":{"Auto":0,"Custom":1}}}]

package/model/historical-curve/historical-curve-chanel.model.d.ts

@@ -7,6 +7,14 @@ export interface HistroicalCurveChannelModel {
      * 连接线颜色
      */
     readonly connectorColor: string;
+    /**
+     * 启用标记点
+     */
+    readonly enablePoint: boolean;
+    /**
+     * 标记点颜色
+     */
+    readonly pointColor: string;
     /**
      * 是否投影颜色
      */

package/model/meter/meter.d.ts

@@ -10,4 +10,8 @@ export interface Meter extends ReadableModel {
     readonly radius: number;
     readonly min: number;
     readonly max: number;
+    readonly masterDivisionNumber: number;
+    readonly subDivisionNumber: number;
+    readonly integerDigits: number;
+    readonly fractionDigits: number;
 }

package/model/numerical-display/numerical-operation.d.ts

@@ -2,8 +2,16 @@ import { NumericalOperationType } from '../../utils/numerical-operation-type';
 import { ProportionalConversion } from './proportional-conversion';
 import { Zoom } from './zoom';
 export interface NumericalOperation {
-    numericalUpperLimit: number;
-    numericalLowerLimit: number;
+    numericalUpperLimit: number | {
+        type: number;
+        variableName: string;
+        variableVersion?: number;
+    };
+    numericalLowerLimit: number | {
+        type: number;
+        variableName: string;
+        variableVersion?: number;
+    };
     enableNumericalOperation: boolean;
     type: NumericalOperationType;
     proportionalConversion: ProportionalConversion;

package/model/ring-graph/ring-graph.model.d.ts

@@ -22,4 +22,12 @@ export interface RingGraphModel extends ConditionalDisplayModel {
     readonly alarmRange?: AlarmRangeModel;
     readonly showPercentage: boolean;
     readonly percentageFont?: Font;
+    readonly minVariable?: any;
+    readonly maxVariable?: any;
+    readonly minValueType?: any;
+    readonly maxValueType?: any;
+    readonly masterDivisionNumber: number;
+    readonly subDivisionNumber: number;
+    readonly integerDigits: number;
+    readonly fractionDigits: number;
 }

package/model/scroll-alarm/scroll-alarm.model.d.ts

@@ -0,0 +1,21 @@
+import { ConditionalDynamicDisplayModel } from '../base/conditional-dynamic-display-model';
+import { Point, Size } from '../shared';
+import { DynamicDisplayModel } from '../shared/dynamic-display/dynamic-display-model';
+export interface ScrollAlarmModel extends ConditionalDynamicDisplayModel {
+    readonly version: number;
+    readonly size: Size;
+    readonly location: Point;
+    readonly generalSetting?: any;
+    readonly filterSetting?: any;
+    readonly widths: number[];
+    readonly heights: number[];
+    readonly columLabels: string[];
+    readonly levelText: string[];
+    readonly scrollSetting?: {
+        readonly scrollInterval?: number;
+        readonly scrollDirection?: 'vertical' | 'horizontal';
+        readonly pauseOnHover?: boolean;
+        readonly autoPlay?: boolean;
+    };
+    readonly dynamicSetting?: DynamicDisplayModel;
+}

package/model/scroll-alarm/scroll-alarm.model.metadata.json

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

package/model/shared/state/state.d.ts

@@ -4,5 +4,6 @@ export declare enum State {
     Unbind = 2,
     Abnormal = 3,
     Loading = 4,
+    InvalidMonitor = 5,
     Disable = 9
 }

package/model/shared/state/state.js

@@ -5,5 +5,6 @@ export var State;
     State[State["Unbind"] = 2] = "Unbind";
     State[State["Abnormal"] = 3] = "Abnormal";
     State[State["Loading"] = 4] = "Loading";
+    State[State["InvalidMonitor"] = 5] = "InvalidMonitor";
     State[State["Disable"] = 9] = "Disable";
 })(State || (State = {}));

package/model/shared/state/state.metadata.json

@@ -1 +1 @@
-[{"__symbolic":"module","version":4,"metadata":{"State":{"Normal":0,"Offline":1,"Unbind":2,"Abnormal":3,"Loading":4,"Disable":9}}}]
+[{"__symbolic":"module","version":4,"metadata":{"State":{"Normal":0,"Offline":1,"Unbind":2,"Abnormal":3,"Loading":4,"InvalidMonitor":5,"Disable":9}}}]

package/model/shared/text/font.d.ts

@@ -5,6 +5,6 @@ export interface Font {
     readonly fontSize: string;
     fontFamily?: string;
     readonly color: string;
-    readonly textAlign: string;
+    readonly textAlign?: string;
     readonly fontStyle?: string;
 }

package/model/shared/text/text.d.ts

@@ -2,4 +2,7 @@ import { Font } from './font';
 export interface Text {
     content: string;
     font: Font;
+    cultures?: {
+        [languageCode: string]: string;
+    };
 }

package/model/switch-indicator-light/switch-indicator-light.d.ts

@@ -5,6 +5,7 @@ import { ConditionalEnableModel } from '../base/conditional-enable-model';
 import { ConditionItemModel, GraphSetting, Point, Size } from '../shared';
 import { DynamicDisplayModel } from '../shared/dynamic-display/dynamic-display-model';
 import { SecurityModel } from '../base/security-model';
+import { TextLibrarySetting } from '../base/font-setting-model';
 export interface SwitchIndicatorLight extends ConditionalEnableModel, SecurityModel {
     /**
        * @type {(number)}
@@ -30,4 +31,5 @@ export interface SwitchIndicatorLight extends ConditionalEnableModel, SecurityMo
     readonly isAwaysEnable?: boolean;
     readonly enableItems?: ConditionItemModel[];
     readonly fixedPositionType?: number;
+    readonly textLibrary?: TextLibrarySetting;
 }

package/model/view-operation/view-operation-element.model.d.ts

@@ -2,12 +2,14 @@ import { Size, Text, GraphSetting } from '../shared';
 import { ConditionalEnableModel } from '../base/conditional-enable-model';
 import { SecurityModel } from '../base';
 import { ViewOperationType } from './view-operation-type';
+import { TextLibrarySetting } from '../base/font-setting-model';
 export interface ViewOperationElementModel extends ConditionalEnableModel, SecurityModel {
     /**
      * 版本 2 : 动态行为调整
      * 版本 3 ：使能控制调整
      * 版本 4 ：新增操作记录
-     * 版本 5 ：新增页面操作类型，之前类型都为“切换页面”
+     * 版本 5 ：新增页面操作类型，之前类型都为"切换页面"
+     * 版本 6 ：新增文本库支持
      */
     readonly version?: number;
     readonly viewIndex?: number;
@@ -16,4 +18,8 @@ export interface ViewOperationElementModel extends ConditionalEnableModel, Secur
     readonly useGraph: boolean;
     readonly graphSetting: GraphSetting;
     readonly operationType: ViewOperationType;
+    /**
+     * 文本库配置（版本6新增）
+     */
+    readonly textLibrary?: TextLibrarySetting;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
 	"main": "bundles/fc-gui.umd.js",
-	"version": "3.0.0-alpha.17",
+	"version": "3.0.0-alpha.171",
 	"module": "public_api.js",
 	"typings": "public_api.d.ts",
 	"license": "UNLICENSED",

package/public_api.js

@@ -8,4 +8,5 @@ export * from './localization';
 export * from './shared';
 export { GuiModule } from './gui.module';
 export * from './remote';
+export * from './service';
 export { LOGGER_SERVICE_TOKEN, ConsoleLoggerService } from './logger';

package/remote/communication/variable/remote-variable-communicator.d.ts

@@ -9,6 +9,7 @@ export declare class RemoteVariableCommunicator implements VariableCommunicator
     private appIdVariablesMap;
     private connectedSubscription;
     private variableValuesChangedSubscription;
+    private virtualDeviceStatesChangedSubscription;
     private variablesToBeOpened;
     private variablesToBeClosed;
     private variableValueCache;
@@ -17,14 +18,43 @@ export declare class RemoteVariableCommunicator implements VariableCommunicator
     private variableStateCache;
     private variableStatesToBeOpened;
     private variableStatesToBeClosed;
+    private alarmObservers;
+    private alarmChangedSubscription;
+    private systemVariableHandlers;
+    private offlineValueCache;
     constructor(remoteVariableProtocol: RemoteVariableProtocol, logger: LoggerService);
+    private doAlarmChanged;
     private doVariableValuesChanged;
+    private doVirtualDeviceStatesChanged;
     private doVariableStatesChanged;
+    /**
+     * 预填充离线变量值缓存，由 GuiContext 在组态加载时一次性调用。
+     * 若状态推送早于接口返回，变量已在 Offline 状态，则直接推送；
+     * 否则缓存等待状态事件到来时推送。
+     */
+    setOfflineValueCache(variableName: string, value: any): void;
     subscribeVariableStates(variableNames: string[]): Observable<VariableState[]>;
     subscribeVariableState(variableName: string): Observable<VariableState>;
+    requestVirtualDeviceState(): Observable<void>;
     openVariables(variableNames: string[], appId?: string): Observable<VariableValue[]>;
     openVariable(variableName: string, appId?: string): Observable<VariableValue>;
     write(variableName: string, value: any): Observable<VariableValue>;
     writeWordByBit(variableName: string, index: number, value: number): Observable<VariableValue>;
+    subscribeUserDeviceAlarms(appId?: string): Observable<any[]>;
+    subscribeUserOneDeviceAlarms(appId?: string): Observable<any>;
+    /**
+     * 注册系统变量处理器
+     * @param variableName 变量名（如"当前语种ID"）
+     * @param getValue 获取值的函数
+     * @param setValue 设置值的函数
+     */
+    registerSystemVariableHandler(variableName: string, getValue: () => Promise<any>, setValue: (value: any) => Promise<void>): void;
+    /**
+     * 通知系统变量值变化
+     * 用于在系统变量值改变时通知所有订阅者
+     * @param variableName 变量名
+     * @param value 新值
+     */
+    notifySystemVariableChange(variableName: string, value: any): void;
     dispose(): void;
 }

package/remote/communication/variable/remote-variable-communicator.js

@@ -1,7 +1,9 @@
 import { each, remove, uniq } from 'lodash';
 import { Observable } from 'rxjs';
 import { map } from 'rxjs/operators';
+import { VariableStateEnum } from '../../../communication';
 import { StringifyingMap } from '../../../core';
+import { GuiFeatureConfig } from '../../../config';
 export class RemoteVariableCommunicator {
     constructor(remoteVariableProtocol, logger) {
         this.remoteVariableProtocol = remoteVariableProtocol;
@@ -10,6 +12,11 @@ export class RemoteVariableCommunicator {
         this.appIdVariablesMap = new Map();
         this.variableStateObservers = new Map();
         this.variableStateCache = new Map();
+        this.alarmObservers = [];
+        // 系统变量处理器
+        this.systemVariableHandlers = new Map();
+        // 预加载的离线变量最新值缓存（组态加载时一次性填充，推送后即删除）
+        this.offlineValueCache = new Map();
         this.variableValueCache = new StringifyingMap(k => JSON.stringify(k));
         this.connectedSubscription = this.remoteVariableProtocol.connected.subscribe(() => {
             const variableNamesToStart = [];
@@ -23,6 +30,18 @@ export class RemoteVariableCommunicator {
         });
         this.doVariableStatesChanged();
         this.doVariableValuesChanged();
+        this.doVirtualDeviceStatesChanged();
+        this.doAlarmChanged();
+    }
+    doAlarmChanged() {
+        if (this.alarmChangedSubscription !== undefined) {
+            this.alarmChangedSubscription.unsubscribe();
+        }
+        this.alarmChangedSubscription = this.remoteVariableProtocol.virtualDeviceAlarmsChanged.subscribe((alarms) => {
+            each(this.alarmObservers, ob => {
+                ob.next(alarms);
+            });
+        });
     }
     doVariableValuesChanged() {
         if (this.variableValuesChangedSubscription !== undefined) {
@@ -42,6 +61,25 @@ export class RemoteVariableCommunicator {
                 });
             });
     }
+    doVirtualDeviceStatesChanged() {
+        if (this.virtualDeviceStatesChangedSubscription !== undefined) {
+            this.virtualDeviceStatesChangedSubscription.unsubscribe();
+        }
+        this.virtualDeviceStatesChangedSubscription =
+            this.remoteVariableProtocol.virtualDeviceStatesChanged.subscribe((deviceStates) => {
+                each(deviceStates, deviceState => {
+                    const variableName = '设备状态';
+                    this.variableValueCache.set(variableName, deviceState);
+                    const data = Object.assign(Object.assign({}, deviceState), { systemName: '设备状态' });
+                    if (this.observers.has(variableName)) {
+                        each(this.observers.get(variableName), ob => {
+                            // TODO 同一个ob监听多个变量的情况，组合成数组一次推送。
+                            ob.next([data]);
+                        });
+                    }
+                });
+            });
+    }
     doVariableStatesChanged() {
         if (this.variableStatesChangedSubscription !== undefined) {
             this.variableStatesChangedSubscription.unsubscribe();
@@ -53,13 +91,69 @@ export class RemoteVariableCommunicator {
                     this.variableStateCache.set(variableName, state);
                     if (this.variableStateObservers.has(variableName)) {
                         each(this.variableStateObservers.get(variableName), ob => {
-                            // TODO 同一个ob监听多个变量的情况，组合成数组一次推送。
                             ob.next([state]);
                         });
                     }
+                    // 离线时推送最后已知值给值订阅者
+                    if (GuiFeatureConfig.isOfflineDisplayEnabled && state.state === VariableStateEnum.Offline) {
+                        let cachedValue;
+                        // 优先用最后一次收到的值（可能是在线时推送的），覆盖所有切页/重连场景
+                        if (this.variableValueCache.has(variableName)) {
+                            cachedValue = this.variableValueCache.get(variableName).value;
+                        }
+                        else if (this.offlineValueCache.has(variableName)) {
+                            // 兜底：变量从未收到过值，用预加载的离线值
+                            cachedValue = this.offlineValueCache.get(variableName);
+                        }
+                        if (cachedValue !== null && cachedValue !== undefined) {
+                            const variableValue = {
+                                variableName,
+                                value: cachedValue,
+                                state: VariableStateEnum.Offline
+                            };
+                            this.variableValueCache.set(variableName, variableValue);
+                            if (this.observers.has(variableName)) {
+                                each(this.observers.get(variableName), ob => {
+                                    ob.next([variableValue]);
+                                });
+                            }
+                        }
+                    }
                 });
             });
     }
+    /**
+     * 预填充离线变量值缓存，由 GuiContext 在组态加载时一次性调用。
+     * 若状态推送早于接口返回，变量已在 Offline 状态，则直接推送；
+     * 否则缓存等待状态事件到来时推送。
+     */
+    setOfflineValueCache(variableName, value) {
+        if (!GuiFeatureConfig.isOfflineDisplayEnabled) {
+            return;
+        }
+        if (value === null || value === undefined) {
+            return;
+        }
+        const cachedState = this.variableStateCache.get(variableName);
+        if (cachedState && cachedState.state === VariableStateEnum.Offline) {
+            // 状态已推送过，直接补推值给订阅者
+            const variableValue = {
+                variableName,
+                value,
+                state: VariableStateEnum.Offline
+            };
+            this.variableValueCache.set(variableName, variableValue);
+            if (this.observers.has(variableName)) {
+                each(this.observers.get(variableName), ob => {
+                    ob.next([variableValue]);
+                });
+            }
+        }
+        else {
+            // 状态还未推送，先缓存，等待状态事件
+            this.offlineValueCache.set(variableName, value);
+        }
+    }
     subscribeVariableStates(variableNames) {
         return new Observable(observer => {
             let variableNamesToStart = [];
@@ -115,6 +209,9 @@ export class RemoteVariableCommunicator {
     subscribeVariableState(variableName) {
         return this.subscribeVariableStates([variableName]).pipe(map(values => values[0]));
     }
+    requestVirtualDeviceState() {
+        return this.remoteVariableProtocol.requestVirtualDeviceState();
+    }
     openVariables(variableNames, appId = '') {
         return new Observable(observer => {
             let variablesToStart = [];
@@ -140,7 +237,33 @@ export class RemoteVariableCommunicator {
                     }
                 }
             });
-            variablesToStart = uniq(variablesToStart);
+            // 过滤掉系统变量，它们不需要通过SignalR订阅
+            const normalVariables = variablesToStart.filter(v => !this.systemVariableHandlers.has(v));
+            const systemVariables = variablesToStart.filter(v => this.systemVariableHandlers.has(v));
+            // 处理系统变量的初始值
+            systemVariables.forEach(variableName => {
+                const handler = this.systemVariableHandlers.get(variableName);
+                if (handler && handler.getValue) {
+                    void handler.getValue().then(value => {
+                        const variableValue = {
+                            variableName: variableName,
+                            value: value,
+                            state: 1 // Normal state
+                        };
+                        this.variableValueCache.set(variableName, variableValue);
+                        if (this.observers.has(variableName)) {
+                            each(this.observers.get(variableName), ob => {
+                                ob.next([variableValue]);
+                            });
+                        }
+                    }).catch(error => {
+                        if (this.logger) {
+                            this.logger.error(`[RemoteVariableCommunicator] Failed to get system variable "${variableName}" value:`, error);
+                        }
+                    });
+                }
+            });
+            variablesToStart = uniq(normalVariables);
             if (variablesToStart && variablesToStart.length > 0) {
                 if (!this.variablesToBeOpened) {
                     this.variablesToBeOpened = [];
@@ -185,8 +308,24 @@ export class RemoteVariableCommunicator {
     }
     write(variableName, value) {
         if (!variableName) {
-            return;
+            return new Observable(observer => {
+                observer.complete();
+            });
         }
+        // 检查是否为系统变量
+        if (this.systemVariableHandlers.has(variableName)) {
+            const handler = this.systemVariableHandlers.get(variableName);
+            // 调用系统变量的setValue处理器
+            void handler.setValue(value).catch(error => {
+                if (this.logger) {
+                    this.logger.error('[RemoteVariableCommunicator] Failed to set system variable value:', error);
+                }
+            });
+            return new Observable(__ => {
+                /* 系统变量通过自己的机制通知变化 */
+            });
+        }
+        // 普通变量通过SignalR写入
         this.remoteVariableProtocol.writeVariable(variableName, value);
         return new Observable(__ => {
             /* do nothing right now, if want value change immediately, can use this code below:
@@ -203,11 +342,62 @@ export class RemoteVariableCommunicator {
               observer.next(new VariableValue(variable, VariableStateEnum.DataNormal, value))*/
         });
     }
+    subscribeUserDeviceAlarms(appId = '') {
+        return new Observable(observer => {
+            this.alarmObservers.push(observer);
+            this.remoteVariableProtocol.subscribeVirtualDeviceAlarms(appId);
+            return () => {
+                this.remoteVariableProtocol.unsubscribeVirtualDeviceAlarms(appId);
+            };
+        });
+    }
+    subscribeUserOneDeviceAlarms(appId = '') {
+        return new Observable(observer => {
+            const subscription = this.remoteVariableProtocol.historyAlarmChanged.subscribe(value => observer.next(value), error => observer.error(error), () => observer.complete());
+            this.remoteVariableProtocol.subscribeUserOneDeviceAlarms(appId);
+            return () => {
+                subscription.unsubscribe();
+                this.remoteVariableProtocol.unsubscribeUserOneDeviceAlarms(appId);
+            };
+        });
+    }
+    /**
+     * 注册系统变量处理器
+     * @param variableName 变量名（如"当前语种ID"）
+     * @param getValue 获取值的函数
+     * @param setValue 设置值的函数
+     */
+    registerSystemVariableHandler(variableName, getValue, setValue) {
+        this.systemVariableHandlers.set(variableName, { getValue, setValue });
+    }
+    /**
+     * 通知系统变量值变化
+     * 用于在系统变量值改变时通知所有订阅者
+     * @param variableName 变量名
+     * @param value 新值
+     */
+    notifySystemVariableChange(variableName, value) {
+        const variableValue = {
+            variableName: variableName,
+            value: value,
+            state: 1 // Normal state
+        };
+        // 更新缓存
+        this.variableValueCache.set(variableName, variableValue);
+        // 通知所有订阅者
+        if (this.observers.has(variableName)) {
+            each(this.observers.get(variableName), ob => {
+                ob.next([variableValue]);
+            });
+        }
+    }
     dispose() {
         // TODO调用所有的ob.complete()。
         this.connectedSubscription.unsubscribe();
         this.variableStatesChangedSubscription.unsubscribe();
         this.variableValuesChangedSubscription.unsubscribe();
+        this.virtualDeviceStatesChangedSubscription.unsubscribe();
+        this.alarmChangedSubscription.unsubscribe();
         if (this.logger && this.logger.isDebugEnabled()) {
             this.logger.debug('[VariableCommunicator] RemoteVariableCommunicator disposed.');
         }

package/remote/communication/variable/remote-variable-communicator.metadata.json

@@ -1 +1 @@
-[{"__symbolic":"module","version":4,"metadata":{"RemoteVariableCommunicator":{"__symbolic":"class","members":{"__ctor__":[{"__symbolic":"constructor","parameters":[{"__symbolic":"reference","module":"./remote-variable-protocol","name":"RemoteVariableProtocol","line":24,"character":57},{"__symbolic":"reference","module":"../../../logger","name":"LoggerService","line":24,"character":106}]}],"doVariableValuesChanged":[{"__symbolic":"method"}],"doVariableStatesChanged":[{"__symbolic":"method"}],"subscribeVariableStates":[{"__symbolic":"method"}],"subscribeVariableState":[{"__symbolic":"method"}],"openVariables":[{"__symbolic":"method"}],"openVariable":[{"__symbolic":"method"}],"write":[{"__symbolic":"method"}],"writeWordByBit":[{"__symbolic":"method"}],"dispose":[{"__symbolic":"method"}]}}}}]
+[{"__symbolic":"module","version":4,"metadata":{"RemoteVariableCommunicator":{"__symbolic":"class","members":{"__ctor__":[{"__symbolic":"constructor","parameters":[{"__symbolic":"reference","module":"./remote-variable-protocol","name":"RemoteVariableProtocol","line":38,"character":57},{"__symbolic":"reference","module":"../../../logger","name":"LoggerService","line":38,"character":106}]}],"doAlarmChanged":[{"__symbolic":"method"}],"doVariableValuesChanged":[{"__symbolic":"method"}],"doVirtualDeviceStatesChanged":[{"__symbolic":"method"}],"doVariableStatesChanged":[{"__symbolic":"method"}],"setOfflineValueCache":[{"__symbolic":"method"}],"subscribeVariableStates":[{"__symbolic":"method"}],"subscribeVariableState":[{"__symbolic":"method"}],"requestVirtualDeviceState":[{"__symbolic":"method"}],"openVariables":[{"__symbolic":"method"}],"openVariable":[{"__symbolic":"method"}],"write":[{"__symbolic":"method"}],"writeWordByBit":[{"__symbolic":"method"}],"subscribeUserDeviceAlarms":[{"__symbolic":"method"}],"subscribeUserOneDeviceAlarms":[{"__symbolic":"method"}],"registerSystemVariableHandler":[{"__symbolic":"method"}],"notifySystemVariableChange":[{"__symbolic":"method"}],"dispose":[{"__symbolic":"method"}]}}}}]

package/remote/communication/variable/remote-variable-protocol.d.ts

@@ -4,10 +4,18 @@ export interface RemoteVariableProtocol {
     connected: Observable<void>;
     variableStatesChanged: Observable<VariableValue[]>;
     variableValuesChanged: Observable<VariableValue[]>;
+    virtualDeviceAlarmsChanged: Observable<any>;
     tryOpenVariables(variableNames: string[], appId: string): Observable<void>;
     tryStopVariables(variableNames: string[], appId: string): Observable<void>;
     writeVariable(variableName: string, value: any): Observable<void>;
     writeVariableWordByBit(variableName: string, index: number, value: number): Observable<void>;
+    requestVirtualDeviceState(): Observable<void>;
+    virtualDeviceStatesChanged: Observable<any>;
     subscribeVariableStates(variableNames: string[]): Observable<void>;
     unsubscribeVariableStates(variableNames: string[]): Observable<void>;
+    subscribeVirtualDeviceAlarms(appId: string): any;
+    unsubscribeVirtualDeviceAlarms(appId: string): any;
+    subscribeUserOneDeviceAlarms(appId: string): any;
+    unsubscribeUserOneDeviceAlarms(appId: string): any;
+    historyAlarmChanged: Observable<any>;
 }

package/service/index.d.ts

@@ -1,4 +1,8 @@
 export { WeatherService } from './weather.service';
 export { PermissionChecker } from './permission-checker';
+export { ReleasedVariableService } from './released-variable';
 export * from './operation-record';
 export * from './video';
+export * from './text-library.service';
+export * from './language.service';
+export * from './system-text-library.service';

package/service/index.js

@@ -0,0 +1 @@
+export * from './system-text-library.service';

package/service/index.metadata.json

@@ -1 +1 @@
-[{"__symbolic":"module","version":4,"metadata":{},"exports":[{"from":"./weather.service","export":["WeatherService"]},{"from":"./permission-checker","export":["PermissionChecker"]},{"from":"./operation-record"},{"from":"./video"}]}]
+[{"__symbolic":"module","version":4,"metadata":{},"exports":[{"from":"./weather.service","export":["WeatherService"]},{"from":"./permission-checker","export":["PermissionChecker"]},{"from":"./released-variable","export":["ReleasedVariableService"]},{"from":"./operation-record"},{"from":"./video"},{"from":"./text-library.service"},{"from":"./language.service"},{"from":"./system-text-library.service"}]}]